From 9a8286d22d0f4051ae4b945459fa0e554cd6e58d Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Sat, 24 Aug 2024 20:57:33 +0800
Subject: [PATCH 1/9] add annotation

---
 tools/pnnx/src/save_ncnn.cpp | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index bbe778ddc42..5be1f89525c 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -462,6 +462,8 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
 
     fclose(pyfp);
 
+    // cpp inference
+
     return 0;
 }
 

From c018ce0c7eedc121dfe61ea143f4f2a5a83a7555 Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Fri, 30 Aug 2024 22:07:28 +0800
Subject: [PATCH 2/9] generate cpp

---
 tools/pnnx/src/main.cpp      |   6 +-
 tools/pnnx/src/save_ncnn.cpp | 183 ++++++++++++++++++++++++++++++++++-
 tools/pnnx/src/save_ncnn.h   |   2 +-
 3 files changed, 188 insertions(+), 3 deletions(-)

diff --git a/tools/pnnx/src/main.cpp b/tools/pnnx/src/main.cpp
index c25128032d9..d7f587ba080 100644
--- a/tools/pnnx/src/main.cpp
+++ b/tools/pnnx/src/main.cpp
@@ -226,6 +226,7 @@ int main(int argc, char** argv)
     std::string ncnnparampath = ptbase + ".ncnn.param";
     std::string ncnnbinpath = ptbase + ".ncnn.bin";
     std::string ncnnpypath = ptbase + "_ncnn.py";
+    std::string ncnncpppath = ptbase + "_ncnn.cpp";
     int fp16 = 1;
     int optlevel = 2;
     std::string device = "cpu";
@@ -267,6 +268,8 @@ int main(int argc, char** argv)
             ncnnbinpath = std::string(value);
         if (strcmp(key, "ncnnpy") == 0)
             ncnnpypath = std::string(value);
+        if (strcmp(key, "ncnncpp") == 0)
+            ncnncpppath = std::string(value);
         if (strcmp(key, "fp16") == 0)
             fp16 = atoi(value);
         if (strcmp(key, "optlevel") == 0)
@@ -292,6 +295,7 @@ int main(int argc, char** argv)
         fprintf(stderr, "ncnnparam = %s\n", ncnnparampath.c_str());
         fprintf(stderr, "ncnnbin = %s\n", ncnnbinpath.c_str());
         fprintf(stderr, "ncnnpy = %s\n", ncnnpypath.c_str());
+        fprintf(stderr, "ncnncpp = %s\n", ncnncpppath.c_str());
         fprintf(stderr, "fp16 = %d\n", fp16);
         fprintf(stderr, "optlevel = %d\n", optlevel);
         fprintf(stderr, "device = %s\n", device.c_str());
@@ -375,7 +379,7 @@ int main(int argc, char** argv)
 
         pnnx::pass_ncnn(pnnx_graph, module_operators);
 
-        pnnx::save_ncnn(pnnx_graph, ncnnparampath, ncnnbinpath, ncnnpypath, fp16);
+        pnnx::save_ncnn(pnnx_graph, ncnnparampath, ncnnbinpath, ncnnpypath, ncnncpppath, fp16);
     }
 
     //     pnnx::Graph pnnx_graph2;
diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index 5be1f89525c..82ed7ef2389 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -54,6 +54,48 @@ static const char* type_to_dtype_string(int type)
     return "null";
 }
 
+static const char* type_to_libtorch_dtype_string(int type)
+{
+    if (type == 1) return "Float";
+    if (type == 2) return "Double";
+    if (type == 3) return "Half";
+    if (type == 4) return "Int";
+    if (type == 5)
+    {
+        fprintf(stderr, "replace ncnn input torch.long type with torch.int\n");
+        return "torch.int";
+    }
+    if (type == 6) return "Short";
+    if (type == 7) return "Char";
+    if (type == 8) return "Byte";
+    if (type == 9) return "Bool";
+    if (type == 10) return "ComplexFloat";
+    if (type == 11) return "ComplexDouble";
+    if (type == 12) return "ComplexHalf";
+    return "null";
+}
+
+static size_t type_to_elemsize(int type)
+{
+    if (type == 1) return 4;
+    if (type == 2) return 8;
+    if (type == 3) return 2;
+    if (type == 4) return 4;
+    if (type == 5)
+    {
+        fprintf(stderr, "replace ncnn input torch.long type with torch.int\n");
+        return 4;
+    }
+    if (type == 6) return 2;
+    if (type == 7) return 1;
+    if (type == 8) return 1;
+    if (type == 9) return 1;
+    if (type == 10) return 8;
+    if (type == 11) return 16;
+    if (type == 12) return 4;
+    return 4;
+}
+
 static bool string_is_positive_integer(const std::string& t)
 {
     for (size_t i = 0; i < t.size(); i++)
@@ -124,7 +166,7 @@ static size_t alignSize(size_t sz, int n)
     return (sz + n - 1) & -n;
 }
 
-int save_ncnn(const Graph& g, const std::string& parampath, const std::string& binpath, const std::string& pypath, int fp16)
+int save_ncnn(const Graph& g, const std::string& parampath, const std::string& binpath, const std::string& pypath, const std::string& cpppath, int fp16)
 {
     FILE* paramfp = fopen(parampath.c_str(), "wb");
     if (!paramfp)
@@ -348,6 +390,8 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
     fclose(paramfp);
     fclose(binfp);
 
+    // py inference
+
     FILE* pyfp = fopen(pypath.c_str(), "wb");
     if (!pyfp)
     {
@@ -462,7 +506,144 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
 
     fclose(pyfp);
 
+    // ================
     // cpp inference
+    // ================
+
+    FILE* cppfp = fopen(cpppath.c_str(), "wb");
+    if (!cppfp)
+    {
+        fprintf(stderr, "fopen %s failed\n", cpppath.c_str());
+        return -1;
+    }
+
+    // include
+
+    fprintf(cppfp, "#include <stdio.h>\n");
+    fprintf(cppfp, "#include <vector>\n");
+    fprintf(cppfp, "#include <torch/torch.h>\n");
+    fprintf(cppfp, "#include \"net.h\"\n\n");
+
+    // utils
+
+    fprintf(cppfp, "void print_mat(const ncnn::Mat& m)\n");
+    fprintf(cppfp, "{\n");
+    fprintf(cppfp, "    for (int q=0; q<m.c; q++)\n");
+    fprintf(cppfp, "    {\n");
+    fprintf(cppfp, "        const float* ptr = m.channel(q);\n");
+    fprintf(cppfp, "        for (int z=0; z<m.d; z++)\n");
+    fprintf(cppfp, "        {\n");
+    fprintf(cppfp, "            for (int y=0; y<m.h; y++)\n");
+    fprintf(cppfp, "            {\n");
+    fprintf(cppfp, "                for (int x=0; x<m.w; x++)\n");
+    fprintf(cppfp, "                {\n");
+    fprintf(cppfp, "                    fprintf(stderr, \"%%f \", ptr[x]);\n");
+    fprintf(cppfp, "                }\n");
+    fprintf(cppfp, "                ptr += m.w;\n");
+    fprintf(cppfp, "                fprintf(stderr, \"\\n\");\n");
+    fprintf(cppfp, "            }\n");
+    fprintf(cppfp, "            fprintf(stderr, \"\\n\");\n");
+    fprintf(cppfp, "        }\n");
+    fprintf(cppfp, "        fprintf(stderr, \"------------------------\\n\");\n");
+    fprintf(cppfp, "    }\n");
+    fprintf(cppfp, "}\n");
+
+
+    fprintf(cppfp, "void copy(const ncnn::Mat& m, const at::Tensor& t, size_t elemsize)\n");
+    fprintf(cppfp, "{\n");
+    fprintf(cppfp, "    void* t_ptr = t.data_ptr();\n");
+    fprintf(cppfp, "    size_t step = m.d * m.h * m.w * elemsize;\n");
+    fprintf(cppfp, "    for (int q=0; q<m.c; q++)\n");
+    fprintf(cppfp, "    {\n");
+    fprintf(cppfp, "        const char* ptr = m.channel(q);\n");
+    fprintf(cppfp, "        memcpy((void*)ptr, t_ptr, step);\n");
+    fprintf(cppfp, "        t_ptr = (void*)((char*)t_ptr + step);\n");
+    fprintf(cppfp, "    }\n");
+    fprintf(cppfp, "}\n\n");
+
+    // test inference
+
+    fprintf(cppfp, "int main(int argc, char** argv)\n");
+    fprintf(cppfp, "{\n");
+    fprintf(cppfp, "    ncnn::Net net;\n");
+    fprintf(cppfp, "    if (net.load_param(\"%s\"))\n", parampath.c_str());
+    fprintf(cppfp, "        exit(-1);\n");
+    fprintf(cppfp, "    if (net.load_model(\"%s\"))\n", binpath.c_str());
+    fprintf(cppfp, "        exit(-1);\n\n");
+
+    fprintf(cppfp, "    at::manual_seed(0);\n");
+
+    for (int input_index = 0;; input_index++)
+    {
+        std::string input_name = std::string("in") + std::to_string(input_index);
+        const Operand* r = g.get_operand(input_name);
+        if (!r)
+            break;
+
+        int numel = 1;
+        for (size_t j = 0; j < r->shape.size(); j++)
+        {
+            numel *= r->shape[j];
+        }
+        const int batch_index = r->params.at("__batch_index").i;
+
+        if (type_is_integer(r->type))
+        {
+            fprintf(cppfp, "    at::Tensor %s_t = at::randint(10, {%d}, ", input_name.c_str(), numel);
+            fprintf(cppfp, "at::TensorOptions().dtype(at::k%s));\n", type_to_libtorch_dtype_string(r->type));
+        }
+        else
+        {
+            fprintf(cppfp, "    at::Tensor %s_t = at::rand({%d}, ", input_name.c_str(), numel);
+            fprintf(cppfp, "at::TensorOptions().dtype(at::k%s));\n", type_to_libtorch_dtype_string(r->type));
+        }
+
+        fprintf(cppfp, "    ncnn::Mat %s(", input_name.c_str());
+        for (size_t i = 0; i < r->shape.size(); i++)
+        {
+            // squeeze batch index
+            if (batch_index != 233 && i == batch_index && r->shape[r->shape.size() - 1 - i] == 1)
+                continue;
+            fprintf(cppfp, "%d, ", r->shape[r->shape.size() - 1 - i]);
+        }
+        fprintf(cppfp, "(size_t)%du);\n", type_to_elemsize(r->type));
+        fprintf(cppfp, "    copy(%s, %s_t, (size_t)%du);\n", input_name.c_str(), input_name.c_str(), type_to_elemsize(r->type));
+    }
+
+    fprintf(cppfp, "    ncnn::Extractor ex = net.create_extractor();\n");
+
+    for (int input_index = 0;; input_index++)
+    {
+        std::string input_name = std::string("in") + std::to_string(input_index);
+        const Operand* r = g.get_operand(input_name);
+        if (!r)
+            break;
+        fprintf(cppfp, "    ex.input(\"%s\", %s);\n", input_name.c_str(), input_name.c_str());
+    }
+
+    fprintf(cppfp, "\n");
+
+    for (int output_index = 0;; output_index++)
+    {
+        std::string output_name = std::string("out") + std::to_string(output_index);
+        const Operand* r = g.get_operand(output_name);
+        if (!r)
+            break;
+
+        fprintf(cppfp, "    ncnn::Mat %s;\n", output_name.c_str());
+        fprintf(cppfp, "    ex.extract(\"%s\", %s);\n", output_name.c_str(), output_name.c_str());
+
+        // TODO unsqueeze
+
+        fprintf(cppfp, "    print_mat(%s);\n", output_name.c_str());
+        
+    }
+
+
+    fprintf(cppfp, "    return 0;\n");
+    fprintf(cppfp, "}\n");
+
+    fclose(cppfp);
 
     return 0;
 }
diff --git a/tools/pnnx/src/save_ncnn.h b/tools/pnnx/src/save_ncnn.h
index 458c1470020..62490232977 100644
--- a/tools/pnnx/src/save_ncnn.h
+++ b/tools/pnnx/src/save_ncnn.h
@@ -19,7 +19,7 @@
 
 namespace pnnx {
 
-int save_ncnn(const Graph& g, const std::string& parampath, const std::string& binpath, const std::string& pypath, int fp16);
+int save_ncnn(const Graph& g, const std::string& parampath, const std::string& binpath, const std::string& pypath, const std::string& cpppath, int fp16);
 
 } // namespace pnnx
 

From 3e6e6e76cdf28ac819a8bc9ffa39d565e99482ba Mon Sep 17 00:00:00 2001
From: wnqn1597 <wnqn1597@users.noreply.github.com>
Date: Fri, 30 Aug 2024 14:26:36 +0000
Subject: [PATCH 3/9] apply code-format changes

---
 tools/pnnx/src/save_ncnn.cpp | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index 82ed7ef2389..b19666a023e 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -548,7 +548,6 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
     fprintf(cppfp, "    }\n");
     fprintf(cppfp, "}\n");
 
-
     fprintf(cppfp, "void copy(const ncnn::Mat& m, const at::Tensor& t, size_t elemsize)\n");
     fprintf(cppfp, "{\n");
     fprintf(cppfp, "    void* t_ptr = t.data_ptr();\n");
@@ -636,10 +635,8 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
         // TODO unsqueeze
 
         fprintf(cppfp, "    print_mat(%s);\n", output_name.c_str());
-        
     }
 
-
     fprintf(cppfp, "    return 0;\n");
     fprintf(cppfp, "}\n");
 

From 04b6cdd5f9604d523fb402c828c9cd9060209479 Mon Sep 17 00:00:00 2001
From: wnqn1597 <wnqn1597@users.noreply.github.com>
Date: Tue, 1 Oct 2024 15:36:04 +0000
Subject: [PATCH 4/9] apply code-format changes

---
 tools/pnnx/src/save_ncnn.cpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index fff829ff7c9..82f40570e48 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -624,8 +624,8 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
 
         // TODO unsqueeze
 
-        fprintf(cppfp, "    at::Tensor %s_t = at::zeros({%s.c, %s.d, %s.h, %s.w}, at::TensorOptions().dtype(at::k%s));\n", 
-            output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
+        fprintf(cppfp, "    at::Tensor %s_t = at::zeros({%s.c, %s.d, %s.h, %s.w}, at::TensorOptions().dtype(at::k%s));\n",
+                output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
         fprintf(cppfp, "    copy_mat2tensor(%s_t, %s, (size_t)%du);\n", output_name.c_str(), output_name.c_str(), type_to_elemsize(r->type));
     }
 

From 69e9b6f2f4d2b81a56729ee70b9d8e776fb552de Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Wed, 2 Oct 2024 06:51:02 +0800
Subject: [PATCH 5/9] cmakelists for ncnn cpp

---
 tools/pnnx/src/save_ncnn.cpp               | 57 ++++++++++++----------
 tools/pnnx/tests/ncnn/CMakeListsForCPP.txt | 13 +++++
 2 files changed, 43 insertions(+), 27 deletions(-)
 create mode 100644 tools/pnnx/tests/ncnn/CMakeListsForCPP.txt

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index 82ed7ef2389..fff829ff7c9 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -63,7 +63,7 @@ static const char* type_to_libtorch_dtype_string(int type)
     if (type == 5)
     {
         fprintf(stderr, "replace ncnn input torch.long type with torch.int\n");
-        return "torch.int";
+        return "Int";
     }
     if (type == 6) return "Short";
     if (type == 7) return "Char";
@@ -526,37 +526,26 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
 
     // utils
 
-    fprintf(cppfp, "void print_mat(const ncnn::Mat& m)\n");
+    fprintf(cppfp, "void copy_tensor2mat(const ncnn::Mat& m, const at::Tensor& t, size_t elemsize)\n");
     fprintf(cppfp, "{\n");
+    fprintf(cppfp, "    void* t_ptr = t.data_ptr();\n");
+    fprintf(cppfp, "    size_t step = m.d * m.h * m.w * elemsize;\n");
     fprintf(cppfp, "    for (int q=0; q<m.c; q++)\n");
     fprintf(cppfp, "    {\n");
-    fprintf(cppfp, "        const float* ptr = m.channel(q);\n");
-    fprintf(cppfp, "        for (int z=0; z<m.d; z++)\n");
-    fprintf(cppfp, "        {\n");
-    fprintf(cppfp, "            for (int y=0; y<m.h; y++)\n");
-    fprintf(cppfp, "            {\n");
-    fprintf(cppfp, "                for (int x=0; x<m.w; x++)\n");
-    fprintf(cppfp, "                {\n");
-    fprintf(cppfp, "                    fprintf(stderr, \"%%f \", ptr[x]);\n");
-    fprintf(cppfp, "                }\n");
-    fprintf(cppfp, "                ptr += m.w;\n");
-    fprintf(cppfp, "                fprintf(stderr, \"\\n\");\n");
-    fprintf(cppfp, "            }\n");
-    fprintf(cppfp, "            fprintf(stderr, \"\\n\");\n");
-    fprintf(cppfp, "        }\n");
-    fprintf(cppfp, "        fprintf(stderr, \"------------------------\\n\");\n");
+    fprintf(cppfp, "        const char* ptr = m.channel(q);\n");
+    fprintf(cppfp, "        memcpy((void*)ptr, t_ptr, step);\n");
+    fprintf(cppfp, "        t_ptr = (void*)((char*)t_ptr + step);\n");
     fprintf(cppfp, "    }\n");
-    fprintf(cppfp, "}\n");
-
+    fprintf(cppfp, "}\n\n");
 
-    fprintf(cppfp, "void copy(const ncnn::Mat& m, const at::Tensor& t, size_t elemsize)\n");
+    fprintf(cppfp, "void copy_mat2tensor(const at::Tensor& t, const ncnn::Mat& m, size_t elemsize)\n");
     fprintf(cppfp, "{\n");
     fprintf(cppfp, "    void* t_ptr = t.data_ptr();\n");
     fprintf(cppfp, "    size_t step = m.d * m.h * m.w * elemsize;\n");
     fprintf(cppfp, "    for (int q=0; q<m.c; q++)\n");
     fprintf(cppfp, "    {\n");
     fprintf(cppfp, "        const char* ptr = m.channel(q);\n");
-    fprintf(cppfp, "        memcpy((void*)ptr, t_ptr, step);\n");
+    fprintf(cppfp, "        memcpy(t_ptr, (void*)ptr, step);\n");
     fprintf(cppfp, "        t_ptr = (void*)((char*)t_ptr + step);\n");
     fprintf(cppfp, "    }\n");
     fprintf(cppfp, "}\n\n");
@@ -599,15 +588,15 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
         }
 
         fprintf(cppfp, "    ncnn::Mat %s(", input_name.c_str());
