Add onnx demos

Author: meenakshiramanathan1

demos/tt-forge-onnx/onnx/cnn/alexnet_demo.py

@@ -0,0 +1,28 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.alexnet.image_classification.onnx import ModelLoader
+
+
+def run_alexnet_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("alexnet", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Print the results
+
+
+if __name__ == "__main__":
+    run_alexnet_demo_case()

demos/tt-forge-onnx/onnx/cnn/densenet_demo.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.densenet.image_classification.onnx import ModelLoader
+
+
+def run_densenet_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("densenet121", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Print the results
+        loader.print_cls_results(output)
+
+
+if __name__ == "__main__":
+    run_densenet_demo_case()

demos/tt-forge-onnx/onnx/cnn/googlenet_demo.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.googlenet.image_classification.onnx import ModelLoader
+
+
+def run_googlenet_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("googlenet", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Print the results
+        loader.print_cls_results(output)
+
+
+if __name__ == "__main__":
+    run_googlenet_demo_case()

demos/tt-forge-onnx/onnx/cnn/mobilenetv1_demo.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.mobilenetv1.image_classification.onnx import ModelLoader
+
+
+def run_mobilenetv1_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("mobilenetv1", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Print the results
+        loader.print_cls_results(output)
+
+
+if __name__ == "__main__":
+    run_mobilenetv1_demo_case()

demos/tt-forge-onnx/onnx/cnn/resnet_demo.py

@@ -0,0 +1,44 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.resnet.image_classification.onnx import ModelLoader, ModelVariant
+
+
+def run_resnet_onnx(variant):
+    loader = ModelLoader(variant=variant)
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs().contiguous()
+        framework_model = forge.OnnxModule(variant.value, onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+        loader.print_cls_results(output)
+
+        print("=" * 60, flush=True)
+
+
+if __name__ == "__main__":
+    demo_cases = [
+        ModelVariant.RESNET_50_HF,
+        ModelVariant.RESNET_50_HF_HIGH_RES,
+        ModelVariant.RESNET_50_TIMM,
+        ModelVariant.RESNET_50_TIMM_HIGH_RES,
+        ModelVariant.RESNET_18,
+        ModelVariant.RESNET_34,
+        ModelVariant.RESNET_50,
+        ModelVariant.RESNET_50_HIGH_RES,
+        ModelVariant.RESNET_101,
+        ModelVariant.RESNET_152,
+    ]
+
+    # Run each demo case
+    for variant in demo_cases:
+        run_resnet_onnx(variant)

demos/tt-forge-onnx/onnx/cnn/vgg_demo.py

@@ -0,0 +1,29 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.vgg.image_classification.onnx import ModelLoader
+
+
+def run_vgg_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs().contiguous()
+        framework_model = forge.OnnxModule("vgg11", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Print the results
+        loader.print_cls_results(output)
+
+
+if __name__ == "__main__":
+    run_vgg_demo_case()

demos/tt-forge-onnx/onnx/multimodal/nbeats_demo.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.nbeats.time_series_forecasting.onnx import ModelLoader
+
+
+def run_nbeats_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("nbeats", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, inputs)
+
+        # Run inference on Tenstorrent device
+        compiled_model(*inputs)
+
+
+if __name__ == "__main__":
+    run_nbeats_demo_case()

demos/tt-forge-onnx/onnx/nlp/roberta_demo.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.roberta.sequence_classification.onnx.loader import ModelLoader
+
+
+def run_roberta_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("roberta_sequence_classification", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Decode the output
+        predicted_value = loader.decode_output(output)
+        print(f"Predicted Sentiment: {predicted_value}")
+
+
+if __name__ == "__main__":
+    run_roberta_demo_case()

demos/tt-forge-onnx/onnx/nlp/squeezebert_demo.py

@@ -0,0 +1,30 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.squeezebert.sequence_classification.onnx.loader import ModelLoader
+
+
+def run_squeezebert_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("squeezebert_sequence_classification", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, [inputs])
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(inputs)
+
+        # Decode the output
+        predicted_value = loader.decode_output(output)
+        print(f"Predicted Category: {predicted_value}")
+
+
+if __name__ == "__main__":
+    run_squeezebert_demo_case()

demos/tt-forge-onnx/onnx/nlp/t5_demo.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: (c) 2026 Tenstorrent AI ULC
+#
+# SPDX-License-Identifier: Apache-2.0
+import tempfile
+import forge
+from third_party.tt_forge_models.t5.causal_lm.onnx.loader import ModelLoader
+
+
+def run_t5_demo_case():
+    loader = ModelLoader()
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # Load model and input
+        onnx_model = loader.load_model(onnx_tmp_path=tmpdir)
+        inputs = loader.load_inputs()
+        framework_model = forge.OnnxModule("t5_causal_lm", onnx_model)
+
+        # Compile the model using Forge
+        compiled_model = forge.compile(framework_model, inputs)
+
+        # Run inference on Tenstorrent device
+        output = compiled_model(*inputs)
+
+
+if __name__ == "__main__":
+    run_t5_demo_case()