Skip to content

P
Paddle

PaddlePaddle / Paddle
接近 2 年 前同步成功

通知 2323
Star 20933
Fork 5424
P
Paddle
未验证 提交 6cfe9bfd 编写于 作者: 6 6clc 提交者： GitHub
浏览文件
操作

Migrate the CI of CINN (#54890) 

* test=cinnunit

* test=cinnunit

* sync to develop of cinn

* test=cinnunit

* test=cinnunit
上级 15c87528
展开全部 隐藏空白更改
内联 并排
Showing with 2212 addition and 1162 deletion
CMakeLists.txt
浏览文件 @ 6cfe9bfd
......@@ -240,7 +240,6 @@ else()
)
endif()
find_package(Threads REQUIRED)
include(simd)
......@@ -583,15 +582,11 @@ include(flags) # set paddle compile flags
#------------- cinn cmake config start --------------
set(WITH_MKL_CBLAS ${WITH_MKL})
set(WITH_CUDA ${WITH_GPU})
set(WITH_CUDNN ${WITH_GPU})
if(WITH_CINN)
message(STATUS "Compile Paddle with CINN.")
include(cmake/cinn.cmake)
add_definitions(-DPADDLE_WITH_CINN)
# TODO(6clc): Use CINN_WITH_CUDNN to completely replace WITH_CUDNN in CINN.
# Use WITH_GPU to completely replace WITH_CUDA in CINN.
set(WITH_MKL_CBLAS ${WITH_MKL})
if(WITH_GPU)
set(WITH_CUDA ${WITH_GPU})
add_definitions(-DCINN_WITH_CUDA)
......@@ -600,6 +595,8 @@ if(WITH_CINN)
add_definitions(-DCINN_WITH_CUDNN)
endif()
endif()
include(cmake/cinn.cmake)
add_definitions(-DPADDLE_WITH_CINN)
if(CINN_ONLY)
if(WITH_PYTHON)
......
cmake/cinn.cmake
浏览文件 @ 6cfe9bfd
......@@ -3,18 +3,25 @@ set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
set(DOWNLOAD_MODEL_DIR "${CINN_THIRD_PARTY_PATH}/model")
string(REGEX MATCH "-std=(c\\+\\+[^ ]+)" STD_FLAG "${CMAKE_CXX_FLAGS}")
if (NOT STD_FLAG)
if (NOT CMAKE_CXX_STANDARD)
message(STATUS "STD_FLAG and CMAKE_CXX_STANDARD not found, using default flag: -std=c++17")
if(NOT STD_FLAG)
if(NOT CMAKE_CXX_STANDARD)
message(
STATUS
"STD_FLAG and CMAKE_CXX_STANDARD not found, using default flag: -std=c++17"
)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
set(CMAKE_CXX_STANDARD 17)
else()
message(STATUS "Got CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}, append -std=c++${CMAKE_CXX_STANDARD} to CMAKE_CXX_FLAGS")
message(
STATUS
"Got CMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}, append -std=c++${CMAKE_CXX_STANDARD} to CMAKE_CXX_FLAGS"
)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++${CMAKE_CXX_STANDARD}")
endif()
else()
string(REGEX MATCH "([0-9]+)" STD_VALUE "${STD_FLAG}")
message(STATUS "Got STD_FLAG=${STD_FLAG}, set CMAKE_CXX_STANDARD=${STD_VALUE}")
message(
STATUS "Got STD_FLAG=${STD_FLAG}, set CMAKE_CXX_STANDARD=${STD_VALUE}")
set(CMAKE_CXX_STANDARD ${STD_VALUE})
endif()
......@@ -34,7 +41,6 @@ if(WITH_DEBUG)
add_definitions(-DCINN_WITH_DEBUG)
endif()
# TODO(zhhsplendid): CINN has lots of warnings during early development.
# They will be treated as errors under paddle. We set no-error now and we will
# clean the code in the future.
......@@ -43,13 +49,15 @@ add_definitions(-w)
include(cmake/cinn/version.cmake)
# include the customized configures
if(NOT EXISTS ${CMAKE_BINARY_DIR}/cmake/cinn/config.cmake)
file(COPY ${PROJECT_SOURCE_DIR}/cmake/cinn/config.cmake DESTINATION ${CMAKE_BINARY_DIR}/cmake/cinn)
file(COPY ${PROJECT_SOURCE_DIR}/cmake/cinn/config.cmake
DESTINATION ${CMAKE_BINARY_DIR}/cmake/cinn)
endif()
include(${CMAKE_BINARY_DIR}/cmake/cinn/config.cmake)
if(WITH_MKL)
generate_dummy_static_lib(LIB_NAME "cinn_mklml" GENERATOR "mklml.cmake")
target_link_libraries(cinn_mklml ${MKLML_LIB} ${MKLML_IOMP_LIB})
add_dependencies(cinn_mklml ${MKLML_PROJECT})
add_definitions(-DCINN_WITH_MKL_CBLAS)
endif()
if(WITH_MKLDNN)
......@@ -59,8 +67,10 @@ endif()
if(WITH_GPU)
message(STATUS "Enable CINN CUDA")
add_definitions(-DCINN_WITH_CUDA)
message(STATUS "Enable CINN CUDNN")
add_definitions(-DCINN_WITH_CUDNN)
if(WITH_CUDNN)
message(STATUS "Enable CINN CUDNN")
add_definitions(-DCINN_WITH_CUDNN)
endif()
enable_language(CUDA)
find_package(CUDA REQUIRED)
include_directories(${CUDA_INCLUDE_DIRS})
......@@ -81,10 +91,14 @@ if(WITH_GPU)
find_library(CUDASTUB libcuda.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64/stubs/
REQUIRED)
find_library(CUBLAS libcublas.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib /usr/lib64 REQUIRED)
find_library(CUDNN libcudnn.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib /usr/lib64 REQUIRED)
find_library(CURAND libcurand.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib /usr/lib64 REQUIRED)
find_library(CUSOLVER libcusolver.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib /usr/lib64 REQUIRED)
find_library(CUBLAS libcublas.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64
/usr/lib /usr/lib64 REQUIRED)
find_library(CUDNN libcudnn.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64 /usr/lib
/usr/lib64 REQUIRED)
find_library(CURAND libcurand.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64
/usr/lib /usr/lib64 REQUIRED)
find_library(CUSOLVER libcusolver.so HINTS ${CUDA_TOOLKIT_ROOT_DIR}/lib64
/usr/lib /usr/lib64 REQUIRED)
endif()
set(cinnapi_src CACHE INTERNAL "" FORCE)
......@@ -108,7 +122,7 @@ include(cmake/cinn/external/openmp.cmake)
include(cmake/cinn/external/jitify.cmake)
if(CINN_ONLY)
LINK_LIBRARIES(gflags)
link_libraries(gflags)
endif()
set(LINK_FLAGS
......@@ -269,15 +283,18 @@ if(PUBLISH_LIBS)
POST_BUILD
COMMAND cmake -E copy ${CMAKE_BINARY_DIR}/libcinnapi.so
${CMAKE_BINARY_DIR}/dist/cinn/lib/libcinnapi.so
COMMAND cmake -E copy_directory ${CINN_THIRD_PARTY_PATH}/install
COMMAND cmake -E copy_directory ${CINN_THIRD_PARTY_PATH}/install
${CMAKE_BINARY_DIR}/dist/third_party DEPENDS cinnapi)
add_custom_command(
TARGET cinncore_static
POST_BUILD
COMMAND cmake -E copy ${PROJECT_SOURCE_DIR}/tools/cinn/tutorials_demo/demo.cc
${CMAKE_BINARY_DIR}/dist/demo.cc
COMMAND cmake -E copy ${PROJECT_SOURCE_DIR}/tools/cinn/tutorials_demo/build_demo.sh
${CMAKE_BINARY_DIR}/dist/build_demo.sh
COMMAND
cmake -E copy ${PROJECT_SOURCE_DIR}/tools/cinn/tutorials_demo/demo.cc
${CMAKE_BINARY_DIR}/dist/demo.cc
COMMAND
cmake -E copy
${PROJECT_SOURCE_DIR}/tools/cinn/tutorials_demo/build_demo.sh
${CMAKE_BINARY_DIR}/dist/build_demo.sh
COMMAND cmake -E copy ${CMAKE_BINARY_DIR}/libcinncore_static.a
${CMAKE_BINARY_DIR}/dist/cinn/lib/libcinncore_static.a
COMMAND
......
cmake/cinn/external/absl.cmake
浏览文件 @ 6cfe9bfd
......@@ -63,6 +63,9 @@ set(ABSL_LIB_NAMES
bad_optional_access
bad_variant_access
raw_hash_set)
if(CINN_ONLY)
list(APPEND ABSL_LIB_NAMES strings_internal raw_logging_internal)
endif()
set(ABSL_LIBS "")
add_library(absl STATIC IMPORTED GLOBAL)
......
cmake/external/gtest.cmake
浏览文件 @ 6cfe9bfd
......@@ -56,14 +56,9 @@ else()
"${GTEST_INSTALL_DIR}/${CMAKE_INSTALL_LIBDIR}/libgmock.a"
CACHE FILEPATH "gmock libraries." FORCE)
set(GTEST_CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
if(CINN_ONLY)
set(GTEST_CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
else()
set(GTEST_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
endif()
set(GTEST_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
endif()
if(WITH_MKLML)
# wait for mklml downloading completed
set(GTEST_DEPENDS ${MKLML_PROJECT})
......
cmake/third_party.cmake
浏览文件 @ 6cfe9bfd
......@@ -263,6 +263,7 @@ endif()
# cinn_only includes third-party libraries separately
if(CINN_ONLY)
set(CMAKE_CXX_FLAGS "-std=c++17 ${CMAKE_CXX_FLAGS}")
include(external/zlib)
include(external/gflags)
include(external/glog)
......@@ -289,7 +290,6 @@ if(WITH_CINN)
endif()
endif()
include(external/zlib) # download, build, install zlib
include(external/gflags) # download, build, install gflags
include(external/glog) # download, build, install glog
......
paddle/cinn/backends/llvm/codegen_llvm.cc
浏览文件 @ 6cfe9bfd
......@@ -1086,9 +1086,7 @@ llvm::Value *CodeGenLLVM::Visit(const ir::Sum *op) {
#undef __IR_EMITTER_CINN_NOT_IMPLEMENTED
void CodeGenLLVM::Compile(const ir::Module &module) {
Visit(module.self());
}
void CodeGenLLVM::Compile(const ir::Module &module) { Visit(module.self()); }
llvm::Value *CodeGenLLVM::EmitCall_buffer_malloc(const ir::Call *op) { return nullptr; }
......
paddle/cinn/backends/llvm/simple_jit.cc
浏览文件 @ 6cfe9bfd
......@@ -111,7 +111,6 @@ SimpleJIT::SimpleJIT() : context_(std::make_unique<llvm::LLVMContext>()) {
template <typename CodeGenT>
void SimpleJIT::Link(ir::Module module, bool optimize) {
VLOG(-1) << "dddddd";
std::string runtime_ir(backends::kRuntimeLlvmIr);
llvm::SMDiagnostic error;
auto m = llvm::parseAssemblyString(runtime_ir, error, context());
......@@ -119,17 +118,11 @@ void SimpleJIT::Link(ir::Module module, bool optimize) {
auto b = std::make_unique<llvm::IRBuilder<>>(context());
auto ir_emitter = std::make_unique<CodeGenT>(m.get(), b.get());
VLOG(-1) << "dddddd";
ir_emitter->Compile(module);
VLOG(-1) << "dddddd";
VLOG(-1) << "dddddd";
CHECK(!llvm::verifyModule(*m, &llvm::errs())) << "Invalid module found";
VLOG(-1) << "dddddd";
VLOG(-1) << "dddddd";
AddModule(std::move(m), optimize);
VLOG(-1) << "dddddd";
}
template void SimpleJIT::Link<CodeGenLLVM>(ir::Module module, bool optimize);
......
paddle/cinn/hlir/framework/op_lowering.h
浏览文件 @ 6cfe9bfd
......@@ -45,12 +45,6 @@ typedef std::vector<Expr> (OpLowerer::*IRComputeFunction)(poly::StageMap&,
const GroupPtr&,
const GroupPtr&,
bool);
typedef void (OpLowerer::*IRScheduleFunction)(ir::IRSchedule& ir_sch,
std::unordered_map<std::string, ir::Tensor>&,
const GroupPtr&,
const GroupPtr&,
Node*&,
Node*&);
class OpLowerer {
public:
......@@ -61,27 +55,21 @@ class OpLowerer {
std::vector<ir::LoweredFunc> LowerWithoutSchedule(GroupPtr& group);
private:
std::vector<ir::LoweredFunc> IRLowerOp(IRComputeFunction, IRScheduleFunction, GroupPtr&);
std::vector<ir::LoweredFunc> IRLowerOp(IRComputeFunction, GroupPtr&);
std::vector<ir::LoweredFunc> IRLowerNonFusibleOp(GroupPtr&, bool);
std::vector<ir::LoweredFunc> IRLowerOpWithoutSchedule(IRComputeFunction, GroupPtr&);
#define DEFINE_IR_COMPUTE_SCHDULE(type) \
#define DEFINE_IR_COMPUTE(type) \
std::vector<Expr> IR##type##Compute(poly::StageMap& stages, \
std::vector<ir::Tensor>& func_args, \
std::unordered_map<std::string, ir::Tensor>& tensor_map, \
const GroupPtr& group, \
const GroupPtr& sub_group, \
bool apply_impl_schedule = false); \
void IR##type##Schedule(ir::IRSchedule& ir_sch, \
std::unordered_map<std::string, ir::Tensor>& tensor_map, \
const GroupPtr& group, \
const GroupPtr& sub_group, \
Node*& first, \
Node*& second);
bool apply_impl_schedule = false);
// compute and schedule
DEFINE_IR_COMPUTE_SCHDULE(Elementwise);
DEFINE_IR_COMPUTE_SCHDULE(Reduce);
DEFINE_IR_COMPUTE_SCHDULE(OutEWiseFusable);
DEFINE_IR_COMPUTE(Elementwise);
DEFINE_IR_COMPUTE(Reduce);
DEFINE_IR_COMPUTE(OutEWiseFusable);
void IRSchedule(ir::IRSchedule& ir_sch,
const GroupPtr& group,
......
paddle/cinn/hlir/op/contrib/argmax.cc
浏览文件 @ 6cfe9bfd
......@@ -120,11 +120,9 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmax(const framework::NodeAt
CHECK(in_expr.as_tensor());
Tensor in_tensor = in_expr.as_tensor_ref();
auto stages = CreateStages({in_tensor});
if (FLAGS_cinn_ir_schedule) {
CHECK_EQ(pack_args.size(), 2U);
CHECK(pack_args[1].is_string());
tensor_name = pack_args[1].operator std::string();
}
CHECK_EQ(pack_args.size(), 2U);
CHECK(pack_args[1].is_string());
tensor_name = pack_args[1].operator std::string();
std::vector<ir::Tensor> out_tensor = Argmax(in_tensor, target, stages, axis, keep_dims, tensor_name);
stages->InsertLazily(out_tensor[0]);
......@@ -134,39 +132,31 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmax(const framework::NodeAt
});
framework::CINNSchedule argmax_schedule([=](lang::Args args, lang::RetValue *ret) {
if (FLAGS_cinn_ir_schedule) {
CHECK(!args.empty()) << "The input argument of argmax_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
std::vector<Expr> vec_ast;
for (int i = 0; i < arg_pack.size(); i++) {
if (arg_pack[i].is_expr()) {
Expr temp = arg_pack[i];
vec_ast.emplace_back(temp);
}
}
CHECK(!vec_ast.empty());
ir::ModuleExpr mod_expr(vec_ast);
ir::IRSchedule ir_sch(mod_expr);
ir_sch.MergeExprs();
auto blocks = ir_sch.GetAllBlocks();
// TODO: It needs to be rewritten according to the reduction_max operator to improve performance.
// Do not use local variables, because the size will exceed the limit.
ir_sch.SetBuffer(blocks[0], "local");
ir_sch.SetBuffer(blocks[1], "local");
long prod_size = std::accumulate(output_shapes[0].begin(), output_shapes[0].end(), 1, std::multiplies<int>());
if (prod_size > 1 && target.arch == Target::Arch::X86) {
pe::IRScheduleInjectiveCPU(ir_sch, output_shapes.front(), target, true);
CHECK(!args.empty()) << "The input argument of argmax_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
std::vector<Expr> vec_ast;
for (int i = 0; i < arg_pack.size(); i++) {
if (arg_pack[i].is_expr()) {
Expr temp = arg_pack[i];
vec_ast.emplace_back(temp);
}
std::vector<common::CINNValue> res{common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
*ret = common::CINNValuePack{res};
} else {
CHECK(!args.empty()) << "The input argument of arange_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
Expr out = arg_pack[0];
CHECK(out.as_tensor());
*ret = arg_pack;
}
CHECK(!vec_ast.empty());
ir::ModuleExpr mod_expr(vec_ast);
ir::IRSchedule ir_sch(mod_expr);
ir_sch.MergeExprs();
auto blocks = ir_sch.GetAllBlocks();
// TODO: It needs to be rewritten according to the reduction_max operator to improve performance.
// Do not use local variables, because the size will exceed the limit.
ir_sch.SetBuffer(blocks[0], "local");
ir_sch.SetBuffer(blocks[1], "local");
long prod_size = std::accumulate(output_shapes[0].begin(), output_shapes[0].end(), 1, std::multiplies<int>());
if (prod_size > 1 && target.arch == Target::Arch::X86) {
pe::IRScheduleInjectiveCPU(ir_sch, output_shapes.front(), target, true);
}
std::vector<common::CINNValue> res{common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
*ret = common::CINNValuePack{res};
});
auto strategy = std::make_shared<framework::OpStrategy>();
......
paddle/cinn/hlir/op/contrib/argmin.cc
浏览文件 @ 6cfe9bfd
......@@ -113,18 +113,15 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmin(const framework::NodeAt
framework::CINNCompute argmin_compute([=](lang::Args args, lang::RetValue *ret) {
CHECK(!args.empty()) << "The input argument of argmin compute is empty! Please check.";
common::CINNValuePack pack_args = args[0];
std::string tensor_name = UniqName("Argmin_out");
CHECK_GE(pack_args.size(), 1U) << "There should be 1 input args for argmax compute";
Expr in_expr = pack_args[0];
CHECK(in_expr.as_tensor());
Tensor in_tensor = in_expr.as_tensor_ref();
auto stages = CreateStages({in_tensor});
if (FLAGS_cinn_ir_schedule) {
CHECK_EQ(pack_args.size(), 2U);
CHECK(pack_args[1].is_string());
tensor_name = pack_args[1].operator std::string();
}
auto out_tensor = Argmin(in_tensor, target, stages, axis, keep_dims, tensor_name);
CHECK_EQ(pack_args.size(), 2U);
CHECK(pack_args[1].is_string());
std::string tensor_name = pack_args[1].operator std::string();
auto out_tensor = Argmin(in_tensor, target, stages, axis, keep_dims, tensor_name);
stages->InsertLazily(out_tensor[0]);
std::vector<CINNValue> cinn_values{
......@@ -133,38 +130,30 @@ std::shared_ptr<framework::OpStrategy> StrategyForArgmin(const framework::NodeAt
});
framework::CINNSchedule argmin_schedule([=](lang::Args args, lang::RetValue *ret) {
if (FLAGS_cinn_ir_schedule) {
CHECK(!args.empty()) << "The input argument of arange_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
std::vector<Expr> vec_ast;
for (int i = 0; i < arg_pack.size(); i++) {
if (arg_pack[i].is_expr()) {
Expr temp = arg_pack[i];
vec_ast.emplace_back(temp);
}
}
CHECK(!vec_ast.empty());
ir::ModuleExpr mod_expr(vec_ast);
ir::IRSchedule ir_sch(mod_expr);
ir_sch.MergeExprs();
auto blocks = ir_sch.GetAllBlocks();
// TODO: It needs to be rewritten according to the reduction_min operator to improve performance.
// Do not use local variables, because the size will exceed the limit.
ir_sch.SetBuffer(blocks[0], "local");
ir_sch.SetBuffer(blocks[1], "local");
long prod_size = std::accumulate(output_shapes[0].begin(), output_shapes[0].end(), 1, std::multiplies<int>());
if (prod_size > 1 && target.arch == Target::Arch::X86) {
pe::IRScheduleInjectiveCPU(ir_sch, output_shapes.front(), target, true);
CHECK(!args.empty()) << "The input argument of arange_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
std::vector<Expr> vec_ast;
for (int i = 0; i < arg_pack.size(); i++) {
if (arg_pack[i].is_expr()) {
Expr temp = arg_pack[i];
vec_ast.emplace_back(temp);
}
std::vector<common::CINNValue> res{common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
*ret = common::CINNValuePack{res};
} else {
CHECK(!args.empty()) << "The input argument of arange_schedule is empty! Please check.\n";
common::CINNValuePack arg_pack = args[0];
Expr out = arg_pack[0];
CHECK(out.as_tensor());
*ret = arg_pack;
}
CHECK(!vec_ast.empty());
ir::ModuleExpr mod_expr(vec_ast);
ir::IRSchedule ir_sch(mod_expr);
ir_sch.MergeExprs();
auto blocks = ir_sch.GetAllBlocks();
// TODO: It needs to be rewritten according to the reduction_min operator to improve performance.
// Do not use local variables, because the size will exceed the limit.
ir_sch.SetBuffer(blocks[0], "local");
ir_sch.SetBuffer(blocks[1], "local");
long prod_size = std::accumulate(output_shapes[0].begin(), output_shapes[0].end(), 1, std::multiplies<int>());
if (prod_size > 1 && target.arch == Target::Arch::X86) {
pe::IRScheduleInjectiveCPU(ir_sch, output_shapes.front(), target, true);
}
std::vector<common::CINNValue> res{common::CINNValue(ir_sch.GetModule().GetExprs().at(0))};
*ret = common::CINNValuePack{res};
});
auto strategy = std::make_shared<framework::OpStrategy>();
......
paddle/cinn/hlir/op/elementwise.cc
浏览文件 @ 6cfe9bfd
......@@ -858,6 +858,10 @@ std::vector<Type> InferDtypeForArange(const std::vector<Type> &inputs_type, cons
return {common::Str2Type(absl::get<std::string>(attrs.at("dtype")))};
}
std::vector<Type> InferDtypeForLogicalNot(const std::vector<Type> &inputs_type, const framework::AttrMapType &attrs) {
return {common::Bool()};
}
} // namespace op
} // namespace hlir
} // namespace cinn
......@@ -901,7 +905,6 @@ CINN_REGISTER_HELPER(elementwise_ops) {
CINN_REGISTER_UNARY(negative, Negative)
CINN_REGISTER_UNARY(identity, Identity)
CINN_REGISTER_UNARY(logical_not, LogicalNot)
CINN_REGISTER_UNARY(sign, Sign)
CINN_REGISTER_UNARY(abs, Abs)
CINN_REGISTER_UNARY(rsqrt, Rsqrt)
......@@ -1052,5 +1055,16 @@ CINN_REGISTER_HELPER(elementwise_ops) {
.set_attr("inferdtype", MakeOpFunction(cinn::hlir::op::InferDtypeForElementwise))
.set_attr<cinn::hlir::framework::OpPatternKind>("OpPattern", cinn::hlir::framework::OpPatternKind::kElementWise);
CINN_REGISTER_OP(logical_not)
.describe("Logical not function")
.set_num_inputs(1)
.set_num_outputs(1)
.set_attr<cinn::hlir::framework::StrategyFunction>("CINNStrategy", cinn::hlir::op::StrategyForLogicalNot)
.set_attr("infershape", MakeOpFunction(cinn::hlir::op::InferShapeForElementwise))
.set_attr("inferdtype", MakeOpFunction(cinn::hlir::op::InferDtypeForLogicalNot))
.set_attr("inferlayout", MakeOpFunction(cinn::hlir::op::InferLayoutForElementwise))
.set_attr<cinn::hlir::framework::OpPatternKind>("OpPattern", cinn::hlir::framework::OpPatternKind::kElementWise)
.set_support_level(4);
return true;
}
paddle/cinn/hlir/pe/broadcast.cc
浏览文件 @ 6cfe9bfd
......@@ -256,9 +256,11 @@ HLIR_IMP_BC_PE(Minimum, return ir::Min::Make(a, b););
HLIR_IMP_BC_PE(LeftShift, return a << b;);
HLIR_IMP_BC_PE(RightShift, return a >> b;);
HLIR_IMP_BC_PE(LogicalRightShift, return lang::LogicalRightShift(a, b););
HLIR_IMP_BC_PE(LogicalAnd, return a && b;);
HLIR_IMP_BC_PE(LogicalOr, return a || b;);
HLIR_IMP_BC_PE(LogicalXOr, return (a || b) && !(a && b););
HLIR_IMP_BC_PE(LogicalAnd, return ir::Cast::Make(Bool(), a) && ir::Cast::Make(Bool(), b););
HLIR_IMP_BC_PE(LogicalOr, return ir::Cast::Make(Bool(), a) || ir::Cast::Make(Bool(), b););
HLIR_IMP_BC_PE(LogicalXOr,
return (ir::Cast::Make(Bool(), a) || ir::Cast::Make(Bool(), b)) &&
!(ir::Cast::Make(Bool(), a) && ir::Cast::Make(Bool(), b)););
HLIR_IMP_BC_PE(BitwiseAnd, return a & b;);
HLIR_IMP_BC_PE(BitwiseOr, return a | b;);
HLIR_IMP_BC_PE(BitwiseXor, return a ^ b;);
......
paddle/cinn/pybind/bind.h
浏览文件 @ 6cfe9bfd
......@@ -23,7 +23,6 @@
namespace pybind11 {
namespace detail {
template <typename Key, typename Value, typename Hash, typename Equal, typename Alloc>
struct type_caster<absl::flat_hash_map<Key, Value, Hash, Equal, Alloc>>
: map_caster<absl::flat_hash_map<Key, Value, Hash, Equal, Alloc>, Key, Value> {};
......
test/cinn/CMakeLists.txt
浏览文件 @ 6cfe9bfd
......@@ -3,15 +3,11 @@ set(CINN_CORE_API ${CMAKE_BINARY_DIR}/python/core_api.so)
add_custom_command(
OUTPUT ${CMAKE_BINARY_DIR}/test/__init__.py POST_BUILD
COMMAND cp -rf --remove-destination
${PROJECT_SOURCE_DIR}/test/cinn
COMMAND cp -rf --remove-destination ${PROJECT_SOURCE_DIR}/test/cinn
${CMAKE_BINARY_DIR}/test/
COMMAND cd ${CMAKE_BINARY_DIR}/test/ && touch __init__.py
)
add_custom_target(
COPY_CINN_PYTHON_TESTS ALL
DEPENDS ${CMAKE_BINARY_DIR}/test/__init__.py
)
COMMAND cd ${CMAKE_BINARY_DIR}/test/ && touch __init__.py)
add_custom_target(COPY_CINN_PYTHON_TESTS ALL
DEPENDS ${CMAKE_BINARY_DIR}/test/__init__.py)
set(BASIC_TEST_NAMES
test_matmul
......@@ -29,8 +25,8 @@ foreach(basic_test_name ${BASIC_TEST_NAMES})
NAME ${basic_test_name}
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/${basic_test_name}.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/${basic_test_name}.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach()
......@@ -41,7 +37,7 @@ if(NOT ${WITH_GPU})
# )
endif()
if(WITH_GPU)
if(WITH_CUDNN)
# TODO(thisjiang): revert test_cinn_frontend after fix inference mul problem
# ADD_TEST(NAME test_cinn_frontend
# COMMAND ${CMAKE_COMMAND} -E env PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
......@@ -54,8 +50,8 @@ if(WITH_GPU)
NAME test_netbuilder
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_netbuilder.py "${WITH_GPU}"
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_netbuilder.py "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endif()
......@@ -76,17 +72,17 @@ add_test(
NAME test_cinn_op_benchmark
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_op_benchmark.py "${WITH_GPU}"
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_op_benchmark.py "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
if(WITH_GPU)
if(WITH_CUDNN)
add_test(
NAME test_cinn_fake_resnet
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_resnet.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_resnet.py
"${CMAKE_BINARY_DIR}/third_party/resnet_model" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -94,8 +90,8 @@ if(WITH_GPU)
NAME test_cinn_real_resnet18
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_resnet18.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_resnet18.py
"${CMAKE_BINARY_DIR}/third_party/ResNet18" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -103,8 +99,8 @@ if(WITH_GPU)
NAME test_cinn_real_mobilenetV2
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_mobilenetv2.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_mobilenetv2.py
"${CMAKE_BINARY_DIR}/third_party/MobileNetV2" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -112,8 +108,8 @@ if(WITH_GPU)
NAME test_cinn_real_efficientnet
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_efficientnet.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_efficientnet.py
"${CMAKE_BINARY_DIR}/third_party/EfficientNet" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -121,8 +117,8 @@ if(WITH_GPU)
NAME test_cinn_real_mobilenetV1
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_mobilenetv1.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_mobilenetv1.py
"${CMAKE_BINARY_DIR}/third_party/MobilenetV1" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -130,8 +126,8 @@ if(WITH_GPU)
NAME test_cinn_real_resnet50
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_resnet50.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_resnet50.py
"${CMAKE_BINARY_DIR}/third_party/ResNet50" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -139,8 +135,8 @@ if(WITH_GPU)
NAME test_cinn_real_squeezenet
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_squeezenet.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_squeezenet.py
"${CMAKE_BINARY_DIR}/third_party/SqueezeNet" "${WITH_GPU}"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
......@@ -148,8 +144,8 @@ if(WITH_GPU)
NAME test_paddle_model_convertor
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/test_paddle_model_convertor.py --path
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/test_paddle_model_convertor.py --path
"${CMAKE_BINARY_DIR}/third_party/resnet_model"
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endif()
......@@ -165,13 +161,13 @@ if(WITH_GPU)
"ops/test_*.py")
set(EXCLUDE_OP test_conv2d_op)
if(WITH_GPU)
if(WITH_CUDNN)
add_test(
NAME test_conv2d_op
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/ops/test_conv2d_op.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/ops/test_conv2d_op.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endif()
......@@ -185,8 +181,8 @@ if(WITH_GPU)
NAME ${op_test_name}
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/${op_test_name}.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/${op_test_name}.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach()
......@@ -197,21 +193,21 @@ if(WITH_GPU)
"op_mappers/test_*.py")
set(EXCLUDE_OP_MAPPER test_mul_op test_conv2d_op)
if(WITH_GPU)
if(WITH_CUDNN)
add_test(
NAME test_mul_op_mapper
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/op_mappers/test_mul_op.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/op_mappers/test_mul_op.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
add_test(
NAME test_conv2d_op_mapper
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/op_mappers/test_conv2d_op.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/op_mappers/test_conv2d_op.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endif()
......@@ -225,8 +221,8 @@ if(WITH_GPU)
NAME "${op_mapper_test_name}_mapper"
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/${op_mapper_test_name}.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/${op_mapper_test_name}.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach()
......@@ -246,8 +242,8 @@ if(WITH_GPU)
NAME ${pass_test_name}
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/${pass_test_name}.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/${pass_test_name}.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach()
......@@ -266,8 +262,8 @@ if(WITH_GPU)
NAME ${fusion_test_name}
COMMAND
${CMAKE_COMMAND} -E env
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH} python3
${CMAKE_CURRENT_SOURCE_DIR}/${fusion_test_name}.py
PYTHONPATH=${CMAKE_BINARY_DIR}:${CMAKE_BINARY_DIR}/python/:$ENV{PYTHONPATH}
python3 ${CMAKE_CURRENT_SOURCE_DIR}/${fusion_test_name}.py
WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
endforeach()
......
test/cinn/ops/test_acosh_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
# Copyright (c) 2023 CINN Authors. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestAcoshOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
low=2,
high=100,
shape=self.case["x_shape"],
dtype=self.case["x_dtype"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=False)
out = paddle.acosh(x)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("acosh")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
out = builder.acosh(x)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x], [self.x_np], [out])
self.cinn_outputs = res
def test_check_results(self):
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestAcoshCase1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestAcoshCase1"
self.cls = TestAcoshOp
self.inputs = [{"x_shape": [512, 256]}]
self.dtypes = [{
"x_dtype": "float32"
}, {
"x_dtype": "float64",
}]
self.attrs = []
class TestAcoshCase2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestAcoshCase2"
self.cls = TestAcoshOp
self.inputs = [{
"x_shape": [1]
}, {
"x_shape": [1024]
}, {
"x_shape": [512, 256]
}, {
"x_shape": [128, 64, 32]
}, {
"x_shape": [128, 2048, 32]
}, {
"x_shape": [16, 8, 4, 2]
}, {
"x_shape": [1, 1, 1, 1]
}, {
"x_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "float32"}]
self.attrs = []
if __name__ == "__main__":
TestAcoshCase1().run()
TestAcoshCase2().run()
test/cinn/ops/test_batch_norm_op.py
浏览文件 @ 6cfe9bfd
......@@ -17,6 +17,7 @@
import unittest, sys
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
......@@ -27,21 +28,17 @@ from cinn.common import *
"x86 test will be skipped due to timeout.")
class TestBatchNormTrainOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.num_channels = 16
self.inputs = {
"x":
self.random([2, self.num_channels, 8, 8], "float32", 0.0, 1.0),
"dout":
self.random([2, self.num_channels, 8, 8], "float32", 1e-7, 1e-6),
}
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"], dtype=self.case["x_dtype"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"])
x = paddle.to_tensor(self.x_np)
batch_norm = paddle.nn.BatchNorm(
self.num_channels, act=None, is_test=False)
self.case["x_shape"][1], act=None, is_test=False)
out = batch_norm(x)
self.paddle_outputs = [out]
......@@ -51,110 +48,115 @@ class TestBatchNormTrainOp(OpTest):
def build_cinn_program(self, target):
builder = NetBuilder("batch_norm")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
scale = builder.fill_constant([self.num_channels], 1.0, 'scale',
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
scale = builder.fill_constant([self.case["x_shape"][1]], 1.0, 'scale',
'float32')
bias = builder.fill_constant([self.num_channels], 0.0, 'bias',
bias = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'bias',
'float32')
mean = builder.fill_constant([self.num_channels], 0.0, 'mean',
mean = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'mean',
'float32')
variance = builder.fill_constant([self.num_channels], 1.0, 'variance',
'float32')
variance = builder.fill_constant([self.case["x_shape"][1]], 1.0,
'variance', 'float32')
out = builder.batchnorm(x, scale, bias, mean, variance, is_test=False)
prog = builder.build()
forward_res = self.get_cinn_output(
prog, target, [x], [self.inputs["x"]], out, passes=[])
prog, target, [x], [self.x_np], out, passes=[])
self.cinn_outputs = [forward_res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
# Reopen after decomposer infer dtype fixed
class TestBatchNormTrainFP16(TestBatchNormTrainOp):
def init_case(self):
self.num_channels = 16
self.inputs = {
"x": self.random([2, self.num_channels, 8, 8], "float16"),
"dout": self.random([2, self.num_channels, 8, 8], "float16"),
}
def test_check_results(self):
self.check_outputs_and_grads(max_relative_error=1e-3)
class TestBatchNormTrainBF16(TestBatchNormTrainOp):
def init_case(self):
self.num_channels = 16
x = self.random([2, self.num_channels, 8, 8], "bfloat16")
dout = self.random([2, self.num_channels, 8, 8], "bfloat16")
self.inputs = {
"x": x,
"dout": dout,
}
def test_check_results(self):
self.check_outputs_and_grads(max_relative_error=1e-2)
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestBatchNormTrainOpAll(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestBatchNormTrainOpCase"
self.cls = TestBatchNormTrainOp
self.inputs = [
{
"x_shape": [2, 16, 8, 8],
},
{
"x_shape": [2, 16, 8, 1],
},
{
"x_shape": [2, 16, 2048, 8],
},
]
self.dtypes = [
{
"x_dtype": "float16",
"max_relative_error": 1e-3
},
{
"x_dtype": "float32",
"max_relative_error": 1e-5
},
{
"x_dtype": "bfloat16",
"max_relative_error": 1e-2
},
]
self.attrs = []
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestBatchNormBackwardOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.num_channels = 16
self.inputs = {
"x":
self.random([2, self.num_channels, 8, 8], "float32", 0.0, 10.0),
"dout":
self.random([2, self.num_channels, 8, 8], "float32", 1e-7, 1e-6),
}
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"], dtype=self.case["x_dtype"])
self.y_np = self.random(
shape=self.case["x_shape"], dtype=self.case["x_dtype"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
x = paddle.to_tensor(self.x_np, stop_gradient=False)
batch_norm = paddle.nn.BatchNorm(
self.num_channels, act=None, is_test=False)
self.case["x_shape"][1], act=None, is_test=False)
out = batch_norm(x)
self.paddle_outputs = [out]
self.paddle_grads = self.get_paddle_grads([out], [x],
[self.inputs["dout"]])
self.paddle_grads = self.get_paddle_grads([out], [x], [self.y_np])
# Note: If the forward and backward operators are run in the same program,
# the forward result will be incorrect.
def build_cinn_program(self, target):
builder = NetBuilder("batch_norm")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
scale = builder.fill_constant([self.num_channels], 1.0, 'scale',
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
scale = builder.fill_constant([self.case["x_shape"][1]], 1.0, 'scale',
'float32')
bias = builder.fill_constant([self.num_channels], 0.0, 'bias',
bias = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'bias',
'float32')
mean = builder.fill_constant([self.num_channels], 0.0, 'mean',
mean = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'mean',
'float32')
variance = builder.fill_constant([self.num_channels], 1.0, 'variance',
'float32')
variance = builder.fill_constant([self.case["x_shape"][1]], 1.0,
'variance', 'float32')
out = builder.batchnorm(x, scale, bias, mean, variance, is_test=False)
prog = builder.build()
forward_res = self.get_cinn_output(
prog, target, [x], [self.inputs["x"]], out, passes=[])
prog, target, [x], [self.x_np], out, passes=[])
self.cinn_outputs = [forward_res[0]]
builder_grad = NetBuilder("batch_norm_grad")
dout = builder_grad.create_input(
self.nptype2cinntype(self.inputs["dout"].dtype),
self.inputs["dout"].shape, "dout")
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"dout")
x_g = builder_grad.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x_g")
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x_g")
scale_g = builder_grad.fill_constant(scale.shape(), 1.0, 'scale_g',
'float32')
save_mean = builder_grad.create_input(
......@@ -167,49 +169,62 @@ class TestBatchNormBackwardOp(OpTest):
prog = builder_grad.build()
backward_res = self.get_cinn_output(
prog,
target, [dout, x_g, save_mean, save_variance], [
self.inputs["dout"], self.inputs["x"], forward_res[1],
forward_res[2]
],
target, [dout, x_g, save_mean, save_variance],
[self.y_np, self.x_np, forward_res[1], forward_res[2]],
out_grad,
passes=[])
self.cinn_grads = [backward_res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
class TestBatchNormBackwardFP16(TestBatchNormBackwardOp):
def init_case(self):
self.num_channels = 16
self.inputs = {
"x":
self.random([2, self.num_channels, 8, 8], "float16", 0.0, 10.0),
"dout":
self.random([2, self.num_channels, 8, 8], "float16", 1e-7, 1e-6),
}
def test_check_results(self):
self.check_outputs_and_grads(max_relative_error=1e-3)
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestBatchNormBackwardOpAll(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestBatchNormBackwardOpCase"
self.cls = TestBatchNormBackwardOp
self.inputs = [
{
"x_shape": [2, 16, 8, 8],
},
{
"x_shape": [2, 16, 8, 1],
},
{
"x_shape": [2, 16, 2048, 8],
},
]
self.dtypes = [
{
"x_dtype": "float16",
"max_relative_error": 1e-3
},
{
"x_dtype": "float32",
"max_relative_error": 1e-5
},
]
self.attrs = []
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestBatchNormInferOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.num_channels = 16
self.inputs = {
"x": self.random([2, self.num_channels, 8, 8], "float32", 0.0,
1.0),
}
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"], dtype=self.case["x_dtype"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"])
x = paddle.to_tensor(self.x_np)
batch_norm = paddle.nn.BatchNorm(
self.num_channels, act=None, is_test=True)
self.case["x_shape"][1], act=None, is_test=True)
out = batch_norm(x)
self.paddle_outputs = [out]
......@@ -219,27 +234,54 @@ class TestBatchNormInferOp(OpTest):
def build_cinn_program(self, target):
builder = NetBuilder("batch_norm")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
scale = builder.fill_constant([self.num_channels], 1.0, 'scale',
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
scale = builder.fill_constant([self.case["x_shape"][1]], 1.0, 'scale',
'float32')
bias = builder.fill_constant([self.num_channels], 0.0, 'bias',
bias = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'bias',
'float32')
mean = builder.fill_constant([self.num_channels], 0.0, 'mean',
mean = builder.fill_constant([self.case["x_shape"][1]], 0.0, 'mean',
'float32')
variance = builder.fill_constant([self.num_channels], 1.0, 'variance',
'float32')
variance = builder.fill_constant([self.case["x_shape"][1]], 1.0,
'variance', 'float32')
out = builder.batchnorm(x, scale, bias, mean, variance, is_test=False)
prog = builder.build()
forward_res = self.get_cinn_output(
prog, target, [x], [self.inputs["x"]], out, passes=[])
prog, target, [x], [self.x_np], out, passes=[])
self.cinn_outputs = [forward_res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
class TestBatchNormInferOpAll(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestBatchNormInferOpCase"
self.cls = TestBatchNormInferOp
self.inputs = [
{
"x_shape": [2, 16, 8, 8],
},
{
"x_shape": [2, 16, 8, 1],
},
{
"x_shape": [2, 16, 2048, 8],
},
]
self.dtypes = [
{
"x_dtype": "float32",
"max_relative_error": 1e-5
},
]
self.attrs = []
if __name__ == "__main__":
unittest.main()
TestBatchNormTrainOpAll().run()
TestBatchNormBackwardOpAll().run()
TestBatchNormInferOpAll().run()
test/cinn/ops/test_logical_and_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
# Copyright (c) 2023 CINN Authors. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestLogicalAndOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=-10,
high=100)
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=-10,
high=100)
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=False)
y = paddle.to_tensor(self.y_np, stop_gradient=False)
def get_unsqueeze_axis(x_rank, y_rank, axis):
self.assertTrue(
x_rank >= y_rank,
"The rank of x should be greater or equal to that of y.")
axis = axis if axis >= 0 else x_rank - y_rank
unsqueeze_axis = np.arange(0, axis).tolist() + np.arange(
axis + y_rank, x_rank).tolist()
return unsqueeze_axis
unsqueeze_axis = get_unsqueeze_axis(
len(x.shape), len(y.shape), self.case["axis"])
y_t = paddle.unsqueeze(
y, axis=unsqueeze_axis) if len(unsqueeze_axis) > 0 else y
out = paddle.logical_and(x, y_t)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("logical_and")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.logical_and(x, y, axis=self.case["axis"])
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.x_np, self.y_np], [out])
self.cinn_outputs = res
def test_check_results(self):
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestLogicalAndCase1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalAndCase1"
self.cls = TestLogicalAndOp
self.inputs = [{"x_shape": [512, 256], "y_shape": [512, 256]}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
class TestLogicalAndCase2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalAndCase2"
self.cls = TestLogicalAndOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1024]
}, {
"x_shape": [512, 256],
"y_shape": [512, 256]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 32]
}, {
"x_shape": [128, 2048, 32],
"y_shape": [128, 2048, 32]
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [1, 1, 1, 1]
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool", "y_dtype": "bool"}]
self.attrs = [{"axis": -1}]
class TestLogicalAndCaseWithBroadcast1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalAndCaseWithBroadcast1"
self.cls = TestLogicalAndOp
self.inputs = [{"x_shape": [56], "y_shape": [1]}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
class TestLogicalAndCaseWithBroadcast2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalAndCaseWithBroadcast2"
self.cls = TestLogicalAndOp
self.inputs = [{
"x_shape": [56],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1]
}, {
"x_shape": [512, 256],
"y_shape": [512, 1]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 1]
}, {
"x_shape": [16, 1, 1, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [16, 1, 1, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool", "y_dtype": "bool"}]
self.attrs = [{"axis": -1}]
if __name__ == "__main__":
TestLogicalAndCase1().run()
TestLogicalAndCase2().run()
TestLogicalAndCaseWithBroadcast1().run()
TestLogicalAndCaseWithBroadcast2().run()
test/cinn/ops/test_logical_not_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
# Copyright (c) 2023 CINN Authors. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestLogicalNotOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=-10,
high=100)
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=False)
out = paddle.logical_not(x)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("logical_not")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
out = builder.logical_not(x)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x], [self.x_np], [out])
self.cinn_outputs = res
def test_check_results(self):
self.check_outputs_and_grads(all_equal=True)
class TestLogicalNotCase1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalNotCase1"
self.cls = TestLogicalNotOp
self.inputs = [{"x_shape": [512, 256]}]
self.dtypes = [{
"x_dtype": "bool"
}, {
"x_dtype": "int8"
}, {
"x_dtype": "int16"
}, {
"x_dtype": "int32"
}, {
"x_dtype": "int64"
}, {
"x_dtype": "float32"
}, {
"x_dtype": "float64"
}]
self.attrs = []
class TestLogicalNotCase2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalNotCase2"
self.cls = TestLogicalNotOp
self.inputs = [{
"x_shape": [1]
}, {
"x_shape": [1024]
}, {
"x_shape": [512, 256]
}, {
"x_shape": [128, 64, 32]
}, {
"x_shape": [128, 2048, 32]
}, {
"x_shape": [16, 8, 4, 2]
}, {
"x_shape": [1, 1, 1, 1]
}, {
"x_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool"}]
self.attrs = []
class TestLogicalNotCaseWithBroadcast1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalNotCaseWithBroadcast1"
self.cls = TestLogicalNotOp
self.inputs = [{"x_shape": [56]}]
self.dtypes = [{
"x_dtype": "bool"
}, {
"x_dtype": "int8"
}, {
"x_dtype": "int16"
}, {
"x_dtype": "int32"
}, {
"x_dtype": "int64"
}, {
"x_dtype": "float32"
}, {
"x_dtype": "float64"
}]
self.attrs = []
class TestLogicalNotCaseWithBroadcast2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalNotCaseWithBroadcast2"
self.cls = TestLogicalNotOp
self.inputs = [{
"x_shape": [56]
}, {
"x_shape": [1024]
}, {
"x_shape": [512, 256]
}, {
"x_shape": [128, 64, 32]
}, {
"x_shape": [16, 1, 1, 2]
}, {
"x_shape": [16, 1, 1, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool"}]
self.attrs = []
if __name__ == "__main__":
TestLogicalNotCase1().run()
TestLogicalNotCase2().run()
TestLogicalNotCaseWithBroadcast1().run()
TestLogicalNotCaseWithBroadcast2().run()
test/cinn/ops/test_logical_or_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
# Copyright (c) 2023 CINN Authors. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestLogicalOrOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=-10,
high=100)
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=-10,
high=100)
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=False)
y = paddle.to_tensor(self.y_np, stop_gradient=False)
def get_unsqueeze_axis(x_rank, y_rank, axis):
self.assertTrue(
x_rank >= y_rank,
"The rank of x should be greater or equal to that of y.")
axis = axis if axis >= 0 else x_rank - y_rank
unsqueeze_axis = np.arange(0, axis).tolist() + np.arange(
axis + y_rank, x_rank).tolist()
return unsqueeze_axis
unsqueeze_axis = get_unsqueeze_axis(
len(x.shape), len(y.shape), self.case["axis"])
y_t = paddle.unsqueeze(
y, axis=unsqueeze_axis) if len(unsqueeze_axis) > 0 else y
out = paddle.logical_or(x, y_t)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("logical_and")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.logical_or(x, y, axis=self.case["axis"])
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.x_np, self.y_np], [out])
self.cinn_outputs = res
def test_check_results(self):
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestLogicalOrCase(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalOrCase"
self.cls = TestLogicalOrOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1024]
}, {
"x_shape": [512, 256],
"y_shape": [512, 256]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 32]
}, {
"x_shape": [128, 2048, 32],
"y_shape": [128, 2048, 32]
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [1, 1, 1, 1]
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
class TestLogicalOrCaseWithBroadcast(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalOrCaseWithBroadcast"
self.cls = TestLogicalOrOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1]
}, {
"x_shape": [512, 256],
"y_shape": [512, 1]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 1]
}, {
"x_shape": [16, 1, 1, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [16, 1, 1, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
if __name__ == "__main__":
TestLogicalOrCase().run()
TestLogicalOrCaseWithBroadcast().run()
test/cinn/ops/test_logical_xor_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
# Copyright (c) 2023 CINN Authors. All Rights Reserved.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import cinn
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestLogicalXorOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=-10,
high=100)
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=-10,
high=100)
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=False)
y = paddle.to_tensor(self.y_np, stop_gradient=False)
def get_unsqueeze_axis(x_rank, y_rank, axis):
self.assertTrue(
x_rank >= y_rank,
"The rank of x should be greater or equal to that of y.")
axis = axis if axis >= 0 else x_rank - y_rank
unsqueeze_axis = np.arange(0, axis).tolist() + np.arange(
axis + y_rank, x_rank).tolist()
return unsqueeze_axis
unsqueeze_axis = get_unsqueeze_axis(
len(x.shape), len(y.shape), self.case["axis"])
y_t = paddle.unsqueeze(
y, axis=unsqueeze_axis) if len(unsqueeze_axis) > 0 else y
out = paddle.logical_xor(x, y_t)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("logical_and")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.logical_xor(x, y, axis=self.case["axis"])
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.x_np, self.y_np], [out])
self.cinn_outputs = res
def test_check_results(self):
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestLogicalXorCase1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalXorCase1"
self.cls = TestLogicalXorOp
self.inputs = [{"x_shape": [512, 256], "y_shape": [512, 256]}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
class TestLogicalXorCase2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalXorCase2"
self.cls = TestLogicalXorOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1024]
}, {
"x_shape": [512, 256],
"y_shape": [512, 256]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 32]
}, {
"x_shape": [128, 2048, 32],
"y_shape": [128, 2048, 32]
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [1, 1, 1, 1]
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool", "y_dtype": "bool"}]
self.attrs = [{"axis": -1}]
class TestLogicalXorCaseWithBroadcast1(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalXorCaseWithBroadcast1"
self.cls = TestLogicalXorOp
self.inputs = [{"x_shape": [56], "y_shape": [1]}]
self.dtypes = [{
"x_dtype": "bool",
"y_dtype": "bool"
}, {
"x_dtype": "int8",
"y_dtype": "int8"
}, {
"x_dtype": "int16",
"y_dtype": "int16"
}, {
"x_dtype": "int32",
"y_dtype": "int32"
}, {
"x_dtype": "int64",
"y_dtype": "int64"
}, {
"x_dtype": "float32",
"y_dtype": "float32"
}, {
"x_dtype": "float64",
"y_dtype": "float64"
}]
self.attrs = [{"axis": -1}]
class TestLogicalXorCaseWithBroadcast2(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestLogicalXorCaseWithBroadcast2"
self.cls = TestLogicalXorOp
self.inputs = [{
"x_shape": [56],
"y_shape": [1]
}, {
"x_shape": [1024],
"y_shape": [1]
}, {
"x_shape": [512, 256],
"y_shape": [512, 1]
}, {
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 1]
}, {
"x_shape": [16, 1, 1, 2],
"y_shape": [16, 8, 4, 2]
}, {
"x_shape": [16, 1, 1, 2, 1],
"y_shape": [16, 8, 4, 2, 1]
}]
self.dtypes = [{"x_dtype": "bool", "y_dtype": "bool"}]
self.attrs = [{"axis": -1}]
if __name__ == "__main__":
TestLogicalXorCase1().run()
TestLogicalXorCase2().run()
TestLogicalXorCaseWithBroadcast1().run()
TestLogicalXorCaseWithBroadcast2().run()
test/cinn/ops/test_max_op.py
浏览文件 @ 6cfe9bfd
......@@ -14,12 +14,9 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import paddle.nn.functional as F
import cinn
from cinn.frontend import *
from cinn.common import *
......@@ -28,81 +25,254 @@ from cinn.common import *
"x86 test will be skipped due to timeout.")
class TestMaxOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.inputs = {
"x": np.random.random((16, 64)).astype("float32"),
"y": np.random.random((16, 64)).astype("float32")
}
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=self.case["x_low"],
high=self.case["x_high"])
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=self.case["y_low"],
high=self.case["y_high"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
x = paddle.to_tensor(self.x_np, stop_gradient=True)
y = paddle.to_tensor(self.y_np, stop_gradient=True)
out = paddle.maximum(x, y)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("pow")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.inputs["y"].dtype),
self.inputs["y"].shape, "y")
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.max(x, y)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.inputs["x"], self.inputs["y"]], [out])
[self.x_np, self.y_np], [out])
self.cinn_outputs = [res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestMinOp(OpTest):
def setUp(self):
self.init_case()
class TestMaxOpBase(TestCaseHelper):
def init_case(self):
self.inputs = {
"x": np.random.random((16, 64)).astype("float32"),
"y": np.random.random((16, 64)).astype("float32")
}
inputs = [
{
"x_shape": [1],
"y_shape": [1],
},
{
"x_shape": [32, 64],
"y_shape": [32, 64],
},
{
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
},
]
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
dtypes = [
{
"x_dtype": "float32",
"y_dtype": "float32",
},
]
out = paddle.minimum(x, y)
attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100
},
]
self.paddle_outputs = [out]
def init_attrs(self):
self.class_name = "TestMaxOpBase"
self.cls = TestMaxOp
def build_cinn_program(self, target):
builder = NetBuilder("pow")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
y = builder.create_input(
self.nptype2cinntype(self.inputs["y"].dtype),
self.inputs["y"].shape, "y")
out = builder.min(x, y)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.inputs["x"], self.inputs["y"]], [out])
class TestMaxOpShapeTest(TestMaxOpBase):
def init_attrs(self):
self.class_name = "TestMaxOpShapeTest"
self.cls = TestMaxOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1],
}, {
"x_shape": [1024],
"y_shape": [1024],
}, {
"x_shape": [2048],
"y_shape": [2048],
}, {
"x_shape": [32, 64],
"y_shape": [32, 64],
}, {
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 4, 1024],
"y_shape": [16, 8, 4, 1024],
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [1, 1, 1, 1, 1],
}]
self.cinn_outputs = [res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
class TestMaxOpDtypeTest(TestMaxOpBase):
def init_attrs(self):
self.class_name = "TestMaxOpDtypeTest"
self.cls = TestMaxOp
self.dtypes = [
#{
#"x_dtype": "int8",
#"y_dtype": "int8",
#}, {
#"x_dtype": "int16",
#"y_dtype": "int16",
#}, {
#"x_dtype": "uint8",
#"y_dtype": "uint8",
#}, {
#"x_dtype": "uint16",
#"y_dtype": "uint16",
#},
{
"x_dtype": "int32",
"y_dtype": "int32",
},
{
"x_dtype": "int64",
"y_dtype": "int64",
},
#{
# "x_dtype": "float16",
# "y_dtype": "float16",
# "max_relative_error": 1e-3,
#},
{
"x_dtype": "float32",
"y_dtype": "float32",
},
{
"x_dtype": "float64",
"y_dtype": "float64",
}
]
class TestMaxOpPolarityTest(TestMaxOpBase):
def init_attrs(self):
self.class_name = "TestMaxOpPolarityTest"
self.cls = TestMaxOp
self.attrs = [{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100,
}]
class TestMaxOpBroadcastTest(TestMaxOpBase):
def init_attrs(self):
self.class_name = "TestMaxOpBroadcastTest"
self.cls = TestMaxOp
self.inputs = [{
"x_shape": [32],
"y_shape": [1],
}, {
"x_shape": [1],
"y_shape": [32],
}, {
"x_shape": [1, 64],
"y_shape": [32, 1],
}, {
"x_shape": [1, 64],
"y_shape": [32, 64],
}, {
"x_shape": [32, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 3, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 1, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [2, 1, 1],
"y_shape": [1, 3, 4],
}, {
"x_shape": [1, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 2],
"y_shape": [16, 1, 4, 1],
}, {
"x_shape": [1, 8, 4, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 1, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 32],
"y_shape": [1, 8, 1, 2, 1],
}]
if __name__ == "__main__":
unittest.main()
TestMaxOpShapeTest().run()
TestMaxOpDtypeTest().run()
TestMaxOpPolarityTest().run()
TestMaxOpBroadcastTest().run()
test/cinn/ops/test_min_op.py 0 → 100644
浏览文件 @ 6cfe9bfd
#!/usr/bin/env python3
# Copyright (c) 2022 CINN Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
from cinn.frontend import *
from cinn.common import *
@OpTestTool.skip_if(not is_compiled_with_cuda(),
"x86 test will be skipped due to timeout.")
class TestMinOp(OpTest):
def setUp(self):
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=self.case["x_low"],
high=self.case["x_high"])
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=self.case["y_low"],
high=self.case["y_high"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.x_np, stop_gradient=True)
y = paddle.to_tensor(self.y_np, stop_gradient=True)
out = paddle.minimum(x, y)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("pow")
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.min(x, y)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.x_np, self.y_np], [out])
self.cinn_outputs = [res[0]]
def test_check_results(self):
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestMinOpBase(TestCaseHelper):
inputs = [
{
"x_shape": [1],
"y_shape": [1],
},
{
"x_shape": [32, 64],
"y_shape": [32, 64],
},
{
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
},
]
dtypes = [
{
"x_dtype": "float32",
"y_dtype": "float32",
},
]
attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100
},
]
def init_attrs(self):
self.class_name = "TestMinOpBase"
self.cls = TestMinOp
class TestMinOpShapeTest(TestMinOpBase):
def init_attrs(self):
self.class_name = "TestMinOpShapeTest"
self.cls = TestMinOp
self.inputs = [{
"x_shape": [1],
"y_shape": [1],
}, {
"x_shape": [1024],
"y_shape": [1024],
}, {
"x_shape": [2048],
"y_shape": [2048],
}, {
"x_shape": [32, 64],
"y_shape": [32, 64],
}, {
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 4, 1024],
"y_shape": [16, 8, 4, 1024],
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [1, 1, 1, 1, 1],
}]
class TestMinOpDtypeTest(TestMinOpBase):
def init_attrs(self):
self.class_name = "TestMinOpDtypeTest"
self.cls = TestMinOp
self.dtypes = [
#{
#"x_dtype": "int8",
#"y_dtype": "int8",
#}, {
#"x_dtype": "int16",
#"y_dtype": "int16",
#}, {
#"x_dtype": "uint8",
#"y_dtype": "uint8",
#}, {
#"x_dtype": "uint16",
#"y_dtype": "uint16",
#},
{
"x_dtype": "int32",
"y_dtype": "int32",
},
{
"x_dtype": "int64",
"y_dtype": "int64",
},
#{
# "x_dtype": "float16",
# "y_dtype": "float16",
# "max_relative_error": 1e-3,
#},
{
"x_dtype": "float32",
"y_dtype": "float32",
},
{
"x_dtype": "float64",
"y_dtype": "float64",
}
]
class TestMinOpPolarityTest(TestMinOpBase):
def init_attrs(self):
self.class_name = "TestMinOpPolarityTest"
self.cls = TestMinOp
self.attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100,
},
]
class TestMinOpBroadcastTest(TestMinOpBase):
def init_attrs(self):
self.class_name = "TestMinOpBroadcastTest"
self.cls = TestMinOp
self.inputs = [{
"x_shape": [32],
"y_shape": [1],
}, {
"x_shape": [1],
"y_shape": [32],
}, {
"x_shape": [1, 64],
"y_shape": [32, 1],
}, {
"x_shape": [1, 64],
"y_shape": [32, 64],
}, {
"x_shape": [32, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 3, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 1, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [2, 1, 1],
"y_shape": [1, 3, 4],
}, {
"x_shape": [1, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 2],
"y_shape": [16, 1, 4, 1],
}, {
"x_shape": [1, 8, 4, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 1, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 32],
"y_shape": [1, 8, 1, 2, 1],
}]
if __name__ == "__main__":
TestMinOpShapeTest().run()
TestMinOpDtypeTest().run()
TestMinOpPolarityTest().run()
TestMinOpBroadcastTest().run()
test/cinn/ops/test_mod_op.py
浏览文件 @ 6cfe9bfd
......@@ -17,8 +17,8 @@
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import paddle.nn.functional as F
import cinn
from cinn.frontend import *
from cinn.common import *
......@@ -28,105 +28,255 @@ from cinn.common import *
"x86 test will be skipped due to timeout.")
class TestModOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.inputs = {
"x": np.array([7]).astype('float32'),
"y": np.array([-3]).astype('float32')
}
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=self.case["x_low"],
high=self.case["x_high"])
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=self.case["y_low"],
high=self.case["y_high"])
self.y_np[self.y_np == 0] = 1
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
x = paddle.to_tensor(self.x_np, stop_gradient=True)
y = paddle.to_tensor(self.y_np, stop_gradient=True)
out = paddle.mod(x, y)
self.paddle_outputs = [out]
def build_cinn_program(self, target):
builder = NetBuilder("pow")
x = builder.create_input(
self.nptype2cinntype(self.inputs["x"].dtype),
self.inputs["x"].shape, "x")
self.nptype2cinntype(self.x_np.dtype), self.x_np.shape, "x")
y = builder.create_input(
self.nptype2cinntype(self.inputs["y"].dtype),
self.inputs["y"].shape, "y")
self.nptype2cinntype(self.y_np.dtype), self.y_np.shape, "y")
out = builder.mod(x, y)
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.inputs["x"], self.inputs["y"]], [out])
[self.x_np, self.y_np], [out])
self.cinn_outputs = [res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
class TestModCase1(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "float32", 20, 100),
"y": self.random([32, 64], "float32", 1, 20),
}
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestModCase2(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "int32", 20, 100),
"y": self.random([32, 64], "int32", 1, 20),
}
class TestModOpBase(TestCaseHelper):
inputs = [
{
"x_shape": [32],
"y_shape": [32],
},
{
"x_shape": [32, 64],
"y_shape": [32, 64],
},
{
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
},
]
class TestModCase3(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "float32", 20, 100),
"y": self.random([32, 64], "float32", -20, -1),
}
dtypes = [
{
"x_dtype": "float32",
"y_dtype": "float32",
},
]
attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100
},
]
class TestModCase4(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "int32", 20, 100),
"y": self.random([32, 64], "int32", -20, -1),
}
def init_attrs(self):
self.class_name = "TestModOpBase"
self.cls = TestModOp
class TestModCase5(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "float32", -100, -20),
"y": self.random([32, 64], "float32", 1, 20),
}
class TestModOpShapeTest(TestModOpBase):
def init_attrs(self):
self.class_name = "TestModOpShapeTest"
self.cls = TestModOp
self.inputs = [{
"x_shape": [32],
"y_shape": [32],
}, {
"x_shape": [32, 64],
"y_shape": [32, 64],
}, {
"x_shape": [2, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 4, 1024],
"y_shape": [16, 8, 4, 1024],
}, {
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [1, 1, 1, 1, 1],
}, {
"x_shape": [1],
"y_shape": [1],
}, {
"x_shape": [1024],
"y_shape": [1024],
}, {
"x_shape": [2048],
"y_shape": [2048],
}, {
"x_shape": [32768],
"y_shape": [32768],
}, {
"x_shape": [65536],
"y_shape": [65536],
}, {
"x_shape": [131072],
"y_shape": [131072],
}]
class TestModCase6(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "float32", -100, -20),
"y": self.random([32, 64], "float32", -20, -1),
}
class TestModOpDtypeTest(TestModOpBase):
def init_attrs(self):
self.class_name = "TestModOpDtypeTest"
self.cls = TestModOp
self.dtypes = [{
"x_dtype": "float16",
"y_dtype": "float16",
"max_relative_error": 1e-3
}, {
"x_dtype": "int32",
"y_dtype": "int32",
}, {
"x_dtype": "int64",
"y_dtype": "int64",
}, {
"x_dtype": "float32",
"y_dtype": "float32",
}, {
"x_dtype": "float64",
"y_dtype": "float64",
}]
class TestModCase7(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "int32", -100, -20),
"y": self.random([32, 64], "int32", 1, 20),
}
class TestModOpPolarityTest(TestModOpBase):
def init_attrs(self):
self.class_name = "TestModOpPolarityTest"
self.cls = TestModOp
self.attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": -1
},
{
"x_low": -100,
"x_high": 100,
"y_low": 1,
"y_high": 100
},
]
class TestModCase8(TestModOp):
def init_case(self):
self.inputs = {
"x": self.random([32, 64], "int32", -100, -20),
"y": self.random([32, 64], "int32", -20, -1),
}
class TestModOpBroadcastTest(TestModOpBase):
def init_attrs(self):
self.class_name = "TestModOpBroadcastTest"
self.cls = TestModOp
self.inputs = [{
"x_shape": [32],
"y_shape": [1],
}, {
"x_shape": [1],
"y_shape": [32],
}, {
"x_shape": [1, 64],
"y_shape": [32, 1],
}, {
"x_shape": [1, 64],
"y_shape": [32, 64],
}, {
"x_shape": [32, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 1],
"y_shape": [32, 64],
}, {
"x_shape": [1, 3, 4],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 3, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [1, 1, 1],
"y_shape": [2, 3, 4],
}, {
"x_shape": [2, 1, 1],
"y_shape": [1, 3, 4],
}, {
"x_shape": [1, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [16, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 1, 1, 1],
"y_shape": [16, 8, 4, 2],
}, {
"x_shape": [1, 8, 1, 2],
"y_shape": [16, 1, 4, 1],
}, {
"x_shape": [1, 8, 4, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 1, 2, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 32],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [16, 8, 4, 2, 32],
}, {
"x_shape": [16, 1, 4, 1, 32],
"y_shape": [1, 8, 1, 2, 1],
}]
if __name__ == "__main__":
unittest.main()
TestModOpShapeTest().run()
TestModOpDtypeTest().run()
TestModOpPolarityTest().run()
TestModOpBroadcastTest().run()
test/cinn/ops/test_multiply_op.py
浏览文件 @ 6cfe9bfd
......@@ -14,12 +14,10 @@
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import paddle.nn.functional as F
import cinn
from cinn.frontend import *
from cinn.common import *
......@@ -28,18 +26,24 @@ from cinn.common import *
"x86 test will be skipped due to timeout.")
class TestElementwiseMulOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.inputs = {
"x": np.random.random([32, 64]).astype("float32"),
"y": np.random.random([32, 64]).astype("float32")
}
self.axis = 0
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"],
dtype=self.case["x_dtype"],
low=self.case["x_low"],
high=self.case["x_high"])
self.y_np = self.random(
shape=self.case["y_shape"],
dtype=self.case["y_dtype"],
low=self.case["y_low"],
high=self.case["y_high"])
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
x = paddle.to_tensor(self.x_np, stop_gradient=False)
y = paddle.to_tensor(self.y_np, stop_gradient=False)
def get_unsqueeze_axis(x_rank, y_rank, axis):
self.assertTrue(
......@@ -48,12 +52,10 @@ class TestElementwiseMulOp(OpTest):
axis = axis if axis >= 0 else x_rank - y_rank
unsqueeze_axis = np.arange(0, axis).tolist() + np.arange(
axis + y_rank, x_rank).tolist()
return unsqueeze_axis
unsqueeze_axis = get_unsqueeze_axis(
len(self.inputs["x"].shape), len(self.inputs["y"].shape),
self.axis)
len(x.shape), len(y.shape), self.case["axis"])
y_t = paddle.unsqueeze(
y, axis=unsqueeze_axis) if len(unsqueeze_axis) > 0 else y
out = paddle.multiply(x, y_t)
......@@ -62,28 +64,209 @@ class TestElementwiseMulOp(OpTest):
def build_cinn_program(self, target):
builder = NetBuilder("multiply")
x = builder.create_input(Float(32), self.inputs["x"].shape, "x")
y = builder.create_input(Float(32), self.inputs["y"].shape, "y")
out = builder.multiply(x, y, axis=self.axis)
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
y = builder.create_input(
self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
"y")
out = builder.multiply(x, y, axis=self.case["axis"])
prog = builder.build()
res = self.get_cinn_output(prog, target, [x, y],
[self.inputs["x"], self.inputs["y"]], [out])
[self.x_np, self.y_np], [out])
self.cinn_outputs = [res[0]]
def test_check_results(self):
self.check_outputs_and_grads()
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestElementwiseMulOpBase(TestCaseHelper):
inputs = [
{
"x_shape": [1],
"y_shape": [1],
"axis": 0,
},
{
"x_shape": [1024],
"y_shape": [1024],
"axis": 0,
},
{
"x_shape": [512, 256],
"y_shape": [512, 256],
"axis": 0,
},
{
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 32],
"axis": 0,
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
"axis": 0,
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
"axis": 0,
},
]
dtypes = [
{
"x_dtype": "float32",
"y_dtype": "float32",
},
]
attrs = [
{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100
},
]
def init_attrs(self):
self.class_name = "TestElementwiseMulOpBase"
self.cls = TestElementwiseMulOp
class TestElementwiseMulOpShapeTest(TestElementwiseMulOpBase):
def init_attrs(self):
self.class_name = "TestElementwiseMulOpShapeTest"
self.cls = TestElementwiseMulOp
self.inputs = [
{
"x_shape": [1],
"y_shape": [1],
"axis": 0,
},
{
"x_shape": [1024],
"y_shape": [1024],
"axis": -1,
},
{
"x_shape": [2048],
"y_shape": [2048],
"axis": 0,
},
{
"x_shape": [512, 256],
"y_shape": [512, 256],
"axis": 0,
},
{
"x_shape": [128, 64, 32],
"y_shape": [128, 64, 32],
"axis": -1,
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [16, 8, 4, 2],
"axis": 0,
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [16, 8, 4, 2, 1],
"axis": -1,
},
{
"x_shape": [1, 1, 1, 1, 1],
"y_shape": [1, 1, 1, 1, 1],
"axis": 0,
},
]
class TestElementwiseMulOpDtypeTest(TestElementwiseMulOpBase):
def init_attrs(self):
self.class_name = "TestElementwiseMulOpDtypeTest"
self.cls = TestElementwiseMulOp
self.dtypes = [
{
"x_dtype": "bool",
"y_dtype": "bool",
},
{
"x_dtype": "int32",
"y_dtype": "int32",
},
{
"x_dtype": "int64",
"y_dtype": "int64",
},
{
"x_dtype": "float32",
"y_dtype": "float32",
},
{
"x_dtype": "float64",
"y_dtype": "float64",
},
]
class TestElementwiseMulOpPolarityTest(TestElementwiseMulOpBase):
def init_attrs(self):
self.class_name = "TestElementwiseMulOpPolarityTest"
self.cls = TestElementwiseMulOp
self.attrs = [{
"x_low": -100,
"x_high": 100,
"y_low": -100,
"y_high": 100,
}]
class TestMulCase1(TestElementwiseMulOp):
def init_case(self):
self.inputs = {
"x": np.random.random([8, 16, 32, 32]).astype("float32"),
"y": np.random.random([32, 32]).astype("float32")
}
self.axis = 2
class TestElementwiseMulOpBroadcast(TestElementwiseMulOpBase):
def init_attrs(self):
self.class_name = "TestElementwiseMulOpBroadcast"
self.cls = TestElementwiseMulOp
self.inputs = [
{
"x_shape": [1],
"y_shape": [1],
"axis": 0,
},
{
"x_shape": [1024],
"y_shape": [1],
"axis": -1,
},
{
"x_shape": [512, 256],
"y_shape": [1, 1],
"axis": 0,
},
{
"x_shape": [128, 64, 32],
"y_shape": [1, 1, 1],
"axis": -1,
},
{
"x_shape": [16, 8, 4, 2],
"y_shape": [1, 1, 1, 1],
"axis": 0,
},
{
"x_shape": [16, 8, 4, 2, 1],
"y_shape": [1, 1, 1, 1, 1],
"axis": -1,
},
]
if __name__ == "__main__":
unittest.main()
TestElementwiseMulOpShapeTest().run()
TestElementwiseMulOpDtypeTest().run()
TestElementwiseMulOpPolarityTest().run()
TestElementwiseMulOpBroadcast().run()
test/cinn/ops/test_one_hot_op.py
浏览文件 @ 6cfe9bfd
......@@ -17,6 +17,7 @@
import unittest
import numpy as np
from op_test import OpTest, OpTestTool
from op_test_helper import TestCaseHelper
import paddle
import paddle.nn.functional as F
import cinn
......@@ -28,19 +29,17 @@ from cinn.common import *
"x86 test will be skipped due to timeout.")
class TestOneHotOp(OpTest):
def setUp(self):
self.init_case()
print(f"\nRunning {self.__class__.__name__}: {self.case}")
self.prepare_inputs()
def init_case(self):
self.inputs = {
"X": np.random.random_integers(0, 9, (10)).astype("int64")
}
self.depth = 10
self.axis = -1
def prepare_inputs(self):
self.x_np = self.random(
shape=self.case["x_shape"], dtype=self.case["x_dtype"])
self.dtype = "float32"
def build_paddle_program(self, target):
x = paddle.to_tensor(self.inputs["X"])
out = F.one_hot(x, self.depth)
x = paddle.to_tensor(self.x_np, stop_gradient=True)
out = F.one_hot(x, num_classes=self.case["depth"])
self.paddle_outputs = [out]
......@@ -48,24 +47,79 @@ class TestOneHotOp(OpTest):
# the forward result will be incorrect.
def build_cinn_program(self, target):
builder = NetBuilder("one_hot")
x = builder.create_input(Int(64), self.inputs["X"].shape, "X")
on_value = builder.fill_constant([1], 1, 'on_value', 'int64')
off_value = builder.fill_constant([1], 0, 'off_value', 'int64')
x = builder.create_input(
self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
"x")
on_value = builder.fill_constant([1],
1,
'on_value',
dtype=self.case["x_dtype"])
off_value = builder.fill_constant([1],
0,
'off_value',
dtype=self.case["x_dtype"])
out = builder.one_hot(
x,
on_value,
off_value,
depth=self.case["depth"],
axis=self.case["axis"],
dtype=self.dtype)
out = builder.one_hot(x, on_value, off_value, self.depth, self.axis,
self.dtype)
prog = builder.build()
forward_res = self.get_cinn_output(prog, target, [x],
[self.inputs["X"]], [out])
res = self.get_cinn_output(prog, target, [x], [self.x_np], [out])
self.cinn_outputs = forward_res
self.cinn_outputs = [res[0]]
def test_check_results(self):
self.build_paddle_program(self.target)
self.build_cinn_program(self.target)
self.check_results(self.paddle_outputs, self.cinn_outputs, 1e-5, False,
False)
max_relative_error = self.case[
"max_relative_error"] if "max_relative_error" in self.case else 1e-5
self.check_outputs_and_grads(max_relative_error=max_relative_error)
class TestOneHotOpTest(TestCaseHelper):
def init_attrs(self):
self.class_name = "TestOneHotOpTest"
self.cls = TestOneHotOp
self.inputs = [
{
"x_shape": [1],
"depth": 10,
"axis": -1,
},
{
"x_shape": [1024],
"depth": 10,
"axis": -1,
},
{
"x_shape": [32, 64],
"depth": 10,
"axis": -1,
},
{
"x_shape": [16, 8, 4],
"depth": 10,
"axis": -1,
},
{
"x_shape": [16, 8, 4, 2],
"depth": 10,
"axis": -1,
},
{
"x_shape": [16, 8, 4, 2, 1],
"depth": 10,
"axis": -1,
},
]
self.dtypes = [{
"x_dtype": "int32",
}, {
"x_dtype": "int64",
}]
self.attrs = []
if __name__ == "__main__":
unittest.main()
TestOneHotOpTest().run()
test/cinn/test_paddle_model_convertor.py
浏览文件 @ 6cfe9bfd
......@@ -259,7 +259,9 @@ class TestPaddleModel(OpMapperTest):
logger.debug("CINN Result:\n{}".format(self.cinn_outputs))
def test_check_results(self):
self.check_outputs_and_grads(max_relative_error=1e-2)
# TODO(6clc): There is a random accuracy problem,
# temporarily adjust max_absolute_error from 1e-6 to 1e-3
self.check_outputs_and_grads(max_relative_error=1e-2, max_absolute_error=1e-3)
if __name__ == "__main__":
......
tools/cinn/build.sh
浏览文件 @ 6cfe9bfd
......@@ -16,7 +16,7 @@
set -ex
workspace=$(cd $(dirname ${BASH_SOURCE[0]})/../..; pwd)
build_dir_name=${cinn_build:-build_ci}
build_dir_name=${cinn_build:-build_cinn}
build_dir=$workspace/${build_dir_name}
py_version=${py_version:-3.8}
cinn_whl_path=python/dist/cinn-0.0.0-py3-none-any.whl
......
tools/cinn/docker/Dockerfile.ci
浏览文件 @ 6cfe9bfd
FROM registry.baidubce.com/paddlepaddle/paddle:latest-dev-cuda11.2-cudnn8-gcc82
# Use SHA to specify the docker image to prevent the use of old cache images
# TAG: latest-dev-cuda11.2-cudnn8.2-trt8.0-gcc82
FROM registry.baidubce.com/paddlepaddle/paddle@sha256:ac757bc25c341814284ceafb274c55e36ea7dcf026a265d14f885a0fa60368f8
tools/cinn/docker/Dockerfile.ci.cuda
浏览文件 @ 6cfe9bfd
FROM registry.baidubce.com/paddlepaddle/paddle:latest-dev-cuda11.2-cudnn8-gcc82
# Use SHA to specify the docker image to prevent the use of old cache images
# TAG: latest-dev-cuda11.2-cudnn8.2-trt8.0-gcc82
FROM registry.baidubce.com/paddlepaddle/paddle@sha256:ac757bc25c341814284ceafb274c55e36ea7dcf026a265d14f885a0fa60368f8
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或