clarifai 10.0.0__py3-none-any.whl → 10.1.0__py3-none-any.whl

clarifai/models/model_serving/model_config/config.py

@@ -1,180 +1,25 @@
-# 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."""
-
 import logging
+from copy import deepcopy
 from dataclasses import asdict, dataclass, field
-from typing import List
+from typing import Any, List
 
 import yaml
 
-from ..models.model_types import *  # noqa # pylint: disable=unused-import
-from ..models.output import *  # noqa # pylint: disable=unused-import
+from .inference_parameter import InferParam
+from .output import *  # noqa: F403
+from .triton import DType  # noqa
+from .triton import Device, DynamicBatching, InputConfig, OutputConfig, TritonModelConfig
 
 logger = logging.getLogger(__name__)
 
-__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)
-  optional: bool = False
-
-
-@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 ###
+__all__ = ["ModelTypes", "ModelConfigClass", "MODEL_TYPES", "get_model_config", "load_user_config"]
 
 
 # Clarifai model types
 @dataclass
 class ModelTypes:
+  """ All supported Clarifai model type names
+  """
   visual_detector: str = "visual-detector"
   visual_classifier: str = "visual-classifier"
   text_classifier: str = "text-classifier"
@@ -188,31 +33,86 @@ class ModelTypes:
   def __post_init__(self):
     self.all = list(asdict(self).values())
 
+  @property
+  def image_input_models(self):
+    """ Return list of model types having image as input or one of inputs"""
+    _visual = [each for each in self.all if each.startswith("visual")]
 
-@dataclass
-class InferenceConfig:
-  wrap_func: callable
-  return_type: dataclass
+    return _visual + [self.multimodal_embedder]
 
 
 @dataclass
 class FieldMapsConfig:
-  input_fields_map: dict
-  output_fields_map: dict
+  input_fields_map: dict = field(default_factory=dict)
+  output_fields_map: dict = field(default_factory=dict)
+
+
+@dataclass
+class ServingBackendConfig:
+  """
+  """
+  triton: TritonModelConfig = None
 
 
 @dataclass
-class DefaultTritonConfig:
-  input: List[InputConfig] = field(default_factory=list)
-  output: List[OutputConfig] = field(default_factory=list)
+class ClarifaiModelConfig:
+  """Clarifai necessary configs for building/uploading/creation
+
+  Args:
+    field_maps (FieldMapsConfig): Field maps config
+    output_type (dataclass): model output type
+    labels (List[str]): list of concept names
+    inference_parameters (List[InferParam]): list of inference parameters
+    clarifai_model_id (str): Clarifai model id on the platform
+    type (str): one of `MODEL_TYPES`
+    clarifai_user_app_id (str): User ID and App ID separated by '/', e.g., <user_id>/<app_id>
+    description (str): model description
+
+  """
+  field_maps: FieldMapsConfig = None
+  output_type: str = None
+  labels: List[str] = field(default_factory=list)
+  inference_parameters: List[InferParam] = field(default_factory=list)
+  clarifai_model_id: str = ""
+  type: str = ""
+  clarifai_user_app_id: str = ""
+  description: str = ""
+
+  def _checking(self, var_name: str, var_value: Any):
+    if var_name == "type":
+      _model_types = MODEL_TYPES + [""]
+      assert self.type in _model_types
+    elif var_name == "clarifai_model_id" and var_value:
+      # TODO: Must ensure name is valid
+      pass
+    elif var_name == "clarifai_user_app_id" and var_value:
+      _user_app = var_value.split("/")
+      assert len(_user_app) == 2, ValueError(
+          f"id must be combination of user_id and app_id separated by `/`, e.g. <user_id>/<app_id>. Got {var_value}"
+      )
+    elif var_name == "labels":
+      if var_value:
+        assert isinstance(var_value, tuple) or isinstance(
+            var_value, list), f"labels must be tuple or list, got {type(var_value)}"
+        var_value = [str(each) for each in var_value]
+
+    return var_value
+
+  def __setattr__(self, __name: str, __value: Any) -> None:
+    __value = self._checking(__name, __value)
+
+    super().__setattr__(__name, __value)
 
 
 @dataclass
