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

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

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

@@ -1,281 +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 inference model predictions to triton inference responses
-per model type.
-"""
-
-from functools import wraps
-from itertools import zip_longest
-from typing import Callable, Dict
-import numpy as np
-
-try:
-  import triton_python_backend_utils as pb_utils
-except ModuleNotFoundError:
-  pass
-
-
-def visual_detector(func: Callable):
-  """
-  Visual detector type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_bboxes = []
-    out_labels = []
-    out_scores = []
-
-    # input_data passed as list of images
-    preds = func(self, list(input_data[:]), *args, **kwargs)
-    for pred in preds:
-      out_bboxes.append(pred.predicted_bboxes)
-      out_labels.append(pred.predicted_labels)
-      out_scores.append(pred.predicted_scores)
-
-    if len(out_bboxes) < 1 or len(out_labels) < 1:
-      out_tensor_bboxes = pb_utils.Tensor("predicted_bboxes", np.zeros((0, 4), dtype=np.float32))
-      out_tensor_labels = pb_utils.Tensor("predicted_labels", np.zeros((0, 1), dtype=np.int32))
-      out_tensor_scores = pb_utils.Tensor("predicted_scores", np.zeros((0, 1), dtype=np.float32))
-    else:
-      out_tensor_bboxes = pb_utils.Tensor("predicted_bboxes",
-                                          np.asarray(out_bboxes, dtype=np.float32))
-      out_tensor_labels = pb_utils.Tensor("predicted_labels",
-                                          np.asarray(out_labels, dtype=np.int32))
-      out_tensor_scores = pb_utils.Tensor("predicted_scores",
-                                          np.asarray(out_scores, dtype=np.float32))
-
-    inference_response = pb_utils.InferenceResponse(
-        output_tensors=[out_tensor_bboxes, out_tensor_labels, out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_classifier(func: Callable):
-  """
-  Visual classifier type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_scores = []
-    # input_data passed as list of images
-    preds = func(self, list(input_data[:]), *args, **kwargs)
-
-    for pred in preds:
-      out_scores.append(pred.predicted_scores)
-
-    out_tensor_scores = pb_utils.Tensor("softmax_predictions",
-                                        np.asarray(out_scores, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_classifier(func: Callable):
-  """
-  Text classifier type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_scores = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    preds = func(self, input_data, *args, **kwargs)
-
-    for pred in preds:
-      out_scores.append(pred.predicted_scores)
-
-    out_tensor_scores = pb_utils.Tensor("softmax_predictions",
-                                        np.asarray(out_scores, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_tensor_scores])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_to_text(func: Callable):
-  """
-  Text to text type output parser.
-  Convert a sequence of text into another e.g. text generation,
-  summarization or translation.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_text = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    preds = func(self, input_data, *args, **kwargs)
-
-    for pred in preds:
-      out_text.append(pred.predicted_text)
-
-    out_text_tensor = pb_utils.Tensor("text", np.asarray(out_text, dtype=object))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_text_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_embedder(func: Callable):
-  """
-  Text embedder type output parser.
-  Generates embeddings for an input text.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    preds = func(self, input_data, *args, **kwargs)
-
-    for pred in preds:
-      out_embeddings.append(pred.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_embedder(func: Callable):
-  """
-  Visual embedder type output parser.
-  Generates embeddings for an input image.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    # input_data passed as list of images
-    preds = func(self, list(input_data[:]), *args, **kwargs)
-
-    for pred in preds:
-      out_embeddings.append(pred.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def visual_segmenter(func: Callable):
-  """
-  Visual segmenter type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    masks = []
-    # input_data passed as list of images
-    preds = func(self, list(input_data[:]), *args, **kwargs)
-
-    for pred in preds:
-      masks.append(pred.predicted_mask)
-
-    out_mask_tensor = pb_utils.Tensor("predicted_mask", np.asarray(masks, dtype=np.int64))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_mask_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def text_to_image(func: Callable):
-  """
-  Text to image type output parser.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: np.ndarray, *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    gen_images = []
-    input_data = [in_elem[0].decode() for in_elem in input_data]
-    preds = func(self, input_data, *args, **kwargs)
-
-    for pred in preds:
-      gen_images.append(pred.image)
-
-    out_image_tensor = pb_utils.Tensor("image", np.asarray(gen_images, dtype=np.uint8))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_image_tensor])
-
-    return inference_response
-
-  return parse_predictions
-
-
-def multimodal_embedder(func: Callable):
-  """
-  Multimodal embedder type output parser.
-  Generates embeddings for image or text input.
-  """
-
-  @wraps(func)
-  def parse_predictions(self, input_data: Dict[str, np.ndarray], *args, **kwargs):
-    """
-    Format predictions and return clarifai compatible output.
-    """
-    out_embeddings = []
-    model_input_data = []
-    for group in zip_longest(*input_data.values()):
-      _input_data = dict(zip(input_data, group))
-      for k, v in _input_data.items():
-        # decode np.object to string
-        if isinstance(v, np.ndarray) and v.dtype == np.object_:
-          _input_data.update({k: v[0].decode()})
-        model_input_data.append(_input_data)
-
-    preds = func(self, model_input_data, *args, **kwargs)
-    for pred in preds:
-      out_embeddings.append(pred.embedding_vector)
-
-    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
-    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
-
-    return inference_response
-
-  return parse_predictions

clarifai/models/model_serving/repo_build/__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 .build import RepositoryBuilder  # noqa
-from .static_files.base_test import BaseTest  # noqa

clarifai/models/model_serving/repo_build/build.py

@@ -1,198 +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.
-"""
-Triton python backend inference model controller.
-"""
-
-import inspect
-import os
-import shutil
-import zipfile
-from dataclasses import asdict
-from pathlib import Path
-from typing import Iterable, Literal, Union
-
-import yaml
-from tqdm import tqdm
-
-from ..constants import BUILT_MODEL_EXT
-from ..model_config import MODEL_TYPES, ModelConfigClass, base, get_model_config, load_user_config
-from ..model_config.base import *  # noqa
-from ..model_config.config import parse_config
-from ..model_config.triton.serializer import Serializer
-
-
-def __parse_type_to_class():
-  _t = {}
-  _classes = inspect.getmembers(base, inspect.isclass)
-  for cls_name, cls_obj in _classes:
-    if cls_obj.__base__ is base._BaseClarifaiModel:
-      _t.update({cls_obj._config.clarifai_model.type: cls_name})
-  return _t
-
-
-_TYPE_TO_CLASS = __parse_type_to_class()
-
-
-def _get_static_file_path(relative_path: str):
-  curr_dir = os.path.dirname(__file__)
-  return os.path.join(curr_dir, "static_files", relative_path)
-
-
-def _read_static_file(relative_path: str):
-  path = _get_static_file_path(relative_path)
-  with open(path, "r") as f:
-    return f.read()
-
-
-def copy_folder(src_folder, dest_folder, exclude_items=None):
-
-  if exclude_items is None:
-    exclude_items = set()
-
-  # Ensure the destination folder exists
-  if not os.path.exists(dest_folder):
-    os.makedirs(dest_folder)
-
-  loader = tqdm(os.listdir(src_folder))
-  if exclude_items:
-    print(f"NOTE: skipping {exclude_items}")
-
-  for item in loader:
-    loader.set_description(f"copying {item}...")
-    src_item = os.path.join(src_folder, item)
-    dest_item = os.path.join(dest_folder, item)
-
-    # Skip items in the exclude list
-    if item in exclude_items or item.endswith(BUILT_MODEL_EXT):
-      continue
-
-    # Copy files directly
-    if os.path.isfile(src_item):
-      shutil.copy2(src_item, dest_item)
-
-    # Copy directories using copytree
-    elif os.path.isdir(src_item):
-      shutil.copytree(src_item, dest_item, symlinks=False, ignore=None, dirs_exist_ok=True)
-
-
-def zip_dir(input: Union[Path, str], zip_filename: Union[Path, str]):
-  """
-  Zip folder without compressing
-  """
-  # Convert to Path object
-  dir = Path(input)
-
-  with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_STORED) as zip_file:
-    for entry in dir.rglob("*"):
-      zip_file.write(entry, entry.relative_to(dir))
-
-
-class RepositoryBuilder:
-
-  @staticmethod
-  def init_repository(model_type: str, working_dir: str, backend=Literal['triton'], **kwargs):
-    assert model_type in MODEL_TYPES
-    model_type = model_type
-    default_model_type_config: ModelConfigClass = get_model_config(model_type)
-
-    os.makedirs(working_dir, exist_ok=True)
-
-    def __write_to(filename, data):
-      with open(os.path.join(working_dir, filename), "w") as f:
-        f.write(data)
-
-    # create inference.py
-    _filename = "inference.py"
-    inference_py = _read_static_file(_filename)
-    inference_py = inference_py.replace("InferenceModel()",
-                                        f"InferenceModel({_TYPE_TO_CLASS[model_type]})")
-    inference_py = inference_py.replace("predict_docstring",
-                                        eval(_TYPE_TO_CLASS[model_type]).predict.__doc__)
-    # create config
-    config = asdict(default_model_type_config)
-    if backend == "triton":
-      max_batch_size = kwargs.get("max_batch_size", None)
-      image_shape = kwargs.get("image_shape", None)
-      if max_batch_size:
-        config['serving_backend']['triton']['max_batch_size'] = max_batch_size
-      if image_shape:
-        config['serving_backend']['triton']['image_shape'] = image_shape
-      config = parse_config(config).dump_to_user_config()
-      config_data = yaml.dump(config)
-      sample_yaml = _read_static_file("sample_clarifai_config.yaml")
-      config_data = sample_yaml + "\n\n" + config_data
-      __write_to("clarifai_config.yaml", config_data)
-      #
-    # create inference.py after checking all configs
-    __write_to(_filename, inference_py)
-    # create test.py
-    __write_to("test.py", _read_static_file("test.py"))
-    # create requirements.txt
-    __write_to("requirements.txt", _read_static_file("_requirements.txt"))
-
-  @staticmethod
-  def build(working_dir: str, output_dir: str = None, name: str = None, backend=Literal['triton']):
-    if not output_dir:
-      output_dir = working_dir
-    else:
-      os.makedirs(output_dir, exist_ok=True)
-
-    temp_folder = os.path.join(working_dir, ".cache")
-    os.makedirs(temp_folder, exist_ok=True)
-
-    user_config_file = os.path.join(working_dir, "clarifai_config.yaml")
-    assert os.path.exists(
-        user_config_file
-    ), f"FileNotFound: please make sure `clarifai_config.yaml` exists in {working_dir}"
-    user_config = load_user_config(user_config_file)
-
-    if backend == "triton":
-      triton_1_ver = os.path.join(temp_folder, "1")
-      os.makedirs(triton_1_ver, exist_ok=True)
-      # check if labels exists
-      for output_config in user_config.serving_backend.triton.output:
-        if output_config.label_filename:
-          user_labels = user_config.clarifai_model.labels
-          assert user_labels, f"Model type `{user_config.clarifai_model.type}` requires labels, "\
-          f"but can not found value of `clarifai_model.labels` in {user_config_file}. Please update this attribute to build the model"
-          with open(os.path.join(temp_folder, "labels.txt"), "w") as f:
-            if not isinstance(user_labels, Iterable):
-              user_labels = [user_labels]
-            f.write("\n".join([str(lb) for lb in user_labels]) + "\n")
-
-      # copy model.py
-      shutil.copy(_get_static_file_path("triton/model.py"), triton_1_ver)
-      # copy requirements.txt
-      shutil.copy(os.path.join(working_dir, "requirements.txt"), temp_folder)
-      # copy all other files
-      copy_folder(
-          working_dir, triton_1_ver, exclude_items=["requirements.txt", ".cache", "__pycache__"])
-      # generate config.pbtxt
-      _config_pbtxt_serializer = Serializer(user_config.serving_backend.triton)
-      _config_pbtxt_serializer.to_file(temp_folder)
-
-    else:
-      raise ValueError(f"backend must be ['triton'], got {backend}")
-
-    clarifai_model_name = name or user_config.clarifai_model.clarifai_model_id or "model"
-    clarifai_model_name += BUILT_MODEL_EXT
-    clarifai_model_name = os.path.join(output_dir, clarifai_model_name)
-
-    print(
-        "Model building in progress; the duration may vary depending on the size of checkpoints/assets..."
-    )
-    zip_dir(temp_folder, clarifai_model_name)
-    print(f"Finished. Your model is located at {clarifai_model_name}")
-
-    return clarifai_model_name

clarifai/models/model_serving/repo_build/static_files/_requirements.txt

@@ -1,2 +0,0 @@
-clarifai>9.10.4
-tritonclient[all]