create bmm op and move several api from fluid.layers to tensor (#23457)
* add gradient check to reduce ops * add skip gradient check to reduce ops test=develop * modify stack api test=develop * add bmm op and move serval ops from fluid.layers to tensor test=developrevert-22778-infer_var_type
Qinghe JING
5 years ago
committed by
GitHub
parent
071a702060
commit
ad7ac4c607
@ -0,0 +1,165 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License. */
|
||||
|
||||
#include "paddle/fluid/operators/bmm_op.h"
|
||||
#include <vector>
|
||||
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
class BmmOp : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||
PADDLE_ENFORCE_EQ(
|
||||
ctx->HasInput("X"), true,
|
||||
platform::errors::NotFound("Input(X) of BmmOp should not be null"));
|
||||
PADDLE_ENFORCE_EQ(
|
||||
ctx->HasInput("Y"), true,
|
||||
platform::errors::NotFound("Input(Y) of BmmOp should not be null"));
|
||||
PADDLE_ENFORCE_EQ(
|
||||
ctx->HasOutput("Out"), true,
|
||||
platform::errors::NotFound("Output(Out) of BmmOp should not be null."));
|
||||
|
||||
auto x_dims = ctx->GetInputDim("X");
|
||||
auto y_dims = ctx->GetInputDim("Y");
|
||||
|
||||
PADDLE_ENFORCE_EQ(x_dims.size(), 3,
|
||||
platform::errors::InvalidArgument(
|
||||
"Input(X) of BmmOp must be 3-dimensional in BmmOp, "
|
||||
"but received X's shape: [%s].",
|
||||
x_dims));
|
||||
PADDLE_ENFORCE_EQ(y_dims.size(), 3,
|
||||
platform::errors::InvalidArgument(
|
||||
"Input(Y) of BmmOp must be 3-dimensional in BmmOp, "
|
||||
"but received Y's shape: [%s].",
|
||||
y_dims));
|
||||
PADDLE_ENFORCE_EQ(
|
||||
x_dims[0], y_dims[0],
|
||||
platform::errors::InvalidArgument(
|
||||
"Input(X) and Input(Y) must have the same batch size in BmmOp, "
|
||||
"but received X's batch size: [%s],"
|
||||
"Y's batch size [%s]",
|
||||
x_dims[0], y_dims[0]));
|
||||
PADDLE_ENFORCE_EQ(
|
||||
x_dims[2], y_dims[1],
|
||||
platform::errors::InvalidArgument(
|
||||
"Input(X)'s width must be equal with Input(Y)'s height in BmmOp,"
|
||||
"but receive X's width: [%s],"
|
||||
"Y's height: [%s].",
|
||||
x_dims[2], y_dims[1]));
|
||||
|
||||
std::vector<int64_t> dim_out;
|
||||
dim_out.push_back(x_dims[0]);
|
||||
dim_out.push_back(x_dims[1]);
|
||||
dim_out.push_back(y_dims[2]);
|
||||
ctx->SetOutputDim("Out", framework::make_ddim(dim_out));
|
||||
ctx->ShareLoD("X", /*->*/ "Out");
|
||||
}
|
||||
|
||||
framework::OpKernelType GetExpectedKernelType(
|
||||
const framework::ExecutionContext& ctx) const override {
|
||||
auto data_type = OperatorWithKernel::IndicateVarDataType(ctx, "X");
|
||||
return framework::OpKernelType(data_type, ctx.device_context());
|
||||
}
|
||||
};
|
||||
|
||||
class BmmOpMaker : public framework::OpProtoAndCheckerMaker {
|
||||
public:
|
||||
void Make() override {
|
||||
AddInput("X", "(Tensor), The first input tensor of Bmm op.");
|
||||
AddInput("Y", "(Tensor), The second input tensor of Bmm op.");
|
||||
AddOutput("Out", "(Tensor), The output tensor of Bmm op.");
|
||||
AddComment(R"DOC(
|
||||
The Bmm operator is used to perform batched matrix multiplication
|
||||
over the last two dimensions of the input tensors `X` and `Y`
|
||||
which are both 3-dimentionsal.
|
||||
|
||||
Examples:
|
||||
- X: [B, M, K], Y: [B, K, N] => Out: [B, M, N]
|
||||
|
||||
)DOC");
|
||||
}
|
||||
};
|
||||
|
||||
class BmmOpGrad : public framework::OperatorWithKernel {
|
||||
public:
|
||||
using framework::OperatorWithKernel::OperatorWithKernel;
|
||||
|
||||
protected:
|
||||
void InferShape(framework::InferShapeContext* ctx) const override {
|
||||
PADDLE_ENFORCE_EQ(
|
||||
ctx->HasInput("X"), true,
|
||||
platform::errors::NotFound("Input(X) of BmmOp should not be null"));
|
||||
PADDLE_ENFORCE_EQ(
|
||||
ctx->HasInput("Y"), true,
|
||||
platform::errors::NotFound("Input(Y) of BmmOp should not be null"));
|
||||
PADDLE_ENFORCE_EQ(ctx->HasInput(framework::GradVarName("Out")), true,
|
||||
platform::errors::NotFound(
|
||||
"Output(Out@GRAD) of BmmOp should not be null."));
|
||||
|
||||
auto x_dims = ctx->GetInputDim("X");
|
||||
auto y_dims = ctx->GetInputDim("Y");
|
||||
|
||||
auto x_grad_name = framework::GradVarName("X");
|
||||
auto y_grad_name = framework::GradVarName("Y");
|
||||
|
||||
if (ctx->HasOutput(x_grad_name)) {
|
||||
ctx->SetOutputDim(x_grad_name, x_dims);
|
||||
}
|
||||
if (ctx->HasOutput(y_grad_name)) {
|
||||
ctx->SetOutputDim(y_grad_name, y_dims);
|
||||
}
|
||||
}
|
||||
framework::OpKernelType GetExpectedKernelType(
|
||||
const framework::ExecutionContext& ctx) const override {
|
||||
return framework::OpKernelType(OperatorWithKernel::IndicateVarDataType(
|
||||
ctx, framework::GradVarName("Out")),
|
||||
ctx.device_context());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
class BmmOpGradMaker : public framework::SingleGradOpMaker<T> {
|
||||
public:
|
||||
using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
|
||||
|
||||
protected:
|
||||
void Apply(GradOpPtr<T> retv) const override {
|
||||
retv->SetType("bmm_grad");
|
||||
retv->SetInput("X", this->Input("X"));
|
||||
retv->SetInput("Y", this->Input("Y"));
|
||||
retv->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
|
||||
retv->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
|
||||
retv->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y"));
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
|
||||
namespace ops = paddle::operators;
|
||||
|
||||
REGISTER_OPERATOR(bmm, ops::BmmOp, ops::BmmOpMaker,
|
||||
ops::BmmOpGradMaker<paddle::framework::OpDesc>,
|
||||
ops::BmmOpGradMaker<paddle::imperative::OpBase>);
|
||||
REGISTER_OPERATOR(bmm_grad, ops::BmmOpGrad);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
bmm, ops::BmmKernel<paddle::platform::CPUDeviceContext, float>,
|
||||
ops::BmmKernel<paddle::platform::CPUDeviceContext, double>);
|
||||
REGISTER_OP_CPU_KERNEL(
|
||||
bmm_grad, ops::BmmGradKernel<paddle::platform::CPUDeviceContext, float>,
|
||||
ops::BmmGradKernel<paddle::platform::CPUDeviceContext, double>);
|
||||
@ -0,0 +1,27 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License. */
|
||||
|
||||
#include "paddle/fluid/operators/bmm_op.h"
|
||||
|
||||
#ifdef PADDLE_WITH_CUDA
|
||||
namespace ops = paddle::operators;
|
||||
REGISTER_OP_CUDA_KERNEL(
|
||||
bmm, ops::BmmKernel<paddle::platform::CUDADeviceContext, float>,
|
||||
ops::BmmKernel<paddle::platform::CUDADeviceContext, double>,
|
||||
ops::BmmKernel<paddle::platform::CUDADeviceContext,
|
||||
paddle::platform::float16>);
|
||||
|
||||
REGISTER_OP_CUDA_KERNEL(
|
||||
bmm_grad, ops::BmmGradKernel<paddle::platform::CUDADeviceContext, float>,
|
||||
ops::BmmGradKernel<paddle::platform::CUDADeviceContext, double>,
|
||||
ops::BmmGradKernel<paddle::platform::CUDADeviceContext,
|
||||
paddle::platform::float16>);
|
||||
#endif
|
||||
@ -0,0 +1,141 @@
|
||||
/* Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License. */
|
||||
|
||||
#ifndef PADDLE_FLUID_OPERATORS_BMM_OP_H_
|
||||
#define PADDLE_FLUID_OPERATORS_BMM_OP_H_
|
||||
|
||||
#include <algorithm>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
#include "paddle/fluid/framework/op_registry.h"
|
||||
#include "paddle/fluid/framework/operator.h"
|
||||
#include "paddle/fluid/operators/math/blas.h"
|
||||
#include "paddle/fluid/operators/math/math_function.h"
|
||||
namespace paddle {
|
||||
namespace operators {
|
||||
|
||||
using Tensor = framework::Tensor;
|
||||
|
||||
static void ReshapeTensorIntoMatrixSequence(
|
||||
framework::Tensor *x, const math::MatDescriptor &descriptor) {
|
||||
int64_t h, w;
|
||||
h = descriptor.height_;
|
||||
w = descriptor.width_;
|
||||
if (descriptor.trans_) {
|
||||
std::swap(w, h);
|
||||
}
|
||||
|
||||
x->Resize({descriptor.batch_size_, h, w});
|
||||
}
|
||||
|
||||
static void ReshapeXYOutIntoMatrixSequence(framework::Tensor *x,
|
||||
framework::Tensor *y,
|
||||
framework::Tensor *out, bool trans_x,
|
||||
bool trans_y) {
|
||||
auto x_dim = x->dims();
|
||||
auto y_dim = y->dims();
|
||||
auto mat_dim_x = math::CreateMatrixDescriptor(x_dim, 0, false);
|
||||
auto mat_dim_y = math::CreateMatrixDescriptor(y_dim, 0, false);
|
||||
|
||||
out->Resize({std::max(mat_dim_x.batch_size_, mat_dim_y.batch_size_),
|
||||
mat_dim_x.height_, mat_dim_y.width_});
|
||||
|
||||
ReshapeTensorIntoMatrixSequence(x, mat_dim_x);
|
||||
ReshapeTensorIntoMatrixSequence(y, mat_dim_y);
|
||||
}
|
||||
|
||||
template <typename DeviceContext, typename T>
|
||||
class BmmKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void Compute(const framework::ExecutionContext &context) const override {
|
||||
const Tensor &x = *context.Input<Tensor>("X");
|
||||
const Tensor &y = *context.Input<Tensor>("Y");
|
||||
Tensor *out = context.Output<Tensor>("Out");
|
||||
out->mutable_data<T>(context.GetPlace());
|
||||
|
||||
auto blas = math::GetBlas<DeviceContext, T>(context);
|
||||
|
||||
auto mat_dim_a = math::CreateMatrixDescriptor(x.dims(), 0, false);
|
||||
auto mat_dim_b = math::CreateMatrixDescriptor(y.dims(), 0, false);
|
||||
|
||||
// auto scale = static_cast<T>(context.Attr<float>("alpha"));
|
||||
blas.MatMul(x, mat_dim_a, y, mat_dim_b, T(1), out, T(0));
|
||||
}
|
||||
};
|
||||
|
||||
template <typename DeviceContext, typename T>
|
||||
class BmmGradKernel : public framework::OpKernel<T> {
|
||||
public:
|
||||
void MatMul(const framework::ExecutionContext &context,
|
||||
const framework::Tensor &a, bool trans_a,
|
||||
const framework::Tensor &b, bool trans_b,
|
||||
framework::Tensor *out) const {
|
||||
out->mutable_data<T>(context.GetPlace());
|
||||
auto blas = math::GetBlas<DeviceContext, T>(context);
|
||||
auto mat_dim_a = math::CreateMatrixDescriptor(a.dims(), 0, trans_a);
|
||||
auto mat_dim_b = math::CreateMatrixDescriptor(b.dims(), 0, trans_b);
|
||||
|
||||
blas.MatMul(a, mat_dim_a, b, mat_dim_b, T(1), out, T(0));
|
||||
}
|
||||
void CalcInputGrad(const framework::ExecutionContext &context,
|
||||
const framework::Tensor &a, bool trans_a,
|
||||
const framework::Tensor &b, bool trans_b,
|
||||
framework::Tensor *out) const {
|
||||
if (out == nullptr) return;
|
||||
MatMul(context, a, trans_a, b, trans_b, out);
|
||||
}
|
||||
void Compute(const framework::ExecutionContext &context) const override {
|
||||
auto x = *context.Input<framework::Tensor>("X");
|
||||
auto y = *context.Input<framework::Tensor>("Y");
|
||||
auto dout =
|
||||
*context.Input<framework::Tensor>(framework::GradVarName("Out"));
|
||||
auto *dx = context.Output<framework::Tensor>(framework::GradVarName("X"));
|
||||
auto *dy = context.Output<framework::Tensor>(framework::GradVarName("Y"));
|
||||
|
||||
ReshapeXYOutIntoMatrixSequence(&x, &y, &dout, false, false);
|
||||
framework::DDim dx_dims;
|
||||
if (dx) {
|
||||
dx_dims = dx->dims();
|
||||
if (dx_dims != x.dims()) {
|
||||
dx->Resize(x.dims());
|
||||
}
|
||||
}
|
||||
|
||||
framework::DDim dy_dims;
|
||||
if (dy) {
|
||||
dy_dims = dy->dims();
|
||||
if (dy_dims != y.dims()) {
|
||||
dy->Resize(y.dims());
|
||||
}
|
||||
}
|
||||
|
||||
CalcInputGrad(context, dout, false, y, true, dx);
|
||||
CalcInputGrad(context, x, true, dout, false, dy);
|
||||
|
||||
if (dx) {
|
||||
if (dx_dims != x.dims()) {
|
||||
dx->Resize(dx_dims);
|
||||
}
|
||||
}
|
||||
if (dy) {
|
||||
if (dy_dims != y.dims()) {
|
||||
dy->Resize(dy_dims);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace operators
|
||||
} // namespace paddle
|
||||
#endif // PADDLE_FLUID_OPERATORS_BMM_OP_H_
|
||||
@ -0,0 +1,91 @@
|
||||
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import paddle
|
||||
import paddle.fluid as fluid
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
|
||||
|
||||
class TestArangeOp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "range"
|
||||
self.init_config()
|
||||
self.inputs = {
|
||||
'Start': np.array([self.case[0]]).astype(self.dtype),
|
||||
'End': np.array([self.case[1]]).astype(self.dtype),
|
||||
'Step': np.array([self.case[2]]).astype(self.dtype)
|
||||
}
|
||||
|
||||
self.outputs = {
|
||||
'Out': np.arange(self.case[0], self.case[1],
|
||||
self.case[2]).astype(self.dtype)
|
||||
}
|
||||
|
||||
def init_config(self):
|
||||
self.dtype = np.float32
|
||||
self.case = (0, 1, 0.2)
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
|
||||
class TestFloatArangeOpCase0(TestArangeOp):
|
||||
def init_config(self):
|
||||
self.dtype = np.float32
|
||||
self.case = (0, 5, 1)
|
||||
|
||||
|
||||
class TestInt32ArangeOpCase0(TestArangeOp):
|
||||
def init_config(self):
|
||||
self.dtype = np.int32
|
||||
self.case = (0, 5, 2)
|
||||
|
||||
|
||||
class TestInt32ArangeOpCase1(TestArangeOp):
|
||||
def init_config(self):
|
||||
self.dtype = np.int32
|
||||
self.case = (10, 1, -2)
|
||||
|
||||
|
||||
class TestInt32ArangeOpCase2(TestArangeOp):
|
||||
def init_config(self):
|
||||
self.dtype = np.int32
|
||||
self.case = (-1, -10, -2)
|
||||
|
||||
|
||||
class TestArangeAPI(unittest.TestCase):
|
||||
def test_out(self):
|
||||
with fluid.program_guard(fluid.Program()):
|
||||
data = paddle.arange(0, 5, 1)
|
||||
place = fluid.CPUPlace()
|
||||
exe = fluid.Executor(place)
|
||||
result, = exe.run(fetch_list=[data])
|
||||
expected_data = np.arange(0, 5, 1).astype(np.float32)
|
||||
self.assertEqual((result == expected_data).all(), True)
|
||||
|
||||
with fluid.program_guard(fluid.Program()):
|
||||
data = paddle.arange(0.0, 5.0, 1.0, 'int32')
|
||||
place = fluid.CPUPlace()
|
||||
exe = fluid.Executor(place)
|
||||
result, = exe.run(fetch_list=[data])
|
||||
expected_data = np.arange(0, 5, 1).astype(np.int32)
|
||||
self.assertEqual((result == expected_data).all(), True)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@ -0,0 +1,77 @@
|
||||
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
|
||||
#
|
||||
# Licensed under the Apache License, Version 2.0 (the "License");
|
||||
# you may not use this file except in compliance with the License.
|
||||
# You may obtain a copy of the License at
|
||||
#
|
||||
# http://www.apache.org/licenses/LICENSE-2.0
|
||||
#
|
||||
# Unless required by applicable law or agreed to in writing, software
|
||||
# distributed under the License is distributed on an "AS IS" BASIS,
|
||||
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
# See the License for the specific language governing permissions and
|
||||
# limitations under the License.
|
||||
|
||||
from __future__ import print_function
|
||||
|
||||
import unittest
|
||||
import numpy as np
|
||||
from op_test import OpTest
|
||||
import paddle
|
||||
import paddle.fluid as fluid
|
||||
import paddle.tensor as tensor
|
||||
from paddle.fluid import Program, program_guard
|
||||
|
||||
|
||||
class TestBmmOp(OpTest):
|
||||
def setUp(self):
|
||||
self.op_type = "bmm"
|
||||
X = np.random.random((10, 3, 4)).astype("float64")
|
||||
Y = np.random.random((10, 4, 5)).astype("float64")
|
||||
self.inputs = {'X': X, 'Y': Y}
|
||||
Out = np.matmul(X, Y)
|
||||
self.outputs = {'Out': Out}
|
||||
|
||||
def test_check_output(self):
|
||||
self.check_output()
|
||||
|
||||
def test_checkout_grad(self):
|
||||
self.check_grad(['X', 'Y'], 'Out')
|
||||
|
||||
|
||||
class API_TestBmm(unittest.TestCase):
|
||||
def test_out(self):
|
||||
with fluid.program_guard(fluid.Program(), fluid.Program()):
|
||||
data1 = fluid.layers.data(
|
||||
'data1', shape=[-1, 3, 4], dtype='float64')
|
||||
data2 = fluid.layers.data(
|
||||
'data2', shape=[-1, 4, 5], dtype='float64')
|
||||
result_bmm = paddle.bmm(data1, data2)
|
||||
place = fluid.CPUPlace()
|
||||
exe = fluid.Executor(place)
|
||||
input1 = np.random.random([10, 3, 4]).astype('float64')
|
||||
input2 = np.random.random([10, 4, 5]).astype('float64')
|
||||
result, = exe.run(feed={"data1": input1,
|
||||
"data2": input2},
|
||||
fetch_list=[result_bmm])
|
||||
expected_result = np.matmul(input1, input2)
|
||||
self.assertTrue(np.allclose(expected_result, result))
|
||||
|
||||
|
||||
class API_TestDygraphBmm(unittest.TestCase):
|
||||
def test_out(self):
|
||||
input1 = np.array([[[1.0, 1.0, 1.0], [2.0, 2.0, 2.0]],
|
||||
[[3.0, 3.0, 3.0], [4.0, 4.0, 4.0]]])
|
||||
input2 = np.array([[[1.0, 1.0], [2.0, 2.0], [3.0, 3.0]],
|
||||
[[4.0, 4.0], [5.0, 5.0], [6.0, 6.0]]])
|
||||
with fluid.dygraph.guard():
|
||||
x = fluid.dygraph.to_variable(input1)
|
||||
y = fluid.dygraph.to_variable(input2)
|
||||
out = paddle.bmm(x, y)
|
||||
out_np = out.numpy()
|
||||
expected_result = np.matmul(input1, input2)
|
||||
self.assertTrue(np.allclose(expected_result, out_np))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Loading…
Reference in new issue