clarifai 9.8.1__py3-none-any.whl → 9.9.0__py3-none-any.whl

clarifai_utils/models/model_serving/model_config/config.py

@@ -0,0 +1,298 @@
+# Copyright 2023 Clarifai, Inc.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+""" Model Config classes."""
+
+from dataclasses import asdict, dataclass, field
+from typing import List
+
+import yaml
+
+from ..models.model_types import *  # noqa # pylint: disable=unused-import
+from ..models.output import *  # noqa # pylint: disable=unused-import
+
+__all__ = ["get_model_config", "MODEL_TYPES", "TritonModelConfig", "ModelTypes"]
+
+### Triton Model Config classes.###
+
+
+@dataclass
+class DType:
+  """
+  Triton Model Config data types.
+  """
+  # https://github.com/triton-inference-server/common/blob/main/protobuf/model_config.proto
+  TYPE_UINT8: int = 2
+  TYPE_INT8: int = 6
+  TYPE_INT16: int = 7
+  TYPE_INT32: int = 8
+  TYPE_INT64: int = 9
+  TYPE_FP16: int = 10
+  TYPE_FP32: int = 11
+  TYPE_STRING: int = 13
+  KIND_GPU: int = 1
+  KIND_CPU: int = 2
+
+
+@dataclass
+class InputConfig:
+  """
+  Triton Input definition.
+  Params:
+  -------
+  name: input name
+  data_type: input data type
+  dims: Pre-defined input data shape(s).
+
+  Returns:
+  --------
+  InputConfig
+  """
+  name: str
+  data_type: int
+  dims: List = field(default_factory=list)
+
+
+@dataclass
+class OutputConfig:
+  """
+  Triton Output definition.
+  Params:
+  -------
+  name: output name
+  data_type: output data type
+  dims: Pre-defined output data shape(s).
+  labels (bool): If labels file is required for inference.
+
+  Returns:
+  --------
+  OutputConfig
+  """
+  name: str
+  data_type: int
+  dims: List = field(default_factory=list)
+  labels: bool = False
+
+  def __post_init__(self):
+    if self.labels:
+      self.label_filename = "labels.txt"
+    del self.labels
+
+
+@dataclass
+class Device:
+  """
+  Triton instance_group.
+  Define the type of inference device and number of devices to use.
+  Params:
+  -------
+  count: number of devices
+  use_gpu: whether to use cpu or gpu.
+
+  Returns:
+  --------
+  Device object
+  """
+  count: int = 1
+  use_gpu: bool = True
+
+  def __post_init__(self):
+    if self.use_gpu:
+      self.kind: str = DType.KIND_GPU
+    else:
+      self.kind: str = DType.KIND_CPU
+
+
+@dataclass
+class DynamicBatching:
+  """
+  Triton dynamic_batching config.
+  Params:
+  -------
+  preferred_batch_size: batch size
+  max_queue_delay_microseconds: max queue delay for a request batch
+
+  Returns:
+  --------
+  DynamicBatching object
+  """
+  #preferred_batch_size: List[int] = [1] # recommended not to set
+  max_queue_delay_microseconds: int = 500
+
+
+@dataclass
+class TritonModelConfig:
+  """
+  Triton Model Config base.
+  Params:
+  -------
+  name: triton inference model name
+  input: a list of an InputConfig field
+  output: a list of OutputConfig fields/dicts
+  instance_group: Device. see Device
+  dynamic_batching: Triton dynamic batching settings.
+  max_batch_size: max request batch size
+  backend: Triton Python Backend. Constant
+
+  Returns:
+  --------
+  TritonModelConfig
+  """
+  model_type: str
+  model_name: str
+  model_version: str
+  image_shape: List  #(H, W)
+  input: List[InputConfig] = field(default_factory=list)
+  output: List[OutputConfig] = field(default_factory=list)
+  instance_group: Device = field(default_factory=Device)
+  dynamic_batching: DynamicBatching = field(default_factory=DynamicBatching)
+  max_batch_size: int = 1
+  backend: str = "python"
+
+  def __post_init__(self):
+    if "image" in [each.name for each in self.input]:
+      image_dims = self.image_shape
+      image_dims.append(3)  # add channel dim
+      self.input[0].dims = image_dims
+
+
+### General Model Config classes & functions ###
+
+
+# Clarifai model types
+@dataclass
+class ModelTypes:
+  visual_detector: str = "visual-detector"
+  visual_classifier: str = "visual-classifier"
+  text_classifier: str = "text-classifier"
+  text_to_text: str = "text-to-text"
+  text_embedder: str = "text-embedder"
+  text_to_image: str = "text-to-image"
+  visual_embedder: str = "visual-embedder"
+  visual_segmenter: str = "visual-segmenter"
+
+  def __post_init__(self):
+    self.all = list(asdict(self).values())
+
+
+@dataclass
+class InferenceConfig:
+  wrap_func: callable
+  return_type: dataclass
+
+
+@dataclass
+class FieldMapsConfig:
+  input_fields_map: dict
+  output_fields_map: dict
+
+
+@dataclass
+class DefaultTritonConfig:
+  input: List[InputConfig] = field(default_factory=list)
+  output: List[OutputConfig] = field(default_factory=list)
+
+
+@dataclass
+class ModelConfigClass:
+  type: str = field(init=False)
+  triton: DefaultTritonConfig
+  inference: InferenceConfig
+  field_maps: FieldMapsConfig
+
+  def make_triton_model_config(
+      self,
+      model_name: str,
+      model_version: str,
+      image_shape: List = None,
+      instance_group: Device = Device(),
+      dynamic_batching: DynamicBatching = DynamicBatching(),
+      max_batch_size: int = 1,
+      backend: str = "python",
+  ) -> TritonModelConfig:
+
+    return TritonModelConfig(
+        model_type=self.type,
+        model_name=model_name,
+        model_version=model_version,
+        image_shape=image_shape,
+        instance_group=instance_group,
+        dynamic_batching=dynamic_batching,
+        max_batch_size=max_batch_size,
+        backend=backend,
+        input=self.triton.input,
+        output=self.triton.output)
+
+
+def read_config(cfg: str):
+  with open(cfg, encoding="utf-8") as f:
+    config = yaml.safe_load(f)  # model dict
+
+  # parse default triton
+  input_triton_configs = config["triton"]["input"]
+  output_triton_configs = config["triton"]["output"]
+  triton = DefaultTritonConfig(
+      input=[
+          InputConfig(
+              name=input["name"],
+              data_type=eval(f"DType.{input['data_type']}"),
+              dims=input["dims"]) for input in input_triton_configs
+      ],
+      output=[
+          OutputConfig(
+              name=output["name"],
+              data_type=eval(f"DType.{output['data_type']}"),
+              dims=output["dims"],
+              labels=output["labels"],
+          ) for output in output_triton_configs
+      ])
+
+  # parse inference config
+  inference = InferenceConfig(
+      wrap_func=eval(config["inference"]["wrap_func"]),
+      return_type=eval(config["inference"]["return_type"]),
+  )
+
+  # parse field maps for deployment
+  field_maps = FieldMapsConfig(**config["field_maps"])
+
+  return ModelConfigClass(triton=triton, inference=inference, field_maps=field_maps)
+
+
+def get_model_config(model_type: str) -> ModelConfigClass:
+  """
+  Get model config by model type
+
+  Args:
+
+    model_type (str): One of field value of ModelTypes
+
+  Return:
+    ModelConfigClass
+
+  ### Example:
+  >>> cfg = get_model_config(ModelTypes.text_classifier)
+  >>> custom_triton_config = cfg.make_triton_model_config(**kwargs)
+
+
+  """
+  import os
+  assert model_type in MODEL_TYPES, f"`model_type` must be in {MODEL_TYPES}"
+  cfg = read_config(
+      os.path.join(os.path.dirname(__file__), "model_types_config", f"{model_type}.yaml"))
+  cfg.type = model_type
+  return cfg
+
+
+_model_types = ModelTypes()
+MODEL_TYPES = _model_types.all
+del _model_types

