diff --git a/include/aidge/backend/cpu.hpp b/include/aidge/backend/cpu.hpp
index 80574b4a46fef0c843c9511836f162e02de5aab3..5c1f9b111f41a435aa477d0647fa66fb29a058fb 100644
--- a/include/aidge/backend/cpu.hpp
+++ b/include/aidge/backend/cpu.hpp
@@ -27,6 +27,7 @@
#include "aidge/backend/cpu/operator/ClipImpl.hpp"
#include "aidge/backend/cpu/operator/ConvDepthWiseImpl.hpp"
#include "aidge/backend/cpu/operator/ConvImpl.hpp"
+#include "aidge/backend/cpu/operator/ConvTransposeImpl.hpp"
#include "aidge/backend/cpu/operator/ConstantOfShapeImpl.hpp"
#include "aidge/backend/cpu/operator/CryptoHashImpl.hpp"
#include "aidge/backend/cpu/operator/DivImpl.hpp"
diff --git a/include/aidge/backend/cpu/operator/ConvTransposeImpl.hpp b/include/aidge/backend/cpu/operator/ConvTransposeImpl.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..7604a96a18e7be44f4c2e8970a0b60b1c4ad918b
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/ConvTransposeImpl.hpp
@@ -0,0 +1,59 @@
+
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_H_
+#define AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_H_
+
+#include <array>
+
+#include "aidge/backend/cpu/operator/OperatorImpl.hpp"
+#include "aidge/operator/ConvTranspose.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include "aidge/utils/Types.h"
+
+namespace Aidge {
+
+using std::array;
+
+// Operator implementation entry point for the backend
+using ConvTranspose1D_Op = ConvTranspose_Op<1>;
+using ConvTransposeImpl1D_cpu =
+ OperatorImpl_cpu<ConvTranspose1D_Op,
+ void(const array<DimSize_t,1> &,
+ const array<DimSize_t,1> &,
+ const array<DimSize_t,1> &,
+ const array<DimSize_t, 3> &,
+ const array<DimSize_t, 3> &,
+ const void *,
+ const void *,
+ const void *,
+ void *)>;
+
+using ConvTranspose2D_Op = ConvTranspose_Op<2>;
+using ConvTransposeImpl2D_cpu =
+ OperatorImpl_cpu<ConvTranspose2D_Op,
+ void(const array<DimSize_t, 2> &,
+ const array<DimSize_t, 2> &,
+ const array<DimSize_t, 2> &,
+ const array<DimSize_t, 4> &,
+ const array<DimSize_t, 4> &,
+ const void *,
+ const void *,
+ const void *,
+ void *)>;
+
+// Implementation entry point registration to Operator
+REGISTRAR(ConvTranspose1D_Op, "cpu", ConvTransposeImpl1D_cpu::create);
+REGISTRAR(ConvTranspose2D_Op, "cpu", ConvTransposeImpl2D_cpu::create);
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_H_ */
diff --git a/include/aidge/backend/cpu/operator/ConvTransposeImpl_kernels.hpp b/include/aidge/backend/cpu/operator/ConvTransposeImpl_kernels.hpp
new file mode 100644
index 0000000000000000000000000000000000000000..e11dd2625ae1645a8e7c5482b1635b85fb475b06
--- /dev/null
+++ b/include/aidge/backend/cpu/operator/ConvTransposeImpl_kernels.hpp
@@ -0,0 +1,305 @@
+/********************************************************************************
+ * Copyright (c) 2025 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#ifndef AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_KERNELS_H_
+#define AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_KERNELS_H_
+
+#include <array>
+
+#include "aidge/backend/cpu/operator/ConvTransposeImpl.hpp"
+#include "aidge/utils/Registrar.hpp"
+#include <aidge/backend/cpu/operator/ConvImpl_kernels.hpp>
+#include <aidge/data/Data.hpp>
+#include <aidge/data/half.hpp>
+#include <aidge/scheduler/ProdConso.hpp>
+#include <aidge/utils/Types.h>
+
+namespace Aidge {
+
+using std::array;
+
+////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+// 1D
+////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+
+/**
+ * @brief performs forward bias operation for convtranspose operator
+ *
+ * @tparam B Bias data type.
+ * @tparam O Output data type.
+ * @param[in] bias bias values
+ * @param[in] oDims dimensions of the output
+ * @param[in] oStrides nb of elements contained per dimension of the output
+ * @param[out] output
+ */
+template <class B, class O>
+static void convTranspose1DForwardBias(const B *biases,
+ const array<DimSize_t, 3> &oDims,
+ const array<DimSize_t, 2> &oStrides,
+ O *output) {
+ array<DimSize_t, 2> outOffsets{0, 0};
+ for (DimSize_t batch = 0; batch < oDims[0]; ++batch) {
+ outOffsets[0] = batch * oStrides[0];
+ for (DimSize_t outCh = 0; outCh < oDims[1]; ++outCh) {
+ outOffsets[1] = outCh * oStrides[1] + outOffsets[0];
+ // If bias = nullptr, set B(0)
+ B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
+ std::fill(output + outOffsets[1],
+ output + (outOffsets[1] + oDims[2]),
+ biasVal);
+ }
+ }
+}
+
+/**
+ * @brief forward kernel for convtranspose
+ * @note ConvTranspose forward is simply convolution backward kernel.
+ * Check convolution functions for more in-depth details on how the
+ subfunctions are built.
+ * @tparam I Input data type.
+ * @tparam W Weight data type.
+ * @tparam B Bias data type.
+ * @tparam O Output data type.
+ * @param[in] stride stride parameter of the convTranspose operator
+ * @param[in] dilation dilation parameter of the convTranspose operator
+ * @param[in] inputDims input dimensions
+ * @param[in] outputDims output tensor dimensions
+ * @param[in] oStrides nb of elements contained per dimension of the output
+ * @param[in] input_ values
+ * @param[in] weight_ values
+ * @param[in] biases_ values
+ * @param[out] output
+ */
+template <class I, class W, class B, class O>
+void ConvTransposeImpl1D_cpu_forward_kernel(
+ const array<DimSize_t, 1> &stride,
+ const array<DimSize_t, 1> &dilation,
+ const array<DimSize_t, 1> &kernelDim,
+ const array<DimSize_t, 3> &inputDims,
+ const array<DimSize_t, 3> &outputDims,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_) {
+
+ const I *input = static_cast<const I *>(input_);
+ const W *weights = static_cast<const W *>(weights_);
+ O *output = static_cast<O *>(output_);
+
+ // {batch_stride, channel_stride, dim0_stride}
+ const array<DimSize_t, 2> inputStrides{inputDims[1] * inputDims[2],
+ inputDims[2]};
+
+ // {batch_stride, channel_stride, dim0_stride}
+ const array<DimSize_t, 2> outputStrides{outputDims[1] * outputDims[2],
+ outputDims[2]};
+
+ // NOTE: kernel dims = {inChannels, outChannels, kernelDims[0]}
+ const array<DimSize_t, 2> kernelStrides{
+ outputDims[1] * kernelDim[0],
+ kernelDim[0],
+ };
+
+ if (biases_ != nullptr) {
+ const B *biases = static_cast<const B *>(biases_);
+ convTranspose1DForwardBias(biases, outputDims, outputStrides, output);
+ }
+
+ conv1DBackwardInput(stride,
+ dilation,
+ kernelDim,
+ kernelStrides,
+ weights,
+ inputDims,
+ inputStrides,
+ input,
+ outputDims,
+ outputStrides,
+ output);
+}
+
+REGISTRAR(ConvTransposeImpl1D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Int32, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl1D_cpu_forward_kernel<std::int32_t,
+ std::int32_t,
+ std::int32_t,
+ std::int32_t>,
+ nullptr});
+REGISTRAR(ConvTransposeImpl1D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Float32, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl1D_cpu_forward_kernel<float, float, float, float>,
+ nullptr});
+REGISTRAR(ConvTransposeImpl1D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Float16, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl1D_cpu_forward_kernel<half_float::half,
+ half_float::half,
+ half_float::half,
+ half_float::half>,
+ nullptr});
+REGISTRAR(
+ ConvTransposeImpl1D_cpu,
+ {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl1D_cpu_forward_kernel<double, double, double, double>,
+ nullptr});
+
+////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+// 2D
+////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////
+
+/**
+ * @brief performs forward bias operation for convtranspose operator
+ *
+ * @tparam B Bias data type.
+ * @tparam O Output data type.
+ * @param[in] bias bias values
+ * @param[in] oDims dimensions of the output
+ * @param[in] oStrides nb of elements contained per dimension of the output
+ * @param[out] output
+ */
+template <class B, class O>
+static void convTranspose2DForwardBias(const B *biases,
+ const array<DimSize_t, 4> &oDims,
+ const array<DimSize_t, 3> &oStrides,
+ O *output) {
+ array<DimSize_t, 2> outOffsets{0, 0};
+
+ for (DimSize_t batch = 0; batch < oDims[0]; ++batch) {
+ outOffsets[0] = batch * oStrides[0];
+
+ for (DimSize_t outCh = 0; outCh < oDims[1]; ++outCh) {
+ outOffsets[1] = outCh * oStrides[1] + outOffsets[0];
+ // If bias = nullptr, set B(0)
+ B biasVal = (biases != nullptr) ? biases[outCh] : B(0);
+ std::fill(output + outOffsets[1],
+ (output + outOffsets[1]) + oStrides[1],
+ biasVal);
+ }
+ }
+}
+
+/**
+ * @brief forward kernel for convtranspose
+ * @note ConvTranspose forward is simply convolution backward kernel.
+ * Check convolution functions for more in-depth details on how the
+ subfunctions are built.
+ * @tparam I Input data type.
+ * @tparam W Weight data type.
+ * @tparam B Bias data type.
+ * @tparam O Output data type.
+ * @param[in] stride stride parameter of the convTranspose operator
+ * @param[in] dilation dilation parameter of the convTranspose operator
+ * @param[in] inputDims input dimensions
+ * @param[in] outputDims output tensor dimensions
+ * @param[in] oStrides nb of elements contained per dimension of the output
+ * @param[in] input_ values
+ * @param[in] weight_ values
+ * @param[in] biases_ values
+ * @param[out] output
+ */
+template <class I, class W, class B, class O>
+void ConvTransposeImpl2D_cpu_forward_kernel(
+ const array<DimSize_t, 2> &stride,
+ const array<DimSize_t, 2> &dilation,
+ const array<DimSize_t, 2> &kernelDims,
+ const array<DimSize_t, 4> &inputDims,
+ const array<DimSize_t, 4> &outputDims,
+ const void *input_,
+ const void *weights_,
+ const void *biases_,
+ void *output_) {
+
+ auto input = static_cast<const I *>(input_);
+ auto weights = static_cast<const W *>(weights_);
+ auto output = static_cast<O *>(output_);
+
+ // {channel_stride, dim0_stride, dim1_stride}
+ const array<DimSize_t, 3> inputStrides{
+ inputDims[1] * inputDims[2] * inputDims[3],
+ inputDims[2] * inputDims[3],
+ inputDims[3]};
+
+ // {channel_stride, dim0_stride, dim1_stride}
+ const array<DimSize_t, 3> outputStrides{
+ outputDims[1] * outputDims[2] * outputDims[3],
+ outputDims[2] * outputDims[3],
+ outputDims[3]};
+
+ // NOTE: kernel dims = {inChannels, outChannels, kernelDims[0],
+ // kernelDims[1]}
+ const array<DimSize_t, 3> kernelStrides{
+ outputDims[1] * kernelDims[0] * kernelDims[1],
+ kernelDims[0] * kernelDims[1],
+ kernelDims[1],
+ };
+
+ if (biases_ != nullptr) {
+ auto biases = static_cast<const B *>(biases_);
+ convTranspose2DForwardBias(biases, outputDims, outputStrides, output);
+ }
+
+ conv2DBackwardInput(stride,
+ dilation,
+ kernelDims,
+ kernelStrides,
+ weights,
+ inputDims,
+ inputStrides,
+ input,
+ outputDims,
+ outputStrides,
+ output);
+}
+
+REGISTRAR(ConvTransposeImpl2D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Int32, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl2D_cpu_forward_kernel<std::int32_t,
+ std::int32_t,
+ std::int32_t,
+ std::int32_t>,
+ nullptr});
+REGISTRAR(ConvTransposeImpl2D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Float16, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl2D_cpu_forward_kernel<half_float::half,
+ half_float::half,
+ half_float::half,
+ half_float::half>,
+ nullptr});
+REGISTRAR(ConvTransposeImpl2D_cpu,
+ {{DataType::Any, DataFormat::NCHW},
+ {DataType::Float32, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl2D_cpu_forward_kernel<float, float, float, float>,
+ nullptr});
+REGISTRAR(
+ ConvTransposeImpl2D_cpu,
+ {{DataType::Any, DataFormat::NCHW}, {DataType::Float64, DataFormat::NCHW}},
+ {ProdConso::inPlaceModel,
+ ConvTransposeImpl2D_cpu_forward_kernel<double, double, double, double>,
+ nullptr});
+
+} // namespace Aidge
+
+#endif /* AIDGE_CPU_OPERATOR_CONVTRANSPOSEIMPL_KERNELS_H_ */
diff --git a/src/operator/ConvTransposeImpl.cpp b/src/operator/ConvTransposeImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..d1135cc92dd3c68746b9dcf80739f4f65acdad2e
--- /dev/null
+++ b/src/operator/ConvTransposeImpl.cpp
@@ -0,0 +1,91 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include "aidge/backend/cpu/operator/ConvTransposeImpl.hpp"
+#include "aidge/backend/cpu/operator/ConvTransposeImpl_kernels.hpp"
+
+template <> void Aidge::ConvTransposeImpl1D_cpu::forward() {
+ const auto &op = static_cast<const ConvTranspose_Op<1> &>(mOp);
+
+ AIDGE_ASSERT(op.getInput(0), "{}: missing data input (#0).", op.type());
+ AIDGE_ASSERT(op.getInput(1), "{}: missing bias input (#1).", op.type());
+ AIDGE_ASSERT(op.getInput(2), "{}: missing weight input (#1).", op.type());
+
+ std::shared_ptr<Tensor> inputDataFallback, inputWeightFallback,
+ inputBiasFallback;
+ const auto &inputData =
+ op.getInput(0)->refCastFrom(inputDataFallback, *op.getOutput(0));
+ const auto &inputWeight =
+ op.getInput(1)->refCastFrom(inputWeightFallback, *op.getOutput(0));
+ const auto &inputBias =
+ (op.getInput(2))
+ ? op.getInput(2)->refCastFrom(inputBiasFallback, *op.getOutput(0))
+ : Tensor();
+
+ // Call kernel
+ const auto impl = Registrar<ConvTransposeImpl1D_cpu>::create(
+ getBestMatch(getRequiredSpec()));
+ impl.forward(op.strideDims(),
+ op.dilationDims(),
+ op.kernelDims(),
+ op.getInput(0)->template dims<3>(),
+ op.getOutput(0)->template dims<3>(),
+ inputData.getImpl()->hostPtr(),
+ inputWeight.getImpl()->hostPtr(),
+ op.getInput(2) ? inputBias.getImpl()->hostPtr() : nullptr,
+ op.getOutput(0)->getImpl()->rawPtr());
+}
+
+template <> void Aidge::ConvTransposeImpl1D_cpu::backward() {
+ AIDGE_THROW_OR_ABORT(
+ std::runtime_error,
+ "Backward not yet implemented for Conv_Op<1> on backend cpu");
+}
+
+template <> void Aidge::ConvTransposeImpl2D_cpu::forward() {
+ const auto &op = static_cast<const ConvTranspose_Op<2> &>(mOp);
+
+ AIDGE_ASSERT(op.getInput(0), "{}: missing data input (#0).", op.type());
+ AIDGE_ASSERT(op.getInput(1), "{}: missing bias input (#1).", op.type());
+ AIDGE_ASSERT(op.getInput(2), "{}: missing weight input (#1).", op.type());
+
+ std::shared_ptr<Tensor> inputDataFallback, inputWeightFallback,
+ inputBiasFallback;
+ const auto &inputData =
+ op.getInput(0)->refCastFrom(inputDataFallback, *op.getOutput(0));
+ const auto &inputWeight =
+ op.getInput(1)->refCastFrom(inputWeightFallback, *op.getOutput(0));
+ const auto &inputBias =
+ (op.getInput(2))
+ ? op.getInput(2)->refCastFrom(inputBiasFallback, *op.getOutput(0))
+ : Tensor();
+
+ // Call kernel
+ const auto impl = Registrar<ConvTransposeImpl2D_cpu>::create(
+ getBestMatch(getRequiredSpec()));
+
+ impl.forward(op.strideDims(),
+ op.dilationDims(),
+ op.kernelDims(),
+ op.getInput(0)->template dims<4>(),
+ op.getOutput(0)->template dims<4>(),
+ inputData.getImpl()->hostPtr(),
+ inputWeight.getImpl()->hostPtr(),
+ op.getInput(2) ? inputBias.getImpl()->hostPtr() : nullptr,
+ op.getOutput(0)->getImpl()->rawPtr());
+}
+
+template <> void Aidge::ConvTransposeImpl2D_cpu::backward() {
+ AIDGE_THROW_OR_ABORT(
+ std::runtime_error,
+ "Backward not yet implemented for Conv_Op<2> on backend cpu");
+}
+
diff --git a/unit_tests/operator/Test_ConvTranspose.cpp b/unit_tests/operator/Test_ConvTranspose.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6e889e809e0a05d551829bd15fda9cc651068465
--- /dev/null
+++ b/unit_tests/operator/Test_ConvTranspose.cpp
@@ -0,0 +1,2298 @@
+/********************************************************************************
+ * Copyright (c) 2023 CEA-List
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ ********************************************************************************/
+
+#include <aidge/utils/Types.h>
+#include <memory>
+
+#include <catch2/catch_test_macros.hpp>
+#include <fmt/core.h>
+
+#include "aidge/backend/cpu/operator/ConvTransposeImpl.hpp"
+#include "aidge/data/Tensor.hpp"
+#include "aidge/operator/ConvTranspose.hpp"
+#include "aidge/utils/TensorUtils.hpp"
+
+namespace Aidge {
+
+template <DimSize_t DIM>
+static std::shared_ptr<OperatorTensor>
+setupTestConvTranspose(const DimSize_t batchSize,
+ const DimSize_t inChannels,
+ const DimSize_t outChannels,
+ const std::array<DimSize_t, DIM> kernelSize,
+ const std::array<DimSize_t, DIM> dataSize,
+ const std::array<DimSize_t, DIM> stride,
+ const std::array<DimSize_t, DIM> dilation,
+ const std::shared_ptr<Tensor> input,
+ const std::shared_ptr<Tensor> weights,
+ const std::shared_ptr<Tensor> biases) {
+ std::shared_ptr<Node> convTransposeNode;
+ convTransposeNode = ConvTranspose(inChannels,
+ outChannels,
+ kernelSize,
+ stride,
+ dilation,
+ false,
+ "myconv");
+ auto op = std::static_pointer_cast<OperatorTensor>(
+ convTransposeNode->getOperator());
+
+ op->associateInput(0, input);
+ op->setDataType(DataType::Float32);
+
+ input->setBackend("cpu");
+ op->setBackend("cpu");
+
+ weights->setBackend("cpu");
+ op->associateInput(1, weights);
+
+ biases->setBackend("cpu");
+ op->associateInput(2, biases);
+
+ REQUIRE_NOTHROW(op->forwardDims(true));
+
+ return op;
+}
+
+TEST_CASE("[cpu/operator] ConvTranspose(forward)", "[ConvTranspose][CPU]") {
+ constexpr DimSize_t DIM = 1;
+ SECTION("1D") {
+ SECTION("kernel = 2 , in/outChannels = 1") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 1;
+ constexpr DimSize_t outChannels = 1;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{5};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1.000000, 2.000000, 3.000000, 4.000000}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.100000, 0.200000}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{0.110000, 0.410000, 0.710000, 1.010000, 0.810000}}}}));
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ SECTION("kernel = 2, inChannel = 2, outChannels = 1") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 2;
+ constexpr DimSize_t outChannels = 1;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{5};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1.000000, 2.000000, 3.000000, 4.000000},
+ {5.000000, 6.000000, 7.000000, 8.000000}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.100000, 0.200000}}, {{0.300000, 0.400000}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{1.610000, 4.210000, 5.210000, 6.210001, 4.010000}}}}));
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ SECTION("kernel = 2, inChannel = 1, outChannels = 2") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 1;
+ constexpr DimSize_t outChannels = 2;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{5};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1., 2., 3., 4.}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.1, 0.2}, {0.3, 0.4}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.01, 0.02}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{0.11, 0.41, 0.71, 1.01, 0.81},
+ {0.32, 1.02, 1.72, 2.42, 1.62}}}}));
+
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ SECTION("kernel = 1, inChannel = 2, outChannels = 2") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 2;
+ constexpr DimSize_t outChannels = 2;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{1};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{4};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1.000000, 2.000000, 3.000000, 4.000000},
+ {5.000000, 6.000000, 7.000000, 8.000000}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.100000}, {0.200000}},
+
+ {{0.300000}, {0.400000}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000, 0.020000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{1.610000, 2.010000, 2.410000, 2.810000},
+ {2.220000, 2.820000, 3.420000, 4.020000}}}}));
+
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ SECTION("kernel = 2, inChannels = 2, outChannels = 3") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 2;
+ constexpr DimSize_t outChannels = 3;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{5};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1., 2., 3., 4.}, {5., 6., 7., 8.}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.10, 0.20}, {0.30, 0.40}, {0.50, 0.60}},
+
+ {{0.70, 0.80}, {0.90, 1.}, {1.10, 1.20}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000, 0.020000, 0.030000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<
+ Tensor>(Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{3.610000, 8.610001, 10.410000, 12.210001, 7.210001},
+ {4.820000, 11.420000, 14.020000, 16.620001, 9.620001},
+ {6.030000, 14.230000, 17.630001, 21.030001, 12.030000}}}}));
+
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+
+ SECTION("Big test to ensure kernel capabilities") {
+ constexpr DimSize_t batchSize = 2;
+ constexpr DimSize_t inChannels = 3;
+ constexpr DimSize_t outChannels = 4;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{6};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{6};
+ constexpr std::array<DimSize_t, DIM> outDataSize{11};
+
+ constexpr std::array<DimSize_t, DIM> stride{1};
+ constexpr std::array<DimSize_t, DIM> dilation{1};
+
+ auto input = std::make_shared<Tensor>(
+ Array3D<float, batchSize, inChannels, inDataSize[0]>(
+ {{{{1., 2., 3., 4., 5., 6.},
+ {7., 8., 9., 10., 11., 12.},
+ {13., 14., 15., 16., 17., 18.}},
+
+ {{19., 20., 21., 22., 23., 24.},
+ {25., 26., 27., 28., 29., 30.},
+ {31., 32., 33., 34., 35., 36.}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array3D<float, inChannels, outChannels, kernelSize[0]>(
+ {{{{0.1, 0.2, 0.3, 0.4, 0.5, 0.6},
+ {0.7, 0.8, 0.9, 1., 1.1, 1.2},
+ {1.3, 1.4, 1.5, 1.6, 1.7, 1.8},
+ {1.9, 2., 2.1, 2.2, 2.3, 2.4}},
+
+ {{2.5, 2.6, 2.7, 2.8, 2.9, 3.},
+ {3.1, 3.2, 3.3, 3.4, 3.5, 3.6},
+ {3.7, 3.8, 3.9, 4., 4.1, 4.2},
+ {4.3, 4.4, 4.5, 4.6, 4.7, 4.8}},
+
+ {{4.9, 5., 5.1, 5.2, 5.3, 5.4},
+ {5.5, 5.6, 5.7, 5.8, 5.9, 6.},
+ {6.1, 6.2, 6.3, 6.4, 6.5, 6.6},
+ {6.7, 6.8, 6.9, 7., 7.1, 7.2}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.01, 0.02, 0.03, 0.04}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array3D<float, batchSize, outChannels, outDataSize[0]>(
+ {{{{81.310005,
+ 172.210007,
+ 273.010010,
+ 384.010040,
+ 505.509979,
+ 637.810059,
+ 561.010010,
+ 472.809998,
+ 372.910004,
+ 261.010010,
+ 136.809998},
+ {93.919998,
+ 199.220001,
+ 316.219971,
+ 445.220001,
+ 586.520081,
+ 740.420044,
+ 651.020020,
+ 548.420044,
+ 432.319977,
+ 302.420013,
+ 158.419998},
+ {106.529999,
+ 226.230011,
+ 359.429993,
+ 506.430054,
+ 667.530090,
+ 843.030029,
+ 741.030029,
+ 624.030029,
+ 491.730042,
+ 343.829987,
+ 180.029999},
+ {119.140007,
+ 253.240005,
+ 402.640045,
+ 567.640076,
+ 748.539978,
+ 945.639954,
+ 831.039978,
+ 699.640015,
+ 551.140015,
+ 385.239990,
+ 201.639999}},
+
+ {{216.309998,
+ 447.610016,
+ 694.210022,
+ 956.410034,
+ 1234.510132,
+ 1528.810059,
+ 1317.010010,
+ 1088.410034,
+ 842.710022,
+ 579.610046,
+ 298.810028},
+ {261.319977,
+ 539.420044,
+ 834.619995,
+ 1147.220093,
+ 1477.520142,
+ 1825.820068,
+ 1569.019897,
+ 1293.619995,
+ 999.320068,
+ 685.820007,
+ 352.819977},
+ {306.329987,
+ 631.230042,
+ 975.030029,
+ 1338.030151,
+ 1720.530029,
+ 2122.829834,
+ 1821.029785,
+ 1498.830200,
+ 1155.930054,
+ 792.030029,
+ 406.830017},
+ {351.340027,
+ 723.039978,
+ 1115.440063,
+ 1528.840210,
+ 1963.539917,
+ 2419.839844,
+ 2073.040283,
+ 1704.040039,
+ 1312.540039,
+ 898.239990,
+ 460.840027}}}}));
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ }
+
+ SECTION("2D") {
+ constexpr DimSize_t DIM = 2;
+ SECTION("inChannels = 1, outChannels = 2, kernelSize = {1,2}, "
+ "inDataSize = {2,3}") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 1;
+ constexpr DimSize_t outChannels = 2;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{1, 2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{2, 3};
+ constexpr std::array<DimSize_t, DIM> outDataSize{2, 4};
+
+ constexpr std::array<DimSize_t, DIM> stride{1, 1};
+ constexpr std::array<DimSize_t, DIM> dilation{1, 1};
+
+ auto input = std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>(
+ {{{{{1.000000, 2.000000, 3.000000},
+ {4.000000, 5.000000, 6.000000}}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>({{{{{0.100000, 0.200000}},
+
+ {{0.300000, 0.400000}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput =
+ std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>(
+ {{{{{0.110000, 0.410000, 0.710000, 0.610000},
+ {0.410000, 1.310000, 1.610000, 1.210000}},
+
+ {{0.320000, 1.020000, 1.720000, 1.220000},
+ {1.220000, 3.120000, 3.820000, 2.420000}}}}}));
+ }
+ SECTION("inChannels = 1, outChannels = 2, kernelSize = {2,3}, "
+ "inDataSize = {2,3}") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 1;
+ constexpr DimSize_t outChannels = 2;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2, 3};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{2, 3};
+ constexpr std::array<DimSize_t, DIM> outDataSize{3, 5};
+
+ constexpr std::array<DimSize_t, DIM> stride{1, 1};
+ constexpr std::array<DimSize_t, DIM> dilation{1, 1};
+
+ auto input = std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>(
+ {{{{{1.000000, 2.000000, 3.000000},
+ {4.000000, 5.000000, 6.000000}}}}}));
+
+ auto weights = std::make_shared<Tensor>(Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>(
+ {{{{{0.100000, 0.200000, 0.300000},
+ {0.400000, 0.500000, 0.600000}},
+
+ {{0.700000, 0.800000, 0.900000},
+ {1.000000, 1.100000, 1.200000}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000, 0.020000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<
+ Tensor>(Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>(
+ {{{{{0.110000, 0.410000, 1.010000, 1.210000, 0.910000},
+ {0.810000, 2.610000, 5.610000, 5.410000, 3.610000},
+ {1.610000, 4.010000, 7.310000, 6.010000, 3.610000}},
+
+ {{0.720000, 2.220000, 4.620000, 4.220000, 2.720000},
+ {3.820000, 9.820001, 18.220001, 15.020000, 9.020000},
+ {4.020000, 9.420000, 16.320000, 12.620001, 7.220000}}}}}));
+ }
+ SECTION("inChannels = 1, outChannels = 2, kernelSize = {2,3}, "
+ "inDataSize = {6,6}, stride = {2, 2}, dilation = {2, 2}") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 1;
+ constexpr DimSize_t outChannels = 2;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2, 3};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4, 4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{9, 11};
+
+ constexpr std::array<DimSize_t, DIM> stride{2, 2};
+ constexpr std::array<DimSize_t, DIM> dilation{2, 2};
+
+ auto input = std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>(
+ {{{{{1.00, 2.00, 3.00, 4.000000},
+ {5.00, 6.00, 7.00, 8.000000},
+ {9.00, 10.00, 11.00, 12.000000},
+ {13.00, 14.00, 15.00, 16.000000}}}}}));
+
+ auto weights = std::make_shared<Tensor>(Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>(
+ {{{{{0.10, 0.20, 0.300000}, {0.40, 0.50, 0.600000}},
+
+ {{0.70, 0.80, 0.900000}, {1.00, 1.10, 1.200000}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.01, 0.020000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>({{{{{0.11,
+ 0.01,
+ 0.41,
+ 0.01,
+ 1.01,
+ 0.01,
+ 1.61,
+ 0.01,
+ 1.71,
+ 0.01,
+ 1.210000},
+ {0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.010000},
+ {0.91,
+ 0.01,
+ 2.91,
+ 0.01,
+ 6.210001,
+ 0.01,
+ 8.31,
+ 0.01,
+ 7.510001,
+ 0.01,
+ 4.810000},
+ {0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.010000},
+ {2.91,
+ 0.01,
+ 7.710001,
+ 0.01,
+ 14.610001,
+ 0.01,
+ 16.710001,
+ 0.01,
+ 13.910002,
+ 0.01,
+ 8.410001},
+ {0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.010000},
+ {4.91,
+ 0.01,
+ 12.51,
+ 0.01,
+ 23.01,
+ 0.01,
+ 25.110001,
+ 0.01,
+ 20.309999,
+ 0.01,
+ 12.010000},
+ {0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.01,
+ 0.010000},
+ {5.210001,
+ 0.01,
+ 12.110001,
+ 0.01,
+ 20.809999,
+ 0.01,
+ 22.309999,
+ 0.01,
+ 17.01,
+ 0.01,
+ 9.610001}},
+
+ {{0.72,
+ 0.02,
+ 2.22,
+ 0.02,
+ 4.62,
+ 0.02,
+ 7.02,
+ 0.02,
+ 5.92,
+ 0.02,
+ 3.620000},
+ {0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.020000},
+ {4.52,
+ 0.02,
+ 11.320001,
+ 0.02,
+ 20.620003,
+ 0.02,
+ 26.320002,
+ 0.02,
+ 20.720001,
+ 0.02,
+ 12.020000},
+ {0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.020000},
+ {11.32,
+ 0.02,
+ 25.720001,
+ 0.02,
+ 43.420002,
+ 0.02,
+ 49.120003,
+ 0.02,
+ 36.720001,
+ 0.02,
+ 20.420002},
+ {0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.020000},
+ {18.119999,
+ 0.02,
+ 40.120003,
+ 0.02,
+ 66.220001,
+ 0.02,
+ 71.919998,
+ 0.02,
+ 52.720001,
+ 0.02,
+ 28.820002},
+ {0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.02,
+ 0.020000},
+ {13.02,
+ 0.02,
+ 28.32,
+ 0.02,
+ 46.02,
+ 0.02,
+ 49.320004,
+ 0.02,
+ 35.619999,
+ 0.02,
+ 19.220001}}}}}));
+ }
+ SECTION("inChannels = 4, outChannels = 3, kernelSize = {2,2}, "
+ "inDataSize = {3,3}, stride = {2, 2}, dilation = {2, 2}") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 4;
+ constexpr DimSize_t outChannels = 3;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2, 2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{4, 4};
+ constexpr std::array<DimSize_t, DIM> outDataSize{7, 7};
+
+ constexpr std::array<DimSize_t, DIM> stride{2, 2};
+ constexpr std::array<DimSize_t, DIM> dilation{2, 2};
+
+ auto input = std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>(
+ {{{{{1.0, 2.0, 3.0}, {4.0, 5.0, 6.0}, {7.0, 8.0, 9.0}},
+
+ {{10.0, 11.0, 12.0},
+ {13.0, 14.0, 15.0},
+ {16.0, 17.0, 18.0}},
+
+ {{19.0, 20.0, 21.0},
+ {22.0, 23.0, 24.0},
+ {25.0, 26.0, 27.0}},
+
+ {{28.0, 29.0, 30.0},
+ {31.0, 32.0, 33.0},
+ {34.0, 35.0, 36.0}}}}}));
+
+ auto weights = std::make_shared<Tensor>(
+ Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>({{{{{0.1, 0.2}, {0.3, 0.4}},
+
+ {{0.5, 0.6}, {0.7, 0.8}},
+
+ {{0.9, 1.0}, {1.1, 1.2}}},
+
+ {{{1.3, 1.4}, {1.5, 1.6}},
+
+ {{1.7, 1.8}, {1.9, 2.0}},
+
+ {{2.1, 2.2}, {2.3, 2.4}}},
+
+ {{{2.5, 2.6}, {2.7, 2.8}},
+
+ {{2.9, 3.0}, {3.1, 3.2}},
+
+ {{3.3, 3.4}, {3.5, 3.6}}},
+
+ {{{3.7, 3.8}, {3.9, 4.0}},
+
+ {{4.1, 4.2}, {4.3, 4.4}},
+
+ {{4.5, 4.6}, {4.7, 4.8}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.010000, 0.020000, 0.030000}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>({{{{{164.209991,
+ 0.010000,
+ 341.809998,
+ 0.010000,
+ 357.410034,
+ 0.010000,
+ 186.009995},
+ {0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000},
+ {362.809998,
+ 0.010000,
+ 754.410034,
+ 0.010000,
+ 787.210083,
+ 0.010000,
+ 409.210022},
+ {0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000},
+ {410.809998,
+ 0.010000,
+ 852.810059,
+ 0.010000,
+ 885.609985,
+ 0.010000,
+ 459.610016},
+ {0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000,
+ 0.010000},
+ {226.209991,
+ 0.010000,
+ 469.010010,
+ 0.010000,
+ 486.210022,
+ 0.010000,
+ 252.009995}},
+
+ {{187.419998,
+ 0.020000,
+ 389.820007,
+ 0.020000,
+ 408.619995,
+ 0.020000,
+ 212.420013},
+ {0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000},
+ {414.019989,
+ 0.020000,
+ 860.020020,
+ 0.020000,
+ 899.220032,
+ 0.020000,
+ 466.820007},
+ {0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000},
+ {471.620026,
+ 0.020000,
+ 977.619995,
+ 0.020000,
+ 1016.820068,
+ 0.020000,
+ 526.820007},
+ {0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000,
+ 0.020000},
+ {259.019989,
+ 0.020000,
+ 536.220032,
+ 0.020000,
+ 556.619995,
+ 0.020000,
+ 288.019989}},
+
+ {{210.630005,
+ 0.030000,
+ 437.829987,
+ 0.030000,
+ 459.829987,
+ 0.030000,
+ 238.830002},
+ {0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000},
+ {465.230011,
+ 0.030000,
+ 965.630005,
+ 0.030000,
+ 1011.230103,
+ 0.030000,
+ 524.430054},
+ {0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000},
+ {532.430054,
+ 0.030000,
+ 1102.430054,
+ 0.030000,
+ 1148.030029,
+ 0.030000,
+ 594.030029},
+ {0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000,
+ 0.030000},
+ {291.830017,
+ 0.030000,
+ 603.430054,
+ 0.030000,
+ 627.030029,
+ 0.030000,
+ 324.029999}}}}}));
+ }
+ SECTION("Big test to ensure kernel capabilities 1") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 3;
+ constexpr DimSize_t outChannels = 4;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{2, 2};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{6, 5};
+ constexpr std::array<DimSize_t, DIM> outDataSize{8, 17};
+
+ constexpr std::array<DimSize_t, DIM> stride{1, 3};
+ constexpr std::array<DimSize_t, DIM> dilation{2, 4};
+
+ auto input = std::make_shared<Tensor>(
+ Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>({{{{{1., 2., 3., 4., 5.},
+ {6., 7., 8., 9., 10.},
+ {11., 12., 13., 14., 15.},
+ {16., 17., 18., 19., 20.},
+ {21., 22., 23., 24., 25.},
+ {26., 27., 28., 29., 30.}},
+
+ {{31., 32., 33., 34., 35.},
+ {36., 37., 38., 39., 40.},
+ {41., 42., 43., 44., 45.},
+ {46., 47., 48., 49., 50.},
+ {51., 52., 53., 54., 55.},
+ {56., 57., 58., 59., 60.}},
+
+ {{61., 62., 63., 64., 65.},
+ {66., 67., 68., 69., 70.},
+ {71., 72., 73., 74., 75.},
+ {76., 77., 78., 79., 80.},
+ {81., 82., 83., 84., 85.},
+ {86., 87., 88., 89., 90.}}}}}));
+
+ auto weights = std::make_shared<Tensor>(Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>(
+ {{{{{0.100000, 0.200000}, {0.300000, 0.400000}},
+
+ {{0.500000, 0.600000}, {0.700000, 0.800000}},
+
+ {{0.900000, 1.000000}, {1.100000, 1.200000}},
+
+ {{1.300000, 1.400000}, {1.500000, 1.600000}}},
+
+ {{{1.700000, 1.800000}, {1.900000, 2.000000}},
+
+ {{2.100000, 2.200000}, {2.300000, 2.400000}},
+
+ {{2.500000, 2.600000}, {2.700000, 2.800000}},
+
+ {{2.900000, 3.000000}, {3.100000, 3.200000}}},
+
+ {{{3.300000, 3.400000}, {3.500000, 3.600000}},
+
+ {{3.700000, 3.800000}, {3.900000, 4.000000}},
+
+ {{4.100000, 4.200000}, {4.300000, 4.400000}},
+
+ {{4.500000, 4.600000}, {4.700000, 4.800000}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.01, 0.02, 0.03, 0.04}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput = std::make_shared<Tensor>(
+ Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>({{{{{254.110001,
+ 0.010000,
+ 0.010000,
+ 259.210022,
+ 263.410034,
+ 0.010000,
+ 264.309998,
+ 268.810028,
+ 0.010000,
+ 269.410004,
+ 274.210022,
+ 0.010000,
+ 274.510010,
+ 279.610016,
+ 0.010000,
+ 0.010000,
+ 285.010010},
+ {279.610016,
+ 0.010000,
+ 0.010000,
+ 284.710022,
+ 290.410004,
+ 0.010000,
+ 289.809998,
+ 295.810028,
+ 0.010000,
+ 294.910004,
+ 301.210022,
+ 0.010000,
+ 300.010010,
+ 306.610016,
+ 0.010000,
+ 0.010000,
+ 312.010010},
+ {577.810059,
+ 0.010000,
+ 0.010000,
+ 588.609985,
+ 599.410034,
+ 0.010000,
+ 599.410034,
+ 610.810059,
+ 0.010000,
+ 610.209961,
+ 622.210022,
+ 0.010000,
+ 621.010010,
+ 633.609985,
+ 0.010000,
+ 0.010000,
+ 645.010010},
+ {631.810059,
+ 0.010000,
+ 0.010000,
+ 642.609985,
+ 656.410034,
+ 0.010000,
+ 653.410034,
+ 667.810059,
+ 0.010000,
+ 664.209961,
+ 679.210022,
+ 0.010000,
+ 675.010010,
+ 690.609985,
+ 0.010000,
+ 0.010000,
+ 702.010010},
+ {685.810059,
+ 0.010000,
+ 0.010000,
+ 696.609985,
+ 713.410034,
+ 0.010000,
+ 707.410034,
+ 724.810059,
+ 0.010000,
+ 718.209961,
+ 736.210022,
+ 0.010000,
+ 729.010010,
+ 747.609985,
+ 0.010000,
+ 0.010000,
+ 759.010010},
+ {739.810059,
+ 0.010000,
+ 0.010000,
+ 750.609985,
+ 770.410034,
+ 0.010000,
+ 761.410034,
+ 781.810059,
+ 0.010000,
+ 772.209961,
+ 793.210022,
+ 0.010000,
+ 783.010010,
+ 804.609985,
+ 0.010000,
+ 0.010000,
+ 816.010010},
+ {386.710022,
+ 0.010000,
+ 0.010000,
+ 392.410004,
+ 402.010010,
+ 0.010000,
+ 398.110016,
+ 408.010010,
+ 0.010000,
+ 403.809998,
+ 414.010010,
+ 0.010000,
+ 409.510010,
+ 420.010010,
+ 0.010000,
+ 0.010000,
+ 426.010010},
+ {415.210022,
+ 0.010000,
+ 0.010000,
+ 420.910004,
+ 432.010010,
+ 0.010000,
+ 426.610016,
+ 438.010040,
+ 0.010000,
+ 432.309998,
+ 444.010010,
+ 0.010000,
+ 438.010010,
+ 450.010040,
+ 0.010000,
+ 0.010000,
+ 456.010010}},
+
+ {{291.320007,
+ 0.020000,
+ 0.020000,
+ 297.619995,
+ 300.619995,
+ 0.020000,
+ 303.919983,
+ 307.219971,
+ 0.020000,
+ 310.220001,
+ 313.819977,
+ 0.020000,
+ 316.519989,
+ 320.419983,
+ 0.020000,
+ 0.020000,
+ 327.019989},
+ {322.820007,
+ 0.020000,
+ 0.020000,
+ 329.119995,
+ 333.619995,
+ 0.020000,
+ 335.419983,
+ 340.219971,
+ 0.020000,
+ 341.720001,
+ 346.819977,
+ 0.020000,
+ 348.019989,
+ 353.419983,
+ 0.020000,
+ 0.020000,
+ 360.019989},
+ {664.220032,
+ 0.020000,
+ 0.020000,
+ 677.420044,
+ 685.820068,
+ 0.020000,
+ 690.619995,
+ 699.619995,
+ 0.020000,
+ 703.820068,
+ 713.420044,
+ 0.020000,
+ 717.020020,
+ 727.219971,
+ 0.020000,
+ 0.020000,
+ 741.020020},
+ {730.220032,
+ 0.020000,
+ 0.020000,
+ 743.420044,
+ 754.820068,
+ 0.020000,
+ 756.619995,
+ 768.619995,
+ 0.020000,
+ 769.820068,
+ 782.420044,
+ 0.020000,
+ 783.020020,
+ 796.219971,
+ 0.020000,
+ 0.020000,
+ 810.020020},
+ {796.220032,
+ 0.020000,
+ 0.020000,
+ 809.420044,
+ 823.820068,
+ 0.020000,
+ 822.620056,
+ 837.619995,
+ 0.020000,
+ 835.820068,
+ 851.420044,
+ 0.020000,
+ 849.020020,
+ 865.219971,
+ 0.020000,
+ 0.020000,
+ 879.020020},
+ {862.220032,
+ 0.020000,
+ 0.020000,
+ 875.420044,
+ 892.820068,
+ 0.020000,
+ 888.619995,
+ 906.619995,
+ 0.020000,
+ 901.820068,
+ 920.420044,
+ 0.020000,
+ 915.020020,
+ 934.219971,
+ 0.020000,
+ 0.020000,
+ 948.020020},
+ {447.919983,
+ 0.020000,
+ 0.020000,
+ 454.820007,
+ 463.220001,
+ 0.020000,
+ 461.720001,
+ 470.420013,
+ 0.020000,
+ 468.619995,
+ 477.619995,
+ 0.020000,
+ 475.519989,
+ 484.819977,
+ 0.020000,
+ 0.020000,
+ 492.019989},
+ {482.419983,
+ 0.020000,
+ 0.020000,
+ 489.320007,
+ 499.220001,
+ 0.020000,
+ 496.220001,
+ 506.420013,
+ 0.020000,
+ 503.119995,
+ 513.619995,
+ 0.020000,
+ 510.019989,
+ 520.820007,
+ 0.020000,
+ 0.020000,
+ 528.020020}},
+
+ {{328.529999,
+ 0.030000,
+ 0.030000,
+ 336.029999,
+ 337.830017,
+ 0.030000,
+ 343.529999,
+ 345.630035,
+ 0.030000,
+ 351.029999,
+ 353.430023,
+ 0.030000,
+ 358.529999,
+ 361.230011,
+ 0.030000,
+ 0.030000,
+ 369.030029},
+ {366.029999,
+ 0.030000,
+ 0.030000,
+ 373.529999,
+ 376.830017,
+ 0.030000,
+ 381.029999,
+ 384.630035,
+ 0.030000,
+ 388.529999,
+ 392.430023,
+ 0.030000,
+ 396.029999,
+ 400.230042,
+ 0.030000,
+ 0.030000,
+ 408.030029},
+ {750.630005,
+ 0.030000,
+ 0.030000,
+ 766.230042,
+ 772.230042,
+ 0.030000,
+ 781.830078,
+ 788.430054,
+ 0.030000,
+ 797.430054,
+ 804.630066,
+ 0.030000,
+ 813.030029,
+ 820.830078,
+ 0.030000,
+ 0.030000,
+ 837.030029},
+ {828.630005,
+ 0.030000,
+ 0.030000,
+ 844.230042,
+ 853.230042,
+ 0.030000,
+ 859.830078,
+ 869.430054,
+ 0.030000,
+ 875.430054,
+ 885.630066,
+ 0.030000,
+ 891.030029,
+ 901.830078,
+ 0.030000,
+ 0.030000,
+ 918.030029},
+ {906.630005,
+ 0.030000,
+ 0.030000,
+ 922.230042,
+ 934.230042,
+ 0.030000,
+ 937.830078,
+ 950.430054,
+ 0.030000,
+ 953.430054,
+ 966.630066,
+ 0.030000,
+ 969.030029,
+ 982.830078,
+ 0.030000,
+ 0.030000,
+ 999.030090},
+ {984.630005,
+ 0.030000,
+ 0.030000,
+ 1000.230042,
+ 1015.230103,
+ 0.030000,
+ 1015.830078,
+ 1031.430054,
+ 0.030000,
+ 1031.430054,
+ 1047.630127,
+ 0.030000,
+ 1047.030029,
+ 1063.830078,
+ 0.030000,
+ 0.030000,
+ 1080.030029},
+ {509.130005,
+ 0.030000,
+ 0.030000,
+ 517.230042,
+ 524.430054,
+ 0.030000,
+ 525.330078,
+ 532.830017,
+ 0.030000,
+ 533.430054,
+ 541.230042,
+ 0.030000,
+ 541.530029,
+ 549.630066,
+ 0.030000,
+ 0.030000,
+ 558.030029},
+ {549.630066,
+ 0.030000,
+ 0.030000,
+ 557.730042,
+ 566.430054,
+ 0.030000,
+ 565.830078,
+ 574.830017,
+ 0.030000,
+ 573.930054,
+ 583.230042,
+ 0.030000,
+ 582.030029,
+ 591.630066,
+ 0.030000,
+ 0.030000,
+ 600.030029}},
+
+ {{365.740021,
+ 0.040000,
+ 0.040000,
+ 374.440002,
+ 375.040009,
+ 0.040000,
+ 383.140015,
+ 384.040009,
+ 0.040000,
+ 391.839996,
+ 393.040009,
+ 0.040000,
+ 400.540009,
+ 402.040009,
+ 0.040000,
+ 0.040000,
+ 411.040009},
+ {409.240021,
+ 0.040000,
+ 0.040000,
+ 417.940002,
+ 420.040009,
+ 0.040000,
+ 426.640015,
+ 429.040009,
+ 0.040000,
+ 435.339996,
+ 438.040009,
+ 0.040000,
+ 444.040009,
+ 447.040009,
+ 0.040000,
+ 0.040000,
+ 456.040009},
+ {837.039978,
+ 0.040000,
+ 0.040000,
+ 855.040039,
+ 858.639954,
+ 0.040000,
+ 873.039978,
+ 877.239990,
+ 0.040000,
+ 891.039978,
+ 895.840027,
+ 0.040000,
+ 909.039978,
+ 914.440002,
+ 0.040000,
+ 0.040000,
+ 933.039978},
+ {927.039978,
+ 0.040000,
+ 0.040000,
+ 945.040039,
+ 951.639954,
+ 0.040000,
+ 963.039978,
+ 970.239990,
+ 0.040000,
+ 981.039978,
+ 988.840027,
+ 0.040000,
+ 999.039978,
+ 1007.440002,
+ 0.040000,
+ 0.040000,
+ 1026.040039},
+ {1017.039978,
+ 0.040000,
+ 0.040000,
+ 1035.040039,
+ 1044.640015,
+ 0.040000,
+ 1053.040039,
+ 1063.239990,
+ 0.040000,
+ 1071.040039,
+ 1081.840088,
+ 0.040000,
+ 1089.040039,
+ 1100.440063,
+ 0.040000,
+ 0.040000,
+ 1119.040039},
+ {1107.040039,
+ 0.040000,
+ 0.040000,
+ 1125.040039,
+ 1137.640137,
+ 0.040000,
+ 1143.040039,
+ 1156.239990,
+ 0.040000,
+ 1161.040039,
+ 1174.840088,
+ 0.040000,
+ 1179.040039,
+ 1193.440063,
+ 0.040000,
+ 0.040000,
+ 1212.040039},
+ {570.340027,
+ 0.040000,
+ 0.040000,
+ 579.640015,
+ 585.640015,
+ 0.040000,
+ 588.940002,
+ 595.239990,
+ 0.040000,
+ 598.239990,
+ 604.840027,
+ 0.040000,
+ 607.540039,
+ 614.440002,
+ 0.040000,
+ 0.040000,
+ 624.039978},
+ {616.840027,
+ 0.040000,
+ 0.040000,
+ 626.140015,
+ 633.640015,
+ 0.040000,
+ 635.440002,
+ 643.239990,
+ 0.040000,
+ 644.739990,
+ 652.840027,
+ 0.040000,
+ 654.040039,
+ 662.440002,
+ 0.040000,
+ 0.040000,
+ 672.039978}}}}}));
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ SECTION("Big test to ensure kernel capabilities") {
+ constexpr DimSize_t batchSize = 1;
+ constexpr DimSize_t inChannels = 3;
+ constexpr DimSize_t outChannels = 4;
+
+ constexpr std::array<DimSize_t, DIM> kernelSize{6, 4};
+
+ constexpr std::array<DimSize_t, DIM> inDataSize{6, 5};
+ constexpr std::array<DimSize_t, DIM> outDataSize{16, 25};
+
+ constexpr std::array<DimSize_t, DIM> stride{1, 3};
+ constexpr std::array<DimSize_t, DIM> dilation{2, 4};
+
+ auto input = std::make_shared<Tensor>(
+ Array4D<float,
+ batchSize,
+ inChannels,
+ inDataSize[0],
+ inDataSize[1]>({{{{{1., 2., 3., 4., 5.},
+ {6., 7., 8., 9., 10.},
+ {11., 12., 13., 14., 15.},
+ {16., 17., 18., 19., 20.},
+ {21., 22., 23., 24., 25.},
+ {26., 27., 28., 29., 30.}},
+
+ {{31., 32., 33., 34., 35.},
+ {36., 37., 38., 39., 40.},
+ {41., 42., 43., 44., 45.},
+ {46., 47., 48., 49., 50.},
+ {51., 52., 53., 54., 55.},
+ {56., 57., 58., 59., 60.}},
+
+ {{61., 62., 63., 64., 65.},
+ {66., 67., 68., 69., 70.},
+ {71., 72., 73., 74., 75.},
+ {76., 77., 78., 79., 80.},
+ {81., 82., 83., 84., 85.},
+ {86., 87., 88., 89., 90.}}}}}));
+
+ auto weights = std::make_shared<Tensor>(Array4D<float,
+ inChannels,
+ outChannels,
+ kernelSize[0],
+ kernelSize[1]>(
+ {{{{{0.100000, 0.200000, 0.300000, 0.400000},
+ {0.500000, 0.600000, 0.700000, 0.800000},
+ {0.900000, 1.000000, 1.100000, 1.200000},
+ {1.300000, 1.400000, 1.500000, 1.600000},
+ {1.700000, 1.800000, 1.900000, 2.000000},
+ {2.100000, 2.200000, 2.300000, 2.400000}},
+
+ {{2.500000, 2.600000, 2.700000, 2.800000},
+ {2.900000, 3.000000, 3.100000, 3.200000},
+ {3.300000, 3.400000, 3.500000, 3.600000},
+ {3.700000, 3.800000, 3.900000, 4.000000},
+ {4.100000, 4.200000, 4.300000, 4.400000},
+ {4.500000, 4.600000, 4.700000, 4.800000}},
+
+ {{4.900000, 5.000000, 5.100000, 5.200000},
+ {5.300000, 5.400000, 5.500000, 5.600000},
+ {5.700000, 5.800000, 5.900000, 6.000000},
+ {6.100000, 6.200000, 6.300000, 6.400000},
+ {6.500000, 6.600000, 6.700000, 6.800000},
+ {6.900000, 7.000000, 7.100000, 7.200000}},
+
+ {{7.300000, 7.400000, 7.500000, 7.600000},
+ {7.700000, 7.800000, 7.900000, 8.000000},
+ {8.100000, 8.200000, 8.300000, 8.400001},
+ {8.500000, 8.600000, 8.700000, 8.800000},
+ {8.900001, 9.000000, 9.100000, 9.200000},
+ {9.300000, 9.400001, 9.500000, 9.600000}}},
+
+ {{{9.700000, 9.800000, 9.900001, 10.000000},
+ {10.100000, 10.200000, 10.300000, 10.400001},
+ {10.500000, 10.600000, 10.700000, 10.800000},
+ {10.900001, 11.000000, 11.100000, 11.200000},
+ {11.300000, 11.400001, 11.500000, 11.600000},
+ {11.700000, 11.800000, 11.900001, 12.000000}},
+
+ {{12.100000, 12.200000, 12.300000, 12.400001},
+ {12.500000, 12.600000, 12.700000, 12.800000},
+ {12.900001, 13.000000, 13.100000, 13.200000},
+ {13.300000, 13.400001, 13.500000, 13.600000},
+ {13.700000, 13.800000, 13.900001, 14.000000},
+ {14.100000, 14.200000, 14.300000, 14.400001}},
+
+ {{14.500000, 14.600000, 14.700000, 14.800000},
+ {14.900001, 15.000000, 15.100000, 15.200000},
+ {15.300000, 15.400001, 15.500000, 15.600000},
+ {15.700000, 15.800000, 15.900001, 16.000000},
+ {16.100000, 16.200001, 16.300001, 16.400000},
+ {16.500000, 16.600000, 16.700001, 16.800001}},
+
+ {{16.900000, 17.000000, 17.100000, 17.200001},
+ {17.300001, 17.400000, 17.500000, 17.600000},
+ {17.700001, 17.800001, 17.900000, 18.000000},
+ {18.100000, 18.200001, 18.300001, 18.400000},
+ {18.500000, 18.600000, 18.700001, 18.800001},
+ {18.900000, 19.000000, 19.100000, 19.200001}}},
+
+ {{{19.300001, 19.400000, 19.500000, 19.600000},
+ {19.700001, 19.800001, 19.900000, 20.000000},
+ {20.100000, 20.200001, 20.300001, 20.400000},
+ {20.500000, 20.600000, 20.700001, 20.800001},
+ {20.900000, 21.000000, 21.100000, 21.200001},
+ {21.300001, 21.400000, 21.500000, 21.600000}},
+
+ {{21.700001, 21.800001, 21.900000, 22.000000},
+ {22.100000, 22.200001, 22.300001, 22.400000},
+ {22.500000, 22.600000, 22.700001, 22.800001},
+ {22.900000, 23.000000, 23.100000, 23.200001},
+ {23.300001, 23.400000, 23.500000, 23.600000},
+ {23.700001, 23.800001, 23.900000, 24.000000}},
+
+ {{24.100000, 24.200001, 24.300001, 24.400000},
+ {24.500000, 24.600000, 24.700001, 24.800001},
+ {24.900000, 25.000000, 25.100000, 25.200001},
+ {25.300001, 25.400000, 25.500000, 25.600000},
+ {25.700001, 25.800001, 25.900000, 26.000000},
+ {26.100000, 26.200001, 26.300001, 26.400000}},
+
+ {{26.500000, 26.600000, 26.700001, 26.800001},
+ {26.900000, 27.000000, 27.100000, 27.200001},
+ {27.300001, 27.400000, 27.500000, 27.600000},
+ {27.700001, 27.800001, 27.900000, 28.000000},
+ {28.100000, 28.200001, 28.300001, 28.400000},
+ {28.500000, 28.600000, 28.700001, 28.800001}}}}}));
+
+ auto biases = std::make_shared<Tensor>(
+ Array1D<float, outChannels>({{0.01, 0.02, 0.03, 0.04}}));
+
+ auto op = setupTestConvTranspose<DIM>(batchSize,
+ inChannels,
+ outChannels,
+ kernelSize,
+ inDataSize,
+ stride,
+ dilation,
+ input,
+ weights,
+ biases);
+
+ REQUIRE_NOTHROW(op->forward());
+
+ auto expectedOutput =
+ std::make_shared<Tensor>(Array4D<float,
+ batchSize,
+ outChannels,
+ outDataSize[0],
+ outDataSize[1]>(
+ {{{{{1478.110107, 0.010000, 0.010000, 1507.210083,
+ 1487.410034, 0.010000, 1536.310059, 1516.809937,
+ 1496.709961, 1565.410034, 1546.209961, 1526.410034,
+ 3100.510010, 1575.609985, 1556.109985, 1536.010010,
+ 1605.010010, 1585.810059, 1566.010010, 0.010000,
+ 1615.510010, 1596.010010, 0.010000, 0.010000,
+ 1626.010010},
+ {1623.610107, 0.010000, 0.010000, 1652.710083,
+ 1634.410034, 0.010000, 1681.810059, 1663.809937,
+ 1645.209961, 1710.910034, 1693.209961, 1674.910034,
+ 3396.010010, 1722.609985, 1704.610107, 1686.010010,
+ 1752.010010, 1734.310059, 1716.010010, 0.010000,
+ 1764.010010, 1746.010010, 0.010000, 0.010000,
+ 1776.010010},
+ {3284.410156, 0.010000, 0.010000, 3343.810303,
+ 3306.010010, 0.010000, 3403.210205, 3366.010010,
+ 3327.610107, 3462.610107, 3426.010010, 3388.209961,
+ 6871.209961, 3486.010010, 3448.810059, 3410.409912,
+ 3546.010010, 3509.409912, 3471.610107, 0.010000,
+ 3570.010010, 3532.810059, 0.010000, 0.010000,
+ 3594.010010},
+ {3581.410156, 0.010000, 0.010000, 3640.810303,
+ 3606.010010, 0.010000, 3700.210205, 3666.010010,
+ 3630.610107, 3759.610107, 3726.010010, 3691.209961,
+ 7474.209961, 3786.010010, 3751.810059, 3716.409912,
+ 3846.010010, 3812.409912, 3777.610107, 0.010000,
+ 3873.010010, 3838.810059, 0.010000, 0.010000,
+ 3900.010010},
+ {5430.910156, 0.010000, 0.010000, 5521.809570,
+ 5467.809570, 0.010000, 5612.709961, 5559.609863,
+ 5504.709961, 5703.609863, 5651.409668, 5597.409668,
+ 11336.110352, 5743.209961, 5690.109863, 5635.209473,
+ 5835.009766, 5782.809570, 5728.809570, 0.010000,
+ 5875.509766, 5822.409668, 0.010000, 0.010000,
+ 5916.009766},
+ {5885.410156, 0.010000, 0.010000, 5976.310059,
+ 5926.809570, 0.010000, 6067.209961, 6018.609863,
+ 5968.209961, 6158.110352, 6110.409668, 6060.909668,
+ 12258.610352, 6202.209961, 6153.609375, 6103.209473,
+ 6294.009766, 6246.309570, 6196.809570, 0.010000,
+ 6339.009766, 6290.409668, 0.010000, 0.010000,
+ 6384.009766},
+ {5578.509766, 0.010000, 0.010000, 5673.009766,
+ 5615.410156, 0.010000, 5767.510254, 5710.809570,
+ 5652.309570, 5862.009766, 5806.209961, 5748.609863,
+ 11645.710938, 5901.609863, 5844.909668, 5786.409668,
+ 5997.009766, 5941.209961, 5883.609375, 0.010000,
+ 6037.509766, 5980.809570, 0.010000, 0.010000,
+ 6078.009766},
+ {6051.009766, 0.010000, 0.010000, 6145.509766,
+ 6092.410156, 0.010000, 6240.010254, 6187.810059,
+ 6133.809570, 6334.509766, 6283.209961, 6230.109863,
+ 12604.208984, 6378.610352, 6326.409668, 6272.410156,
+ 6474.009766, 6422.709961, 6369.609375, 0.010000,
+ 6519.009766, 6466.809570, 0.010000, 0.010000,
+ 6564.009766},
+ {5726.109863, 0.010000, 0.010000, 5824.209473,
+ 5763.009766, 0.010000, 5922.309570, 5862.009766,
+ 5799.910156, 6020.409668, 5961.010254, 5899.809570,
+ 11955.309570, 6060.009766, 5999.709961, 5937.609863,
+ 6159.009766, 6099.609863, 6038.409668, 0.010000,
+ 6199.509766, 6139.209961, 0.010000, 0.010000,
+ 6240.009766},
+ {6216.609863, 0.010000, 0.010000, 6314.709473,
+ 6258.009766, 0.010000, 6412.809570, 6357.009766,
+ 6299.410156, 6510.909668, 6456.010254, 6399.310059,
+ 12949.809570, 6555.009766, 6499.209961, 6441.609863,
+ 6654.009766, 6599.110352, 6542.409668, 0.010000,
+ 6699.009766, 6643.209961, 0.010000, 0.010000,
+ 6744.009766},
+ {5873.709961, 0.010000, 0.010000, 5975.409668,
+ 5910.609863, 0.010000, 6077.109375, 6013.209473,
+ 5947.509766, 6178.809570, 6115.809570, 6051.009766,
+ 12264.910156, 6218.409668, 6154.510254, 6088.809570,
+ 6321.009766, 6258.009766, 6193.209961, 0.010000,
+ 6361.509766, 6297.610352, 0.010000, 0.010000,
+ 6402.009766},
+ {6382.209473, 0.010000, 0.010000, 6483.910156,
+ 6423.609863, 0.010000, 6585.609375, 6526.209473,
+ 6465.009766, 6687.309570, 6628.809570, 6568.509766,
+ 13295.410156, 6731.409668, 6672.010254, 6610.810059,
+ 6834.009766, 6775.509766, 6715.209961, 0.010000,
+ 6879.009766, 6819.610352, 0.010000, 0.010000,
+ 6924.009766},
+ {4320.009766, 0.010000, 0.010000, 4389.009766,
+ 4347.609863, 0.010000, 4458.009766, 4417.209961,
+ 4375.209961, 4527.009766, 4486.809570, 4445.409668,
+ 8998.809570, 4556.409668, 4515.609863, 4473.609863,
+ 4626.009766, 4585.809570, 4544.410156, 0.010000,
+ 4656.009766, 4615.209961, 0.010000, 0.010000,
+ 4686.009766},
+ {4665.009766, 0.010000, 0.010000, 4734.009766,
+ 4695.609375, 0.010000, 4803.009766, 4765.209961,
+ 4726.209961, 4872.009766, 4834.809570, 4796.409668,
+ 9697.809570, 4904.409668, 4866.609863, 4827.609863,
+ 4974.009766, 4936.809570, 4898.410156, 0.010000,
+ 5007.009766, 4969.209961, 0.010000, 0.010000,
+ 5040.009766},
+ {2366.110107, 0.010000, 0.010000, 2401.209961,
+ 2381.409912, 0.010000, 2436.310059, 2416.810059,
+ 2396.709961, 2471.410156, 2452.209961, 2432.409912,
+ 4918.509766, 2487.609863, 2468.110107, 2448.010010,
+ 2523.010010, 2503.810059, 2484.010010, 0.010000,
+ 2539.510010, 2520.010010, 0.010000, 0.010000,
+ 2556.010010},
+ {2541.610107, 0.010000, 0.010000, 2576.710205,
+ 2558.409912, 0.010000, 2611.810059, 2593.810059,
+ 2575.209961, 2646.910156, 2629.209961, 2610.909912,
+ 5274.009766, 2664.609863, 2646.610107, 2628.010010,
+ 2700.010010, 2682.310059, 2664.010010, 0.010000,
+ 2718.010010, 2700.010010, 0.010000, 0.010000,
+ 2736.010010}},
+
+ {{1701.320068, 0.020000, 0.020000, 1737.620117,
+ 1710.620117, 0.020000, 1773.920044, 1747.220093,
+ 1719.920044, 1810.220093, 1783.820068, 1756.819946,
+ 3575.719971, 1820.420044, 1793.719971, 1766.420044,
+ 1857.020142, 1830.619995, 1803.619995, 0.020000,
+ 1867.520020, 1840.820068, 0.020000, 0.020000,
+ 1878.020020},
+ {1882.820068, 0.020000, 0.020000, 1919.120117,
+ 1893.620117, 0.020000, 1955.420044, 1930.220093,
+ 1904.420044, 1991.720093, 1966.820068, 1941.319946,
+ 3943.219971, 2003.420044, 1978.219971, 1952.420044,
+ 2040.020142, 2015.119995, 1989.620117, 0.020000,
+ 2052.020020, 2026.820068, 0.020000, 0.020000,
+ 2064.020020},
+ {3802.820068, 0.020000, 0.020000, 3876.620117,
+ 3824.420166, 0.020000, 3950.420166, 3898.820068,
+ 3846.020020, 4024.220215, 3973.220215, 3921.020020,
+ 7965.620117, 4047.620117, 3996.020020, 3943.219727,
+ 4122.020020, 4071.020020, 4018.820068, 0.020000,
+ 4146.020020, 4094.419922, 0.020000, 0.020000,
+ 4170.020020},
+ {4171.819824, 0.020000, 0.020000, 4245.620117,
+ 4196.420410, 0.020000, 4319.420410, 4270.819824,
+ 4221.020020, 4393.220215, 4345.220215, 4296.020020,
+ 8712.620117, 4419.620605, 4371.020020, 4321.219727,
+ 4494.020020, 4446.020020, 4396.819824, 0.020000,
+ 4521.020020, 4472.419922, 0.020000, 0.020000,
+ 4548.020020},
+ {6316.520020, 0.020000, 0.020000, 6429.020020,
+ 6353.420410, 0.020000, 6541.520508, 6466.819824,
+ 6390.319824, 6654.020020, 6580.220215, 6504.620117,
+ 13193.718750, 6693.620605, 6618.919922, 6542.420410,
+ 6807.020020, 6733.220215, 6657.619629, 0.020000,
+ 6847.520020, 6772.819824, 0.020000, 0.020000,
+ 6888.020020},
+ {6879.020020, 0.020000, 0.020000, 6991.520020,
+ 6920.420410, 0.020000, 7104.020508, 7033.820312,
+ 6961.819824, 7216.520020, 7147.220215, 7076.120117,
+ 14332.218750, 7260.620605, 7190.420410, 7118.420410,
+ 7374.020020, 7304.720215, 7233.619629, 0.020000,
+ 7419.020020, 7348.819824, 0.020000, 0.020000,
+ 7464.020020},
+ {6464.120117, 0.020000, 0.020000, 6580.219727,
+ 6501.020020, 0.020000, 6696.319824, 6618.020020,
+ 6537.920410, 6812.419922, 6735.020508, 6655.819824,
+ 13503.319336, 6852.020020, 6773.720215, 6693.620117,
+ 6969.020020, 6891.620605, 6812.419922, 0.020000,
+ 7009.520020, 6931.220215, 0.020000, 0.020000,
+ 7050.020020},
+ {7044.620117, 0.020000, 0.020000, 7160.720215,
+ 7086.020020, 0.020000, 7276.819824, 7203.020020,
+ 7127.420410, 7392.919434, 7320.020508, 7245.320312,
+ 14677.819336, 7437.020020, 7363.220215, 7287.620117,
+ 7554.020020, 7481.120605, 7406.420410, 0.020000,
+ 7599.020020, 7525.220215, 0.020000, 0.020000,
+ 7644.020020},
+ {6611.719727, 0.020000, 0.020000, 6731.420410,
+ 6648.620117, 0.020000, 6851.119629, 6769.219727,
+ 6685.520020, 6970.819824, 6889.819824, 6807.020020,
+ 13812.919922, 7010.419922, 6928.520508, 6844.819824,
+ 7131.020020, 7050.020020, 6967.220215, 0.020000,
+ 7171.520020, 7089.620605, 0.020000, 0.020000,
+ 7212.020020},
+ {7210.219727, 0.020000, 0.020000, 7329.920410,
+ 7251.620117, 0.020000, 7449.619629, 7372.220215,
+ 7293.020020, 7569.319824, 7492.819824, 7414.520020,
+ 15023.418945, 7613.419434, 7536.020508, 7456.820312,
+ 7734.020020, 7657.520020, 7579.220215, 0.020000,
+ 7779.020020, 7701.620605, 0.020000, 0.020000,
+ 7824.020020},
+ {6759.319824, 0.020000, 0.020000, 6882.620117,
+ 6796.219727, 0.020000, 7005.919922, 6920.420410,
+ 6833.120117, 7129.220215, 7044.619629, 6958.219727,
+ 14122.519531, 7168.819824, 7083.319824, 6996.020020,
+ 7293.020020, 7208.419922, 7122.020508, 0.020000,
+ 7333.520020, 7248.020020, 0.020000, 0.020000,
+ 7374.020020},
+ {7375.819824, 0.020000, 0.020000, 7499.120117,
+ 7417.219727, 0.020000, 7622.420410, 7541.420410,
+ 7458.620117, 7745.720215, 7665.619629, 7583.720215,
+ 15369.019531, 7789.819824, 7708.819824, 7626.020020,
+ 7914.020020, 7833.919434, 7752.020508, 0.020000,
+ 7959.020020, 7878.020020, 0.020000, 0.020000,
+ 8004.020020},
+ {4982.420410, 0.020000, 0.020000, 5065.819824,
+ 5010.020020, 0.020000, 5149.220215, 5094.020020,
+ 5037.619629, 5232.620605, 5178.020020, 5122.220215,
+ 10381.219727, 5262.020020, 5206.819824, 5150.419922,
+ 5346.020020, 5291.419922, 5235.620117, 0.020000,
+ 5376.020020, 5320.819824, 0.020000, 0.020000,
+ 5406.020020},
+ {5399.420410, 0.020000, 0.020000, 5482.820312,
+ 5430.020020, 0.020000, 5566.220215, 5514.020020,
+ 5460.619629, 5649.620605, 5598.020020, 5545.220215,
+ 11224.219727, 5682.020020, 5629.819824, 5576.419922,
+ 5766.020020, 5714.419922, 5661.620117, 0.020000,
+ 5799.020020, 5746.819824, 0.020000, 0.020000,
+ 5832.020020},
+ {2733.320068, 0.020000, 0.020000, 2775.620117,
+ 2748.620117, 0.020000, 2817.920166, 2791.219971,
+ 2763.919922, 2860.220215, 2833.820068, 2806.820068,
+ 5681.720215, 2876.420166, 2849.719971, 2822.419922,
+ 2919.020020, 2892.619873, 2865.620117, 0.020000,
+ 2935.520020, 2908.820068, 0.020000, 0.020000,
+ 2952.020020},
+ {2944.820068, 0.020000, 0.020000, 2987.120117,
+ 2961.620117, 0.020000, 3029.420166, 3004.220215,
+ 2978.419922, 3071.720215, 3046.820068, 3021.320068,
+ 6109.220215, 3089.420166, 3064.219971, 3038.419922,
+ 3132.020020, 3107.119873, 3081.620117, 0.020000,
+ 3150.020020, 3124.820068, 0.020000, 0.020000,
+ 3168.020020}},
+
+ {{1924.530029, 0.030000, 0.030000, 1968.030029,
+ 1933.830078, 0.030000, 2011.530029, 1977.630127,
+ 1943.130127, 2055.030029, 2021.430054, 1987.230103,
+ 4050.929932, 2065.230225, 2031.330078, 1996.829956,
+ 2109.030029, 2075.430176, 2041.229980, 0.030000,
+ 2119.530029, 2085.630127, 0.030000, 0.030000,
+ 2130.030029},
+ {2142.030029, 0.030000, 0.030000, 2185.530029,
+ 2152.830078, 0.030000, 2229.030029, 2196.630127,
+ 2163.630127, 2272.530029, 2240.430176, 2207.729980,
+ 4490.429688, 2284.230225, 2251.830078, 2218.830078,
+ 2328.030029, 2295.930176, 2263.229980, 0.030000,
+ 2340.030029, 2307.629883, 0.030000, 0.030000,
+ 2352.030029},
+ {4321.229980, 0.030000, 0.030000, 4409.429688,
+ 4342.829590, 0.030000, 4497.629883, 4431.629883,
+ 4364.430176, 4585.829590, 4520.430176, 4453.829590,
+ 9060.030273, 4609.229980, 4543.229980, 4476.029785,
+ 4698.029785, 4632.630371, 4566.029785, 0.030000,
+ 4722.029785, 4656.029785, 0.030000, 0.030000,
+ 4746.029785},
+ {4762.229980, 0.030000, 0.030000, 4850.429688,
+ 4786.829590, 0.030000, 4938.629883, 4875.629883,
+ 4811.430176, 5026.829590, 4964.430176, 4900.829590,
+ 9951.030273, 5053.229980, 4990.229980, 4926.029785,
+ 5142.029785, 5079.630371, 5016.029785, 0.030000,
+ 5169.029785, 5106.029785, 0.030000, 0.030000,
+ 5196.029785},
+ {7202.129883, 0.030000, 0.030000, 7336.229492,
+ 7239.029785, 0.030000, 7470.329590, 7374.029785,
+ 7275.930176, 7604.429688, 7509.030273, 7411.829590,
+ 15051.330078, 7644.029785, 7547.729980, 7449.629883,
+ 7779.029785, 7683.630371, 7586.430176, 0.030000,
+ 7819.529785, 7723.229980, 0.030000, 0.030000,
+ 7860.029785},
+ {7872.629883, 0.030000, 0.030000, 8006.729980,
+ 7914.029785, 0.030000, 8140.829590, 8049.029785,
+ 7955.430176, 8274.929688, 8184.030273, 8091.330078,
+ 16405.830078, 8319.030273, 8227.230469, 8133.629883,
+ 8454.030273, 8363.130859, 8270.430664, 0.030000,
+ 8499.030273, 8407.230469, 0.030000, 0.030000,
+ 8544.030273},
+ {7349.729492, 0.030000, 0.030000, 7487.430176,
+ 7386.629883, 0.030000, 7625.129395, 7525.229980,
+ 7423.529785, 7762.829590, 7663.829590, 7563.029785,
+ 15360.929688, 7802.429688, 7702.530273, 7600.829590,
+ 7941.029785, 7842.029785, 7741.229980, 0.030000,
+ 7981.529785, 7881.630371, 0.030000, 0.030000,
+ 8022.029785},
+ {8038.229492, 0.030000, 0.030000, 8175.930176,
+ 8079.629883, 0.030000, 8313.629883, 8218.230469,
+ 8121.029785, 8451.330078, 8356.830078, 8260.530273,
+ 16751.427734, 8495.429688, 8400.030273, 8302.831055,
+ 8634.030273, 8539.530273, 8443.230469, 0.030000,
+ 8679.030273, 8583.630859, 0.030000, 0.030000,
+ 8724.030273},
+ {7497.329590, 0.030000, 0.030000, 7638.629883,
+ 7534.229492, 0.030000, 7779.930176, 7676.430176,
+ 7571.130371, 7921.229980, 7818.629395, 7714.229980,
+ 15670.530273, 7960.829590, 7857.329590, 7752.029785,
+ 8103.029785, 8000.429688, 7896.030273, 0.030000,
+ 8143.529785, 8040.029785, 0.030000, 0.030000,
+ 8184.029785},
+ {8203.830078, 0.030000, 0.030000, 8345.129883,
+ 8245.229492, 0.030000, 8486.430664, 8387.430664,
+ 8286.630859, 8627.730469, 8529.629883, 8429.730469,
+ 17097.029297, 8671.830078, 8572.830078, 8472.030273,
+ 8814.030273, 8715.930664, 8616.030273, 0.030000,
+ 8859.030273, 8760.030273, 0.030000, 0.030000,
+ 8904.030273},
+ {7644.930176, 0.030000, 0.030000, 7789.829590,
+ 7681.829590, 0.030000, 7934.729980, 7827.629883,
+ 7718.729980, 8079.630371, 7973.430176, 7865.430176,
+ 15980.130859, 8119.229980, 8012.129395, 7903.229980,
+ 8265.030273, 8158.830566, 8050.829590, 0.030000,
+ 8305.530273, 8198.430664, 0.030000, 0.030000,
+ 8346.030273},
+ {8369.430664, 0.030000, 0.030000, 8514.331055,
+ 8410.830078, 0.030000, 8659.230469, 8556.629883,
+ 8452.231445, 8804.130859, 8702.430664, 8598.930664,
+ 17442.628906, 8848.230469, 8745.629883, 8641.230469,
+ 8994.030273, 8892.331055, 8788.830078, 0.030000,
+ 9039.030273, 8936.430664, 0.030000, 0.030000,
+ 9084.030273},
+ {5644.829590, 0.030000, 0.030000, 5742.629883,
+ 5672.430176, 0.030000, 5840.430176, 5770.830078,
+ 5700.029785, 5938.229980, 5869.229980, 5799.029785,
+ 11763.630859, 5967.630371, 5898.029785, 5827.229980,
+ 6066.029785, 5997.029785, 5926.829590, 0.030000,
+ 6096.029785, 6026.430176, 0.030000, 0.030000,
+ 6126.029785},
+ {6133.829590, 0.030000, 0.030000, 6231.629883,
+ 6164.430176, 0.030000, 6329.430176, 6262.830078,
+ 6195.029785, 6427.229980, 6361.229980, 6294.029785,
+ 12750.630859, 6459.630371, 6393.029785, 6325.229980,
+ 6558.029785, 6492.029785, 6424.829590, 0.030000,
+ 6591.029785, 6524.430176, 0.030000, 0.030000,
+ 6624.029785},
+ {3100.530029, 0.030000, 0.030000, 3150.030029,
+ 3115.830078, 0.030000, 3199.530029, 3165.630127,
+ 3131.130127, 3249.030029, 3215.430176, 3181.230225,
+ 6444.930176, 3265.230225, 3231.330078, 3196.830078,
+ 3315.030029, 3281.430176, 3247.230225, 0.030000,
+ 3331.530029, 3297.630127, 0.030000, 0.030000,
+ 3348.030029},
+ {3348.030029, 0.030000, 0.030000, 3397.530029,
+ 3364.830078, 0.030000, 3447.030029, 3414.630127,
+ 3381.630127, 3496.530029, 3464.430176, 3431.730225,
+ 6944.430176, 3514.230225, 3481.830078, 3448.830078,
+ 3564.030029, 3531.930176, 3499.230225, 0.030000,
+ 3582.030029, 3549.630127, 0.030000, 0.030000,
+ 3600.030029}},
+
+ {{2147.739990, 0.040000, 0.040000, 2198.439941,
+ 2157.040039, 0.040000, 2249.140137, 2208.040039,
+ 2166.340088, 2299.840088, 2259.040039, 2217.640137,
+ 4526.140137, 2310.040039, 2268.940186, 2227.240234,
+ 2361.040039, 2320.240234, 2278.840088, 0.040000,
+ 2371.540039, 2330.440186, 0.040000, 0.040000,
+ 2382.040039},
+ {2401.239990, 0.040000, 0.040000, 2451.939941,
+ 2412.040039, 0.040000, 2502.640137, 2463.040039,
+ 2422.840088, 2553.340088, 2514.040039, 2474.140137,
+ 5037.640137, 2565.040039, 2525.440186, 2485.240234,
+ 2616.040039, 2576.740234, 2536.840088, 0.040000,
+ 2628.040039, 2588.440186, 0.040000, 0.040000,
+ 2640.040039},
+ {4839.640137, 0.040000, 0.040000, 4942.240234,
+ 4861.240234, 0.040000, 5044.839844, 4964.439941,
+ 4882.839844, 5147.440430, 5067.640137, 4986.640137,
+ 10154.440430, 5170.839844, 5090.440430, 5008.840332,
+ 5274.040039, 5194.240234, 5113.240234, 0.040000,
+ 5298.040039, 5217.640625, 0.040000, 0.040000,
+ 5322.040039},
+ {5352.640137, 0.040000, 0.040000, 5455.240234,
+ 5377.240234, 0.040000, 5557.839844, 5480.439941,
+ 5401.839844, 5660.440430, 5583.640137, 5505.640137,
+ 11189.439453, 5686.839844, 5609.440430, 5530.840332,
+ 5790.040039, 5713.240234, 5635.240234, 0.040000,
+ 5817.040039, 5739.640625, 0.040000, 0.040000,
+ 5844.040039},
+ {8087.740234, 0.040000, 0.040000, 8243.440430,
+ 8124.640625, 0.040000, 8399.139648, 8281.240234,
+ 8161.540039, 8554.840820, 8437.839844, 8319.040039,
+ 16908.937500, 8594.440430, 8476.540039, 8356.840820,
+ 8751.040039, 8634.040039, 8515.240234, 0.040000,
+ 8791.540039, 8673.640625, 0.040000, 0.040000,
+ 8832.040039},
+ {8866.240234, 0.040000, 0.040000, 9021.940430,
+ 8907.640625, 0.040000, 9177.639648, 9064.240234,
+ 8949.040039, 9333.340820, 9220.839844, 9106.540039,
+ 18479.437500, 9377.440430, 9264.040039, 9148.840820,
+ 9534.040039, 9421.540039, 9307.240234, 0.040000,
+ 9579.040039, 9465.640625, 0.040000, 0.040000,
+ 9624.040039},
+ {8235.339844, 0.040000, 0.040000, 8394.639648,
+ 8272.240234, 0.040000, 8553.940430, 8432.440430,
+ 8309.140625, 8713.240234, 8592.639648, 8470.240234,
+ 17218.539062, 8752.840820, 8631.339844, 8508.040039,
+ 8913.040039, 8792.440430, 8670.040039, 0.040000,
+ 8953.540039, 8832.040039, 0.040000, 0.040000,
+ 8994.040039},
+ {9031.839844, 0.040000, 0.040000, 9191.139648,
+ 9073.240234, 0.040000, 9350.440430, 9233.440430,
+ 9114.640625, 9509.740234, 9393.639648, 9275.740234,
+ 18825.039062, 9553.839844, 9436.839844, 9318.040039,
+ 9714.040039, 9597.940430, 9480.040039, 0.040000,
+ 9759.040039, 9642.040039, 0.040000, 0.040000,
+ 9804.040039},
+ {8382.940430, 0.040000, 0.040000, 8545.840820,
+ 8419.839844, 0.040000, 8708.740234, 8583.639648,
+ 8456.740234, 8871.640625, 8747.440430, 8621.440430,
+ 17528.138672, 8911.240234, 8786.139648, 8659.240234,
+ 9075.040039, 8950.840820, 8824.839844, 0.040000,
+ 9115.540039, 8990.440430, 0.040000, 0.040000,
+ 9156.040039},
+ {9197.440430, 0.040000, 0.040000, 9360.340820,
+ 9238.839844, 0.040000, 9523.240234, 9402.639648,
+ 9280.240234, 9686.140625, 9566.440430, 9444.940430,
+ 19170.638672, 9730.240234, 9609.639648, 9487.240234,
+ 9894.040039, 9774.339844, 9652.839844, 0.040000,
+ 9939.040039, 9818.440430, 0.040000, 0.040000,
+ 9984.040039},
+ {8530.540039, 0.040000, 0.040000, 8697.040039,
+ 8567.440430, 0.040000, 8863.540039, 8734.840820,
+ 8604.339844, 9030.040039, 8902.240234, 8772.639648,
+ 17837.740234, 9069.640625, 8940.940430, 8810.440430,
+ 9237.040039, 9109.240234, 8979.639648, 0.040000,
+ 9277.540039, 9148.840820, 0.040000, 0.040000,
+ 9318.040039},
+ {9363.040039, 0.040000, 0.040000, 9529.540039,
+ 9404.440430, 0.040000, 9696.040039, 9571.840820,
+ 9445.839844, 9862.540039, 9739.240234, 9614.139648,
+ 19516.240234, 9906.640625, 9782.440430, 9656.440430,
+ 10074.040039, 9950.740234, 9825.639648, 0.040000,
+ 10119.040039, 9994.839844, 0.040000, 0.040000,
+ 10164.040039},
+ {6307.240234, 0.040000, 0.040000, 6419.439941,
+ 6334.839844, 0.040000, 6531.640137, 6447.640137,
+ 6362.440430, 6643.839844, 6560.440430, 6475.840332,
+ 13146.040039, 6673.240234, 6589.240234, 6504.040039,
+ 6786.040039, 6702.640625, 6618.040039, 0.040000,
+ 6816.040039, 6732.040039, 0.040000, 0.040000,
+ 6846.040039},
+ {6868.240234, 0.040000, 0.040000, 6980.439941,
+ 6898.839844, 0.040000, 7092.640137, 7011.640137,
+ 6929.440430, 7204.839844, 7124.440430, 7042.840332,
+ 14277.040039, 7237.240234, 7156.240234, 7074.040039,
+ 7350.040039, 7269.640625, 7188.040039, 0.040000,
+ 7383.040039, 7302.040039, 0.040000, 0.040000,
+ 7416.040039},
+ {3467.739990, 0.040000, 0.040000, 3524.439941,
+ 3483.040039, 0.040000, 3581.140137, 3540.040039,
+ 3498.340088, 3637.840088, 3597.040039, 3555.640137,
+ 7208.140137, 3654.040039, 3612.940186, 3571.240234,
+ 3711.040039, 3670.240234, 3628.840088, 0.040000,
+ 3727.540039, 3686.440186, 0.040000, 0.040000,
+ 3744.040039},
+ {3751.239990, 0.040000, 0.040000, 3807.939941,
+ 3768.040039, 0.040000, 3864.640137, 3825.040039,
+ 3784.840088, 3921.340088, 3882.040039, 3842.140137,
+ 7779.640137, 3939.040039, 3899.440186, 3859.240234,
+ 3996.040039, 3956.740234, 3916.840088, 0.040000,
+ 4014.040039, 3974.440186, 0.040000, 0.040000,
+ 4032.040039}}}}}));
+ CHECK(approxEq<float, float>(*op->getOutput(0), *expectedOutput));
+ }
+ }
+}
+
+} // namespace Aidge