feat: publishing infernet-container-starter v0.2.0

projects/onnx-iris/container/Dockerfile

@@ -0,0 +1,25 @@
+FROM python:3.11-slim as builder
+
+WORKDIR /app
+
+ENV PYTHONUNBUFFERED 1
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PIP_NO_CACHE_DIR 1
+ENV RUNTIME docker
+ENV PYTHONPATH src
+
+RUN apt-get update
+RUN apt-get install -y git curl
+
+# install uv
+ADD --chmod=755 https://astral.sh/uv/install.sh /install.sh
+RUN /install.sh && rm /install.sh
+
+COPY src/requirements.txt .
+
+RUN /root/.cargo/bin/uv pip install --system --no-cache -r requirements.txt
+
+COPY src src
+
+ENTRYPOINT ["hypercorn", "app:create_app()"]
+CMD ["-b", "0.0.0.0:3000"]

projects/onnx-iris/container/Makefile

@@ -0,0 +1,17 @@
+DOCKER_ORG := ritualnetwork
+EXAMPLE_NAME := onnx-iris
+TAG := $(DOCKER_ORG)/example-$(EXAMPLE_NAME)-infernet:latest
+
+.phony: build run build-multiplatform
+
+build:
+	@docker build -t $(TAG) .
+
+run:
+	docker run -p 3000:3000 $(TAG)
+
+# You may need to set up a docker builder, to do so run:
+# docker buildx create --name mybuilder --bootstrap --use
+# refer to https://docs.docker.com/build/building/multi-platform/#building-multi-platform-images for more info
+build-multiplatform:
+	docker buildx build --platform linux/amd64,linux/arm64 -t $(TAG) --push .

projects/onnx-iris/container/README.md

