Skip to content

P
Paddle

BaiXuePrincess / Paddle
与 Fork 源项目一致

Fork自 PaddlePaddle / Paddle

通知 1
Star 1
Fork 0
P
Paddle
提交 85e0cd70 编写于 作者: H hedaoyuan
浏览文件
操作

move some BaseMatrix test from test_matrixCompare.cpp to test_BaseMatrix.cpp

上级 ff7b4284
隐藏空白更改
内联 并排
Showing with 300 addition and 367 deletion
paddle/math/tests/TensorCheck.h
浏览文件 @ 85e0cd70
...@@ -21,60 +21,29 @@ using namespace std; // NOLINT ...@@ -21,60 +21,29 @@ using namespace std; // NOLINT
namespace autotest { namespace autotest {
class CheckEqual { class AssertEqual {
public: public:
inline int operator()(real a, real b) { AssertEqual(real err = 0) : err_(err) {}
if (a != b) {
return 1;
}
return 0;
}
};
class CheckWithErr { inline bool operator()(real a, real b) {
public: if (err_ == 0) {
CheckWithErr() { if (a != b) {
#ifndef PADDLE_TYPE_DOUBLE return false;
err_ = 1e-5; }
#else } else {
err_ = 1e-10; if (std::fabs(a - b) > err_) {
#endif if ((std::fabs(a - b) / std::fabs(a)) > (err_ / 10.0f)) {
} return false;
}
inline int operator()(real a, real b) {
if (std::fabs(a - b) > err_) {
if ((std::fabs(a - b) / std::fabs(a)) > (err_ / 10.0f)) {
return 1;
} }
} }
return 0; return true;
} }
private: private:
real err_; real err_;
}; };
template<typename Check>
void TensorCheck(Check op, const CpuMatrix& matrix1, const CpuMatrix& matrix2) {
CHECK(matrix1.getHeight() == matrix2.getHeight());
CHECK(matrix1.getWidth() == matrix2.getWidth());
int height = matrix1.getHeight();
int width = matrix1.getWidth();
const real* data1 = matrix1.getData();
const real* data2 = matrix2.getData();
int count = 0;
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
real a = data1[i * width + j];
real b = data2[i * width + j];
count += op(a, b);
}
}
EXPECT_EQ(count, 0) << "There are " << count << " different element.";
}
template <typename Tensor> template <typename Tensor>
class CopyToCpu; class CopyToCpu;
...@@ -101,10 +70,36 @@ private: ...@@ -101,10 +70,36 @@ private:
CpuMatrix arg_; CpuMatrix arg_;
}; };
template<typename Tensor1, typename Tensor2> template<typename AssertEq>
extern void TensorCheckErr(const Tensor1& tensor1, const Tensor2& tensor2) { void TensorCheck(AssertEq compare,
const CpuMatrix& matrix1,
const CpuMatrix& matrix2) {
CHECK(matrix1.getHeight() == matrix2.getHeight());
CHECK(matrix1.getWidth() == matrix2.getWidth());
int height = matrix1.getHeight();
int width = matrix1.getWidth();
const real* data1 = matrix1.getData();
const real* data2 = matrix2.getData();
int count = 0;
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
real a = data1[i * width + j];
real b = data2[i * width + j];
if (!compare(a, b)) {
count++;
}
}
}
EXPECT_EQ(count, 0) << "There are " << count << " different element.";
}
template<typename AssertEq, typename Tensor1, typename Tensor2>
extern void TensorCheck(AssertEq compare,
const Tensor1& tensor1,
const Tensor2& tensor2) {
TensorCheck( TensorCheck(
CheckWithErr(), compare,
CopyToCpu<Tensor1>(tensor1).copiedArg(), CopyToCpu<Tensor1>(tensor1).copiedArg(),
CopyToCpu<Tensor2>(tensor2).copiedArg()); CopyToCpu<Tensor2>(tensor2).copiedArg());
} }
......
paddle/math/tests/TestUtils.h
浏览文件 @ 85e0cd70
...@@ -107,12 +107,16 @@ R call(C& obj, R (FC::*f)(FArgs...), Args&&... args) { ...@@ -107,12 +107,16 @@ R call(C& obj, R (FC::*f)(FArgs...), Args&&... args) {
return (obj.*f)(args...); return (obj.*f)(args...);
} }
template <std::size_t... I, typename C, typename R, typename ...Args> template <bool ApplyRow, bool ApplyCol,
void BaseMatrixCompare(R (C::*f)(Args...)) { std::size_t... I, typename C, typename R, typename ...Args,
typename AssertEq>
void BaseMatrixCompare(R (C::*f)(Args...), AssertEq compare) {
for (auto height : {1, 11, 73, 128, 200, 330}) { for (auto height : {1, 11, 73, 128, 200, 330}) {
for (auto width : {1, 3, 32, 100, 512, 1000, 3210}) { for (auto width : {1, 3, 32, 100, 512, 1000}) {
CpuMatrix obj1(height, width); CpuMatrix obj1(ApplyCol ? 1 : height,
GpuMatrix obj2(height, width); ApplyRow ? 1 : width);
GpuMatrix obj2(ApplyCol ? 1 : height,
ApplyRow ? 1 : width);
init(obj1); init(obj1);
copy(obj2, obj1); copy(obj2, obj1);
...@@ -132,7 +136,7 @@ void BaseMatrixCompare(R (C::*f)(Args...)) { ...@@ -132,7 +136,7 @@ void BaseMatrixCompare(R (C::*f)(Args...)) {
call(obj1, f, std::get<I>(tuple1)...); call(obj1, f, std::get<I>(tuple1)...);
call(obj2, f, std::get<I>(tuple2)...); call(obj2, f, std::get<I>(tuple2)...);
TensorCheckErr(obj1, obj2); TensorCheck(compare, obj1, obj2);
} }
} }
} }
...@@ -144,6 +148,39 @@ void BaseMatrixCompare(R (C::*f)(Args...)) { ...@@ -144,6 +148,39 @@ void BaseMatrixCompare(R (C::*f)(Args...)) {
static_assert(sizeof...(I) == sizeof...(Args), static_assert(sizeof...(I) == sizeof...(Args),
"size of parameter packs are not equal"); "size of parameter packs are not equal");
autotest::BaseMatrixCompare<I...>(f); #ifndef PADDLE_TYPE_DOUBLE
autotest::AssertEqual compare(1e-5);
#else
autotest::AssertEqual compare(1e-10);
#endif
autotest::BaseMatrixCompare<false, false, I...>(f, compare);
}
template <std::size_t... I, typename C, typename R, typename ...Args>
void BaseMatrixApplyRow(R (C::*f)(Args...)) {
static_assert(sizeof...(I) == sizeof...(Args),
"size of parameter packs are not equal");
#ifndef PADDLE_TYPE_DOUBLE
autotest::AssertEqual compare(1e-3);
#else
autotest::AssertEqual compare(1e-8);
#endif
autotest::BaseMatrixCompare<true, false, I...>(f, compare);
}
template <std::size_t... I, typename C, typename R, typename ...Args>
void BaseMatrixApplyCol(R (C::*f)(Args...)) {
static_assert(sizeof...(I) == sizeof...(Args),
"size of parameter packs are not equal");
#ifndef PADDLE_TYPE_DOUBLE
autotest::AssertEqual compare(1e-3);
#else
autotest::AssertEqual compare(1e-8);
#endif
autotest::BaseMatrixCompare<false, true, I...>(f, compare);
} }
paddle/math/tests/test_BaseMatrix.cpp
浏览文件 @ 85e0cd70
...@@ -26,25 +26,224 @@ limitations under the License. */ ...@@ -26,25 +26,224 @@ limitations under the License. */
using namespace paddle; // NOLINT using namespace paddle; // NOLINT
using namespace std; // NOLINT using namespace std; // NOLINT
TEST(BaseMatrix, apply) { /**
// member function with no argument * Test member functions which prototype is
BaseMatrixCompare(&BaseMatrix::neg); * void (BaseMatrix::*)().
*/
TEST(BaseMatrix, void) {
typedef void (BaseMatrix::*FunctionProto)();
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXCOMPARE(neg);
BASEMATRIXCOMPARE(exp);
BASEMATRIXCOMPARE(log);
BASEMATRIXCOMPARE(sqrt);
BASEMATRIXCOMPARE(square);
BASEMATRIXCOMPARE(reciprocal);
BASEMATRIXCOMPARE(abs);
BASEMATRIXCOMPARE(sign);
BASEMATRIXCOMPARE(zero);
BASEMATRIXCOMPARE(one);
#undef BASEMATRIXCOMPARE
}
/**
* Test member functions which prototype is
* void (BaseMatrix::*)(real).
*/
TEST(BaseMatrix, real) {
typedef void (BaseMatrix::*FunctionProto)(real);
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare<0>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXCOMPARE(pow);
BASEMATRIXCOMPARE(subScalar);
BASEMATRIXCOMPARE(mulScalar);
BASEMATRIXCOMPARE(divScalar);
BASEMATRIXCOMPARE(assign);
BASEMATRIXCOMPARE(add);
BASEMATRIXCOMPARE(biggerThanScalar);
BASEMATRIXCOMPARE(downClip);
#undef BASEMATRIXCOMPARE
}
/**
* Test member functions which prototype is
* void (BaseMatrix::*)(real, real).
*/
TEST(BaseMatrix, real_real) {
typedef void (BaseMatrix::*FunctionProto)(real, real);
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare<0, 1>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXCOMPARE(add);
BASEMATRIXCOMPARE(clip);
#undef BASEMATRIXCOMPARE
}
/**
* Test member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&).
*/
TEST(BaseMatrix, BaseMatrix) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&);
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare<0>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXCOMPARE(assign);
BASEMATRIXCOMPARE(add);
BASEMATRIXCOMPARE(relu);
BASEMATRIXCOMPARE(reluDerivative);
BASEMATRIXCOMPARE(softrelu);
BASEMATRIXCOMPARE(softreluDerivative);
BASEMATRIXCOMPARE(brelu);
BASEMATRIXCOMPARE(breluDerivative);
BASEMATRIXCOMPARE(square);
BASEMATRIXCOMPARE(squareDerivative);
BASEMATRIXCOMPARE(tanh);
BASEMATRIXCOMPARE(tanhDerivative);
BASEMATRIXCOMPARE(reciprocal);
BASEMATRIXCOMPARE(reciprocalDerivative);
BASEMATRIXCOMPARE(abs);
BASEMATRIXCOMPARE(absDerivative);
BASEMATRIXCOMPARE(sigmoid);
BASEMATRIXCOMPARE(sigmoidDerivative);
BASEMATRIXCOMPARE(expDerivative);
BASEMATRIXCOMPARE(sign);
BASEMATRIXCOMPARE(exp);
BASEMATRIXCOMPARE(log);
BASEMATRIXCOMPARE(sqrt);
BASEMATRIXCOMPARE(dotMul);
BASEMATRIXCOMPARE(dotMulSquare);
BASEMATRIXCOMPARE(dotSquareMul);
BASEMATRIXCOMPARE(addColVector);
BASEMATRIXCOMPARE(addRowVector);
BASEMATRIXCOMPARE(mulRowVector);
BASEMATRIXCOMPARE(divRowVector);
BASEMATRIXCOMPARE(addP2P);
BASEMATRIXCOMPARE(invSqrt);
#undef BASEMATRIXCOMPARE
}
/**
* Test member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&, real).
*/
TEST(BaseMatrix, BaseMatrix_real) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&, real);
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare<0, 1>(static_cast<FunctionProto>(&BaseMatrix::function));
// If the member function are overloaded, use static_cast to specify which BASEMATRIXCOMPARE(addBias);
// member function need be test. BASEMATRIXCOMPARE(add);
BaseMatrixCompare( BASEMATRIXCOMPARE(sub);
static_cast<void (BaseMatrix::*)()>(&BaseMatrix::exp)); BASEMATRIXCOMPARE(pow);
BaseMatrixCompare( BASEMATRIXCOMPARE(addScalar);
static_cast<void (BaseMatrix::*)()>(&BaseMatrix::sqrt)); BASEMATRIXCOMPARE(subScalar);
BASEMATRIXCOMPARE(mulScalar);
BASEMATRIXCOMPARE(divScalar);
BASEMATRIXCOMPARE(scalarDiv);
BASEMATRIXCOMPARE(addSquare);
BASEMATRIXCOMPARE(isEqualTo);
#undef BASEMATRIXCOMPARE
}
/**
* Test member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&, BaseMatrix&).
*/
TEST(BaseMatrix, BaseMatrix_BaseMatrix) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&, BaseMatrix&);
#define BASEMATRIXCOMPARE(function) \
BaseMatrixCompare<0, 1>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXCOMPARE(softCrossEntropy);
BASEMATRIXCOMPARE(softCrossEntropyBp);
BASEMATRIXCOMPARE(binaryLabelCrossEntropy);
BASEMATRIXCOMPARE(binaryLabelCrossEntropyBp);
BASEMATRIXCOMPARE(sub);
BASEMATRIXCOMPARE(add2);
BASEMATRIXCOMPARE(dotMul);
BASEMATRIXCOMPARE(dotDiv);
BASEMATRIXCOMPARE(logisticRegressionLoss);
BASEMATRIXCOMPARE(logisticRegressionLossBp);
BASEMATRIXCOMPARE(biggerThan);
BASEMATRIXCOMPARE(max);
BASEMATRIXCOMPARE(dotMulSquare);
BASEMATRIXCOMPARE(dotSquareSquare);
#undef BASEMATRIXCOMPARE
}
/**
* Test aggregate member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&).
*/
TEST(Aggregate, BaseMatrix) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&);
#define BASEMATRIXAPPLYROW(function) \
BaseMatrixApplyRow<0>(static_cast<FunctionProto>(&BaseMatrix::function));
#define BASEMATRIXAPPLYCOL(function) \
BaseMatrixApplyCol<0>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXAPPLYROW(maxRows);
BASEMATRIXAPPLYROW(minRows);
BASEMATRIXAPPLYCOL(sumCols);
BASEMATRIXAPPLYCOL(maxCols);
BASEMATRIXAPPLYCOL(minCols);
#undef BASEMATRIXAPPLYROW
#undef BASEMATRIXAPPLYCOL
}
/**
* Test aggregate member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&, BaseMatrix&).
*/
TEST(Aggregate, BaseMatrix_BaseMatrix) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&, BaseMatrix&);
#define BASEMATRIXAPPLYROW(function) \
BaseMatrixApplyRow<0, 1>(static_cast<FunctionProto>(&BaseMatrix::function));
#define BASEMATRIXAPPLYCOL(function) \
BaseMatrixApplyCol<0, 1>(static_cast<FunctionProto>(&BaseMatrix::function));
BASEMATRIXAPPLYCOL(addDotMulVMM);
#undef BASEMATRIXAPPLYROW
#undef BASEMATRIXAPPLYCOL
}
/**
* Test aggregate member functions which prototype is
* void (BaseMatrix::*)(BaseMatrix&, real, real).
*/
TEST(Aggregate, BaseMatrix_real_real) {
typedef void (BaseMatrix::*FunctionProto)(BaseMatrix&, real, real);
#define BASEMATRIXAPPLYROW(function) \
BaseMatrixApplyRow<0, 1, 2>(\
static_cast<FunctionProto>(&BaseMatrix::function));
// member function with one argument #define BASEMATRIXAPPLYCOL(function) \
BaseMatrixApplyCol<0, 1, 2>(\
static_cast<FunctionProto>(&BaseMatrix::function));
BaseMatrixCompare<0>(&BaseMatrix::tanh); BASEMATRIXAPPLYROW(sumRows);
BASEMATRIXAPPLYCOL(sumCols);
BaseMatrixCompare<0>( #undef BASEMATRIXAPPLYROW
static_cast<void (BaseMatrix::*)(real)>(&BaseMatrix::assign)); #undef BASEMATRIXAPPLYCOL
BaseMatrixCompare<0>(
static_cast<void (BaseMatrix::*)(real)>(&BaseMatrix::pow));
} }
int main(int argc, char** argv) { int main(int argc, char** argv) {
......
paddle/math/tests/test_matrixCompare.cpp
浏览文件 @ 85e0cd70
...@@ -448,125 +448,6 @@ void testMatrixZeroAtOffset(int height, int width) { ...@@ -448,125 +448,6 @@ void testMatrixZeroAtOffset(int height, int width) {
MatrixCheckEqual(*cpuA, *cpuTest); MatrixCheckEqual(*cpuA, *cpuTest);
} }
void testMatrixBinaryAdd(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
cpuA->add(*cpuB);
gpuA->add(*gpuB);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckEqual(*cpuA, *outputCheck);
}
void testMatrixAssign(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
gpuA->copyFrom(*cpuA);
cpuA->assign(2.5);
gpuA->assign(2.5);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckEqual(*cpuA, *outputCheck);
}
void testMatrixAdd(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
gpuA->copyFrom(*cpuA);
cpuA->add(2.5);
gpuA->add(2.5);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckEqual(*cpuA, *outputCheck);
}
void testMatrixSqrt(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
gpuA->copyFrom(*cpuA);
cpuA->sqrt();
gpuA->sqrt();
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixTanhDerivative(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
cpuA->tanhDerivative(*cpuB);
gpuA->tanhDerivative(*gpuB);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixTanh(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
cpuA->tanh(*cpuB);
gpuA->tanh(*gpuB);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixTernarySub(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuC = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuC = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
cpuC->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
gpuC->copyFrom(*cpuC);
cpuA->sub(*cpuB, *cpuC);
gpuA->sub(*gpuB, *gpuC);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckEqual(*cpuA, *outputCheck);
}
void testMatrixSumOfSquaresBp(int height, int width) { void testMatrixSumOfSquaresBp(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width); MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width); MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
...@@ -789,18 +670,7 @@ TEST(Matrix, unary) { ...@@ -789,18 +670,7 @@ TEST(Matrix, unary) {
for (auto width : {1, 3, 32, 100, 512, 1000, 3210}) { for (auto width : {1, 3, 32, 100, 512, 1000, 3210}) {
VLOG(3) << " height=" << height << " width=" << width; VLOG(3) << " height=" << height << " width=" << width;
// applyUnary
testMatrixAssign(height, width);
testMatrixAdd(height, width);
testMatrixSqrt(height, width);
// applyBinary
testMatrixBinaryAdd(height, width);
testMatrixTanh(height, width);
testMatrixTanhDerivative(height, width);
// applyTernary // applyTernary
testMatrixTernarySub(height, width);
testMatrixSumOfSquaresBp(height, width); testMatrixSumOfSquaresBp(height, width);
// asRowVector // asRowVector
...@@ -931,165 +801,6 @@ TEST(Matrix, softmax) { ...@@ -931,165 +801,6 @@ TEST(Matrix, softmax) {
} }
} }
void testMatrixAddDotMulVMM(int height, int width, int endCol = 0) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(1, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuC = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(1, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
MatrixPtr gpuC = std::make_shared<GpuMatrix>(height, width);
MatrixPtr cpuA1 = std::make_shared<CpuMatrix>(1, width);
MatrixPtr cpuB1 = std::make_shared<CpuMatrix>(height, width);
MatrixPtr cpuC1 = std::make_shared<CpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
cpuC->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
gpuC->copyFrom(*cpuC);
cpuA1->copyFrom(*cpuA);
cpuB1->copyFrom(*cpuB);
cpuC1->copyFrom(*cpuC);
if (!endCol) {
cpuA->addDotMulVMM(*cpuB, *cpuC);
gpuA->addDotMulVMM(*gpuB, *gpuC);
cpuA1->addDotMulVMM2(*cpuB1, *cpuC1);
MatrixCheckErr(*cpuA, *cpuA1);
} else {
MatrixPtr subCpuA = cpuA->subColMatrix(0, endCol);
MatrixPtr subCpuB = cpuB->subColMatrix(0, endCol);
MatrixPtr subCpuC = cpuC->subColMatrix(0, endCol);
MatrixPtr subGpuA = gpuA->subColMatrix(0, endCol);
MatrixPtr subGpuB = gpuB->subColMatrix(0, endCol);
MatrixPtr subGpuC = gpuC->subColMatrix(0, endCol);
subCpuA->addDotMulVMM(*subCpuB, *subCpuC);
subGpuA->addDotMulVMM(*subGpuB, *subGpuC);
}
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(1, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixRowSum(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, 1);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, 1);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
MatrixPtr cpuA1 = std::make_shared<CpuMatrix>(height, 1);
MatrixPtr cpuB1 = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA1 = std::make_shared<GpuMatrix>(height, 1);
MatrixPtr gpuB1 = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
cpuA1->copyFrom(*cpuA);
cpuB1->copyFrom(*cpuB);
gpuA1->copyFrom(*cpuA);
gpuB1->copyFrom(*cpuB);
cpuA->colMerge(*cpuB);
gpuA->colMerge(*gpuB);
cpuB1->rowSum(*cpuA1);
gpuB1->rowSum(*gpuA1);
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, 1);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
outputCheck->copyFrom(*gpuA1);
MatrixCheckErr(*cpuA1, *outputCheck);
}
void testMatrixRowMax(int height, int width, int endCol = 0) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(height, 1);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(height, 1);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
if (!endCol) {
cpuB->rowMax(*cpuA);
gpuB->rowMax(*gpuA);
} else {
MatrixPtr subCpuB = cpuB->subColMatrix(0, endCol);
MatrixPtr subGpuB = gpuB->subColMatrix(0, endCol);
subCpuB->rowMax(*cpuA);
subGpuB->rowMax(*gpuA);
}
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(height, 1);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixColSum(int height, int width, int endCol = 0) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(1, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(1, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
if (!endCol) {
cpuA->accumulateColSum(*cpuB);
gpuA->accumulateColSum(*gpuB);
} else {
MatrixPtr subCpuA = cpuA->subColMatrix(0, endCol);
MatrixPtr subGpuA = gpuA->subColMatrix(0, endCol);
MatrixPtr subCpuB = cpuB->subColMatrix(0, endCol);
MatrixPtr subGpuB = gpuB->subColMatrix(0, endCol);
subCpuA->accumulateColSum(*subCpuB);
subGpuA->accumulateColSum(*subGpuB);
}
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(1, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixColMax(int height, int width, int endCol = 0) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(1, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
MatrixPtr gpuA = std::make_shared<GpuMatrix>(1, width);
MatrixPtr gpuB = std::make_shared<GpuMatrix>(height, width);
cpuA->randomizeUniform();
cpuB->randomizeUniform();
gpuA->copyFrom(*cpuA);
gpuB->copyFrom(*cpuB);
if (!endCol) {
cpuB->colMax(*cpuA);
gpuB->colMax(*gpuA);
} else {
MatrixPtr subCpuA = cpuA->subColMatrix(0, endCol);
MatrixPtr subGpuA = gpuA->subColMatrix(0, endCol);
MatrixPtr subCpuB = cpuB->subColMatrix(0, endCol);
MatrixPtr subGpuB = gpuB->subColMatrix(0, endCol);
subCpuB->colMax(*subCpuA);
subGpuB->colMax(*subGpuA);
}
MatrixPtr outputCheck = std::make_shared<CpuMatrix>(1, width);
outputCheck->copyFrom(*gpuA);
MatrixCheckErr(*cpuA, *outputCheck);
}
void testMatrixCollectBias(int height, int width) { void testMatrixCollectBias(int height, int width) {
MatrixPtr cpuA = std::make_shared<CpuMatrix>(1, width); MatrixPtr cpuA = std::make_shared<CpuMatrix>(1, width);
MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width); MatrixPtr cpuB = std::make_shared<CpuMatrix>(height, width);
...@@ -1182,13 +893,8 @@ TEST(Matrix, aggregate) { ...@@ -1182,13 +893,8 @@ TEST(Matrix, aggregate) {
for (auto height : {1, 11, 16, 32, 64, 73, 128, 200, 1024, 2345}) { for (auto height : {1, 11, 16, 32, 64, 73, 128, 200, 1024, 2345}) {
for (auto width : {1, 9, 16, 32, 64, 100, 512, 1000, 1024, 2453}) { for (auto width : {1, 9, 16, 32, 64, 100, 512, 1000, 1024, 2453}) {
VLOG(3) << " height=" << height << " width=" << width; VLOG(3) << " height=" << height << " width=" << width;
testMatrixRowSum(height, width);
testMatrixRowMax(height, width);
testMatrixColSum(height, width);
testMatrixColMax(height, width);
testMatrixCollectBias(height, width); testMatrixCollectBias(height, width);
testMatrixTernaryRowDotMul(height, width); testMatrixTernaryRowDotMul(height, width);
testMatrixAddDotMulVMM(height, width);
testMatrixSumOfSquares(height, width); testMatrixSumOfSquares(height, width);
testMatrixBinaryClassificationError(height, width); testMatrixBinaryClassificationError(height, width);
...@@ -1203,11 +909,7 @@ TEST(Matrix, aggregate2) { ...@@ -1203,11 +909,7 @@ TEST(Matrix, aggregate2) {
VLOG(3) << " height=" << height << " width=" << width; VLOG(3) << " height=" << height << " width=" << width;
int endCol = rand() % width; // NOLINT int endCol = rand() % width; // NOLINT
testMatrixRowMax(height, width, endCol);
testMatrixSumOfSquares(height, width, endCol); testMatrixSumOfSquares(height, width, endCol);
testMatrixColSum(height, width, endCol);
testMatrixColMax(height, width, endCol);
testMatrixAddDotMulVMM(height, width, endCol);
} }
} }
} }
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或