-class ModelConfigClass:
-  type: str = field(init=False)
-  triton: DefaultTritonConfig
-  inference: InferenceConfig
-  field_maps: FieldMapsConfig
+class ModelConfigClass():
+  """All config of model
+  Args:
+    clarifai_model (ClarifaiModelConfig): Clarifai model config
+    serving_backend (ServingBackendConfig): Custom serving backend config. Only support triton for now
+  """
+  clarifai_model: ClarifaiModelConfig
+  serving_backend: ServingBackendConfig
 
   def make_triton_model_config(
       self,
@@ -226,7 +126,6 @@ class ModelConfigClass:
   ) -> TritonModelConfig:
 
     return TritonModelConfig(
-        model_type=self.type,
         model_name=model_name,
         model_version=model_version,
         image_shape=image_shape,
@@ -234,45 +133,98 @@ class ModelConfigClass:
         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:
+        input=self.serving_backend.triton.input,
+        output=self.serving_backend.triton.output)
+
+  def dump_to_user_config(self):
+    data = asdict(self)
+    _self = deepcopy(self)
+    # dump backend
+    if hasattr(_self.serving_backend, "triton"):
+      dict_triton_config = asdict(_self.serving_backend.triton)
+      for k, v in dict_triton_config.items():
+        if (k == "max_batch_size" and v > 1) \
+        or (k == "image_shape" and v != [-1, -1] and self.clarifai_model.type in ModelTypes().image_input_models):
+          continue
+        else:
+          data["serving_backend"]["triton"].pop(k, None)
+
+      if not data["serving_backend"]["triton"]:
+        data["serving_backend"].pop("triton", None)
+    if not data["serving_backend"]:
+      data.pop("serving_backend", None)
+
+    # dump clarifai model
+    data["clarifai_model"].pop("field_maps", None)
+    data["clarifai_model"].pop("output_type", None)
+
+    return data
+
+  @classmethod
+  def custom_doc(cls):
+    msg = f"{cls.__doc__}\nWhere: \n\n"
+    for k, v in cls.__annotations__.items():
+      msg += f"* {k}:\n------\n {v.__doc__}\n"
+    return msg
+
+
+def read_yaml(path: str) -> dict:
+  with open(path, 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"],
-              optional=input.get("optional", False),
-          ) 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"]),
-  )
+  return config
+
+
+def parse_config(config: dict):
+  clarifai_model = config.get("clarifai_model", {})
+  serving_backend = config.get("serving_backend", {})
+  if serving_backend:
+    if serving_backend.get("triton", {}):
+      # parse triton input/output
+      triton = serving_backend["triton"]
+      input_triton_configs = triton.pop("input", {})
+      triton.update(
+          dict(input=[
+              InputConfig(
+                  name=input["name"],
+                  data_type=eval(f"DType.{input['data_type']}") if isinstance(
+                      input['data_type'], str) else input['data_type'],
+                  dims=input["dims"],
+                  optional=input.get("optional", False),
+              ) for input in input_triton_configs
+          ]))
+      output_triton_configs = triton.pop("output", {})
+      triton.update(
+          dict(output=[
+              OutputConfig(
+                  name=output["name"],
+                  data_type=eval(f"DType.{output['data_type']}") if isinstance(
+                      output['data_type'], str) else output['data_type'],
+                  dims=output["dims"],
+                  label_filename=output["label_filename"],
+              ) for output in output_triton_configs
+          ]))
+      serving_backend.update(dict(triton=TritonModelConfig(**triton)))
+    serving_backend = ServingBackendConfig(**serving_backend)
 
   # parse field maps for deployment
-  field_maps = FieldMapsConfig(**config["field_maps"])
-
-  return ModelConfigClass(triton=triton, inference=inference, field_maps=field_maps)
+  field_maps = clarifai_model.pop("field_maps", {})
+  clarifai_model.update(dict(field_maps=FieldMapsConfig(**field_maps)))
+  # parse inference_parameters
+  inference_parameters = clarifai_model.pop("inference_parameters", [])
+  if inference_parameters is None:
+    inference_parameters = []
+  clarifai_model.update(
+      dict(inference_parameters=[InferParam(**each) for each in inference_parameters]))
+  # parse output type
+  output_type = clarifai_model.pop("output_type", None)
+  if output_type:
+    #if isinstance(output_type, str):
+    #  output_type = eval(output_type)
+    clarifai_model.update(dict(output_type=output_type))
+
+  clarifai_model = ClarifaiModelConfig(**clarifai_model)
+
+  return ModelConfigClass(clarifai_model=clarifai_model, serving_backend=serving_backend)
 
 
 def get_model_config(model_type: str) -> ModelConfigClass:
@@ -287,31 +239,74 @@ def get_model_config(model_type: str) -> ModelConfigClass:
     ModelConfigClass
 
   ### Example:
-  >>> from clarifai.models.model_serving.models.output import ClassifierOutput
   >>> from clarifai.models.model_serving.model_config import get_model_config, ModelTypes
   >>> cfg = get_model_config(ModelTypes.text_classifier)
   >>> custom_triton_config = cfg.make_triton_model_config(**kwargs)
