Parameter Annotations

Generic Annotation

Use the Parameter.Generic annotation to provide information about a general input or output parameters:

model.py

from muna import compile, Parameter
from typing import Annotated

@compile(...)
def area(
    radius: Annotated[
        float,
        Parameter.Generic(description="Radius of the circle.")
    ]
) -> float:
    ...

Below is the full Parameter.Generic annotation definition:

@classmethod
def Generic(
    cls,
    *,
    description: str  # Parameter description.
) -> Parameter: ...

Numeric Annotation

Use the Parameter.Numeric annotation to specify numeric input or output parameters:

calculate_area.py

from muna import compile, Parameter
from typing import Annotated

@compile(...)
def area(
    radius: Annotated[
        float,
        Parameter.Numeric(
            description="Circle radius.",
            min=1.,
            max=12.
        )
    ]
) -> float:
    ...

Below is the full Parameter.Numeric annotation definition:

@classmethod
def Numeric(
    cls,
    *,
    description: str,         # Parameter description.
    min: float | None=None,   # Minimum value.
    max: float | None=None    # Maximum value.
) -> Parameter: ...

Audio Annotation

Use the Parameter.Audio annotation to specify audio parameters:

transcribe_audio.py

from muna import compile, Parameter
from numpy import ndarray
from typing import Annotated

@compile(...)
def transcribe_audio(
    audio: Annotated[
        ndarray,
        Parameter.Audio(
            description="Input audio.",
            sample_rate=24_000
        )
    ]
) -> str:
    ...

The Parameter.Audio annotation allows the compiled model to be used by our OpenAI speech client.

Below is the full Parameter.Audio annotation definition:

@classmethod
def Audio(
    cls,
    *,
    description: str, # Parameter description.
    sample_rate: int  # Audio sample rate in Hertz.
) -> Parameter: ...

Audio Speed Annotation

Use the Parameter.AudioSpeed annotation to specify audio speed parameters in audio generation models:

generate_speech.py

from muna import compile, Parameter
from numpy import ndarray
from typing import Annotated

@compile(...)
def generate_speech(
    text: str,
    speed: Annotated[
        float,
        Parameter.AudioSpeed(
            description="The speed of the generated audio.",
            min=0.25,
            max=4.0
        )
    ] = 1.0
) -> ndarray:
    ...

Below is the full Parameter.AudioSpeed annotation definition:

@classmethod
def AudioSpeed(
    cls,
    *,
    description: str,       # Parameter description.
    min: float | None=None, # Minimum audio speed.
    max: float | None=None  # Maximum audio speed.
) -> Parameter: ...

Audio Voice Annotation

Use the Parameter.AudioVoice annotation to specify audio voice parameters in audio generation models:

generate_speech.py

from muna import compile, Parameter
from numpy import ndarray
from typing import Annotated, Literal

Voice = Literal["almas", "parv", "rhea", "sam"]

@compile(...)
def generate_speech(
    text: str,
    voice: Annotated[
        Voice,
        Parameter.AudioVoice(description="Voice to use when generating audio.")
    ],
    speed: float=1.0
) -> ndarray:
    ...

Below is the full Parameter.AudioVoice annotation definition:

@classmethod
def AudioVoice(
    cls,
    *,
    description: str    # Parameter description.
) -> Parameter: ...

Bounding Box Annotation

Use the Parameter.BoundingBox or Parameter.BoundingBoxes annotations to specify bounding box parameters in object detection models:

from muna import compile, Parameter
from PIL import Image
from typing import Annotated, Literal

@compile(...)
def detect_object(
    image: Image.Image
) -> Annotated[
    Detection,
    Parameter.BoundingBox(description="Detected object.")
]:
    ...

from muna import compile, Parameter
from PIL import Image
from typing import Annotated, Literal

@compile(...)
def detect_objects(
    image: Image.Image
) -> Annotated[
    list[Detection],
    Parameter.BoundingBoxes(description="Detected objects.")
]:
    ...

Below is the full Parameter.BoundingBox annotation definition:

@classmethod
def BoundingBox(
    cls,
    *,
    description: str    # Parameter description.
) -> Parameter: ...

@classmethod
def BoundingBoxes(
    cls,
    *,
    description: str    # Parameter description.
) -> Parameter: ...

Depth Map Annotation

Use the Parameter.DepthMap annotation to specify depth map parameters in depth estimation models:

estimate_depth.py

from muna import compile, Parameter
from numpy import ndarray
from PIL import Image
from typing import Annotated

@compile(...)
def estimate_depth(
    image: Image.Image
) -> Annotated[
    ndarray,
    Parameter.DepthMap(description="Metric depth tensor.")
]:
    ...

Below is the full Parameter.DepthMap annotation definition:

@classmethod
def DepthMap(
    cls,
    *,
    description: str    # Parameter description.
) -> Parameter: ...

Embedding Annotation

Use the Parameter.Embedding annotation to specify vector embedding parameters in embedding models:

embed_text.py

from muna import compile, Parameter
from numpy import ndarray
from typing import Annotated

@compile(...)
def embed_text(
    text: str
) -> Annotated[
    ndarray,
    Parameter.Embedding(description="Embedding vector.")
]:
    ...

The Parameter.Embedding annotation allows the compiled model to be used by our
OpenAI embedding client.

Below is the full Parameter.Embedding annotation definition:

@classmethod
def Embedding(
    cls,
    *,
    description: str  # Parameter description.
) -> Parameter: ...

Embedding Dimensions Annotation

Use the Parameter.EmbeddingDims annotation to specify an embedding Matryoshka dimension parameter in embedding models:

embed_text.py

from muna import compile, Parameter
from numpy import ndarray
from typing import Annotated

@compile(...)
def embed_text(
    text: str,
    dims: Annotated[
        int,
        Parameter.EmbeddingDims(description="Embedding dimensions.")
    ]
) -> ndarray:
    ...

Below is the full Parameter.EmbeddingDims annotation definition:

@classmethod
def EmbeddingDims(
    cls,
    *,
    description: str,       # Parameter description.
    min: int | None=None,   # Minimum embedding dimensions.
    max: int | None=None    # Maximum embedding dimensions.
) -> Parameter: ...

Compiling Models

Insiders

Parameter Annotations