clarifai 10.8.4__py3-none-any.whl → 10.8.5__py3-none-any.whl

clarifai/models/model_serving/model_config/inference_parameter.py

@@ -1,129 +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 __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()}
-
-
-@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=k)
-      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/models/model_serving/model_config/model_types_config/multimodal-embedder.yaml

@@ -1,25 +0,0 @@
-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,19 +0,0 @@
-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,20 +0,0 @@
-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

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

@@ -1,19 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: text
-        data_type: TYPE_STRING
-        dims: [1]
-    output:
-      - name: image
-        data_type: TYPE_UINT8
-        dims: [-1, -1, 3]
-        label_filename: null
-clarifai_model:
-  type: text-to-image
-  output_type: ImageOutput
-  field_maps:
-    input_fields_map:
-      text: text
-    output_fields_map:
-      image: image

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

@@ -1,19 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: text
-        data_type: TYPE_STRING
-        dims: [1]
-    output:
-      - name: text
-        data_type: TYPE_STRING
-        dims: [1]
-        label_filename: null
-clarifai_model:
-  type: text-to-text
-  output_type: TextOutput
-  field_maps:
-    input_fields_map:
-      text: text
-    output_fields_map:
-      text: text

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

@@ -1,22 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: image
-        data_type: TYPE_UINT8
-        dims: [-1, -1, 3]
-    output:
-      - name: softmax_predictions
-        data_type: TYPE_FP32
-        dims: [-1]
-        label_filename: "labels.txt"
-
-clarifai_model:
-  field_maps:
-    input_fields_map:
-      image: image
-    output_fields_map:
-      concepts: softmax_predictions
-  output_type: ClassifierOutput
-  type: visual-classifier
-  labels:
-  inference_parameters:

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

@@ -1,32 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: image
-        data_type: TYPE_UINT8
-        dims: [-1, -1, 3]
-    output:
-      - name: predicted_bboxes
-        data_type: TYPE_FP32
-        dims: [-1, 4]
-        label_filename: null
-      - name: predicted_labels
-        data_type: TYPE_INT32
-        dims: [-1, 1]
-        label_filename: "labels.txt"
-      - name: predicted_scores
-        data_type: TYPE_FP32
-        dims: [-1, 1]
-        label_filename: null
-
-clarifai_model:
-  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"
-  output_type: VisualDetectorOutput
-  type: visual-detector
-  labels:
-  inference_parameters:

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

@@ -1,19 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: image
-        data_type: TYPE_UINT8
-        dims: [-1, -1, 3]
-    output:
-      - name: embeddings
-        data_type: TYPE_FP32
-        dims: [-1]
-        label_filename: null
-clarifai_model:
-  type: visual-embedder
-  output_type: EmbeddingOutput
-  field_maps:
-    input_fields_map:
-      image: image
-    output_fields_map:
-      embeddings: embeddings

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

@@ -1,19 +0,0 @@
-serving_backend:
-  triton:
-    input:
-      - name: image
-        data_type: TYPE_UINT8
-        dims: [-1, -1, 3]
-    output:
-      - name: predicted_mask
-        data_type: TYPE_INT64
-        dims: [-1, -1]
-        label_filename: "labels.txt"
-clarifai_model:
-  type: visual-segmenter
-  output_type: MasksOutput
-  field_maps:
-    input_fields_map:
-      image: image
-    output_fields_map:
-      "regions[...].region_info.mask,regions[...].data.concepts": "predicted_mask"

clarifai/models/model_serving/model_config/output.py