-  >>> cfg.inference.return_type is ClassifierOutput # True
-
 
   """
   if model_type == "MODEL_TYPE_PLACEHOLDER":
     logger.warning(
         "Warning: A placeholder value has been detected for obtaining the model configuration. This will result in empty `ModelConfigClass` object."
     )
-    return ModelConfigClass(
-        triton=None,
-        inference=InferenceConfig(wrap_func=lambda x: x, return_type=None),
-        field_maps=None)
+    return ModelConfigClass(clarifai_model=None, serving_backend=None)
 
   import os
   assert model_type in MODEL_TYPES, f"`model_type` must be in {MODEL_TYPES}"
-  cfg = read_config(
+  cfg = read_yaml(
       os.path.join(os.path.dirname(__file__), "model_types_config", f"{model_type}.yaml"))
-  cfg.type = model_type
+  cfg = parse_config(cfg)
+  cfg.clarifai_model.type = model_type
   return cfg
 
 
 _model_types = ModelTypes()
 MODEL_TYPES = _model_types.all
 del _model_types
+
+
+def load_user_config(cfg_path: str) -> ModelConfigClass:
+  """Read `clarifai_config.yaml` in user working dir
+
+  Args:
+      cfg_path (str): path to config
+
+  Returns:
+      ModelConfigClass
+  """
+  cfg = read_yaml(cfg_path)
+  return _ensure_user_config(cfg)
+
+
+def _ensure_user_config(user_config: dict) -> ModelConfigClass:
+  """Ensure user config with default one
+
+  Args:
+      user_config (dict): ModelConfigClass as dict
+
+  Raises:
+      e: Exception when loading user config
+
+  Returns:
+      ModelConfigClass
+  """
+
+  try:
+    user_config_obj: ModelConfigClass = parse_config(user_config)
+  except Exception as e:
+    raise e
+
+  default_config = get_model_config(user_config_obj.clarifai_model.type)
+
+  for _model_cfg, value in asdict(user_config_obj.clarifai_model).items():
+
+    if value and _model_cfg != "field_maps":
+      setattr(default_config.clarifai_model, _model_cfg, value)
+
+  if hasattr(user_config_obj, "serving_backend"):
+    if hasattr(user_config_obj.serving_backend, "triton"):
+      if user_config_obj.serving_backend.triton.max_batch_size > 1:
+        default_config.serving_backend.triton.max_batch_size = user_config_obj.serving_backend.triton.max_batch_size
+      if user_config_obj.serving_backend.triton.image_shape != [-1, -1]:
+        default_config.serving_backend.triton.image_shape = user_config_obj.serving_backend.triton.image_shape
+
+  return default_config

clarifai/models/model_serving/model_config/inference_parameter.py

@@ -35,6 +35,11 @@ class InferParam:
           value,
           str), f"`field_type` is `STRING` or `ENCRYPTED_STRING` (str), however got {type(value)}"
 
+  def __setattr__(self, __name: str, __value: Any) -> None:
+    if __name == "default_value":
+      self.validate_type(__value)
+    super().__setattr__(__name, __value)
+
   def todict(self):
     return {k: v for k, v in asdict(self).items()}
 

clarifai/models/model_serving/model_config/model_types_config/multimodal-embedder.yaml

@@ -1,24 +1,25 @@
-triton:
-  input:
-    - name: image
-      data_type: TYPE_UINT8
-      dims: [-1, -1, 3]
-      optional: true
-    - name: text
-      data_type: TYPE_STRING
-      dims: [1]
-      optional: true
-  output:
-    - name: embeddings
-      data_type: TYPE_FP32
-      dims: [-1]
-      labels: false
-inference:
-  wrap_func: multimodal_embedder
-  return_type: EmbeddingOutput
-field_maps:
-  input_fields_map:
-    image: image
-    text: text
-  output_fields_map:
-    embeddings: embeddings
+serving_backend:
+  triton:
+    input:
+      - name: image
+        data_type: TYPE_UINT8
+        dims: [-1, -1, 3]
+        optional: true
+      - name: text
+        data_type: TYPE_STRING
+        dims: [1]
+        optional: true
+    output:
+      - name: embeddings
+        data_type: TYPE_FP32
+        dims: [-1]
+        label_filename: null
+clarifai_model:
+  type: multimodal-embedder
+  output_type: EmbeddingOutput
+  field_maps:
+    input_fields_map:
+      image: image
+      text: text
+    output_fields_map:
+      embeddings: embeddings

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

@@ -1,18 +1,19 @@
-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
+serving_backend:
+  triton:
+    input:
+      - name: text
+        data_type: TYPE_STRING
+        dims: [1]
+    output:
+      - name: softmax_predictions
+        data_type: TYPE_FP32
+        dims: [-1]
+        label_filename: "labels.txt"
+clarifai_model:
+  type: text-classifier
+  output_type: ClassifierOutput
+  field_maps:
+    input_fields_map:
+      text: text
+    output_fields_map:
+      concepts: softmax_predictions

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

@@ -1,18 +1,20 @@
-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
+serving_backend:
+  triton:
+    input:
+      - name: text
+        data_type: TYPE_STRING
+        dims: [1]
+    output:
+      - name: embeddings
+        data_type: TYPE_FP32
+        dims: [-1]
+        label_filename: null
+
+clarifai_model:
+  type: text-embedder
+  output_type: EmbeddingOutput
+  field_maps:
+    input_fields_map:
+      text: text
+    output_fields_map:
+      embeddings: embeddings