diff --git a/backends/arm/test/ops/test_abs.py b/backends/arm/test/ops/test_abs.py index f351253b1b2..4ebcf7393c1 100644 --- a/backends/arm/test/ops/test_abs.py +++ b/backends/arm/test/ops/test_abs.py @@ -15,6 +15,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.abs.default" @@ -66,3 +67,25 @@ def test_abs_u85_INT(test_data: torch.Tensor): Abs(), test_data(), aten_op, exir_op, run_on_fvp=True ) pipeline.run() + + +@common.parametrize("test_data", Abs.test_parameters) +@common.SkipIfNoModelConverter +def test_abs_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Abs(), test_data(), aten_op, exir_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", Abs.test_parameters) +@common.SkipIfNoModelConverter +def test_abs_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Abs(), + test_data(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_acosh.py b/backends/arm/test/ops/test_acosh.py index bebf839c340..25ba2b1a83b 100644 --- a/backends/arm/test/ops/test_acosh.py +++ b/backends/arm/test/ops/test_acosh.py @@ -14,6 +14,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = Tuple[torch.Tensor] # Input x @@ -112,3 +113,27 @@ def test_acosh_u85_INT_xfail(test_data: Tuple): run_on_fvp=False, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_acosh_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Acosh(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_acosh_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Acosh(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_adaptive_avg_pool2d.py b/backends/arm/test/ops/test_adaptive_avg_pool2d.py index 2a0562155b7..4411ce7f746 100644 --- a/backends/arm/test/ops/test_adaptive_avg_pool2d.py +++ b/backends/arm/test/ops/test_adaptive_avg_pool2d.py @@ -14,6 +14,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) exir_op = "executorch_exir_dialects_edge__ops_aten_avg_pool2d_default" @@ -161,3 +162,31 @@ def test_adaptive_avg_pool2d_u85_INT(test_module): exir_ops=exir_op, ) pipeline.run() + + +@common.parametrize("test_module", test_modules) +@common.SkipIfNoModelConverter +def test_adaptive_avg_pool2d_vgf_FP(test_module): + model, input_tensor = test_module() + pipeline = VgfPipeline[input_t]( + model, + input_tensor, + [], + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_module", test_modules) +@common.SkipIfNoModelConverter +def test_adaptive_avg_pool2d_vgf_INT(test_module): + model, input_tensor = test_module() + pipeline = VgfPipeline[input_t]( + model, + input_tensor, + [], + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_addmm.py b/backends/arm/test/ops/test_addmm.py index c92ba190439..cfe324ab0af 100644 --- a/backends/arm/test/ops/test_addmm.py +++ b/backends/arm/test/ops/test_addmm.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.addmm.default" @@ -155,3 +156,29 @@ def test_addmm_u85_INT(test_data: Tuple): exir_ops=exir_op, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_addmm_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Addmm(), + (*test_data,), + aten_op=aten_op, + exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_addmm_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Addmm(), + (*test_data,), + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_alias_copy.py b/backends/arm/test/ops/test_alias_copy.py index 401f9df0dac..cf8caca02c4 100644 --- a/backends/arm/test/ops/test_alias_copy.py +++ b/backends/arm/test/ops/test_alias_copy.py @@ -12,6 +12,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] @@ -83,3 +84,29 @@ def test_alias_u85_INT(test_data: input_t1): AliasCopy.aten_op, AliasCopy.exir_op, ).run() + + +@common.parametrize("test_data", AliasCopy.test_data) +@common.SkipIfNoModelConverter +def test_alias_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AliasCopy(), + test_data(), + AliasCopy.aten_op, + AliasCopy.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AliasCopy.test_data) +@common.SkipIfNoModelConverter +def test_alias_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AliasCopy(), + test_data(), + AliasCopy.aten_op, + AliasCopy.exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_amax.py b/backends/arm/test/ops/test_amax.py index e8ed3007b80..3600c34c94c 100644 --- a/backends/arm/test/ops/test_amax.py +++ b/backends/arm/test/ops/test_amax.py @@ -14,6 +14,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) @@ -138,3 +139,57 @@ def test_max_dim_tosa_FP_not_delegated(): data, dim = Max.test_data["rank_4_dim_3"]() pipeline = OpNotSupportedPipeline[Max.input_t](MaxWithIndex(dim), data, {}) pipeline.run() + + +@common.parametrize("test_data", Amax.test_data) +@common.SkipIfNoModelConverter +def test_amax_vgf_FP(test_data: Amax.input_t): + data, dim, keep_dims = test_data() + module = Amax(dim, keep_dims) + pipeline = VgfPipeline[Amax.input_t]( + module, + data, + Amax.aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Amax.test_data) +@common.SkipIfNoModelConverter +def test_amax_vgf_INT(test_data: Amax.input_t): + data, dim, keep_dims = test_data() + module = Amax(dim, keep_dims) + pipeline = VgfPipeline[Amax.input_t]( + module, + data, + Amax.aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", Max.test_data) +@common.SkipIfNoModelConverter +def test_max_dim_vgf_FP_to_amax(test_data: Max.input_t): + data, dim = test_data() + pipeline = VgfPipeline[Max.input_t]( + Max(dim), + data, + "torch.ops.aten.max", + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Max.test_data) +@common.SkipIfNoModelConverter +def test_max_dim_vgf_INT_to_amax(test_data: Max.input_t): + data, dim = test_data() + pipeline = VgfPipeline[Max.input_t]( + Max(dim), + data, + "torch.ops.aten.amax", + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_amin.py b/backends/arm/test/ops/test_amin.py index b508259093d..3ae94fe3c6e 100644 --- a/backends/arm/test/ops/test_amin.py +++ b/backends/arm/test/ops/test_amin.py @@ -15,6 +15,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) @@ -150,3 +151,52 @@ def test_min_dim_tosa_FP_not_delegated(): data, dim = Min.test_data["rank_4_dim_3"]() pipeline = OpNotSupportedPipeline[Min.input_t](MinWithIndex(dim), data, {}) pipeline.run() + + +@common.parametrize("test_data", Amin.test_data) +@common.SkipIfNoModelConverter +def test_amin_vgf_FP(test_data: Amin.input_t): + data, dim, keep_dims = test_data() + pipeline = VgfPipeline[Amin.input_t]( + Amin(dim, keep_dims), data, Amin.aten_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", Amin.test_data) +@common.SkipIfNoModelConverter +def test_amin_vgf_INT(test_data: Amin.input_t): + data, dim, keep_dims = test_data() + pipeline = VgfPipeline[Amin.input_t]( + Amin(dim, keep_dims), + data, + Amin.aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", Min.test_data) +@common.SkipIfNoModelConverter +def test_min_dim_vgf_FP_to_amin(test_data: Min.input_t): + data, dim = test_data() + pipeline = VgfPipeline[Min.input_t]( + Min(dim), + data, + "torch.ops.aten.min", + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Min.test_data) +@common.SkipIfNoModelConverter +def test_min_dim_vgf_INT_to_amin(test_data: Min.input_t): + data, dim = test_data() + pipeline = VgfPipeline[Min.input_t]( + Min(dim), + data, + "torch.ops.aten.amin", + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_any.py b/backends/arm/test/ops/test_any.py index 5805eb9c671..ae738480048 100644 --- a/backends/arm/test/ops/test_any.py +++ b/backends/arm/test/ops/test_any.py @@ -13,6 +13,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) @@ -184,3 +185,33 @@ def test_any_u85_INT(test_data: input_t1): pipeline.pop_stage("quantize") pipeline.pop_stage("check.quant_nodes") pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_any_vgf_FP(test_data: input_t1): + op, data_fn = test_data() + pipeline = VgfPipeline[input_t1]( + op, + data_fn(), + op.aten_op, + op.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_any_vgf_INT(test_data: input_t1): + op, data_fn = test_data() + pipeline = VgfPipeline[input_t1]( + op, + data_fn(), + op.aten_op, + op.exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() diff --git a/backends/arm/test/ops/test_arange.py b/backends/arm/test/ops/test_arange.py index 4cc6a1a119b..ede00768f52 100644 --- a/backends/arm/test/ops/test_arange.py +++ b/backends/arm/test/ops/test_arange.py @@ -14,6 +14,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = tuple[torch.Tensor] @@ -115,6 +116,36 @@ def test_arange_start_step_u85_INT(test_data: test_data_t): pipeline.run() +@common.parametrize("test_data", ArangeAdd.test_data) +@common.SkipIfNoModelConverter +def test_arange_start_step_vgf_FP(test_data: test_data_t): + input_data, init_data = test_data + module = ArangeAdd(*init_data) + pipeline = VgfPipeline[input_t]( + module, + input_data(), + module.aten_op, + module.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", ArangeAdd.test_data) +@common.SkipIfNoModelConverter +def test_arange_start_step_vgf_INT(test_data: test_data_t): + input_data, init_data = test_data + module = ArangeAdd(*init_data) + pipeline = VgfPipeline[input_t]( + module, + input_data(), + module.aten_op, + module.exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + class LinspaceAdd(torch.nn.Module): aten_op: str = "torch.ops.aten.linspace.default" exir_op: str = "executorch_exir_dialects_edge__ops_aten_arange_default" @@ -134,7 +165,7 @@ def forward(self, x: torch.Tensor) -> torch.Tensor: @common.parametrize("test_data", LinspaceAdd.test_data) -def test_linspace_tosa_FP(test_data): +def test_linspace_tosa_FP(test_data: test_data_t): input_data, init_data = test_data pipeline = TosaPipelineFP[input_t]( LinspaceAdd(*init_data), @@ -154,7 +185,34 @@ def test_linspace_tosa_INT(test_data: test_data_t): LinspaceAdd.aten_op, LinspaceAdd.exir_op, ) - pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +@common.parametrize("test_data", LinspaceAdd.test_data) +@common.SkipIfNoModelConverter +def test_linspace_vgf_FP(test_data: test_data_t): + input_data, init_data = test_data + pipeline = VgfPipeline[input_t]( + LinspaceAdd(*init_data), + input_data(), + LinspaceAdd.aten_op, + LinspaceAdd.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", LinspaceAdd.test_data) +@common.SkipIfNoModelConverter +def test_linspace_vgf_INT(test_data: test_data_t): + input_data, init_data = test_data + pipeline = VgfPipeline[input_t]( + LinspaceAdd(*init_data), + input_data(), + LinspaceAdd.aten_op, + LinspaceAdd.exir_op, + tosa_version="TOSA-1.0+INT", + ) pipeline.run() @@ -179,3 +237,13 @@ def test_arange_u55_INT(): @pytest.mark.skip(reason=skip_str) def test_arange_u85_INT(): pass + + +@pytest.mark.skip(reason=skip_str) +def test_arange_vgf_FP(): + pass + + +@pytest.mark.skip(reason=skip_str) +def test_arange_vgf_INT(): + pass diff --git a/backends/arm/test/ops/test_asin.py b/backends/arm/test/ops/test_asin.py index 81cd9288e32..9c37bddbd92 100644 --- a/backends/arm/test/ops/test_asin.py +++ b/backends/arm/test/ops/test_asin.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = Tuple[torch.Tensor] # Input x @@ -78,3 +79,27 @@ def test_asin_u85_INT(test_data: Tuple): aten_ops=[], ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_asin_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Asin(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_asin_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Asin(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_asinh.py b/backends/arm/test/ops/test_asinh.py index af265276010..305c822601c 100644 --- a/backends/arm/test/ops/test_asinh.py +++ b/backends/arm/test/ops/test_asinh.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = Tuple[torch.Tensor] # Input x @@ -77,3 +78,27 @@ def test_asinh_u85_INT(test_data: Tuple): aten_ops=[], ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_asinh_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Asinh(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_asinh_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t]( + Asinh(), + (test_data(),), + aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_at.py b/backends/arm/test/ops/test_at.py index 966b68cc91c..b8a20760820 100644 --- a/backends/arm/test/ops/test_at.py +++ b/backends/arm/test/ops/test_at.py @@ -10,6 +10,7 @@ from executorch.backends.arm.test.tester.test_pipeline import ( TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op_mm = "torch.ops.aten.matmul.default" @@ -147,3 +148,109 @@ def test_atmatmul_mixed_pattern2_tosa_INT(test_data: input_t1): qtol=1, ) pipeline.run() + + +@common.parametrize("test_data", AtMatMulSingleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_single_input_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulSingleInput(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulDoubleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_double_input_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulDoubleInput(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulMixedPattern1.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_mixed_pattern1_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulMixedPattern1(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulMixedPattern2.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_mixed_pattern2_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulMixedPattern2(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulSingleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_single_input_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulSingleInput(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulDoubleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_double_input_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulDoubleInput(), + test_data(), + aten_op_mm, + exir_op_mm, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulMixedPattern1.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_mixed_pattern1_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulMixedPattern1(), + test_data(), + aten_op_mm, + exir_op_mm, + qtol=1, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", AtMatMulMixedPattern2.test_data_generators) +@common.SkipIfNoModelConverter +def test_atmatmul_mixed_pattern2_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + AtMatMulMixedPattern2(), + test_data(), + aten_op_mm, + exir_op_mm, + qtol=1, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_atan.py b/backends/arm/test/ops/test_atan.py index d20fc4fa370..51114d2800f 100644 --- a/backends/arm/test/ops/test_atan.py +++ b/backends/arm/test/ops/test_atan.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.atan.default" @@ -82,3 +83,29 @@ def test_atan_u85_INT(test_data: Tuple): exir_ops=exir_op, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_atan_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Atan(), + (test_data,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_atan_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Atan(), + (test_data,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_atanh.py b/backends/arm/test/ops/test_atanh.py index 577b1e6134d..12754a34646 100644 --- a/backends/arm/test/ops/test_atanh.py +++ b/backends/arm/test/ops/test_atanh.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.atanh.default" @@ -83,3 +84,29 @@ def test_atanh_u85_INT(test_data: Tuple): exir_ops=exir_op, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_atanh_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Atanh(), + (test_data,), + aten_op=aten_op, + exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_atanh_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Atanh(), + (test_data,), + aten_op=aten_op, + exir_op=exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_avg_pool2d.py b/backends/arm/test/ops/test_avg_pool2d.py index f838a781148..be54c76e68b 100644 --- a/backends/arm/test/ops/test_avg_pool2d.py +++ b/backends/arm/test/ops/test_avg_pool2d.py @@ -20,6 +20,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.avg_pool2d.default" @@ -170,6 +171,34 @@ def test_avg_pool2d_u85_INT(test_module): pipeline.run() +@common.parametrize("test_module", test_modules) +@common.SkipIfNoModelConverter +def test_avg_pool2d_vgf_FP(test_module): + model, input_tensor = test_module() + pipeline = VgfPipeline[input_t]( + model, + input_tensor, + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_module", test_modules) +@common.SkipIfNoModelConverter +def test_avg_pool2d_vgf_INT(test_module): + model, input_tensor = test_module() + pipeline = VgfPipeline[input_t]( + model, + input_tensor, + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + reject_modules = { "kernel_1x1_stride_1_pad_0": lambda: (AvgPool2d(1, 1, 0), torch.rand(2, 5, 5, 5)), "kernel_2x9_stride_1_pad_1": lambda: ( diff --git a/backends/arm/test/ops/test_batch_norm.py b/backends/arm/test/ops/test_batch_norm.py index 63bc4e1b159..a28180b7b57 100644 --- a/backends/arm/test/ops/test_batch_norm.py +++ b/backends/arm/test/ops/test_batch_norm.py @@ -18,6 +18,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] # Input x @@ -99,6 +100,26 @@ def test_native_batch_norm_legit_no_training_tosa_INT_not_delegated(): ).run() +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_training_vgf_FP(test_data: Tuple): + inp, model_params = test_data() + pipeline = VgfPipeline[input_t1]( + BatchNorm2d(*model_params), + (inp,), + aten_op=BatchNorm2d.aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_training_vgf_INT(test_data: Tuple): + # TODO(MLETORCH-100: Quantized stand-alone batch norms) + pass + + # TODO(MLETORCH-100: Quantized stand-alone batch norms) def test_native_batch_norm_legit_no_training_u55_INT_not_delegated(): test_data, model_params = test_data_suite["rand_1_3_254_254"]() @@ -219,6 +240,33 @@ def test_native_batch_norm_legit_no_training_u85_INT_conv(test_data: Tuple): pipeline.run() +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_training_vgf_FP_conv(test_data: Tuple): + test_data, model_params = test_data() + pipeline = VgfPipeline[input_t1]( + BatchNorm2dConv(*model_params), + (test_data,), + aten_op=BatchNorm2dConv.aten_ops, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_training_vgf_INT_conv(test_data: Tuple): + test_data, model_params = test_data() + pipeline = VgfPipeline[input_t1]( + BatchNorm2dConv(*model_params), + (test_data,), + aten_op=BatchNorm2dConv.aten_ops[0], # Bn is removed before check + qtol=1, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + class BatchNorm2dNoStats(torch.nn.Module): """ Decomposes into _native_batch_norm_legit.no_stats @@ -309,3 +357,33 @@ def test_native_batch_norm_legit_no_stats_u85_INT(test_data: Tuple): qtol=1, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_stats_vgf_FP(test_data: Tuple): + test_data, model_params = test_data() + pipeline = VgfPipeline[input_t1]( + BatchNorm2dNoStats(*model_params), + (test_data,), + aten_op=BatchNorm2dNoStats.aten_ops, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@pytest.mark.skip( + reason="MLETORCH-999: Add support for _native_batch_norm_legit.no_stats." +) +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_native_batch_norm_legit_no_stats_vgf_INT(test_data: Tuple): + test_data, model_params = test_data() + pipeline = VgfPipeline[input_t1]( + BatchNorm2dNoStats(*model_params), + (test_data,), + aten_op=BatchNorm2dNoStats.aten_ops, + qtol=1, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_bitwise.py b/backends/arm/test/ops/test_bitwise.py index 4e7dd26f04e..1c0f0e36a6a 100644 --- a/backends/arm/test/ops/test_bitwise.py +++ b/backends/arm/test/ops/test_bitwise.py @@ -13,6 +13,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) @@ -128,7 +129,9 @@ def forward(self, tensor: torch.Tensor, scalar: int): return tensor.bitwise_or(scalar) -# Bitwise AND +######### +## AND ## +######### @common.parametrize("test_data", And().test_data) @@ -259,6 +262,79 @@ def test_bitwise_and_tensor_u85_INT(test_data: input_t2): pipeline.run() +@common.parametrize("test_data", And().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_and_tensor_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + And(), + test_data(), + And().aten_op, + And().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AndScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_and_scalar_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + AndScalar(), + test_data(), + AndScalar().aten_op, + AndScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", And().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_and_tensor_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + And(), + test_data(), + And().aten_op, + And().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +@common.parametrize("test_data", AndScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_and_scalar_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + AndScalar(), + test_data(), + AndScalar().aten_op, + AndScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +######### +## XOR ## +######### + + @common.parametrize("test_data", Xor().test_data) def test_bitwise_xor_tensor_tosa_FP(test_data: input_t2): pipeline = TosaPipelineFP[input_t2]( @@ -387,6 +463,79 @@ def test_bitwise_xor_scalar_u85_INT(test_data: input_t2): pipeline.run() +@common.parametrize("test_data", Xor().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_xor_tensor_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + Xor(), + test_data(), + Xor().aten_op, + Xor().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", XorScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_xor_scalar_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + XorScalar(), + test_data(), + XorScalar().aten_op, + XorScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Xor().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_xor_tensor_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + Xor(), + test_data(), + Xor().aten_op, + Xor().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +@common.parametrize("test_data", XorScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_xor_scalar_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + XorScalar(), + test_data(), + XorScalar().aten_op, + XorScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +######## +## OR ## +######## + + @common.parametrize("test_data", Or().test_data) def test_bitwise_or_tensor_tosa_FP(test_data: input_t2): pipeline = TosaPipelineFP[input_t2]( @@ -513,3 +662,71 @@ def test_bitwise_or_scalar_u85_INT(test_data: input_t2): pipeline.pop_stage("quantize") pipeline.pop_stage("check.quant_nodes") pipeline.run() + + +@common.parametrize("test_data", Or().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_or_tensor_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + Or(), + test_data(), + Or().aten_op, + Or().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", OrScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_or_scalar_vgf_FP(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + OrScalar(), + test_data(), + OrScalar().aten_op, + OrScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Or().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_or_tensor_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + Or(), + test_data(), + Or().aten_op, + Or().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + +@common.parametrize("test_data", OrScalar().test_data) +@common.SkipIfNoModelConverter +def test_bitwise_or_scalar_vgf_INT(test_data: input_t2): + pipeline = VgfPipeline[input_t2]( + OrScalar(), + test_data(), + OrScalar().aten_op, + OrScalar().exir_op, + atol=0, + rtol=0, + qtol=0, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("quantize") + pipeline.pop_stage("check.quant_nodes") + pipeline.run() diff --git a/backends/arm/test/ops/test_bmm.py b/backends/arm/test/ops/test_bmm.py index 40ae35cb5dd..7c0fc1665bb 100644 --- a/backends/arm/test/ops/test_bmm.py +++ b/backends/arm/test/ops/test_bmm.py @@ -17,6 +17,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op_bmm = "torch.ops.aten.bmm.default" @@ -138,3 +139,53 @@ def test_bmm_u85_INT_single_input(test_data: input_t1): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", BMM.test_data_generators) +@common.SkipIfNoModelConverter +def test_bmm_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + BMM(), test_data(), aten_op_bmm, exir_op_bmm, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", BMMSingleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_bmm_vgf_FP_single_input(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + BMMSingleInput(), + test_data(), + aten_op_bmm, + exir_op_bmm, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", BMM.test_data_generators) +@common.SkipIfNoModelConverter +def test_bmm_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + BMM(), + test_data(), + aten_op_bmm, + exir_op_bmm, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_data", BMMSingleInput.test_data_generators) +@common.SkipIfNoModelConverter +def test_bmm_vgf_INT_single_input(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + BMMSingleInput(), + test_data(), + aten_op_bmm, + exir_op_bmm, + tosa_version="TOSA-1.0+INT", + ) + # TODO: MLETORCH-1136 Change args of run_method_and_compare_outputs of the vgf tests + # pipeline.change_args("run_method_and_compare_outputs", qtol=1) + pipeline.run() diff --git a/backends/arm/test/ops/test_cat.py b/backends/arm/test/ops/test_cat.py index 583a79e6710..826689622fb 100644 --- a/backends/arm/test/ops/test_cat.py +++ b/backends/arm/test/ops/test_cat.py @@ -16,6 +16,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] # Input x @@ -136,3 +137,25 @@ def test_cat_u85_INT(test_data: Tuple): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", Cat.test_parameters) +@common.SkipIfNoModelConverter +def test_cat_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Cat(), test_data(), aten_op, exir_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", Cat.test_parameters) +@common.SkipIfNoModelConverter +def test_cat_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Cat(), + test_data(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_ceil.py b/backends/arm/test/ops/test_ceil.py index 25e641fa72c..64e9040a974 100644 --- a/backends/arm/test/ops/test_ceil.py +++ b/backends/arm/test/ops/test_ceil.py @@ -12,6 +12,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] @@ -94,3 +95,33 @@ def test_ceil_u85_INT(test_data: input_t1): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_ceil_vgf_FP(test_data: input_t1): + module, data = test_data() + pipeline = VgfPipeline[input_t1]( + module, + (data,), + module.aten_op, + module.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_ceil_vgf_INT(test_data: input_t1): + module, data = test_data() + pipeline = VgfPipeline[input_t1]( + module, + (data,), + module.aten_op, + module.exir_op, + atol=0.06, + rtol=0.01, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_clamp.py b/backends/arm/test/ops/test_clamp.py index 4c67e096c59..ba490ccc0c6 100644 --- a/backends/arm/test/ops/test_clamp.py +++ b/backends/arm/test/ops/test_clamp.py @@ -15,6 +15,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.clamp.default" @@ -119,3 +120,35 @@ def test_clamp_u85_INT(test_data): pipeline.change_args("run_method_and_compare_outputs", qtol=1) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_clamp_vgf_FP(test_data): + input_tensor, min_val, max_val = test_data() + model = Clamp(min_val, max_val) + pipeline = VgfPipeline[input_t]( + model, + (input_tensor,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_clamp_vgf_INT(test_data): + input_tensor, min_val, max_val = test_data() + model = Clamp(min_val, max_val) + pipeline = VgfPipeline[input_t]( + model, + (input_tensor,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + # TODO: MLETORCH-1136 Change args of run_method_and_compare_outputs of the vgf tests + # pipeline.change_args("run_method_and_compare_outputs", qtol=1) + pipeline.run() diff --git a/backends/arm/test/ops/test_clone.py b/backends/arm/test/ops/test_clone.py index 88755f7254a..7a24848697e 100644 --- a/backends/arm/test/ops/test_clone.py +++ b/backends/arm/test/ops/test_clone.py @@ -19,6 +19,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.clone.default" @@ -101,3 +102,25 @@ def test_clone_u85_INT(test_data): ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_clone_vgf_FP(test_data): + pipeline = VgfPipeline[input_t]( + Clone(), test_data(), aten_op, exir_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_clone_vgf_INT(test_data): + pipeline = VgfPipeline[input_t]( + Clone(), + test_data(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_constant_pad_nd.py b/backends/arm/test/ops/test_constant_pad_nd.py index 5670cbd312c..d70249c31d1 100644 --- a/backends/arm/test/ops/test_constant_pad_nd.py +++ b/backends/arm/test/ops/test_constant_pad_nd.py @@ -13,6 +13,7 @@ from executorch.backends.arm.test.tester.test_pipeline import ( TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.pad.default" @@ -74,3 +75,31 @@ def test_constant_pad_nd_tosa_INT(test_data: Tuple): exir_op, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_constant_pad_nd_vgf_FP(test_data: Tuple): + inp, padding, value = test_data() + pipeline = VgfPipeline[input_t1]( + ConstantPadND(padding, value), + (inp,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_constant_pad_nd_vgf_INT(test_data: Tuple): + inp, padding, value = test_data() + pipeline = VgfPipeline[input_t1]( + ConstantPadND(padding, value), + (inp,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_conv1d.py b/backends/arm/test/ops/test_conv1d.py index 60f51260db2..ac66bc1556b 100644 --- a/backends/arm/test/ops/test_conv1d.py +++ b/backends/arm/test/ops/test_conv1d.py @@ -13,6 +13,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.conv1d.default" @@ -327,3 +328,31 @@ def test_convolution_1d_u85_INT(test_data): qtol=1, ) pipeline.run() + + +@common.parametrize("test_data", test_data_FP) +@common.SkipIfNoModelConverter +def test_convolution_1d_vgf_FP(test_data): + pipeline = VgfPipeline[input_t]( + test_data(), + test_data().get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_1d_vgf_INT(test_data): + model, per_channel_quantization = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_conv2d.py b/backends/arm/test/ops/test_conv2d.py index ef5ad5c3dec..0d23d2a6c7e 100644 --- a/backends/arm/test/ops/test_conv2d.py +++ b/backends/arm/test/ops/test_conv2d.py @@ -14,6 +14,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.conv2d.default" @@ -455,6 +456,35 @@ def test_convolution_u85_INT(test_data): pipeline.run() +@common.parametrize("test_data", test_data_FP) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP(test_data): + model = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT(test_data): + model, per_channel_quantization = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + pipeline.run() + + reject_suite = { "large_stride": lambda: Conv2d( in_channels=1, diff --git a/backends/arm/test/ops/test_conv3d.py b/backends/arm/test/ops/test_conv3d.py index 0e7ba7b2bfb..b26f75daa1a 100644 --- a/backends/arm/test/ops/test_conv3d.py +++ b/backends/arm/test/ops/test_conv3d.py @@ -15,6 +15,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.conv3d.default" @@ -387,6 +388,35 @@ def test_convolution_3d_u85_INT(test_data): pipeline.run() +@common.parametrize("test_data", test_data_FP) +@pytest.mark.skip # Not implemented, skip until it is. +@common.SkipIfNoModelConverter +def test_convolution_3d_vgf_FP(test_data): + pipeline = VgfPipeline[input_t]( + test_data(), + test_data().get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_INT) +@pytest.mark.skip # Not implemented, skip until it is. +@common.SkipIfNoModelConverter +def test_convolution_3d_vgf_INT(test_data): + model, per_channel_quantization = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + reject_suite = { "large_stride": lambda: Conv3d( in_channels=1, diff --git a/backends/arm/test/ops/test_conv_combos.py b/backends/arm/test/ops/test_conv_combos.py index 6769eb7ea34..76502daf45c 100644 --- a/backends/arm/test/ops/test_conv_combos.py +++ b/backends/arm/test/ops/test_conv_combos.py @@ -15,6 +15,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] @@ -275,6 +276,32 @@ def test_convolution_2d_u85_INT_meandim(): pipeline.run() +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP_meandim(): + model = ComboConv2dMeandim() + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboConv2dMeandim.edge_op_list, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT_meandim(): + model = ComboConv2dMeandim() + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboConv2dMeandim.edge_op_list, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + ############################## ## Conv + batch norm + relu ## ############################## @@ -341,6 +368,37 @@ def test_convolution_2d_u85_INT_batchnorm_relu6(test_data): pipeline.run() +@common.parametrize("test_data", ComboConvBatchnormRelu6.test_data_FP) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP_batchnorm_relu6(test_data): + affine = test_data + model = ComboConvBatchnormRelu6(affine) + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboConvBatchnormRelu6.edge_op_list, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", ComboConvBatchnormRelu6.test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT_batchnorm_relu6(test_data): + affine, per_channel_quantization = test_data + model = ComboConvBatchnormRelu6(affine) + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboConvBatchnormRelu6.edge_op_list, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + pipeline.run() + + ################## ## Conv + ReLU6 ## ################## @@ -405,6 +463,36 @@ def test_convolution_2d_u85_INT_relu6(test_data): pipeline.run() +@common.parametrize("test_data", ComboConvRelu6.test_data_FP) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP_relu6(test_data): + model = ComboConvRelu6() + pipeline = VgfPipeline[input_t1]( + model, + test_data(), + aten_op=[], + exir_op=ComboConvRelu6.edge_op_list, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", ComboConvRelu6.test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT_relu6(test_data): + input, per_channel_quantization = test_data() + model = ComboConvRelu6() + pipeline = VgfPipeline[input_t1]( + model, + input, + aten_op=[], + exir_op=ComboConvRelu6.edge_op_list, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + pipeline.run() + + ############################### ## Block bottleneck residual ## ############################### @@ -467,6 +555,37 @@ def test_convolution_2d_u85_INT_block_bottleneck(test_data): pipeline.run() +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP_block_bottleneck(): + model = ComboBlockBottleneckResidual() + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboBlockBottleneckResidual.edge_op_list, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", ComboBlockBottleneckResidual.test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT_block_bottleneck(test_data): + per_channel_quantization = test_data + model = ComboBlockBottleneckResidual() + pipeline = VgfPipeline[input_t1]( + model, + model.get_inputs(), + aten_op=[], + exir_op=ComboBlockBottleneckResidual.edge_op_list, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + # TODO: MLETORCH-1136 Change args of run_method_and_compare_outputs of the vgf tests + # pipeline.change_args("run_method_and_compare_outputs", model.get_inputs(), qtol=1) + pipeline.run() + + ###################### ## Conv + AvgPool2d ## ###################### @@ -529,3 +648,33 @@ def test_convolution_2d_u85_INT_avgpool2d(test_data): per_channel_quantization=per_channel_quantization, ) pipeline.run() + + +@common.parametrize("test_data", ComboConvAvgPool2d.test_data_FP) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_FP_avgpool2d(test_data): + model = ComboConvAvgPool2d() + pipeline = VgfPipeline[input_t1]( + model, + test_data(), + aten_op=[], + exir_op=ComboConvAvgPool2d.edge_op_list, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", ComboConvAvgPool2d.test_data_INT) +@common.SkipIfNoModelConverter +def test_convolution_2d_vgf_INT_avgpool2d(test_data): + input, per_channel_quantization = test_data() + model = ComboConvAvgPool2d() + pipeline = VgfPipeline[input_t1]( + model, + input, + aten_op=[], + exir_op=ComboConvAvgPool2d.edge_op_list, + tosa_version="TOSA-1.0+INT", + per_channel_quantization=per_channel_quantization, + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_conv_constant_pad_nd.py b/backends/arm/test/ops/test_conv_constant_pad_nd.py index 19750788e6e..636c18ef753 100644 --- a/backends/arm/test/ops/test_conv_constant_pad_nd.py +++ b/backends/arm/test/ops/test_conv_constant_pad_nd.py @@ -16,6 +16,7 @@ from executorch.backends.arm.test.tester.test_pipeline import ( TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.pad.default" @@ -114,3 +115,31 @@ def test_constant_pad_nd_tosa_INT(test_data: Tuple): rtol=0.01, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_constant_pad_nd_vgf_FP(test_data: Tuple): + test_data, padding, value = test_data + pipeline = VgfPipeline[input_t1]( + ConstantPadND(padding, value), + (test_data,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_constant_pad_nd_vgf_INT(test_data: Tuple): + test_data, padding, value = test_data + pipeline = VgfPipeline[input_t1]( + ConstantPadND(padding, value), + (test_data,), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_cos.py b/backends/arm/test/ops/test_cos.py index e872c847ade..acb950f2a2e 100644 --- a/backends/arm/test/ops/test_cos.py +++ b/backends/arm/test/ops/test_cos.py @@ -15,6 +15,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.cos.default" @@ -65,7 +66,7 @@ def test_cos_tosa_INT(test_data: Tuple): @common.parametrize("test_data", test_data_suite) -def test_cos_tosa_u55_INT(test_data: Tuple): +def test_cos_u55_INT(test_data: Tuple): pipeline = EthosU55PipelineINT[input_t1]( Cos(), (test_data,), @@ -77,7 +78,7 @@ def test_cos_tosa_u55_INT(test_data: Tuple): @common.parametrize("test_data", test_data_suite) -def test_cos_tosa_u85_INT(test_data: Tuple): +def test_cos_u85_INT(test_data: Tuple): pipeline = EthosU85PipelineINT[input_t1]( Cos(), (test_data,), @@ -86,3 +87,29 @@ def test_cos_tosa_u85_INT(test_data: Tuple): run_on_fvp=False, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_cos_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Cos(), + (test_data,), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_cos_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Cos(), + (test_data,), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_depthwise_conv.py b/backends/arm/test/ops/test_depthwise_conv.py index 9d044dc2237..bf6aad840ac 100644 --- a/backends/arm/test/ops/test_depthwise_conv.py +++ b/backends/arm/test/ops/test_depthwise_conv.py @@ -15,6 +15,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = Tuple[torch.Tensor] # Input x @@ -222,6 +223,34 @@ def test_depthwise_convolution_2d_tosa_INT(test_data): pipeline.run() +@common.parametrize("test_data", test_data_conv1d_FP | test_data_conv2d_FP) +@common.SkipIfNoModelConverter +def test_depthwise_convolution_2d_vgf_FP(test_data: torch.nn.Module): + model = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_conv1d_INT | test_data_conv2d_INT) +@common.SkipIfNoModelConverter +def test_depthwise_convolution_2d_vgf_INT(test_data): + model, per_channel_quantization = test_data() + pipeline = VgfPipeline[input_t]( + model, + model.get_inputs(), + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + x_fails = { f"{k},per_channel_quant={q}": reason for k, reason in { diff --git a/backends/arm/test/ops/test_div.py b/backends/arm/test/ops/test_div.py index 2c27a0a0c96..026939758a0 100644 --- a/backends/arm/test/ops/test_div.py +++ b/backends/arm/test/ops/test_div.py @@ -16,6 +16,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.div.Tensor" @@ -134,3 +135,25 @@ def test_div_tensor_u85_INT(test_data: Tuple): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_div_tensor_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Div(), test_data(), aten_op, exir_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_div_tensor_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Div(), + test_data(), + aten_op=[], + exir_op=[], + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_embedding.py b/backends/arm/test/ops/test_embedding.py index df6bf601f0b..b0a4647c3ae 100644 --- a/backends/arm/test/ops/test_embedding.py +++ b/backends/arm/test/ops/test_embedding.py @@ -13,6 +13,7 @@ from executorch.backends.arm.test.tester.test_pipeline import ( TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) @@ -84,3 +85,37 @@ def test_embedding_tosa_INT(test_input: input_params): pipeline.pop_stage("check_count.exir") pipeline.run() + + +@common.parametrize("test_input", test_input) +@common.SkipIfNoModelConverter +def test_embedding_vgf_FP(test_input: input_params): + op = Embedding() + pipeline = VgfPipeline[input_params]( + op, + test_input, + op.aten_op, + op.exir_op, + tosa_version="TOSA-1.0+FP", + use_to_edge_transform_and_lower=True, + transform_passes=[InsertCastForOpsWithInt64InputPass()], + ) + pipeline.run() + + +@common.parametrize("test_input", test_input) +@common.SkipIfNoModelConverter +def test_embedding_vgf_INT(test_input: input_params): + op = Embedding() + pipeline = VgfPipeline[input_params]( + op, + test_input, + op.aten_op, + op.exir_op, + tosa_version="TOSA-1.0+INT", + use_to_edge_transform_and_lower=True, + ) + pipeline.pop_stage("check.aten") + pipeline.pop_stage("check_count.exir") + + pipeline.run() diff --git a/backends/arm/test/ops/test_eq.py b/backends/arm/test/ops/test_eq.py index dd1add495ed..b840869ba48 100644 --- a/backends/arm/test/ops/test_eq.py +++ b/backends/arm/test/ops/test_eq.py @@ -13,6 +13,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = Tuple[torch.Tensor] @@ -187,3 +188,47 @@ def test_eq_scalar_u85_INT(test_module): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_module", test_data_tensor) +@common.SkipIfNoModelConverter +def test_eq_scalar_vgf_FP_tensor(test_module): + pipeline = VgfPipeline[input_t]( + test_module(), test_module().get_inputs(), Equal.aten_op_Tensor, Equal.exir_op + ) + pipeline.run() + + +@common.parametrize("test_module", test_data_scalar) +@common.SkipIfNoModelConverter +def test_eq_scalar_vgf_FP(test_module): + pipeline = VgfPipeline[input_t]( + test_module(), test_module().get_inputs(), Equal.aten_op_Scalar, Equal.exir_op + ) + pipeline.run() + + +@common.parametrize("test_module", test_data_tensor) +@common.SkipIfNoModelConverter +def test_eq_scalar_vgf_INT_tensor(test_module): + pipeline = VgfPipeline[input_t]( + test_module(), + test_module().get_inputs(), + Equal.aten_op_Tensor, + Equal.exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + +@common.parametrize("test_module", test_data_scalar) +@common.SkipIfNoModelConverter +def test_eq_scalar_vgf_INT(test_module): + pipeline = VgfPipeline[input_t]( + test_module(), + test_module().get_inputs(), + Equal.aten_op_Tensor, + Equal.exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_erf.py b/backends/arm/test/ops/test_erf.py index f50aa34b9b0..363b1e2d8c9 100644 --- a/backends/arm/test/ops/test_erf.py +++ b/backends/arm/test/ops/test_erf.py @@ -12,6 +12,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.erf.default" @@ -61,3 +62,25 @@ def test_erf_u85_INT(test_data: input_t1): Erf(), test_data(), aten_op, exir_op, run_on_fvp=True ) pipeline.run() + + +@common.parametrize("test_data", Erf.test_data) +@common.SkipIfNoModelConverter +def test_erf_vgf_FP(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Erf(), test_data(), aten_op, exir_op, tosa_version="TOSA-1.0+FP" + ) + pipeline.run() + + +@common.parametrize("test_data", Erf.test_data) +@common.SkipIfNoModelConverter +def test_erf_vgf_INT(test_data: input_t1): + pipeline = VgfPipeline[input_t1]( + Erf(), + test_data(), + aten_op, + exir_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_exp.py b/backends/arm/test/ops/test_exp.py index 4458f651e71..6eaacc71d86 100644 --- a/backends/arm/test/ops/test_exp.py +++ b/backends/arm/test/ops/test_exp.py @@ -16,6 +16,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) test_data_suite = { @@ -83,3 +84,29 @@ def test_exp_u85_INT(test_data: Tuple): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_exp_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Exp(), + (test_data(),), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data_suite) +@common.SkipIfNoModelConverter +def test_exp_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Exp(), + (test_data(),), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_expand.py b/backends/arm/test/ops/test_expand.py index 30ab4d73092..607d8650946 100644 --- a/backends/arm/test/ops/test_expand.py +++ b/backends/arm/test/ops/test_expand.py @@ -20,6 +20,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) aten_op = "torch.ops.aten.expand.default" @@ -102,6 +103,32 @@ def test_expand_u85_INT(test_data: Tuple): pipeline.run() +@common.parametrize("test_data", Expand.test_parameters | Expand.test_reject_set) +@common.SkipIfNoModelConverter +def test_expand_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Expand(), + test_data(), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", Expand.test_parameters | Expand.test_reject_set) +@common.SkipIfNoModelConverter +def test_expand_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + Expand(), + test_data(), + aten_op, + exir_op=[], + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() + + @common.parametrize("test_data", Expand.test_reject_set) @common.XfailIfNoCorstone300 @pytest.mark.xfail( diff --git a/backends/arm/test/ops/test_eye.py b/backends/arm/test/ops/test_eye.py index cd2eac74548..48f93379fc0 100644 --- a/backends/arm/test/ops/test_eye.py +++ b/backends/arm/test/ops/test_eye.py @@ -11,6 +11,7 @@ OpNotSupportedPipeline, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t = tuple[torch.Tensor] @@ -98,6 +99,39 @@ def test_eye_u85_INT(test_data: test_data_t): pipeline.run() +@common.parametrize( + "test_data", + EyeAdd.test_data, +) +@common.SkipIfNoModelConverter +def test_eye_vgf_FP(test_data: test_data_t): + input_data, init_data = test_data + pipeline = VgfPipeline[input_t]( + EyeAdd(*init_data), + input_data(), + EyeAdd.aten_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize( + "test_data", + EyeAdd.test_data, +) +@common.SkipIfNoModelConverter +def test_eye_vgf_INT(test_data: test_data_t): + input_data, init_data = test_data + pipeline = VgfPipeline[input_t]( + EyeAdd(*init_data), + input_data(), + EyeAdd.aten_op, + tosa_version="TOSA-1.0+INT", + ) + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + @common.parametrize( "test_data", EyeAdd.test_data_not_delegated, diff --git a/backends/arm/test/ops/test_floor.py b/backends/arm/test/ops/test_floor.py index 0a77181efe7..c66ef1c5d27 100644 --- a/backends/arm/test/ops/test_floor.py +++ b/backends/arm/test/ops/test_floor.py @@ -12,6 +12,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor] @@ -94,3 +95,33 @@ def test_floor_u85_INT(test_data: input_t1): run_on_fvp=True, ) pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_floor_vgf_FP(test_data: input_t1): + module, data = test_data() + pipeline = VgfPipeline[input_t1]( + module, + (data,), + module.aten_op, + module.exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", test_data) +@common.SkipIfNoModelConverter +def test_floor_vgf_INT(test_data: input_t1): + module, data = test_data() + pipeline = VgfPipeline[input_t1]( + module, + (data,), + module.aten_op, + module.exir_op, + atol=0.06, + rtol=0.01, + tosa_version="TOSA-1.0+INT", + ) + pipeline.run() diff --git a/backends/arm/test/ops/test_full.py b/backends/arm/test/ops/test_full.py index 09cb47812d7..9e2c9b4d8be 100644 --- a/backends/arm/test/ops/test_full.py +++ b/backends/arm/test/ops/test_full.py @@ -19,6 +19,7 @@ EthosU85PipelineINT, TosaPipelineFP, TosaPipelineINT, + VgfPipeline, ) input_t1 = Tuple[torch.Tensor, int] @@ -108,6 +109,18 @@ def test_full_like_tosa_FP(test_data: Tuple): pipeline.run() +@common.parametrize("test_data", FullLike.test_parameters) +def test_full_like_tosa_INT(test_data: Tuple): + pipeline = TosaPipelineINT[input_t1]( + FullLike(), + test_data(), + aten_op=[], + exir_op=exir_op, + ) + pipeline.pop_stage("check.quant_nodes") + pipeline.run() + + @common.parametrize("test_data", AddVariableFull.test_parameters) def test_full_tosa_FP(test_data: Tuple): pipeline = TosaPipelineFP[input_t1]( @@ -130,15 +143,54 @@ def test_full_tosa_INT(test_data: Tuple): pipeline.run() -@common.parametrize("test_data", FullLike.test_parameters) -def test_full_like_tosa_INT(test_data: Tuple): - pipeline = TosaPipelineINT[input_t1]( - FullLike(), - test_data(), +@common.SkipIfNoModelConverter +def test_full_vgf_FP_only(): + pipeline = VgfPipeline[input_t1]( + Full(), + (), aten_op=[], exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.SkipIfNoModelConverter +def test_full_vgf_FP_const(): + test_data = (torch.rand((2, 2, 3, 3)) * 10,) + pipeline = VgfPipeline[input_t1]( + AddConstFull(), + test_data, + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AddVariableFull.test_parameters) +@common.SkipIfNoModelConverter +def test_full_vgf_FP(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + AddVariableFull(), + test_data, + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+FP", + ) + pipeline.run() + + +@common.parametrize("test_data", AddVariableFull.test_parameters) +@common.SkipIfNoModelConverter +def test_full_vgf_INT(test_data: Tuple): + pipeline = VgfPipeline[input_t1]( + AddVariableFull(), + test_data, + aten_op=[], + exir_op=exir_op, + tosa_version="TOSA-1.0+INT", ) - pipeline.pop_stage("check.quant_nodes") pipeline.run()