clarifai_utils/models/model_serving/model_config/model_types_config/text-classifier.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: text
+      data_type: TYPE_STRING
+      dims: [1]
+  output:
+    - name: softmax_predictions
+      data_type: TYPE_FP32
+      dims: [-1]
+      labels: true
+inference:
+  wrap_func: text_classifier
+  return_type: ClassifierOutput
+field_maps:
+  input_fields_map:
+    text: text
+  output_fields_map:
+    concepts: softmax_predictions

clarifai_utils/models/model_serving/model_config/model_types_config/text-embedder.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: text
+      data_type: TYPE_STRING
+      dims: [1]
+  output:
+    - name: embeddings
+      data_type: TYPE_FP32
+      dims: [-1]
+      labels: false
+inference:
+  wrap_func: text_embedder
+  return_type: EmbeddingOutput
+field_maps:
+  input_fields_map:
+    text: text
+  output_fields_map:
+    embeddings: embeddings

clarifai_utils/models/model_serving/model_config/model_types_config/text-to-image.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: text
+      data_type: TYPE_STRING
+      dims: [1]
+  output:
+    - name: image
+      data_type: TYPE_UINT8
+      dims: [-1, -1, 3]
+      labels: false
+inference:
+  wrap_func: text_to_image
+  return_type: ImageOutput
+field_maps:
+  input_fields_map:
+    text: text
+  output_fields_map:
+    image: image