@@ -1,133 +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.
-"""
-Output Predictions format for different model types.
-"""
-
-from dataclasses import dataclass
-import numpy as np
-
-
-@dataclass
-class VisualDetectorOutput:
-  predicted_bboxes: np.ndarray
-  predicted_labels: np.ndarray
-  predicted_scores: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert isinstance(self.predicted_scores, np.ndarray), "`predicted_scores` must be numpy array"
-    assert isinstance(self.predicted_labels, np.ndarray), "`predicted_labels` must be numpy array"
-    assert isinstance(self.predicted_scores, np.ndarray), "`predicted_scores` must be numpy array"
-
-    assert self.predicted_bboxes.ndim == self.predicted_labels.ndim == \
-      self.predicted_scores.ndim==2, f"All predictions must be 2-dimensional, \
-        Got bbox-dims: {self.predicted_bboxes.ndim}, label-dims: {self.predicted_labels.ndim}, \
-          scores-dims: {self.predicted_scores.ndim} instead."
-    assert self.predicted_bboxes.shape[0] == self.predicted_labels.shape[0] == \
-      self.predicted_scores.shape[0], f"The Number of predicted bounding boxes, \
-        predicted labels and predicted scores MUST match. Got {len(self.predicted_bboxes)}, \
-          {self.predicted_labels.shape[0]}, {self.predicted_scores.shape[0]} instead."
-
-    if len(self.predicted_labels) > 0:
-      assert self.predicted_bboxes.shape[
-          1] == 4, f"Box coordinates must have a length of 4. Actual:{self.predicted_bboxes.shape[1]}"
-      assert np.all(np.logical_and(0 <= self.predicted_bboxes, self.predicted_bboxes <= 1)), \
-       "Bounding box coordinates must be between 0 and 1"
-
-
-@dataclass
-class ClassifierOutput:
-  """
-  Takes model softmax predictions
-  """
-  predicted_scores: np.ndarray
-
-  # the index of each predicted score as returned by the model must correspond
-  # to the predicted label index in the labels.txt file
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert isinstance(self.predicted_scores, np.ndarray), "`predicted_scores` must be numpy array"
-    assert self.predicted_scores.ndim == 1, \
-      f"All predictions must be 1-dimensional, Got scores-dims: {self.predicted_scores.ndim} instead."
-
-
-@dataclass
-class TextOutput:
-  """
-  Takes model text predictions
-  """
-  predicted_text: str
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    self.predicted_text = np.array(self.predicted_text, dtype=object)
-    assert self.predicted_text.ndim == 0, \
-      f"All predictions must be 0-dimensional, Got text-dims: {self.predicted_text.ndim} instead."
-
-
-@dataclass
-class EmbeddingOutput:
-  """
-  Takes embedding vector returned by a model.
-  """
-  embedding_vector: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert isinstance(self.embedding_vector, np.ndarray), "`embedding_vector` must be numpy array"
-    assert self.embedding_vector.ndim == 1, \
-      f"Embeddings must be 1-dimensional, Got embedding-dims: {self.embedding_vector.ndim} instead."
-
-
-@dataclass
-class MasksOutput:
-  """
-  Takes image segmentation masks returned by a model.
-  """
-  predicted_mask: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert isinstance(self.predicted_mask, np.ndarray), "`predicted_mask` must be numpy array"
-    assert self.predicted_mask.ndim == 2, \
-      f"predicted_mask must be 2-dimensional, Got mask dims: {self.predicted_mask.ndim} instead."
-
-
-@dataclass
-class ImageOutput:
-  """
-  Takes a predicted/generated image array as returned by a model.
-  """
-  image: np.ndarray
-
-  def __post_init__(self):
-    """
-    Validate input upon initialization.
-    """
-    assert isinstance(self.image, np.ndarray), "`image` must be numpy array"
-    assert self.image.ndim == 3, \
-      f"Generated image must be 3-dimensional, Got image-dims: {self.image.ndim} instead."
-    assert self.image.shape[2] == 3, \
-      f"The image channels dimension must equal 3, Got channel dim: {self.image.shape[2]} instead."

clarifai/models/model_serving/model_config/triton/__init__.py

@@ -1,14 +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.
-from .serializer import Serializer  # noqa # pylint: disable=unused-import
-from .triton_config import *  # noqa # pylint: disable=unused-import

