mirror of
https://github.com/pytorch/pytorch.git
synced 2025-10-20 21:14:14 +08:00
fe7e1bd1ce
Summary: Pull Request resolved: https://github.com/pytorch/pytorch/pull/72603 This change adds out variant dispatchers generated by the previous diff. The number of the out variant dispatchers generated by this diff is 133, which increases the out variant coverage by 309% (current: 43, this diff: 133 + 43 = 176). This number is expected to increase a lot as we develop this script further to cover more ops. Test Plan: **Unittest** Confirmed ``` buck run //caffe2/benchmarks/static_runtime:static_runtime_cpptest ``` is passing. Reviewed By: swolchok Differential Revision: D33373928 fbshipit-source-id: 4d94d788282f3f313bb36f2f9452edecd9862246 (cherry picked from commit e4ce8b386d1fcc47b86cb9c9016a70e7a31b452c)
4446 lines
113 KiB
C++
4446 lines
113 KiB
C++
// @lint-ignore-every CLANGTIDY HOWTOEVEN
|
|
#include <gtest/gtest.h>
|
|
#include <torch/csrc/jit/runtime/static/impl.h>
|
|
#include <torch/torch.h>
|
|
|
|
#include "test_utils.h"
|
|
|
|
using namespace caffe2;
|
|
using namespace torch;
|
|
using namespace torch::jit;
|
|
using namespace torch::jit::test;
|
|
using c10::IValue;
|
|
|
|
TEST(StaticRuntime, autogen_sgn) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sgn(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_acos) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::acos(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_addmv) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %mat: Tensor, %vec: Tensor, %beta: int, %alpha: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::addmv(%self, %mat, %vec, %beta, %alpha)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({2});
|
|
auto mat0 = at::rand({2, 2});
|
|
auto vec0 = at::rand({2});
|
|
auto beta0 = 2;
|
|
auto alpha0 = 2;
|
|
std::vector<IValue> args{self0, mat0, vec0, beta0, alpha0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({35});
|
|
auto mat1 = at::rand({35, 35});
|
|
auto vec1 = at::rand({35});
|
|
auto beta1 = 2;
|
|
auto alpha1 = 2;
|
|
std::vector<IValue> args2{self1, mat1, vec1, beta1, alpha1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_argmax) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int?, %keepdim: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::argmax(%self, %dim, %keepdim)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto keepdim0 = false;
|
|
std::vector<IValue> args{self0, dim0, keepdim0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto keepdim1 = false;
|
|
std::vector<IValue> args2{self1, dim1, keepdim1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_acosh) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::acosh(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({2, 2, 2}) + at::ones({2, 2, 2});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({5, 5, 5}) + at::ones({5, 5, 5});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_asinh) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::asinh(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_atanh) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::atanh(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_asin) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::asin(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_atan) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::atan(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_baddbmm) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %batch1: Tensor, %batch2: Tensor, %beta: int, %alpha: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::baddbmm(%self, %batch1, %batch2, %beta, %alpha)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto batch10 = at::rand({6, 6, 6});
|
|
auto batch20 = at::rand({6, 6, 6});
|
|
auto beta0 = 2;
|
|
auto alpha0 = 2;
|
|
std::vector<IValue> args{self0, batch10, batch20, beta0, alpha0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto batch11 = at::rand({22, 22, 22});
|
|
auto batch21 = at::rand({22, 22, 22});
|
|
auto beta1 = 2;
|
|
auto alpha1 = 2;
|
|
std::vector<IValue> args2{self1, batch11, batch21, beta1, alpha1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_not) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_not(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_copysign_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::copysign(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_ceil) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::ceil(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_cos) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::cos(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_cosh) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::cosh(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_cumprod) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %dtype: int?):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::cumprod(%self, %dim, %dtype)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto dtype0 = at::ScalarType::Float;
|
|
std::vector<IValue> args{self0, dim0, dtype0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto dtype1 = at::ScalarType::Float;
|
|
std::vector<IValue> args2{self1, dim1, dtype1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_erf) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::erf(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_erfc) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::erfc(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_exp) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::exp(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_exp2) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::exp2(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_expm1) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::expm1(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_floor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::floor(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_frac) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::frac(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gcd) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gcd(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
auto other0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
auto other1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lcm) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lcm(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
auto other0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
auto other1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_index_copy) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %source: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::index_copy(%self, %dim, %index, %source)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({2});
|
|
auto dim0 = 0;
|
|
auto index0 = at::randint(0, 1, {2}, at::kLong);
|
|
auto source0 = at::rand({2});
|
|
std::vector<IValue> args{self0, dim0, index0, source0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({32});
|
|
auto dim1 = 0;
|
|
auto index1 = at::randint(0, 10, {32}, at::kLong);
|
|
auto source1 = at::rand({32});
|
|
std::vector<IValue> args2{self1, dim1, index1, source1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_isin_Tensor_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%elements: Tensor, %test_elements: Tensor, %assume_unique: bool, %invert: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::isin(%elements, %test_elements, %assume_unique, %invert)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto elements0 = at::rand({6, 6, 6});
|
|
auto test_elements0 = at::rand({6, 6, 6});
|
|
auto assume_unique0 = false;
|
|
auto invert0 = false;
|
|
std::vector<IValue> args{elements0, test_elements0, assume_unique0, invert0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto elements1 = at::rand({22, 22, 22});
|
|
auto test_elements1 = at::rand({22, 22, 22});
|
|
auto assume_unique1 = false;
|
|
auto invert1 = false;
|
|
std::vector<IValue> args2{elements1, test_elements1, assume_unique1, invert1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_isin_Tensor_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%elements: Tensor, %test_element: int, %assume_unique: bool, %invert: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::isin(%elements, %test_element, %assume_unique, %invert)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto elements0 = at::rand({6, 6, 6});
|
|
auto test_element0 = 2;
|
|
auto assume_unique0 = false;
|
|
auto invert0 = false;
|
|
std::vector<IValue> args{elements0, test_element0, assume_unique0, invert0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto elements1 = at::rand({22, 22, 22});
|
|
auto test_element1 = 2;
|
|
auto assume_unique1 = false;
|
|
auto invert1 = false;
|
|
std::vector<IValue> args2{elements1, test_element1, assume_unique1, invert1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_isin_Scalar_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%element: int, %test_elements: Tensor, %assume_unique: bool, %invert: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::isin(%element, %test_elements, %assume_unique, %invert)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto element0 = 2;
|
|
auto test_elements0 = at::rand({6, 6, 6});
|
|
auto assume_unique0 = false;
|
|
auto invert0 = false;
|
|
std::vector<IValue> args{element0, test_elements0, assume_unique0, invert0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/false);
|
|
|
|
auto element1 = 2;
|
|
auto test_elements1 = at::rand({22, 22, 22});
|
|
auto assume_unique1 = false;
|
|
auto invert1 = false;
|
|
std::vector<IValue> args2{element1, test_elements1, assume_unique1, invert1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/false);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_log10) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::log10(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_log1p) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::log1p(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_log2) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::log2(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_logaddexp) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::logaddexp(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_logaddexp2) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::logaddexp2(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_xlogy_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::xlogy(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__log_softmax) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %half_to_float: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_log_softmax(%self, %dim, %half_to_float)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto half_to_float0 = false;
|
|
std::vector<IValue> args{self0, dim0, half_to_float0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto half_to_float1 = false;
|
|
std::vector<IValue> args2{self1, dim1, half_to_float1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__log_softmax_backward_data) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %output: Tensor, %dim: int, %input_dtype: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_log_softmax_backward_data(%grad_output, %output, %dim, %input_dtype)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto output0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto input_dtype0 = at::ScalarType::Float;
|
|
std::vector<IValue> args{grad_output0, output0, dim0, input_dtype0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto output1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto input_dtype1 = at::ScalarType::Float;
|
|
std::vector<IValue> args2{grad_output1, output1, dim1, input_dtype1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_mm) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %mat2: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::mm(%self, %mat2)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({8, 8});
|
|
auto mat20 = at::rand({8, 8});
|
|
std::vector<IValue> args{self0, mat20};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({32, 32});
|
|
auto mat21 = at::rand({32, 32});
|
|
std::vector<IValue> args2{self1, mat21};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_reciprocal) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::reciprocal(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_neg) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::neg(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_round) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::round(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_round_decimals) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %decimals: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::round(%self, %decimals)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto decimals0 = 1;
|
|
std::vector<IValue> args{self0, decimals0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto decimals1 = 1;
|
|
std::vector<IValue> args2{self1, decimals1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gelu) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %approximate: str):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gelu(%self, %approximate)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto approximate0 = "tanh";
|
|
std::vector<IValue> args{self0, approximate0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto approximate1 = "tanh";
|
|
std::vector<IValue> args2{self1, approximate1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gelu_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %approximate: str):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gelu_backward(%grad_output, %self, %approximate)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto approximate0 = "tanh";
|
|
std::vector<IValue> args{grad_output0, self0, approximate0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto approximate1 = "tanh";
|
|
std::vector<IValue> args2{grad_output1, self1, approximate1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_hardshrink) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %lambd: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::hardshrink(%self, %lambd)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto lambd0 = 2;
|
|
std::vector<IValue> args{self0, lambd0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto lambd1 = 2;
|
|
std::vector<IValue> args2{self1, lambd1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_hardshrink_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_out: Tensor, %self: Tensor, %lambd: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::hardshrink_backward(%grad_out, %self, %lambd)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_out0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto lambd0 = 2;
|
|
std::vector<IValue> args{grad_out0, self0, lambd0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_out1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto lambd1 = 2;
|
|
std::vector<IValue> args2{grad_out1, self1, lambd1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_rsqrt) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::rsqrt(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_silu) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::silu(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_silu_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::silu_backward(%grad_output, %self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{grad_output0, self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{grad_output1, self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_mish) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::mish(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_sin) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sin(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_sinc) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sinc(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_sinh) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sinh(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__softmax) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %half_to_float: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_softmax(%self, %dim, %half_to_float)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto half_to_float0 = false;
|
|
std::vector<IValue> args{self0, dim0, half_to_float0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto half_to_float1 = false;
|
|
std::vector<IValue> args2{self1, dim1, half_to_float1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__softmax_backward_data) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %output: Tensor, %dim: int, %input_dtype: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_softmax_backward_data(%grad_output, %output, %dim, %input_dtype)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto output0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto input_dtype0 = at::ScalarType::Float;
|
|
std::vector<IValue> args{grad_output0, output0, dim0, input_dtype0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto output1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto input_dtype1 = at::ScalarType::Float;
|
|
std::vector<IValue> args2{grad_output1, output1, dim1, input_dtype1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_sqrt) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sqrt(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_prod_dim_int) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %keepdim: bool, %dtype: int?):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::prod(%self, %dim, %keepdim, %dtype)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
auto keepdim0 = false;
|
|
auto dtype0 = at::ScalarType::Float;
|
|
std::vector<IValue> args{self0, dim0, keepdim0, dtype0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
auto keepdim1 = false;
|
|
auto dtype1 = at::ScalarType::Float;
|
|
std::vector<IValue> args2{self1, dim1, keepdim1, dtype1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_tan) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::tan(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_threshold) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %threshold: int, %value: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::threshold(%self, %threshold, %value)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto threshold0 = 2;
|
|
auto value0 = 2;
|
|
std::vector<IValue> args{self0, threshold0, value0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto threshold1 = 2;
|
|
auto value1 = 2;
|
|
std::vector<IValue> args2{self1, threshold1, value1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_threshold_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %threshold: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::threshold_backward(%grad_output, %self, %threshold)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto threshold0 = 2;
|
|
std::vector<IValue> args{grad_output0, self0, threshold0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto threshold1 = 2;
|
|
std::vector<IValue> args2{grad_output1, self1, threshold1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_trunc) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::trunc(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_heaviside) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %values: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::heaviside(%self, %values)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto values0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, values0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto values1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, values1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_index_add) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %source: Tensor, %alpha: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::index_add(%self, %dim, %index, %source, %alpha)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({2});
|
|
auto dim0 = 0;
|
|
auto index0 = at::randint(0, 1, {2}, at::kInt);
|
|
auto source0 = at::rand({2});
|
|
auto alpha0 = 2;
|
|
std::vector<IValue> args{self0, dim0, index0, source0, alpha0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/false);
|
|
|
|
auto self1 = at::rand({16});
|
|
auto dim1 = 0;
|
|
auto index1 = at::randint(0, 10, {16}, at::kInt);
|
|
auto source1 = at::rand({16});
|
|
auto alpha1 = 2;
|
|
std::vector<IValue> args2{self1, dim1, index1, source1, alpha1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/false);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_scatter_src) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %src: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::scatter(%self, %dim, %index, %src)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto src0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
std::vector<IValue> args{self0, dim0, index0, src0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 1, {5, 5, 5}, torch::kInt64);
|
|
auto src1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
std::vector<IValue> args2{self1, dim1, index1, src1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_scatter_value) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %value: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::scatter(%self, %dim, %index, %value)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto value0 = 2;
|
|
auto src0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
std::vector<IValue> args{self0, dim0, index0, value0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 1, {5, 5, 5}, torch::kInt64);
|
|
auto value1 = 2;
|
|
auto src1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
std::vector<IValue> args2{self1, dim1, index1, value1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_scatter_reduce) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %src: Tensor, %reduce: str):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::scatter(%self, %dim, %index, %src, %reduce)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto src0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto reduce0 = "add";
|
|
std::vector<IValue> args{self0, dim0, index0, src0, reduce0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 1, {5, 5, 5}, torch::kInt64);
|
|
auto src1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto reduce1 = "add";
|
|
std::vector<IValue> args2{self1, dim1, index1, src1, reduce1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_scatter_value_reduce) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %value: int, %reduce: str):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::scatter(%self, %dim, %index, %value, %reduce)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto value0 = 2;
|
|
auto reduce0 = "add";
|
|
auto src0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
std::vector<IValue> args{self0, dim0, index0, value0, reduce0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 1, {5, 5, 5}, torch::kInt64);
|
|
auto value1 = 2;
|
|
auto reduce1 = "add";
|
|
auto src1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
std::vector<IValue> args2{self1, dim1, index1, value1, reduce1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_scatter_add) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %src: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::scatter_add(%self, %dim, %index, %src)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto src0 = at::randint(1, 100, {2, 2, 2}, torch::kInt64);
|
|
std::vector<IValue> args{self0, dim0, index0, src0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 1, {5, 5, 5}, torch::kInt64);
|
|
auto src1 = at::randint(1, 100, {5, 5, 5}, torch::kInt64);
|
|
std::vector<IValue> args2{self1, dim1, index1, src1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_eq_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::eq(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_eq_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::eq(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_and_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_and(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
auto other0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
auto other1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_or_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_or(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
auto other0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
auto other1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_xor_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_xor(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
auto other0 = at::randint(1, 100, {6, 6, 6}, at::kInt);
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
auto other1 = at::randint(1, 100, {22, 22, 22}, at::kInt);
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_left_shift_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_left_shift(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_bitwise_right_shift_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::bitwise_right_shift(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_tril) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %diagonal: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::tril(%self, %diagonal)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto diagonal0 = 1;
|
|
std::vector<IValue> args{self0, diagonal0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto diagonal1 = 1;
|
|
std::vector<IValue> args2{self1, diagonal1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_triu) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %diagonal: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::triu(%self, %diagonal)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto diagonal0 = 1;
|
|
std::vector<IValue> args{self0, diagonal0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto diagonal1 = 1;
|
|
std::vector<IValue> args2{self1, diagonal1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_digamma) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::digamma(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lerp_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %end: Tensor, %weight: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lerp(%self, %end, %weight)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto end0 = at::rand({6, 6, 6});
|
|
auto weight0 = 2;
|
|
std::vector<IValue> args{self0, end0, weight0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto end1 = at::rand({22, 22, 22});
|
|
auto weight1 = 2;
|
|
std::vector<IValue> args2{self1, end1, weight1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lerp_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %end: Tensor, %weight: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lerp(%self, %end, %weight)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto end0 = at::rand({6, 6, 6});
|
|
auto weight0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, end0, weight0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto end1 = at::rand({22, 22, 22});
|
|
auto weight1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, end1, weight1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_ne_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::ne(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_ne_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::ne(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_ge_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::ge(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_ge_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::ge(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_le_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::le(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_le_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::le(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gt_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gt(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gt_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gt(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lt_Scalar) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lt(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = 2;
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = 2;
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lt_Tensor) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lt(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_gather) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int, %index: Tensor, %sparse_grad: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::gather(%self, %dim, %index, %sparse_grad)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(1, 100, {2, 2, 2}, at::kInt);
|
|
auto dim0 = 1;
|
|
auto index0 = at::randint(0, 1, {2, 2, 2}, torch::kInt64);
|
|
auto sparse_grad0 = false;
|
|
std::vector<IValue> args{self0, dim0, index0, sparse_grad0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(1, 100, {5, 5, 5}, at::kInt);
|
|
auto dim1 = 1;
|
|
auto index1 = at::randint(0, 4, {5, 5, 5}, torch::kInt64);
|
|
auto sparse_grad1 = false;
|
|
std::vector<IValue> args2{self1, dim1, index1, sparse_grad1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_addcmul) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %tensor1: Tensor, %tensor2: Tensor, %value: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::addcmul(%self, %tensor1, %tensor2, %value)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto tensor10 = at::rand({6, 6, 6});
|
|
auto tensor20 = at::rand({6, 6, 6});
|
|
auto value0 = 2;
|
|
std::vector<IValue> args{self0, tensor10, tensor20, value0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto tensor11 = at::rand({22, 22, 22});
|
|
auto tensor21 = at::rand({22, 22, 22});
|
|
auto value1 = 2;
|
|
std::vector<IValue> args2{self1, tensor11, tensor21, value1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_addcdiv) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %tensor1: Tensor, %tensor2: Tensor, %value: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::addcdiv(%self, %tensor1, %tensor2, %value)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto tensor10 = at::rand({6, 6, 6});
|
|
auto tensor20 = at::rand({6, 6, 6});
|
|
auto value0 = 2;
|
|
std::vector<IValue> args{self0, tensor10, tensor20, value0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto tensor11 = at::rand({22, 22, 22});
|
|
auto tensor21 = at::rand({22, 22, 22});
|
|
auto value1 = 2;
|
|
std::vector<IValue> args2{self1, tensor11, tensor21, value1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_lgamma) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::lgamma(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_polygamma) {
|
|
const std::string script = R"IR(
|
|
graph(%n: int, %self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::polygamma(%n, %self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto n0 = 1;
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{n0, self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto n1 = 1;
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{n1, self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_erfinv) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::erfinv(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_i0) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::i0(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_signbit) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::signbit(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_atan2) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::atan2(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_hypot) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::hypot(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_igamma) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::igamma(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_igammac) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::igammac(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_nextafter) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::nextafter(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_fmin) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::fmin(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_fmax) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::fmax(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_maximum) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::maximum(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_minimum) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::minimum(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_renorm) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %p: int, %dim: int, %maxnorm: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::renorm(%self, %p, %dim, %maxnorm)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto p0 = 2;
|
|
auto dim0 = 1;
|
|
auto maxnorm0 = 2;
|
|
std::vector<IValue> args{self0, p0, dim0, maxnorm0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto p1 = 2;
|
|
auto dim1 = 1;
|
|
auto maxnorm1 = 2;
|
|
std::vector<IValue> args2{self1, p1, dim1, maxnorm1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__convert_indices_from_coo_to_csr) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %size: int, %out_int32: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_convert_indices_from_coo_to_csr(%self, %size, %out_int32)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::randint(0, 3, {2}, at::kInt);
|
|
auto size0 = 10;
|
|
auto out_int320 = false;
|
|
std::vector<IValue> args{self0, size0, out_int320};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::randint(0, 3, {12}, at::kInt);
|
|
auto size1 = 24;
|
|
auto out_int321 = false;
|
|
std::vector<IValue> args2{self1, size1, out_int321};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen__convert_indices_from_csr_to_coo) {
|
|
const std::string script = R"IR(
|
|
graph(%crow_indices: Tensor, %col_indices: Tensor, %out_int32: bool, %transpose: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::_convert_indices_from_csr_to_coo(%crow_indices, %col_indices, %out_int32, %transpose)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto crow_indices0 = torch::tensor({1}, torch::kInt32);
|
|
auto col_indices0 = torch::tensor({0, 1, 0}, torch::kInt32);
|
|
auto out_int320 = false;
|
|
auto transpose0 = false;
|
|
std::vector<IValue> args{crow_indices0, col_indices0, out_int320, transpose0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto crow_indices1 = torch::tensor({0, 1}, torch::kInt32);
|
|
auto col_indices1 = torch::tensor({0, 1, 0, 2, 1, 2}, torch::kInt32);
|
|
auto out_int321 = false;
|
|
auto transpose1 = false;
|
|
std::vector<IValue> args2{
|
|
crow_indices1, col_indices1, out_int321, transpose1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_nll_loss_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %target: Tensor, %weight: Tensor?, %reduction: int, %ignore_index: int, %total_weight: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::nll_loss_backward(%grad_output, %self, %target, %weight, %reduction, %ignore_index, %total_weight)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({});
|
|
auto self0 = at::rand({6});
|
|
auto target0 = at::randint(0, 5, {6}, torch::kInt64);
|
|
auto weight0 = at::rand({6});
|
|
auto reduction0 = 1;
|
|
auto ignore_index0 = 1;
|
|
auto total_weight0 = at::rand({});
|
|
std::vector<IValue> args{
|
|
grad_output0,
|
|
self0,
|
|
target0,
|
|
weight0,
|
|
reduction0,
|
|
ignore_index0,
|
|
total_weight0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({});
|
|
auto self1 = at::rand({36});
|
|
auto target1 = at::randint(0, 11, {36}, torch::kInt64);
|
|
auto weight1 = at::rand({36});
|
|
auto reduction1 = 1;
|
|
auto ignore_index1 = 1;
|
|
auto total_weight1 = at::rand({});
|
|
std::vector<IValue> args2{
|
|
grad_output1,
|
|
self1,
|
|
target1,
|
|
weight1,
|
|
reduction1,
|
|
ignore_index1,
|
|
total_weight1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_elu) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %alpha: int, %scale: int, %input_scale: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::elu(%self, %alpha, %scale, %input_scale)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto alpha0 = 2;
|
|
auto scale0 = 2;
|
|
auto input_scale0 = 2;
|
|
std::vector<IValue> args{self0, alpha0, scale0, input_scale0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto alpha1 = 2;
|
|
auto scale1 = 2;
|
|
auto input_scale1 = 2;
|
|
std::vector<IValue> args2{self1, alpha1, scale1, input_scale1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_elu_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %alpha: int, %scale: int, %input_scale: int, %is_result: bool, %self_or_result: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::elu_backward(%grad_output, %alpha, %scale, %input_scale, %is_result, %self_or_result)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto alpha0 = 2;
|
|
auto scale0 = 2;
|
|
auto input_scale0 = 2;
|
|
auto is_result0 = false;
|
|
auto self_or_result0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{
|
|
grad_output0, alpha0, scale0, input_scale0, is_result0, self_or_result0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto alpha1 = 2;
|
|
auto scale1 = 2;
|
|
auto input_scale1 = 2;
|
|
auto is_result1 = false;
|
|
auto self_or_result1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{
|
|
grad_output1, alpha1, scale1, input_scale1, is_result1, self_or_result1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_glu) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %dim: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::glu(%self, %dim)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto dim0 = 1;
|
|
std::vector<IValue> args{self0, dim0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto dim1 = 1;
|
|
std::vector<IValue> args2{self1, dim1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_hardsigmoid) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::hardsigmoid(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_hardsigmoid_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::hardsigmoid_backward(%grad_output, %self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{grad_output0, self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{grad_output1, self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_leaky_relu_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %negative_slope: int, %self_is_result: bool):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::leaky_relu_backward(%grad_output, %self, %negative_slope, %self_is_result)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto negative_slope0 = 2;
|
|
auto self_is_result0 = false;
|
|
std::vector<IValue> args{
|
|
grad_output0, self0, negative_slope0, self_is_result0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto negative_slope1 = 2;
|
|
auto self_is_result1 = false;
|
|
std::vector<IValue> args2{
|
|
grad_output1, self1, negative_slope1, self_is_result1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_softplus) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %beta: int, %threshold: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::softplus(%self, %beta, %threshold)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto beta0 = 2;
|
|
auto threshold0 = 2;
|
|
std::vector<IValue> args{self0, beta0, threshold0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto beta1 = 2;
|
|
auto threshold1 = 2;
|
|
std::vector<IValue> args2{self1, beta1, threshold1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_softplus_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %beta: int, %threshold: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::softplus_backward(%grad_output, %self, %beta, %threshold)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto beta0 = 2;
|
|
auto threshold0 = 2;
|
|
std::vector<IValue> args{grad_output0, self0, beta0, threshold0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto beta1 = 2;
|
|
auto threshold1 = 2;
|
|
std::vector<IValue> args2{grad_output1, self1, beta1, threshold1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_softshrink) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %lambd: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::softshrink(%self, %lambd)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto lambd0 = 2;
|
|
std::vector<IValue> args{self0, lambd0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto lambd1 = 2;
|
|
std::vector<IValue> args2{self1, lambd1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_softshrink_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %lambd: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::softshrink_backward(%grad_output, %self, %lambd)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto lambd0 = 2;
|
|
std::vector<IValue> args{grad_output0, self0, lambd0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto lambd1 = 2;
|
|
std::vector<IValue> args2{grad_output1, self1, lambd1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_adaptive_max_pool2d_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %indices: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::adaptive_max_pool2d_backward(%grad_output, %self, %indices)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::randint(-3, 2, {2, 2, 2});
|
|
auto self0 = at::randint(-3, 2, {2, 2, 2});
|
|
auto indices0 = at::randint(0, 1, {2, 2, 2}, at::kLong);
|
|
std::vector<IValue> args{grad_output0, self0, indices0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::randint(-3, 3, {3, 3, 3});
|
|
auto self1 = at::randint(-3, 2, {3, 3, 3});
|
|
auto indices1 = at::randint(0, 1, {3, 3, 3}, at::kLong);
|
|
std::vector<IValue> args2{grad_output1, self1, indices1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_adaptive_max_pool3d_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %self: Tensor, %indices: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::adaptive_max_pool3d_backward(%grad_output, %self, %indices)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::randint(-3, 2, {2, 2, 2, 2});
|
|
auto self0 = at::randint(-3, 2, {2, 2, 2, 2});
|
|
auto indices0 = at::randint(0, 1, {2, 2, 2, 2}, at::kLong);
|
|
std::vector<IValue> args{grad_output0, self0, indices0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::randint(-3, 3, {3, 3, 3, 3});
|
|
auto self1 = at::randint(-3, 2, {3, 3, 3, 3});
|
|
auto indices1 = at::randint(0, 1, {3, 3, 3, 3}, at::kLong);
|
|
std::vector<IValue> args2{grad_output1, self1, indices1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_sigmoid_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %output: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::sigmoid_backward(%grad_output, %output)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto output0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{grad_output0, output0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto output1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{grad_output1, output1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_tanh_backward) {
|
|
const std::string script = R"IR(
|
|
graph(%grad_output: Tensor, %output: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::tanh_backward(%grad_output, %output)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto grad_output0 = at::rand({6, 6, 6});
|
|
auto output0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{grad_output0, output0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto grad_output1 = at::rand({22, 22, 22});
|
|
auto output1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{grad_output1, output1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_isposinf) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::isposinf(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_isneginf) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::isneginf(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_entr) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_entr(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_ndtri) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_ndtri(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_erfcx) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_erfcx(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_xlog1py) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_xlog1py(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
auto other0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
auto other1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_zeta) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_zeta(%self, %other)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({2, 2, 2}, at::kDouble) + at::ones({2, 2, 2});
|
|
auto other0 = at::rand({2, 2, 2}, at::kDouble) + at::ones({2, 2, 2});
|
|
std::vector<IValue> args{self0, other0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({5, 5, 5}, at::kDouble) + at::ones({5, 5, 5});
|
|
auto other1 = at::rand({5, 5, 5}, at::kDouble) + at::ones({5, 5, 5});
|
|
std::vector<IValue> args2{self1, other1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_i0e) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_i0e(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_i1) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_i1(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_special_i1e) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::special_i1e(%self)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 6, 6});
|
|
std::vector<IValue> args{self0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 22, 22});
|
|
std::vector<IValue> args2{self1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|
|
|
|
TEST(StaticRuntime, autogen_linalg_cross) {
|
|
const std::string script = R"IR(
|
|
graph(%self: Tensor, %other: Tensor, %dim: int):
|
|
%bias: None = prim::Constant()
|
|
%ret = aten::linalg_cross(%self, %other, %dim)
|
|
%cloned = aten::clone(%ret, %bias)
|
|
return (%cloned)
|
|
)IR";
|
|
|
|
auto self0 = at::rand({6, 3, 6});
|
|
auto other0 = at::rand({6, 3, 6});
|
|
auto dim0 = 1;
|
|
std::vector<IValue> args{self0, other0, dim0};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
{},
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
|
|
auto self1 = at::rand({22, 3, 22});
|
|
auto other1 = at::rand({22, 3, 22});
|
|
auto dim1 = 1;
|
|
std::vector<IValue> args2{self1, other1, dim1};
|
|
testStaticRuntime(
|
|
script,
|
|
args,
|
|
args2,
|
|
/*use_allclose=*/false,
|
|
/*use_equalnan=*/false,
|
|
/*check_resize=*/true);
|
|
}
|