clarifai_utils/models/model_serving/model_config/model_types_config/text-to-text.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: text
+      data_type: TYPE_STRING
+      dims: [1]
+  output:
+    - name: text
+      data_type: TYPE_STRING
+      dims: [1]
+      labels: false
+inference:
+  wrap_func: text_to_text
+  return_type: TextOutput
+field_maps:
+  input_fields_map:
+    text: text
+  output_fields_map:
+    text: text

clarifai_utils/models/model_serving/model_config/model_types_config/visual-classifier.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: image
+      data_type: TYPE_UINT8
+      dims: [-1, -1, 3]
+  output:
+    - name: softmax_predictions
+      data_type: TYPE_FP32
+      dims: [-1]
+      labels: true
+inference:
+  wrap_func: visual_classifier
+  return_type: ClassifierOutput
+field_maps:
+  input_fields_map:
+    image: image
+  output_fields_map:
+    concepts: softmax_predictions

clarifai_utils/models/model_serving/model_config/model_types_config/visual-detector.yaml

@@ -0,0 +1,28 @@
+triton:
+  input:
+    - name: image
+      data_type: TYPE_UINT8
+      dims: [-1, -1, 3]
+  output:
+    - name: predicted_bboxes
+      data_type: TYPE_FP32
+      dims: [-1, 4]
+      labels: false
+    - name: predicted_labels
+      data_type: TYPE_INT32
+      dims: [-1, 1]
+      labels: true
+    - name: predicted_scores
+      data_type: TYPE_FP32
+      dims: [-1, 1]
+      labels: false
+inference:
+  wrap_func: visual_detector
+  return_type: VisualDetectorOutput
+field_maps:
+  input_fields_map:
+    image: image
+  output_fields_map:
+    "regions[...].region_info.bounding_box": "predicted_bboxes"
+    "regions[...].data.concepts[...].id": "predicted_labels"
+    "regions[...].data.concepts[...].value": "predicted_scores"

clarifai_utils/models/model_serving/model_config/model_types_config/visual-embedder.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: image
+      data_type: TYPE_UINT8
+      dims: [-1, -1, 3]
+  output:
+    - name: embeddings
+      data_type: TYPE_FP32
+      dims: [-1]
+      labels: false
+inference:
+  wrap_func: visual_embedder
+  return_type: EmbeddingOutput
+field_maps:
+  input_fields_map:
+    image: image
+  output_fields_map:
+    embeddings: embeddings

clarifai_utils/models/model_serving/model_config/model_types_config/visual-segmenter.yaml

@@ -0,0 +1,18 @@
+triton:
+  input:
+    - name: image
+      data_type: TYPE_UINT8
+      dims: [-1, -1, 3]
+  output:
+    - name: predicted_mask
+      data_type: TYPE_INT64
+      dims: [-1, -1]
+      labels: true
+inference:
+  wrap_func: visual_segmenter
+  return_type: MasksOutput
+field_maps:
+  input_fields_map:
+    image: image
+  output_fields_map:
+    "regions[...].region_info.mask,regions[...].data.concepts": "predicted_mask"

