potok/opencv
1
0
Fork 0
mirror of https://github.com/opencv/opencv.git synced 2026-07-31 00:03:03 +04:00
Code Packages Releases Wiki Activity

Merge pull request #25595 from Abdurrahheem:ash/01D-einsum-test

Browse Source 
Add support for scalar and matrix multiplication in einsum #25595

### Pull Request Readiness Checklist

See details at https://github.com/opencv/opencv/wiki/How_to_contribute#making-a-good-pull-request

- [x] I agree to contribute to the project under Apache 2 License.
- [x] To the best of my knowledge, the proposed patch is not based on a code under GPL or another license that is incompatible with OpenCV
- [x] The PR is proposed to the proper branch
- [x] There is a reference to the original bug report and related work
- [x] There is accuracy test, performance test and test data in opencv_extra repository, if applicable
      Patch to opencv_extra has the same branch name.
- [x] The feature is well documented and sample code can be built with the project CMake
This commit is contained in:
Abduragim Shtanchaev
2024-05-21 14:36:12 +04:00
committed by GitHub
parent 9238eb2ab2
commit f676cb3c62
3 changed files with 44 additions and 32 deletions
Download Patch File Download Diff File Expand all files Collapse all files
modules/dnn/test/test_layers_1d.cpp
+33 -26
View File
@@ -824,12 +824,13 @@ INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Tile_Test,
std::vector<int>({2, 2})
));
typedef testing::TestWithParam<tuple<std::vector<int>, std::string>> Layer_Einsum_Test;
typedef testing::TestWithParam<tuple<std::vector<int>, std::vector<int>, std::string>> Layer_Einsum_Test;
TEST_P(Layer_Einsum_Test, Accuracy_01D)
{
auto tup = GetParam();
std::vector<int> input_shape = std::get<0>(tup);
std::string equation = std::get<1>(tup);
std::vector<int> input_shape1 = std::get<0>(tup);
std::vector<int> input_shape2 = std::get<1>(tup);
std::string equation = std::get<2>(tup);
LayerParams lp;
lp.type = "Einsum";
@@ -837,13 +838,13 @@ TEST_P(Layer_Einsum_Test, Accuracy_01D)
lp.set("equation", equation);
lp.set("inputSize", 2);
lp.set("outputSize", 1);
lp.set("inputShapes0", DictValue::arrayInt(&input_shape[0], input_shape.size()));
lp.set("inputShapes1", DictValue::arrayInt(&input_shape[0], input_shape.size()));
lp.set("inputShapes0", DictValue::arrayInt(&input_shape1[0], input_shape1.size()));
lp.set("inputShapes1", DictValue::arrayInt(&input_shape2[0], input_shape2.size()));
Ptr<Layer> layer = EinsumLayer::create(lp);
cv::Mat input1(input_shape.size(), input_shape.data(), CV_32F);
cv::Mat input2(input_shape.size(), input_shape.data(), CV_32F);
cv::Mat input1(input_shape1.size(), input_shape1.data(), CV_32F);
cv::Mat input2(input_shape2.size(), input_shape2.data(), CV_32F);
cv::randn(input1, 0.0, 1.0); cv::randn(input2, 0.0, 1.0);
std::vector<Mat> inputs = {input1, input2};
@@ -854,27 +855,29 @@ TEST_P(Layer_Einsum_Test, Accuracy_01D)
// create output_ref to compare with outputs
cv::Mat output_ref;
int size[] = {1};
if (equation == ",->"){
if(equation == ",->" || equation == "i,->i" || equation == ",i->i" || equation == "ij,->ij"){
output_ref = input1.mul(input2);
}else if (equation == "i, i->i"){
if (equation == ",i->i")
output_ref = output_ref.reshape(1, 1, size);
} else if (equation == "i,i->i"){
output_ref = input1.mul(input2);
} else if (equation == "i, i->"){
} else if (equation == "i,i->"){
output_ref = input1.mul(input2);
cv::Scalar sum = cv::sum(output_ref);
output_ref = cv::Mat(0, nullptr, CV_32F, sum[0]);
} else if (equation == "ij, ij->ij"){
} else if (equation == "ij,ij->ij"){
output_ref = input1.mul(input2);
} else if (equation == "ij, ij->i"){
} else if (equation == "ij,ij->i"){
output_ref = input1.mul(input2);
if (input_shape[0] == 1){
if (input_shape1[0] == 1){
cv::Scalar sum = cv::sum(output_ref);
output_ref = cv::Mat(1, size, CV_32F, sum[0]);
} else if (input_shape[1] == 1){
size[0] = input_shape[0];
} else if (input_shape1[1] == 1){
size[0] = input_shape1[0];
output_ref = output_ref.reshape(1, 1, size);
} else {
cv::reduce(output_ref, output_ref, 1, cv::REDUCE_SUM, CV_32F);
size[0] = input_shape[0];
size[0] = input_shape1[0];
output_ref = output_ref.reshape(1, 1, size);
}
} else {
@@ -886,16 +889,20 @@ TEST_P(Layer_Einsum_Test, Accuracy_01D)
}
INSTANTIATE_TEST_CASE_P(/*nothing*/, Layer_Einsum_Test, testing::Values(
std::make_tuple(std::vector<int>({}), std::string(",->")),
std::make_tuple(std::vector<int>({1}), std::string("i, i->i")),
std::make_tuple(std::vector<int>({1}), std::string("i, i->")),
std::make_tuple(std::vector<int>({4}), std::string("i, i->i")),
std::make_tuple(std::vector<int>({4}), std::string("i, i->")),
std::make_tuple(std::vector<int>({1, 4}), std::string("ij, ij->ij")),
std::make_tuple(std::vector<int>({4, 1}), std::string("ij, ij->ij")),
std::make_tuple(std::vector<int>({1, 4}), std::string("ij, ij->i")),
std::make_tuple(std::vector<int>({4, 1}), std::string("ij, ij->i")),
std::make_tuple(std::vector<int>({4, 4}), std::string("ij, ij->i"))
std::make_tuple(std::vector<int>({}), std::vector<int>({}), ",->"),
std::make_tuple(std::vector<int>({1}), std::vector<int>({}), "i,->i"),
std::make_tuple(std::vector<int>({}), std::vector<int>({1}), ",i->i"),
std::make_tuple(std::vector<int>({4, 1}), std::vector<int>({}), "ij,->ij"),
// std::make_tuple(std::vector<int>({}), std::vector<int>({4, 1}), ",ij->ij")), // mul function of arithm_op can not handle cases with different number of channels
std::make_tuple(std::vector<int>({1}), std::vector<int>({1}), "i,i->i"),
std::make_tuple(std::vector<int>({1}), std::vector<int>({1}), "i,i->"),
std::make_tuple(std::vector<int>({4}), std::vector<int>({4}), "i,i->i"),
std::make_tuple(std::vector<int>({4}), std::vector<int>({4}), "i,i->"),
std::make_tuple(std::vector<int>({1, 4}), std::vector<int>({1, 4}), "ij,ij->ij"),
std::make_tuple(std::vector<int>({4, 1}), std::vector<int>({4, 1}), "ij,ij->ij"),
std::make_tuple(std::vector<int>({1, 4}), std::vector<int>({1, 4}), "ij,ij->i"),
std::make_tuple(std::vector<int>({4, 1}), std::vector<int>({4, 1}), "ij,ij->i"),
std::make_tuple(std::vector<int>({4, 4}), std::vector<int>({4, 4}), "ij,ij->i")
));