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

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)

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

@@ -1,182 +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 __future__ import annotations  # isort: skip
-
-from copy import deepcopy
-from dataclasses import dataclass, field
-from typing import Any, List, Union
-
-from ...constants import IMAGE_TENSOR_NAME, MAX_HW_DIM
-
-
-### 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)
-  label_filename: str = ""
-
-
-@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
-  image_shape: List of Height and Width of input image. *
-
-  (*): This attribute won't be serialized in config.pbtxt
-
-  Returns:
-  --------
-  TritonModelConfig
-  """
-  #model_type: str
-  model_name: str = ""
-  model_version: str = "1"
-  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"
-  image_shape: tuple[Union[int, float], Union[int, float]] = field(
-      default_factory=lambda: [-1, -1])  #(H, W)
-
-  def __setattr__(self, __name: str, __value: Any) -> None:
-    if __name == "image_shape":
-      __value = self._check_and_assign_image_shape_value(__value)
-
-    super().__setattr__(__name, __value)
-
-  def _check_and_assign_image_shape_value(self, value):
-    _has_image = False
-    for each in self.input:
-      if IMAGE_TENSOR_NAME in each.name:
-        _has_image = True
-        if len(value) != 2:
-          raise ValueError(
-              f"image_shape takes 2 values, Height and Width. Got {len(value)} values instead.")
-        if value[0] > MAX_HW_DIM or value[1] > MAX_HW_DIM:
-          raise ValueError(
-              f"H and W each have a maximum value of {MAX_HW_DIM}. Got H: {value[0]}, W: {value[1]}"
-          )
-        image_dims = deepcopy(value)
-        image_dims.append(3)  # add channel dim
-        each.dims = image_dims
-
-    if not _has_image and self.input:
-      return [-1, -1]
-    else:
-      return value