clarifai_utils/models/model_serving/model_config/serializer.py

@@ -21,7 +21,7 @@ from typing import Type
 from google.protobuf.text_format import MessageToString
 from tritonclient.grpc import model_config_pb2
 
-from .triton_config import TritonModelConfig
+from .config import TritonModelConfig
 
 
 class Serializer:

clarifai_utils/models/model_serving/models/default_test.py

@@ -6,7 +6,8 @@ import unittest
 
 import numpy as np
 
-from ..model_config.triton_config import TritonModelConfig
+from ..model_config import ModelTypes
+from ..model_config.config import get_model_config
 from .output import (ClassifierOutput, EmbeddingOutput, ImageOutput, MasksOutput, TextOutput,
                      VisualDetectorOutput)
 
@@ -75,19 +76,18 @@ class DefaultTestInferenceModel(unittest.TestCase):
             model_repository=os.path.join(repo_version_dir, ".."),
             model_instance_kind="GPU" if self.is_instance_kind_gpu else "cpu"))
     # Get default config of model and model_type
-    self.default_triton_model_config = TritonModelConfig(
-        model_name=self.model_type,
-        model_version="1",
-        model_type=self.model_type,
-        image_shape=[-1, -1])
+    self.default_triton_model_config = get_model_config(self.model_type).make_triton_model_config(
+        model_name=self.model_type, model_version="1", image_shape=[-1, -1])
     # Get current model config
     self.triton_model_config = self.triton_model.config_msg
     self.triton_model_input_name = self.triton_model.input_name
     self.preprocess = self._get_preprocess()
     # load labels
     self._required_label_model_types = [
-        "visual-detector", "visual-classifier", "text-classifier", "visual-segmenter"
+        ModelTypes.visual_detector, ModelTypes.visual_classifier, ModelTypes.text_classifier,
+        ModelTypes.visual_segmenter
     ]
+    self._output_text_models = [ModelTypes.text_to_text]
     self.labels = []
     if self.model_type in self._required_label_model_types:
       with open(os.path.join(repo_version_dir, "../labels.txt"), 'r') as fp:
@@ -144,14 +144,15 @@ class DefaultTestInferenceModel(unittest.TestCase):
     for inp, output in zip(inputs, outputs):
 
       field = dataclasses.fields(output)[0].name
-      self.assertEqual(
-          len(self.triton_model_config.output[0].dims),
-          len(getattr(output, field).shape),
-          "Length of 'dims' of config and output must be matched, but get "
-          f"Config {len(self.triton_model_config.output[0].dims)} != Output {len(getattr(output, field).shape)}"
-      )
+      if self.model_type not in self._output_text_models:
+        self.assertEqual(
+            len(self.triton_model_config.output[0].dims),
+            len(getattr(output, field).shape),
+            "Length of 'dims' of config and output must be matched, but get "
+            f"Config {len(self.triton_model_config.output[0].dims)} != Output {len(getattr(output, field).shape)}"
+        )
 
-      if self.model_type == "visual-detector":
+      if self.model_type == ModelTypes.visual_detector:
         logging.info(output.predicted_labels)
         self.assertEqual(
             type(output), VisualDetectorOutput,
@@ -166,7 +167,7 @@ class DefaultTestInferenceModel(unittest.TestCase):
             f"`predicted_labels` must be in [0, {len(self.labels) - 1}]")
         self.assertTrue(_is_integer(output.predicted_labels), "`predicted_labels` must be integer")
 
-      elif self.model_type == "visual-classifier":
+      elif self.model_type == ModelTypes.visual_classifier:
         self.assertEqual(
             type(output), ClassifierOutput,
             f"Output type must be `ClassifierOutput`, but got {type(output)}")
@@ -179,7 +180,7 @@ class DefaultTestInferenceModel(unittest.TestCase):
               f"`predicted_labels` must equal to {len(self.labels)}, however got {len(output.predicted_scores)}"
           )
 
-      elif self.model_type == "text-classifier":
+      elif self.model_type == ModelTypes.text_classifier:
         self.assertEqual(
             type(output), ClassifierOutput,
             f"Output type must be `ClassifierOutput`, but got {type(output)}")