-        for (size_t i = 0; i < r->shape.size(); i++)
+        for (int i = r->shape.size() - 1; i >= 0; i--)
         {
             // squeeze batch index
-            if (batch_index != 233 && i == batch_index && r->shape[r->shape.size() - 1 - i] == 1)
+            if (batch_index != 233 && i == batch_index && r->shape[i] == 1)
                 continue;
-            fprintf(cppfp, "%d, ", r->shape[r->shape.size() - 1 - i]);
+            fprintf(cppfp, "%d, ", r->shape[i]);
         }
         fprintf(cppfp, "(size_t)%du);\n", type_to_elemsize(r->type));
-        fprintf(cppfp, "    copy(%s, %s_t, (size_t)%du);\n", input_name.c_str(), input_name.c_str(), type_to_elemsize(r->type));
+        fprintf(cppfp, "    copy_tensor2mat(%s, %s_t, (size_t)%du);\n", input_name.c_str(), input_name.c_str(), type_to_elemsize(r->type));
     }
 
     fprintf(cppfp, "    ncnn::Extractor ex = net.create_extractor();\n");
@@ -635,11 +624,25 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
 
         // TODO unsqueeze
 
-        fprintf(cppfp, "    print_mat(%s);\n", output_name.c_str());
-        
+        fprintf(cppfp, "    at::Tensor %s_t = at::zeros({%s.c, %s.d, %s.h, %s.w}, at::TensorOptions().dtype(at::k%s));\n", 
+            output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
+        fprintf(cppfp, "    copy_mat2tensor(%s_t, %s, (size_t)%du);\n", output_name.c_str(), output_name.c_str(), type_to_elemsize(r->type));
     }
 
+    fprintf(cppfp, "    torch::save({");
+    for (int output_index = 0;; output_index++)
+    {
+        std::string output_name = std::string("out") + std::to_string(output_index);
+        const Operand* r = g.get_operand(output_name);
+        if (!r)
+            break;
+        if (output_index != 0)
+            fprintf(cppfp, ", ");
+        fprintf(cppfp, "%s_t", output_name.c_str());
+    }
+    fprintf(cppfp, "}, \"out.pt\");\n");
 
+    fprintf(cppfp, "\n");
     fprintf(cppfp, "    return 0;\n");
     fprintf(cppfp, "}\n");
 
diff --git a/tools/pnnx/tests/ncnn/CMakeListsForCPP.txt b/tools/pnnx/tests/ncnn/CMakeListsForCPP.txt
new file mode 100644
index 00000000000..e9dfc76a35a
--- /dev/null
+++ b/tools/pnnx/tests/ncnn/CMakeListsForCPP.txt
@@ -0,0 +1,13 @@
+cmake_minimum_required (VERSION 2.8)
+
+project(${FNAME})
+
+# set(Torch_DIR "/home/beqjal/libtorch/share/cmake/Torch")
+find_package(Torch REQUIRED)
+# set(ncnn_DIR "/home/beqjal/ncnn/build/install/lib/cmake/ncnn" CACHE PATH "/home/beqjal/ncnn/build/install/lib/cmake/ncnn/ncnnConfig.cmake")
+find_package(ncnn REQUIRED)
+
+add_executable(${FNAME} ${FNAME}.cpp)
+target_link_libraries(${FNAME} "${TORCH_LIBRARIES}")
+target_link_libraries(${FNAME} ncnn)
+set_property(TARGET ${FNAME} PROPERTY CXX_STANDARD 14)

From ac329e708887680508a817b4f1e190fa4eb5c37e Mon Sep 17 00:00:00 2001
From: wnqn1597 <wnqn1597@users.noreply.github.com>
Date: Wed, 2 Oct 2024 08:23:28 +0000
Subject: [PATCH 6/9] apply code-format changes

---
 tools/pnnx/src/save_ncnn.cpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index e210afa1a20..69815ecf3bb 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -634,10 +634,10 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
         fprintf(cppfp, "    ncnn::Mat %s;\n", output_name.c_str());
         fprintf(cppfp, "    ex.extract(\"%s\", %s);\n", output_name.c_str(), output_name.c_str());
 