@@ -0,0 +1,96 @@
+# Iris Classification via ONNX Runtime
+
+This example uses a pre-trained model to classify iris flowers. The code for the model
+is located at
+our [simple-ml-models](https://github.com/ritual-net/simple-ml-models/tree/main/iris_classification)
+repository.
+
+## Overview
+
+We're making use of
+the [ONNXInferenceWorkflow](https://github.com/ritual-net/infernet-ml-internal/blob/main/src/ml/workflows/inference/onnx_inference_workflow.py)
+class to run the model. This is one of many workflows that we currently support in our
+[infernet-ml](https://github.com/ritual-net/infernet-ml-internal). Consult the library's
+documentation for more info on workflows that
+are supported.
+
+## Building & Running the Container in Isolation
+
+Note that this container is meant to be started by the infernet-node. For development &
+Testing purposes, you can run the container in isolation using the following commands.
+
+### Building the Container
+
+Simply run the following command to build the container.
+
+```bash
+make build
+```
+
+Consult the [Makefile](./Makefile) for the build command.
+
+### Running the Container
+
+To run the container, you can use the following command:
+
+```bash
+make run
+```
+
+## Testing the Container
+
+Run the following command to run an inference:
+
+```bash
+curl -X POST http://127.0.0.1:3000/service_output \
+     -H "Content-Type: application/json" \
+     -d '{"source":1, "data": {"input": [[1.0380048, 0.5586108, 1.1037828, 1.712096]]}}'
+```
+
+#### Note Regarding the Input
+
+The inputs provided above correspond to an iris flower with the following
+characteristics. Refer to the
+
+1. Sepal Length: `5.5cm`
+2. Sepal Width: `2.4cm`
+3. Petal Length: `3.8cm`
+4. Petal Width: `1.1cm`
+
+Putting this input into a vector and scaling it, we get the following scaled input:
+
+```python
+[1.0380048, 0.5586108, 1.1037828, 1.712096]
+```
+
+Refer
+to [this function in the model's repository](https://github.com/ritual-net/simple-ml-models/blob/03ebc6fb15d33efe20b7782505b1a65ce3975222/iris_classification/iris_inference_pytorch.py#L13)
+for more information on how the input is scaled.
+
+For more context on the Iris dataset, refer to
+the [UCI Machine Learning Repository](https://archive.ics.uci.edu/ml/datasets/iris).
+
+### Output
+
+By running the above command, you should get a response similar to the following:
+
+```json
+[
+  [
+    [
+      0.0010151526657864451,
+      0.014391022734344006,
+      0.9845937490463257
+    ]
+  ]
+]
+```
+
+The response corresponds to the model's prediction for each of the classes:
+
+```python
+['setosa', 'versicolor', 'virginica']
+```
+
+In this case, the model predicts that the input corresponds to the class `virginica`with
+a probability of `0.9845937490463257`(~98.5%).

projects/onnx-iris/container/config.json

@@ -0,0 +1,50 @@
+{
+    "log_path": "infernet_node.log",
+    "server": {
+        "port": 4000
+    },
+    "chain": {
+        "enabled": true,
+        "trail_head_blocks": 0,
+        "rpc_url": "http://host.docker.internal:8545",
+        "coordinator_address": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        "wallet": {
+            "max_gas_limit": 4000000,
+            "private_key": "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d"
+        }
+    },
+    "startup_wait": 1.0,
+    "docker": {
+        "username": "your-username",
+        "password": ""
+    },
+    "redis": {
+        "host": "redis",
+        "port": 6379
+    },
+    "forward_stats": true,
+    "containers": [
+        {
+            "id": "onnx-iris",
+            "image": "ritualnetwork/example-onnx-iris-infernet:latest",
+            "external": true,
+            "port": "3000",
+            "allowed_delegate_addresses": [],
+            "allowed_addresses": [],
+            "allowed_ips": [],
+            "command": "--bind=0.0.0.0:3000 --workers=2",
+            "env": {}
+        },
+        {
+            "id": "anvil-node",
+            "image": "ritualnetwork/infernet-anvil:0.0.0",
+            "external": true,
+            "port": "8545",
+            "allowed_delegate_addresses": [],
+            "allowed_addresses": [],
+            "allowed_ips": [],
+            "command": "",
+            "env": {}
+        }
+    ]
+}

projects/onnx-iris/container/scripts/sample_endpoints.py

@@ -0,0 +1,52 @@
+import asyncio
+
+import aiohttp
+from eth_abi import encode, decode  # type: ignore
+
+
+async def ping(session: aiohttp.ClientSession) -> None:
+    async with session.get("http://127.0.0.1:3000/") as response:
+        print(await response.text())
+
+
+async def post_directly_web2(session: aiohttp.ClientSession) -> None:
+    async with session.post(
+        "http://127.0.0.1:3000/service_output",
+        json={
+            "source": 1,
+            "data": {"input": [[1.0380048, 0.5586108, 1.1037828, 1.712096]]},
+        },
+    ) as response:
+        print(await response.json())
+
+
+async def post_directly_web3(session: aiohttp.ClientSession) -> None:
+    async with session.post(
+        "http://127.0.0.1:3000/service_output",
+        json={
+            "source": 0,
+            "data": encode(
+                ["uint256[]"], [[1_038_004, 558_610, 1_103_782, 1_712_096]]
+            ).hex(),
+        },
+    ) as response:
+        print(await response.text())
+        result = await response.json()
+        output = result["raw_output"]
+        result = decode(["uint256[]"], bytes.fromhex(output))[0]
+        print(f"result: {result}")
+
+
+# async maine
+async def main(session: aiohttp.ClientSession) -> None:
+    await post_directly_web3(session)
+
+
+if __name__ == "__main__":
+    # run main async
+
+    async def provide_session() -> None:
+        async with aiohttp.ClientSession() as session:
+            await main(session)
+
+    asyncio.run(provide_session())

projects/onnx-iris/container/src/app.py

@@ -0,0 +1,107 @@
+import logging
+from typing import Any, cast, List
+
+import numpy as np
+from eth_abi import decode, encode  # type: ignore
+from infernet_ml.utils.model_loader import ModelSource
+from infernet_ml.utils.service_models import InfernetInput, InfernetInputSource
+from infernet_ml.workflows.inference.onnx_inference_workflow import (
+    ONNXInferenceWorkflow,
+)
+from quart import Quart, request
+from quart.json.provider import DefaultJSONProvider
+
+log = logging.getLogger(__name__)
+
+
+class NumpyJsonEncodingProvider(DefaultJSONProvider):
+    @staticmethod
+    def default(obj: Any) -> Any:
+        if isinstance(obj, np.ndarray):
+            # Convert NumPy arrays to list
+            return obj.tolist()
+        # fallback to default JSON encoding
+        return DefaultJSONProvider.default(obj)
+
+
+def create_app() -> Quart:
+    Quart.json_provider_class = NumpyJsonEncodingProvider
+    app = Quart(__name__)
+    # we are downloading the model from the hub.
+    # model repo is located at: https://huggingface.co/Ritual-Net/iris-dataset
+    model_source = ModelSource.HUGGINGFACE_HUB
+    model_args = {"repo_id": "Ritual-Net/iris-dataset", "filename": "iris.onnx"}
+
+    workflow = ONNXInferenceWorkflow(model_source=model_source, model_args=model_args)
+    workflow.setup()
+
+    @app.route("/")
+    def index() -> str:
+        """
+        Utility endpoint to check if the service is running.
+        """
+        return "ONNX Iris Classifier Example Program"
+
+    @app.route("/service_output", methods=["POST"])
+    async def inference() -> dict[str, Any]:
+        req_data = await request.get_json()
+        """
+        InfernetInput has the format:
+            source: (0 on-chain, 1 off-chain)
+            data: dict[str, Any]
+        """
+        infernet_input: InfernetInput = InfernetInput(**req_data)
+
+        if infernet_input.source == InfernetInputSource.OFFCHAIN:
+            web2_input = cast(dict[str, Any], infernet_input.data)
+            values = cast(List[List[float]], web2_input["input"])
+        else:
+            # On-chain requests are sent as a generalized hex-string which we will
+            # decode to the appropriate format.
+            web3_input: List[int] = decode(
+                ["uint256[]"], bytes.fromhex(cast(str, infernet_input.data))
+            )[0]
+            values = [[float(v) / 1e6 for v in web3_input]]
+
+        """
+        The input to the onnx inference workflow needs to conform to ONNX runtime's
+        input_feed format. For more information refer to:
+        https://docs.ritual.net/ml-workflows/inference-workflows/onnx_inference_workflow
+        """
+        result: dict[str, Any] = workflow.inference({"input": values})
+
+        if infernet_input.source == InfernetInputSource.OFFCHAIN:
+            """
+            In case of an off-chain request, the result is returned as is.
+            """
+            return result
+        else:
+            """
+            In case of an on-chain request, the result is returned in the format:
+            {
+                "raw_input": str,
+                "processed_input": str,
+                "raw_output": str,
+                "processed_output": str,
+                "proof": str,
+            }
+            refer to: https://docs.ritual.net/infernet/node/containers for more info.
+            """
+            predictions = cast(List[List[List[float]]], result)
+            predictions_normalized = [int(p * 1e6) for p in predictions[0][0]]
+            return {
+                "raw_input": "",
+                "processed_input": "",
+                "raw_output": encode(["uint256[]"], [predictions_normalized]).hex(),
+                "processed_output": "",
+                "proof": "",
+            }
+
+    return app
+
+
+if __name__ == "__main__":
+    """
+    Utility to run the app locally. For development purposes only.
+    """
+    create_app().run(port=3000)

projects/onnx-iris/container/src/requirements.txt

@@ -0,0 +1,7 @@
+quart==0.19.4
+infernet_ml==0.1.0
+PyArweave @ git+https://github.com/ritual-net/pyarweave.git
+web3==6.15.0
+onnx==1.15.0
+onnxruntime==1.16.3
+torch==2.1.2