clarifai/models/model_serving/model_config/triton/serializer.py

@@ -1,136 +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.
-"""
-Parse & Serialize TritonModelConfig objects into proto format.
-"""
-
-import os
-from pathlib import Path
-from typing import Type
-
-from google.protobuf.text_format import MessageToString
-from tritonclient.grpc import model_config_pb2
-
-from .triton_config import TritonModelConfig
-
-
-class Serializer:
-  """
-  Serialize TritonModelConfig type object.
-  """
-
-  def __init__(self, model_config: Type[TritonModelConfig]) -> None:
-    self.model_config = model_config  #python dataclass config
-    self.config_proto = model_config_pb2.ModelConfig()  #holds parsed python config
-
-    self._set_all_fields()
-
-  def _set_input(self) -> None:
-    """
-    Parse InputConfig object to proto.
-    """
-    for in_field in self.model_config.input:
-      input_config = self.config_proto.input.add()
-      for key, value in in_field.__dict__.items():
-        try:
-          setattr(input_config, key, value)
-        except AttributeError:
-          field = getattr(input_config, key)
-          if isinstance(value, list):
-            field.extend(value)
-          else:
-            field.extend([value])
-    return
-
-  def _set_output(self) -> None:
-    """
-    Parse OutputConfig object to proto.
-    """
-    # loop over output dataclass list
-    for out_field in self.model_config.output:
-      output_config = self.config_proto.output.add()
-      for key, value in out_field.__dict__.items():
-        try:
-          if not value:
-            continue
-          setattr(output_config, key, value)
-        except AttributeError:  #Proto Repeated Field assignment not allowed
-          field = getattr(output_config, key)
-          if isinstance(value, list):
-            field.extend(value)
-          else:
-            field.extend([value])
-    return
-
-  def _set_instance_group(self) -> None:
-    """
-    Parse triton model instance group settings to proto.
-    """
-    instance = self.config_proto.instance_group.add()
-    for field_name, value in self.model_config.instance_group.__dict__.items():
-      try:
-        setattr(instance, field_name, value)
-      except AttributeError:
-        continue
-    return
-
-  def _set_batch_info(self) -> model_config_pb2.ModelDynamicBatching:
-    """
-    Parse triton model dynamic batching settings to proto.
-    """
-    dbatch_msg = model_config_pb2.ModelDynamicBatching()
-    for key, value in self.model_config.dynamic_batching.__dict__.items():
-      try:
-        setattr(dbatch_msg, key, value)
-      except AttributeError:  #Proto Repeated Field assignment not allowed
-        field = getattr(dbatch_msg, key)
-        if isinstance(value, list):
-          field.extend(value)
-        else:
-          field.extend([value])
-
-    return dbatch_msg
-
-  def _set_all_fields(self) -> None:
-    """
-    Set all config fields.
-    """
-    self.config_proto.name = self.model_config.model_name
-    self.config_proto.backend = self.model_config.backend
-    self.config_proto.max_batch_size = self.model_config.max_batch_size
-    self._set_input()
-    self._set_output()
-    self._set_instance_group()
-    dynamic_batch_msg = self._set_batch_info()
-    self.config_proto.dynamic_batching.CopyFrom(dynamic_batch_msg)
-
-  @property
-  def get_config(self) -> model_config_pb2.ModelConfig:
-    """
-    Return model config proto.
-    """
-    return self.config_proto
-
-  def to_file(self, save_dir: Path) -> None:
-    """
-    Serialize all triton config parameters and save output
-    to file.
-    Args:
-    -----
-    save_dir: Directory where to save resultant config.pbtxt file.
-          Defaults to the current working dir.
-    """
-    msg_string = MessageToString(self.config_proto)
-
-    with open(os.path.join(save_dir, "config.pbtxt"), "w") as cfile:
-      cfile.write(msg_string)