EZKL - Infernet ML
Description: Infernet ML Documentation

Skip to content

# EZKL Artifacts

EZKL is an engine for doing inference for deep learning models and other computational graphs in a zk-snark (ZKML). To use EZKL, you need to:

1. Perform a setup & generate settings
2. Calibrate the settings
3. Compile your circuit

You then can use the generated files to perform verifiable inference. Below we show how to generate the artifacts & run them. We also show how to upload the artifacts to a repository.

## Generate Artifacts

You need to have a trained model exported in the ONNX format. Once you have your model exported, you can generate the artifacts using the following code:

    from infernet_ml.zk.ezkl.ezkl_artifact import (
        ArtifactGenerationArgs,
        EZKLArtifact,
        generate_ezkl_artifacts,
    )
    from pathlib import Path
    from infernet_ml.resource.artifact_manager import RitualArtifactManager

    async def generate_artifacts_and_proof(onnx_path: Path, target_dir: Path) -> None:
        """
        Generate an EZKL artifact, generate a proof, and verify the proof.

        Args:
            onnx_path: The path to the ONNX model file
            target_dir: The directory to save the generated artifacts

        Returns:
            None
        """
        artifact = await generate_ezkl_artifacts(
            ArtifactGenerationArgs(
                onnx_path=onnx_path,
                input_visibility="public",
                output_visibility="public",
                param_visibility="fixed",
            ),
        )

        assert artifact.prover_key_path
        assert artifact.prover_key_path.exists()
        artifact_manager = RitualArtifactManager[EZKLArtifact](artifact=artifact)

        artifact_manager.to_dir(target_dir)

    if __name__ == "__main__":
        onnx_path = Path("path/to/onnx/model")
        target_dir = Path("path/to/save/artifacts")
        generate_artifacts_and_proof(onnx_path, target_dir)

By running the above code, you will generate the artifacts and save them in the target directory.

## Run Artifacts

You can now run an inference using the generated artifacts. Below is an example of how to generate a proof and verify it.

    from infernet_ml.zk.ezkl.ezkl_artifact import (
        EZKLArtifact,
    )
    from pathlib import Path
    from infernet_ml.zk.ezkl.ezkl_utils import generate_proof, verify_proof
    from infernet_ml.utils.onnx_utils import generate_dummy_input

    async def run_model(artifact: EZKLArtifact, onnx_path: Path) -> None:
        sample_input = generate_dummy_input(onnx_path)

        proof = await generate_proof(
            artifact_files=artifact,
            input_data=sample_input,
            prover_key=artifact.prover_key_path.read_bytes(),
        )

        assert artifact.verifier_key_path

        proof.verify_key = artifact.verifier_key_path.read_bytes()

        verify = await verify_proof(proof, artifact)
        print(f"proof verification result: {verify}")
        print(f"proof output: {proof.output}")

## Upload Artifacts to a Repository

As we mentioned in the Artifact Management documentation, EZKLArtifact is one such Pydantic class that you can use in conjunction with RitualArtifactManager to upload/download to various repositories.

    from infernet_ml.resource.artifact_manager import RitualArtifactManager
    from infernet_ml.zk.ezkl.ezkl_artifact import (
        EZKLArtifact,
    )
    from pathlib import Path

    artifact_manager: RitualArtifactManager[
        EZKLArtifact
    ] = RitualArtifactManager.from_dir(
        EZKLArtifact, Path(f"./linreg-100-features")
    )

    # to upload to huggingface
    artifact_manager.to_repo("huggingface/my-account/linreg-100-features")

    # to upload to arweave
    artifact_manager.to_repo("areweave/<my-wallet-address>/linreg-100-features")