Skip to content

P
Paddle

PaddlePaddle / Paddle
大约 2 年 前同步成功

通知 2325
Star 20933
Fork 5424
P
Paddle
未验证 提交 7a0b8625 编写于 作者: Z zlsh80826 提交者： GitHub
浏览文件
操作

Cherrypick NV fixes to release/2.4 (#48263) 

* Reduce squeeze2_matmul_fuse_pass, flattent tests time (#47098)

* Add missing fp32 config and reduce the testing combination

* Reduce trt matmul pass test max examples

* Loose TRT fp16 tests tolerance (#47100)

* Loose TRT half test tolerance to 1e-3 (#47101)

* Loose TRT half test tolerance to 1e-3 (#47106)

* Update distributed_strategy.proto (#46531)

* Close popen pipe after used (#47053)

* Add launch_bounds (#47285)

* Fix TRT UT failures (#47488)

* Format cherry-picked commits

* CudnnNormConvolution is no longer supported on NVIDIA Hopper GPUs (#48203)

* Skip tests that use fused_ops on H100

* Add error message to FusedOps on H100
Co-authored-by: NShijie <505749828@qq.com>
Co-authored-by: NLeo Chen <39020268+leo0519@users.noreply.github.com>
Co-authored-by: NTian Zheng <tizheng@nvidia.com>
上级 a2f61fef
隐藏空白更改
内联 并排
Showing with 3129 addition and 2744 deletion
paddle/fluid/framework/distributed_strategy.proto
浏览文件 @ 7a0b8625
...@@ -123,6 +123,7 @@ message BuildStrategy { ...@@ -123,6 +123,7 @@ message BuildStrategy {
optional bool allow_cuda_graph_capture = 14 [ default = false ]; optional bool allow_cuda_graph_capture = 14 [ default = false ];
optional int32 reduce_strategy = 15 [ default = 0 ]; optional int32 reduce_strategy = 15 [ default = 0 ];
optional bool fuse_gemm_epilogue = 16 [ default = false ]; optional bool fuse_gemm_epilogue = 16 [ default = false ];
optional string debug_graphviz_path = 17;
} }
message ExecutionStrategy { message ExecutionStrategy {
......
paddle/fluid/operators/fused/cudnn_norm_conv.cu.h
浏览文件 @ 7a0b8625
...@@ -45,6 +45,14 @@ struct NormConvolutionArgs { ...@@ -45,6 +45,14 @@ struct NormConvolutionArgs {
int stride, int stride,
int dilation, int dilation,
int group) { int group) {
PADDLE_ENFORCE_LT(
ctx.GetComputeCapability(),
90,
phi::errors::PreconditionNotMet(
"Expect compute compatiblity to be less than 90, but got %d. "
"CUDNN FusedOps is no longer available on H100 and later "
"devices.",
ctx.GetComputeCapability()));
PADDLE_ENFORCE_EQ( PADDLE_ENFORCE_EQ(
input_shape.size(), input_shape.size(),
4U, 4U,
......
paddle/fluid/operators/fused/cudnn_norm_conv_test.cc
浏览文件 @ 7a0b8625
...@@ -442,7 +442,7 @@ TEST(CudnnNormConvFp16, K1S1) { ...@@ -442,7 +442,7 @@ TEST(CudnnNormConvFp16, K1S1) {
phi::GPUContext *ctx = static_cast<phi::GPUContext *>( phi::GPUContext *ctx = static_cast<phi::GPUContext *>(
platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0))); platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0)));
if (ctx->GetComputeCapability() < 70) { if (ctx->GetComputeCapability() < 70 || ctx->GetComputeCapability() >= 90) {
ASSERT_THROW(test.CheckForward(1e-3, true), ASSERT_THROW(test.CheckForward(1e-3, true),
paddle::platform::EnforceNotMet); paddle::platform::EnforceNotMet);
ASSERT_THROW(test.CheckBackward(1e-3, true), ASSERT_THROW(test.CheckBackward(1e-3, true),
...@@ -472,7 +472,7 @@ TEST(CudnnNormConvFp16, K3S1) { ...@@ -472,7 +472,7 @@ TEST(CudnnNormConvFp16, K3S1) {
phi::GPUContext *ctx = static_cast<phi::GPUContext *>( phi::GPUContext *ctx = static_cast<phi::GPUContext *>(
platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0))); platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0)));
if (ctx->GetComputeCapability() < 70) { if (ctx->GetComputeCapability() < 70 || ctx->GetComputeCapability() >= 90) {
ASSERT_THROW(test.CheckForward(1e-3, true), ASSERT_THROW(test.CheckForward(1e-3, true),
paddle::platform::EnforceNotMet); paddle::platform::EnforceNotMet);
ASSERT_THROW(test.CheckBackward(1e-3, true), ASSERT_THROW(test.CheckBackward(1e-3, true),
...@@ -502,7 +502,7 @@ TEST(CudnnNormConvFp16, K1S1O4) { ...@@ -502,7 +502,7 @@ TEST(CudnnNormConvFp16, K1S1O4) {
phi::GPUContext *ctx = static_cast<phi::GPUContext *>( phi::GPUContext *ctx = static_cast<phi::GPUContext *>(
platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0))); platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0)));
if (ctx->GetComputeCapability() < 70) { if (ctx->GetComputeCapability() < 70 || ctx->GetComputeCapability() >= 90) {
ASSERT_THROW(test.CheckForward(1e-3, true), ASSERT_THROW(test.CheckForward(1e-3, true),
paddle::platform::EnforceNotMet); paddle::platform::EnforceNotMet);
ASSERT_THROW(test.CheckBackward(1e-3, true), ASSERT_THROW(test.CheckBackward(1e-3, true),
...@@ -532,7 +532,7 @@ TEST(CudnnNormConvFp16, K1S2O4) { ...@@ -532,7 +532,7 @@ TEST(CudnnNormConvFp16, K1S2O4) {
phi::GPUContext *ctx = static_cast<phi::GPUContext *>( phi::GPUContext *ctx = static_cast<phi::GPUContext *>(
platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0))); platform::DeviceContextPool::Instance().Get(platform::CUDAPlace(0)));
if (ctx->GetComputeCapability() <= 70) { if (ctx->GetComputeCapability() <= 70 || ctx->GetComputeCapability() >= 90) {
ASSERT_THROW(test.CheckForward(1e-3, true), ASSERT_THROW(test.CheckForward(1e-3, true),
paddle::platform::EnforceNotMet); paddle::platform::EnforceNotMet);
ASSERT_THROW(test.CheckBackward(1e-3), paddle::platform::EnforceNotMet); ASSERT_THROW(test.CheckBackward(1e-3), paddle::platform::EnforceNotMet);
......
paddle/fluid/operators/fused/fused_dropout_act_bias.h
浏览文件 @ 7a0b8625
...@@ -256,17 +256,19 @@ template <typename T, ...@@ -256,17 +256,19 @@ template <typename T,
int BlockSizeX, int BlockSizeX,
int BlockSizeY, int BlockSizeY,
int VecSize, int VecSize,
typename Functor> typename Functor,
__global__ void FusedDropoutActBiasGrad(Functor act_grad, int THREADS_PER_CTA = BlockSizeX *BlockSizeY>
const T *dout, __global__ __launch_bounds__(THREADS_PER_CTA) void FusedDropoutActBiasGrad(
const MaskType *mask, Functor act_grad,
const T *src, const T *dout,
const T *bias, const MaskType *mask,
const T factor, const T *src,
const int64_t rows, const T *bias,
const int64_t cols, const T factor,
T *dx, const int64_t rows,
T *dbias) { const int64_t cols,
T *dx,
T *dbias) {
int64_t col_id = blockIdx.x * blockDim.x + threadIdx.x; int64_t col_id = blockIdx.x * blockDim.x + threadIdx.x;
using LoadT = phi::AlignedVector<T, VecSize>; using LoadT = phi::AlignedVector<T, VecSize>;
......
python/paddle/fluid/core.py
浏览文件 @ 7a0b8625
...@@ -35,9 +35,9 @@ try: ...@@ -35,9 +35,9 @@ try:
if os.name == 'nt': if os.name == 'nt':
third_lib_path = current_path + os.sep + '..' + os.sep + 'libs' third_lib_path = current_path + os.sep + '..' + os.sep + 'libs'
# Will load shared library from 'path' on windows # Will load shared library from 'path' on windows
os.environ[ os.environ['path'] = (
'path'] = current_path + ';' + third_lib_path + ';' + os.environ[ current_path + ';' + third_lib_path + ';' + os.environ['path']
'path'] )
sys.path.insert(0, third_lib_path) sys.path.insert(0, third_lib_path)
# Note: from python3.8, PATH will not take effect # Note: from python3.8, PATH will not take effect
# https://github.com/python/cpython/pull/12302 # https://github.com/python/cpython/pull/12302
...@@ -47,20 +47,24 @@ try: ...@@ -47,20 +47,24 @@ try:
except ImportError as e: except ImportError as e:
from .. import compat as cpt from .. import compat as cpt
if os.name == 'nt': if os.name == 'nt':
executable_path = os.path.abspath(os.path.dirname(sys.executable)) executable_path = os.path.abspath(os.path.dirname(sys.executable))
raise ImportError( raise ImportError(
"""NOTE: You may need to run \"set PATH=%s;%%PATH%%\" """NOTE: You may need to run \"set PATH=%s;%%PATH%%\"
if you encounters \"DLL load failed\" errors. If you have python if you encounters \"DLL load failed\" errors. If you have python
installed in other directory, replace \"%s\" with your own installed in other directory, replace \"%s\" with your own
directory. The original error is: \n %s""" % directory. The original error is: \n %s"""
(executable_path, executable_path, cpt.get_exception_message(e))) % (executable_path, executable_path, cpt.get_exception_message(e))
)
else: else:
raise ImportError( raise ImportError(
"""NOTE: You may need to run \"export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH\" """NOTE: You may need to run \"export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH\"
if you encounters \"libmkldnn.so not found\" errors. If you have python if you encounters \"libmkldnn.so not found\" errors. If you have python
installed in other directory, replace \"/usr/local/lib\" with your own installed in other directory, replace \"/usr/local/lib\" with your own
directory. The original error is: \n""" + cpt.get_exception_message(e)) directory. The original error is: \n"""
+ cpt.get_exception_message(e)
)
except Exception as e: except Exception as e:
raise e raise e
...@@ -70,36 +74,45 @@ def avx_supported(): ...@@ -70,36 +74,45 @@ def avx_supported():
Whether current system(Linux, MacOS, Windows) is supported with AVX. Whether current system(Linux, MacOS, Windows) is supported with AVX.
""" """
from .. import compat as cpt from .. import compat as cpt
sysstr = platform.system().lower() sysstr = platform.system().lower()
has_avx = False has_avx = False
if sysstr == 'linux': if sysstr == 'linux':
try: try:
has_avx = os.popen('cat /proc/cpuinfo | grep -i avx').read() != '' pipe = os.popen('cat /proc/cpuinfo | grep -i avx')
has_avx = pipe.read() != ''
pipe.close()
except Exception as e: except Exception as e:
sys.stderr.write('Can not get the AVX flag from /proc/cpuinfo.\n' sys.stderr.write(
'The original error is: %s\n' % 'Can not get the AVX flag from /proc/cpuinfo.\n'
cpt.get_exception_message(e)) 'The original error is: %s\n' % cpt.get_exception_message(e)
)
return has_avx return has_avx
elif sysstr == 'darwin': elif sysstr == 'darwin':
try: try:
has_avx = os.popen( pipe = os.popen('sysctl machdep.cpu.features | grep -i avx')
'sysctl machdep.cpu.features | grep -i avx').read() != '' has_avx = pipe.read() != ''
pipe.close()
except Exception as e: except Exception as e:
sys.stderr.write( sys.stderr.write(
'Can not get the AVX flag from machdep.cpu.features.\n' 'Can not get the AVX flag from machdep.cpu.features.\n'
'The original error is: %s\n' % cpt.get_exception_message(e)) 'The original error is: %s\n' % cpt.get_exception_message(e)
)
if not has_avx: if not has_avx:
import subprocess import subprocess
pipe = subprocess.Popen( pipe = subprocess.Popen(
'sysctl machdep.cpu.leaf7_features | grep -i avx', 'sysctl machdep.cpu.leaf7_features | grep -i avx',
shell=True, shell=True,
stdout=subprocess.PIPE, stdout=subprocess.PIPE,
stderr=subprocess.PIPE) stderr=subprocess.PIPE,
)
_ = pipe.communicate() _ = pipe.communicate()
has_avx = True if pipe.returncode == 0 else False has_avx = True if pipe.returncode == 0 else False
return has_avx return has_avx
elif sysstr == 'windows': elif sysstr == 'windows':
import ctypes import ctypes
ONE_PAGE = ctypes.c_size_t(0x1000) ONE_PAGE = ctypes.c_size_t(0x1000)
def asm_func(code_str, restype=ctypes.c_uint32, argtypes=()): def asm_func(code_str, restype=ctypes.c_uint32, argtypes=()):
...@@ -109,24 +122,31 @@ def avx_supported(): ...@@ -109,24 +122,31 @@ def avx_supported():
pfnVirtualAlloc.restype = ctypes.c_void_p pfnVirtualAlloc.restype = ctypes.c_void_p
MEM_COMMIT = ctypes.c_ulong(0x1000) MEM_COMMIT = ctypes.c_ulong(0x1000)
PAGE_READWRITE = ctypes.c_ulong(0x4) PAGE_READWRITE = ctypes.c_ulong(0x4)
address = pfnVirtualAlloc(None, ONE_PAGE, MEM_COMMIT, address = pfnVirtualAlloc(
PAGE_READWRITE) None, ONE_PAGE, MEM_COMMIT, PAGE_READWRITE
)
if not address: if not address:
raise Exception("Failed to VirtualAlloc") raise Exception("Failed to VirtualAlloc")
# Copy the code into the memory segment # Copy the code into the memory segment
memmove = ctypes.CFUNCTYPE(ctypes.c_void_p, ctypes.c_void_p, memmove = ctypes.CFUNCTYPE(
ctypes.c_void_p, ctypes.c_void_p,
ctypes.c_size_t)(ctypes._memmove_addr) ctypes.c_void_p,
ctypes.c_void_p,
ctypes.c_size_t,
)(ctypes._memmove_addr)
if memmove(address, code_str, len(code_str)) < 0: if memmove(address, code_str, len(code_str)) < 0:
raise Exception("Failed to memmove") raise Exception("Failed to memmove")
# Enable execute permissions # Enable execute permissions
PAGE_EXECUTE = ctypes.c_ulong(0x10) PAGE_EXECUTE = ctypes.c_ulong(0x10)
pfnVirtualProtect = ctypes.windll.kernel32.VirtualProtect pfnVirtualProtect = ctypes.windll.kernel32.VirtualProtect
res = pfnVirtualProtect(ctypes.c_void_p(address), res = pfnVirtualProtect(
ONE_PAGE, PAGE_EXECUTE, ctypes.c_void_p(address),
ctypes.byref(ctypes.c_ulong(0))) ONE_PAGE,
PAGE_EXECUTE,
ctypes.byref(ctypes.c_ulong(0)),
)
if not res: if not res:
raise Exception("Failed VirtualProtect") raise Exception("Failed VirtualProtect")
...@@ -135,7 +155,8 @@ def avx_supported(): ...@@ -135,7 +155,8 @@ def avx_supported():
pfnGetCurrentProcess.restype = ctypes.c_void_p pfnGetCurrentProcess.restype = ctypes.c_void_p
prochandle = ctypes.c_void_p(pfnGetCurrentProcess()) prochandle = ctypes.c_void_p(pfnGetCurrentProcess())
res = ctypes.windll.kernel32.FlushInstructionCache( res = ctypes.windll.kernel32.FlushInstructionCache(
prochandle, ctypes.c_void_p(address), ONE_PAGE) prochandle, ctypes.c_void_p(address), ONE_PAGE
)
if not res: if not res:
raise Exception("Failed FlushInstructionCache") raise Exception("Failed FlushInstructionCache")
...@@ -153,12 +174,14 @@ def avx_supported(): ...@@ -153,12 +174,14 @@ def avx_supported():
# Convert the code_str into a function that returns uint # Convert the code_str into a function that returns uint
func, address = asm_func(code_str) func, address = asm_func(code_str)
retval = func() retval = func()
ctypes.windll.kernel32.VirtualFree(ctypes.c_void_p(address), ctypes.windll.kernel32.VirtualFree(
ctypes.c_size_t(0), ONE_PAGE) ctypes.c_void_p(address), ctypes.c_size_t(0), ONE_PAGE
)
except Exception as e: except Exception as e:
sys.stderr.write('Failed getting the AVX flag on Windows.\n' sys.stderr.write(
'The original error is: %s\n' % 'Failed getting the AVX flag on Windows.\n'
cpt.get_exception_message(e)) 'The original error is: %s\n' % cpt.get_exception_message(e)
)
return (retval & (1 << avx_bit)) > 0 return (retval & (1 << avx_bit)) > 0
else: else:
sys.stderr.write('Do not get AVX flag on %s\n' % sysstr) sys.stderr.write('Do not get AVX flag on %s\n' % sysstr)
...@@ -167,10 +190,10 @@ def avx_supported(): ...@@ -167,10 +190,10 @@ def avx_supported():
def run_shell_command(cmd): def run_shell_command(cmd):
import subprocess import subprocess
out, err = subprocess.Popen(cmd,
stdout=subprocess.PIPE, out, err = subprocess.Popen(
stderr=subprocess.PIPE, cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True
shell=True).communicate() ).communicate()
if err: if err:
return None return None
else: else:
...@@ -179,8 +202,9 @@ def run_shell_command(cmd): ...@@ -179,8 +202,9 @@ def run_shell_command(cmd):
def get_dso_path(core_so, dso_name): def get_dso_path(core_so, dso_name):
if core_so and dso_name: if core_so and dso_name:
return run_shell_command("ldd %s|grep %s|awk '{print $3}'" % return run_shell_command(
(core_so, dso_name)) "ldd %s|grep %s|awk '{print $3}'" % (core_so, dso_name)
)
else: else:
return None return None
...@@ -189,6 +213,7 @@ def load_dso(dso_absolute_path): ...@@ -189,6 +213,7 @@ def load_dso(dso_absolute_path):
if dso_absolute_path: if dso_absolute_path:
try: try:
from ctypes import cdll from ctypes import cdll
cdll.LoadLibrary(dso_absolute_path) cdll.LoadLibrary(dso_absolute_path)
except: except:
warnings.warn("Load {} failed".format(dso_absolute_path)) warnings.warn("Load {} failed".format(dso_absolute_path))
...@@ -247,12 +272,14 @@ if platform.system().lower() == 'linux': ...@@ -247,12 +272,14 @@ if platform.system().lower() == 'linux':
try: try:
from . import libpaddle from . import libpaddle
if avx_supported() and not libpaddle.is_compiled_with_avx(): if avx_supported() and not libpaddle.is_compiled_with_avx():
sys.stderr.write( sys.stderr.write(
"Hint: Your machine support AVX, but the installed paddlepaddle doesn't have avx core. " "Hint: Your machine support AVX, but the installed paddlepaddle doesn't have avx core. "
"Hence, no-avx core with worse preformance will be imported.\nIf you like, you could " "Hence, no-avx core with worse preformance will be imported.\nIf you like, you could "
"reinstall paddlepaddle by 'python -m pip install --force-reinstall paddlepaddle-gpu[==version]' " "reinstall paddlepaddle by 'python -m pip install --force-reinstall paddlepaddle-gpu[==version]' "
"to get better performance.\n") "to get better performance.\n"
)
# assign tensor alias # assign tensor alias
libpaddle.LoDTensor = libpaddle.Tensor libpaddle.LoDTensor = libpaddle.Tensor
...@@ -283,6 +310,7 @@ try: ...@@ -283,6 +310,7 @@ try:
from .libpaddle import _Profiler, _ProfilerResult, _RecordEvent from .libpaddle import _Profiler, _ProfilerResult, _RecordEvent
from .libpaddle import _set_current_stream from .libpaddle import _set_current_stream
from .libpaddle import _get_phi_kernel_name from .libpaddle import _get_phi_kernel_name
if sys.platform != 'win32': if sys.platform != 'win32':
from .libpaddle import _set_process_pids from .libpaddle import _set_process_pids
from .libpaddle import _erase_process_pids from .libpaddle import _erase_process_pids
...@@ -295,12 +323,18 @@ try: ...@@ -295,12 +323,18 @@ try:
except Exception as e: except Exception as e:
if has_paddle_dy_lib: if has_paddle_dy_lib:
sys.stderr.write( sys.stderr.write(
'Error: Can not import paddle core while this file exists: ' + 'Error: Can not import paddle core while this file exists: '
current_path + os.sep + 'libpaddle.' + dy_lib_suffix + '\n') + current_path
+ os.sep
+ 'libpaddle.'
+ dy_lib_suffix
+ '\n'
)
if not avx_supported() and libpaddle.is_compiled_with_avx(): if not avx_supported() and libpaddle.is_compiled_with_avx():
sys.stderr.write( sys.stderr.write(
"Error: Your machine doesn't support AVX, but the installed PaddlePaddle is avx core, " "Error: Your machine doesn't support AVX, but the installed PaddlePaddle is avx core, "
"you should reinstall paddlepaddle with no-avx core.\n") "you should reinstall paddlepaddle with no-avx core.\n"
)
raise e raise e
...@@ -317,22 +351,26 @@ def set_paddle_custom_device_lib_path(lib_path): ...@@ -317,22 +351,26 @@ def set_paddle_custom_device_lib_path(lib_path):
# set paddle lib path # set paddle lib path
def set_paddle_lib_path(): def set_paddle_lib_path():
site_dirs = site.getsitepackages() if hasattr( site_dirs = (
site, site.getsitepackages()
'getsitepackages') else [x for x in sys.path if 'site-packages' in x] if hasattr(site, 'getsitepackages')
else [x for x in sys.path if 'site-packages' in x]
)
for site_dir in site_dirs: for site_dir in site_dirs:
lib_dir = os.path.sep.join([site_dir, 'paddle', 'libs']) lib_dir = os.path.sep.join([site_dir, 'paddle', 'libs'])
if os.path.exists(lib_dir): if os.path.exists(lib_dir):
_set_paddle_lib_path(lib_dir) _set_paddle_lib_path(lib_dir)
set_paddle_custom_device_lib_path( set_paddle_custom_device_lib_path(
os.path.sep.join([lib_dir, '..', '..', 'paddle-plugins'])) os.path.sep.join([lib_dir, '..', '..', 'paddle-plugins'])
)
return return
if hasattr(site, 'USER_SITE'): if hasattr(site, 'USER_SITE'):
lib_dir = os.path.sep.join([site.USER_SITE, 'paddle', 'libs']) lib_dir = os.path.sep.join([site.USER_SITE, 'paddle', 'libs'])
if os.path.exists(lib_dir): if os.path.exists(lib_dir):
_set_paddle_lib_path(lib_dir) _set_paddle_lib_path(lib_dir)
set_paddle_custom_device_lib_path( set_paddle_custom_device_lib_path(
os.path.sep.join([lib_dir, '..', '..', 'paddle-plugins'])) os.path.sep.join([lib_dir, '..', '..', 'paddle-plugins'])
)
set_paddle_lib_path() set_paddle_lib_path()
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_activation.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertActivationTest(TrtLayerAutoScanTest): class TrtConvertActivationTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(dims, batch, attrs: List[Dict[str, Any]]): def generate_input1(dims, batch, attrs: List[Dict[str, Any]]):
if dims == 1: if dims == 1:
return np.random.random([32]).astype(np.float32) return np.random.random([32]).astype(np.float32)
...@@ -41,11 +39,19 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -41,11 +39,19 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
for op_type in [ for op_type in [
"relu", "sigmoid", "tanh", "relu6", "elu", "selu", "relu",
"softsign", "stanh", "thresholded_relu", "softplus" "sigmoid",
"tanh",
"relu6",
"elu",
"selu",
"softsign",
"stanh",
"thresholded_relu",
"softplus",
]: ]:
# few samples to reduce time # few samples to reduce time
#for beta in [-0.2, 0.5, 0.67, 3]: # for beta in [-0.2, 0.5, 0.67, 3]:
# for alpha in [-0.2, 0.5, 0.67, 3]: # for alpha in [-0.2, 0.5, 0.67, 3]:
for beta in [0.67]: for beta in [0.67]:
for alpha in [0.67]: for alpha in [0.67]:
...@@ -62,33 +68,34 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -62,33 +68,34 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
if op_type == "softplus": if op_type == "softplus":
dics = [{"beta": beta}] dics = [{"beta": beta}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {"Out": ["output_data"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["output_data"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1, dims, batch, dics
)
)
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -131,19 +138,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -131,19 +138,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_anchor_generator.py
浏览文件 @ 7a0b8625
...@@ -22,60 +22,66 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,60 +22,66 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertAnchorGeneratorTest(TrtLayerAutoScanTest): class TrtConvertAnchorGeneratorTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch, attrs: List[Dict[str, Any]]): def generate_input1(batch, attrs: List[Dict[str, Any]]):
return np.random.random([batch, 3, 64, 64]).astype(np.float32) return np.random.random([batch, 3, 64, 64]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 2, 4]:
for anchor_sizes in [[64.0, 128.0, 256.0, 512.0]]: for anchor_sizes in [[64.0, 128.0, 256.0, 512.0]]:
for aspect_ratios in [[0.5, 1, 2], [0.4, 1.2, 3]]: for aspect_ratios in [[0.5, 1, 2], [0.4, 1.2, 3]]:
for variances in [[1.0, 1.0, 1.0, 1.0], for variances in [
[0.5, 1.0, 0.5, 1.0]]: [1.0, 1.0, 1.0, 1.0],
[0.5, 1.0, 0.5, 1.0],
]:
for stride in [[16.0, 16.0], [16.0, 32.0]]: for stride in [[16.0, 16.0], [16.0, 32.0]]:
for offset in [0.5, 0.8]: for offset in [0.5, 0.8]:
dics = [{ dics = [
"anchor_sizes": anchor_sizes, {
"aspect_ratios": aspect_ratios, "anchor_sizes": anchor_sizes,
"variances": variances, "aspect_ratios": aspect_ratios,
"stride": stride, "variances": variances,
"offset": offset "stride": stride,
}] "offset": offset,
}
ops_config = [{ ]
"op_type": "anchor_generator",
"op_inputs": { ops_config = [
"Input": ["input_data"] {
}, "op_type": "anchor_generator",
"op_outputs": { "op_inputs": {"Input": ["input_data"]},
"Anchors": ["output_anchors"], "op_outputs": {
"Variances": ["output_variances"] "Anchors": ["output_anchors"],
}, "Variances": ["output_variances"],
"op_attrs": dics[0] },
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, batch, dics)) generate_input1, batch, dics
)
)
}, },
outputs=[ outputs=[
"output_anchors", "output_variances" "output_anchors",
]) "output_variances",
],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]}
...@@ -100,19 +106,23 @@ class TrtConvertAnchorGeneratorTest(TrtLayerAutoScanTest): ...@@ -100,19 +106,23 @@ class TrtConvertAnchorGeneratorTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_arg_max.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import List ...@@ -22,7 +22,6 @@ from typing import List
class TrtConvertArgMaxTest(TrtLayerAutoScanTest): class TrtConvertArgMaxTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
input_shape = program_config.inputs["arg_max_input"].shape input_shape = program_config.inputs["arg_max_input"].shape
axis = program_config.ops[0].attrs["axis"] axis = program_config.ops[0].attrs["axis"]
...@@ -33,7 +32,6 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest): ...@@ -33,7 +32,6 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(rank, batch): def generate_input(rank, batch):
dims = [batch] dims = [batch]
for i in range(rank - 1): for i in range(rank - 1):
...@@ -48,36 +46,37 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest): ...@@ -48,36 +46,37 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest):
self.rank = rank self.rank = rank
flatten = False flatten = False
dtype = 2 dtype = 2
ops_config = [{ ops_config = [
"op_type": "arg_max", {
"op_inputs": { "op_type": "arg_max",
"X": ["arg_max_input"] "op_inputs": {"X": ["arg_max_input"]},
}, "op_outputs": {"Out": ["arg_max_out"]},
"op_outputs": { "op_attrs": {
"Out": ["arg_max_out"] "axis": axis,
}, "keepdims": keepdims,
"op_attrs": { "flatten": flatten,
"axis": axis, "dtype": dtype,
"keepdims": keepdims, },
"flatten": flatten,
"dtype": dtype
} }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"arg_max_input": "arg_max_input": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input, rank, batch)) generate_input, rank, batch
)
)
}, },
outputs=["arg_max_out"]) outputs=["arg_max_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.rank == 3: if self.rank == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -117,19 +116,23 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest): ...@@ -117,19 +116,23 @@ class TrtConvertArgMaxTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_bmm.py
浏览文件 @ 7a0b8625
...@@ -12,20 +12,18 @@ ...@@ -12,20 +12,18 @@
# See the License for the specific language governing permissions and # See the License for the specific language governing permissions and
# limitations under the License. # limitations under the License.
from trt_layer_auto_scan_test import TrtLayerAutoScanTest, SkipReasons from trt_layer_auto_scan_test import TrtLayerAutoScanTest
from program_config import TensorConfig, ProgramConfig from program_config import TensorConfig, ProgramConfig
import numpy as np import numpy as np
import paddle.inference as paddle_infer import paddle.inference as paddle_infer
from functools import partial from functools import partial
from typing import Optional, List, Callable, Dict, Any, Set from typing import List
import unittest import unittest
import os import os
class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest): class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest):
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -33,48 +31,47 @@ class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest): ...@@ -33,48 +31,47 @@ class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest):
input1_shape = [batch, 350, 75] input1_shape = [batch, 350, 75]
input2_shape = [batch, 75, 25] input2_shape = [batch, 75, 25]
dics = [{}] dics = [{}]
ops_config = [{ ops_config = [
"op_type": "bmm", {
"op_inputs": { "op_type": "bmm",
"X": ["input1_data"], "op_inputs": {"X": ["input1_data"], "Y": ["input2_data"]},
"Y": ["input2_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input1_shape)
data_gen=partial(generate_input, input1_shape)), ),
"input2_data": "input2_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input, input2_shape)) data_gen=partial(generate_input, input2_shape)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1_data": [10, 350, 75], "input1_data": [10, 350, 75],
"input2_data": [10, 75, 25] "input2_data": [10, 75, 25],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1_data": [100, 350, 75], "input1_data": [100, 350, 75],
"input2_data": [100, 75, 25] "input2_data": [100, 75, 25],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1_data": [15, 350, 75], "input1_data": [15, 350, 75],
"input2_data": [15, 75, 25] "input2_data": [15, 75, 25],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -95,25 +92,29 @@ class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest): ...@@ -95,25 +92,29 @@ class TrtConvertBmmTest_dynamic(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# The output has little diff between gpu and trt in CI-Windows-Inference # The output has little diff between gpu and trt in CI-Windows-Inference
tol_fp32 = 1e-4 tol_fp32 = 1e-4
tol_half = 1e-4 tol_half = 1e-4
if (os.name == 'nt'): if os.name == 'nt':
tol_fp32 = 1e-2 tol_fp32 = 1e-2
tol_half = 1e-2 tol_half = 1e-2
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), tol_fp32 attrs, True
), tol_fp32
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), tol_half attrs, True
), tol_half
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_clip.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertClipTest(TrtLayerAutoScanTest): class TrtConvertClipTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(dims, batch, attrs: List[Dict[str, Any]]): def generate_input1(dims, batch, attrs: List[Dict[str, Any]]):
if dims == 1: if dims == 1:
return np.ones([32]).astype(np.float32) return np.ones([32]).astype(np.float32)
...@@ -46,52 +44,52 @@ class TrtConvertClipTest(TrtLayerAutoScanTest): ...@@ -46,52 +44,52 @@ class TrtConvertClipTest(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
for op_inputs in [{ for op_inputs in [
"X": ["input_data"] {"X": ["input_data"]},
}, { {"X": ["input_data"], "Min": ["Min_"], "Max": ["Max_"]},
"X": ["input_data"], ]:
"Min": ["Min_"],
"Max": ["Max_"]
}]:
self.input_num = len(op_inputs) self.input_num = len(op_inputs)
self.dims = dims self.dims = dims
dics = [{ dics = [
"min": np.random.uniform(1, 10), {
"max": np.random.uniform(10, 20) "min": np.random.uniform(1, 10),
}, { "max": np.random.uniform(10, 20),
"op_inputs": op_inputs
}]
ops_config = [{
"op_type": "clip",
"op_inputs": op_inputs,
"op_outputs": {
"Out": ["output_data"]
}, },
"op_attrs": dics[0] {"op_inputs": op_inputs},
}] ]
ops_config = [
{
"op_type": "clip",
"op_inputs": op_inputs,
"op_outputs": {"Out": ["output_data"]},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"Min_": "Min_": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1, dics)
data_gen=partial(generate_weight1, dics)), ),
"Max_": "Max_": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2, dics)
data_gen=partial(generate_weight2, dics)) ),
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1, dims, batch, dics
)
)
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs(self, program_config): def sample_predictor_configs(self, program_config):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -135,19 +133,23 @@ class TrtConvertClipTest(TrtLayerAutoScanTest): ...@@ -135,19 +133,23 @@ class TrtConvertClipTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_concat.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertConcatTest(TrtLayerAutoScanTest): class TrtConvertConcatTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -31,14 +30,13 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest): ...@@ -31,14 +30,13 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest):
attrs = [ attrs = [
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
] ]
#The input dimension should be less than or equal to the set axis. # The input dimension should be less than or equal to the set axis.
if len(inputs['concat_input1'].shape) <= attrs[0]['axis']: if len(inputs['concat_input1'].shape) <= attrs[0]['axis']:
return False return False
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
if self.dims == 4: if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32) return np.ones([batch, 3, 24, 24]).astype(np.float32)
...@@ -79,58 +77,83 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest): ...@@ -79,58 +77,83 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest):
self.num_input = num_input self.num_input = num_input
self.dims = dims self.dims = dims
dics = [{"axis": axis}, {}] dics = [{"axis": axis}, {}]
dics_intput = [{ dics_intput = [
"X": {
["concat_input1", "concat_input2", "concat_input3"], "X": [
"AxisTensor": ["AxisTensor"], "concat_input1",
}, { "concat_input2",
"X": "concat_input3",
["concat_input1", "concat_input2", "concat_input3"] ],
}] "AxisTensor": ["AxisTensor"],
dics_inputs = [{ },
"concat_input1": {
TensorConfig( "X": [
data_gen=partial(generate_input1, dics, batch)), "concat_input1",
"concat_input2": "concat_input2",
TensorConfig( "concat_input3",
data_gen=partial(generate_input2, dics, batch)), ]
"concat_input3": },
TensorConfig( ]
data_gen=partial(generate_input3, dics, batch)), dics_inputs = [
"AxisTensor": {
TensorConfig( "concat_input1": TensorConfig(
data_gen=partial(generate_weight1, dics)) data_gen=partial(
}, { generate_input1, dics, batch
"concat_input1": )
TensorConfig( ),
data_gen=partial(generate_input1, dics, batch)), "concat_input2": TensorConfig(
"concat_input2": data_gen=partial(
TensorConfig( generate_input2, dics, batch
data_gen=partial(generate_input2, dics, batch)), )
"concat_input3": ),
TensorConfig( "concat_input3": TensorConfig(
data_gen=partial(generate_input3, dics, batch)) data_gen=partial(
}] generate_input3, dics, batch
ops_config = [{ )
"op_type": "concat", ),
"op_inputs": dics_intput[num_input], "AxisTensor": TensorConfig(
"op_outputs": { data_gen=partial(generate_weight1, dics)
"Out": ["concat_output"] ),
},
{
"concat_input1": TensorConfig(
data_gen=partial(
generate_input1, dics, batch
)
),
"concat_input2": TensorConfig(
data_gen=partial(
generate_input2, dics, batch
)
),
"concat_input3": TensorConfig(
data_gen=partial(
generate_input3, dics, batch
)
),
}, },
"op_attrs": dics[0] ]
}] ops_config = [
{
"op_type": "concat",
"op_inputs": dics_intput[num_input],
"op_outputs": {"Out": ["concat_output"]},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs=dics_inputs[num_input], inputs=dics_inputs[num_input],
outputs=["concat_output"]) outputs=["concat_output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.num_input == 0: if self.num_input == 0:
if self.dims == 4: if self.dims == 4:
...@@ -138,76 +161,76 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest): ...@@ -138,76 +161,76 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest):
"concat_input1": [1, 3, 24, 24], "concat_input1": [1, 3, 24, 24],
"concat_input2": [1, 3, 24, 24], "concat_input2": [1, 3, 24, 24],
"concat_input3": [1, 3, 24, 24], "concat_input3": [1, 3, 24, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 3, 48, 48], "concat_input1": [4, 3, 48, 48],
"concat_input2": [4, 3, 48, 48], "concat_input2": [4, 3, 48, 48],
"concat_input3": [4, 3, 48, 48], "concat_input3": [4, 3, 48, 48],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 3, 24, 24], "concat_input1": [1, 3, 24, 24],
"concat_input2": [1, 3, 24, 24], "concat_input2": [1, 3, 24, 24],
"concat_input3": [1, 3, 24, 24], "concat_input3": [1, 3, 24, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [1, 3, 24], "concat_input1": [1, 3, 24],
"concat_input2": [1, 3, 24], "concat_input2": [1, 3, 24],
"concat_input3": [1, 3, 24], "concat_input3": [1, 3, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 12, 48], "concat_input1": [4, 12, 48],
"concat_input2": [4, 12, 48], "concat_input2": [4, 12, 48],
"concat_input3": [4, 12, 48], "concat_input3": [4, 12, 48],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 3, 24], "concat_input1": [1, 3, 24],
"concat_input2": [1, 3, 24], "concat_input2": [1, 3, 24],
"concat_input3": [1, 3, 24], "concat_input3": [1, 3, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
elif self.dims == 2: elif self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [1, 24], "concat_input1": [1, 24],
"concat_input2": [1, 24], "concat_input2": [1, 24],
"concat_input3": [1, 24], "concat_input3": [1, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 48], "concat_input1": [4, 48],
"concat_input2": [4, 48], "concat_input2": [4, 48],
"concat_input3": [4, 48], "concat_input3": [4, 48],
"AxisTensor": [1] "AxisTensor": [1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 24], "concat_input1": [1, 24],
"concat_input2": [1, 24], "concat_input2": [1, 24],
"concat_input3": [1, 24], "concat_input3": [1, 24],
"AxisTensor": [1] "AxisTensor": [1],
} }
elif self.dims == 1: elif self.dims == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [24], "concat_input1": [24],
"concat_input2": [24], "concat_input2": [24],
"concat_input3": [24], "concat_input3": [24],
"AxisTensor": [0] "AxisTensor": [0],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [48], "concat_input1": [48],
"concat_input2": [48], "concat_input2": [48],
"concat_input3": [48], "concat_input3": [48],
"AxisTensor": [0] "AxisTensor": [0],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [24], "concat_input1": [24],
"concat_input2": [24], "concat_input2": [24],
"concat_input3": [24], "concat_input3": [24],
"AxisTensor": [0] "AxisTensor": [0],
} }
elif self.num_input == 1: elif self.num_input == 1:
if self.dims == 4: if self.dims == 4:
...@@ -219,60 +242,60 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest): ...@@ -219,60 +242,60 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest):
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 3, 48, 48], "concat_input1": [4, 3, 48, 48],
"concat_input2": [4, 3, 48, 48], "concat_input2": [4, 3, 48, 48],
"concat_input3": [4, 3, 48, 48] "concat_input3": [4, 3, 48, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 3, 24, 24], "concat_input1": [1, 3, 24, 24],
"concat_input2": [1, 3, 24, 24], "concat_input2": [1, 3, 24, 24],
"concat_input3": [1, 3, 24, 24] "concat_input3": [1, 3, 24, 24],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [1, 3, 24], "concat_input1": [1, 3, 24],
"concat_input2": [1, 3, 24], "concat_input2": [1, 3, 24],
"concat_input3": [1, 3, 24] "concat_input3": [1, 3, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 12, 48], "concat_input1": [4, 12, 48],
"concat_input2": [4, 12, 48], "concat_input2": [4, 12, 48],
"concat_input3": [4, 12, 48] "concat_input3": [4, 12, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 3, 24], "concat_input1": [1, 3, 24],
"concat_input2": [1, 3, 24], "concat_input2": [1, 3, 24],
"concat_input3": [1, 3, 24] "concat_input3": [1, 3, 24],
} }
elif self.dims == 2: elif self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [1, 24], "concat_input1": [1, 24],
"concat_input2": [1, 24], "concat_input2": [1, 24],
"concat_input3": [1, 24] "concat_input3": [1, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [4, 48], "concat_input1": [4, 48],
"concat_input2": [4, 48], "concat_input2": [4, 48],
"concat_input3": [4, 48] "concat_input3": [4, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [1, 24], "concat_input1": [1, 24],
"concat_input2": [1, 24], "concat_input2": [1, 24],
"concat_input3": [1, 24] "concat_input3": [1, 24],
} }
elif self.dims == 1: elif self.dims == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"concat_input1": [24], "concat_input1": [24],
"concat_input2": [24], "concat_input2": [24],
"concat_input3": [24] "concat_input3": [24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"concat_input1": [48], "concat_input1": [48],
"concat_input2": [48], "concat_input2": [48],
"concat_input3": [48] "concat_input3": [48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"concat_input1": [24], "concat_input1": [24],
"concat_input2": [24], "concat_input2": [24],
"concat_input3": [24] "concat_input3": [24],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -296,29 +319,33 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest): ...@@ -296,29 +319,33 @@ class TrtConvertConcatTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(program_config.inputs) == 4: if len(program_config.inputs) == 4:
return True return True
return False return False
self.add_skip_case(teller1, SkipReasons.TRT_NOT_SUPPORT, self.add_skip_case(
"INPUT AxisTensor NOT SUPPORT") teller1, SkipReasons.TRT_NOT_SUPPORT, "INPUT AxisTensor NOT SUPPORT"
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_conv2d_transpose.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -30,8 +29,10 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -30,8 +29,10 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
] ]
if inputs['input_data'].shape[ if (
1] != weights['conv2d_weight'].shape[1] * attrs[0]['groups']: inputs['input_data'].shape[1]
!= weights['conv2d_weight'].shape[1] * attrs[0]['groups']
):
return False return False
if inputs['input_data'].shape[1] != weights['conv2d_weight'].shape[0]: if inputs['input_data'].shape[1] != weights['conv2d_weight'].shape[0]:
...@@ -54,12 +55,13 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -54,12 +55,13 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
def generate_weight1(num_channels, attrs: List[Dict[str, Any]]): def generate_weight1(num_channels, attrs: List[Dict[str, Any]]):
if attrs[0]['groups'] == 1: if attrs[0]['groups'] == 1:
return np.random.random([num_channels, num_channels, 3, return np.random.random(
3]).astype(np.float32) [num_channels, num_channels, 3, 3]
).astype(np.float32)
else: else:
return np.random.random( return np.random.random(
[num_channels, int(num_channels / 2), 3, [num_channels, int(num_channels / 2), 3, 3]
3]).astype(np.float32) ).astype(np.float32)
for num_channels in [2, 4, 6]: for num_channels in [2, 4, 6]:
for batch in [1, 4]: for batch in [1, 4]:
...@@ -67,99 +69,113 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -67,99 +69,113 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
for paddings in [[0, 3], [1, 2, 3, 4]]: for paddings in [[0, 3], [1, 2, 3, 4]]:
for groups in [2]: for groups in [2]:
for padding_algorithm in [ for padding_algorithm in [
'EXPLICIT', 'SAME', 'VALID' 'EXPLICIT',
'SAME',
'VALID',
]: ]:
for dilations in [[2, 2], [1, 2]]: for dilations in [[2, 2], [1, 2]]:
for data_format in ['NCHW']: for data_format in ['NCHW']:
self.num_channels = num_channels self.num_channels = num_channels
dics = [{ dics = [
"data_fromat": data_format, {
"dilations": dilations, "data_fromat": data_format,
"padding_algorithm": "dilations": dilations,
padding_algorithm, "padding_algorithm": padding_algorithm,
"groups": groups, "groups": groups,
"paddings": paddings, "paddings": paddings,
"strides": strides, "strides": strides,
"data_format": data_format, "data_format": data_format,
"output_size": [], "output_size": [],
"output_padding": [] "output_padding": [],
}] }
]
ops_config = [{
"op_type": "conv2d_transpose", ops_config = [
"op_inputs": { {
"Input": ["input_data"], "op_type": "conv2d_transpose",
"Filter": ["conv2d_weight"] "op_inputs": {
}, "Input": ["input_data"],
"op_outputs": { "Filter": ["conv2d_weight"],
"Output": ["output_data"] },
}, "op_outputs": {
"op_attrs": dics[0] "Output": ["output_data"]
}] },
"op_attrs": dics[0],
}
]
ops = self.generate_op_config( ops = self.generate_op_config(
ops_config) ops_config
)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"conv2d_weight": "conv2d_weight": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_weight1, generate_weight1,
num_channels, dics)) num_channels,
dics,
)
)
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, batch, generate_input1,
num_channels, dics)) batch,
num_channels,
dics,
)
)
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.num_channels == 2: if self.num_channels == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 2, 32, 32], "input_data": [1, 2, 32, 32],
"output_data": [1, 24, 32, 32] "output_data": [1, 24, 32, 32],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 2, 64, 64], "input_data": [4, 2, 64, 64],
"output_data": [4, 24, 64, 64] "output_data": [4, 24, 64, 64],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [1, 2, 64, 64], "input_data": [1, 2, 64, 64],
"output_data": [1, 24, 64, 64] "output_data": [1, 24, 64, 64],
} }
elif self.num_channels == 4: elif self.num_channels == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 4, 32, 32], "input_data": [1, 4, 32, 32],
"output_data": [1, 24, 32, 32] "output_data": [1, 24, 32, 32],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 4, 64, 64], "input_data": [4, 4, 64, 64],
"output_data": [4, 24, 64, 64] "output_data": [4, 24, 64, 64],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [1, 4, 64, 64], "input_data": [1, 4, 64, 64],
"output_data": [1, 24, 64, 64] "output_data": [1, 24, 64, 64],
} }
else: else:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 6, 32, 32], "input_data": [1, 6, 32, 32],
"output_data": [1, 24, 32, 32] "output_data": [1, 24, 32, 32],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 6, 64, 64], "input_data": [4, 6, 64, 64],
"output_data": [4, 24, 64, 64] "output_data": [4, 24, 64, 64],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [1, 6, 64, 64], "input_data": [1, 6, 64, 64],
"output_data": [1, 24, 64, 64] "output_data": [1, 24, 64, 64],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -178,10 +194,12 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -178,10 +194,12 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-3) attrs, False
), (1e-3, 1e-3)
# self.trt_param.precision = paddle_infer.PrecisionType.Int8 # self.trt_param.precision = paddle_infer.PrecisionType.Int8
# yield self.create_inference_config(), generate_trt_nodes_num( # yield self.create_inference_config(), generate_trt_nodes_num(
# attrs, False), (1e-5, 1e-5) # attrs, False), (1e-5, 1e-5)
...@@ -190,24 +208,26 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -190,24 +208,26 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-3) attrs, True
), (1e-3, 1e-3)
# self.trt_param.precision = paddle_infer.PrecisionType.Int8 # self.trt_param.precision = paddle_infer.PrecisionType.Int8
# yield self.create_inference_config(), generate_trt_nodes_num( # yield self.create_inference_config(), generate_trt_nodes_num(
# attrs, True), (1e-5, 1e-5) # attrs, True), (1e-5, 1e-5)
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if self.trt_param.precision == paddle_infer.PrecisionType.Int8: if self.trt_param.precision == paddle_infer.PrecisionType.Int8:
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_IMPLEMENTED, teller1,
"When precisionType is int8 without relu op, output is different between Trt and Paddle." SkipReasons.TRT_NOT_IMPLEMENTED,
"When precisionType is int8 without relu op, output is different between Trt and Paddle.",
) )
def test(self): def test(self):
...@@ -221,7 +241,6 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest): ...@@ -221,7 +241,6 @@ class TrtConvertConv2dTransposeTest(TrtLayerAutoScanTest):
# Special case # Special case
class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest): class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
ver = paddle_infer.get_trt_compile_version() ver = paddle_infer.get_trt_compile_version()
if ver[0] * 1000 + ver[1] * 100 + ver[2] * 10 < 7000: if ver[0] * 1000 + ver[1] * 100 + ver[2] * 10 < 7000:
...@@ -241,49 +260,52 @@ class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest): ...@@ -241,49 +260,52 @@ class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest):
batch = 1 batch = 1
self.num_channels = num_channels self.num_channels = num_channels
dics = [{ dics = [
"data_fromat": 'NCHW', {
"dilations": [1, 1], "data_fromat": 'NCHW',
"padding_algorithm": 'EXPLICIT', "dilations": [1, 1],
"groups": 1, "padding_algorithm": 'EXPLICIT',
"paddings": [1, 1], "groups": 1,
"strides": [2, 2], "paddings": [1, 1],
"output_padding": [1, 1], "strides": [2, 2],
"output_size": [], "output_padding": [1, 1],
}] "output_size": [],
}
ops_config = [{ ]
"op_type": "conv2d_transpose",
"op_inputs": { ops_config = [
"Input": ["input_data"], {
"Filter": ["conv2d_weight"] "op_type": "conv2d_transpose",
}, "op_inputs": {
"op_outputs": { "Input": ["input_data"],
"Output": ["output_data"] "Filter": ["conv2d_weight"],
}, },
"op_attrs": dics[0] "op_outputs": {"Output": ["output_data"]},
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"conv2d_weight": "conv2d_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1, num_channels, dics)
data_gen=partial(generate_weight1, num_channels, dics)) )
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, batch, data_gen=partial(generate_input1, batch, num_channels, dics)
num_channels, dics)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 128, 20, 30], "input_data": [1, 128, 20, 30],
...@@ -311,19 +333,23 @@ class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest): ...@@ -311,19 +333,23 @@ class TrtConvertConv2dTransposeTest2(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-4 attrs, False
), 1e-4
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e0, 1e-3) attrs, False
), (1e0, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-4 attrs, True
), 1e-4
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e0, 1e-3) attrs, True
), (1e0, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_dropout.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertDropoutTest(TrtLayerAutoScanTest): class TrtConvertDropoutTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(dims, batch, attrs: List[Dict[str, Any]]): def generate_input1(dims, batch, attrs: List[Dict[str, Any]]):
if dims == 1: if dims == 1:
return np.ones([64]).astype(np.float32) return np.ones([64]).astype(np.float32)
...@@ -42,47 +40,57 @@ class TrtConvertDropoutTest(TrtLayerAutoScanTest): ...@@ -42,47 +40,57 @@ class TrtConvertDropoutTest(TrtLayerAutoScanTest):
for batch in [1, 2, 4]: for batch in [1, 2, 4]:
for fix_seed in [False, True]: for fix_seed in [False, True]:
for dropout_implementation in [ for dropout_implementation in [
"downgrade_in_infer", "upscale_in_train" "downgrade_in_infer",
"upscale_in_train",
]: ]:
for dropout_prob in [np.random.random()]: for dropout_prob in [np.random.random()]:
for seed in [0, 64, 128, 512]: for seed in [0, 64, 128, 512]:
self.dims = dims self.dims = dims
dics = [{ dics = [
"fix_seed": fix_seed, {
"dropout_implementation": "fix_seed": fix_seed,
dropout_implementation, "dropout_implementation": dropout_implementation,
"dropout_prob": dropout_prob, "dropout_prob": dropout_prob,
"seed": seed, "seed": seed,
"is_test": True "is_test": True,
}] }
]
ops_config = [{
"op_type": "dropout", ops_config = [
"op_inputs": { {
"X": ["input_data"], "op_type": "dropout",
}, "op_inputs": {
"op_outputs": { "X": ["input_data"],
"Out": ["dropout_output_data"] },
}, "op_outputs": {
"op_attrs": dics[0] "Out": ["dropout_output_data"]
}] },
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1,
dims,
batch,
dics,
)
)
}, },
outputs=["dropout_output_data"]) outputs=["dropout_output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -128,19 +136,23 @@ class TrtConvertDropoutTest(TrtLayerAutoScanTest): ...@@ -128,19 +136,23 @@ class TrtConvertDropoutTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_elementwise.py
浏览文件 @ 7a0b8625
...@@ -24,12 +24,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -24,12 +24,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
# This is the special test case with weight including batch dimension # This is the special test case with weight including batch dimension
# I don't want to mess up the code written by others, so I wrote a class specifically # I don't want to mess up the code written by others, so I wrote a class specifically
class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -39,44 +37,50 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest): ...@@ -39,44 +37,50 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest):
for batch in [1, 4]: for batch in [1, 4]:
for shape in [[batch, 32, 16, 32]]: for shape in [[batch, 32, 16, 32]]:
for op_type in [ for op_type in [
"elementwise_add", "elementwise_mul", "elementwise_sub", "elementwise_add",
"elementwise_div", "elementwise_pow", "elementwise_min", "elementwise_mul",
"elementwise_max" "elementwise_sub",
"elementwise_div",
"elementwise_pow",
"elementwise_min",
"elementwise_max",
]: ]:
for axis in [-1]: for axis in [-1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data"], "op_inputs": {
"Y": ["weight"] "X": ["input_data"],
}, "Y": ["weight"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"weight": "weight": TensorConfig(
TensorConfig(data_gen=partial(generate_weight)) data_gen=partial(generate_weight)
)
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The input.dims[1] must be equal to the weight's length. # The input.dims[1] must be equal to the weight's length.
if self.dims == 4: if self.dims == 4:
...@@ -106,19 +110,23 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest): ...@@ -106,19 +110,23 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
...@@ -130,12 +138,10 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest): ...@@ -130,12 +138,10 @@ class TrtConvertElementwiseTest_one_input_special_case0(TrtLayerAutoScanTest):
# This is the special test case # This is the special test case
class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -144,44 +150,47 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest): ...@@ -144,44 +150,47 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest):
for shape in [[32]]: for shape in [[32]]:
for op_type in [ for op_type in [
"elementwise_add", "elementwise_mul", "elementwise_sub", "elementwise_add",
"elementwise_div", "elementwise_pow", "elementwise_min", "elementwise_mul",
"elementwise_max" "elementwise_sub",
"elementwise_div",
"elementwise_pow",
"elementwise_min",
"elementwise_max",
]: ]:
for axis in [-1]: for axis in [-1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Y": ["weight"]},
"Y": ["weight"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"weight": "weight": TensorConfig(
TensorConfig(data_gen=partial(generate_weight)) data_gen=partial(generate_weight)
)
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [32]} self.dynamic_shape.min_input_shape = {"input_data": [32]}
self.dynamic_shape.max_input_shape = {"input_data": [64]} self.dynamic_shape.max_input_shape = {"input_data": [64]}
...@@ -205,19 +214,23 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest): ...@@ -205,19 +214,23 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
...@@ -228,12 +241,10 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest): ...@@ -228,12 +241,10 @@ class TrtConvertElementwiseTest_one_input_special_case1(TrtLayerAutoScanTest):
class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -241,47 +252,57 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest): ...@@ -241,47 +252,57 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest):
return np.random.randn(32).astype(np.float32) return np.random.randn(32).astype(np.float32)
for batch in [1, 4]: for batch in [1, 4]:
for shape in [[32], [batch, 32], [batch, 32, 32], for shape in [
[batch, 32, 16, 32]]: [32],
[batch, 32],
[batch, 32, 32],
[batch, 32, 16, 32],
]:
for op_type in [ for op_type in [
"elementwise_add", "elementwise_mul", "elementwise_sub", "elementwise_add",
"elementwise_div", "elementwise_pow", "elementwise_min", "elementwise_mul",
"elementwise_max" "elementwise_sub",
"elementwise_div",
"elementwise_pow",
"elementwise_min",
"elementwise_max",
]: ]:
for axis in [-1 if len(shape) == 1 else 1]: for axis in [-1 if len(shape) == 1 else 1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data"], "op_inputs": {
"Y": ["weight"] "X": ["input_data"],
}, "Y": ["weight"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"weight": "weight": TensorConfig(
TensorConfig(data_gen=partial(generate_weight)) data_gen=partial(generate_weight)
)
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The input.dims[1] must be equal to the weight's length. # The input.dims[1] must be equal to the weight's length.
if self.dims == 1: if self.dims == 1:
...@@ -325,19 +346,23 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest): ...@@ -325,19 +346,23 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
...@@ -348,108 +373,112 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest): ...@@ -348,108 +373,112 @@ class TrtConvertElementwiseTest_one_input(TrtLayerAutoScanTest):
class TrtConvertElementwiseTest_two_input_without_broadcast( class TrtConvertElementwiseTest_two_input_without_broadcast(
TrtLayerAutoScanTest): TrtLayerAutoScanTest
):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
for shape in [[4], [4, 32], [2, 64, 32], [1, 8, 16, 32]]: for shape in [[4], [4, 32], [2, 32, 16], [1, 8, 16, 32]]:
for op_type in [ for op_type in [
"elementwise_add", "elementwise_mul", "elementwise_sub", "elementwise_add",
"elementwise_div", "elementwise_pow", "elementwise_min", "elementwise_mul",
"elementwise_max" "elementwise_sub",
"elementwise_div",
"elementwise_pow",
"elementwise_min",
"elementwise_max",
]: ]:
for axis in [0, -1]: for axis in [0, -1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data1"], "op_inputs": {
"Y": ["input_data2"] "X": ["input_data1"],
}, "Y": ["input_data2"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
"input_data2": "input_data2": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)) ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1], "input_data1": [1],
"input_data2": [1] "input_data2": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [128], "input_data1": [128],
"input_data2": [128] "input_data2": [128],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [32], "input_data1": [32],
"input_data2": [32] "input_data2": [32],
} }
elif self.dims == 2: elif self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 4], "input_data1": [1, 4],
"input_data2": [1, 4] "input_data2": [1, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [128, 256], "input_data1": [128, 256],
"input_data2": [128, 256] "input_data2": [128, 256],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [32, 64], "input_data1": [32, 64],
"input_data2": [32, 64] "input_data2": [32, 64],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 4, 4], "input_data1": [1, 4, 4],
"input_data2": [1, 4, 4] "input_data2": [1, 4, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [128, 128, 256], "input_data1": [128, 128, 256],
"input_data2": [128, 128, 256] "input_data2": [128, 128, 256],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [2, 64, 64], "input_data1": [2, 32, 16],
"input_data2": [2, 64, 64] "input_data2": [2, 32, 16],
} }
elif self.dims == 4: elif self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 4, 4, 4], "input_data1": [1, 4, 4, 4],
"input_data2": [1, 4, 4, 4] "input_data2": [1, 4, 4, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [8, 128, 64, 128], "input_data1": [8, 128, 64, 128],
"input_data2": [8, 128, 64, 128] "input_data2": [8, 128, 64, 128],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [2, 64, 32, 32], "input_data1": [2, 64, 32, 32],
"input_data2": [2, 64, 32, 32] "input_data2": [2, 64, 32, 32],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -470,10 +499,12 @@ class TrtConvertElementwiseTest_two_input_without_broadcast( ...@@ -470,10 +499,12 @@ class TrtConvertElementwiseTest_two_input_without_broadcast(
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
...@@ -491,7 +522,6 @@ class TrtConvertElementwiseTest_two_input_without_broadcast( ...@@ -491,7 +522,6 @@ class TrtConvertElementwiseTest_two_input_without_broadcast(
class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
if len(inputs['input_data1'].shape) != len(inputs['input_data2'].shape): if len(inputs['input_data1'].shape) != len(inputs['input_data2'].shape):
...@@ -500,7 +530,6 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): ...@@ -500,7 +530,6 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -512,8 +541,12 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): ...@@ -512,8 +541,12 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
input2_shape5_list = [[32], [2, 1, 32], [4, 1, 1, 32]] input2_shape5_list = [[32], [2, 1, 32], [4, 1, 1, 32]]
input2_shape6_list = [[1, 32], [1, 32], [1, 1, 1, 32]] input2_shape6_list = [[1, 32], [1, 32], [1, 1, 1, 32]]
input2_shape_list = [ input2_shape_list = [
input2_shape1_list, input2_shape2_list, input2_shape3_list, input2_shape1_list,
input2_shape4_list, input2_shape5_list, input2_shape6_list input2_shape2_list,
input2_shape3_list,
input2_shape4_list,
input2_shape5_list,
input2_shape6_list,
] ]
axis1_list = [[-1], [1, -1], [1, -1]] axis1_list = [[-1], [1, -1], [1, -1]]
axis2_list = [[-1], [0], [0]] axis2_list = [[-1], [0], [0]]
...@@ -522,8 +555,12 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): ...@@ -522,8 +555,12 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
axis5_list = [[-1, 1], [-1, 0], [-1, 0]] axis5_list = [[-1, 1], [-1, 0], [-1, 0]]
axis6_list = [[-1, 0], [-1, 1], [-1, 0]] axis6_list = [[-1, 0], [-1, 1], [-1, 0]]
axis_list = [ axis_list = [
axis1_list, axis2_list, axis3_list, axis4_list, axis5_list, axis1_list,
axis6_list axis2_list,
axis3_list,
axis4_list,
axis5_list,
axis6_list,
] ]
for i in range(3): for i in range(3):
...@@ -531,66 +568,75 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): ...@@ -531,66 +568,75 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
for j in range(6): for j in range(6):
input2_shape = input2_shape_list[j][i] input2_shape = input2_shape_list[j][i]
for op_type in [ for op_type in [
"elementwise_add", "elementwise_add",
"elementwise_mul", "elementwise_mul",
"elementwise_sub", "elementwise_sub",
"elementwise_div", "elementwise_div",
"elementwise_pow", "elementwise_pow",
"elementwise_min", "elementwise_min",
"elementwise_max", "elementwise_max",
]: ]:
for axis in axis_list[j][i]: for axis in axis_list[j][i]:
self.shape1 = input1_shape self.shape1 = input1_shape
self.shape2 = input2_shape self.shape2 = input2_shape
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data1"], "op_inputs": {
"Y": ["input_data2"] "X": ["input_data1"],
}, "Y": ["input_data2"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input, input1_shape)), generate_input, input1_shape
"input_data2": )
TensorConfig(data_gen=partial( ),
generate_input, input2_shape)) "input_data2": TensorConfig(
data_gen=partial(
generate_input, input2_shape
)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
max_shape = [[128], [128, 128], [128, 128, 128], max_shape = [
[128, 128, 128, 128]] [128],
[128, 128],
[128, 128, 128],
[128, 128, 128, 128],
]
min_shape = [[1], [1, 1], [1, 1, 1], [1, 1, 1, 1]] min_shape = [[1], [1, 1], [1, 1, 1], [1, 1, 1, 1]]
opt_shape = [[32], [32, 32], [32, 32, 32], [32, 32, 32, 32]] opt_shape = [[32], [32, 32], [32, 32, 32], [32, 32, 32, 32]]
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": min_shape[len(self.shape1) - 1], "input_data1": min_shape[len(self.shape1) - 1],
"input_data2": min_shape[len(self.shape2) - 1] "input_data2": min_shape[len(self.shape2) - 1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": max_shape[len(self.shape1) - 1], "input_data1": max_shape[len(self.shape1) - 1],
"input_data2": max_shape[len(self.shape2) - 1] "input_data2": max_shape[len(self.shape2) - 1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": opt_shape[len(self.shape1) - 1], "input_data1": opt_shape[len(self.shape1) - 1],
"input_data2": opt_shape[len(self.shape2) - 1] "input_data2": opt_shape[len(self.shape2) - 1],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -626,12 +672,10 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest): ...@@ -626,12 +672,10 @@ class TrtConvertElementwiseTest_two_input_with_broadcast(TrtLayerAutoScanTest):
class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -640,52 +684,58 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): ...@@ -640,52 +684,58 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
return np.random.rand(32).astype(np.float32) return np.random.rand(32).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 2, 4]:
for shape in [[32], [batch, 32], [batch, 32, 32], for shape in [
[batch, 32, 16, 32]]: [32],
[batch, 32],
[batch, 32, 32],
[batch, 32, 16, 32],
]:
for op_type in [ for op_type in [
"elementwise_add", "elementwise_add",
"elementwise_mul", "elementwise_mul",
"elementwise_sub", "elementwise_sub",
"elementwise_div", "elementwise_div",
"elementwise_pow", "elementwise_pow",
"elementwise_min", "elementwise_min",
"elementwise_max", "elementwise_max",
]: ]:
self.op_type = op_type self.op_type = op_type
for axis in [-1 if len(shape) == 1 else 1]: for axis in [-1 if len(shape) == 1 else 1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["weight"], "op_inputs": {
"Y": ["input_data"] "X": ["weight"],
}, "Y": ["input_data"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"weight": "weight": TensorConfig(
TensorConfig(data_gen=partial(generate_weight)) data_gen=partial(generate_weight)
)
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The input.dims[1] must be equal to the weight's length. # The input.dims[1] must be equal to the weight's length.
if self.dims == 1: if self.dims == 1:
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_equal.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
attrs = [ attrs = [
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
...@@ -35,7 +34,6 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): ...@@ -35,7 +34,6 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -44,86 +42,84 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): ...@@ -44,86 +42,84 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
for axis in [-1 if len(shape) == 1 else 1]: for axis in [-1 if len(shape) == 1 else 1]:
self.dims = len(shape) self.dims = len(shape)
dics = [{"axis": axis}, {"in_dtype": 0, "out_dtype": 5}] dics = [{"axis": axis}, {"in_dtype": 0, "out_dtype": 5}]
ops_config = [{ ops_config = [
"op_type": "equal", {
"op_inputs": { "op_type": "equal",
"X": ["input_data1"], "op_inputs": {
"Y": ["input_data2"] "X": ["input_data1"],
}, "Y": ["input_data2"],
"op_outputs": { },
"Out": ["compare_output_data"] "op_outputs": {"Out": ["compare_output_data"]},
"op_attrs": dics[0],
}, },
"op_attrs": dics[0] {
}, { "op_type": "cast",
"op_type": "cast", "op_inputs": {"X": ["compare_output_data"]},
"op_inputs": { "op_outputs": {"Out": ["output_data"]},
"X": ["compare_output_data"] "op_attrs": dics[1],
}, },
"op_outputs": { ]
"Out": ["output_data"]
},
"op_attrs": dics[1]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)), ),
"input_data2": "input_data2": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)) ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The input.dims[1] must be equal to the weight's length. # The input.dims[1] must be equal to the weight's length.
if self.dims == 2: if self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 1], "input_data1": [1, 1],
"input_data2": [1, 1] "input_data2": [1, 1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [4, 1], "input_data1": [4, 1],
"input_data2": [4, 1] "input_data2": [4, 1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [2, 1], "input_data1": [2, 1],
"input_data2": [2, 1] "input_data2": [2, 1],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 1, 4], "input_data1": [1, 1, 4],
"input_data2": [1, 1, 4] "input_data2": [1, 1, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [4, 1, 256], "input_data1": [4, 1, 256],
"input_data2": [1, 1, 256] "input_data2": [1, 1, 256],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [2, 1, 16], "input_data1": [2, 1, 16],
"input_data2": [2, 1, 16] "input_data2": [2, 1, 16],
} }
elif self.dims == 4: elif self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 1, 4, 4], "input_data1": [1, 1, 4, 4],
"input_data2": [1, 1, 4, 4] "input_data2": [1, 1, 4, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [4, 1, 128, 256], "input_data1": [4, 1, 128, 256],
"input_data2": [4, 1, 128, 256] "input_data2": [4, 1, 128, 256],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [2, 1, 32, 16], "input_data1": [2, 1, 32, 16],
"input_data2": [2, 1, 32, 16] "input_data2": [2, 1, 32, 16],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -144,19 +140,23 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest): ...@@ -144,19 +140,23 @@ class TrtConvertElementwiseTest_one_input_corner_case(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_fc.py
浏览文件 @ 7a0b8625
...@@ -23,10 +23,9 @@ import os ...@@ -23,10 +23,9 @@ import os
class TrtConvertFcTest(TrtLayerAutoScanTest): class TrtConvertFcTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
# The output has diff between gpu and trt in CI windows # The output has diff between gpu and trt in CI windows
if (os.name == 'nt'): if os.name == 'nt':
return False return False
return True return True
...@@ -34,12 +33,14 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -34,12 +33,14 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
self.trt_param.workspace_size = 1073741824 self.trt_param.workspace_size = 1073741824
def generate_input1(batch, attrs: List[Dict[str, Any]]): def generate_input1(batch, attrs: List[Dict[str, Any]]):
return np.random.random([batch, 3, 64, (int)(attrs[0]["m"] / 2), return np.random.random(
2]).astype(np.float32) [batch, 3, 64, (int)(attrs[0]["m"] / 2), 2]
).astype(np.float32)
def generate_w(batch, attrs: List[Dict[str, Any]]): def generate_w(batch, attrs: List[Dict[str, Any]]):
return np.random.random([attrs[0]["m"], return np.random.random([attrs[0]["m"], attrs[0]["n"]]).astype(
attrs[0]["n"]]).astype(np.float32) np.float32
)
def generate_bias(batch, attrs: List[Dict[str, Any]]): def generate_bias(batch, attrs: List[Dict[str, Any]]):
return np.random.random([attrs[0]["n"]]).astype(np.float32) return np.random.random([attrs[0]["n"]]).astype(np.float32)
...@@ -53,7 +54,7 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -53,7 +54,7 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
"m": m, "m": m,
"n": n, "n": n,
}, },
{} {},
] ]
ops_config = [ ops_config = [
...@@ -62,12 +63,10 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -62,12 +63,10 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
"op_inputs": { "op_inputs": {
"Input": ["input_data"], "Input": ["input_data"],
"W": ["w_data"], "W": ["w_data"],
"Bias": ["bias_data"] "Bias": ["bias_data"],
},
"op_outputs": {
"Out": ["output_data"]
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["output_data"]},
"op_attrs": dics[0],
}, },
] ]
...@@ -76,24 +75,26 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -76,24 +75,26 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"w_data": "w_data": TensorConfig(
TensorConfig(data_gen=partial(generate_w, batch, dics)), data_gen=partial(generate_w, batch, dics)
"bias_data": ),
TensorConfig( "bias_data": TensorConfig(
data_gen=partial(generate_bias, batch, dics)) data_gen=partial(generate_bias, batch, dics)
),
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, batch, dics)
data_gen=partial(generate_input1, batch, dics)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 3, 32, 16, 2], "input_data": [1, 3, 32, 16, 2],
...@@ -121,19 +122,23 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -121,19 +122,23 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
# clear_dynamic_shape() # clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
...@@ -143,10 +148,9 @@ class TrtConvertFcTest(TrtLayerAutoScanTest): ...@@ -143,10 +148,9 @@ class TrtConvertFcTest(TrtLayerAutoScanTest):
class TrtConvertFcTest2(TrtLayerAutoScanTest): class TrtConvertFcTest2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
# The output has diff between gpu and trt in CI windows # The output has diff between gpu and trt in CI windows
if (os.name == 'nt'): if os.name == 'nt':
return False return False
return True return True
...@@ -157,8 +161,9 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest): ...@@ -157,8 +161,9 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest):
return np.random.random([batch, 3, 64, 14]).astype(np.float32) return np.random.random([batch, 3, 64, 14]).astype(np.float32)
def generate_w(batch, attrs: List[Dict[str, Any]]): def generate_w(batch, attrs: List[Dict[str, Any]]):
return np.random.random([attrs[0]["m"], return np.random.random([attrs[0]["m"], attrs[0]["n"]]).astype(
attrs[0]["n"]]).astype(np.float32) np.float32
)
def generate_bias(batch, attrs: List[Dict[str, Any]]): def generate_bias(batch, attrs: List[Dict[str, Any]]):
return np.random.random([attrs[0]["n"]]).astype(np.float32) return np.random.random([attrs[0]["n"]]).astype(np.float32)
...@@ -172,7 +177,7 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest): ...@@ -172,7 +177,7 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest):
"m": m, "m": m,
"n": n, "n": n,
}, },
{} {},
] ]
ops_config = [ ops_config = [
...@@ -181,12 +186,10 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest): ...@@ -181,12 +186,10 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest):
"op_inputs": { "op_inputs": {
"Input": ["input_data"], "Input": ["input_data"],
"W": ["w_data"], "W": ["w_data"],
"Bias": ["bias_data"] "Bias": ["bias_data"],
}, },
"op_outputs": { "op_outputs": {"Out": ["output_data"]},
"Out": ["output_data"] "op_attrs": dics[0],
},
"op_attrs": dics[0]
}, },
] ]
...@@ -195,24 +198,26 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest): ...@@ -195,24 +198,26 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"w_data": "w_data": TensorConfig(
TensorConfig(data_gen=partial(generate_w, batch, dics)), data_gen=partial(generate_w, batch, dics)
"bias_data": ),
TensorConfig( "bias_data": TensorConfig(
data_gen=partial(generate_bias, batch, dics)) data_gen=partial(generate_bias, batch, dics)
),
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, batch, dics)
data_gen=partial(generate_input1, batch, dics)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 3, 32, 14], "input_data": [1, 3, 32, 14],
...@@ -234,14 +239,14 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest): ...@@ -234,14 +239,14 @@ class TrtConvertFcTest2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), (1e-5, 1e-5) yield self.create_inference_config(), (1, 2), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), (1e-5, 1e-5) yield self.create_inference_config(), (1, 2), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
...@@ -277,7 +282,7 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest): ...@@ -277,7 +282,7 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest):
"m": m, "m": m,
"n": n, "n": n,
}, },
{} {},
] ]
ops_config = [ ops_config = [
...@@ -286,12 +291,10 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest): ...@@ -286,12 +291,10 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest):
"op_inputs": { "op_inputs": {
"Input": ["input_data"], "Input": ["input_data"],
"W": ["w_data"], "W": ["w_data"],
"Bias": ["bias_data"] "Bias": ["bias_data"],
}, },
"op_outputs": { "op_outputs": {"Out": ["output_data"]},
"Out": ["output_data"] "op_attrs": dics[0],
},
"op_attrs": dics[0]
}, },
] ]
...@@ -300,24 +303,26 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest): ...@@ -300,24 +303,26 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"w_data": "w_data": TensorConfig(
TensorConfig(data_gen=partial(generate_w, batch, dics)), data_gen=partial(generate_w, batch, dics)
"bias_data": ),
TensorConfig( "bias_data": TensorConfig(
data_gen=partial(generate_bias, batch, dics)) data_gen=partial(generate_bias, batch, dics)
),
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, batch, dics)
data_gen=partial(generate_input1, batch, dics)), ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 14, 1, 2], "input_data": [1, 14, 1, 2],
...@@ -339,16 +344,16 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest): ...@@ -339,16 +344,16 @@ class TrtConvertFcTest3(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), (1e-5, 1e-5) yield self.create_inference_config(), (1, 2), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), (1e-5, 1e-5) yield self.create_inference_config(), (1, 2), (1e-3, 1e-3)
self.trt_param.precision = paddle_infer.PrecisionType.Int8 self.trt_param.precision = paddle_infer.PrecisionType.Int8
yield self.create_inference_config(), (1, 2), (1e-5, 1e-5) yield self.create_inference_config(), (1, 2), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_fill_constant.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertSplitTest(TrtLayerAutoScanTest): class TrtConvertSplitTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_value_data(attrs: List[Dict[str, Any]]): def generate_value_data(attrs: List[Dict[str, Any]]):
return np.array([1]).astype(np.int32) return np.array([1]).astype(np.int32)
...@@ -47,21 +45,28 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -47,21 +45,28 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
str_value = str_value str_value = str_value
else: else:
str_value = "" str_value = ""
dics = [{ dics = [
"str_value": str_value, {
"value": value, "str_value": str_value,
"shape": shape, "value": value,
"dtype": dtype "shape": shape,
}, { "dtype": dtype,
"axis": -1 },
}] {"axis": -1},
dics_intput = [{ ]
"ValueTensor": ["value_data"] dics_intput = [
}, { {"ValueTensor": ["value_data"]},
"ShapeTensor": ["shape_data"], {
}, { "ShapeTensor": ["shape_data"],
"ShapeTensorList": ["shapeT1_data", "shapeT2_data"], },
}, {}] {
"ShapeTensorList": [
"shapeT1_data",
"shapeT2_data",
],
},
{},
]
ops_config = [ ops_config = [
{ {
"op_type": "fill_constant", "op_type": "fill_constant",
...@@ -69,7 +74,7 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -69,7 +74,7 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
"op_outputs": { "op_outputs": {
"Out": ["out_data"], "Out": ["out_data"],
}, },
"op_attrs": dics[0] "op_attrs": dics[0],
}, },
] ]
...@@ -81,26 +86,31 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -81,26 +86,31 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"value_data": "value_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(generate_value_data, dics)
generate_value_data, dics)), ),
"shape_data": "shape_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(generate_shape_data, dics)
generate_shape_data, dics)), ),
"shapeT1_data": "shapeT1_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_shapelist_data, dics)), generate_shapelist_data, dics
"shapeT2_data": )
TensorConfig(data_gen=partial( ),
generate_shapelist_data, dics)), "shapeT2_data": TensorConfig(
data_gen=partial(
generate_shapelist_data, dics
)
),
}, },
outputs=["out_data"]) outputs=["out_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.input_shape = [1, 1] self.input_shape = [1, 1]
max_shape = list(self.input_shape) max_shape = list(self.input_shape)
...@@ -118,7 +128,7 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -118,7 +128,7 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
self.dynamic_shape.opt_input_shape = {} self.dynamic_shape.opt_input_shape = {}
def generate_trt_nodes_num(attrs, dynamic_shape): def generate_trt_nodes_num(attrs, dynamic_shape):
if (self.num_input < 3): if self.num_input < 3:
return 0, 6 return 0, 6
return 1, 5 return 1, 5
...@@ -131,10 +141,12 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -131,10 +141,12 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_flatten.py
浏览文件 @ 7a0b8625
...@@ -22,16 +22,14 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,16 +22,14 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest): class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(batch): def generate_input(batch):
return np.random.random([batch, 32]).astype(np.float32) return np.random.random([batch, 32]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 4]:
for axis in [0, 1]: for axis in [0, 1]:
for type in ["flatten", "flatten2"]: for type in ["flatten", "flatten2"]:
if type == "flatten": if type == "flatten":
...@@ -39,34 +37,35 @@ class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest): ...@@ -39,34 +37,35 @@ class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest):
else: else:
op_outputs = { op_outputs = {
"Out": ["output_data"], "Out": ["output_data"],
"XShape": ["xshape_data"] "XShape": ["xshape_data"],
} }
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": "flatten", {
"op_inputs": { "op_type": "flatten",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": op_outputs,
"op_outputs": op_outputs, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, batch)
data_gen=partial(generate_input, batch)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 8]} self.dynamic_shape.min_input_shape = {"input_data": [1, 8]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 64]}
...@@ -100,35 +99,37 @@ class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest): ...@@ -100,35 +99,37 @@ class TrtConvertFlattenTest_dim_2(TrtLayerAutoScanTest):
# for static_shape # for static_shape
clear_dynamic_shape() clear_dynamic_shape()
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest): class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(batch): def generate_input(batch):
return np.random.random([batch, 32, 64]).astype(np.float32) return np.random.random([batch, 32, 64]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 4]:
for axis in [0, 1, 2]: for axis in [0, 1, 2]:
for type in ["flatten", "flatten2"]: for type in ["flatten", "flatten2"]:
if type == "flatten": if type == "flatten":
...@@ -136,38 +137,39 @@ class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest): ...@@ -136,38 +137,39 @@ class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest):
else: else:
op_outputs = { op_outputs = {
"Out": ["output_data"], "Out": ["output_data"],
"XShape": ["xshape_data"] "XShape": ["xshape_data"],
} }
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": "flatten", {
"op_inputs": { "op_type": "flatten",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": op_outputs,
"op_outputs": op_outputs, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, batch)
data_gen=partial(generate_input, batch)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 8, 8]} self.dynamic_shape.min_input_shape = {"input_data": [1, 8, 8]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 64, 768]} self.dynamic_shape.max_input_shape = {"input_data": [4, 32, 64]}
self.dynamic_shape.opt_input_shape = {"input_data": [2, 32, 256]} self.dynamic_shape.opt_input_shape = {"input_data": [2, 32, 64]}
def clear_dynamic_shape(): def clear_dynamic_shape():
self.dynamic_shape.max_input_shape = {} self.dynamic_shape.max_input_shape = {}
...@@ -198,35 +200,37 @@ class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest): ...@@ -198,35 +200,37 @@ class TrtConvertFlattenTest_dim_3(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest): class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(batch): def generate_input(batch):
return np.random.random([batch, 8, 8, 8]).astype(np.float32) return np.random.random([batch, 8, 8, 8]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 4]:
for axis in [0, 1, 2, 3]: for axis in [0, 1, 2, 3]:
for type in ["flatten", "flatten2"]: for type in ["flatten", "flatten2"]:
if type == "flatten": if type == "flatten":
...@@ -234,37 +238,38 @@ class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest): ...@@ -234,37 +238,38 @@ class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest):
else: else:
op_outputs = { op_outputs = {
"Out": ["output_data"], "Out": ["output_data"],
"XShape": ["xshape_data"] "XShape": ["xshape_data"],
} }
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": "flatten", {
"op_inputs": { "op_type": "flatten",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": op_outputs,
"op_outputs": op_outputs, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, batch)
data_gen=partial(generate_input, batch)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 4, 4, 4]} self.dynamic_shape.min_input_shape = {"input_data": [1, 4, 4, 4]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 32, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 32, 32, 32]}
self.dynamic_shape.opt_input_shape = {"input_data": [2, 16, 16, 8]} self.dynamic_shape.opt_input_shape = {"input_data": [2, 16, 16, 8]}
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -294,36 +299,39 @@ class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest): ...@@ -294,36 +299,39 @@ class TrtConvertFlattenTest_dim_4(TrtLayerAutoScanTest):
# for static_shape # for static_shape
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest): class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(batch): def generate_input(batch):
return np.random.random([batch, 8, 8, 8]).astype(np.float32) return np.random.random([batch, 8, 8, 8]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 4]:
for axis in [0, 1, 2, 3, 4]: for axis in [0, 1, 2, 3, 4]:
for type in ["flatten", "flatten2"]: for type in ["flatten", "flatten2"]:
if type == "flatten": if type == "flatten":
...@@ -331,37 +339,38 @@ class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest): ...@@ -331,37 +339,38 @@ class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest):
else: else:
op_outputs = { op_outputs = {
"Out": ["output_data"], "Out": ["output_data"],
"XShape": ["xshape_data"] "XShape": ["xshape_data"],
} }
dics = [{"axis": axis}] dics = [{"axis": axis}]
ops_config = [{ ops_config = [
"op_type": "flatten", {
"op_inputs": { "op_type": "flatten",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": op_outputs,
"op_outputs": op_outputs, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, batch)
data_gen=partial(generate_input, batch)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 4, 4, 4]} self.dynamic_shape.min_input_shape = {"input_data": [1, 4, 4, 4]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 32, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 16, 16, 8]}
self.dynamic_shape.opt_input_shape = {"input_data": [2, 16, 16, 8]} self.dynamic_shape.opt_input_shape = {"input_data": [2, 16, 16, 8]}
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -391,20 +400,25 @@ class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest): ...@@ -391,20 +400,25 @@ class TrtConvertFlattenTest_dim_5(TrtLayerAutoScanTest):
# for static_shape # for static_shape
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_gather.py
浏览文件 @ 7a0b8625
...@@ -23,7 +23,6 @@ import unittest ...@@ -23,7 +23,6 @@ import unittest
class TrtConvertGatherTest(TrtLayerAutoScanTest): class TrtConvertGatherTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
attrs = [ attrs = [
...@@ -35,7 +34,6 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest): ...@@ -35,7 +34,6 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(shape): def generate_input1(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -52,112 +50,126 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest): ...@@ -52,112 +50,126 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest):
for index in [[1, 4], [4, 8]]: for index in [[1, 4], [4, 8]]:
for axis in [0, 1, 2, 3]: for axis in [0, 1, 2, 3]:
for overwrite in [True, False]: for overwrite in [True, False]:
for input in [{ for input in [
"X": ["input_data"], {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] {
}, {
"X": ["input_data"], "X": ["input_data"],
"Index": ["index_data"], "Index": ["index_data"],
"Axis": ["axis_data"] "Axis": ["axis_data"],
}]: },
]:
for index_type_int32 in [True, False]: for index_type_int32 in [True, False]:
self.shape = shape self.shape = shape
self.axis = axis self.axis = axis
self.input_num = len(input) self.input_num = len(input)
self.index_type_int32 = index_type_int32 self.index_type_int32 = index_type_int32
dics = [{"overwrite": overwrite, "axis": axis}] dics = [{"overwrite": overwrite, "axis": axis}]
ops_config = [{ ops_config = [
"op_type": "gather", {
"op_inputs": input, "op_type": "gather",
"op_outputs": { "op_inputs": input,
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, shape)), generate_input1, shape
"index_data": )
TensorConfig(data_gen=partial( ),
generate_input2 "index_data": TensorConfig(
if index_type_int32 == data_gen=partial(
True else generate_input4, index)), generate_input2
} if len(input) == 2 else { if index_type_int32 == True
"input_data": else generate_input4,
TensorConfig(data_gen=partial( index,
generate_input1, shape)), )
"index_data": ),
TensorConfig(data_gen=partial( }
generate_input2, index)), if len(input) == 2
"axis_data": else {
TensorConfig(data_gen=partial( "input_data": TensorConfig(
generate_input3, axis)), data_gen=partial(
generate_input1, shape
)
),
"index_data": TensorConfig(
data_gen=partial(
generate_input2, index
)
),
"axis_data": TensorConfig(
data_gen=partial(
generate_input3, axis
)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if len(self.shape) == 1: if len(self.shape) == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [4], "input_data": [4],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [128], "input_data": [128],
"index_data": [4] "index_data": [4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [16], "input_data": [16],
"index_data": [2] "index_data": [2],
} }
elif len(self.shape) == 2: elif len(self.shape) == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [2, 4], "input_data": [2, 4],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [256, 256], "input_data": [256, 256],
"index_data": [4] "index_data": [4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [64, 32], "input_data": [64, 32],
"index_data": [2] "index_data": [2],
} }
elif len(self.shape) == 3: elif len(self.shape) == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [2, 4, 4], "input_data": [2, 4, 4],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [128, 256, 256], "input_data": [128, 256, 256],
"index_data": [4] "index_data": [4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [16, 64, 32], "input_data": [16, 64, 32],
"index_data": [2] "index_data": [2],
} }
elif len(self.shape) == 4: elif len(self.shape) == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [2, 4, 4, 2], "input_data": [2, 4, 4, 2],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [128, 256, 64, 128], "input_data": [128, 256, 64, 128],
"index_data": [4] "index_data": [4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [16, 64, 16, 32], "input_data": [16, 64, 16, 32],
"index_data": [2] "index_data": [2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -182,10 +194,12 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest): ...@@ -182,10 +194,12 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
...@@ -201,14 +215,17 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest): ...@@ -201,14 +215,17 @@ class TrtConvertGatherTest(TrtLayerAutoScanTest):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0: if len(self.dynamic_shape.min_input_shape) != 0:
inputs = program_config.inputs inputs = program_config.inputs
if len(inputs['input_data'].shape) == 1 or len( if (
inputs['index_data'].shape) == 1: len(inputs['input_data'].shape) == 1
or len(inputs['index_data'].shape) == 1
):
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Need to repair the case: trt reshape out failed for dynamic shape mode when inputs' dims==1. under trt7.0 " SkipReasons.TRT_NOT_SUPPORT,
"Need to repair the case: trt reshape out failed for dynamic shape mode when inputs' dims==1. under trt7.0 ",
) )
def test(self): def test(self):
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_gather_nd.py
浏览文件 @ 7a0b8625
...@@ -23,7 +23,6 @@ import os ...@@ -23,7 +23,6 @@ import os
class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
# The output has diff between gpu and trt in CI windows # The output has diff between gpu and trt in CI windows
# if ( and self.trt_param.precision == paddle_infer.PrecisionType.Half): # if ( and self.trt_param.precision == paddle_infer.PrecisionType.Half):
...@@ -31,54 +30,53 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest): ...@@ -31,54 +30,53 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([2, 32, 64, 64]).astype(np.float32) return np.random.random([2, 32, 64, 64]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.ones([1]).astype(np.int32) return np.ones([1]).astype(np.int32)
ops_config = [{ ops_config = [
"op_type": "gather_nd", {
"op_inputs": { "op_type": "gather_nd",
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
"index_data": ),
TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(
data_gen=partial(generate_input2)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 8, 8, 8], "input_data": [1, 8, 8, 8],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 32, 64, 64], "input_data": [4, 32, 64, 64],
"index_data": [1] "index_data": [1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 32, 64, 64], "input_data": [2, 32, 64, 64],
"index_data": [1] "index_data": [1],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -95,25 +93,26 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest): ...@@ -95,25 +93,26 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt': if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt':
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Under Windows Ci, this case will sporadically fail.") SkipReasons.TRT_NOT_SUPPORT,
"Under Windows Ci, this case will sporadically fail.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -121,29 +120,24 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest): ...@@ -121,29 +120,24 @@ class TrtConvertGatherNdTest_dim_4_1(TrtLayerAutoScanTest):
class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([2, 32, 64, 64]).astype(np.float32) return np.random.random([2, 32, 64, 64]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.array([1, 2]).astype(np.int32) return np.array([1, 2]).astype(np.int32)
ops_config = [{ ops_config = [
"op_type": "gather_nd", {
"op_inputs": { "op_type": "gather_nd",
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
...@@ -153,25 +147,26 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest): ...@@ -153,25 +147,26 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest):
"input_data": TensorConfig(data_gen=partial(generate_input1)), "input_data": TensorConfig(data_gen=partial(generate_input1)),
"index_data": TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(data_gen=partial(generate_input2)),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 8, 8, 8], "input_data": [1, 8, 8, 8],
"index_data": [2] "index_data": [2],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 32, 64, 64], "input_data": [4, 32, 64, 64],
"index_data": [2] "index_data": [2],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 32, 64, 64], "input_data": [2, 32, 64, 64],
"index_data": [2] "index_data": [2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -188,25 +183,26 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest): ...@@ -188,25 +183,26 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt': if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt':
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Under Windows Ci, this case will sporadically fail.") SkipReasons.TRT_NOT_SUPPORT,
"Under Windows Ci, this case will sporadically fail.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -214,29 +210,24 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest): ...@@ -214,29 +210,24 @@ class TrtConvertGatherNdTest_dim_4_1_2(TrtLayerAutoScanTest):
class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([2, 32, 64, 64]).astype(np.float32) return np.random.random([2, 32, 64, 64]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.ones([2, 2]).astype(np.int32) return np.ones([2, 2]).astype(np.int32)
ops_config = [{ ops_config = [
"op_type": "gather_nd", {
"op_inputs": { "op_type": "gather_nd",
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
...@@ -246,25 +237,26 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest): ...@@ -246,25 +237,26 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest):
"input_data": TensorConfig(data_gen=partial(generate_input1)), "input_data": TensorConfig(data_gen=partial(generate_input1)),
"index_data": TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(data_gen=partial(generate_input2)),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 8, 8, 8], "input_data": [1, 8, 8, 8],
"index_data": [2, 2] "index_data": [2, 2],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 32, 64, 64], "input_data": [4, 32, 64, 64],
"index_data": [2, 2] "index_data": [2, 2],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 32, 64, 64], "input_data": [2, 32, 64, 64],
"index_data": [2, 2] "index_data": [2, 2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -281,25 +273,26 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest): ...@@ -281,25 +273,26 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt': if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt':
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Under Windows Ci, this case will sporadically fail.") SkipReasons.TRT_NOT_SUPPORT,
"Under Windows Ci, this case will sporadically fail.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -307,29 +300,24 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest): ...@@ -307,29 +300,24 @@ class TrtConvertGatherNdTest_dim_4_2(TrtLayerAutoScanTest):
class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([2, 32, 64, 64]).astype(np.float32) return np.random.random([2, 32, 64, 64]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.ones([2, 2, 4]).astype(np.int32) return np.ones([2, 2, 4]).astype(np.int32)
ops_config = [{ ops_config = [
"op_type": "gather_nd", {
"op_inputs": { "op_type": "gather_nd",
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
...@@ -339,25 +327,26 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest): ...@@ -339,25 +327,26 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest):
"input_data": TensorConfig(data_gen=partial(generate_input1)), "input_data": TensorConfig(data_gen=partial(generate_input1)),
"index_data": TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(data_gen=partial(generate_input2)),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 8, 8, 8], "input_data": [1, 8, 8, 8],
"index_data": [2, 2, 4] "index_data": [2, 2, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 32, 64, 64], "input_data": [4, 32, 64, 64],
"index_data": [2, 2, 4] "index_data": [2, 2, 4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 32, 64, 64], "input_data": [2, 32, 64, 64],
"index_data": [2, 2, 4] "index_data": [2, 2, 4],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -374,25 +363,26 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest): ...@@ -374,25 +363,26 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt': if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt':
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Under Windows Ci, this case will sporadically fail.") SkipReasons.TRT_NOT_SUPPORT,
"Under Windows Ci, this case will sporadically fail.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -400,29 +390,24 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest): ...@@ -400,29 +390,24 @@ class TrtConvertGatherNdTest_dim_4_3(TrtLayerAutoScanTest):
class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([2, 32]).astype(np.float32) return np.random.random([2, 32]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.array([[0, 3], [1, 9]]).astype(np.int32) return np.array([[0, 3], [1, 9]]).astype(np.int32)
ops_config = [{ ops_config = [
"op_type": "gather_nd", {
"op_inputs": { "op_type": "gather_nd",
"X": ["input_data"], "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
"Index": ["index_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_outputs": { }
"Out": ["output_data"] ]
},
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
...@@ -432,25 +417,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest): ...@@ -432,25 +417,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest):
"input_data": TensorConfig(data_gen=partial(generate_input1)), "input_data": TensorConfig(data_gen=partial(generate_input1)),
"index_data": TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(data_gen=partial(generate_input2)),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 4], "input_data": [1, 4],
"index_data": [2, 2] "index_data": [2, 2],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [4, 64], "input_data": [4, 64],
"index_data": [2, 2] "index_data": [2, 2],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 8], "input_data": [2, 8],
"index_data": [2, 2] "index_data": [2, 2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -467,25 +453,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest): ...@@ -467,25 +453,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt': if len(self.dynamic_shape.min_input_shape) != 0 and os.name == 'nt':
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"Under Windows Ci, this case will sporadically fail.") SkipReasons.TRT_NOT_SUPPORT,
"Under Windows Ci, this case will sporadically fail.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -493,30 +480,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest): ...@@ -493,30 +480,26 @@ class TrtConvertGatherNdTest_dim_2_2(TrtLayerAutoScanTest):
class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest): class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([16, 32, 256]).astype(np.float32) return np.random.random([16, 32, 256]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.array([[[2, 5], [3, 8]], [[0, 2], [0, return np.array([[[2, 5], [3, 8]], [[0, 2], [0, 3]]]).astype(
3]]]).astype(np.int32) np.int32
)
ops_config = [{
"op_type": "gather_nd", ops_config = [
"op_inputs": { {
"X": ["input_data"], "op_type": "gather_nd",
"Index": ["index_data"] "op_inputs": {"X": ["input_data"], "Index": ["index_data"]},
}, "op_outputs": {"Out": ["output_data"]},
"op_outputs": { "op_attrs": {},
"Out": ["output_data"] }
}, ]
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
...@@ -526,25 +509,26 @@ class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest): ...@@ -526,25 +509,26 @@ class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest):
"input_data": TensorConfig(data_gen=partial(generate_input1)), "input_data": TensorConfig(data_gen=partial(generate_input1)),
"index_data": TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(data_gen=partial(generate_input2)),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 4, 4], "input_data": [1, 4, 4],
"index_data": [1, 1, 1] "index_data": [1, 1, 1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [16, 64, 512], "input_data": [16, 64, 512],
"index_data": [4, 2, 4] "index_data": [4, 2, 4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [2, 8, 64], "input_data": [2, 8, 64],
"index_data": [2, 2, 2] "index_data": [2, 2, 2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -561,14 +545,14 @@ class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest): ...@@ -561,14 +545,14 @@ class TrtConvertGatherNdTest_dim_3_3(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_gelu.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertGeluTest(TrtLayerAutoScanTest): class TrtConvertGeluTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(dims, attrs: List[Dict[str, Any]]): def generate_input1(dims, attrs: List[Dict[str, Any]]):
if dims == 1: if dims == 1:
return np.ones([32]).astype(np.float32) return np.ones([32]).astype(np.float32)
...@@ -43,33 +41,32 @@ class TrtConvertGeluTest(TrtLayerAutoScanTest): ...@@ -43,33 +41,32 @@ class TrtConvertGeluTest(TrtLayerAutoScanTest):
self.dims = dims self.dims = dims
dics = [{"approximate": approximate}] dics = [{"approximate": approximate}]
ops_config = [{ ops_config = [
"op_type": "gelu", {
"op_inputs": { "op_type": "gelu",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {"Out": ["output_data"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["output_data"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dims, dics)
data_gen=partial(generate_input1, dims, dics)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -123,19 +120,23 @@ class TrtConvertGeluTest(TrtLayerAutoScanTest): ...@@ -123,19 +120,23 @@ class TrtConvertGeluTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_grid_sampler.py
浏览文件 @ 7a0b8625
...@@ -22,29 +22,27 @@ import unittest ...@@ -22,29 +22,27 @@ import unittest
class TrtConvertGridSampler(TrtLayerAutoScanTest): class TrtConvertGridSampler(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([1, 3, 32, 32]).astype(np.float32) return np.random.random([1, 3, 32, 32]).astype(np.float32)
def generate_input2(): def generate_input2():
return np.random.random([1, 3, 3, 2]).astype(np.float32) return np.random.random([1, 3, 3, 2]).astype(np.float32)
ops_config = [{ ops_config = [
"op_type": "grid_sampler", {
"op_inputs": { "op_type": "grid_sampler",
"X": ["input_data"], "op_inputs": {
"Grid": ["grid_data"], "X": ["input_data"],
}, "Grid": ["grid_data"],
"op_outputs": { },
"Output": ["output_data"] "op_outputs": {"Output": ["output_data"]},
}, "op_attrs": {},
"op_attrs": {} }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
...@@ -52,30 +50,33 @@ class TrtConvertGridSampler(TrtLayerAutoScanTest): ...@@ -52,30 +50,33 @@ class TrtConvertGridSampler(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
"grid_data": ),
TensorConfig(data_gen=partial(generate_input2)), "grid_data": TensorConfig(
data_gen=partial(generate_input2)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 3, 32, 32], "input_data": [1, 3, 32, 32],
"grid_data": [1, 3, 3, 2] "grid_data": [1, 3, 3, 2],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data": [1, 3, 64, 64], "input_data": [1, 3, 64, 64],
"grid_data": [1, 3, 4, 4] "grid_data": [1, 3, 4, 4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data": [1, 3, 32, 32], "input_data": [1, 3, 32, 32],
"grid_data": [1, 3, 3, 2] "grid_data": [1, 3, 3, 2],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -92,14 +93,14 @@ class TrtConvertGridSampler(TrtLayerAutoScanTest): ...@@ -92,14 +93,14 @@ class TrtConvertGridSampler(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 4), 1e-5 yield self.create_inference_config(), (0, 4), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_group_norm.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertGroupNormTest(TrtLayerAutoScanTest): class TrtConvertGroupNormTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -36,7 +35,6 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest): ...@@ -36,7 +35,6 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(attrs: List[Dict[str, Any]], batch): def generate_input(attrs: List[Dict[str, Any]], batch):
if attrs[0]['data_layout'] == 'NCHW': if attrs[0]['data_layout'] == 'NCHW':
return np.random.random([batch, 32, 64, 64]).astype(np.float32) return np.random.random([batch, 32, 64, 64]).astype(np.float32)
...@@ -53,47 +51,56 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest): ...@@ -53,47 +51,56 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest):
for group in [1, 4, 32, -1]: for group in [1, 4, 32, -1]:
for epsilon in [0.0001, 0.0007, -1, 1]: for epsilon in [0.0001, 0.0007, -1, 1]:
for data_layout in ['NCHW']: for data_layout in ['NCHW']:
dics = [{ dics = [
"epsilon": epsilon, {
"groups": group, "epsilon": epsilon,
"data_layout": data_layout "groups": group,
}] "data_layout": data_layout,
ops_config = [{ }
"op_type": "group_norm", ]
"op_inputs": { ops_config = [
"X": ["input_data"], {
"Scale": ["scale_weight"], "op_type": "group_norm",
"Bias": ["bias_weight"] "op_inputs": {
}, "X": ["input_data"],
"op_outputs": { "Scale": ["scale_weight"],
"Y": ["y_output"], "Bias": ["bias_weight"],
"Mean": ["mean_output"], },
"Variance": ["variance_output"] "op_outputs": {
}, "Y": ["y_output"],
"op_attrs": dics[0] "Mean": ["mean_output"],
}] "Variance": ["variance_output"],
},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"scale_weight": "scale_weight": TensorConfig(
TensorConfig(data_gen=partial(generate_scale)), data_gen=partial(generate_scale)
"bias_weight": ),
TensorConfig(data_gen=partial(generate_bias)) "bias_weight": TensorConfig(
data_gen=partial(generate_bias)
),
}, },
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input, dics, batch)) generate_input, dics, batch
)
)
}, },
outputs=["y_output"]) outputs=["y_output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 16, 16, 16]} self.dynamic_shape.min_input_shape = {"input_data": [1, 16, 16, 16]}
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
...@@ -117,19 +124,23 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest): ...@@ -117,19 +124,23 @@ class TrtConvertGroupNormTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_hard_sigmoid.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest): class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -37,33 +35,34 @@ class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest): ...@@ -37,33 +35,34 @@ class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest):
for slope in [0.1, 0.5]: for slope in [0.1, 0.5]:
for offset in [0.2, 0.7]: for offset in [0.2, 0.7]:
dics = [{"slope": slope, "offset": offset}] dics = [{"slope": slope, "offset": offset}]
ops_config = [{ ops_config = [
"op_type": "hard_sigmoid", {
"op_inputs": { "op_type": "hard_sigmoid",
"X": ["input_data"], "op_inputs": {
}, "X": ["input_data"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, shape)
data_gen=partial(generate_input, shape)) )
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.input_dim == 2: if self.input_dim == 2:
self.dynamic_shape.min_input_shape = {"input_data": [1, 8]} self.dynamic_shape.min_input_shape = {"input_data": [1, 8]}
...@@ -98,14 +97,14 @@ class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest): ...@@ -98,14 +97,14 @@ class TrtConvertHardSigmoidTest_dim_2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_hard_swish.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertHardSwishTest(TrtLayerAutoScanTest): class TrtConvertHardSwishTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -36,46 +35,46 @@ class TrtConvertHardSwishTest(TrtLayerAutoScanTest): ...@@ -36,46 +35,46 @@ class TrtConvertHardSwishTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
return np.ones([1, 3, 32, 32]).astype(np.float32) return np.ones([1, 3, 32, 32]).astype(np.float32)
for threshold in [6.0, 7.0, 100.0, 0.0, -1.0]: for threshold in [6.0, 7.0, 100.0, 0.0, -1.0]:
for scale in [5.0, 7.0, -1.0, 0.0, 100.0]: for scale in [5.0, 7.0, -1.0, 0.0, 100.0]:
for offset in [3.0, 5.0, -1.0, 0.0, 100.0]: for offset in [3.0, 5.0, -1.0, 0.0, 100.0]:
dics = [{ dics = [
"threshold": threshold, {
"scale": scale, "threshold": threshold,
"offset": offset "scale": scale,
}] "offset": offset,
}
ops_config = [{ ]
"op_type": "hard_swish",
"op_inputs": { ops_config = [
"X": ["input_data"] {
}, "op_type": "hard_swish",
"op_outputs": { "op_inputs": {"X": ["input_data"]},
"Out": ["hard_swish_output_data"] "op_outputs": {"Out": ["hard_swish_output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics)
data_gen=partial(generate_input1, dics)) )
}, },
outputs=["hard_swish_output_data"]) outputs=["hard_swish_output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 16, 16]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 16, 16]}
self.dynamic_shape.max_input_shape = {"input_data": [2, 3, 32, 32]} self.dynamic_shape.max_input_shape = {"input_data": [2, 3, 32, 32]}
...@@ -97,19 +96,23 @@ class TrtConvertHardSwishTest(TrtLayerAutoScanTest): ...@@ -97,19 +96,23 @@ class TrtConvertHardSwishTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_inverse.py
浏览文件 @ 7a0b8625
...@@ -22,41 +22,41 @@ import unittest ...@@ -22,41 +22,41 @@ import unittest
class TrtConvertInverse(TrtLayerAutoScanTest): class TrtConvertInverse(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([32, 32]).astype(np.float32) return np.random.random([32, 32]).astype(np.float32)
ops_config = [{ ops_config = [
"op_type": "inverse", {
"op_inputs": { "op_type": "inverse",
"Input": ["input_data"], "op_inputs": {
}, "Input": ["input_data"],
"op_outputs": { },
"Output": ["output_data"] "op_outputs": {"Output": ["output_data"]},
}, "op_attrs": {},
"op_attrs": {} }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 1], "input_data": [1, 1],
...@@ -82,14 +82,14 @@ class TrtConvertInverse(TrtLayerAutoScanTest): ...@@ -82,14 +82,14 @@ class TrtConvertInverse(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_leaky_relu.py
浏览文件 @ 7a0b8625
...@@ -23,12 +23,10 @@ import unittest ...@@ -23,12 +23,10 @@ import unittest
class TrtConvertLeakyReluTest(TrtLayerAutoScanTest): class TrtConvertLeakyReluTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(shape): def generate_input1(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -37,32 +35,35 @@ class TrtConvertLeakyReluTest(TrtLayerAutoScanTest): ...@@ -37,32 +35,35 @@ class TrtConvertLeakyReluTest(TrtLayerAutoScanTest):
self.input_dim = len(shape) self.input_dim = len(shape)
for alpha in [0.02, 1.0, 100.0, -1.0, 0.0]: for alpha in [0.02, 1.0, 100.0, -1.0, 0.0]:
dics = [{"alpha": alpha}] dics = [{"alpha": alpha}]
ops_config = [{ ops_config = [
"op_type": "leaky_relu", {
"op_inputs": { "op_type": "leaky_relu",
"X": ["input_data"], "op_inputs": {
}, "X": ["input_data"],
"op_outputs": { },
"Out": ["y_data"], "op_outputs": {
}, "Out": ["y_data"],
"op_attrs": dics[0] },
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, shape)
data_gen=partial(generate_input1, shape)) )
}, },
outputs=["y_data"]) outputs=["y_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.input_dim == 2: if self.input_dim == 2:
self.dynamic_shape.min_input_shape = {"input_data": [1, 8]} self.dynamic_shape.min_input_shape = {"input_data": [1, 8]}
...@@ -101,25 +102,31 @@ class TrtConvertLeakyReluTest(TrtLayerAutoScanTest): ...@@ -101,25 +102,31 @@ class TrtConvertLeakyReluTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-3, 1e-3)
self.trt_param.precision = paddle_infer.PrecisionType.Int8 self.trt_param.precision = paddle_infer.PrecisionType.Int8
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-3, 1e-3)
self.trt_param.precision = paddle_infer.PrecisionType.Int8 self.trt_param.precision = paddle_infer.PrecisionType.Int8
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-3, 1e-3)
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_matmul.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertMatmulTest_static(TrtLayerAutoScanTest): class TrtConvertMatmulTest_static(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -47,48 +45,55 @@ class TrtConvertMatmulTest_static(TrtLayerAutoScanTest): ...@@ -47,48 +45,55 @@ class TrtConvertMatmulTest_static(TrtLayerAutoScanTest):
input1_shape = [batch, 32, 6] input1_shape = [batch, 32, 6]
input2_shape = [batch, 6, 11] input2_shape = [batch, 6, 11]
for alpha in [0.3, 1.0]: for alpha in [0.3, 1.0]:
dics = [{ dics = [
"transpose_X": trans_x, {
"transpose_Y": trans_y, "transpose_X": trans_x,
"alpha": alpha, "transpose_Y": trans_y,
"fused_reshape_X": [], "alpha": alpha,
"fused_reshape_Y": [], "fused_reshape_X": [],
"fused_transpose_X": [], "fused_reshape_Y": [],
"fused_transpose_Y": [], "fused_transpose_X": [],
"fused_reshape_Out": [], "fused_transpose_Y": [],
"fused_transpose_Out": [] "fused_reshape_Out": [],
}] "fused_transpose_Out": [],
ops_config = [{ }
"op_type": "matmul", ]
"op_inputs": { ops_config = [
"X": ["input1_data"], {
"Y": ["input2_data"] "op_type": "matmul",
}, "op_inputs": {
"op_outputs": { "X": ["input1_data"],
"Out": ["output_data"] "Y": ["input2_data"],
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["output_data"]},
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input, input1_shape)), generate_input, input1_shape
"input2_data": )
TensorConfig(data_gen=partial( ),
generate_input, input2_shape)) "input2_data": TensorConfig(
data_gen=partial(
generate_input, input2_shape
)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
pass pass
...@@ -102,19 +107,17 @@ class TrtConvertMatmulTest_static(TrtLayerAutoScanTest): ...@@ -102,19 +107,17 @@ class TrtConvertMatmulTest_static(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -133,60 +136,63 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): ...@@ -133,60 +136,63 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
# input1_shape = [batch, 32, 6] # input1_shape = [batch, 32, 6]
# input2_shape = [batch, 6, 11] # input2_shape = [batch, 6, 11]
for alpha in [0.3, 1.0]: for alpha in [0.3, 1.0]:
dics = [{ dics = [
"transpose_X": trans_x, {
"transpose_Y": trans_y, "transpose_X": trans_x,
"alpha": alpha, "transpose_Y": trans_y,
"fused_reshape_X": [], "alpha": alpha,
"fused_reshape_Y": [], "fused_reshape_X": [],
"fused_transpose_X": [], "fused_reshape_Y": [],
"fused_transpose_Y": [], "fused_transpose_X": [],
"fused_reshape_Out": [], "fused_transpose_Y": [],
"fused_transpose_Out": [] "fused_reshape_Out": [],
}] "fused_transpose_Out": [],
ops_config = [{ }
"op_type": "matmul", ]
"op_inputs": { ops_config = [
"X": ["input1_data"], {
"Y": ["input2_data"] "op_type": "matmul",
}, "op_inputs": {
"op_outputs": { "X": ["input1_data"],
"Out": ["output_data"] "Y": ["input2_data"],
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["output_data"]},
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input1_shape)
data_gen=partial(generate_input, input1_shape)), ),
"input2_data": "input2_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input2_shape)
data_gen=partial(generate_input, input2_shape)) ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1_data": [1, 4, 4], "input1_data": [1, 4, 4],
"input2_data": [1, 4, 4] "input2_data": [1, 4, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1_data": [16, 4, 4], "input1_data": [16, 4, 4],
"input2_data": [16, 4, 4] "input2_data": [16, 4, 4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1_data": [8, 4, 4], "input1_data": [8, 4, 4],
"input2_data": [8, 4, 4] "input2_data": [8, 4, 4],
} }
attrs = [ attrs = [
...@@ -198,7 +204,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): ...@@ -198,7 +204,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_matmul_v2.py
浏览文件 @ 7a0b8625
...@@ -23,9 +23,7 @@ import os ...@@ -23,9 +23,7 @@ import os
class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -34,53 +32,56 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): ...@@ -34,53 +32,56 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
for trans_y in [False]: for trans_y in [False]:
input1_shape = [batch, 64, 350, 75] input1_shape = [batch, 64, 350, 75]
input2_shape = [75, 25] input2_shape = [75, 25]
dics = [{ dics = [
"trans_x": trans_x, {
"trans_y": trans_y, "trans_x": trans_x,
}] "trans_y": trans_y,
ops_config = [{ }
"op_type": "matmul_v2", ]
"op_inputs": { ops_config = [
"X": ["input1_data"], {
"Y": ["input2_data"] "op_type": "matmul_v2",
}, "op_inputs": {
"op_outputs": { "X": ["input1_data"],
"Out": ["output_data"] "Y": ["input2_data"],
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["output_data"]},
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input1_shape)
data_gen=partial(generate_input, input1_shape)), ),
"input2_data": "input2_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input2_shape)
data_gen=partial(generate_input, input2_shape)) ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1_data": [10, 64, 350, 75], "input1_data": [10, 64, 350, 75],
"input2_data": [75, 25] "input2_data": [75, 25],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1_data": [100, 64, 350, 75], "input1_data": [100, 64, 350, 75],
"input2_data": [75, 25] "input2_data": [75, 25],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1_data": [15, 64, 350, 75], "input1_data": [15, 64, 350, 75],
"input2_data": [75, 25] "input2_data": [75, 25],
} }
attrs = [ attrs = [
...@@ -90,7 +91,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): ...@@ -90,7 +91,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
# The output has little diff between gpu and trt in CI-Windows-Inference # The output has little diff between gpu and trt in CI-Windows-Inference
tol_fp32 = 1e-5 tol_fp32 = 1e-5
tol_half = 1e-5 tol_half = 1e-5
if (os.name == 'nt'): if os.name == 'nt':
tol_fp32 = 1e-3 tol_fp32 = 1e-3
tol_half = 1e-3 tol_half = 1e-3
# for dynamic_shape # for dynamic_shape
...@@ -109,9 +110,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest): ...@@ -109,9 +110,7 @@ class TrtConvertMatmulTest_dynamic(TrtLayerAutoScanTest):
class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest): class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest):
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -120,53 +119,56 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest): ...@@ -120,53 +119,56 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest):
for trans_y in [False]: for trans_y in [False]:
input1_shape = [60, 40] input1_shape = [60, 40]
input2_shape = [batch, 40, 90] input2_shape = [batch, 40, 90]
dics = [{ dics = [
"trans_x": trans_x, {
"trans_y": trans_y, "trans_x": trans_x,
}] "trans_y": trans_y,
ops_config = [{ }
"op_type": "matmul_v2", ]
"op_inputs": { ops_config = [
"X": ["input1_data"], {
"Y": ["input2_data"] "op_type": "matmul_v2",
}, "op_inputs": {
"op_outputs": { "X": ["input1_data"],
"Out": ["output_data"] "Y": ["input2_data"],
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["output_data"]},
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input1_shape)
data_gen=partial(generate_input, input1_shape)), ),
"input2_data": "input2_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input, input2_shape)
data_gen=partial(generate_input, input2_shape)) ),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1_data": [60, 40], "input1_data": [60, 40],
"input2_data": [10, 40, 90] "input2_data": [10, 40, 90],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1_data": [60, 40], "input1_data": [60, 40],
"input2_data": [20, 40, 90] "input2_data": [20, 40, 90],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1_data": [60, 40], "input1_data": [60, 40],
"input2_data": [15, 40, 90] "input2_data": [15, 40, 90],
} }
attrs = [ attrs = [
...@@ -175,7 +177,7 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest): ...@@ -175,7 +177,7 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest):
# The output has little diff between gpu and trt in CI-Windows-Inference # The output has little diff between gpu and trt in CI-Windows-Inference
tol_fp32 = 1e-5 tol_fp32 = 1e-5
tol_half = 1e-5 tol_half = 1e-5
if (os.name == 'nt'): if os.name == 'nt':
tol_fp32 = 1e-3 tol_fp32 = 1e-3
tol_half = 1e-3 tol_half = 1e-3
# for dynamic_shape # for dynamic_shape
...@@ -194,9 +196,7 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest): ...@@ -194,9 +196,7 @@ class TrtConvertMatmulTest_dynamic2(TrtLayerAutoScanTest):
class TrtConvertMatmulTest_dynamic3(TrtLayerAutoScanTest): class TrtConvertMatmulTest_dynamic3(TrtLayerAutoScanTest):
def sample_program_configs(self): def sample_program_configs(self):
def generate_input(shape): def generate_input(shape):
return np.random.random(shape).astype(np.float32) return np.random.random(shape).astype(np.float32)
...@@ -219,93 +219,102 @@ class TrtConvertMatmulTest_dynamic3(TrtLayerAutoScanTest): ...@@ -219,93 +219,102 @@ class TrtConvertMatmulTest_dynamic3(TrtLayerAutoScanTest):
elif case == 2: elif case == 2:
input1_shape = [50] input1_shape = [50]
input2_shape = [50] input2_shape = [50]
if (case == 0 or case == 1): if case == 0 or case == 1:
dics = [{ dics = [
"trans_x": False, {
"trans_y": False, "trans_x": False,
}] "trans_y": False,
elif (case == 2): }
dics = [{ ]
"trans_x": trans_x, elif case == 2:
"trans_y": trans_y, dics = [
}] {
ops_config = [{ "trans_x": trans_x,
"op_type": "matmul_v2", "trans_y": trans_y,
"op_inputs": { }
"X": ["input1_data"], ]
"Y": ["input2_data"] ops_config = [
}, {
"op_outputs": { "op_type": "matmul_v2",
"Out": ["output_data"] "op_inputs": {
}, "X": ["input1_data"],
"op_attrs": dics[0] "Y": ["input2_data"],
}] },
"op_outputs": {"Out": ["output_data"]},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1_data": "input1_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input, input1_shape)), generate_input, input1_shape
"input2_data": )
TensorConfig(data_gen=partial( ),
generate_input, input2_shape)) "input2_data": TensorConfig(
data_gen=partial(
generate_input, input2_shape
)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if (self.case == 0): if self.case == 0:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1_data": [20, 50], "input1_data": [20, 50],
"input2_data": [50] "input2_data": [50],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1_data": [30, 50], "input1_data": [30, 50],
"input2_data": [50] "input2_data": [50],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1_data": [25, 50], "input1_data": [25, 50],
"input2_data": [50] "input2_data": [50],
} }
elif (self.case == 1): elif self.case == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input2_data": [50, 20], "input2_data": [50, 20],
"input1_data": [50] "input1_data": [50],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input2_data": [50, 30], "input2_data": [50, 30],
"input1_data": [50] "input1_data": [50],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input2_data": [50, 25], "input2_data": [50, 25],
"input1_data": [50] "input1_data": [50],
} }
elif (self.case == 2): elif self.case == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input2_data": [30], "input2_data": [30],
"input1_data": [50] "input1_data": [50],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input2_data": [50], "input2_data": [50],
"input1_data": [50] "input1_data": [50],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input2_data": [50], "input2_data": [50],
"input1_data": [50] "input1_data": [50],
} }
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), 1e-5 yield self.create_inference_config(), (1, 3), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_multihead_matmul.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch, dim1): def generate_input1(batch, dim1):
return np.random.random((batch, dim1, 768)).astype(np.float32) return np.random.random((batch, dim1, 768)).astype(np.float32)
...@@ -44,103 +42,86 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -44,103 +42,86 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
self.batch = batch self.batch = batch
for reshape_shape in [[0, 0, 12, 64]]: for reshape_shape in [[0, 0, 12, 64]]:
for dim1 in [128]: for dim1 in [128]:
input2_shapes = [[batch, reshape_shape[2], dim1, dim1], input2_shapes = [
[batch, 1, 1, dim1]] [batch, reshape_shape[2], dim1, dim1],
[batch, 1, 1, dim1],
]
for input2_shape in input2_shapes: for input2_shape in input2_shapes:
for axis in [0]: for axis in [0]:
dics = [{ dics = [
"x_num_col_dims": 2, {"x_num_col_dims": 2, "y_num_col_dims": 1},
"y_num_col_dims": 1 {"axis": 2},
}, { {"shape": reshape_shape},
"axis": 2 {"axis": [0, 2, 1, 3]},
}, { {"x_num_col_dims": 2, "y_num_col_dims": 1},
"shape": reshape_shape {"axis": 2},
}, { {"shape": reshape_shape},
"axis": [0, 2, 1, 3] {"axis": [0, 2, 1, 3]},
}, { {"x_num_col_dims": 2, "y_num_col_dims": 1},
"x_num_col_dims": 2, {"axis": 2},
"y_num_col_dims": 1 {"shape": reshape_shape},
}, { {"axis": [0, 2, 1, 3]},
"axis": 2 {
}, { "scale": 0.125,
"shape": reshape_shape "bias": 0.0,
}, { "bias_after_scale": True,
"axis": [0, 2, 1, 3] },
}, { {
"x_num_col_dims": 2, "alpha": 1.0,
"y_num_col_dims": 1 "transpose_X": False,
}, { "transpose_Y": True,
"axis": 2 "fused_reshape_X": [],
}, { "fused_reshape_Y": [],
"shape": reshape_shape "fused_transpose_X": [],
}, { "fused_transpose_Y": [],
"axis": [0, 2, 1, 3] "fused_reshape_Out": [],
}, { "fused_transpose_Out": [],
"scale": 0.125, },
"bias": 0.0, {"axis": axis},
"bias_after_scale": True {"axis": -1, "is_test": True},
}, { {
"alpha": 1.0, "seed": 0,
"transpose_X": False, "dropout_prob": 0.10000000149011612,
"transpose_Y": True, "dropout_implementation": "upscale_in_train",
"fused_reshape_X": [], "fix_seed": False,
"fused_reshape_Y": [], "is_test": True,
"fused_transpose_X": [], },
"fused_transpose_Y": [], {
"fused_reshape_Out": [], "alpha": 1.0,
"fused_transpose_Out": [] "transpose_X": False,
}, { "transpose_Y": False,
"axis": axis "fused_reshape_X": [],
}, { "fused_reshape_Y": [],
"axis": -1, "fused_transpose_X": [],
"is_test": True "fused_transpose_Y": [],
}, { "fused_reshape_Out": [],
"seed": 0, "fused_transpose_Out": [],
"dropout_prob": 0.10000000149011612, },
"dropout_implementation": "upscale_in_train", {"axis": [0, 2, 1, 3]},
"fix_seed": False, {"shape": [0, 0, 768]},
"is_test": True {"x_num_col_dims": 2, "y_num_col_dims": 1},
}, { ]
"alpha": 1.0,
"transpose_X": False,
"transpose_Y": False,
"fused_reshape_X": [],
"fused_reshape_Y": [],
"fused_transpose_X": [],
"fused_transpose_Y": [],
"fused_reshape_Out": [],
"fused_transpose_Out": []
}, {
"axis": [0, 2, 1, 3]
}, {
"shape": [0, 0, 768]
}, {
"x_num_col_dims": 2,
"y_num_col_dims": 1
}]
ops_config = [ ops_config = [
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul1_weight"] "Y": ["mul1_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul1_output"]},
"Out": ["mul1_output"] "op_attrs": dics[0],
},
"op_attrs": dics[0]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul1_output"], "X": ["mul1_output"],
"Y": ["elementwise_add1_weight"] "Y": ["elementwise_add1_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add1_output"] "Out": ["elementwise_add1_output"]
}, },
"op_attrs": dics[1] "op_attrs": dics[1],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -149,42 +130,38 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -149,42 +130,38 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape21_output"], "Out": ["reshape21_output"],
"XShape": ["reshape21_output_xshape"] "XShape": ["reshape21_output_xshape"],
}, },
"op_attrs": dics[2] "op_attrs": dics[2],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape21_output"]},
"X": ["reshape21_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose21_output"], "Out": ["transpose21_output"],
"XShape": ["transpose21_output_xshape"] "XShape": ["transpose21_output_xshape"],
}, },
"op_attrs": dics[3] "op_attrs": dics[3],
}, },
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul2_weight"] "Y": ["mul2_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul2_output"]},
"Out": ["mul2_output"] "op_attrs": dics[4],
},
"op_attrs": dics[4]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul2_output"], "X": ["mul2_output"],
"Y": ["elementwise_add2_weight"] "Y": ["elementwise_add2_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add2_output"] "Out": ["elementwise_add2_output"]
}, },
"op_attrs": dics[5] "op_attrs": dics[5],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -193,42 +170,38 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -193,42 +170,38 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape22_output"], "Out": ["reshape22_output"],
"XShape": ["reshape22_output_xshape"] "XShape": ["reshape22_output_xshape"],
}, },
"op_attrs": dics[6] "op_attrs": dics[6],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape22_output"]},
"X": ["reshape22_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose22_output"], "Out": ["transpose22_output"],
"XShape": ["transpose22_output_xshape"] "XShape": ["transpose22_output_xshape"],
}, },
"op_attrs": dics[7] "op_attrs": dics[7],
}, },
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul3_weight"] "Y": ["mul3_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul3_output"]},
"Out": ["mul3_output"] "op_attrs": dics[8],
},
"op_attrs": dics[8]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul3_output"], "X": ["mul3_output"],
"Y": ["elementwise_add3_weight"] "Y": ["elementwise_add3_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add3_output"] "Out": ["elementwise_add3_output"]
}, },
"op_attrs": dics[9] "op_attrs": dics[9],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -237,30 +210,26 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -237,30 +210,26 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape23_output"], "Out": ["reshape23_output"],
"XShape": ["reshape23_output_xshape"] "XShape": ["reshape23_output_xshape"],
}, },
"op_attrs": dics[10] "op_attrs": dics[10],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape23_output"]},
"X": ["reshape23_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose23_output"], "Out": ["transpose23_output"],
"XShape": ["transpose23_output_xshape"] "XShape": ["transpose23_output_xshape"],
}, },
"op_attrs": dics[11] "op_attrs": dics[11],
}, },
{ {
"op_type": "scale", "op_type": "scale",
"op_inputs": { "op_inputs": {
"X": ["transpose23_output"], "X": ["transpose23_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["scale_output"]},
"Out": ["scale_output"] "op_attrs": dics[12],
},
"op_attrs": dics[12]
}, },
{ {
"op_type": "matmul", "op_type": "matmul",
...@@ -268,41 +237,35 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -268,41 +237,35 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
"X": ["scale_output"], "X": ["scale_output"],
"Y": ["transpose22_output"], "Y": ["transpose22_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["matmul1_output"]},
"Out": ["matmul1_output"] "op_attrs": dics[13],
},
"op_attrs": dics[13]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["matmul1_output"], "X": ["matmul1_output"],
"Y": ["input_data2"] "Y": ["input_data2"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add4_output"] "Out": ["elementwise_add4_output"]
}, },
"op_attrs": dics[14] "op_attrs": dics[14],
}, },
{ {
"op_type": "softmax", "op_type": "softmax",
"op_inputs": { "op_inputs": {
"X": ["elementwise_add4_output"] "X": ["elementwise_add4_output"]
}, },
"op_outputs": { "op_outputs": {"Out": ["softmax_output"]},
"Out": ["softmax_output"] "op_attrs": dics[15],
},
"op_attrs": dics[15]
}, },
{ {
"op_type": "dropout", "op_type": "dropout",
"op_inputs": { "op_inputs": {
"X": ["softmax_output"], "X": ["softmax_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["dropout3_output"]},
"Out": ["dropout3_output"] "op_attrs": dics[16],
},
"op_attrs": dics[16]
}, },
{ {
"op_type": "matmul", "op_type": "matmul",
...@@ -310,32 +273,26 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -310,32 +273,26 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
"X": ["dropout3_output"], "X": ["dropout3_output"],
"Y": ["transpose21_output"], "Y": ["transpose21_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["matmul2_output"]},
"Out": ["matmul2_output"] "op_attrs": dics[17],
},
"op_attrs": dics[17]
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["matmul2_output"]},
"X": ["matmul2_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose24_output"], "Out": ["transpose24_output"],
"XShape": ["transpose24_output_xshape"] "XShape": ["transpose24_output_xshape"],
}, },
"op_attrs": dics[18] "op_attrs": dics[18],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
"op_inputs": { "op_inputs": {"X": ["transpose24_output"]},
"X": ["transpose24_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["reshape24_output"], "Out": ["reshape24_output"],
"XShape": ["reshape24_output_xshape"] "XShape": ["reshape24_output_xshape"],
}, },
"op_attrs": dics[19] "op_attrs": dics[19],
}, },
# In order to fuse ops with # In order to fuse ops with
# multihead_matmul_fuse_pass_v2, the last op # multihead_matmul_fuse_pass_v2, the last op
...@@ -344,72 +301,75 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -344,72 +301,75 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["reshape24_output"], "X": ["reshape24_output"],
"Y": ["mul4_weight"] "Y": ["mul4_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul4_output"]},
"Out": ["mul4_output"] "op_attrs": dics[20],
}, },
"op_attrs": dics[20]
}
] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"mul1_weight": "mul1_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul2_weight": "mul2_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul3_weight": "mul3_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul4_weight": "mul4_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"elementwise_add1_weight": "elementwise_add1_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
"elementwise_add2_weight": "elementwise_add2_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
"elementwise_add3_weight": "elementwise_add3_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
}, },
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, batch, dim1)), generate_input1, batch, dim1
"input_data2": )
TensorConfig(data_gen=partial( ),
generate_input2, input2_shape)), "input_data2": TensorConfig(
data_gen=partial(
generate_input2, input2_shape
)
),
}, },
outputs=["mul4_output"]) outputs=["mul4_output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The last dim of input1 and input2 should be static. # The last dim of input1 and input2 should be static.
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data1": [1, 8, 768], "input_data1": [1, 8, 768],
"input_data2": [1, 1, 1, 128], "input_data2": [1, 1, 1, 128],
"reshape24_output": [1, 128, 768] "reshape24_output": [1, 128, 768],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input_data1": [16, 512, 768], "input_data1": [16, 512, 768],
"input_data2": [16, 256, 512, 128], "input_data2": [16, 256, 512, 128],
"reshape24_output": [1, 128, 768] "reshape24_output": [1, 128, 768],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input_data1": [8, 128, 768], "input_data1": [8, 128, 768],
"input_data2": [8, 32, 64, 128], "input_data2": [8, 32, 64, 128],
"reshape24_output": [1, 128, 768] "reshape24_output": [1, 128, 768],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -427,7 +387,7 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -427,7 +387,7 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
self.trt_param.workspace_size = 2013265920 self.trt_param.workspace_size = 2013265920
yield self.create_inference_config(), (1, 4), (1e-5, 1e-5) yield self.create_inference_config(), (1, 4), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 4), (1e-5, 1e-5) yield self.create_inference_config(), (1, 4), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
...@@ -435,28 +395,33 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -435,28 +395,33 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
self.trt_param.workspace_size = 2013265920 self.trt_param.workspace_size = 2013265920
yield self.create_inference_config(), (1, 3), (1e-5, 1e-4) yield self.create_inference_config(), (1, 3), (1e-5, 1e-4)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 3), (1e-5, 1e-5) yield self.create_inference_config(), (1, 3), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if self.trt_param.precision == paddle_infer.PrecisionType.Half: if self.trt_param.precision == paddle_infer.PrecisionType.Half:
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_IMPLEMENTED, teller1,
"The output has diff between gpu and trt in fp16 mode.") SkipReasons.TRT_NOT_IMPLEMENTED,
"The output has diff between gpu and trt in fp16 mode.",
)
def teller2(program_config, predictor_config): def teller2(program_config, predictor_config):
if self.trt_param.precision == paddle_infer.PrecisionType.Float32 and len( if (
self.dynamic_shape.min_input_shape) != 0 and self.batch > 2: self.trt_param.precision == paddle_infer.PrecisionType.Float32
and len(self.dynamic_shape.min_input_shape) != 0
and self.batch > 2
):
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller2, SkipReasons.TRT_NOT_IMPLEMENTED, teller2,
"The output has diff between gpu and trt when dynamic fp32 mode and batch size > 2." SkipReasons.TRT_NOT_IMPLEMENTED,
"The output has diff between gpu and trt when dynamic fp32 mode and batch size > 2.",
) )
def teller3(program_config, predictor_config): def teller3(program_config, predictor_config):
...@@ -465,8 +430,10 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -465,8 +430,10 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
return False return False
self.add_skip_case( self.add_skip_case(
teller3, SkipReasons.TRT_NOT_IMPLEMENTED, teller3,
"The output has diff between gpu and trt in int8 mode.") SkipReasons.TRT_NOT_IMPLEMENTED,
"The output has diff between gpu and trt in int8 mode.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
...@@ -474,9 +441,7 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -474,9 +441,7 @@ class TrtConvertMultiHeadMatmulTest(TrtLayerAutoScanTest):
class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch, dim1): def generate_input1(batch, dim1):
return np.random.random((batch, dim1, 768)).astype(np.float32) return np.random.random((batch, dim1, 768)).astype(np.float32)
...@@ -493,112 +458,110 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -493,112 +458,110 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
self.batch = batch self.batch = batch
for reshape_shape in [[0, 0, 12, 64]]: for reshape_shape in [[0, 0, 12, 64]]:
for dim1 in [128]: for dim1 in [128]:
input2_shapes = [[batch, reshape_shape[2], dim1, dim1], input2_shapes = [
[batch, 1, 1, dim1]] [batch, reshape_shape[2], dim1, dim1],
[batch, 1, 1, dim1],
]
for input2_shape in input2_shapes: for input2_shape in input2_shapes:
for axis in [0]: for axis in [0]:
dics = [{ dics = [
"x_num_col_dims": 2, {
"y_num_col_dims": 1, "x_num_col_dims": 2,
"enable_int8": True, "y_num_col_dims": 1,
"Input_scale": 1.0, "enable_int8": True,
}, { "Input_scale": 1.0,
"axis": 2, },
"out_threshold": 1.0, {
}, { "axis": 2,
"shape": reshape_shape "out_threshold": 1.0,
}, { },
"axis": [0, 2, 1, 3] {"shape": reshape_shape},
}, { {"axis": [0, 2, 1, 3]},
"x_num_col_dims": 2, {
"y_num_col_dims": 1, "x_num_col_dims": 2,
"enable_int8": True, "y_num_col_dims": 1,
"Input_scale": 1.0, "enable_int8": True,
}, { "Input_scale": 1.0,
"axis": 2, },
"out_threshold": 1.0, {
}, { "axis": 2,
"shape": reshape_shape "out_threshold": 1.0,
}, { },
"axis": [0, 2, 1, 3] {"shape": reshape_shape},
}, { {"axis": [0, 2, 1, 3]},
"x_num_col_dims": 2, {
"y_num_col_dims": 1, "x_num_col_dims": 2,
"enable_int8": True, "y_num_col_dims": 1,
"Input_scale": 1.0, "enable_int8": True,
}, { "Input_scale": 1.0,
"axis": 2, },
"out_threshold": 1.0, {
}, { "axis": 2,
"shape": reshape_shape "out_threshold": 1.0,
}, { },
"axis": [0, 2, 1, 3] {"shape": reshape_shape},
}, { {"axis": [0, 2, 1, 3]},
"scale": 0.125, {
"bias": 0.0, "scale": 0.125,
"bias_after_scale": True "bias": 0.0,
}, { "bias_after_scale": True,
"alpha": 1.0, },
"transpose_X": False, {
"transpose_Y": True, "alpha": 1.0,
"fused_reshape_X": [], "transpose_X": False,
"fused_reshape_Y": [], "transpose_Y": True,
"fused_transpose_X": [], "fused_reshape_X": [],
"fused_transpose_Y": [], "fused_reshape_Y": [],
"fused_reshape_Out": [], "fused_transpose_X": [],
"fused_transpose_Out": [] "fused_transpose_Y": [],
}, { "fused_reshape_Out": [],
"axis": axis "fused_transpose_Out": [],
}, { },
"axis": -1, {"axis": axis},
"is_test": True {"axis": -1, "is_test": True},
}, { {
"seed": 0, "seed": 0,
"dropout_prob": 0.10000000149011612, "dropout_prob": 0.10000000149011612,
"dropout_implementation": "upscale_in_train", "dropout_implementation": "upscale_in_train",
"fix_seed": False, "fix_seed": False,
"is_test": True "is_test": True,
}, { },
"alpha": 1.0, {
"transpose_X": False, "alpha": 1.0,
"transpose_Y": False, "transpose_X": False,
"fused_reshape_X": [], "transpose_Y": False,
"fused_reshape_Y": [], "fused_reshape_X": [],
"fused_transpose_X": [], "fused_reshape_Y": [],
"fused_transpose_Y": [], "fused_transpose_X": [],
"fused_reshape_Out": [], "fused_transpose_Y": [],
"fused_transpose_Out": [] "fused_reshape_Out": [],
}, { "fused_transpose_Out": [],
"axis": [0, 2, 1, 3] },
}, { {"axis": [0, 2, 1, 3]},
"shape": [0, 0, 768] {"shape": [0, 0, 768]},
}, { {"x_num_col_dims": 2, "y_num_col_dims": 1},
"x_num_col_dims": 2, ]
"y_num_col_dims": 1
}]
ops_config = [ ops_config = [
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul1_weight"] "Y": ["mul1_weight"],
},
"op_outputs": {
"Out": ["mul1_output"]
}, },
"op_attrs": dics[0] "op_outputs": {"Out": ["mul1_output"]},
"op_attrs": dics[0],
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul1_output"], "X": ["mul1_output"],
"Y": ["elementwise_add1_weight"] "Y": ["elementwise_add1_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add1_output"] "Out": ["elementwise_add1_output"]
}, },
"op_attrs": dics[1] "op_attrs": dics[1],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -607,42 +570,38 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -607,42 +570,38 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape21_output"], "Out": ["reshape21_output"],
"XShape": ["reshape21_output_xshape"] "XShape": ["reshape21_output_xshape"],
}, },
"op_attrs": dics[2] "op_attrs": dics[2],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape21_output"]},
"X": ["reshape21_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose21_output"], "Out": ["transpose21_output"],
"XShape": ["transpose21_output_xshape"] "XShape": ["transpose21_output_xshape"],
}, },
"op_attrs": dics[3] "op_attrs": dics[3],
}, },
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul2_weight"] "Y": ["mul2_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul2_output"]},
"Out": ["mul2_output"] "op_attrs": dics[4],
},
"op_attrs": dics[4]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul2_output"], "X": ["mul2_output"],
"Y": ["elementwise_add2_weight"] "Y": ["elementwise_add2_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add2_output"] "Out": ["elementwise_add2_output"]
}, },
"op_attrs": dics[5] "op_attrs": dics[5],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -651,42 +610,38 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -651,42 +610,38 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape22_output"], "Out": ["reshape22_output"],
"XShape": ["reshape22_output_xshape"] "XShape": ["reshape22_output_xshape"],
}, },
"op_attrs": dics[6] "op_attrs": dics[6],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape22_output"]},
"X": ["reshape22_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose22_output"], "Out": ["transpose22_output"],
"XShape": ["transpose22_output_xshape"] "XShape": ["transpose22_output_xshape"],
}, },
"op_attrs": dics[7] "op_attrs": dics[7],
}, },
{ {
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["input_data1"], "X": ["input_data1"],
"Y": ["mul3_weight"] "Y": ["mul3_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul3_output"]},
"Out": ["mul3_output"] "op_attrs": dics[8],
},
"op_attrs": dics[8]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["mul3_output"], "X": ["mul3_output"],
"Y": ["elementwise_add3_weight"] "Y": ["elementwise_add3_weight"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add3_output"] "Out": ["elementwise_add3_output"]
}, },
"op_attrs": dics[9] "op_attrs": dics[9],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
...@@ -695,30 +650,26 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -695,30 +650,26 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
}, },
"op_outputs": { "op_outputs": {
"Out": ["reshape23_output"], "Out": ["reshape23_output"],
"XShape": ["reshape23_output_xshape"] "XShape": ["reshape23_output_xshape"],
}, },
"op_attrs": dics[10] "op_attrs": dics[10],
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["reshape23_output"]},
"X": ["reshape23_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose23_output"], "Out": ["transpose23_output"],
"XShape": ["transpose23_output_xshape"] "XShape": ["transpose23_output_xshape"],
}, },
"op_attrs": dics[11] "op_attrs": dics[11],
}, },
{ {
"op_type": "scale", "op_type": "scale",
"op_inputs": { "op_inputs": {
"X": ["transpose23_output"], "X": ["transpose23_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["scale_output"]},
"Out": ["scale_output"] "op_attrs": dics[12],
},
"op_attrs": dics[12]
}, },
{ {
"op_type": "matmul", "op_type": "matmul",
...@@ -726,41 +677,35 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -726,41 +677,35 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
"X": ["scale_output"], "X": ["scale_output"],
"Y": ["transpose22_output"], "Y": ["transpose22_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["matmul1_output"]},
"Out": ["matmul1_output"] "op_attrs": dics[13],
},
"op_attrs": dics[13]
}, },
{ {
"op_type": "elementwise_add", "op_type": "elementwise_add",
"op_inputs": { "op_inputs": {
"X": ["matmul1_output"], "X": ["matmul1_output"],
"Y": ["input_data2"] "Y": ["input_data2"],
}, },
"op_outputs": { "op_outputs": {
"Out": ["elementwise_add4_output"] "Out": ["elementwise_add4_output"]
}, },
"op_attrs": dics[14] "op_attrs": dics[14],
}, },
{ {
"op_type": "softmax", "op_type": "softmax",
"op_inputs": { "op_inputs": {
"X": ["elementwise_add4_output"] "X": ["elementwise_add4_output"]
}, },
"op_outputs": { "op_outputs": {"Out": ["softmax_output"]},
"Out": ["softmax_output"] "op_attrs": dics[15],
},
"op_attrs": dics[15]
}, },
{ {
"op_type": "dropout", "op_type": "dropout",
"op_inputs": { "op_inputs": {
"X": ["softmax_output"], "X": ["softmax_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["dropout3_output"]},
"Out": ["dropout3_output"] "op_attrs": dics[16],
},
"op_attrs": dics[16]
}, },
{ {
"op_type": "matmul", "op_type": "matmul",
...@@ -768,32 +713,26 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -768,32 +713,26 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
"X": ["dropout3_output"], "X": ["dropout3_output"],
"Y": ["transpose21_output"], "Y": ["transpose21_output"],
}, },
"op_outputs": { "op_outputs": {"Out": ["matmul2_output"]},
"Out": ["matmul2_output"] "op_attrs": dics[17],
},
"op_attrs": dics[17]
}, },
{ {
"op_type": "transpose2", "op_type": "transpose2",
"op_inputs": { "op_inputs": {"X": ["matmul2_output"]},
"X": ["matmul2_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["transpose24_output"], "Out": ["transpose24_output"],
"XShape": ["transpose24_output_xshape"] "XShape": ["transpose24_output_xshape"],
}, },
"op_attrs": dics[18] "op_attrs": dics[18],
}, },
{ {
"op_type": "reshape2", "op_type": "reshape2",
"op_inputs": { "op_inputs": {"X": ["transpose24_output"]},
"X": ["transpose24_output"]
},
"op_outputs": { "op_outputs": {
"Out": ["reshape24_output"], "Out": ["reshape24_output"],
"XShape": ["reshape24_output_xshape"] "XShape": ["reshape24_output_xshape"],
}, },
"op_attrs": dics[19] "op_attrs": dics[19],
}, },
# In order to fuse ops with # In order to fuse ops with
# multihead_matmul_fuse_pass_v2, the last op # multihead_matmul_fuse_pass_v2, the last op
...@@ -802,61 +741,62 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest): ...@@ -802,61 +741,62 @@ class TrtConvertMultiHeadMatmulTestInt8(TrtConvertMultiHeadMatmulTest):
"op_type": "mul", "op_type": "mul",
"op_inputs": { "op_inputs": {
"X": ["reshape24_output"], "X": ["reshape24_output"],
"Y": ["mul4_weight"] "Y": ["mul4_weight"],
}, },
"op_outputs": { "op_outputs": {"Out": ["mul4_output"]},
"Out": ["mul4_output"] "op_attrs": dics[20],
}, },
"op_attrs": dics[20]
}
] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"mul1_weight": "mul1_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul2_weight": "mul2_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul3_weight": "mul3_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"mul4_weight": "mul4_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight1)
data_gen=partial(generate_weight1)), ),
"elementwise_add1_weight": "elementwise_add1_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
"elementwise_add2_weight": "elementwise_add2_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
"elementwise_add3_weight": "elementwise_add3_weight": TensorConfig(
TensorConfig( data_gen=partial(generate_weight2)
data_gen=partial(generate_weight2)), ),
}, },
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, batch, dim1)), generate_input1, batch, dim1
"input_data2": )
TensorConfig(data_gen=partial( ),
generate_input2, input2_shape)), "input_data2": TensorConfig(
data_gen=partial(
generate_input2, input2_shape
)
),
}, },
outputs=["mul4_output"]) outputs=["mul4_output"],
)
yield program_config yield program_config
class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest): class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch, length): def generate_input1(batch, length):
return np.zeros((batch, length, 768), dtype=np.float32) return np.zeros((batch, length, 768), dtype=np.float32)
...@@ -870,216 +810,190 @@ class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -870,216 +810,190 @@ class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest):
self.batch = batch self.batch = batch
for length in [64, 384]: for length in [64, 384]:
self.length = length self.length = length
ops_config = [{ ops_config = [
"op_type": "matmul_v2", {
"op_inputs": { "op_type": "matmul_v2",
"X": ["input_data1"], "op_inputs": {
"Y": ["matmul1_weight"] "X": ["input_data1"],
}, "Y": ["matmul1_weight"],
"op_outputs": { },
"Out": ["matmul1_output"] "op_outputs": {"Out": ["matmul1_output"]},
}, "op_attrs": {"trans_x": False, "trans_y": False},
"op_attrs": {
"trans_x": False,
"trans_y": False
}
}, {
"op_type": "elementwise_add",
"op_inputs": {
"X": ["matmul1_output"],
"Y": ["elementwise_add1_weight"]
},
"op_outputs": {
"Out": ["elementwise_add1_output"]
}, },
"op_attrs": { {
"Scale_out": 1.0, "op_type": "elementwise_add",
"Scale_x": 1.0, "op_inputs": {
"Scale_y": 1.0, "X": ["matmul1_output"],
"axis": 2 "Y": ["elementwise_add1_weight"],
} },
}, { "op_outputs": {"Out": ["elementwise_add1_output"]},
"op_type": "reshape2", "op_attrs": {
"op_inputs": { "Scale_out": 1.0,
"X": ["elementwise_add1_output"], "Scale_x": 1.0,
"Scale_y": 1.0,
"axis": 2,
},
}, },
"op_outputs": { {
"Out": ["reshape1_output"], "op_type": "reshape2",
"XShape": ["reshape1_output_xshape"] "op_inputs": {
"X": ["elementwise_add1_output"],
},
"op_outputs": {
"Out": ["reshape1_output"],
"XShape": ["reshape1_output_xshape"],
},
"op_attrs": {"shape": [-1, self.length, 3, 12, 64]},
}, },
"op_attrs": { {
"shape": [-1, self.length, 3, 12, 64] "op_type": "transpose2",
} "op_inputs": {"X": ["reshape1_output"]},
}, { "op_outputs": {
"op_type": "transpose2", "Out": ["transpose1_output"],
"op_inputs": { "XShape": ["transpose1_output_xshape"],
"X": ["reshape1_output"] },
"op_attrs": {
"axis": [2, 0, 3, 1, 4],
"data_format": "AnyLayout",
},
}, },
"op_outputs": { {
"Out": ["transpose1_output"], "op_type": "slice",
"XShape": ["transpose1_output_xshape"] "op_inputs": {
"Input": ["transpose1_output"],
},
"op_outputs": {"Out": ["slice1_output"]},
"op_attrs": {
"axes": [0],
"starts": [0],
"ends": [1],
"decrease_axis": [0],
"infer_flags": [1],
},
}, },
"op_attrs": { {
"axis": [2, 0, 3, 1, 4], "op_type": "slice",
"data_format": "AnyLayout" "op_inputs": {
} "Input": ["transpose1_output"],
}, { },
"op_type": "slice", "op_outputs": {"Out": ["slice2_output"]},
"op_inputs": { "op_attrs": {
"Input": ["transpose1_output"], "axes": [0],
"starts": [1],
"ends": [2],
"decrease_axis": [0],
"infer_flags": [1],
},
}, },
"op_outputs": { {
"Out": ["slice1_output"] "op_type": "slice",
"op_inputs": {
"Input": ["transpose1_output"],
},
"op_outputs": {"Out": ["slice3_output"]},
"op_attrs": {
"axes": [0],
"starts": [2],
"ends": [3],
"decrease_axis": [0],
"infer_flags": [1],
},
}, },
"op_attrs": { {
"axes": [0], "op_type": "transpose2",
"starts": [0], "op_inputs": {"X": ["slice2_output"]},
"ends": [1], "op_outputs": {
"decrease_axis": [0], "Out": ["transpose2_output"],
"infer_flags": [1] },
} "op_attrs": {
}, { "axis": [0, 1, 3, 2],
"op_type": "slice", "data_format": "AnyLayout",
"op_inputs": { },
"Input": ["transpose1_output"],
}, },
"op_outputs": { {
"Out": ["slice2_output"] "op_type": "matmul_v2",
"op_inputs": {
"X": ["slice1_output"],
"Y": ["transpose2_output"],
},
"op_outputs": {"Out": ["matmul2_output"]},
"op_attrs": {"trans_x": False, "trans_y": False},
}, },
"op_attrs": { {
"axes": [0], "op_type": "scale",
"starts": [1], "op_inputs": {
"ends": [2], "X": ["matmul2_output"],
"decrease_axis": [0], },
"infer_flags": [1] "op_outputs": {"Out": ["scale_output"]},
} "op_attrs": {
}, { "scale": 0.125,
"op_type": "slice", "bias": 0.0,
"op_inputs": { "bias_after_scale": True,
"Input": ["transpose1_output"], },
}, },
"op_outputs": { {
"Out": ["slice3_output"] "op_type": "softmax",
"op_inputs": {"X": ["scale_output"]},
"op_outputs": {"Out": ["softmax_output"]},
"op_attrs": {"axis": -1, "data_format": "AnyLayout"},
}, },
"op_attrs": { {
"axes": [0], "op_type": "matmul_v2",
"starts": [2], "op_inputs": {
"ends": [3], "X": ["softmax_output"],
"decrease_axis": [0], "Y": ["slice3_output"],
"infer_flags": [1] },
} "op_outputs": {"Out": ["matmul3_output"]},
}, { "op_attrs": {"trans_x": False, "trans_y": False},
"op_type": "transpose2",
"op_inputs": {
"X": ["slice2_output"]
}, },
"op_outputs": { {
"Out": ["transpose2_output"], "op_type": "transpose2",
"op_inputs": {"X": ["matmul3_output"]},
"op_outputs": {
"Out": ["transpose3_output"],
"XShape": ["transpose3_output_xshape"],
},
"op_attrs": {
"axis": [0, 2, 1, 3],
"data_format": "AnyLayout",
},
}, },
"op_attrs": { {
"axis": [0, 1, 3, 2], "op_type": "reshape2",
"data_format": "AnyLayout" "op_inputs": {"X": ["transpose3_output"]},
} "op_outputs": {
}, { "Out": ["reshape2_output"],
"op_type": "matmul_v2", "XShape": ["reshape2_output_xshape"],
"op_inputs": { },
"X": ["slice1_output"], "op_attrs": {"shape": [-1, self.length, 768]},
"Y": ["transpose2_output"]
}, },
"op_outputs": { ]
"Out": ["matmul2_output"]
},
"op_attrs": {
"trans_x": False,
"trans_y": False
}
}, {
"op_type": "scale",
"op_inputs": {
"X": ["matmul2_output"],
},
"op_outputs": {
"Out": ["scale_output"]
},
"op_attrs": {
"scale": 0.125,
"bias": 0.0,
"bias_after_scale": True
}
}, {
"op_type": "softmax",
"op_inputs": {
"X": ["scale_output"]
},
"op_outputs": {
"Out": ["softmax_output"]
},
"op_attrs": {
"axis": -1,
"data_format": "AnyLayout"
}
}, {
"op_type": "matmul_v2",
"op_inputs": {
"X": ["softmax_output"],
"Y": ["slice3_output"]
},
"op_outputs": {
"Out": ["matmul3_output"]
},
"op_attrs": {
"trans_x": False,
"trans_y": False
}
}, {
"op_type": "transpose2",
"op_inputs": {
"X": ["matmul3_output"]
},
"op_outputs": {
"Out": ["transpose3_output"],
"XShape": ["transpose3_output_xshape"]
},
"op_attrs": {
"axis": [0, 2, 1, 3],
"data_format": "AnyLayout"
}
}, {
"op_type": "reshape2",
"op_inputs": {
"X": ["transpose3_output"]
},
"op_outputs": {
"Out": ["reshape2_output"],
"XShape": ["reshape2_output_xshape"]
},
"op_attrs": {
"shape": [-1, self.length, 768]
}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={ weights={
"matmul1_weight": "matmul1_weight": TensorConfig(
TensorConfig(data_gen=partial(generate_weight1)), data_gen=partial(generate_weight1)
"elementwise_add1_weight": ),
TensorConfig(data_gen=partial(generate_weight2)) "elementwise_add1_weight": TensorConfig(
data_gen=partial(generate_weight2)
),
}, },
inputs={ inputs={
"input_data1": "input_data1": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, batch, length)
data_gen=partial(generate_input1, batch, length)) )
}, },
outputs=["reshape2_output"]) outputs=["reshape2_output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
# The last dim of input1 and input2 should be static. # The last dim of input1 and input2 should be static.
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -1111,11 +1025,15 @@ class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest): ...@@ -1111,11 +1025,15 @@ class TrtConvertVitToMultiHeadMatmulTest(TrtLayerAutoScanTest):
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.workspace_size = 2013265920 self.trt_param.workspace_size = 2013265920
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num(), (1e-3, yield self.create_inference_config(), generate_trt_nodes_num(), (
1e-3) 1e-3,
1e-3,
)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num(), (1e-5, yield self.create_inference_config(), generate_trt_nodes_num(), (
1e-5) 1e-5,
1e-5,
)
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_pad3d.py
浏览文件 @ 7a0b8625
...@@ -22,30 +22,30 @@ import unittest ...@@ -22,30 +22,30 @@ import unittest
class TrtConvertPad3d(TrtLayerAutoScanTest): class TrtConvertPad3d(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.ones([1, 1, 3, 64, 64]).astype(np.float32) return np.ones([1, 1, 3, 64, 64]).astype(np.float32)
for value in [True, False]: for value in [True, False]:
for paddings in [[0, 0, 0, 0, 1, 1], [0, 0, 1, 2, 3, 4], for paddings in [
[1, 1, 1, 1, 1, 1], [0, 0, -1, -1, 1, 1]]: [0, 0, 0, 0, 1, 1],
[0, 0, 1, 2, 3, 4],
[1, 1, 1, 1, 1, 1],
[0, 0, -1, -1, 1, 1],
]:
dics = [{"value": value, "paddings": paddings}, {}] dics = [{"value": value, "paddings": paddings}, {}]
ops_config = [{ ops_config = [
"op_type": "pad3d", {
"op_inputs": { "op_type": "pad3d",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {"Out": ["output_data"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["output_data"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
...@@ -53,16 +53,18 @@ class TrtConvertPad3d(TrtLayerAutoScanTest): ...@@ -53,16 +53,18 @@ class TrtConvertPad3d(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 1, 3, 64, 64] "input_data": [1, 1, 3, 64, 64]
...@@ -88,14 +90,14 @@ class TrtConvertPad3d(TrtLayerAutoScanTest): ...@@ -88,14 +90,14 @@ class TrtConvertPad3d(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_pool2d.py
浏览文件 @ 7a0b8625
...@@ -20,10 +20,10 @@ from functools import partial ...@@ -20,10 +20,10 @@ from functools import partial
from typing import Optional, List, Callable, Dict, Any, Set from typing import Optional, List, Callable, Dict, Any, Set
import unittest import unittest
import itertools import itertools
import copy
class TrtConvertPool2dTest(TrtLayerAutoScanTest): class TrtConvertPool2dTest(TrtLayerAutoScanTest):
def is_paddings_valid(self, program_config: ProgramConfig) -> bool: def is_paddings_valid(self, program_config: ProgramConfig) -> bool:
exclusive = program_config.ops[0].attrs['exclusive'] exclusive = program_config.ops[0].attrs['exclusive']
paddings = program_config.ops[0].attrs['paddings'] paddings = program_config.ops[0].attrs['paddings']
...@@ -65,39 +65,54 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest): ...@@ -65,39 +65,54 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest):
ceil_mode_options = [True, False] ceil_mode_options = [True, False]
configurations = [ configurations = [
strides_options, paddings_options, pooling_type_options, strides_options,
padding_algorithm_options, ksize_options, data_format_options, paddings_options,
global_pooling_options, exclusive_options, adaptive_option, pooling_type_options,
ceil_mode_options padding_algorithm_options,
ksize_options,
data_format_options,
global_pooling_options,
exclusive_options,
adaptive_option,
ceil_mode_options,
] ]
for (strides, paddings, pooling_type, padding_algorithm, ksize, for (
data_format, global_pooling, exclusive, adaptive, strides,
ceil_mode) in itertools.product(*configurations): paddings,
pooling_type,
attrs = [{ padding_algorithm,
"strides": strides, ksize,
"paddings": paddings, data_format,
"pooling_type": pooling_type, global_pooling,
"padding_algorithm": padding_algorithm, exclusive,
"ksize": ksize, adaptive,
"data_format": data_format, ceil_mode,
"global_pooling": global_pooling, ) in itertools.product(*configurations):
"exclusive": exclusive,
"adaptive": adaptive, attrs = [
"ceil_mode": ceil_mode, {
}] "strides": strides,
"paddings": paddings,
ops_config = [{ "pooling_type": pooling_type,
"op_type": "pool2d", "padding_algorithm": padding_algorithm,
"op_inputs": { "ksize": ksize,
"X": ["input_data"] "data_format": data_format,
}, "global_pooling": global_pooling,
"op_outputs": { "exclusive": exclusive,
"Out": ["output_data"] "adaptive": adaptive,
}, "ceil_mode": ceil_mode,
"op_attrs": attrs[0] }
}] ]
ops_config = [
{
"op_type": "pool2d",
"op_inputs": {"X": ["input_data"]},
"op_outputs": {"Out": ["output_data"]},
"op_attrs": attrs[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
...@@ -105,16 +120,18 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest): ...@@ -105,16 +120,18 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, attrs)) data_gen=partial(generate_input1, attrs)
)
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
self.dynamic_shape.max_input_shape = {"input_data": [1, 3, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [1, 3, 64, 64]}
...@@ -136,36 +153,75 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest): ...@@ -136,36 +153,75 @@ class TrtConvertPool2dTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-3, 1e-3) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-3, 1e-3) attrs, True
), (1e-3, 1e-3)
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller(program_config, predictor_config): def teller(program_config, predictor_config):
if program_config.ops[0].attrs['pooling_type'] == 'avg' and \ if (
program_config.ops[0].attrs['global_pooling'] == False and \ program_config.ops[0].attrs['pooling_type'] == 'avg'
program_config.ops[0].attrs['exclusive'] == True and \ and program_config.ops[0].attrs['global_pooling'] == False
program_config.ops[0].attrs['adaptive'] == False and \ and program_config.ops[0].attrs['exclusive'] == True
program_config.ops[0].attrs['ceil_mode'] == True: and program_config.ops[0].attrs['adaptive'] == False
and program_config.ops[0].attrs['ceil_mode'] == True
):
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller, SkipReasons.TRT_NOT_IMPLEMENTED, teller,
"The results of some cases are Nan, but the results of TensorRT and GPU are the same." SkipReasons.TRT_NOT_IMPLEMENTED,
"The results of some cases are Nan, but the results of TensorRT and GPU are the same.",
) )
def assert_tensors_near(
self,
atol: float,
rtol: float,
tensor: Dict[str, np.array],
baseline: Dict[str, np.array],
):
for key, arr in tensor.items():
self.assertEqual(
baseline[key].shape,
arr.shape,
'The output shapes are not equal, the baseline shape is '
+ str(baseline[key].shape)
+ ', but got '
+ str(arr.shape),
)
# The result of Pool2d may have some elements that is the least value (-65504 for FP16),
# but for FP32 and FP16 precision, their least value are different.
# We set a threshold that is the least value of FP16,
# and make the values less than the threshold to be the threshold.
def align_less_threshold(arr, threshold):
return np.clip(arr, threshold, None)
fp16_min = np.finfo(np.float16).min
baseline_threshold = align_less_threshold(
copy.deepcopy(baseline[key]), fp16_min
)
arr_threshold = align_less_threshold(copy.deepcopy(arr), fp16_min)
np.testing.assert_allclose(
baseline_threshold, arr_threshold, rtol=rtol, atol=atol
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_reduce_sum.py
浏览文件 @ 7a0b8625
...@@ -23,7 +23,6 @@ import unittest ...@@ -23,7 +23,6 @@ import unittest
class TrtConvertReduceSumTest(TrtLayerAutoScanTest): class TrtConvertReduceSumTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
attrs = [ attrs = [
...@@ -41,7 +40,6 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest): ...@@ -41,7 +40,6 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(dtype, attrs: List[Dict[str, Any]]): def generate_input1(dtype, attrs: List[Dict[str, Any]]):
if dtype == -1 or dtype == 5: if dtype == -1 or dtype == 5:
return np.random.random([1, 3, 32, 32]).astype(np.float32) return np.random.random([1, 3, 32, 32]).astype(np.float32)
...@@ -49,39 +47,52 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest): ...@@ -49,39 +47,52 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest):
return np.random.random([1, 3, 32, 32]).astype(np.int32) return np.random.random([1, 3, 32, 32]).astype(np.int32)
for keep_dim in [True, False]: for keep_dim in [True, False]:
for dim in [[], [1], [0], [0, 1], [1, 2, 3], [-2, 0, 3], [-3], for dim in [
[-4, 1], [3, 4, 5]]: [],
[1],
[0],
[0, 1],
[1, 2, 3],
[-2, 0, 3],
[-3],
[-4, 1],
[3, 4, 5],
]:
for reduce_all in [True, False]: for reduce_all in [True, False]:
for out_dtype in [-1, 2, 5]: for out_dtype in [-1, 2, 5]:
dics = [{ dics = [
"keep_dim": keep_dim, {
"dim": dim, "keep_dim": keep_dim,
"reduce_all": reduce_all, "dim": dim,
"out_dtype": out_dtype, "reduce_all": reduce_all,
"in_dtype": out_dtype, "out_dtype": out_dtype,
}, {}] "in_dtype": out_dtype,
ops_config = [{
"op_type": "reduce_sum",
"op_inputs": {
"X": ["input_data"]
}, },
"op_outputs": { {},
"Out": ["reduce_output_data"] ]
},
"op_attrs": dics[0] ops_config = [
}] {
"op_type": "reduce_sum",
"op_inputs": {"X": ["input_data"]},
"op_outputs": {"Out": ["reduce_output_data"]},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, out_dtype, dics)) generate_input1, out_dtype, dics
)
)
}, },
outputs=["reduce_output_data"]) outputs=["reduce_output_data"],
)
if not self.is_program_valid(program_config): if not self.is_program_valid(program_config):
continue continue
...@@ -89,7 +100,6 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest): ...@@ -89,7 +100,6 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest):
yield program_config yield program_config
def sample_predictor_configs(self, program_config): def sample_predictor_configs(self, program_config):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]}
...@@ -120,19 +130,23 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest): ...@@ -120,19 +130,23 @@ class TrtConvertReduceSumTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-5, 1e-5) attrs, False
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), (1e-4, 1e-4) attrs, False
), (1e-3, 1e-3)
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-5, 1e-5) attrs, True
), (1e-5, 1e-5)
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), (1e-4, 1e-4) attrs, True
), (1e-3, 1e-3)
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_reshape.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertReshapeTest(TrtLayerAutoScanTest): class TrtConvertReshapeTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
attrs = [ attrs = [
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
...@@ -31,7 +30,7 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -31,7 +30,7 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
if len(attrs[0]['shape']) != 1: if len(attrs[0]['shape']) != 1:
return False return False
#To test if the shape contains 0 # To test if the shape contains 0
if len(attrs[0]['shape']) == 3: if len(attrs[0]['shape']) == 3:
if attrs[0]['shape'][1] == 0: if attrs[0]['shape'][1] == 0:
if self.dims != 3: if self.dims != 3:
...@@ -45,7 +44,6 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -45,7 +44,6 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
if self.dims == 4: if self.dims == 4:
self.input_shape = [1, 2, 4, 6] self.input_shape = [1, 2, 4, 6]
...@@ -70,9 +68,18 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -70,9 +68,18 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
return np.array([24]).astype(np.int32) return np.array([24]).astype(np.int32)
for dims in [4, 3, 2, 1]: for dims in [4, 3, 2, 1]:
for shape in [[1, 6, 8], [1, 2, 4, 6], [1, 1, 0, 12], [1, 0, 6], for shape in [
[1, -1, 12], [2, -1], [3, 16], [3, 4, 4], [48], [1, 6, 8],
[-1, 48]]: [1, 2, 4, 6],
[1, 1, 0, 12],
[1, 0, 6],
[1, -1, 12],
[2, -1],
[3, 16],
[3, 4, 4],
[48],
[-1, 48],
]:
dics = [ dics = [
{ {
"shape": shape, "shape": shape,
...@@ -81,29 +88,31 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -81,29 +88,31 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
self.dims = dims self.dims = dims
dics_intput = [{"X": ["reshape_input"]}] dics_intput = [{"X": ["reshape_input"]}]
ops_config = [{ ops_config = [
"op_type": "reshape", {
"op_inputs": dics_intput[0], "op_type": "reshape",
"op_outputs": { "op_inputs": dics_intput[0],
"Out": ["reshape_out"] "op_outputs": {"Out": ["reshape_out"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"reshape_input": "reshape_input": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, dics)) data_gen=partial(generate_input1, dics)
)
}, },
outputs=["reshape_out"]) outputs=["reshape_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -141,13 +150,14 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -141,13 +150,14 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
def generate_trt_nodes_num(attrs, dynamic_shape): def generate_trt_nodes_num(attrs, dynamic_shape):
# in static shape mode, here is consistent with op_teller.cc # in static shape mode, here is consistent with op_teller.cc
if (not dynamic_shape): if not dynamic_shape:
if (attrs[0]['shape'][0] == 0): if attrs[0]['shape'][0] == 0:
return 1, 2 return 1, 2
elif (len(attrs[0]['shape']) == 1): elif len(attrs[0]['shape']) == 1:
return 0, 3 return 0, 3
elif (np.prod(attrs[0]['shape'][1:]) == np.prod( elif np.prod(attrs[0]['shape'][1:]) == np.prod(
self.input_shape[1:])): self.input_shape[1:]
):
return 1, 2 return 1, 2
else: else:
return 0, 3 return 0, 3
...@@ -161,19 +171,23 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -161,19 +171,23 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
...@@ -185,12 +199,10 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest): ...@@ -185,12 +199,10 @@ class TrtConvertReshapeTest(TrtLayerAutoScanTest):
# reshape having three inputs. # reshape having three inputs.
class TrtConvertReshapeTest2(TrtLayerAutoScanTest): class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
if self.dims == 4: if self.dims == 4:
return np.random.random([1, 2, 4, 6]).astype(np.float32) return np.random.random([1, 2, 4, 6]).astype(np.float32)
...@@ -203,9 +215,12 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -203,9 +215,12 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
for dims in [4, 3, 2, 1]: for dims in [4, 3, 2, 1]:
for shape in [[-1, 48]]: for shape in [[-1, 48]]:
dics = [{ dics = [
"shape": shape, {
}, {}] "shape": shape,
},
{},
]
self.dims = dims self.dims = dims
dics_intput = [ dics_intput = [
{ {
...@@ -217,9 +232,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -217,9 +232,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
{ {
"op_type": "fill_constant", "op_type": "fill_constant",
"op_inputs": {}, "op_inputs": {},
"op_outputs": { "op_outputs": {"Out": ["shapeT1_data"]},
"Out": ["shapeT1_data"]
},
"op_attrs": { "op_attrs": {
"dtype": 2, "dtype": 2,
"str_value": "2", "str_value": "2",
...@@ -229,9 +242,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -229,9 +242,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
{ {
"op_type": "fill_constant", "op_type": "fill_constant",
"op_inputs": {}, "op_inputs": {},
"op_outputs": { "op_outputs": {"Out": ["shapeT2_data"]},
"Out": ["shapeT2_data"]
},
"op_attrs": { "op_attrs": {
"dtype": 2, "dtype": 2,
"str_value": "24", "str_value": "24",
...@@ -241,10 +252,8 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -241,10 +252,8 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
{ {
"op_type": "reshape", "op_type": "reshape",
"op_inputs": dics_intput[0], "op_inputs": dics_intput[0],
"op_outputs": { "op_outputs": {"Out": ["reshape_out"]},
"Out": ["reshape_out"] "op_attrs": dics[0],
},
"op_attrs": dics[0]
}, },
] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
...@@ -252,16 +261,18 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -252,16 +261,18 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"reshape_input": "reshape_input": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, dics)) data_gen=partial(generate_input1, dics)
)
}, },
outputs=["reshape_out"]) outputs=["reshape_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -297,7 +308,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -297,7 +308,7 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
...@@ -309,12 +320,10 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest): ...@@ -309,12 +320,10 @@ class TrtConvertReshapeTest2(TrtLayerAutoScanTest):
# reshape having 2 inputs. # reshape having 2 inputs.
class TrtConvertReshapeTest3(TrtLayerAutoScanTest): class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
if self.dims == 4: if self.dims == 4:
return np.random.random([1, 2, 12, 6]).astype(np.float32) return np.random.random([1, 2, 12, 6]).astype(np.float32)
...@@ -327,9 +336,12 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest): ...@@ -327,9 +336,12 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
for dims in [4, 3, 2, 1]: for dims in [4, 3, 2, 1]:
for shape in [[-1, 144]]: for shape in [[-1, 144]]:
dics = [{ dics = [
"shape": shape, {
}, {}] "shape": shape,
},
{},
]
self.dims = dims self.dims = dims
dics_intput = [ dics_intput = [
{ {
...@@ -341,9 +353,7 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest): ...@@ -341,9 +353,7 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
{ {
"op_type": "fill_constant", "op_type": "fill_constant",
"op_inputs": {}, "op_inputs": {},
"op_outputs": { "op_outputs": {"Out": ["shape_data"]},
"Out": ["shape_data"]
},
"op_attrs": { "op_attrs": {
"dtype": 2, "dtype": 2,
"str_value": "12", "str_value": "12",
...@@ -353,10 +363,8 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest): ...@@ -353,10 +363,8 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
{ {
"op_type": "reshape", "op_type": "reshape",
"op_inputs": dics_intput[0], "op_inputs": dics_intput[0],
"op_outputs": { "op_outputs": {"Out": ["reshape_out"]},
"Out": ["reshape_out"] "op_attrs": dics[0],
},
"op_attrs": dics[0]
}, },
] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
...@@ -364,16 +372,18 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest): ...@@ -364,16 +372,18 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"reshape_input": "reshape_input": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, dics)) data_gen=partial(generate_input1, dics)
)
}, },
outputs=["reshape_out"]) outputs=["reshape_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -409,7 +419,7 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest): ...@@ -409,7 +419,7 @@ class TrtConvertReshapeTest3(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_roi_align.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,12 +22,10 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertRoiAlignTest(TrtLayerAutoScanTest): class TrtConvertRoiAlignTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
return np.ones([batch, 256, 32, 32]).astype(np.float32) return np.ones([batch, 256, 32, 32]).astype(np.float32)
...@@ -47,92 +45,111 @@ class TrtConvertRoiAlignTest(TrtLayerAutoScanTest): ...@@ -47,92 +45,111 @@ class TrtConvertRoiAlignTest(TrtLayerAutoScanTest):
self.num_input = num_input self.num_input = num_input
if num_input == 1: if num_input == 1:
batch = 1 batch = 1
dics = [{ dics = [
"spatial_scale": spatial_scale, {
"pooled_height": pooled_height, "spatial_scale": spatial_scale,
"pooled_width": pooled_width, "pooled_height": pooled_height,
"sampling_ratio": sampling_ratio, "pooled_width": pooled_width,
"aligned": aligned "sampling_ratio": sampling_ratio,
}, {}] "aligned": aligned,
dics_input = [{ },
"X": ["roi_align_input"], {},
"ROIs": ["ROIs"], ]
"RoisNum": ["RoisNum"] dics_input = [
}, { {
"X": ["roi_align_input"], "X": ["roi_align_input"],
"ROIs": ["ROIs"] "ROIs": ["ROIs"],
}] "RoisNum": ["RoisNum"],
program_input = [{ },
"roi_align_input": {
TensorConfig(data_gen=partial( "X": ["roi_align_input"],
generate_input1, dics, batch)), "ROIs": ["ROIs"],
"ROIs": },
TensorConfig(data_gen=partial( ]
generate_input2, dics, batch)), program_input = [
"RoisNum": {
TensorConfig(data_gen=partial( "roi_align_input": TensorConfig(
generate_input3, dics, batch)) data_gen=partial(
}, { generate_input1, dics, batch
"roi_align_input": )
TensorConfig(data_gen=partial( ),
generate_input1, dics, batch)), "ROIs": TensorConfig(
"ROIs": data_gen=partial(
TensorConfig(data_gen=partial( generate_input2, dics, batch
generate_input2, dics, batch), )
lod=[[32, 3]]) ),
}] "RoisNum": TensorConfig(
ops_config = [{ data_gen=partial(
"op_type": generate_input3, dics, batch
"roi_align", )
"op_inputs": ),
dics_input[num_input], },
"op_outputs": { {
"Out": ["roi_align_out"] "roi_align_input": TensorConfig(
data_gen=partial(
generate_input1, dics, batch
)
),
"ROIs": TensorConfig(
data_gen=partial(
generate_input2, dics, batch
),
lod=[[32, 3]],
),
}, },
"op_attrs": ]
dics[0] ops_config = [
}] {
"op_type": "roi_align",
"op_inputs": dics_input[num_input],
"op_outputs": {
"Out": ["roi_align_out"]
},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs=program_input[num_input], inputs=program_input[num_input],
outputs=["roi_align_out"]) outputs=["roi_align_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.num_input == 0: if self.num_input == 0:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"roi_align_input": [1, 256, 32, 32], "roi_align_input": [1, 256, 32, 32],
"ROIs": [3, 4], "ROIs": [3, 4],
"RoisNum": [1] "RoisNum": [1],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"roi_align_input": [1, 256, 64, 64], "roi_align_input": [1, 256, 64, 64],
"ROIs": [3, 4], "ROIs": [3, 4],
"RoisNum": [1] "RoisNum": [1],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"roi_align_input": [1, 256, 64, 64], "roi_align_input": [1, 256, 64, 64],
"ROIs": [3, 4], "ROIs": [3, 4],
"RoisNum": [1] "RoisNum": [1],
} }
elif self.num_input == 1: elif self.num_input == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"roi_align_input": [1, 256, 32, 32], "roi_align_input": [1, 256, 32, 32],
"ROIs": [3, 4] "ROIs": [3, 4],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"roi_align_input": [1, 256, 64, 64], "roi_align_input": [1, 256, 64, 64],
"ROIs": [3, 4] "ROIs": [3, 4],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"roi_align_input": [1, 256, 64, 64], "roi_align_input": [1, 256, 64, 64],
"ROIs": [3, 4] "ROIs": [3, 4],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -159,29 +176,33 @@ class TrtConvertRoiAlignTest(TrtLayerAutoScanTest): ...@@ -159,29 +176,33 @@ class TrtConvertRoiAlignTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(program_config.inputs) == 3: if len(program_config.inputs) == 3:
return True return True
return False return False
self.add_skip_case(teller1, SkipReasons.TRT_NOT_SUPPORT, self.add_skip_case(
"INPUT RoisNum NOT SUPPORT") teller1, SkipReasons.TRT_NOT_SUPPORT, "INPUT RoisNum NOT SUPPORT"
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_roll.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertRollTest(TrtLayerAutoScanTest): class TrtConvertRollTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -32,43 +31,44 @@ class TrtConvertRollTest(TrtLayerAutoScanTest): ...@@ -32,43 +31,44 @@ class TrtConvertRollTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
return np.ones([1, 56, 56, 192]).astype(np.float32) return np.ones([1, 56, 56, 192]).astype(np.float32)
for axis in [[1, 2]]: for axis in [[1, 2]]:
for shifts in [[-1, -1], [-3, -3]]: for shifts in [[-1, -1], [-3, -3]]:
dics = [{ dics = [
"axis": axis, {
"shifts": shifts, "axis": axis,
}] "shifts": shifts,
}
ops_config = [{ ]
"op_type": "roll",
"op_inputs": { ops_config = [
"X": ["input_data"] {
}, "op_type": "roll",
"op_outputs": { "op_inputs": {"X": ["input_data"]},
"Out": ["roll_output_data"] "op_outputs": {"Out": ["roll_output_data"]},
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, dics)) data_gen=partial(generate_input1, dics)
)
}, },
outputs=["roll_output_data"]) outputs=["roll_output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 56, 56, 192] "input_data": [1, 56, 56, 192]
...@@ -103,19 +103,23 @@ class TrtConvertRollTest(TrtLayerAutoScanTest): ...@@ -103,19 +103,23 @@ class TrtConvertRollTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-4 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-4 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_scatter_nd_add.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertScatterNd(TrtLayerAutoScanTest): class TrtConvertScatterNd(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([6]).astype(np.float32) return np.random.random([6]).astype(np.float32)
...@@ -37,38 +35,42 @@ class TrtConvertScatterNd(TrtLayerAutoScanTest): ...@@ -37,38 +35,42 @@ class TrtConvertScatterNd(TrtLayerAutoScanTest):
def generate_input3(): def generate_input3():
return np.random.random([4]).astype(np.float32) return np.random.random([4]).astype(np.float32)
ops_config = [{ ops_config = [
"op_type": "scatter_nd_add", {
"op_inputs": { "op_type": "scatter_nd_add",
"X": ["input_data"], "op_inputs": {
"Index": ["index_data"], "X": ["input_data"],
"Updates": ["update_data"] "Index": ["index_data"],
}, "Updates": ["update_data"],
"op_outputs": { },
"Out": ["output_data"] "op_outputs": {"Out": ["output_data"]},
}, "op_attrs": {},
"op_attrs": {} }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
"index_data": ),
TensorConfig(data_gen=partial(generate_input2)), "index_data": TensorConfig(
"update_data": data_gen=partial(generate_input2)
TensorConfig(data_gen=partial(generate_input3)), ),
"update_data": TensorConfig(
data_gen=partial(generate_input3)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1], "input_data": [1],
...@@ -100,14 +102,14 @@ class TrtConvertScatterNd(TrtLayerAutoScanTest): ...@@ -100,14 +102,14 @@ class TrtConvertScatterNd(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 5), 1e-5 yield self.create_inference_config(), (0, 5), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 5), 1e-5 yield self.create_inference_config(), (0, 5), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 4), 1e-5 yield self.create_inference_config(), (1, 4), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 4), 1e-5 yield self.create_inference_config(), (1, 4), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_shape.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertSumTest(TrtLayerAutoScanTest): class TrtConvertSumTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch): def generate_input1(batch):
if self.dims == 4: if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32) return np.ones([batch, 3, 24, 24]).astype(np.float32)
...@@ -41,31 +39,31 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -41,31 +39,31 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
self.dims = dims self.dims = dims
ops_config = [{ ops_config = [
"op_type": "shape", {
"op_inputs": { "op_type": "shape",
"Input": ["input1"] "op_inputs": {"Input": ["input1"]},
}, "op_outputs": {"Out": ["output"]},
"op_outputs": { "op_attrs": {},
"Out": ["output"] }
}, ]
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1": "input1": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, batch)) data_gen=partial(generate_input1, batch)
)
}, },
outputs=["output"]) outputs=["output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = {"input1": [1, 3, 24, 24]} self.dynamic_shape.min_input_shape = {"input1": [1, 3, 24, 24]}
...@@ -87,7 +85,7 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -87,7 +85,7 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
} }
def generate_trt_nodes_num(dynamic_shape): def generate_trt_nodes_num(dynamic_shape):
if (not dynamic_shape): if not dynamic_shape:
return 0, 3 return 0, 3
return 1, 2 return 1, 2
...@@ -100,17 +98,19 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -100,17 +98,19 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_shuffle_channel.py
浏览文件 @ 7a0b8625
...@@ -22,44 +22,41 @@ import unittest ...@@ -22,44 +22,41 @@ import unittest
class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest): class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
return np.ones([batch, 6, 24, 24]).astype(np.float32) return np.ones([batch, 6, 24, 24]).astype(np.float32)
for batch in [1, 2, 4]: for batch in [1, 2, 4]:
for group in [1, 2, 3]: for group in [1, 2, 3]:
dics = [{"group": group}, {}] dics = [{"group": group}, {}]
ops_config = [{ ops_config = [
"op_type": "shuffle_channel", {
"op_inputs": { "op_type": "shuffle_channel",
"X": ["shuffle_channel_input"] "op_inputs": {"X": ["shuffle_channel_input"]},
}, "op_outputs": {"Out": ["shuffle_channel_out"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["shuffle_channel_out"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"shuffle_channel_input": "shuffle_channel_input": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics, batch)
data_gen=partial(generate_input1, dics, batch)) )
}, },
outputs=["shuffle_channel_out"]) outputs=["shuffle_channel_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"shuffle_channel_input": [1, 6, 24, 24] "shuffle_channel_input": [1, 6, 24, 24]
...@@ -78,8 +75,10 @@ class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest): ...@@ -78,8 +75,10 @@ class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest):
def generate_trt_nodes_num(attrs, dynamic_shape): def generate_trt_nodes_num(attrs, dynamic_shape):
ver = paddle_infer.get_trt_compile_version() ver = paddle_infer.get_trt_compile_version()
if ver[0] * 1000 + ver[1] * 100 + ver[ if (
2] * 10 < 8000 and dynamic_shape == True: ver[0] * 1000 + ver[1] * 100 + ver[2] * 10 < 8000
and dynamic_shape == True
):
return 0, 3 return 0, 3
else: else:
return 1, 2 return 1, 2
...@@ -92,19 +91,23 @@ class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest): ...@@ -92,19 +91,23 @@ class TrtConvertShuffleChannelTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_slice.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertSliceTest(TrtLayerAutoScanTest): class TrtConvertSliceTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -34,13 +33,17 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest): ...@@ -34,13 +33,17 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest):
start = 0 start = 0
end = 0 end = 0
if attrs[0]["starts"][x] < 0: if attrs[0]["starts"][x] < 0:
start = attrs[0]["starts"][x] + inputs['input_data'].shape[ start = (
attrs[0]["axes"][x]] attrs[0]["starts"][x]
+ inputs['input_data'].shape[attrs[0]["axes"][x]]
)
else: else:
start = attrs[0]["starts"][x] start = attrs[0]["starts"][x]
if attrs[0]["ends"][x] < 0: if attrs[0]["ends"][x] < 0:
end = attrs[0]["ends"][x] + inputs['input_data'].shape[ end = (
attrs[0]["axes"][x]] attrs[0]["ends"][x]
+ inputs['input_data'].shape[attrs[0]["axes"][x]]
)
else: else:
end = attrs[0]["ends"][x] end = attrs[0]["ends"][x]
start = max(0, start) start = max(0, start)
...@@ -51,12 +54,11 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest): ...@@ -51,12 +54,11 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest):
for x in attrs[0]["decrease_axis"]: for x in attrs[0]["decrease_axis"]:
if x < 0: if x < 0:
return False return False
if (out_shape[x] != 1): if out_shape[x] != 1:
return False return False
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
return np.random.random([6, 6, 64, 64]).astype(np.float32) return np.random.random([6, 6, 64, 64]).astype(np.float32)
...@@ -65,41 +67,44 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest): ...@@ -65,41 +67,44 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest):
for ends in [[2, 2], [5, 5], [1, -1]]: for ends in [[2, 2], [5, 5], [1, -1]]:
for decrease_axis in [[], [1], [2], [-1], [-100]]: for decrease_axis in [[], [1], [2], [-1], [-100]]:
for infer_flags in [[-1]]: for infer_flags in [[-1]]:
dics = [{ dics = [
"axes": axes, {
"starts": starts, "axes": axes,
"ends": ends, "starts": starts,
"decrease_axis": decrease_axis, "ends": ends,
"infer_flags": infer_flags "decrease_axis": decrease_axis,
}] "infer_flags": infer_flags,
}
ops_config = [{ ]
"op_type": "slice",
"op_inputs": { ops_config = [
"Input": ["input_data"] {
}, "op_type": "slice",
"op_outputs": { "op_inputs": {"Input": ["input_data"]},
"Out": ["slice_output_data"] "op_outputs": {
}, "Out": ["slice_output_data"]
"op_attrs": dics[0] },
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics)
data_gen=partial(generate_input1, dics)) )
}, },
outputs=["slice_output_data"]) outputs=["slice_output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
self.dynamic_shape.max_input_shape = {"input_data": [8, 8, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [8, 8, 64, 64]}
...@@ -125,19 +130,23 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest): ...@@ -125,19 +130,23 @@ class TrtConvertSliceTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-4 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-4 attrs, True
), 1e-3
def test(self): def test(self):
# TODO(inference): fix. # TODO(inference): fix.
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_split.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertSplitTest(TrtLayerAutoScanTest): class TrtConvertSplitTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -35,13 +34,13 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -35,13 +34,13 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
if len(inputs['split_input'].shape) <= attrs[0]['axis']: if len(inputs['split_input'].shape) <= attrs[0]['axis']:
return False return False
#Sections and num cannot both be equal to 0. # Sections and num cannot both be equal to 0.
if len(attrs[0]['sections']) == 0: if len(attrs[0]['sections']) == 0:
if attrs[0]['num'] == 0: if attrs[0]['num'] == 0:
return False return False
#When sections and num are not both equal to 0, sections has higher priority. # When sections and num are not both equal to 0, sections has higher priority.
#The sum of sections should be equal to the input size. # The sum of sections should be equal to the input size.
if len(attrs[0]['sections']) != 0: if len(attrs[0]['sections']) != 0:
if attrs[0]['num'] != 0: if attrs[0]['num'] != 0:
return False return False
...@@ -53,16 +52,18 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -53,16 +52,18 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
if sum != inputs['split_input'].shape[attrs[0]['axis']]: if sum != inputs['split_input'].shape[attrs[0]['axis']]:
return False return False
#The size of num should be equal to the input dimension. # The size of num should be equal to the input dimension.
if attrs[0]['num'] != 0: if attrs[0]['num'] != 0:
if len(outputs) != attrs[0]['num']: if len(outputs) != attrs[0]['num']:
return False return False
#Test AxisTensor and SectionsTensorList # Test AxisTensor and SectionsTensorList
if self.num_input == 0: if self.num_input == 0:
if self.dims == 2 and attrs[0]['sections'] == [ if (
10, 14 self.dims == 2
] and len(outputs) == 2: and attrs[0]['sections'] == [10, 14]
and len(outputs) == 2
):
return True return True
else: else:
return False return False
...@@ -70,7 +71,6 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -70,7 +71,6 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
if self.dims == 4: if self.dims == 4:
return np.random.random([batch, 3, 3, 24]).astype(np.float32) return np.random.random([batch, 3, 3, 24]).astype(np.float32)
...@@ -93,72 +93,95 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -93,72 +93,95 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
for num_input in [0, 1]: for num_input in [0, 1]:
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [3, 6, 9]: for batch in [3, 6, 9]:
for Out in [["output_var0", "output_var1"], for Out in [
["output_var0", "output_var1", "output_var2"]]: ["output_var0", "output_var1"],
for sections in [[], [1, 2], [2, 1], [10, 14], ["output_var0", "output_var1", "output_var2"],
[1, 1, 1], [2, 2, 2], [3, 3, 3], ]:
[3, 7, 14]]: for sections in [
[],
[1, 2],
[2, 1],
[10, 14],
[1, 1, 1],
[2, 2, 2],
[3, 3, 3],
[3, 7, 14],
]:
for num in [0, 3]: for num in [0, 3]:
for axis in [0, 1, 2, 3]: for axis in [0, 1, 2, 3]:
self.batch = batch self.batch = batch
self.num_input = num_input self.num_input = num_input
self.dims = dims self.dims = dims
dics = [{ dics = [
"sections": sections, {
"num": num, "sections": sections,
"axis": axis "num": num,
}, {}] "axis": axis,
},
dics_intput = [{ {},
"X": ["split_input"], ]
"AxisTensor": ["AxisTensor"],
"SectionsTensorList": [ dics_intput = [
"SectionsTensorList1", {
"SectionsTensorList2" "X": ["split_input"],
] "AxisTensor": ["AxisTensor"],
}, { "SectionsTensorList": [
"X": ["split_input"] "SectionsTensorList1",
}] "SectionsTensorList2",
dics_intputs = [{ ],
"AxisTensor":
TensorConfig(data_gen=partial(
generate_AxisTensor, dics)),
"SectionsTensorList1":
TensorConfig(data_gen=partial(
generate_SectionsTensorList1,
dics)),
"SectionsTensorList2":
TensorConfig(data_gen=partial(
generate_SectionsTensorList2, dics))
}, {}]
ops_config = [{
"op_type":
"split",
"op_inputs":
dics_intput[num_input],
"op_outputs": {
"Out": Out
}, },
"op_attrs": {"X": ["split_input"]},
dics[0] ]
}] dics_intputs = [
{
"AxisTensor": TensorConfig(
data_gen=partial(
generate_AxisTensor, dics
)
),
"SectionsTensorList1": TensorConfig(
data_gen=partial(
generate_SectionsTensorList1,
dics,
)
),
"SectionsTensorList2": TensorConfig(
data_gen=partial(
generate_SectionsTensorList2,
dics,
)
),
},
{},
]
ops_config = [
{
"op_type": "split",
"op_inputs": dics_intput[num_input],
"op_outputs": {"Out": Out},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights=dics_intputs[num_input], weights=dics_intputs[num_input],
inputs={ inputs={
"split_input": "split_input": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dics, batch)) generate_input1, dics, batch
)
)
}, },
outputs=Out) outputs=Out,
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -216,30 +239,35 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -216,30 +239,35 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
def teller1(program_config, predictor_config): def teller1(program_config, predictor_config):
if len(program_config.weights) == 3: if len(program_config.weights) == 3:
return True return True
return False return False
self.add_skip_case( self.add_skip_case(
teller1, SkipReasons.TRT_NOT_SUPPORT, teller1,
"INPUT AxisTensor AND SectionsTensorList NOT SUPPORT.") SkipReasons.TRT_NOT_SUPPORT,
"INPUT AxisTensor AND SectionsTensorList NOT SUPPORT.",
)
def test(self): def test(self):
self.add_skip_trt_case() self.add_skip_trt_case()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_squeeze2.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertSplitTest(TrtLayerAutoScanTest): class TrtConvertSplitTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
attrs = [ attrs = [
...@@ -40,25 +39,25 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -40,25 +39,25 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
self.dims = dims self.dims = dims
self.axes = axes self.axes = axes
dics = [{"axes": axes}] dics = [{"axes": axes}]
ops_config = [{ ops_config = [
"op_type": "squeeze2", {
"op_inputs": { "op_type": "squeeze2",
"X": ["in_data"] "op_inputs": {"X": ["in_data"]},
}, "op_outputs": {
"op_outputs": { "Out": ["out_data"],
"Out": ["out_data"], "XShape": ["XShape_data"],
"XShape": ["XShape_data"] },
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
# new_axes is the update of axes # new_axes is the update of axes
new_axes = list(axes) new_axes = list(axes)
for i in range(len(new_axes)): for i in range(len(new_axes)):
if (new_axes[i] < 0): if new_axes[i] < 0:
new_axes[i] += dims new_axes[i] += dims
if (max(new_axes) >= dims): if max(new_axes) >= dims:
continue continue
# generate input data # generate input data
self.input_shape = [1] * dims self.input_shape = [1] * dims
for i in range(dims): for i in range(dims):
self.input_shape[i] = np.random.randint(1, 20) self.input_shape[i] = np.random.randint(1, 20)
...@@ -68,24 +67,26 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -68,24 +67,26 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
for i in new_axes: for i in new_axes:
self.input_shape[i] = 1 self.input_shape[i] = 1
return np.random.random(self.input_shape).astype( return np.random.random(self.input_shape).astype(
np.float32) np.float32
)
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"in_data": "in_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics, batch)
data_gen=partial(generate_input1, dics, batch)) )
}, },
outputs=["out_data"]) outputs=["out_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
max_shape = list(self.input_shape) max_shape = list(self.input_shape)
min_shape = list(self.input_shape) min_shape = list(self.input_shape)
...@@ -112,19 +113,23 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -112,19 +113,23 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_stack.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertStackTest(TrtLayerAutoScanTest): class TrtConvertStackTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -31,14 +30,13 @@ class TrtConvertStackTest(TrtLayerAutoScanTest): ...@@ -31,14 +30,13 @@ class TrtConvertStackTest(TrtLayerAutoScanTest):
attrs = [ attrs = [
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
] ]
#The input dimension should be less than the set axis. # The input dimension should be less than the set axis.
if len(inputs['stack_input1'].shape) < attrs[0]['axis']: if len(inputs['stack_input1'].shape) < attrs[0]['axis']:
return False return False
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
if self.dims == 4: if self.dims == 4:
return np.random.random([batch, 3, 24, 24]).astype(np.float32) return np.random.random([batch, 3, 24, 24]).astype(np.float32)
...@@ -74,103 +72,107 @@ class TrtConvertStackTest(TrtLayerAutoScanTest): ...@@ -74,103 +72,107 @@ class TrtConvertStackTest(TrtLayerAutoScanTest):
for axis in [-2, -1, 0, 1, 2, 3]: for axis in [-2, -1, 0, 1, 2, 3]:
self.dims = dims self.dims = dims
dics = [{"axis": axis}, {}] dics = [{"axis": axis}, {}]
ops_config = [{ ops_config = [
"op_type": "stack", {
"op_inputs": { "op_type": "stack",
"X": "op_inputs": {
["stack_input1", "stack_input2", "stack_input3"] "X": [
}, "stack_input1",
"op_outputs": { "stack_input2",
"Y": ["stack_output"] "stack_input3",
}, ]
"op_attrs": dics[0] },
}] "op_outputs": {"Y": ["stack_output"]},
"op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"stack_input1": "stack_input1": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics, batch)
data_gen=partial(generate_input1, dics, batch)), ),
"stack_input2": "stack_input2": TensorConfig(
TensorConfig( data_gen=partial(generate_input2, dics, batch)
data_gen=partial(generate_input2, dics, batch)), ),
"stack_input3": "stack_input3": TensorConfig(
TensorConfig( data_gen=partial(generate_input3, dics, batch)
data_gen=partial(generate_input3, dics, batch)) ),
}, },
outputs=["stack_output"]) outputs=["stack_output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"stack_input1": [1, 3, 24, 24], "stack_input1": [1, 3, 24, 24],
"stack_input2": [1, 3, 24, 24], "stack_input2": [1, 3, 24, 24],
"stack_input3": [1, 3, 24, 24] "stack_input3": [1, 3, 24, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"stack_input1": [4, 3, 48, 48], "stack_input1": [4, 3, 48, 48],
"stack_input2": [4, 3, 48, 48], "stack_input2": [4, 3, 48, 48],
"stack_input3": [4, 3, 48, 48] "stack_input3": [4, 3, 48, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"stack_input1": [1, 3, 24, 24], "stack_input1": [1, 3, 24, 24],
"stack_input2": [1, 3, 24, 24], "stack_input2": [1, 3, 24, 24],
"stack_input3": [1, 3, 24, 24] "stack_input3": [1, 3, 24, 24],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"stack_input1": [1, 3, 24], "stack_input1": [1, 3, 24],
"stack_input2": [1, 3, 24], "stack_input2": [1, 3, 24],
"stack_input3": [1, 3, 24] "stack_input3": [1, 3, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"stack_input1": [4, 3, 48], "stack_input1": [4, 3, 48],
"stack_input2": [4, 3, 48], "stack_input2": [4, 3, 48],
"stack_input3": [4, 3, 48] "stack_input3": [4, 3, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"stack_input1": [1, 3, 24], "stack_input1": [1, 3, 24],
"stack_input2": [1, 3, 24], "stack_input2": [1, 3, 24],
"stack_input3": [1, 3, 24] "stack_input3": [1, 3, 24],
} }
elif self.dims == 2: elif self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"stack_input1": [1, 24], "stack_input1": [1, 24],
"stack_input2": [1, 24], "stack_input2": [1, 24],
"stack_input3": [1, 24] "stack_input3": [1, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"stack_input1": [4, 48], "stack_input1": [4, 48],
"stack_input2": [4, 48], "stack_input2": [4, 48],
"stack_input3": [4, 48] "stack_input3": [4, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"stack_input1": [1, 24], "stack_input1": [1, 24],
"stack_input2": [1, 24], "stack_input2": [1, 24],
"stack_input3": [1, 24] "stack_input3": [1, 24],
} }
elif self.dims == 1: elif self.dims == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"stack_input1": [24], "stack_input1": [24],
"stack_input2": [24], "stack_input2": [24],
"stack_input3": [24] "stack_input3": [24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"stack_input1": [48], "stack_input1": [48],
"stack_input2": [48], "stack_input2": [48],
"stack_input3": [48] "stack_input3": [48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"stack_input1": [24], "stack_input1": [24],
"stack_input2": [24], "stack_input2": [24],
"stack_input3": [24] "stack_input3": [24],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -191,19 +193,23 @@ class TrtConvertStackTest(TrtLayerAutoScanTest): ...@@ -191,19 +193,23 @@ class TrtConvertStackTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_sum.py
浏览文件 @ 7a0b8625
...@@ -22,12 +22,10 @@ import unittest ...@@ -22,12 +22,10 @@ import unittest
class TrtConvertSumTest(TrtLayerAutoScanTest): class TrtConvertSumTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch): def generate_input1(batch):
if self.dims == 4: if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32) return np.ones([batch, 3, 24, 24]).astype(np.float32)
...@@ -61,99 +59,101 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -61,99 +59,101 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
self.dims = dims self.dims = dims
ops_config = [{ ops_config = [
"op_type": "sum", {
"op_inputs": { "op_type": "sum",
"X": ["input1", "input2", "input3"] "op_inputs": {"X": ["input1", "input2", "input3"]},
}, "op_outputs": {"Out": ["output"]},
"op_outputs": { "op_attrs": {},
"Out": ["output"] }
}, ]
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1": "input1": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, batch)), data_gen=partial(generate_input1, batch)
"input2": ),
TensorConfig(data_gen=partial(generate_input2, batch)), "input2": TensorConfig(
"input3": data_gen=partial(generate_input2, batch)
TensorConfig(data_gen=partial(generate_input3, batch)) ),
"input3": TensorConfig(
data_gen=partial(generate_input3, batch)
),
}, },
outputs=["output"]) outputs=["output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1": [1, 3, 24, 24], "input1": [1, 3, 24, 24],
"input2": [1, 3, 24, 24], "input2": [1, 3, 24, 24],
"input3": [1, 3, 24, 24] "input3": [1, 3, 24, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1": [4, 3, 48, 48], "input1": [4, 3, 48, 48],
"input2": [4, 3, 48, 48], "input2": [4, 3, 48, 48],
"input3": [4, 3, 48, 48] "input3": [4, 3, 48, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1": [1, 3, 24, 24], "input1": [1, 3, 24, 24],
"input2": [1, 3, 24, 24], "input2": [1, 3, 24, 24],
"input3": [1, 3, 24, 24] "input3": [1, 3, 24, 24],
} }
elif self.dims == 3: elif self.dims == 3:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1": [1, 3, 24], "input1": [1, 3, 24],
"input2": [1, 3, 24], "input2": [1, 3, 24],
"input3": [1, 3, 24] "input3": [1, 3, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1": [4, 3, 48], "input1": [4, 3, 48],
"input2": [4, 3, 48], "input2": [4, 3, 48],
"input3": [4, 3, 48] "input3": [4, 3, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1": [1, 3, 24], "input1": [1, 3, 24],
"input2": [1, 3, 24], "input2": [1, 3, 24],
"input3": [1, 3, 24] "input3": [1, 3, 24],
} }
elif self.dims == 2: elif self.dims == 2:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1": [1, 24], "input1": [1, 24],
"input2": [1, 24], "input2": [1, 24],
"input3": [1, 24] "input3": [1, 24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1": [4, 48], "input1": [4, 48],
"input2": [4, 48], "input2": [4, 48],
"input3": [4, 48] "input3": [4, 48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1": [1, 24], "input1": [1, 24],
"input2": [1, 24], "input2": [1, 24],
"input3": [1, 24] "input3": [1, 24],
} }
elif self.dims == 1: elif self.dims == 1:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input1": [24], "input1": [24],
"input2": [24], "input2": [24],
"input3": [24] "input3": [24],
} }
self.dynamic_shape.max_input_shape = { self.dynamic_shape.max_input_shape = {
"input1": [48], "input1": [48],
"input2": [48], "input2": [48],
"input3": [48] "input3": [48],
} }
self.dynamic_shape.opt_input_shape = { self.dynamic_shape.opt_input_shape = {
"input1": [24], "input1": [24],
"input2": [24], "input2": [24],
"input3": [24] "input3": [24],
} }
def clear_dynamic_shape(): def clear_dynamic_shape():
...@@ -162,7 +162,7 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -162,7 +162,7 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
self.dynamic_shape.opt_input_shape = {} self.dynamic_shape.opt_input_shape = {}
def generate_trt_nodes_num(dynamic_shape): def generate_trt_nodes_num(dynamic_shape):
if (self.dims == 1 and not dynamic_shape): if self.dims == 1 and not dynamic_shape:
return 0, 5 return 0, 5
return 1, 4 return 1, 4
...@@ -170,17 +170,19 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -170,17 +170,19 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
...@@ -188,12 +190,10 @@ class TrtConvertSumTest(TrtLayerAutoScanTest): ...@@ -188,12 +190,10 @@ class TrtConvertSumTest(TrtLayerAutoScanTest):
# special case when sum having olny one input # special case when sum having olny one input
class TrtConvertSumTest1(TrtLayerAutoScanTest): class TrtConvertSumTest1(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(batch): def generate_input1(batch):
if self.dims == 4: if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32) return np.ones([batch, 3, 24, 24]).astype(np.float32)
...@@ -207,31 +207,31 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest): ...@@ -207,31 +207,31 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
self.dims = dims self.dims = dims
ops_config = [{ ops_config = [
"op_type": "sum", {
"op_inputs": { "op_type": "sum",
"X": ["input1"] "op_inputs": {"X": ["input1"]},
}, "op_outputs": {"Out": ["output"]},
"op_outputs": { "op_attrs": {},
"Out": ["output"] }
}, ]
"op_attrs": {}
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input1": "input1": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, batch)), data_gen=partial(generate_input1, batch)
),
}, },
outputs=["output"]) outputs=["output"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(): def generate_dynamic_shape():
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = {"input1": [1, 3, 24, 24]} self.dynamic_shape.min_input_shape = {"input1": [1, 3, 24, 24]}
...@@ -268,7 +268,7 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest): ...@@ -268,7 +268,7 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest):
self.dynamic_shape.opt_input_shape = {} self.dynamic_shape.opt_input_shape = {}
def generate_trt_nodes_num(dynamic_shape): def generate_trt_nodes_num(dynamic_shape):
if (self.dims == 1 and not dynamic_shape): if self.dims == 1 and not dynamic_shape:
return 0, 3 return 0, 3
return 1, 2 return 1, 2
...@@ -276,17 +276,19 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest): ...@@ -276,17 +276,19 @@ class TrtConvertSumTest1(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
False), 1e-5 False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape() generate_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-5 yield self.create_inference_config(), generate_trt_nodes_num(True), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_tile.py
浏览文件 @ 7a0b8625
...@@ -26,7 +26,6 @@ import hypothesis.strategies as st ...@@ -26,7 +26,6 @@ import hypothesis.strategies as st
class TrtConvertTileTest(TrtLayerAutoScanTest): class TrtConvertTileTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
attrs = [ attrs = [
...@@ -39,38 +38,37 @@ class TrtConvertTileTest(TrtLayerAutoScanTest): ...@@ -39,38 +38,37 @@ class TrtConvertTileTest(TrtLayerAutoScanTest):
return True return True
def sample_program_configs(self, *args, **kwargs): def sample_program_configs(self, *args, **kwargs):
def generate_input1(attrs: List[Dict[str, Any]]): def generate_input1(attrs: List[Dict[str, Any]]):
return np.ones([1, 2, 3, 4]).astype(np.float32) return np.ones([1, 2, 3, 4]).astype(np.float32)
dics = [{"repeat_times": kwargs['repeat_times']}] dics = [{"repeat_times": kwargs['repeat_times']}]
ops_config = [{ ops_config = [
"op_type": "tile", {
"op_inputs": { "op_type": "tile",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {"Out": ["tile_output_data"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["tile_output_data"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1, dics)) data_gen=partial(generate_input1, dics)
)
}, },
outputs=["tile_output_data"]) outputs=["tile_output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]} self.dynamic_shape.min_input_shape = {"input_data": [1, 3, 32, 32]}
self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]} self.dynamic_shape.max_input_shape = {"input_data": [4, 3, 64, 64]}
...@@ -99,19 +97,23 @@ class TrtConvertTileTest(TrtLayerAutoScanTest): ...@@ -99,19 +97,23 @@ class TrtConvertTileTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-4 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-4 attrs, True
), 1e-3
@given(repeat_times=st.sampled_from([[100], [1, 2], [0, 3], [1, 2, 100]])) @given(repeat_times=st.sampled_from([[100], [1, 2], [0, 3], [1, 2, 100]]))
def test(self, *args, **kwargs): def test(self, *args, **kwargs):
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_top_k.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertActivationTest(TrtLayerAutoScanTest): class TrtConvertActivationTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
...@@ -44,34 +43,37 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -44,34 +43,37 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
for k in [1, 3]: for k in [1, 3]:
self.dims = dims self.dims = dims
dics = [{"k": k}] dics = [{"k": k}]
ops_config = [{ ops_config = [
"op_type": "top_k", {
"op_inputs": { "op_type": "top_k",
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {
"op_outputs": { "Out": ["output_data"],
"Out": ["output_data"], "Indices": ["indices_data"],
"Indices": ["indices_data"] },
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1, dims, batch, dics
)
)
}, },
outputs=["output_data", "indices_data"]) outputs=["output_data", "indices_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -114,19 +116,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -114,19 +116,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
## for dynamic_shape ## for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_top_k_v2.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertActivationTest(TrtLayerAutoScanTest): class TrtConvertActivationTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
attrs = [ attrs = [
...@@ -53,40 +52,48 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -53,40 +52,48 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
for sort in [True, False]: for sort in [True, False]:
self.dims = dims self.dims = dims
self.sort = sort self.sort = sort
dics = [{ dics = [
"k": k, {
"axis": axis, "k": k,
"largest": largest, "axis": axis,
"sorted": sort "largest": largest,
}] "sorted": sort,
ops_config = [{ }
"op_type": "top_k_v2", ]
"op_inputs": { ops_config = [
"X": ["input_data"] {
}, "op_type": "top_k_v2",
"op_outputs": { "op_inputs": {"X": ["input_data"]},
"Out": ["output_data"], "op_outputs": {
"Indices": ["indices_data"] "Out": ["output_data"],
}, "Indices": ["indices_data"],
"op_attrs": dics[0] },
}] "op_attrs": dics[0],
}
]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1,
dims,
batch,
dics,
)
)
}, },
outputs=["output_data", "indices_data"]) outputs=["output_data", "indices_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -131,19 +138,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -131,19 +138,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_transpose.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ import unittest ...@@ -22,7 +22,6 @@ import unittest
class TrtConvertTransposeTest(TrtLayerAutoScanTest): class TrtConvertTransposeTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
inputs = program_config.inputs inputs = program_config.inputs
weights = program_config.weights weights = program_config.weights
...@@ -32,14 +31,13 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest): ...@@ -32,14 +31,13 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest):
program_config.ops[i].attrs for i in range(len(program_config.ops)) program_config.ops[i].attrs for i in range(len(program_config.ops))
] ]
#The shape of input and axis should be equal. # The shape of input and axis should be equal.
if len(inputs['transpose_input'].shape) != len(attrs[0]['axis']): if len(inputs['transpose_input'].shape) != len(attrs[0]['axis']):
return False return False
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
if self.dims == 4: if self.dims == 4:
return np.ones([batch, 3, 24, 24]).astype(np.float32) return np.ones([batch, 3, 24, 24]).astype(np.float32)
...@@ -50,37 +48,43 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest): ...@@ -50,37 +48,43 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest):
for dims in [2, 3, 4]: for dims in [2, 3, 4]:
for batch in [1, 2, 4]: for batch in [1, 2, 4]:
for axis in [[0, 1, 3, 2], [0, 3, 2, 1], [3, 2, 0, 1], for axis in [
[0, 1, 2, 3], [0, 1, 2], [2, 0, 1], [1, 0], [0, [0, 1, 3, 2],
1]]: [0, 3, 2, 1],
[3, 2, 0, 1],
[0, 1, 2, 3],
[0, 1, 2],
[2, 0, 1],
[1, 0],
[0, 1],
]:
self.dims = dims self.dims = dims
dics = [{"axis": axis}, {}] dics = [{"axis": axis}, {}]
ops_config = [{ ops_config = [
"op_type": "transpose", {
"op_inputs": { "op_type": "transpose",
"X": ["transpose_input"] "op_inputs": {"X": ["transpose_input"]},
}, "op_outputs": {"Out": ["transpose_out"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["transpose_out"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"transpose_input": "transpose_input": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics, batch)
data_gen=partial(generate_input1, dics, batch)) )
}, },
outputs=["transpose_out"]) outputs=["transpose_out"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 4: if self.dims == 4:
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
...@@ -134,19 +138,23 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest): ...@@ -134,19 +138,23 @@ class TrtConvertTransposeTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_unary.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertActivationTest(TrtLayerAutoScanTest): class TrtConvertActivationTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
...@@ -42,40 +41,54 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -42,40 +41,54 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
for dims in [1, 2, 3, 4]: for dims in [1, 2, 3, 4]:
for batch in [1, 4]: for batch in [1, 4]:
for op_type in [ for op_type in [
"exp", "log", "sqrt", "abs", "sin", "cos", "tan", "exp",
"sinh", "cosh", "asin", "acos", "atan", "asinh", "log",
"atanh", "ceil", "floor" "sqrt",
"abs",
"sin",
"cos",
"tan",
"sinh",
"cosh",
"asin",
"acos",
"atan",
"asinh",
"atanh",
"ceil",
"floor",
]: ]:
self.dims = dims self.dims = dims
dics = [{}] dics = [{}]
ops_config = [{ ops_config = [
"op_type": op_type, {
"op_inputs": { "op_type": op_type,
"X": ["input_data"] "op_inputs": {"X": ["input_data"]},
}, "op_outputs": {"Out": ["output_data"]},
"op_outputs": { "op_attrs": dics[0],
"Out": ["output_data"] }
}, ]
"op_attrs": dics[0]
}]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial( data_gen=partial(
generate_input1, dims, batch, dics)) generate_input1, dims, batch, dics
)
)
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
if self.dims == 1: if self.dims == 1:
self.dynamic_shape.min_input_shape = {"input_data": [1]} self.dynamic_shape.min_input_shape = {"input_data": [1]}
...@@ -118,19 +131,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest): ...@@ -118,19 +131,23 @@ class TrtConvertActivationTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_unfold.py
浏览文件 @ 7a0b8625
...@@ -22,46 +22,46 @@ import unittest ...@@ -22,46 +22,46 @@ import unittest
class TrtConvertUnfold(TrtLayerAutoScanTest): class TrtConvertUnfold(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
def sample_program_configs(self): def sample_program_configs(self):
def generate_input1(): def generate_input1():
return np.random.random([1, 3, 24, 24]).astype(np.float32) return np.random.random([1, 3, 24, 24]).astype(np.float32)
ops_config = [{ ops_config = [
"op_type": "unfold", {
"op_inputs": { "op_type": "unfold",
"X": ["input_data"], "op_inputs": {
}, "X": ["input_data"],
"op_outputs": { },
"Y": ["output_data"] "op_outputs": {"Y": ["output_data"]},
}, "op_attrs": {
"op_attrs": { "dilations": [1, 1],
"dilations": [1, 1], "kernel_sizes": [4, 4],
"kernel_sizes": [4, 4], "paddings": [0, 0, 0, 0],
"paddings": [0, 0, 0, 0], "strides": [1, 1],
"strides": [1, 1], },
} }
}] ]
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
for i in range(10): for i in range(10):
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"input_data": "input_data": TensorConfig(
TensorConfig(data_gen=partial(generate_input1)), data_gen=partial(generate_input1)
),
}, },
outputs=["output_data"]) outputs=["output_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
self.dynamic_shape.min_input_shape = { self.dynamic_shape.min_input_shape = {
"input_data": [1, 3, 4, 4], "input_data": [1, 3, 4, 4],
...@@ -87,14 +87,14 @@ class TrtConvertUnfold(TrtLayerAutoScanTest): ...@@ -87,14 +87,14 @@ class TrtConvertUnfold(TrtLayerAutoScanTest):
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (0, 3), 1e-5 yield self.create_inference_config(), (0, 3), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), (1, 2), 1e-5 yield self.create_inference_config(), (1, 2), 1e-3
def test(self): def test(self):
self.run_test() self.run_test()
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_convert_unsqueeze2.py
浏览文件 @ 7a0b8625
...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set ...@@ -22,7 +22,6 @@ from typing import Optional, List, Callable, Dict, Any, Set
class TrtConvertSplitTest(TrtLayerAutoScanTest): class TrtConvertSplitTest(TrtLayerAutoScanTest):
def is_program_valid(self, program_config: ProgramConfig) -> bool: def is_program_valid(self, program_config: ProgramConfig) -> bool:
return True return True
...@@ -34,17 +33,17 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -34,17 +33,17 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
self.dims = dims self.dims = dims
self.axes = axes self.axes = axes
dics = [{"axes": axes}] dics = [{"axes": axes}]
ops_config = [{ ops_config = [
"op_type": "unsqueeze2", {
"op_inputs": { "op_type": "unsqueeze2",
"X": ["in_data"] "op_inputs": {"X": ["in_data"]},
}, "op_outputs": {
"op_outputs": { "Out": ["out_data"],
"Out": ["out_data"], "XShape": ["XShape_data"],
"XShape": ["XShape_data"] },
}, "op_attrs": dics[0],
"op_attrs": dics[0] }
}] ]
# generate input data # generate input data
self.input_shape = [1] * dims self.input_shape = [1] * dims
...@@ -54,24 +53,26 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -54,24 +53,26 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
def generate_input1(attrs: List[Dict[str, Any]], batch): def generate_input1(attrs: List[Dict[str, Any]], batch):
self.input_shape[0] = batch self.input_shape[0] = batch
return np.random.random(self.input_shape).astype( return np.random.random(self.input_shape).astype(
np.float32) np.float32
)
ops = self.generate_op_config(ops_config) ops = self.generate_op_config(ops_config)
program_config = ProgramConfig( program_config = ProgramConfig(
ops=ops, ops=ops,
weights={}, weights={},
inputs={ inputs={
"in_data": "in_data": TensorConfig(
TensorConfig( data_gen=partial(generate_input1, dics, batch)
data_gen=partial(generate_input1, dics, batch)) )
}, },
outputs=["out_data"]) outputs=["out_data"],
)
yield program_config yield program_config
def sample_predictor_configs( def sample_predictor_configs(
self, program_config) -> (paddle_infer.Config, List[int], float): self, program_config
) -> (paddle_infer.Config, List[int], float):
def generate_dynamic_shape(attrs): def generate_dynamic_shape(attrs):
max_shape = list(self.input_shape) max_shape = list(self.input_shape)
min_shape = list(self.input_shape) min_shape = list(self.input_shape)
...@@ -98,19 +99,23 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest): ...@@ -98,19 +99,23 @@ class TrtConvertSplitTest(TrtLayerAutoScanTest):
clear_dynamic_shape() clear_dynamic_shape()
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, False), 1e-5 attrs, False
), 1e-3
# for dynamic_shape # for dynamic_shape
generate_dynamic_shape(attrs) generate_dynamic_shape(attrs)
self.trt_param.precision = paddle_infer.PrecisionType.Float32 self.trt_param.precision = paddle_infer.PrecisionType.Float32
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-5
self.trt_param.precision = paddle_infer.PrecisionType.Half self.trt_param.precision = paddle_infer.PrecisionType.Half
yield self.create_inference_config(), generate_trt_nodes_num( yield self.create_inference_config(), generate_trt_nodes_num(
attrs, True), 1e-5 attrs, True
), 1e-3
def add_skip_trt_case(self): def add_skip_trt_case(self):
pass pass
......
python/paddle/fluid/tests/unittests/ir/inference/test_trt_squeeze2_matmul_fuse_pass.py
浏览文件 @ 7a0b8625
...@@ -47,7 +47,8 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -47,7 +47,8 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
min_subgraph_size=0, min_subgraph_size=0,
precision_mode=paddle_infer.PrecisionType.Float32, precision_mode=paddle_infer.PrecisionType.Float32,
use_static=False, use_static=False,
use_calib_mode=False) use_calib_mode=False,
)
yield config, ['mul', 'elementwise_add'], (1e-4, 1e-1) yield config, ['mul', 'elementwise_add'], (1e-4, 1e-1)
def add_ignore_pass_case(self): def add_ignore_pass_case(self):
...@@ -70,9 +71,10 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -70,9 +71,10 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
def sample_program_config(self, draw): def sample_program_config(self, draw):
# 1. Generate shape of input:X of squeeze2 # 1. Generate shape of input:X of squeeze2
x_shape = draw( x_shape = draw(
st.lists(st.integers(min_value=1, max_value=8), st.lists(
min_size=2, st.integers(min_value=1, max_value=8), min_size=2, max_size=2
max_size=2)) )
)
# axes of squeeze2 == [2, 3] # axes of squeeze2 == [2, 3]
x_shape += [1, 1] x_shape += [1, 1]
axes = [2, 3] axes = [2, 3]
...@@ -84,9 +86,10 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -84,9 +86,10 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
# 3. Generate legal shape of input:Y of matmul # 3. Generate legal shape of input:Y of matmul
y_shape = draw( y_shape = draw(
st.lists(st.integers(min_value=1, max_value=8), st.lists(
min_size=2, st.integers(min_value=1, max_value=8), min_size=2, max_size=2
max_size=2)) )
)
y_shape[0] = x_shape[1] y_shape[0] = x_shape[1]
# 4. Generate legal attr:axis of elementwise_add # 4. Generate legal attr:axis of elementwise_add
...@@ -108,17 +111,11 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -108,17 +111,11 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
"X": ["squeeze2_x"], "X": ["squeeze2_x"],
}, },
axes=axes, axes=axes,
outputs={ outputs={"Out": ["squeeze2_out"], "XShape": ["xshape"]},
"Out": ["squeeze2_out"],
"XShape": ["xshape"]
},
) )
matmul_op = OpConfig( matmul_op = OpConfig(
"matmul", "matmul",
inputs={ inputs={"X": ["squeeze2_out"], "Y": ["matmul_y"]},
"X": ["squeeze2_out"],
"Y": ["matmul_y"]
},
outputs={"Out": ["matmul_out"]}, outputs={"Out": ["matmul_out"]},
alpha=alpha, alpha=alpha,
transpose_X=transpose_X, transpose_X=transpose_X,
...@@ -133,10 +130,7 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -133,10 +130,7 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
add_op = OpConfig( add_op = OpConfig(
"elementwise_add", "elementwise_add",
inputs={ inputs={"X": ["matmul_out"], "Y": ["bias"]},
"X": ["matmul_out"],
"Y": ["bias"]
},
outputs={"Out": ["add_out"]}, outputs={"Out": ["add_out"]},
axis=axis, axis=axis,
) )
...@@ -157,9 +151,11 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest): ...@@ -157,9 +151,11 @@ class TestSqueeze2MatmulFusePass(PassAutoScanTest):
return program_config return program_config
def test(self): def test(self):
self.run_and_statis(quant=False, self.run_and_statis(
max_examples=50, quant=False,
passes=["trt_squeeze2_matmul_fuse_pass"]) max_examples=25,
passes=["trt_squeeze2_matmul_fuse_pass"],
)
if __name__ == "__main__": if __name__ == "__main__":
......
python/paddle/fluid/tests/unittests/ir/test_fuse_resnet_unit.py
浏览文件 @ 7a0b8625
...@@ -24,13 +24,15 @@ paddle.enable_static() ...@@ -24,13 +24,15 @@ paddle.enable_static()
np.random.seed(0) np.random.seed(0)
@unittest.skipIf(not paddle.is_compiled_with_cuda() @unittest.skipIf(
or paddle.get_cudnn_version() < 8000 not paddle.is_compiled_with_cuda()
or paddle.device.cuda.get_device_capability()[0] < 7, or paddle.get_cudnn_version() < 8000
"only support with cuda and cudnn version is at least 8.0 " or paddle.device.cuda.get_device_capability()[0] < 7
"and device's compute capability is at least 7.0") or paddle.device.cuda.get_device_capability()[0] >= 9,
"only support with cuda and cudnn version is at least 8.0 "
"and device's compute capability is at least 7.0 and less than 9.0",
)
class TestFuseResNetUnit(unittest.TestCase): class TestFuseResNetUnit(unittest.TestCase):
def test_fuse_resenet_unit(self): def test_fuse_resenet_unit(self):
place = paddle.CUDAPlace(0) place = paddle.CUDAPlace(0)
program = paddle.static.Program() program = paddle.static.Program()
...@@ -38,14 +40,12 @@ class TestFuseResNetUnit(unittest.TestCase): ...@@ -38,14 +40,12 @@ class TestFuseResNetUnit(unittest.TestCase):
with paddle.static.amp.fp16_guard(): with paddle.static.amp.fp16_guard():
with paddle.static.program_guard(program, startup_program): with paddle.static.program_guard(program, startup_program):
x = paddle.static.data("x", [1, 64, 64, 8]) x = paddle.static.data("x", [1, 64, 64, 8])
conv2d = paddle.nn.Conv2D(8, conv2d = paddle.nn.Conv2D(
32, 8, 32, 1, bias_attr=False, data_format='NHWC'
1, )
bias_attr=False, batch_norm = paddle.nn.BatchNorm(
data_format='NHWC') 32, act='relu', data_layout='NHWC'
batch_norm = paddle.nn.BatchNorm(32, )
act='relu',
data_layout='NHWC')
out = batch_norm(conv2d(x)) out = batch_norm(conv2d(x))
graph = core.Graph(program.desc) graph = core.Graph(program.desc)
core.get_pass("fuse_resnet_unit").apply(graph) core.get_pass("fuse_resnet_unit").apply(graph)
...@@ -54,15 +54,15 @@ class TestFuseResNetUnit(unittest.TestCase): ...@@ -54,15 +54,15 @@ class TestFuseResNetUnit(unittest.TestCase):
after_params = paddle.static.amp.cast_model_to_fp16(after_program) after_params = paddle.static.amp.cast_model_to_fp16(after_program)
exe = paddle.static.Executor(place) exe = paddle.static.Executor(place)
exe.run(startup_program) exe.run(startup_program)
paddle.static.amp.cast_parameters_to_fp16(place,
program,
to_fp16_var_names=params)
paddle.static.amp.cast_parameters_to_fp16( paddle.static.amp.cast_parameters_to_fp16(
place, after_program, to_fp16_var_names=after_params) place, program, to_fp16_var_names=params
)
paddle.static.amp.cast_parameters_to_fp16(
place, after_program, to_fp16_var_names=after_params
)
feed = {"x": np.random.randn(1, 64, 64, 8).astype("float16")} feed = {"x": np.random.randn(1, 64, 64, 8).astype("float16")}
before_out = exe.run(program, feed=feed, fetch_list=[out.name]) before_out = exe.run(program, feed=feed, fetch_list=[out.name])
after_out = exe.run(after_program, feed=feed, fetch_list=[out.name]) after_out = exe.run(after_program, feed=feed, fetch_list=[out.name])
np.testing.assert_allclose(before_out[0], np.testing.assert_allclose(
after_out[0], before_out[0], after_out[0], rtol=1e-05, atol=0.005
rtol=1e-05, )
atol=0.005)
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或