clarifai 9.10.1__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai_utils/models/model_serving/model_config/config.py

@@ -1,302 +0,0 @@
-# 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)
-  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 ###
-
-
-# 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"
-  multimodal_embedder: str = "multimodal-embedder"
-
-  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"],
-              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"]),
-  )
-
-  # 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/inference_parameter.py

@@ -1,124 +0,0 @@
-import json
-from dataclasses import asdict, dataclass, field
-from typing import Any, List
-
-
-@dataclass(frozen=True)
-class InferParamType:
-  BOOL: int = 1
-  STRING: int = 2
-  NUMBER: int = 3
-  ENCRYPTED_STRING: int = 21
-
-
-@dataclass
-class InferParam:
-  path: str
-  field_type: InferParamType = field(default_factory=InferParamType)
-  default_value: Any = None
-  description: str = ""
-
-  def __post_init__(self):
-    assert self.path.isidentifier(
-    ), f"`path` must be valid for creating python variable, got {self.path}"
-    if self.default_value is not None:
-      self.validate_type(self.default_value)
-
-  def validate_type(self, value):
-    if self.field_type == InferParamType.BOOL:
-      assert isinstance(value, bool), f"`field_type` is `BOOL` (bool), however got {type(value)}"
-    elif self.field_type == InferParamType.NUMBER:
-      assert isinstance(value, float) or isinstance(
-          value, int), f"`field_type` is `NUMBER` (float or int), however got {type(value)}"
-    else:
-      assert isinstance(
-          value,
-          str), f"`field_type` is `STRING` or `ENCRYPTED_STRING` (str), however got {type(value)}"
-
-  def todict(self):
-    return {k: v for k, v in asdict(self).items()}
-
-
-@dataclass
-class InferParamManager:
-  json_path: str = ""
-  params: List[InferParam] = field(default_factory=list)
-  _dict_params: dict = field(init=False)
-
-  @classmethod
-  def from_kwargs(cls, **kwargs):
-    params = list()
-    for k, v in kwargs.items():
-      if isinstance(v, str) and k.startswith("_"):
-        _type = InferParamType.ENCRYPTED_STRING
-      elif isinstance(v, str):
-        _type = InferParamType.STRING
-      elif isinstance(v, bool):
-        _type = InferParamType.BOOL
-      elif isinstance(v, float) or isinstance(v, int):
-        _type = InferParamType.NUMBER
-      else:
-        raise TypeError(f"Unsupported type {type(v)} of argument {k}, support {InferParamType}")
-      param = InferParam(path=k, field_type=_type, default_value=v, description="")
-      params.append(param)
-
-    return cls(params=params)
-
-  def __post_init__(self):
-    #assert self.params == [] or self.json_path, "`json_path` or `params` must be set"
-    self._dict_params = dict()
-    if self.params == [] and self.json_path:
-      with open(self.json_path, "r") as fp:
-        objs = json.load(fp)
-        objs = objs if isinstance(objs, list) else [objs]
-      self.params = [InferParam(**obj) for obj in objs]
-    for param in self.params:
-      self._dict_params.update({param.path: param})
-
-  def get_list_params(self):
-    list_params = []
-    for each in self.params:
-      list_params.append(each.todict())
-    return list_params
-
-  def export(self, path: str):
-    list_params = self.get_list_params()
-    with open(path, "w") as fp:
-      json.dump(list_params, fp, indent=2)
-
-  def validate(self, **kwargs) -> dict:
-    output_kwargs = {k: v.default_value for k, v in self._dict_params.items()}
-    assert kwargs == {} or self.params != [], "kwargs are rejected since `params` is empty"
-
-    for key, value in kwargs.items():
-      assert key in self._dict_params, f"param `{key}` is not in setting: {list(self._dict_params.keys())}"
-      if key in self._dict_params:
-        self._dict_params[key].validate_type(value)
-      output_kwargs.update({key: value})
-    return output_kwargs
-
-
-def is_number(v: str):
-  try:
-    _ = float(v)
-    return True
-  except ValueError:
-    return False
-
-
-def str_to_number(v: str):
-  try:
-    return int(v)
-  except ValueError:
-    return float(v)
-
-
-def parse_req_parameters(req_params: str):
-  req_params = json.loads(req_params)
-  for k, v in req_params.items():
-    if isinstance(v, str):
-      if is_number(v):
-        v = str_to_number(v)
-    req_params.update({k: v})
-
-  return req_params

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

@@ -1,24 +0,0 @@
-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

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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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"