@@ -192,29 +193,29 @@ class DefaultTestInferenceModel(unittest.TestCase):
               f"`predicted_labels` must equal to {len(self.labels)}, however got {len(output.predicted_scores)}"
           )
 
-      elif self.model_type == "text-embedder":
+      elif self.model_type == ModelTypes.text_embedder:
         self.assertEqual(
             type(output), EmbeddingOutput,
             f"Output type must be `EmbeddingOutput`, but got {type(output)}")
         self.assertNotEqual(output.embedding_vector.shape, [])
 
-      elif self.model_type == "text-to-text":
+      elif self.model_type == ModelTypes.text_to_text:
         self.assertEqual(
             type(output), TextOutput, f"Output type must be `TextOutput`, but got {type(output)}")
 
-      elif self.model_type == "text-to-image":
+      elif self.model_type == ModelTypes.text_to_image:
         self.assertEqual(
             type(output), ImageOutput,
             f"Output type must be `ImageOutput`, but got {type(output)}")
         self.assertTrue(_is_non_negative(output.image), "`image` elements must be >= 0")
 
-      elif self.model_type == "visual-embedder":
+      elif self.model_type == ModelTypes.visual_embedder:
         self.assertEqual(
             type(output), EmbeddingOutput,
             f"Output type must be `EmbeddingOutput`, but got {type(output)}")
         self.assertNotEqual(output.embedding_vector.shape, [])
 
-      elif self.model_type == "visual-segmenter":
+      elif self.model_type == ModelTypes.visual_segmenter:
         self.assertEqual(
             type(output), MasksOutput,
             f"Output type must be `MasksOutput`, but got {type(output)}")

clarifai_utils/models/model_serving/models/output.py

@@ -72,8 +72,8 @@ class TextOutput:
     """
     Validate input upon initialization.
     """
-    assert self.predicted_text.ndim == 1, \
-      f"All predictions must be 1-dimensional, Got text-dims: {self.predicted_text.ndim} instead."
+    assert self.predicted_text.ndim == 0, \
+      f"All predictions must be 0-dimensional, Got text-dims: {self.predicted_text.ndim} instead."
 
 
 @dataclass

clarifai_utils/models/model_serving/pb_model_repository.py

@@ -19,8 +19,7 @@ import os
 from pathlib import Path
 from typing import Callable, Type
 
-from .model_config.serializer import Serializer
-from .model_config.triton_config import TritonModelConfig
+from .model_config import Serializer, TritonModelConfig
 from .models import inference, pb_model, test
 
 
@@ -79,11 +78,9 @@ class TritonModelRepository:
             pass
         else:
           continue
-      # gen requirements & conda yaml
+      # gen requirements
       with open(os.path.join(repository_path, "requirements.txt"), "w") as f:
         f.write("clarifai>9.5.3\ntritonclient[all]")  # for model upload utils
-      with open(os.path.join(repository_path, "triton_conda.yaml"), "w") as conda_env:
-        conda_env.write("name: triton_conda-cp3.8-torch1.13.1-19f97078")
 
     if not os.path.isdir(model_version_path):
       os.mkdir(model_version_path)

clarifai_utils/runners/example.py

@@ -0,0 +1,33 @@
+from clarifai_grpc.grpc.api import resources_pb2
+
+from clarifai.client.runner import Runner
+
+
+class MyRunner(Runner):
+  """A custom runner that adds "Hello World" to the end of the text and replaces the domain of the
+  image URL as an example.
+  """
+
+  def run_input(self, input: resources_pb2.Input) -> resources_pb2.Output:
+    """This is the method that will be called when the runner is run. It takes in an input and
+    returns an output.
+    """
+
+    output = resources_pb2.Output()
+
+    data = input.data
+
+    if data.text.raw != "":
+      output.data.text.raw = data.text.raw + "Hello World"
+    if data.image.url != "":
+      output.data.text.raw = data.image.url.replace("samples.clarifai.com", "newdomain.com")
+    return output
+
+
+if __name__ == '__main__':
+  # Make sure you set these env vars before running the example.
+  # CLARIFAI_PAT
+  # CLARIFAI_USER_ID
+
+  # You need to first create a runner in the Clarifai API and then use the ID here.
+  MyRunner(runner_id="sdk-test-runner").start()