Skip to content

Commit ecbff68

Browse files
tianbingsztianbingsz
authored
Merge pull request #1147 from tianbingsz/paddle_func_sparse
Matrix::MUL operators using and test Daoyuan's Paddle Function, SparseMatrixArg and Function Test
2 parents 90268e1 + 5b1a5c1 commit ecbff68

File tree

12 files changed

+1036
-36
lines changed

12 files changed

+1036
-36
lines changed

‎paddle/function/BufferArg.cpp‎

Lines changed: 8 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -32,14 +32,20 @@ const SparseMatrixArg& BufferArg::sparse() const {
3232
SparseMatrixArg::SparseMatrixArg(const CpuSparseMatrix& sparse, ArgType argType)
3333
: BufferArg(sparse, argType),
3434
row_(reinterpret_cast<void*>(sparse.getRows()), VALUE_TYPE_INT32),
35-
col_(reinterpret_cast<void*>(sparse.getCols()), VALUE_TYPE_INT32) {
35+
col_(reinterpret_cast<void*>(sparse.getCols()), VALUE_TYPE_INT32),
36+
nnz_(sparse.getElementCnt()),
37+
format_(static_cast<SparseDataFormat>(sparse.getFormat())),
38+
type_(static_cast<SparseDataType>(sparse.getValueType())) {
3639
bufferType_ = TENSOR_SPARSE;
3740
}
3841

3942
SparseMatrixArg::SparseMatrixArg(const GpuSparseMatrix& sparse, ArgType argType)
4043
: BufferArg(sparse, argType),
4144
row_(reinterpret_cast<void*>(sparse.getRows()), VALUE_TYPE_INT32),
42-
col_(reinterpret_cast<void*>(sparse.getCols()), VALUE_TYPE_INT32) {
45+
col_(reinterpret_cast<void*>(sparse.getCols()), VALUE_TYPE_INT32),
46+
nnz_(sparse.getElementCnt()),
47+
format_(static_cast<SparseDataFormat>(sparse.getFormat())),
48+
type_(static_cast<SparseDataType>(sparse.getValueType())) {
4349
bufferType_ = TENSOR_SPARSE;
4450
}
4551

‎paddle/function/BufferArg.h‎

Lines changed: 68 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -30,13 +30,6 @@ enum BufferType {
3030
TENSOR_SPARSE = 4
3131
};
3232

33-
enum SparseDataType {
34-
SPARSE_NO_VALUE = 0, // do not need value pointer, all values are 1
35-
SPARSE_FLOAT_VALUE = 1
36-
};
37-
38-
enum SparseDataFormat { SPARSE_CSR_FORMAT = 0, SPARSE_CSC_FORMAT = 1 };
39-
4033
class BufferArg;
4134
class SequenceArg;
4235
class SparseMatrixArg;
@@ -79,19 +72,21 @@ class BufferArg {
7972
BufferArg(ValueType valueType,
8073
const TensorShape& shape,
8174
ArgType argType = UNSPECIFIED)
82-
: buf_(nullptr),
83-
valueType_(valueType),
84-
shape_(shape),
85-
argType_(argType) {}
75+
: buf_(nullptr), valueType_(valueType), shape_(shape), argType_(argType) {
76+
bufferType_ = TENSOR_NORMAL;
77+
}
8678

8779
BufferArg(void* buf,
8880
ValueType valueType,
8981
const TensorShape& shape,
9082
ArgType argType = UNSPECIFIED)
91-
: buf_(buf), valueType_(valueType), shape_(shape), argType_(argType) {}
83+
: buf_(buf), valueType_(valueType), shape_(shape), argType_(argType) {
84+
bufferType_ = TENSOR_NORMAL;
85+
}
9286

93-
BufferArg(void* buf, ValueType valueType)
94-
: buf_(buf), valueType_(valueType) {}
87+
BufferArg(void* buf, ValueType valueType) : buf_(buf), valueType_(valueType) {
88+
bufferType_ = TENSOR_NORMAL;
89+
}
9590

9691
BufferArg(const Matrix& matrix, ArgType argType = UNSPECIFIED)
9792
: buf_(
@@ -167,8 +162,9 @@ class BufferArg {
167162
ValueType valueType() const { return valueType_; }
168163
BufferType bufferType() const { return bufferType_; }
169164
const TensorShape& shape() const { return shape_; }
170-
bool isSparse() const { return (TENSOR_SPARSE == bufferType_); }
165+
bool isSparseArg() const { return TENSOR_SPARSE == bufferType_; }
171166
bool isSequenceArg() const { return TENSOR_SEQUENCE_DATA == bufferType_; }
167+
virtual size_t numElements() const { return shape_.getElements(); }
172168

173169
const SequenceArg& sequence() const;
174170
const SparseMatrixArg& sparse() const;
@@ -179,6 +175,7 @@ class BufferArg {
179175
TensorShape shape_;
180176
BufferType bufferType_{TENSOR_UNKNOWN};
181177
ArgType argType_{UNSPECIFIED};
178+
// TODO(tianbing), add deviceType_
182179
// leading dimensions. The size is dims_.size()
183180
// Dims lds_;
184181
};
@@ -191,6 +188,7 @@ class SequenceIdArg : public BufferArg {
191188
public:
192189
SequenceIdArg(const TensorShape& shape, ArgType argType = UNSPECIFIED)
193190
: BufferArg(VALUE_TYPE_INT32, shape, argType) {
191+
bufferType_ = TENSOR_SEQUENCE_ID;
194192
CHECK_EQ(shape_.ndims(), (size_t)1);
195193
CHECK_GT(shape_[0], 1);
196194
numSeqs_ = shape_[0] - 1;
@@ -228,7 +226,9 @@ class SequenceArg : public BufferArg {
228226
SequenceArg(ValueType valueType,
229227
const TensorShape& shape,
230228
ArgType argType = UNSPECIFIED)
231-
: BufferArg(valueType, shape, argType), startPositions_(TensorShape()) {}
229+
: BufferArg(valueType, shape, argType), startPositions_(TensorShape()) {
230+
bufferType_ = TENSOR_SEQUENCE_DATA;
231+
}
232232

233233
SequenceArg(void* buf,
234234
ValueType valueType,
@@ -269,31 +269,75 @@ class SparseMatrixArg : public BufferArg {
269269
const BufferArg& row,
270270
const BufferArg& col,
271271
size_t nnz,
272-
SparseDataFormat format,
273-
SparseDataType type,
272+
SparseFormat format,
273+
SparseValueType type,
274274
ArgType argType = UNSPECIFIED)
275275
: BufferArg(buf, valueType, shape, argType),
276276
row_(row),
277277
col_(col),
278278
nnz_(nnz),
279-
format_(format),
280-
type_(type) {
279+
format_(static_cast<SparseDataFormat>(format)),
280+
type_(static_cast<SparseDataType>(type)) {
281281
bufferType_ = TENSOR_SPARSE;
282282
CHECK((valueType == VALUE_TYPE_FLOAT) || (valueType == VALUE_TYPE_DOUBLE));
283283
CHECK_EQ(shape_.ndims(), (size_t)2);
284284
CHECK_EQ(row_.shape().ndims(), (size_t)1);
285285
CHECK_EQ(col_.shape().ndims(), (size_t)1);
286-
if (format == SPARSE_CSR_FORMAT) {
286+
if (format_ == T_SPARSE_CSR) {
287287
CHECK_EQ(nnz, col.shape()[0]);
288-
} else if (format == SPARSE_CSC_FORMAT) {
288+
} else if (format_ == T_SPARSE_CSC) {
289289
CHECK_EQ(nnz, row.shape()[0]);
290290
}
291291
}
292292

293+
SparseMatrixArg(ValueType valueType,
294+
const TensorShape& shape,
295+
size_t nnz,
296+
SparseFormat format,
297+
SparseValueType type,
298+
ArgType argType = UNSPECIFIED)
299+
: BufferArg(valueType, shape, argType),
300+
row_(BufferArg(nullptr, VALUE_TYPE_INT32)),
301+
col_(BufferArg(nullptr, VALUE_TYPE_INT32)),
302+
nnz_(nnz),
303+
format_(static_cast<SparseDataFormat>(format)),
304+
type_(static_cast<SparseDataType>(type)) {
305+
bufferType_ = TENSOR_SPARSE;
306+
CHECK((valueType == VALUE_TYPE_FLOAT) || (valueType == VALUE_TYPE_DOUBLE));
307+
CHECK_EQ(shape_.ndims(), (size_t)2);
308+
309+
/// len of row_ : height + 1 (CSR) or nnz (CSC), buf_ == nullptr
310+
row_ = (format_ == T_SPARSE_CSR
311+
? BufferArg(VALUE_TYPE_INT32, TensorShape{shape_[0] + 1})
312+
: BufferArg(VALUE_TYPE_INT32, TensorShape{nnz}));
313+
/// len of col_ : width + 1 (CSC) or nnz (CSR), buf_ == nullptr
314+
col_ = (format_ == T_SPARSE_CSR
315+
? BufferArg(VALUE_TYPE_INT32, TensorShape{nnz})
316+
: BufferArg(VALUE_TYPE_INT32, TensorShape{shape_[1] + 1}));
317+
}
318+
293319
SparseMatrixArg(const CpuSparseMatrix& sparse, ArgType argType = UNSPECIFIED);
294320

295321
SparseMatrixArg(const GpuSparseMatrix& sparse, ArgType argType = UNSPECIFIED);
296322

323+
template <DeviceType DType>
324+
typename Tensor<real, DType>::SparseMatrix SparseMatrix() const {
325+
CHECK(buf_);
326+
CHECK(valueType_ == DataType<real>::value);
327+
// CHECK(deviceType_ == DType);
328+
CHECK_EQ(2, shape_.ndims());
329+
return typename Tensor<real, DType>::SparseMatrix(
330+
reinterpret_cast<real*>(buf_),
331+
reinterpret_cast<int*>(row_.data()),
332+
reinterpret_cast<int*>(col_.data()),
333+
shape_[0],
334+
shape_[1],
335+
nnz_,
336+
static_cast<SparseValueType>(type_),
337+
static_cast<SparseFormat>(format_),
338+
false);
339+
}
340+
297341
~SparseMatrixArg() {}
298342

299343
void* getRowBuf() const { return row_.data(); }
@@ -302,6 +346,8 @@ class SparseMatrixArg : public BufferArg {
302346

303347
size_t nnz() const { return nnz_; }
304348

349+
size_t numElements() const override { return nnz_; }
350+
305351
SparseDataFormat dataFormat() const { return format_; }
306352

307353
SparseDataType dataType() const { return type_; }

‎paddle/function/CMakeLists.txt‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,7 @@ if(WITH_TESTING)
2626
add_simple_unittest(FunctionTest)
2727
add_simple_unittest(ContextProjectionOpTest)
2828
add_simple_unittest(PadOpTest)
29+
add_simple_unittest(MulOpTest)
2930
endif()
3031
endif()
3132

‎paddle/function/FunctionTest.h‎

Lines changed: 89 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,8 @@ See the License for the specific language governing permissions and
1313
limitations under the License. */
1414

1515
#include "Function.h"
16-
#include "paddle/math/Vector.h"
16+
#include "paddle/math/Matrix.h"
17+
#include "paddle/math/SparseMatrix.h"
1718
#include "paddle/math/tests/TensorCheck.h"
1819
#include "paddle/testing/TestUtil.h"
1920

@@ -69,7 +70,7 @@ class FunctionCompare {
6970
}
7071

7172
// output need only contains shape, do not contains data.
72-
void addOutputs(const BufferArg& output) {
73+
void addOutputs(const BufferArg& output, ArgType argType = ASSIGN_TO) {
7374
size_t size =
7475
output.shape().getElements() * sizeOfValuType(output.valueType());
7576
cpuMemory_.emplace_back(std::make_shared<CpuMemoryHandle>(size));
@@ -79,12 +80,40 @@ class FunctionCompare {
7980
std::make_shared<BufferArg>(cpuMemory_.back()->getBuf(),
8081
output.valueType(),
8182
output.shape(),
82-
ASSIGN_TO));
83+
argType));
8384
gpuOutputs_.emplace_back(
8485
std::make_shared<BufferArg>(gpuMemory_.back()->getBuf(),
8586
output.valueType(),
8687
output.shape(),
87-
ASSIGN_TO));
88+
argType));
89+
}
90+
91+
/// add and init output sparse matrix
92+
void addOutputs(const SparseMatrixArg& output, ArgType argType = ASSIGN_TO) {
93+
cpuSparse_ = std::make_shared<CpuSparseMatrix>(
94+
output.shape()[0],
95+
output.shape()[1],
96+
output.nnz(),
97+
static_cast<SparseValueType>(output.dataType()),
98+
static_cast<SparseFormat>(output.dataFormat()));
99+
100+
gpuSparse_ = std::make_shared<GpuSparseMatrix>(
101+
output.shape()[0],
102+
output.shape()[1],
103+
output.nnz(),
104+
static_cast<SparseValueType>(output.dataType()),
105+
static_cast<SparseFormat>(output.dataFormat()));
106+
107+
/// init sparse matrix
108+
hl_stream_t stream(HPPL_STREAM_1);
109+
cpuSparse_->randomizeUniform();
110+
gpuSparse_->copyFrom(*cpuSparse_, stream);
111+
hl_stream_synchronize(stream);
112+
113+
cpuOutputs_.emplace_back(
114+
std::make_shared<SparseMatrixArg>(*cpuSparse_, argType));
115+
gpuOutputs_.emplace_back(
116+
std::make_shared<SparseMatrixArg>(*gpuSparse_, argType));
88117
}
89118

90119
void addInputs(const SequenceArg& input) {
@@ -107,10 +136,36 @@ class FunctionCompare {
107136
// TODO: need be implemented.
108137
}
109138

139+
void addInputs(const SparseMatrixArg& input) {
140+
cpuSparse_ = std::make_shared<CpuSparseMatrix>(
141+
input.shape()[0],
142+
input.shape()[1],
143+
input.nnz(),
144+
static_cast<SparseValueType>(input.dataType()),
145+
static_cast<SparseFormat>(input.dataFormat()));
146+
147+
gpuSparse_ = std::make_shared<GpuSparseMatrix>(
148+
input.shape()[0],
149+
input.shape()[1],
150+
input.nnz(),
151+
static_cast<SparseValueType>(input.dataType()),
152+
static_cast<SparseFormat>(input.dataFormat()));
153+
154+
/// init sparse matrix
155+
hl_stream_t stream(HPPL_STREAM_1);
156+
cpuSparse_->randomizeUniform();
157+
gpuSparse_->copyFrom(*cpuSparse_, stream);
158+
hl_stream_synchronize(stream);
159+
160+
cpuInputs_.emplace_back(std::make_shared<SparseMatrixArg>(*cpuSparse_));
161+
gpuInputs_.emplace_back(std::make_shared<SparseMatrixArg>(*gpuSparse_));
162+
}
163+
110164
void run() {
111165
// prepare cpu/gpu arguments
112166
initInputs();
113167

168+
initOutputs();
114169
// function calculate
115170
auto callFunction = [](FunctionBase* function,
116171
std::vector<BufferArgPtr>& inputs,
@@ -129,7 +184,7 @@ class FunctionCompare {
129184
callFunction(cpuFunc_.get(), cpuInputs_, cpuOutputs_);
130185
callFunction(gpuFunc_.get(), gpuInputs_, gpuOutputs_);
131186

132-
// check outputs and inouts
187+
// check outputs
133188
compareOutputs();
134189
}
135190

@@ -140,6 +195,10 @@ class FunctionCompare {
140195
protected:
141196
void initInputs() {
142197
for (size_t i = 0; i < cpuInputs_.size(); i++) {
198+
if (cpuInputs_[i]->isSparseArg()) {
199+
continue; /// sparse matrix already init
200+
}
201+
143202
initArg(*cpuInputs_[i]);
144203

145204
// TODO: Need a BufferCopy used to copy from one BufferArg to another.
@@ -152,14 +211,32 @@ class FunctionCompare {
152211
}
153212
}
154213

214+
void initOutputs() {
215+
for (size_t i = 0; i < cpuOutputs_.size(); i++) {
216+
if (cpuOutputs_[i]->isSparseArg()) {
217+
continue; /// sparse matrix already init
218+
}
219+
220+
initArg(*cpuOutputs_[i]);
221+
222+
// TODO: Need a BufferCopy used to copy from one BufferArg to another.
223+
CpuVector cpuVector(cpuOutputs_[i]->shape().getElements(),
224+
(real*)cpuOutputs_[i]->data());
225+
GpuVector gpuVector(gpuOutputs_[i]->shape().getElements(),
226+
(real*)gpuOutputs_[i]->data());
227+
228+
gpuVector.copyFrom(cpuVector);
229+
}
230+
}
231+
155232
void compareOutputs() {
156233
for (size_t i = 0; i < cpuOutputs_.size(); i++) {
157234
// TODO, Need a BufferCheck used to compare the two buffers.
158-
auto cpu = cpuOutputs_[i];
159-
auto gpu = gpuOutputs_[i];
160-
CpuVector cpuVector(cpu->shape().getElements(), (real*)cpu->data());
161-
GpuVector gpuVector(cpu->shape().getElements(), (real*)gpu->data());
162-
235+
const auto cpu = cpuOutputs_[i];
236+
const auto gpu = gpuOutputs_[i];
237+
CHECK_EQ(cpu->numElements(), gpu->numElements());
238+
CpuVector cpuVector(cpu->numElements(), (real*)cpu->data());
239+
GpuVector gpuVector(gpu->numElements(), (real*)gpu->data());
163240
autotest::TensorCheckErr(cpuVector, gpuVector);
164241
}
165242
}
@@ -195,6 +272,8 @@ class FunctionCompare {
195272
std::vector<BufferArgPtr> cpuOutputs_;
196273
std::vector<BufferArgPtr> gpuInputs_;
197274
std::vector<BufferArgPtr> gpuOutputs_;
275+
std::shared_ptr<CpuSparseMatrix> cpuSparse_;
276+
std::shared_ptr<GpuSparseMatrix> gpuSparse_;
198277
};
199278

200279
} // namespace paddle

0 commit comments

Comments
 (0)