-        fprintf(cppfp, "    at::Tensor %s_t = create_tensor_from_mat(%s).toType(at::k%s);\n", 
-            output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
+        fprintf(cppfp, "    at::Tensor %s_t = create_tensor_from_mat(%s).toType(at::k%s);\n",
+                output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
         fprintf(cppfp, "    copy_mat2tensor(%s_t, %s, (size_t)%du);\n", output_name.c_str(), output_name.c_str(), type_to_elemsize(r->type));
-        
+
         // unsqueeze batch index
         const int batch_index = r->params.at("__batch_index").i;
         if (batch_index != 233)

From b053653a2bc0b0203f715cc81cdfd3060397f6c8 Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Thu, 3 Oct 2024 00:17:11 +0800
Subject: [PATCH 7/9] cpp inference and validation

---
 tools/pnnx/src/save_ncnn.cpp                  | 25 +++++++++++++++----
 .../tests/ncnn/test_F_adaptive_avg_pool1d.py  |  9 ++++++-
 .../tests/ncnn/test_F_adaptive_avg_pool2d.py  |  9 +++++++
 .../tests/ncnn/test_F_adaptive_avg_pool3d.py  |  9 +++++++
 .../tests/ncnn/test_F_adaptive_max_pool1d.py  |  9 ++++++-
 .../tests/ncnn/test_F_adaptive_max_pool2d.py  |  9 +++++++
 .../tests/ncnn/test_F_adaptive_max_pool3d.py  |  9 +++++++
 tools/pnnx/tests/ncnn/test_F_alpha_dropout.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_avg_pool1d.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_avg_pool2d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_avg_pool3d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_batch_norm.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_celu.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_conv1d.py        |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_conv2d.py        |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_conv3d.py        |  8 +++++-
 .../tests/ncnn/test_F_conv_transpose1d.py     |  8 +++++-
 .../tests/ncnn/test_F_conv_transpose2d.py     |  8 +++++-
 .../tests/ncnn/test_F_conv_transpose3d.py     |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_dropout.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_dropout2d.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_dropout3d.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_elu.py           |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_embedding.py     |  8 +++++-
 .../ncnn/test_F_feature_alpha_dropout.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_fold.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_gelu.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_glu.py           |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_grid_sample.py   |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_group_norm.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_hardsigmoid.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_hardswish.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_hardtanh.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_interpolate.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_layer_norm.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_leaky_relu.py    |  8 ++++++
 .../tests/ncnn/test_F_local_response_norm.py  |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_log_softmax.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_logsigmoid.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_max_pool1d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_max_pool2d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_max_pool3d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_mish.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_normalize.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_pad.py           |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_pixel_shuffle.py |  8 +++++-
 .../pnnx/tests/ncnn/test_F_pixel_unshuffle.py |  8 +++++-
 tools/pnnx/tests/ncnn/test_F_prelu.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_relu.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_relu6.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_rms_norm.py      | 10 +++++++-
 tools/pnnx/tests/ncnn/test_F_selu.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_sigmoid.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_silu.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_softmax.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_tanh.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_unfold.py        |  8 ++++++
 tools/pnnx/tests/ncnn/test_F_upsample.py      |  8 ++++++
 .../tests/ncnn/test_F_upsample_bilinear.py    |  8 +++++-
 .../tests/ncnn/test_F_upsample_nearest.py     |  8 ++++++
 .../pnnx/tests/ncnn/test_Tensor_contiguous.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_Tensor_permute.py  |  8 ++++++
 tools/pnnx/tests/ncnn/test_Tensor_repeat.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_Tensor_reshape.py  |  8 ++++++
 tools/pnnx/tests/ncnn/test_Tensor_slice.py    |  8 ++++++
 .../pnnx/tests/ncnn/test_Tensor_slice_copy.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_Tensor_view.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_convnext_tiny.py   |  8 +++++-
 tools/pnnx/tests/ncnn/test_mobilenet_v2.py    |  8 +++++-
 .../tests/ncnn/test_mobilenet_v3_small.py     |  8 +++++-
 .../ncnn/test_ncnn_fuse_binaryop_eltwise.py   |  8 ++++++
 .../test_ncnn_fuse_shufflechannel_slice.py    |  8 ++++++
 .../ncnn/test_ncnn_fuse_transpose_matmul.py   |  8 ++++++
 .../test_ncnn_numpy_binaryop_broadcast.py     | 11 ++++++++
 .../tests/ncnn/test_nn_AdaptiveAvgPool1d.py   |  9 ++++++-
 .../tests/ncnn/test_nn_AdaptiveAvgPool2d.py   |  9 +++++++
 .../tests/ncnn/test_nn_AdaptiveAvgPool3d.py   |  9 +++++++
 .../tests/ncnn/test_nn_AdaptiveMaxPool1d.py   |  9 ++++++-
 .../tests/ncnn/test_nn_AdaptiveMaxPool2d.py   |  9 ++++++-
 .../tests/ncnn/test_nn_AdaptiveMaxPool3d.py   |  9 +++++++
 tools/pnnx/tests/ncnn/test_nn_AlphaDropout.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_AvgPool1d.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_AvgPool2d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_AvgPool3d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_BatchNorm1d.py  |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_BatchNorm2d.py  |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_BatchNorm3d.py  |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_CELU.py         |  8 ++++++
 .../pnnx/tests/ncnn/test_nn_ChannelShuffle.py |  8 +++++-
 .../pnnx/tests/ncnn/test_nn_ConstantPad1d.py  |  8 +++++-
 .../pnnx/tests/ncnn/test_nn_ConstantPad2d.py  |  8 +++++-
 .../pnnx/tests/ncnn/test_nn_ConstantPad3d.py  |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Conv1d.py       |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Conv2d.py       |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Conv3d.py       |  8 +++++-
 .../tests/ncnn/test_nn_ConvTranspose1d.py     |  8 +++++-
 .../tests/ncnn/test_nn_ConvTranspose2d.py     |  8 +++++-
 .../tests/ncnn/test_nn_ConvTranspose3d.py     |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Dropout.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Dropout2d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Dropout3d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_ELU.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Embedding.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Fold.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_GELU.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_GLU.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_GRU.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_GroupNorm.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Hardsigmoid.py  |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Hardswish.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Hardtanh.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Identity.py     |  8 ++++++
 .../pnnx/tests/ncnn/test_nn_InstanceNorm2d.py |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_LSTM.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_LayerNorm.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_LeakyReLU.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Linear.py       |  8 ++++++
 .../tests/ncnn/test_nn_LocalResponseNorm.py   | 12 ++++++---
 tools/pnnx/tests/ncnn/test_nn_LogSigmoid.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_LogSoftmax.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_MaxPool1d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_MaxPool2d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_MaxPool3d.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Mish.py         |  8 ++++++
 .../tests/ncnn/test_nn_MultiheadAttention.py  |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_PReLU.py        |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_PixelShuffle.py | 12 ++++++---
 .../pnnx/tests/ncnn/test_nn_PixelUnshuffle.py | 12 ++++++---
 tools/pnnx/tests/ncnn/test_nn_RMSNorm.py      | 10 +++++++-
 tools/pnnx/tests/ncnn/test_nn_RNN.py          |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_ReLU.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_ReLU6.py        |  8 ++++++
 .../tests/ncnn/test_nn_ReflectionPad1d.py     |  8 +++++-
 .../tests/ncnn/test_nn_ReflectionPad2d.py     |  8 +++++-
 .../tests/ncnn/test_nn_ReplicationPad1d.py    |  8 +++++-
 .../tests/ncnn/test_nn_ReplicationPad2d.py    |  8 +++++-
 .../tests/ncnn/test_nn_ReplicationPad3d.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_SELU.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_SiLU.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Sigmoid.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Softmax.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Softmax2d.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_nn_Tanh.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Unfold.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_Upsample.py     |  8 ++++++
 .../ncnn/test_nn_UpsamplingBilinear2d.py      |  8 +++++-
 .../tests/ncnn/test_nn_UpsamplingNearest2d.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_nn_ZeroPad2d.py    |  8 +++++-
 tools/pnnx/tests/ncnn/test_resnet18.py        |  8 +++++-
 .../tests/ncnn/test_shufflenet_v2_x1_0.py     |  8 +++++-
 tools/pnnx/tests/ncnn/test_squeezenet1_1.py   |  8 +++++-
 tools/pnnx/tests/ncnn/test_torch_abs.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_acos.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_addmm.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_amax.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_amin.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_asin.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_atan.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_atan2.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_bmm.py       |  8 +++++-
 tools/pnnx/tests/ncnn/test_torch_cat.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_ceil.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_chunk.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_clamp.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_clone.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_cos.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_cumsum.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_diag.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_einsum.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_exp.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_floor.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_log.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_log10.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_logsumexp.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_matmul.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_max.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_maximum.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_mean.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_min.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_minimum.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_mm.py        |  8 +++++-
 tools/pnnx/tests/ncnn/test_torch_neg.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_norm.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_pow.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_prod.py      |  8 ++++++
 .../pnnx/tests/ncnn/test_torch_reciprocal.py  |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_roll.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_round.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_rsqrt.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_sin.py       |  8 ++++++
 .../tests/ncnn/test_torch_slice_scatter.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_sqrt.py      |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_square.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_squeeze.py   |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_stack.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_sum.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_t.py         |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_tan.py       |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_tanh.py      |  8 ++++++
 .../tests/ncnn/test_torch_tensor_split.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_transpose.py |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_trunc.py     |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_unbind.py    |  8 ++++++
 tools/pnnx/tests/ncnn/test_torch_unsqueeze.py |  8 ++++++
 .../ncnn/test_torchvision_DeformConv2d.py     |  8 +++++-
 tools/pnnx/tests/ncnn/test_vit_b_32.py        |  8 +++++-
 206 files changed, 1628 insertions(+), 68 deletions(-)

diff --git a/tools/pnnx/src/save_ncnn.cpp b/tools/pnnx/src/save_ncnn.cpp
index fff829ff7c9..e210afa1a20 100644
--- a/tools/pnnx/src/save_ncnn.cpp
+++ b/tools/pnnx/src/save_ncnn.cpp
@@ -72,7 +72,9 @@ static const char* type_to_libtorch_dtype_string(int type)
     if (type == 10) return "ComplexFloat";
     if (type == 11) return "ComplexDouble";
     if (type == 12) return "ComplexHalf";
-    return "null";
+
+    fprintf(stderr, "unknown type %d.\n", type);
+    return "Float";
 }
 
 static size_t type_to_elemsize(int type)
@@ -550,6 +552,16 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
     fprintf(cppfp, "    }\n");
     fprintf(cppfp, "}\n\n");
 
+    fprintf(cppfp, "at::Tensor create_tensor_from_mat(const ncnn::Mat& m)\n");
+    fprintf(cppfp, "{\n");
+    fprintf(cppfp, "    at::Tensor t;\n");
+    fprintf(cppfp, "    if (m.dims == 1) t = at::zeros({m.w});\n");
+    fprintf(cppfp, "    if (m.dims == 2) t = at::zeros({m.h, m.w});\n");
+    fprintf(cppfp, "    if (m.dims == 3) t = at::zeros({m.c, m.h, m.w});\n");
+    fprintf(cppfp, "    if (m.dims == 4) t = at::zeros({m.c, m.d, m.h, m.w});\n");
+    fprintf(cppfp, "    return t;\n");
+    fprintf(cppfp, "}\n\n");
+
     // test inference
 
     fprintf(cppfp, "int main(int argc, char** argv)\n");
@@ -622,11 +634,14 @@ int save_ncnn(const Graph& g, const std::string& parampath, const std::string& b
         fprintf(cppfp, "    ncnn::Mat %s;\n", output_name.c_str());
         fprintf(cppfp, "    ex.extract(\"%s\", %s);\n", output_name.c_str(), output_name.c_str());
 
-        // TODO unsqueeze
-
-        fprintf(cppfp, "    at::Tensor %s_t = at::zeros({%s.c, %s.d, %s.h, %s.w}, at::TensorOptions().dtype(at::k%s));\n", 
-            output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
+        fprintf(cppfp, "    at::Tensor %s_t = create_tensor_from_mat(%s).toType(at::k%s);\n", 
+            output_name.c_str(), output_name.c_str(), type_to_libtorch_dtype_string(r->type));
         fprintf(cppfp, "    copy_mat2tensor(%s_t, %s, (size_t)%du);\n", output_name.c_str(), output_name.c_str(), type_to_elemsize(r->type));
+        
+        // unsqueeze batch index
+        const int batch_index = r->params.at("__batch_index").i;
+        if (batch_index != 233)
+            fprintf(cppfp, "    %s_t = %s_t.unsqueeze(%d);\n", output_name.c_str(), output_name.c_str(), batch_index);
     }
 
     fprintf(cppfp, "    torch::save({");
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool1d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool1d.py
index 62cc4508691..fa05f286e03 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool1d.py
@@ -46,9 +46,16 @@ def test():
     import test_F_adaptive_avg_pool1d_ncnn
     b = test_F_adaptive_avg_pool1d_ncnn.test_inference()
 
+    # ncnn cpp inference
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_avg_pool1d_ncnn && make")
+    os.system("./build/test_F_adaptive_avg_pool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
     b = b.reshape_as(a)
+    c = c.reshape_as(a)
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool2d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool2d.py
index 449e10b125b..3be8391fb30 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool2d.py
@@ -48,10 +48,19 @@ def test():
     import test_F_adaptive_avg_pool2d_ncnn
     b = test_F_adaptive_avg_pool2d_ncnn.test_inference()
 
+    # ncnn cpp inference
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_avg_pool2d_ncnn && make")
+    os.system("./build/test_F_adaptive_avg_pool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool3d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool3d.py
index a4bd1c7a0a7..46d6b176da5 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_avg_pool3d.py
@@ -48,10 +48,19 @@ def test():
     import test_F_adaptive_avg_pool3d_ncnn
     b = test_F_adaptive_avg_pool3d_ncnn.test_inference()
 
+    # ncnn cpp inference
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_avg_pool3d_ncnn && make")
+    os.system("./build/test_F_adaptive_avg_pool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool1d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool1d.py
index dfef51ac6e4..b664de85323 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool1d.py
@@ -46,9 +46,16 @@ def test():
     import test_F_adaptive_max_pool1d_ncnn
     b = test_F_adaptive_max_pool1d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_max_pool1d_ncnn && make")
+    os.system("./build/test_F_adaptive_max_pool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
     b = b.reshape_as(a)
+    c = c.reshape_as(a)
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool2d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool2d.py
index 6c6b006cbcc..2c9dc1f6782 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool2d.py
@@ -48,10 +48,19 @@ def test():
     import test_F_adaptive_max_pool2d_ncnn
     b = test_F_adaptive_max_pool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_max_pool2d_ncnn && make")
+    os.system("./build/test_F_adaptive_max_pool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool3d.py b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool3d.py
index 20560605305..63178c85841 100644
--- a/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_adaptive_max_pool3d.py
@@ -48,10 +48,19 @@ def test():
     import test_F_adaptive_max_pool3d_ncnn
     b = test_F_adaptive_max_pool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_adaptive_max_pool3d_ncnn && make")
+    os.system("./build/test_F_adaptive_max_pool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_alpha_dropout.py b/tools/pnnx/tests/ncnn/test_F_alpha_dropout.py
index de8181c19c0..707eb406525 100644
--- a/tools/pnnx/tests/ncnn/test_F_alpha_dropout.py
+++ b/tools/pnnx/tests/ncnn/test_F_alpha_dropout.py
@@ -55,9 +55,17 @@ def test():
     import test_F_alpha_dropout_ncnn
     b = test_F_alpha_dropout_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_alpha_dropout_ncnn && make")
+    os.system("./build/test_F_alpha_dropout_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_avg_pool1d.py b/tools/pnnx/tests/ncnn/test_F_avg_pool1d.py
index fedaf6ababd..677bbcdd464 100644
--- a/tools/pnnx/tests/ncnn/test_F_avg_pool1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_avg_pool1d.py
@@ -51,7 +51,13 @@ def test():
     import test_F_avg_pool1d_ncnn
     b = test_F_avg_pool1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_avg_pool1d_ncnn && make")
+    os.system("./build/test_F_avg_pool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_avg_pool2d.py b/tools/pnnx/tests/ncnn/test_F_avg_pool2d.py
index 22085f14611..bdf50b72024 100644
--- a/tools/pnnx/tests/ncnn/test_F_avg_pool2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_avg_pool2d.py
@@ -61,9 +61,17 @@ def test():
     import test_F_avg_pool2d_ncnn
     b = test_F_avg_pool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_avg_pool2d_ncnn && make")
+    os.system("./build/test_F_avg_pool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_avg_pool3d.py b/tools/pnnx/tests/ncnn/test_F_avg_pool3d.py
index 31f370882a8..e24879860a9 100644
--- a/tools/pnnx/tests/ncnn/test_F_avg_pool3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_avg_pool3d.py
@@ -61,9 +61,17 @@ def test():
     import test_F_avg_pool3d_ncnn
     b = test_F_avg_pool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_avg_pool3d_ncnn && make")
+    os.system("./build/test_F_avg_pool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_batch_norm.py b/tools/pnnx/tests/ncnn/test_F_batch_norm.py
index b4b85e6b09d..914446bdc0f 100644
--- a/tools/pnnx/tests/ncnn/test_F_batch_norm.py
+++ b/tools/pnnx/tests/ncnn/test_F_batch_norm.py
@@ -64,9 +64,17 @@ def test():
     import test_F_batch_norm_ncnn
     b = test_F_batch_norm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_batch_norm_ncnn && make")
+    os.system("./build/test_F_batch_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_celu.py b/tools/pnnx/tests/ncnn/test_F_celu.py
index da7f879dc39..f842d5a1ef1 100644
--- a/tools/pnnx/tests/ncnn/test_F_celu.py
+++ b/tools/pnnx/tests/ncnn/test_F_celu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_celu_ncnn
     b = test_F_celu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_celu_ncnn && make")
+    os.system("./build/test_F_celu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_conv1d.py b/tools/pnnx/tests/ncnn/test_F_conv1d.py
index c6ca2019447..55f9b87f98a 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv1d.py
@@ -61,7 +61,13 @@ def test():
     import test_F_conv1d_ncnn
     b0, b1 = test_F_conv1d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv1d_ncnn && make")
+    os.system("./build/test_F_conv1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_conv2d.py b/tools/pnnx/tests/ncnn/test_F_conv2d.py
index 20dd1c9527a..3383516215f 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv2d.py
@@ -61,7 +61,13 @@ def test():
     import test_F_conv2d_ncnn
     b0, b1 = test_F_conv2d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv2d_ncnn && make")
+    os.system("./build/test_F_conv2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_conv3d.py b/tools/pnnx/tests/ncnn/test_F_conv3d.py
index 36f2518b3d2..c6d3101c02d 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv3d.py
@@ -50,7 +50,13 @@ def test():
     import test_F_conv3d_ncnn
     b = test_F_conv3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv3d_ncnn && make")
+    os.system("./build/test_F_conv3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_conv_transpose1d.py b/tools/pnnx/tests/ncnn/test_F_conv_transpose1d.py
index ff23f77ab27..5fa3b80c405 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv_transpose1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv_transpose1d.py
@@ -57,7 +57,13 @@ def test():
     import test_F_conv_transpose1d_ncnn
     b0, b1 = test_F_conv_transpose1d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv_transpose1d_ncnn && make")
+    os.system("./build/test_F_conv_transpose1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_conv_transpose2d.py b/tools/pnnx/tests/ncnn/test_F_conv_transpose2d.py
index 5913f07ab02..3b721ecd48c 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv_transpose2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv_transpose2d.py
@@ -57,7 +57,13 @@ def test():
     import test_F_conv_transpose2d_ncnn
     b0, b1 = test_F_conv_transpose2d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv_transpose2d_ncnn && make")
+    os.system("./build/test_F_conv_transpose2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_conv_transpose3d.py b/tools/pnnx/tests/ncnn/test_F_conv_transpose3d.py
index a75d5e0a09f..38e2fc0d9a5 100644
--- a/tools/pnnx/tests/ncnn/test_F_conv_transpose3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_conv_transpose3d.py
@@ -50,7 +50,13 @@ def test():
     import test_F_conv_transpose3d_ncnn
     b = test_F_conv_transpose3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_conv_transpose3d_ncnn && make")
+    os.system("./build/test_F_conv_transpose3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_dropout.py b/tools/pnnx/tests/ncnn/test_F_dropout.py
index 56c2cff2157..3a2ded17ae6 100644
--- a/tools/pnnx/tests/ncnn/test_F_dropout.py
+++ b/tools/pnnx/tests/ncnn/test_F_dropout.py
@@ -55,9 +55,17 @@ def test():
     import test_F_dropout_ncnn
     b = test_F_dropout_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_dropout_ncnn && make")
+    os.system("./build/test_F_dropout_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_dropout2d.py b/tools/pnnx/tests/ncnn/test_F_dropout2d.py
index d8e013d185a..5e92fdaa085 100644
--- a/tools/pnnx/tests/ncnn/test_F_dropout2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_dropout2d.py
@@ -49,9 +49,17 @@ def test():
     import test_F_dropout2d_ncnn
     b = test_F_dropout2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_dropout2d_ncnn && make")
+    os.system("./build/test_F_dropout2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_dropout3d.py b/tools/pnnx/tests/ncnn/test_F_dropout3d.py
index 5a7c9e5187a..e88eb544e97 100644
--- a/tools/pnnx/tests/ncnn/test_F_dropout3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_dropout3d.py
@@ -49,9 +49,17 @@ def test():
     import test_F_dropout3d_ncnn
     b = test_F_dropout3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_dropout3d_ncnn && make")
+    os.system("./build/test_F_dropout3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_elu.py b/tools/pnnx/tests/ncnn/test_F_elu.py
index a5693aa6bd5..f7b87cac2e7 100644
--- a/tools/pnnx/tests/ncnn/test_F_elu.py
+++ b/tools/pnnx/tests/ncnn/test_F_elu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_elu_ncnn
     b = test_F_elu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_elu_ncnn && make")
+    os.system("./build/test_F_elu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_embedding.py b/tools/pnnx/tests/ncnn/test_F_embedding.py
index 41a565a1f56..788d7c7b131 100644
--- a/tools/pnnx/tests/ncnn/test_F_embedding.py
+++ b/tools/pnnx/tests/ncnn/test_F_embedding.py
@@ -47,7 +47,13 @@ def test():
     import test_F_embedding_ncnn
     b = test_F_embedding_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_embedding_ncnn && make")
+    os.system("./build/test_F_embedding_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_feature_alpha_dropout.py b/tools/pnnx/tests/ncnn/test_F_feature_alpha_dropout.py
index b0de4e5c6f8..b642f6b2aa1 100644
--- a/tools/pnnx/tests/ncnn/test_F_feature_alpha_dropout.py
+++ b/tools/pnnx/tests/ncnn/test_F_feature_alpha_dropout.py
@@ -49,9 +49,17 @@ def test():
     import test_F_feature_alpha_dropout_ncnn
     b = test_F_feature_alpha_dropout_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_feature_alpha_dropout_ncnn && make")
+    os.system("./build/test_F_feature_alpha_dropout_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_fold.py b/tools/pnnx/tests/ncnn/test_F_fold.py
index 54103fdf261..682def13d1c 100644
--- a/tools/pnnx/tests/ncnn/test_F_fold.py
+++ b/tools/pnnx/tests/ncnn/test_F_fold.py
@@ -51,9 +51,17 @@ def test():
     import test_F_fold_ncnn
     b = test_F_fold_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_fold_ncnn && make")
+    os.system("./build/test_F_fold_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_gelu.py b/tools/pnnx/tests/ncnn/test_F_gelu.py
index 0a99e1fc8ee..dc6248d76ee 100644
--- a/tools/pnnx/tests/ncnn/test_F_gelu.py
+++ b/tools/pnnx/tests/ncnn/test_F_gelu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_gelu_ncnn
     b = test_F_gelu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_gelu_ncnn && make")
+    os.system("./build/test_F_gelu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_glu.py b/tools/pnnx/tests/ncnn/test_F_glu.py
index 937253c1279..7ce7d756b29 100644
--- a/tools/pnnx/tests/ncnn/test_F_glu.py
+++ b/tools/pnnx/tests/ncnn/test_F_glu.py
@@ -53,9 +53,17 @@ def test():
     import test_F_glu_ncnn
     b = test_F_glu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_glu_ncnn && make")
+    os.system("./build/test_F_glu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_grid_sample.py b/tools/pnnx/tests/ncnn/test_F_grid_sample.py
index 95ca812eb51..1237ffb9ae6 100644
--- a/tools/pnnx/tests/ncnn/test_F_grid_sample.py
+++ b/tools/pnnx/tests/ncnn/test_F_grid_sample.py
@@ -103,7 +103,13 @@ def test():
     import test_F_grid_sample_ncnn
     b0, b1, b2, b3 = test_F_grid_sample_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-6, 1e-6) and torch.allclose(a1, b1, 1e-6, 1e-6) and torch.allclose(a2, b2, 1e-6, 1e-6) and torch.allclose(a3, b3, 1e-6, 1e-6)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_grid_sample_ncnn && make")
+    os.system("./build/test_F_grid_sample_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1, c2, c3 = c
+
+    return torch.allclose(a0, b0, 1e-6, 1e-6) and torch.allclose(a0, c0, 1e-6, 1e-6) and torch.allclose(a1, b1, 1e-6, 1e-6) and torch.allclose(a1, c1, 1e-6, 1e-6) and torch.allclose(a2, b2, 1e-6, 1e-6) and torch.allclose(a2, c2, 1e-6, 1e-6) and torch.allclose(a3, b3, 1e-6, 1e-6) and torch.allclose(a3, c3, 1e-6, 1e-6)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_group_norm.py b/tools/pnnx/tests/ncnn/test_F_group_norm.py
index 6b034795045..bd180a62890 100644
--- a/tools/pnnx/tests/ncnn/test_F_group_norm.py
+++ b/tools/pnnx/tests/ncnn/test_F_group_norm.py
@@ -56,9 +56,17 @@ def test():
     import test_F_group_norm_ncnn
     b = test_F_group_norm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_group_norm_ncnn && make")
+    os.system("./build/test_F_group_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_hardsigmoid.py b/tools/pnnx/tests/ncnn/test_F_hardsigmoid.py
index 0636575f2d4..d3ec665cdda 100644
--- a/tools/pnnx/tests/ncnn/test_F_hardsigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_F_hardsigmoid.py
@@ -58,9 +58,17 @@ def test():
     import test_F_hardsigmoid_ncnn
     b = test_F_hardsigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_hardsigmoid_ncnn && make")
+    os.system("./build/test_F_hardsigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_hardswish.py b/tools/pnnx/tests/ncnn/test_F_hardswish.py
index 30fccc477a2..0e7c17fab21 100644
--- a/tools/pnnx/tests/ncnn/test_F_hardswish.py
+++ b/tools/pnnx/tests/ncnn/test_F_hardswish.py
@@ -65,9 +65,17 @@ def test():
     import test_F_hardswish_ncnn
     b = test_F_hardswish_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_hardswish_ncnn && make")
+    os.system("./build/test_F_hardswish_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_hardtanh.py b/tools/pnnx/tests/ncnn/test_F_hardtanh.py
index 95c0c2aa16f..443df638221 100644
--- a/tools/pnnx/tests/ncnn/test_F_hardtanh.py
+++ b/tools/pnnx/tests/ncnn/test_F_hardtanh.py
@@ -55,9 +55,17 @@ def test():
     import test_F_hardtanh_ncnn
     b = test_F_hardtanh_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_hardtanh_ncnn && make")
+    os.system("./build/test_F_hardtanh_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_interpolate.py b/tools/pnnx/tests/ncnn/test_F_interpolate.py
index 691e4379d2c..ec08fc07987 100644
--- a/tools/pnnx/tests/ncnn/test_F_interpolate.py
+++ b/tools/pnnx/tests/ncnn/test_F_interpolate.py
@@ -85,9 +85,17 @@ def test():
     import test_F_interpolate_ncnn
     b = test_F_interpolate_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_interpolate_ncnn && make")
+    os.system("./build/test_F_interpolate_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_layer_norm.py b/tools/pnnx/tests/ncnn/test_F_layer_norm.py
index 9d590aa76dd..83514bd272e 100644
--- a/tools/pnnx/tests/ncnn/test_F_layer_norm.py
+++ b/tools/pnnx/tests/ncnn/test_F_layer_norm.py
@@ -54,9 +54,17 @@ def test():
     import test_F_layer_norm_ncnn
     b = test_F_layer_norm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_layer_norm_ncnn && make")
+    os.system("./build/test_F_layer_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_leaky_relu.py b/tools/pnnx/tests/ncnn/test_F_leaky_relu.py
index 4606ddce203..a7d2af14141 100644
--- a/tools/pnnx/tests/ncnn/test_F_leaky_relu.py
+++ b/tools/pnnx/tests/ncnn/test_F_leaky_relu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_leaky_relu_ncnn
     b = test_F_leaky_relu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_leaky_relu_ncnn && make")
+    os.system("./build/test_F_leaky_relu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_local_response_norm.py b/tools/pnnx/tests/ncnn/test_F_local_response_norm.py
index 9c92eb9c788..bc03ab65050 100644
--- a/tools/pnnx/tests/ncnn/test_F_local_response_norm.py
+++ b/tools/pnnx/tests/ncnn/test_F_local_response_norm.py
@@ -46,7 +46,13 @@ def test():
     import test_F_local_response_norm_ncnn
     b = test_F_local_response_norm_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_local_response_norm_ncnn && make")
+    os.system("./build/test_F_local_response_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_log_softmax.py b/tools/pnnx/tests/ncnn/test_F_log_softmax.py
index 4b0d295f664..c13cefb8b56 100644
--- a/tools/pnnx/tests/ncnn/test_F_log_softmax.py
+++ b/tools/pnnx/tests/ncnn/test_F_log_softmax.py
@@ -55,9 +55,17 @@ def test():
     import test_F_log_softmax_ncnn
     b = test_F_log_softmax_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_log_softmax_ncnn && make")
+    os.system("./build/test_F_log_softmax_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_logsigmoid.py b/tools/pnnx/tests/ncnn/test_F_logsigmoid.py
index 7d2b304a7b2..636410a8555 100644
--- a/tools/pnnx/tests/ncnn/test_F_logsigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_F_logsigmoid.py
@@ -55,9 +55,17 @@ def test():
     import test_F_logsigmoid_ncnn
     b = test_F_logsigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_logsigmoid_ncnn && make")
+    os.system("./build/test_F_logsigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_max_pool1d.py b/tools/pnnx/tests/ncnn/test_F_max_pool1d.py
index 50eca9c1ce4..bf7d58c1297 100644
--- a/tools/pnnx/tests/ncnn/test_F_max_pool1d.py
+++ b/tools/pnnx/tests/ncnn/test_F_max_pool1d.py
@@ -62,9 +62,17 @@ def test():
     import test_F_max_pool1d_ncnn
     b = test_F_max_pool1d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_max_pool1d_ncnn && make")
+    os.system("./build/test_F_max_pool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_max_pool2d.py b/tools/pnnx/tests/ncnn/test_F_max_pool2d.py
index b3ad4c8d17a..7e848645ee6 100644
--- a/tools/pnnx/tests/ncnn/test_F_max_pool2d.py
+++ b/tools/pnnx/tests/ncnn/test_F_max_pool2d.py
@@ -62,9 +62,17 @@ def test():
     import test_F_max_pool2d_ncnn
     b = test_F_max_pool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_max_pool2d_ncnn && make")
+    os.system("./build/test_F_max_pool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_max_pool3d.py b/tools/pnnx/tests/ncnn/test_F_max_pool3d.py
index 7708ffe9a86..2561182269f 100644
--- a/tools/pnnx/tests/ncnn/test_F_max_pool3d.py
+++ b/tools/pnnx/tests/ncnn/test_F_max_pool3d.py
@@ -61,9 +61,17 @@ def test():
     import test_F_max_pool3d_ncnn
     b = test_F_max_pool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_max_pool3d_ncnn && make")
+    os.system("./build/test_F_max_pool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_mish.py b/tools/pnnx/tests/ncnn/test_F_mish.py
index 7d94cee80c4..59e5b4878a3 100644
--- a/tools/pnnx/tests/ncnn/test_F_mish.py
+++ b/tools/pnnx/tests/ncnn/test_F_mish.py
@@ -65,9 +65,17 @@ def test():
     import test_F_mish_ncnn
     b = test_F_mish_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_mish_ncnn && make")
+    os.system("./build/test_F_mish_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_normalize.py b/tools/pnnx/tests/ncnn/test_F_normalize.py
index c39eaf03c71..73ab730550b 100644
--- a/tools/pnnx/tests/ncnn/test_F_normalize.py
+++ b/tools/pnnx/tests/ncnn/test_F_normalize.py
@@ -50,9 +50,17 @@ def test():
     import test_F_normalize_ncnn
     b = test_F_normalize_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_normalize_ncnn && make")
+    os.system("./build/test_F_normalize_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_pad.py b/tools/pnnx/tests/ncnn/test_F_pad.py
index 88590649883..3cca423c151 100644
--- a/tools/pnnx/tests/ncnn/test_F_pad.py
+++ b/tools/pnnx/tests/ncnn/test_F_pad.py
@@ -59,9 +59,17 @@ def test():
     import test_F_pad_ncnn
     b = test_F_pad_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_pad_ncnn && make")
+    os.system("./build/test_F_pad_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_pixel_shuffle.py b/tools/pnnx/tests/ncnn/test_F_pixel_shuffle.py
index 6149b843c58..82679a2c5ea 100644
--- a/tools/pnnx/tests/ncnn/test_F_pixel_shuffle.py
+++ b/tools/pnnx/tests/ncnn/test_F_pixel_shuffle.py
@@ -46,7 +46,13 @@ def test():
     import test_F_pixel_shuffle_ncnn
     b = test_F_pixel_shuffle_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_pixel_shuffle_ncnn && make")
+    os.system("./build/test_F_pixel_shuffle_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_pixel_unshuffle.py b/tools/pnnx/tests/ncnn/test_F_pixel_unshuffle.py
index 2652ba998cc..dcb3daad65a 100644
--- a/tools/pnnx/tests/ncnn/test_F_pixel_unshuffle.py
+++ b/tools/pnnx/tests/ncnn/test_F_pixel_unshuffle.py
@@ -46,7 +46,13 @@ def test():
     import test_F_pixel_unshuffle_ncnn
     b = test_F_pixel_unshuffle_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_pixel_unshuffle_ncnn && make")
+    os.system("./build/test_F_pixel_unshuffle_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_prelu.py b/tools/pnnx/tests/ncnn/test_F_prelu.py
index fc06db52be9..de2db642fc1 100644
--- a/tools/pnnx/tests/ncnn/test_F_prelu.py
+++ b/tools/pnnx/tests/ncnn/test_F_prelu.py
@@ -58,9 +58,17 @@ def test():
     import test_F_prelu_ncnn
     b = test_F_prelu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_prelu_ncnn && make")
+    os.system("./build/test_F_prelu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_relu.py b/tools/pnnx/tests/ncnn/test_F_relu.py
index b4fad8237a0..ec6bc01f6b9 100644
--- a/tools/pnnx/tests/ncnn/test_F_relu.py
+++ b/tools/pnnx/tests/ncnn/test_F_relu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_relu_ncnn
     b = test_F_relu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_relu_ncnn && make")
+    os.system("./build/test_F_relu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_relu6.py b/tools/pnnx/tests/ncnn/test_F_relu6.py
index e93de557bf6..6eb4b67b174 100644
--- a/tools/pnnx/tests/ncnn/test_F_relu6.py
+++ b/tools/pnnx/tests/ncnn/test_F_relu6.py
@@ -55,9 +55,17 @@ def test():
     import test_F_relu6_ncnn
     b = test_F_relu6_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_relu6_ncnn && make")
+    os.system("./build/test_F_relu6_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_rms_norm.py b/tools/pnnx/tests/ncnn/test_F_rms_norm.py
index f30f72f9ac4..aa0d0f79909 100644
--- a/tools/pnnx/tests/ncnn/test_F_rms_norm.py
+++ b/tools/pnnx/tests/ncnn/test_F_rms_norm.py
@@ -56,8 +56,16 @@ def test():
     import test_F_rms_norm_ncnn
     b = test_F_rms_norm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_rms_norm_ncnn && make")
+    os.system("./build/test_F_rms_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
-        if not torch.allclose(a0, b0, 1e-3, 1e-3):
+        if not torch.allclose(a0, b0, 1e-4, 1e-4):
+            return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
             return False
     return True
 
diff --git a/tools/pnnx/tests/ncnn/test_F_selu.py b/tools/pnnx/tests/ncnn/test_F_selu.py
index 210b572cdbe..cd7d69d2a14 100644
--- a/tools/pnnx/tests/ncnn/test_F_selu.py
+++ b/tools/pnnx/tests/ncnn/test_F_selu.py
@@ -55,9 +55,17 @@ def test():
     import test_F_selu_ncnn
     b = test_F_selu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_selu_ncnn && make")
+    os.system("./build/test_F_selu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_sigmoid.py b/tools/pnnx/tests/ncnn/test_F_sigmoid.py
index f5e0f39d6e1..438ca659e0b 100644
--- a/tools/pnnx/tests/ncnn/test_F_sigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_F_sigmoid.py
@@ -55,9 +55,17 @@ def test():
     import test_F_sigmoid_ncnn
     b = test_F_sigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_sigmoid_ncnn && make")
+    os.system("./build/test_F_sigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_silu.py b/tools/pnnx/tests/ncnn/test_F_silu.py
index 78b75ac57cc..014608c3ecd 100644
--- a/tools/pnnx/tests/ncnn/test_F_silu.py
+++ b/tools/pnnx/tests/ncnn/test_F_silu.py
@@ -58,9 +58,17 @@ def test():
     import test_F_silu_ncnn
     b = test_F_silu_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_silu_ncnn && make")
+    os.system("./build/test_F_silu_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_softmax.py b/tools/pnnx/tests/ncnn/test_F_softmax.py
index 12a8cada60a..01ed7fd5d8f 100644
--- a/tools/pnnx/tests/ncnn/test_F_softmax.py
+++ b/tools/pnnx/tests/ncnn/test_F_softmax.py
@@ -55,9 +55,17 @@ def test():
     import test_F_softmax_ncnn
     b = test_F_softmax_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_softmax_ncnn && make")
+    os.system("./build/test_F_softmax_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_tanh.py b/tools/pnnx/tests/ncnn/test_F_tanh.py
index 3ae1b598ed1..6227265f155 100644
--- a/tools/pnnx/tests/ncnn/test_F_tanh.py
+++ b/tools/pnnx/tests/ncnn/test_F_tanh.py
@@ -55,9 +55,17 @@ def test():
     import test_F_tanh_ncnn
     b = test_F_tanh_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_tanh_ncnn && make")
+    os.system("./build/test_F_tanh_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_unfold.py b/tools/pnnx/tests/ncnn/test_F_unfold.py
index e8e1a603cc3..14250b22425 100644
--- a/tools/pnnx/tests/ncnn/test_F_unfold.py
+++ b/tools/pnnx/tests/ncnn/test_F_unfold.py
@@ -49,9 +49,17 @@ def test():
     import test_F_unfold_ncnn
     b = test_F_unfold_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_unfold_ncnn && make")
+    os.system("./build/test_F_unfold_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_upsample.py b/tools/pnnx/tests/ncnn/test_F_upsample.py
index 473ab407d8c..154c61f21a0 100644
--- a/tools/pnnx/tests/ncnn/test_F_upsample.py
+++ b/tools/pnnx/tests/ncnn/test_F_upsample.py
@@ -76,9 +76,17 @@ def test():
     import test_F_upsample_ncnn
     b = test_F_upsample_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_upsample_ncnn && make")
+    os.system("./build/test_F_upsample_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_F_upsample_bilinear.py b/tools/pnnx/tests/ncnn/test_F_upsample_bilinear.py
index 178794ecaa7..966f39b1657 100644
--- a/tools/pnnx/tests/ncnn/test_F_upsample_bilinear.py
+++ b/tools/pnnx/tests/ncnn/test_F_upsample_bilinear.py
@@ -46,7 +46,13 @@ def test():
     import test_F_upsample_bilinear_ncnn
     b = test_F_upsample_bilinear_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_upsample_bilinear_ncnn && make")
+    os.system("./build/test_F_upsample_bilinear_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_F_upsample_nearest.py b/tools/pnnx/tests/ncnn/test_F_upsample_nearest.py
index 78f6e656327..e0678982be7 100644
--- a/tools/pnnx/tests/ncnn/test_F_upsample_nearest.py
+++ b/tools/pnnx/tests/ncnn/test_F_upsample_nearest.py
@@ -49,9 +49,17 @@ def test():
     import test_F_upsample_nearest_ncnn
     b = test_F_upsample_nearest_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_F_upsample_nearest_ncnn && make")
+    os.system("./build/test_F_upsample_nearest_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_contiguous.py b/tools/pnnx/tests/ncnn/test_Tensor_contiguous.py
index 667968a9d0c..45844e6de75 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_contiguous.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_contiguous.py
@@ -52,9 +52,17 @@ def test():
     import test_Tensor_contiguous_ncnn
     b = test_Tensor_contiguous_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_contiguous_ncnn && make")
+    os.system("./build/test_Tensor_contiguous_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_permute.py b/tools/pnnx/tests/ncnn/test_Tensor_permute.py
index 01506f42c34..94bdb12b930 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_permute.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_permute.py
@@ -56,9 +56,17 @@ def test():
     import test_Tensor_permute_ncnn
     b = test_Tensor_permute_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_permute_ncnn && make")
+    os.system("./build/test_Tensor_permute_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_repeat.py b/tools/pnnx/tests/ncnn/test_Tensor_repeat.py
index ad26ea85635..46d2bc6aa7f 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_repeat.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_repeat.py
@@ -52,9 +52,17 @@ def test():
     import test_Tensor_repeat_ncnn
     b = test_Tensor_repeat_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_repeat_ncnn && make")
+    os.system("./build/test_Tensor_repeat_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_reshape.py b/tools/pnnx/tests/ncnn/test_Tensor_reshape.py
index af5eca8f97e..a09ac35ca1f 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_reshape.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_reshape.py
@@ -55,9 +55,17 @@ def test():
     import test_Tensor_reshape_ncnn
     b = test_Tensor_reshape_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_reshape_ncnn && make")
+    os.system("./build/test_Tensor_reshape_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_slice.py b/tools/pnnx/tests/ncnn/test_Tensor_slice.py
index 6c8ef38ab53..6408128346d 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_slice.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_slice.py
@@ -55,9 +55,17 @@ def test():
     import test_Tensor_slice_ncnn
     b = test_Tensor_slice_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_slice_ncnn && make")
+    os.system("./build/test_Tensor_slice_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_slice_copy.py b/tools/pnnx/tests/ncnn/test_Tensor_slice_copy.py
index c82a89fe573..36294057e36 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_slice_copy.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_slice_copy.py
@@ -60,9 +60,17 @@ def test():
     import test_Tensor_slice_copy_ncnn
     b = test_Tensor_slice_copy_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_slice_copy_ncnn && make")
+    os.system("./build/test_Tensor_slice_copy_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_Tensor_view.py b/tools/pnnx/tests/ncnn/test_Tensor_view.py
index 7bf967621de..aa1da32bd77 100644
--- a/tools/pnnx/tests/ncnn/test_Tensor_view.py
+++ b/tools/pnnx/tests/ncnn/test_Tensor_view.py
@@ -55,9 +55,17 @@ def test():
     import test_Tensor_view_ncnn
     b = test_Tensor_view_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_Tensor_view_ncnn && make")
+    os.system("./build/test_Tensor_view_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_convnext_tiny.py b/tools/pnnx/tests/ncnn/test_convnext_tiny.py
index 9347a3427c2..44d1c3eeae5 100644
--- a/tools/pnnx/tests/ncnn/test_convnext_tiny.py
+++ b/tools/pnnx/tests/ncnn/test_convnext_tiny.py
@@ -41,7 +41,13 @@ def test():
     import test_convnext_tiny_ncnn
     b = test_convnext_tiny_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-3, 1e-3)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_convnext_tiny_ncnn && make")
+    os.system("./build/test_convnext_tiny_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-3, 1e-3) and torch.allclose(a, c, 1e-3, 1e-3)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_mobilenet_v2.py b/tools/pnnx/tests/ncnn/test_mobilenet_v2.py
index ea6bddfca47..f2ca1668d6c 100644
--- a/tools/pnnx/tests/ncnn/test_mobilenet_v2.py
+++ b/tools/pnnx/tests/ncnn/test_mobilenet_v2.py
@@ -36,7 +36,13 @@ def test():
     import test_mobilenet_v2_ncnn
     b = test_mobilenet_v2_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-2, 1e-2)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_mobilenet_v2_ncnn && make")
+    os.system("./build/test_mobilenet_v2_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-2, 1e-2) and torch.allclose(a, c, 1e-2, 1e-2)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_mobilenet_v3_small.py b/tools/pnnx/tests/ncnn/test_mobilenet_v3_small.py
index 309f59127a4..6b2306a5090 100644
--- a/tools/pnnx/tests/ncnn/test_mobilenet_v3_small.py
+++ b/tools/pnnx/tests/ncnn/test_mobilenet_v3_small.py
@@ -36,7 +36,13 @@ def test():
     import test_mobilenet_v3_small_ncnn
     b = test_mobilenet_v3_small_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-2, 1e-2)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_mobilenet_v3_small_ncnn && make")
+    os.system("./build/test_mobilenet_v3_small_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-2, 1e-2) and torch.allclose(a, c, 1e-2, 1e-2)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_ncnn_fuse_binaryop_eltwise.py b/tools/pnnx/tests/ncnn/test_ncnn_fuse_binaryop_eltwise.py
index 549e3aa04ff..07705085f0a 100644
--- a/tools/pnnx/tests/ncnn/test_ncnn_fuse_binaryop_eltwise.py
+++ b/tools/pnnx/tests/ncnn/test_ncnn_fuse_binaryop_eltwise.py
@@ -52,9 +52,17 @@ def test():
     import test_ncnn_fuse_binaryop_eltwise_ncnn
     b = test_ncnn_fuse_binaryop_eltwise_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_ncnn_fuse_binaryop_eltwise_ncnn && make")
+    os.system("./build/test_ncnn_fuse_binaryop_eltwise_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_ncnn_fuse_shufflechannel_slice.py b/tools/pnnx/tests/ncnn/test_ncnn_fuse_shufflechannel_slice.py
index 1fc390d3d45..21f7d078b81 100644
--- a/tools/pnnx/tests/ncnn/test_ncnn_fuse_shufflechannel_slice.py
+++ b/tools/pnnx/tests/ncnn/test_ncnn_fuse_shufflechannel_slice.py
@@ -56,9 +56,17 @@ def test():
     import test_ncnn_fuse_shufflechannel_slice_ncnn
     b = test_ncnn_fuse_shufflechannel_slice_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_ncnn_fuse_shufflechannel_slice_ncnn && make")
+    os.system("./build/test_ncnn_fuse_shufflechannel_slice_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_ncnn_fuse_transpose_matmul.py b/tools/pnnx/tests/ncnn/test_ncnn_fuse_transpose_matmul.py
index 439a72269b2..ac05ab1b045 100644
--- a/tools/pnnx/tests/ncnn/test_ncnn_fuse_transpose_matmul.py
+++ b/tools/pnnx/tests/ncnn/test_ncnn_fuse_transpose_matmul.py
@@ -79,9 +79,17 @@ def test():
     import test_ncnn_fuse_transpose_matmul_ncnn
     b = test_ncnn_fuse_transpose_matmul_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_ncnn_fuse_transpose_matmul_ncnn && make")
+    os.system("./build/test_ncnn_fuse_transpose_matmul_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_ncnn_numpy_binaryop_broadcast.py b/tools/pnnx/tests/ncnn/test_ncnn_numpy_binaryop_broadcast.py
index 67946a29b60..4551a096e43 100644
--- a/tools/pnnx/tests/ncnn/test_ncnn_numpy_binaryop_broadcast.py
+++ b/tools/pnnx/tests/ncnn/test_ncnn_numpy_binaryop_broadcast.py
@@ -233,12 +233,23 @@ def test():
     import test_ncnn_numpy_binaryop_broadcast_ncnn
     b = test_ncnn_numpy_binaryop_broadcast_ncnn.test_inference()
 
+    # ncnn cpp inference
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_ncnn_numpy_binaryop_broadcast_ncnn && make")
+    os.system("./build/test_ncnn_numpy_binaryop_broadcast_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         # allclose may auto broadcast compare
         if a0.shape != b0.shape:
             return False
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        # allclose may auto broadcast compare
+        if a0.shape != c0.shape:
+            return False
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool1d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool1d.py
index cef5e052820..8f0a891ba64 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool1d.py
@@ -49,9 +49,16 @@ def test():
     import test_nn_AdaptiveAvgPool1d_ncnn
     b = test_nn_AdaptiveAvgPool1d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveAvgPool1d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveAvgPool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
     b = b.reshape_as(a)
+    c = c.reshape_as(a)
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool2d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool2d.py
index 2727ae9ea20..74f413a0d9d 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool2d.py
@@ -53,10 +53,19 @@ def test():
     import test_nn_AdaptiveAvgPool2d_ncnn
     b = test_nn_AdaptiveAvgPool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveAvgPool2d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveAvgPool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool3d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool3d.py
index 92dd9c6ca4e..c5d3f6d5a11 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveAvgPool3d.py
@@ -53,10 +53,19 @@ def test():
     import test_nn_AdaptiveAvgPool3d_ncnn
     b = test_nn_AdaptiveAvgPool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveAvgPool3d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveAvgPool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool1d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool1d.py
index 1f927a3e809..0442e4b1a62 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool1d.py
@@ -49,9 +49,16 @@ def test():
     import test_nn_AdaptiveMaxPool1d_ncnn
     b = test_nn_AdaptiveMaxPool1d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveMaxPool1d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveMaxPool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
     b = b.reshape_as(a)
+    c = c.reshape_as(a)
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool2d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool2d.py
index bfb6df26d8c..c277ed491d1 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool2d.py
@@ -49,9 +49,16 @@ def test():
     import test_nn_AdaptiveMaxPool2d_ncnn
     b = test_nn_AdaptiveMaxPool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveMaxPool2d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveMaxPool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
     b = b.reshape_as(a)
+    c = c.reshape_as(a)
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool3d.py b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool3d.py
index ef5e09e9d75..a58b013930d 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AdaptiveMaxPool3d.py
@@ -53,10 +53,19 @@ def test():
     import test_nn_AdaptiveMaxPool3d_ncnn
     b = test_nn_AdaptiveMaxPool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AdaptiveMaxPool3d_ncnn && make")
+    os.system("./build/test_nn_AdaptiveMaxPool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         b0 = b0.reshape_as(a0)
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        c0 = c0.reshape_as(a0)
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AlphaDropout.py b/tools/pnnx/tests/ncnn/test_nn_AlphaDropout.py
index f12a27f0209..c6d7d196957 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AlphaDropout.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AlphaDropout.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_AlphaDropout_ncnn
     b = test_nn_AlphaDropout_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AlphaDropout_ncnn && make")
+    os.system("./build/test_nn_AlphaDropout_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AvgPool1d.py b/tools/pnnx/tests/ncnn/test_nn_AvgPool1d.py
index 357c8b67bc8..e09bfa1eea3 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AvgPool1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AvgPool1d.py
@@ -59,7 +59,13 @@ def test():
     import test_nn_AvgPool1d_ncnn
     b = test_nn_AvgPool1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AvgPool1d_ncnn && make")
+    os.system("./build/test_nn_AvgPool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_AvgPool2d.py b/tools/pnnx/tests/ncnn/test_nn_AvgPool2d.py
index 0040d3e7607..ad6c19c2690 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AvgPool2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AvgPool2d.py
@@ -66,9 +66,17 @@ def test():
     import test_nn_AvgPool2d_ncnn
     b = test_nn_AvgPool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AvgPool2d_ncnn && make")
+    os.system("./build/test_nn_AvgPool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_AvgPool3d.py b/tools/pnnx/tests/ncnn/test_nn_AvgPool3d.py
index 3cf42ba6ac3..4cbcf5c450e 100644
--- a/tools/pnnx/tests/ncnn/test_nn_AvgPool3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_AvgPool3d.py
@@ -66,9 +66,17 @@ def test():
     import test_nn_AvgPool3d_ncnn
     b = test_nn_AvgPool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_AvgPool3d_ncnn && make")
+    os.system("./build/test_nn_AvgPool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_BatchNorm1d.py b/tools/pnnx/tests/ncnn/test_nn_BatchNorm1d.py
index 06bb0ead25a..56ff1c037c8 100644
--- a/tools/pnnx/tests/ncnn/test_nn_BatchNorm1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_BatchNorm1d.py
@@ -54,7 +54,13 @@ def test():
     import test_nn_BatchNorm1d_ncnn
     b0, b1 = test_nn_BatchNorm1d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_BatchNorm1d_ncnn && make")
+    os.system("./build/test_nn_BatchNorm1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_BatchNorm2d.py b/tools/pnnx/tests/ncnn/test_nn_BatchNorm2d.py
index 10e3b1e299b..13727b9cb69 100644
--- a/tools/pnnx/tests/ncnn/test_nn_BatchNorm2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_BatchNorm2d.py
@@ -54,7 +54,13 @@ def test():
     import test_nn_BatchNorm2d_ncnn
     b0, b1 = test_nn_BatchNorm2d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_BatchNorm2d_ncnn && make")
+    os.system("./build/test_nn_BatchNorm2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_BatchNorm3d.py b/tools/pnnx/tests/ncnn/test_nn_BatchNorm3d.py
index a2b574ac852..64b6934d5b0 100644
--- a/tools/pnnx/tests/ncnn/test_nn_BatchNorm3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_BatchNorm3d.py
@@ -54,7 +54,13 @@ def test():
     import test_nn_BatchNorm3d_ncnn
     b0, b1 = test_nn_BatchNorm3d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_BatchNorm3d_ncnn && make")
+    os.system("./build/test_nn_BatchNorm3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_CELU.py b/tools/pnnx/tests/ncnn/test_nn_CELU.py
index 36931cc3b37..812dc5b55b9 100644
--- a/tools/pnnx/tests/ncnn/test_nn_CELU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_CELU.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_CELU_ncnn
     b = test_nn_CELU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_CELU_ncnn && make")
+    os.system("./build/test_nn_CELU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ChannelShuffle.py b/tools/pnnx/tests/ncnn/test_nn_ChannelShuffle.py
index 1c31b82a678..2f30c166e37 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ChannelShuffle.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ChannelShuffle.py
@@ -53,7 +53,13 @@ def test():
     import test_nn_ChannelShuffle_ncnn
     b0, b1 = test_nn_ChannelShuffle_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ChannelShuffle_ncnn && make")
+    os.system("./build/test_nn_ChannelShuffle_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConstantPad1d.py b/tools/pnnx/tests/ncnn/test_nn_ConstantPad1d.py
index 4e30aff4482..c7734a73e93 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConstantPad1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConstantPad1d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ConstantPad1d_ncnn
     b = test_nn_ConstantPad1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConstantPad1d_ncnn && make")
+    os.system("./build/test_nn_ConstantPad1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConstantPad2d.py b/tools/pnnx/tests/ncnn/test_nn_ConstantPad2d.py
index e8bb36e2018..ffc586407ce 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConstantPad2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConstantPad2d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ConstantPad2d_ncnn
     b = test_nn_ConstantPad2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConstantPad2d_ncnn && make")
+    os.system("./build/test_nn_ConstantPad2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConstantPad3d.py b/tools/pnnx/tests/ncnn/test_nn_ConstantPad3d.py
index ca6faa77e60..9bf69abb9ec 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConstantPad3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConstantPad3d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ConstantPad3d_ncnn
     b = test_nn_ConstantPad3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConstantPad3d_ncnn && make")
+    os.system("./build/test_nn_ConstantPad3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Conv1d.py b/tools/pnnx/tests/ncnn/test_nn_Conv1d.py
index 18aa1a9de49..b120d6901e5 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Conv1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Conv1d.py
@@ -65,7 +65,13 @@ def test():
     import test_nn_Conv1d_ncnn
     b = test_nn_Conv1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Conv1d_ncnn && make")
+    os.system("./build/test_nn_Conv1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Conv2d.py b/tools/pnnx/tests/ncnn/test_nn_Conv2d.py
index 5cde9e1b530..59b56a84bd7 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Conv2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Conv2d.py
@@ -65,7 +65,13 @@ def test():
     import test_nn_Conv2d_ncnn
     b = test_nn_Conv2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Conv2d_ncnn && make")
+    os.system("./build/test_nn_Conv2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Conv3d.py b/tools/pnnx/tests/ncnn/test_nn_Conv3d.py
index b68a937af9d..d49a9ce322a 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Conv3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Conv3d.py
@@ -71,7 +71,13 @@ def test():
     import test_nn_Conv3d_ncnn
     b = test_nn_Conv3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Conv3d_ncnn && make")
+    os.system("./build/test_nn_Conv3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose1d.py b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose1d.py
index d222ba9ca1d..1ffec72c0eb 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose1d.py
@@ -68,7 +68,13 @@ def test():
     import test_nn_ConvTranspose1d_ncnn
     b = test_nn_ConvTranspose1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConvTranspose1d_ncnn && make")
+    os.system("./build/test_nn_ConvTranspose1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose2d.py b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose2d.py
index 9b0f35dc717..4cef68ae9f1 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose2d.py
@@ -68,7 +68,13 @@ def test():
     import test_nn_ConvTranspose2d_ncnn
     b = test_nn_ConvTranspose2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConvTranspose2d_ncnn && make")
+    os.system("./build/test_nn_ConvTranspose2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose3d.py b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose3d.py
index 4284d86eebf..bc0496db288 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ConvTranspose3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ConvTranspose3d.py
@@ -68,7 +68,13 @@ def test():
     import test_nn_ConvTranspose3d_ncnn
     b = test_nn_ConvTranspose3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ConvTranspose3d_ncnn && make")
+    os.system("./build/test_nn_ConvTranspose3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Dropout.py b/tools/pnnx/tests/ncnn/test_nn_Dropout.py
index 68883c8aec2..c895d7604ec 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Dropout.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Dropout.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_Dropout_ncnn
     b = test_nn_Dropout_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Dropout_ncnn && make")
+    os.system("./build/test_nn_Dropout_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Dropout2d.py b/tools/pnnx/tests/ncnn/test_nn_Dropout2d.py
index bb6a8ecb4e9..a016ddc99d4 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Dropout2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Dropout2d.py
@@ -52,9 +52,17 @@ def test():
     import test_nn_Dropout2d_ncnn
     b = test_nn_Dropout2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Dropout2d_ncnn && make")
+    os.system("./build/test_nn_Dropout2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Dropout3d.py b/tools/pnnx/tests/ncnn/test_nn_Dropout3d.py
index 6088ddf0fb7..aa5b3689a29 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Dropout3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Dropout3d.py
@@ -52,9 +52,17 @@ def test():
     import test_nn_Dropout3d_ncnn
     b = test_nn_Dropout3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Dropout3d_ncnn && make")
+    os.system("./build/test_nn_Dropout3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ELU.py b/tools/pnnx/tests/ncnn/test_nn_ELU.py
index b2d7617a70e..447ba3af239 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ELU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ELU.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_ELU_ncnn
     b = test_nn_ELU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ELU_ncnn && make")
+    os.system("./build/test_nn_ELU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Embedding.py b/tools/pnnx/tests/ncnn/test_nn_Embedding.py
index b97056fa9f8..197c5d9391b 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Embedding.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Embedding.py
@@ -47,7 +47,13 @@ def test():
     import test_nn_Embedding_ncnn
     b = test_nn_Embedding_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Embedding_ncnn && make")
+    os.system("./build/test_nn_Embedding_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Fold.py b/tools/pnnx/tests/ncnn/test_nn_Fold.py
index 8b07b2b5d38..d80a55b2d2f 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Fold.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Fold.py
@@ -55,9 +55,17 @@ def test():
     import test_nn_Fold_ncnn
     b = test_nn_Fold_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Fold_ncnn && make")
+    os.system("./build/test_nn_Fold_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_GELU.py b/tools/pnnx/tests/ncnn/test_nn_GELU.py
index 9c3a139e31f..a95eb16146b 100644
--- a/tools/pnnx/tests/ncnn/test_nn_GELU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_GELU.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_GELU_ncnn
     b = test_nn_GELU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_GELU_ncnn && make")
+    os.system("./build/test_nn_GELU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_GLU.py b/tools/pnnx/tests/ncnn/test_nn_GLU.py
index 49a018ee2c4..7ec8890539a 100644
--- a/tools/pnnx/tests/ncnn/test_nn_GLU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_GLU.py
@@ -55,9 +55,17 @@ def test():
     import test_nn_GLU_ncnn
     b = test_nn_GLU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_GLU_ncnn && make")
+    os.system("./build/test_nn_GLU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_GRU.py b/tools/pnnx/tests/ncnn/test_nn_GRU.py
index 3486ac55045..3f7a5829e36 100644
--- a/tools/pnnx/tests/ncnn/test_nn_GRU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_GRU.py
@@ -75,9 +75,17 @@ def test():
     import test_nn_GRU_ncnn
     b = test_nn_GRU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_GRU_ncnn && make")
+    os.system("./build/test_nn_GRU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-3, 1e-3):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-3, 1e-3):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_GroupNorm.py b/tools/pnnx/tests/ncnn/test_nn_GroupNorm.py
index c016e7ae250..01d1e4fa3b6 100644
--- a/tools/pnnx/tests/ncnn/test_nn_GroupNorm.py
+++ b/tools/pnnx/tests/ncnn/test_nn_GroupNorm.py
@@ -61,9 +61,17 @@ def test():
     import test_nn_GroupNorm_ncnn
     b = test_nn_GroupNorm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_GroupNorm_ncnn && make")
+    os.system("./build/test_nn_GroupNorm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Hardsigmoid.py b/tools/pnnx/tests/ncnn/test_nn_Hardsigmoid.py
index de76482506f..c94bf680f28 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Hardsigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Hardsigmoid.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_Hardsigmoid_ncnn
     b = test_nn_Hardsigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Hardsigmoid_ncnn && make")
+    os.system("./build/test_nn_Hardsigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Hardswish.py b/tools/pnnx/tests/ncnn/test_nn_Hardswish.py
index 91656a2e00a..ce3282840b8 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Hardswish.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Hardswish.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_Hardswish_ncnn
     b = test_nn_Hardswish_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Hardswish_ncnn && make")
+    os.system("./build/test_nn_Hardswish_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Hardtanh.py b/tools/pnnx/tests/ncnn/test_nn_Hardtanh.py
index ea342d89c47..86dda81d711 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Hardtanh.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Hardtanh.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_Hardtanh_ncnn
     b = test_nn_Hardtanh_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Hardtanh_ncnn && make")
+    os.system("./build/test_nn_Hardtanh_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Identity.py b/tools/pnnx/tests/ncnn/test_nn_Identity.py
index 679b2e0bae9..cf7320f586a 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Identity.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Identity.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_Identity_ncnn
     b = test_nn_Identity_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Identity_ncnn && make")
+    os.system("./build/test_nn_Identity_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_InstanceNorm2d.py b/tools/pnnx/tests/ncnn/test_nn_InstanceNorm2d.py
index f65c810fd5b..d0698221e61 100644
--- a/tools/pnnx/tests/ncnn/test_nn_InstanceNorm2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_InstanceNorm2d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_InstanceNorm2d_ncnn
     b = test_nn_InstanceNorm2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_InstanceNorm2d_ncnn && make")
+    os.system("./build/test_nn_InstanceNorm2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_LSTM.py b/tools/pnnx/tests/ncnn/test_nn_LSTM.py
index a51f5e94054..56c08037044 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LSTM.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LSTM.py
@@ -75,9 +75,17 @@ def test():
     import test_nn_LSTM_ncnn
     b = test_nn_LSTM_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LSTM_ncnn && make")
+    os.system("./build/test_nn_LSTM_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-3, 1e-3):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-3, 1e-3):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_LayerNorm.py b/tools/pnnx/tests/ncnn/test_nn_LayerNorm.py
index d409bdfba3a..23d93a4353d 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LayerNorm.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LayerNorm.py
@@ -53,9 +53,17 @@ def test():
     import test_nn_LayerNorm_ncnn
     b = test_nn_LayerNorm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LayerNorm_ncnn && make")
+    os.system("./build/test_nn_LayerNorm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_LeakyReLU.py b/tools/pnnx/tests/ncnn/test_nn_LeakyReLU.py
index a0a8b6e549a..546feb8d0e3 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LeakyReLU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LeakyReLU.py
@@ -58,9 +58,17 @@ def test():
     import test_nn_LeakyReLU_ncnn
     b = test_nn_LeakyReLU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LeakyReLU_ncnn && make")
+    os.system("./build/test_nn_LeakyReLU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Linear.py b/tools/pnnx/tests/ncnn/test_nn_Linear.py
index ea79c50db18..8db15c4ee23 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Linear.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Linear.py
@@ -62,9 +62,17 @@ def test():
     import test_nn_Linear_ncnn
     b = test_nn_Linear_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Linear_ncnn && make")
+    os.system("./build/test_nn_Linear_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_LocalResponseNorm.py b/tools/pnnx/tests/ncnn/test_nn_LocalResponseNorm.py
index ac12886d613..d71449f6494 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LocalResponseNorm.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LocalResponseNorm.py
@@ -35,7 +35,7 @@ def test():
     torch.manual_seed(0)
     x = torch.rand(1, 12, 24, 64)
 
-    a0 = net(x)
+    a = net(x)
 
     # export torchscript
     mod = torch.jit.trace(net, x)
@@ -47,9 +47,15 @@ def test():
 
     # ncnn inference
     import test_nn_LocalResponseNorm_ncnn
-    b0 = test_nn_LocalResponseNorm_ncnn.test_inference()
+    b = test_nn_LocalResponseNorm_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LocalResponseNorm_ncnn && make")
+    os.system("./build/test_nn_LocalResponseNorm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_LogSigmoid.py b/tools/pnnx/tests/ncnn/test_nn_LogSigmoid.py
index d74477dc9cc..2c8daa25567 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LogSigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LogSigmoid.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_LogSigmoid_ncnn
     b = test_nn_LogSigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LogSigmoid_ncnn && make")
+    os.system("./build/test_nn_LogSigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_LogSoftmax.py b/tools/pnnx/tests/ncnn/test_nn_LogSoftmax.py
index 27caaa17705..d618379446c 100644
--- a/tools/pnnx/tests/ncnn/test_nn_LogSoftmax.py
+++ b/tools/pnnx/tests/ncnn/test_nn_LogSoftmax.py
@@ -60,9 +60,17 @@ def test():
     import test_nn_LogSoftmax_ncnn
     b = test_nn_LogSoftmax_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_LogSoftmax_ncnn && make")
+    os.system("./build/test_nn_LogSoftmax_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_MaxPool1d.py b/tools/pnnx/tests/ncnn/test_nn_MaxPool1d.py
index 348dbc661e6..1b86af3ada4 100644
--- a/tools/pnnx/tests/ncnn/test_nn_MaxPool1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_MaxPool1d.py
@@ -72,9 +72,17 @@ def test():
     import test_nn_MaxPool1d_ncnn
     b = test_nn_MaxPool1d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_MaxPool1d_ncnn && make")
+    os.system("./build/test_nn_MaxPool1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_MaxPool2d.py b/tools/pnnx/tests/ncnn/test_nn_MaxPool2d.py
index f4feb30089f..af7743279d4 100644
--- a/tools/pnnx/tests/ncnn/test_nn_MaxPool2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_MaxPool2d.py
@@ -69,9 +69,17 @@ def test():
     import test_nn_MaxPool2d_ncnn
     b = test_nn_MaxPool2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_MaxPool2d_ncnn && make")
+    os.system("./build/test_nn_MaxPool2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_MaxPool3d.py b/tools/pnnx/tests/ncnn/test_nn_MaxPool3d.py
index 0de79785462..aa8f3bac785 100644
--- a/tools/pnnx/tests/ncnn/test_nn_MaxPool3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_MaxPool3d.py
@@ -69,9 +69,17 @@ def test():
     import test_nn_MaxPool3d_ncnn
     b = test_nn_MaxPool3d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_MaxPool3d_ncnn && make")
+    os.system("./build/test_nn_MaxPool3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Mish.py b/tools/pnnx/tests/ncnn/test_nn_Mish.py
index 4ef9f26174a..328a8dcbee5 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Mish.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Mish.py
@@ -61,9 +61,17 @@ def test():
     import test_nn_Mish_ncnn
     b = test_nn_Mish_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Mish_ncnn && make")
+    os.system("./build/test_nn_Mish_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_MultiheadAttention.py b/tools/pnnx/tests/ncnn/test_nn_MultiheadAttention.py
index 9d551cc9498..12d38a85183 100644
--- a/tools/pnnx/tests/ncnn/test_nn_MultiheadAttention.py
+++ b/tools/pnnx/tests/ncnn/test_nn_MultiheadAttention.py
@@ -84,11 +84,19 @@ def test():
     import test_nn_MultiheadAttention_ncnn
     b = test_nn_MultiheadAttention_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_MultiheadAttention_ncnn && make")
+    os.system("./build/test_nn_MultiheadAttention_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             print(a0)
             print(b0)
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_PReLU.py b/tools/pnnx/tests/ncnn/test_nn_PReLU.py
index 67c7717f734..6f7f060d0e4 100644
--- a/tools/pnnx/tests/ncnn/test_nn_PReLU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_PReLU.py
@@ -63,9 +63,17 @@ def test():
     import test_nn_PReLU_ncnn
     b = test_nn_PReLU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_PReLU_ncnn && make")
+    os.system("./build/test_nn_PReLU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_PixelShuffle.py b/tools/pnnx/tests/ncnn/test_nn_PixelShuffle.py
index 446a7933d6b..159e83340a1 100644
--- a/tools/pnnx/tests/ncnn/test_nn_PixelShuffle.py
+++ b/tools/pnnx/tests/ncnn/test_nn_PixelShuffle.py
@@ -35,7 +35,7 @@ def test():
     torch.manual_seed(0)
     x = torch.rand(1, 128, 6, 8)
 
-    a0 = net(x)
+    a = net(x)
 
     # export torchscript
     mod = torch.jit.trace(net, x)
@@ -47,9 +47,15 @@ def test():
 
     # ncnn inference
     import test_nn_PixelShuffle_ncnn
-    b0 = test_nn_PixelShuffle_ncnn.test_inference()
+    b = test_nn_PixelShuffle_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_PixelShuffle_ncnn && make")
+    os.system("./build/test_nn_PixelShuffle_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_PixelUnshuffle.py b/tools/pnnx/tests/ncnn/test_nn_PixelUnshuffle.py
index 68db3508c55..d786323b798 100644
--- a/tools/pnnx/tests/ncnn/test_nn_PixelUnshuffle.py
+++ b/tools/pnnx/tests/ncnn/test_nn_PixelUnshuffle.py
@@ -35,7 +35,7 @@ def test():
     torch.manual_seed(0)
     x = torch.rand(1, 3, 128, 128)
 
-    a0 = net(x)
+    a = net(x)
 
     # export torchscript
     mod = torch.jit.trace(net, x)
@@ -47,9 +47,15 @@ def test():
 
     # ncnn inference
     import test_nn_PixelUnshuffle_ncnn
-    b0 = test_nn_PixelUnshuffle_ncnn.test_inference()
+    b = test_nn_PixelUnshuffle_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_PixelUnshuffle_ncnn && make")
+    os.system("./build/test_nn_PixelUnshuffle_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_RMSNorm.py b/tools/pnnx/tests/ncnn/test_nn_RMSNorm.py
index e69ad1220bc..319b7317bb4 100644
--- a/tools/pnnx/tests/ncnn/test_nn_RMSNorm.py
+++ b/tools/pnnx/tests/ncnn/test_nn_RMSNorm.py
@@ -56,8 +56,16 @@ def test():
     import test_nn_RMSNorm_ncnn
     b = test_nn_RMSNorm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_RMSNorm_ncnn && make")
+    os.system("./build/test_nn_RMSNorm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
-        if not torch.allclose(a0, b0, 1e-3, 1e-3):
+        if not torch.allclose(a0, b0, 1e-4, 1e-4):
+            return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
             return False
     return True
 
diff --git a/tools/pnnx/tests/ncnn/test_nn_RNN.py b/tools/pnnx/tests/ncnn/test_nn_RNN.py
index c2685b51cdd..5ce25afe5d5 100644
--- a/tools/pnnx/tests/ncnn/test_nn_RNN.py
+++ b/tools/pnnx/tests/ncnn/test_nn_RNN.py
@@ -75,9 +75,17 @@ def test():
     import test_nn_RNN_ncnn
     b = test_nn_RNN_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_RNN_ncnn && make")
+    os.system("./build/test_nn_RNN_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-3, 1e-3):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-3, 1e-3):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReLU.py b/tools/pnnx/tests/ncnn/test_nn_ReLU.py
index b3adf2c7573..65eb45e6b2e 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReLU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReLU.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_ReLU_ncnn
     b = test_nn_ReLU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReLU_ncnn && make")
+    os.system("./build/test_nn_ReLU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReLU6.py b/tools/pnnx/tests/ncnn/test_nn_ReLU6.py
index 9dbea33a36d..0aa8a423cfe 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReLU6.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReLU6.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_ReLU6_ncnn
     b = test_nn_ReLU6_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReLU6_ncnn && make")
+    os.system("./build/test_nn_ReLU6_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReflectionPad1d.py b/tools/pnnx/tests/ncnn/test_nn_ReflectionPad1d.py
index 39bcf8ce632..67443c4a8c9 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReflectionPad1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReflectionPad1d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ReflectionPad1d_ncnn
     b = test_nn_ReflectionPad1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReflectionPad1d_ncnn && make")
+    os.system("./build/test_nn_ReflectionPad1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReflectionPad2d.py b/tools/pnnx/tests/ncnn/test_nn_ReflectionPad2d.py
index a2f9e158808..b6f7c33f38f 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReflectionPad2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReflectionPad2d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ReflectionPad2d_ncnn
     b = test_nn_ReflectionPad2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReflectionPad2d_ncnn && make")
+    os.system("./build/test_nn_ReflectionPad2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad1d.py b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad1d.py
index 4ba17a9a8b2..e7d2baba0af 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad1d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad1d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ReplicationPad1d_ncnn
     b = test_nn_ReplicationPad1d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReplicationPad1d_ncnn && make")
+    os.system("./build/test_nn_ReplicationPad1d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad2d.py b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad2d.py
index 5cf663fb298..a67ec472667 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad2d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ReplicationPad2d_ncnn
     b = test_nn_ReplicationPad2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReplicationPad2d_ncnn && make")
+    os.system("./build/test_nn_ReplicationPad2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad3d.py b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad3d.py
index 5714191dff9..03715911aa1 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ReplicationPad3d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ReplicationPad3d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ReplicationPad3d_ncnn
     b = test_nn_ReplicationPad3d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ReplicationPad3d_ncnn && make")
+    os.system("./build/test_nn_ReplicationPad3d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_SELU.py b/tools/pnnx/tests/ncnn/test_nn_SELU.py
index b8cf59006b9..61e9f1a4e73 100644
--- a/tools/pnnx/tests/ncnn/test_nn_SELU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_SELU.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_SELU_ncnn
     b = test_nn_SELU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_SELU_ncnn && make")
+    os.system("./build/test_nn_SELU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_SiLU.py b/tools/pnnx/tests/ncnn/test_nn_SiLU.py
index 3a4d35a67cf..a5b68098ab1 100644
--- a/tools/pnnx/tests/ncnn/test_nn_SiLU.py
+++ b/tools/pnnx/tests/ncnn/test_nn_SiLU.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_SiLU_ncnn
     b = test_nn_SiLU_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_SiLU_ncnn && make")
+    os.system("./build/test_nn_SiLU_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Sigmoid.py b/tools/pnnx/tests/ncnn/test_nn_Sigmoid.py
index 246e63084dd..7b7f2e45a3e 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Sigmoid.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Sigmoid.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_Sigmoid_ncnn
     b = test_nn_Sigmoid_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Sigmoid_ncnn && make")
+    os.system("./build/test_nn_Sigmoid_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Softmax.py b/tools/pnnx/tests/ncnn/test_nn_Softmax.py
index 80c05f5e638..b0ddcbccfd5 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Softmax.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Softmax.py
@@ -60,9 +60,17 @@ def test():
     import test_nn_Softmax_ncnn
     b = test_nn_Softmax_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Softmax_ncnn && make")
+    os.system("./build/test_nn_Softmax_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Softmax2d.py b/tools/pnnx/tests/ncnn/test_nn_Softmax2d.py
index ddeb8586a39..9eac3c7c902 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Softmax2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Softmax2d.py
@@ -48,7 +48,13 @@ def test():
     import test_nn_Softmax2d_ncnn
     b = test_nn_Softmax2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Softmax2d_ncnn && make")
+    os.system("./build/test_nn_Softmax2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_Tanh.py b/tools/pnnx/tests/ncnn/test_nn_Tanh.py
index a60d1345d23..cd621168e43 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Tanh.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Tanh.py
@@ -57,9 +57,17 @@ def test():
     import test_nn_Tanh_ncnn
     b = test_nn_Tanh_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Tanh_ncnn && make")
+    os.system("./build/test_nn_Tanh_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Unfold.py b/tools/pnnx/tests/ncnn/test_nn_Unfold.py
index 8d618f76150..8285f77298f 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Unfold.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Unfold.py
@@ -53,9 +53,17 @@ def test():
     import test_nn_Unfold_ncnn
     b = test_nn_Unfold_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Unfold_ncnn && make")
+    os.system("./build/test_nn_Unfold_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_Upsample.py b/tools/pnnx/tests/ncnn/test_nn_Upsample.py
index 0644bc17df6..ed861094c92 100644
--- a/tools/pnnx/tests/ncnn/test_nn_Upsample.py
+++ b/tools/pnnx/tests/ncnn/test_nn_Upsample.py
@@ -119,9 +119,17 @@ def test():
     import test_nn_Upsample_ncnn
     b = test_nn_Upsample_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_Upsample_ncnn && make")
+    os.system("./build/test_nn_Upsample_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_UpsamplingBilinear2d.py b/tools/pnnx/tests/ncnn/test_nn_UpsamplingBilinear2d.py
index 704b2c778d3..435fc3e1f5c 100644
--- a/tools/pnnx/tests/ncnn/test_nn_UpsamplingBilinear2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_UpsamplingBilinear2d.py
@@ -57,7 +57,13 @@ def test():
     import test_nn_UpsamplingBilinear2d_ncnn
     b = test_nn_UpsamplingBilinear2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_UpsamplingBilinear2d_ncnn && make")
+    os.system("./build/test_nn_UpsamplingBilinear2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_nn_UpsamplingNearest2d.py b/tools/pnnx/tests/ncnn/test_nn_UpsamplingNearest2d.py
index 0973bc650d3..c693904a00f 100644
--- a/tools/pnnx/tests/ncnn/test_nn_UpsamplingNearest2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_UpsamplingNearest2d.py
@@ -62,9 +62,17 @@ def test():
     import test_nn_UpsamplingNearest2d_ncnn
     b = test_nn_UpsamplingNearest2d_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_UpsamplingNearest2d_ncnn && make")
+    os.system("./build/test_nn_UpsamplingNearest2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_nn_ZeroPad2d.py b/tools/pnnx/tests/ncnn/test_nn_ZeroPad2d.py
index e8b4cfb171b..0f3a514c9fc 100644
--- a/tools/pnnx/tests/ncnn/test_nn_ZeroPad2d.py
+++ b/tools/pnnx/tests/ncnn/test_nn_ZeroPad2d.py
@@ -51,7 +51,13 @@ def test():
     import test_nn_ZeroPad2d_ncnn
     b = test_nn_ZeroPad2d_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_nn_ZeroPad2d_ncnn && make")
+    os.system("./build/test_nn_ZeroPad2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_resnet18.py b/tools/pnnx/tests/ncnn/test_resnet18.py
index 1a31f794950..897ee20ea27 100644
--- a/tools/pnnx/tests/ncnn/test_resnet18.py
+++ b/tools/pnnx/tests/ncnn/test_resnet18.py
@@ -36,7 +36,13 @@ def test():
     import test_resnet18_ncnn
     b = test_resnet18_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-2, 1e-2)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_resnet18_ncnn && make")
+    os.system("./build/test_resnet18_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-2, 1e-2) and torch.allclose(a, c, 1e-2, 1e-2)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_shufflenet_v2_x1_0.py b/tools/pnnx/tests/ncnn/test_shufflenet_v2_x1_0.py
index 430a6579e79..ec7fa7d5e10 100644
--- a/tools/pnnx/tests/ncnn/test_shufflenet_v2_x1_0.py
+++ b/tools/pnnx/tests/ncnn/test_shufflenet_v2_x1_0.py
@@ -36,7 +36,13 @@ def test():
     import test_shufflenet_v2_x1_0_ncnn
     b = test_shufflenet_v2_x1_0_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-2, 1e-2)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_shufflenet_v2_x1_0_ncnn && make")
+    os.system("./build/test_shufflenet_v2_x1_0_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-2, 1e-2) and torch.allclose(a, c, 1e-2, 1e-2)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_squeezenet1_1.py b/tools/pnnx/tests/ncnn/test_squeezenet1_1.py
index f7c35ae5567..6ee24763a18 100644
--- a/tools/pnnx/tests/ncnn/test_squeezenet1_1.py
+++ b/tools/pnnx/tests/ncnn/test_squeezenet1_1.py
@@ -36,7 +36,13 @@ def test():
     import test_squeezenet1_1_ncnn
     b = test_squeezenet1_1_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-2, 1e-2)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_squeezenet1_1_ncnn && make")
+    os.system("./build/test_squeezenet1_1_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-2, 1e-2) and torch.allclose(a, c, 1e-2, 1e-2)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_torch_abs.py b/tools/pnnx/tests/ncnn/test_torch_abs.py
index 8d824a11b1e..9ea4a4ef038 100644
--- a/tools/pnnx/tests/ncnn/test_torch_abs.py
+++ b/tools/pnnx/tests/ncnn/test_torch_abs.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_abs_ncnn
     b = test_torch_abs_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_abs_ncnn && make")
+    os.system("./build/test_torch_abs_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_acos.py b/tools/pnnx/tests/ncnn/test_torch_acos.py
index 4fc0e43a37a..ba1398c33e2 100644
--- a/tools/pnnx/tests/ncnn/test_torch_acos.py
+++ b/tools/pnnx/tests/ncnn/test_torch_acos.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_acos_ncnn
     b = test_torch_acos_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_acos_ncnn && make")
+    os.system("./build/test_torch_acos_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_addmm.py b/tools/pnnx/tests/ncnn/test_torch_addmm.py
index 3778dc43d3e..11c824305be 100644
--- a/tools/pnnx/tests/ncnn/test_torch_addmm.py
+++ b/tools/pnnx/tests/ncnn/test_torch_addmm.py
@@ -56,9 +56,17 @@ def test():
     import test_torch_addmm_ncnn
     b = test_torch_addmm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_addmm_ncnn && make")
+    os.system("./build/test_torch_addmm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_amax.py b/tools/pnnx/tests/ncnn/test_torch_amax.py
index 512dfa7d1c3..0707ac3869a 100644
--- a/tools/pnnx/tests/ncnn/test_torch_amax.py
+++ b/tools/pnnx/tests/ncnn/test_torch_amax.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_amax_ncnn
     b = test_torch_amax_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_amax_ncnn && make")
+    os.system("./build/test_torch_amax_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_amin.py b/tools/pnnx/tests/ncnn/test_torch_amin.py
index dc2d9de8791..62c0996a0f8 100644
--- a/tools/pnnx/tests/ncnn/test_torch_amin.py
+++ b/tools/pnnx/tests/ncnn/test_torch_amin.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_amin_ncnn
     b = test_torch_amin_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_amin_ncnn && make")
+    os.system("./build/test_torch_amin_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_asin.py b/tools/pnnx/tests/ncnn/test_torch_asin.py
index 24099e59214..9c862e95357 100644
--- a/tools/pnnx/tests/ncnn/test_torch_asin.py
+++ b/tools/pnnx/tests/ncnn/test_torch_asin.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_asin_ncnn
     b = test_torch_asin_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_asin_ncnn && make")
+    os.system("./build/test_torch_asin_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_atan.py b/tools/pnnx/tests/ncnn/test_torch_atan.py
index bef6aae5891..ea754fade92 100644
--- a/tools/pnnx/tests/ncnn/test_torch_atan.py
+++ b/tools/pnnx/tests/ncnn/test_torch_atan.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_atan_ncnn
     b = test_torch_atan_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_atan_ncnn && make")
+    os.system("./build/test_torch_atan_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_atan2.py b/tools/pnnx/tests/ncnn/test_torch_atan2.py
index f4dcb6eafd7..bd24a5736a0 100644
--- a/tools/pnnx/tests/ncnn/test_torch_atan2.py
+++ b/tools/pnnx/tests/ncnn/test_torch_atan2.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_atan2_ncnn
     b = test_torch_atan2_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_atan2_ncnn && make")
+    os.system("./build/test_torch_atan2_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_bmm.py b/tools/pnnx/tests/ncnn/test_torch_bmm.py
index f2654b539e2..8d976abdf2c 100644
--- a/tools/pnnx/tests/ncnn/test_torch_bmm.py
+++ b/tools/pnnx/tests/ncnn/test_torch_bmm.py
@@ -46,7 +46,13 @@ def test():
     import test_torch_bmm_ncnn
     b = test_torch_bmm_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_bmm_ncnn && make")
+    os.system("./build/test_torch_bmm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_torch_cat.py b/tools/pnnx/tests/ncnn/test_torch_cat.py
index d02078da08e..bea297b9c00 100644
--- a/tools/pnnx/tests/ncnn/test_torch_cat.py
+++ b/tools/pnnx/tests/ncnn/test_torch_cat.py
@@ -56,9 +56,17 @@ def test():
     import test_torch_cat_ncnn
     b = test_torch_cat_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_cat_ncnn && make")
+    os.system("./build/test_torch_cat_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_ceil.py b/tools/pnnx/tests/ncnn/test_torch_ceil.py
index 4ee628adb96..0b3ab98ca59 100644
--- a/tools/pnnx/tests/ncnn/test_torch_ceil.py
+++ b/tools/pnnx/tests/ncnn/test_torch_ceil.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_ceil_ncnn
     b = test_torch_ceil_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_ceil_ncnn && make")
+    os.system("./build/test_torch_ceil_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_chunk.py b/tools/pnnx/tests/ncnn/test_torch_chunk.py
index f4bfaeb4b33..52c8d692f39 100644
--- a/tools/pnnx/tests/ncnn/test_torch_chunk.py
+++ b/tools/pnnx/tests/ncnn/test_torch_chunk.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_chunk_ncnn
     b = test_torch_chunk_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_chunk_ncnn && make")
+    os.system("./build/test_torch_chunk_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_clamp.py b/tools/pnnx/tests/ncnn/test_torch_clamp.py
index daf2e2a00fb..1f8100af8d4 100644
--- a/tools/pnnx/tests/ncnn/test_torch_clamp.py
+++ b/tools/pnnx/tests/ncnn/test_torch_clamp.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_clamp_ncnn
     b = test_torch_clamp_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_clamp_ncnn && make")
+    os.system("./build/test_torch_clamp_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_clone.py b/tools/pnnx/tests/ncnn/test_torch_clone.py
index a5ab9e787c1..b2c527721b4 100644
--- a/tools/pnnx/tests/ncnn/test_torch_clone.py
+++ b/tools/pnnx/tests/ncnn/test_torch_clone.py
@@ -52,9 +52,17 @@ def test():
     import test_torch_clone_ncnn
     b = test_torch_clone_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_clone_ncnn && make")
+    os.system("./build/test_torch_clone_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_cos.py b/tools/pnnx/tests/ncnn/test_torch_cos.py
index f32b1ff4e63..01a51d6ef6f 100644
--- a/tools/pnnx/tests/ncnn/test_torch_cos.py
+++ b/tools/pnnx/tests/ncnn/test_torch_cos.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_cos_ncnn
     b = test_torch_cos_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_cos_ncnn && make")
+    os.system("./build/test_torch_cos_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_cumsum.py b/tools/pnnx/tests/ncnn/test_torch_cumsum.py
index 27b97b7b161..84c304d891e 100644
--- a/tools/pnnx/tests/ncnn/test_torch_cumsum.py
+++ b/tools/pnnx/tests/ncnn/test_torch_cumsum.py
@@ -58,9 +58,17 @@ def test():
     import test_torch_cumsum_ncnn
     b = test_torch_cumsum_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_cumsum_ncnn && make")
+    os.system("./build/test_torch_cumsum_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_diag.py b/tools/pnnx/tests/ncnn/test_torch_diag.py
index 8af8069ef05..742cdacf258 100644
--- a/tools/pnnx/tests/ncnn/test_torch_diag.py
+++ b/tools/pnnx/tests/ncnn/test_torch_diag.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_diag_ncnn
     b = test_torch_diag_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_diag_ncnn && make")
+    os.system("./build/test_torch_diag_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_einsum.py b/tools/pnnx/tests/ncnn/test_torch_einsum.py
index d5a6f8cdbb1..f303ab26e83 100644
--- a/tools/pnnx/tests/ncnn/test_torch_einsum.py
+++ b/tools/pnnx/tests/ncnn/test_torch_einsum.py
@@ -186,9 +186,17 @@ def test():
     import test_torch_einsum_ncnn
     b = test_torch_einsum_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_einsum_ncnn && make")
+    os.system("./build/test_torch_einsum_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_exp.py b/tools/pnnx/tests/ncnn/test_torch_exp.py
index 5e608687c40..3915ffb956e 100644
--- a/tools/pnnx/tests/ncnn/test_torch_exp.py
+++ b/tools/pnnx/tests/ncnn/test_torch_exp.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_exp_ncnn
     b = test_torch_exp_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_exp_ncnn && make")
+    os.system("./build/test_torch_exp_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_floor.py b/tools/pnnx/tests/ncnn/test_torch_floor.py
index e100d96de19..cfa331d1f06 100644
--- a/tools/pnnx/tests/ncnn/test_torch_floor.py
+++ b/tools/pnnx/tests/ncnn/test_torch_floor.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_floor_ncnn
     b = test_torch_floor_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_floor_ncnn && make")
+    os.system("./build/test_torch_floor_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_log.py b/tools/pnnx/tests/ncnn/test_torch_log.py
index a3583f47273..f88c4238bf0 100644
--- a/tools/pnnx/tests/ncnn/test_torch_log.py
+++ b/tools/pnnx/tests/ncnn/test_torch_log.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_log_ncnn
     b = test_torch_log_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_log_ncnn && make")
+    os.system("./build/test_torch_log_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_log10.py b/tools/pnnx/tests/ncnn/test_torch_log10.py
index 20b8f09395c..2b912a380b6 100644
--- a/tools/pnnx/tests/ncnn/test_torch_log10.py
+++ b/tools/pnnx/tests/ncnn/test_torch_log10.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_log10_ncnn
     b = test_torch_log10_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_log10_ncnn && make")
+    os.system("./build/test_torch_log10_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_logsumexp.py b/tools/pnnx/tests/ncnn/test_torch_logsumexp.py
index b5b3ea20af2..91728bbcae4 100644
--- a/tools/pnnx/tests/ncnn/test_torch_logsumexp.py
+++ b/tools/pnnx/tests/ncnn/test_torch_logsumexp.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_logsumexp_ncnn
     b = test_torch_logsumexp_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_logsumexp_ncnn && make")
+    os.system("./build/test_torch_logsumexp_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_matmul.py b/tools/pnnx/tests/ncnn/test_torch_matmul.py
index e4cd3b9b12b..2fc6455b7ef 100644
--- a/tools/pnnx/tests/ncnn/test_torch_matmul.py
+++ b/tools/pnnx/tests/ncnn/test_torch_matmul.py
@@ -91,9 +91,17 @@ def test():
     import test_torch_matmul_ncnn
     b = test_torch_matmul_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_matmul_ncnn && make")
+    os.system("./build/test_torch_matmul_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_max.py b/tools/pnnx/tests/ncnn/test_torch_max.py
index 61fcb383d3d..77ee307abbb 100644
--- a/tools/pnnx/tests/ncnn/test_torch_max.py
+++ b/tools/pnnx/tests/ncnn/test_torch_max.py
@@ -51,9 +51,17 @@ def test():
     import test_torch_max_ncnn
     b = test_torch_max_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_max_ncnn && make")
+    os.system("./build/test_torch_max_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_maximum.py b/tools/pnnx/tests/ncnn/test_torch_maximum.py
index 616a0978cb5..28014fe1d23 100644
--- a/tools/pnnx/tests/ncnn/test_torch_maximum.py
+++ b/tools/pnnx/tests/ncnn/test_torch_maximum.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_maximum_ncnn
     b = test_torch_maximum_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_maximum_ncnn && make")
+    os.system("./build/test_torch_maximum_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_mean.py b/tools/pnnx/tests/ncnn/test_torch_mean.py
index 20d284ddfd7..11e23cfa3fd 100644
--- a/tools/pnnx/tests/ncnn/test_torch_mean.py
+++ b/tools/pnnx/tests/ncnn/test_torch_mean.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_mean_ncnn
     b = test_torch_mean_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_mean_ncnn && make")
+    os.system("./build/test_torch_mean_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_min.py b/tools/pnnx/tests/ncnn/test_torch_min.py
index da35d659a07..fe6f47b1508 100644
--- a/tools/pnnx/tests/ncnn/test_torch_min.py
+++ b/tools/pnnx/tests/ncnn/test_torch_min.py
@@ -51,9 +51,17 @@ def test():
     import test_torch_min_ncnn
     b = test_torch_min_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_min_ncnn && make")
+    os.system("./build/test_torch_min_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_minimum.py b/tools/pnnx/tests/ncnn/test_torch_minimum.py
index 4b3d6e535bd..48744b0b77b 100644
--- a/tools/pnnx/tests/ncnn/test_torch_minimum.py
+++ b/tools/pnnx/tests/ncnn/test_torch_minimum.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_minimum_ncnn
     b = test_torch_minimum_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_minimum_ncnn && make")
+    os.system("./build/test_torch_minimum_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_mm.py b/tools/pnnx/tests/ncnn/test_torch_mm.py
index 778ca983df5..52c408a2f84 100644
--- a/tools/pnnx/tests/ncnn/test_torch_mm.py
+++ b/tools/pnnx/tests/ncnn/test_torch_mm.py
@@ -46,7 +46,13 @@ def test():
     import test_torch_mm_ncnn
     b = test_torch_mm_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_mm_ncnn && make")
+    os.system("./build/test_torch_mm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_torch_neg.py b/tools/pnnx/tests/ncnn/test_torch_neg.py
index 75197fa16fd..13cf90e73cf 100644
--- a/tools/pnnx/tests/ncnn/test_torch_neg.py
+++ b/tools/pnnx/tests/ncnn/test_torch_neg.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_neg_ncnn
     b = test_torch_neg_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_neg_ncnn && make")
+    os.system("./build/test_torch_neg_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_norm.py b/tools/pnnx/tests/ncnn/test_torch_norm.py
index cb3f12f9886..a6cdfc8904e 100644
--- a/tools/pnnx/tests/ncnn/test_torch_norm.py
+++ b/tools/pnnx/tests/ncnn/test_torch_norm.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_norm_ncnn
     b = test_torch_norm_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_norm_ncnn && make")
+    os.system("./build/test_torch_norm_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_pow.py b/tools/pnnx/tests/ncnn/test_torch_pow.py
index 26c850cbaad..4c6a7578323 100644
--- a/tools/pnnx/tests/ncnn/test_torch_pow.py
+++ b/tools/pnnx/tests/ncnn/test_torch_pow.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_pow_ncnn
     b = test_torch_pow_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_pow_ncnn && make")
+    os.system("./build/test_torch_pow_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_prod.py b/tools/pnnx/tests/ncnn/test_torch_prod.py
index 88bff942199..a87d0c88ca1 100644
--- a/tools/pnnx/tests/ncnn/test_torch_prod.py
+++ b/tools/pnnx/tests/ncnn/test_torch_prod.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_prod_ncnn
     b = test_torch_prod_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_prod_ncnn && make")
+    os.system("./build/test_torch_prod_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_reciprocal.py b/tools/pnnx/tests/ncnn/test_torch_reciprocal.py
index 83f2c89c96b..a8d76831b9a 100644
--- a/tools/pnnx/tests/ncnn/test_torch_reciprocal.py
+++ b/tools/pnnx/tests/ncnn/test_torch_reciprocal.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_reciprocal_ncnn
     b = test_torch_reciprocal_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_reciprocal_ncnn && make")
+    os.system("./build/test_torch_reciprocal_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_roll.py b/tools/pnnx/tests/ncnn/test_torch_roll.py
index 6412ee6ba60..d60d027cd03 100644
--- a/tools/pnnx/tests/ncnn/test_torch_roll.py
+++ b/tools/pnnx/tests/ncnn/test_torch_roll.py
@@ -49,12 +49,20 @@ def test():
     import test_torch_roll_ncnn
     b = test_torch_roll_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_roll_ncnn && make")
+    os.system("./build/test_torch_roll_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     print(x)
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             print(a0)
             print(b0)
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_round.py b/tools/pnnx/tests/ncnn/test_torch_round.py
index 23241792e1b..99b423f6354 100644
--- a/tools/pnnx/tests/ncnn/test_torch_round.py
+++ b/tools/pnnx/tests/ncnn/test_torch_round.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_round_ncnn
     b = test_torch_round_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_round_ncnn && make")
+    os.system("./build/test_torch_round_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_rsqrt.py b/tools/pnnx/tests/ncnn/test_torch_rsqrt.py
index b3a34c70d51..0623387793e 100644
--- a/tools/pnnx/tests/ncnn/test_torch_rsqrt.py
+++ b/tools/pnnx/tests/ncnn/test_torch_rsqrt.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_rsqrt_ncnn
     b = test_torch_rsqrt_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_rsqrt_ncnn && make")
+    os.system("./build/test_torch_rsqrt_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-3, 1e-3):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-3, 1e-3):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_sin.py b/tools/pnnx/tests/ncnn/test_torch_sin.py
index d984a269e1c..2f8e774089d 100644
--- a/tools/pnnx/tests/ncnn/test_torch_sin.py
+++ b/tools/pnnx/tests/ncnn/test_torch_sin.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_sin_ncnn
     b = test_torch_sin_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_sin_ncnn && make")
+    os.system("./build/test_torch_sin_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_slice_scatter.py b/tools/pnnx/tests/ncnn/test_torch_slice_scatter.py
index 977b79d3d4e..f21d48273e3 100644
--- a/tools/pnnx/tests/ncnn/test_torch_slice_scatter.py
+++ b/tools/pnnx/tests/ncnn/test_torch_slice_scatter.py
@@ -55,9 +55,17 @@ def test():
     import test_torch_slice_scatter_ncnn
     b = test_torch_slice_scatter_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_slice_scatter_ncnn && make")
+    os.system("./build/test_torch_slice_scatter_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_sqrt.py b/tools/pnnx/tests/ncnn/test_torch_sqrt.py
index bfd5ddb3d2a..309158b3b75 100644
--- a/tools/pnnx/tests/ncnn/test_torch_sqrt.py
+++ b/tools/pnnx/tests/ncnn/test_torch_sqrt.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_sqrt_ncnn
     b = test_torch_sqrt_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_sqrt_ncnn && make")
+    os.system("./build/test_torch_sqrt_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_square.py b/tools/pnnx/tests/ncnn/test_torch_square.py
index d5b5c8af910..320f6503c2d 100644
--- a/tools/pnnx/tests/ncnn/test_torch_square.py
+++ b/tools/pnnx/tests/ncnn/test_torch_square.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_square_ncnn
     b = test_torch_square_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_square_ncnn && make")
+    os.system("./build/test_torch_square_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_squeeze.py b/tools/pnnx/tests/ncnn/test_torch_squeeze.py
index 807997677e4..0d1587676f8 100644
--- a/tools/pnnx/tests/ncnn/test_torch_squeeze.py
+++ b/tools/pnnx/tests/ncnn/test_torch_squeeze.py
@@ -51,9 +51,17 @@ def test():
     import test_torch_squeeze_ncnn
     b = test_torch_squeeze_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_squeeze_ncnn && make")
+    os.system("./build/test_torch_squeeze_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_stack.py b/tools/pnnx/tests/ncnn/test_torch_stack.py
index a55ff5962c5..d8696d936f4 100644
--- a/tools/pnnx/tests/ncnn/test_torch_stack.py
+++ b/tools/pnnx/tests/ncnn/test_torch_stack.py
@@ -55,9 +55,17 @@ def test():
     import test_torch_stack_ncnn
     b = test_torch_stack_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_stack_ncnn && make")
+    os.system("./build/test_torch_stack_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_sum.py b/tools/pnnx/tests/ncnn/test_torch_sum.py
index e32136bf301..e6aaf7f6b7e 100644
--- a/tools/pnnx/tests/ncnn/test_torch_sum.py
+++ b/tools/pnnx/tests/ncnn/test_torch_sum.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_sum_ncnn
     b = test_torch_sum_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_sum_ncnn && make")
+    os.system("./build/test_torch_sum_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_t.py b/tools/pnnx/tests/ncnn/test_torch_t.py
index 2ade16a3875..dc073f5a1b3 100644
--- a/tools/pnnx/tests/ncnn/test_torch_t.py
+++ b/tools/pnnx/tests/ncnn/test_torch_t.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_t_ncnn
     b = test_torch_t_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_t_ncnn && make")
+    os.system("./build/test_torch_t_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_tan.py b/tools/pnnx/tests/ncnn/test_torch_tan.py
index b97bad2fd9a..2bd6f6962a5 100644
--- a/tools/pnnx/tests/ncnn/test_torch_tan.py
+++ b/tools/pnnx/tests/ncnn/test_torch_tan.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_tan_ncnn
     b = test_torch_tan_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_tan_ncnn && make")
+    os.system("./build/test_torch_tan_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_tanh.py b/tools/pnnx/tests/ncnn/test_torch_tanh.py
index 10b1b72ffcd..5e632886358 100644
--- a/tools/pnnx/tests/ncnn/test_torch_tanh.py
+++ b/tools/pnnx/tests/ncnn/test_torch_tanh.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_tanh_ncnn
     b = test_torch_tanh_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_tanh_ncnn && make")
+    os.system("./build/test_torch_tanh_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_tensor_split.py b/tools/pnnx/tests/ncnn/test_torch_tensor_split.py
index 0ff57104d29..c0c514ea1b0 100644
--- a/tools/pnnx/tests/ncnn/test_torch_tensor_split.py
+++ b/tools/pnnx/tests/ncnn/test_torch_tensor_split.py
@@ -57,9 +57,17 @@ def test():
     import test_torch_tensor_split_ncnn
     b = test_torch_tensor_split_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_tensor_split_ncnn && make")
+    os.system("./build/test_torch_tensor_split_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_transpose.py b/tools/pnnx/tests/ncnn/test_torch_transpose.py
index cfd7204d809..e0904a7dad1 100644
--- a/tools/pnnx/tests/ncnn/test_torch_transpose.py
+++ b/tools/pnnx/tests/ncnn/test_torch_transpose.py
@@ -52,9 +52,17 @@ def test():
     import test_torch_transpose_ncnn
     b = test_torch_transpose_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_transpose_ncnn && make")
+    os.system("./build/test_torch_transpose_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_trunc.py b/tools/pnnx/tests/ncnn/test_torch_trunc.py
index c2e42f7b554..f5b7721cd88 100644
--- a/tools/pnnx/tests/ncnn/test_torch_trunc.py
+++ b/tools/pnnx/tests/ncnn/test_torch_trunc.py
@@ -49,9 +49,17 @@ def test():
     import test_torch_trunc_ncnn
     b = test_torch_trunc_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_trunc_ncnn && make")
+    os.system("./build/test_torch_trunc_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_unbind.py b/tools/pnnx/tests/ncnn/test_torch_unbind.py
index 8e224612d7e..4365f0f5a99 100644
--- a/tools/pnnx/tests/ncnn/test_torch_unbind.py
+++ b/tools/pnnx/tests/ncnn/test_torch_unbind.py
@@ -60,9 +60,17 @@ def test():
     import test_torch_unbind_ncnn
     b = test_torch_unbind_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_unbind_ncnn && make")
+    os.system("./build/test_torch_unbind_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.equal(a0, b0):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.equal(a0, c0):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torch_unsqueeze.py b/tools/pnnx/tests/ncnn/test_torch_unsqueeze.py
index b15a43419e4..66227ec3af6 100644
--- a/tools/pnnx/tests/ncnn/test_torch_unsqueeze.py
+++ b/tools/pnnx/tests/ncnn/test_torch_unsqueeze.py
@@ -52,9 +52,17 @@ def test():
     import test_torch_unsqueeze_ncnn
     b = test_torch_unsqueeze_ncnn.test_inference()
 
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torch_unsqueeze_ncnn && make")
+    os.system("./build/test_torch_unsqueeze_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+
     for a0, b0 in zip(a, b):
         if not torch.allclose(a0, b0, 1e-4, 1e-4):
             return False
+    for a0, c0 in zip(a, c):
+        if not torch.allclose(a0, c0, 1e-4, 1e-4):
+            return False
     return True
 
 if __name__ == "__main__":
diff --git a/tools/pnnx/tests/ncnn/test_torchvision_DeformConv2d.py b/tools/pnnx/tests/ncnn/test_torchvision_DeformConv2d.py
index e7eba10168d..6ae1d300d08 100644
--- a/tools/pnnx/tests/ncnn/test_torchvision_DeformConv2d.py
+++ b/tools/pnnx/tests/ncnn/test_torchvision_DeformConv2d.py
@@ -56,7 +56,13 @@ def test():
     import test_torchvision_DeformConv2d_ncnn
     b0, b1 = test_torchvision_DeformConv2d_ncnn.test_inference()
 
-    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_torchvision_DeformConv2d_ncnn && make")
+    os.system("./build/test_torchvision_DeformConv2d_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c0, c1 = c
+
+    return torch.allclose(a0, b0, 1e-4, 1e-4) and torch.allclose(a0, c0, 1e-4, 1e-4) and torch.allclose(a1, b1, 1e-4, 1e-4) and torch.allclose(a1, c1, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():
diff --git a/tools/pnnx/tests/ncnn/test_vit_b_32.py b/tools/pnnx/tests/ncnn/test_vit_b_32.py
index a610bf553a4..3a390555813 100644
--- a/tools/pnnx/tests/ncnn/test_vit_b_32.py
+++ b/tools/pnnx/tests/ncnn/test_vit_b_32.py
@@ -44,7 +44,13 @@ def test():
     import test_vit_b_32_ncnn
     b = test_vit_b_32_ncnn.test_inference()
 
-    return torch.allclose(a, b, 1e-4, 1e-4)
+    # pnnx inference cpp
+    os.system("mkdir -p build && cd build && cmake .. -DFNAME=test_vit_b_32_ncnn && make")
+    os.system("./build/test_vit_b_32_ncnn")
+    c = list(torch.jit.load("out.pt").parameters())
+    c = c[0]
+
+    return torch.allclose(a, b, 1e-4, 1e-4) and torch.allclose(a, c, 1e-4, 1e-4)
 
 if __name__ == "__main__":
     if test():

From 913aa7d2af568d0500c758905fe55388a007642f Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Thu, 3 Oct 2024 01:25:01 +0800
Subject: [PATCH 8/9] pnnx ci

---
 .ci/pnnx.yml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/.ci/pnnx.yml b/.ci/pnnx.yml
index d49da39a0af..1a98761c4ec 100644
--- a/.ci/pnnx.yml
+++ b/.ci/pnnx.yml
@@ -4,14 +4,12 @@ on:
     branches: [master]
     paths:
     - '.ci/pnnx.yml'
-    - 'src/layer/*'
     - 'tools/pnnx/**'
     - '!tools/pnnx/README.md'
   mr:
     target-branches: [master]
     paths:
     - '.ci/pnnx.yml'
-    - 'src/layer/*'
     - 'tools/pnnx/**'
     - '!tools/pnnx/README.md'
 concurrency:
@@ -196,7 +194,13 @@ jobs:
         export OMP_NUM_THREADS=1
         export MKL_NUM_THREADS=1
         export MKL_ENABLE_INSTRUCTIONS=SSE4_2
+        export Torch_DIR=${{ci.workspace}}/pnnx-deps-torch-install/share/cmake/Torch
+        export ncnn_DIR=$(pwd)/build/install/lib/cmake/ncnn
+        echo ${{ci.workspace}}/pnnx-deps-torch-install
+        echo $ncnn_DIR
+        ls
         cd tools/pnnx
+        cp tests/ncnn/CMakeListsForCPP.txt build/tests/ncnn/CMakeLists.txt
         cd build && ctest --output-on-failure -j 16
 
     - name: python-pnnx

From 05f2c046b8e62fac92c23621ca55ef3d9e15c993 Mon Sep 17 00:00:00 2001
From: wnqn1597 <beqjal0@gmail.com>
Date: Thu, 3 Oct 2024 01:28:44 +0800
Subject: [PATCH 9/9] fix bug

---
 .ci/pnnx.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.ci/pnnx.yml b/.ci/pnnx.yml
index 1a98761c4ec..bf0d4a51940 100644
--- a/.ci/pnnx.yml
+++ b/.ci/pnnx.yml
@@ -4,12 +4,14 @@ on:
     branches: [master]
     paths:
     - '.ci/pnnx.yml'
+    - 'src/layer/*'
     - 'tools/pnnx/**'
     - '!tools/pnnx/README.md'
   mr:
     target-branches: [master]
     paths:
     - '.ci/pnnx.yml'
+    - 'src/layer/*'
     - 'tools/pnnx/**'
     - '!tools/pnnx/README.md'
 concurrency: