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

clarifai/models/model_serving/model_config/base.py

@@ -1,369 +0,0 @@
-from typing import Dict, Iterable, List, TypedDict, Union
-
-import numpy as np
-
-from ..constants import IMAGE_TENSOR_NAME, TEXT_TENSOR_NAME
-from .config import ModelConfigClass, ModelTypes, get_model_config
-from .output import (ClassifierOutput, EmbeddingOutput, ImageOutput, MasksOutput, TextOutput,
-                     VisualDetectorOutput)
-from .triton import wrappers as triton_wrapper
-
-
-class _TypeCheckModelOutput(type):
-
-  def __new__(cls, name, bases, attrs):
-    """
-    Override child `predict` function with parent._output_type_check(child.predict).
-    Aim to check if child.predict returns valid output type
-    """
-
-    def wrap_function(fn_name, base, base_fn, other_fn):
-
-      def new_fn(_self,
-                 input_data,
-                 inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-        # Run child class
-        out = other_fn(_self, input_data, inference_parameters=inference_parameters)
-        # Run type check
-        return base_fn(base, input_data, out)
-
-      new_fn.__name__ = "wrapped_%s" % fn_name
-      new_fn.__doc__ = other_fn.__doc__
-      return new_fn
-
-    if name != "_BaseClarifaiModel":
-      attrs["predict"] = wrap_function("predict", bases[0],
-                                       getattr(bases[0], "_output_type_check", lambda: None),
-                                       attrs.setdefault("predict", lambda: None))
-
-    return type.__new__(cls, name, bases, attrs)
-
-
-class _BaseClarifaiModel(metaclass=_TypeCheckModelOutput):
-  _config: ModelConfigClass = None
-
-  @property
-  def config(self):
-    return self._config
-
-  def _output_type_check(self, input, output):
-    output_type = self._config.clarifai_model.output_type
-    if isinstance(output, Iterable):
-      assert all(
-          each.__class__.__name__ == output_type for each in output
-      ), f"Expected output is iteration of `{output_type}` type, got iteration `{output}`"
-      assert len(output) == len(
-          input
-      ), f"Input length and output length must be equal, but got input length of {len(input)} and output length of {len(output)}"
-    else:
-      raise ValueError(f"Expected output is iteration of `{output_type}` type, got `{output}`")
-    return output
-
-  def predict(self,
-              input_data: Union[List[np.ndarray], Dict[str, List[np.ndarray]]],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> Iterable:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data: A list of input data item to predict on. The type depends on model input type:
-      * `image`: List[np.ndarray]
-      * `text`: List[str]
-      * `multimodal`:
-        input_data is list of dict where key is input type name e.i. `image`, `text` and value is list.
-        {"image": List[np.ndarray], "text": List[str]}
-
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of one of the `clarifai.models.model_serving.model_config.output` types. Refer to the README/docs
-    """
-    raise NotImplementedError
-
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    raise NotImplementedError
-
-
-_MultiModalInputTypeDict = TypedDict("_MultiModalInputTypeDict", {
-    IMAGE_TENSOR_NAME: np.ndarray,
-    TEXT_TENSOR_NAME: str
-})
-
-
-class MultiModalEmbedder(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.multimodal_embedder)
-
-  def predict(self,
-              input_data: List[_MultiModalInputTypeDict],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[EmbeddingOutput]:
-    """ Custom prediction function for `multimodal-embedder` model.
-
-    Args:
-      input_data (List[_MultiModalInputTypeDict]): List of dict of key-value: `image`(np.ndarray) and `text` (str)
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of EmbeddingOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.multimodal_embedder
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class TextClassifier(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.text_classifier)
-
-  def predict(self,
-              input_data: List[str],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[ClassifierOutput]:
-    """ Custom prediction function for `text-classifier` model.
-
-    Args:
-      input_data (List[str]): List of text
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of ClassifierOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.text_classifier
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class TextEmbedder(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.text_embedder)
-
-  def predict(self,
-              input_data: List[str],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[EmbeddingOutput]:
-    """ Custom prediction function for `text-embedder` model.
-
-    Args:
-      input_data (List[str]): List of text
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of EmbeddingOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.text_embedder
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class TextToImage(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.text_to_image)
-
-  def predict(
-      self,
-      input_data: List[str],
-      inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> Iterable[ImageOutput]:
-    """ Custom prediction function for `text-to-image` model.
-
-    Args:
-      input_data (List[str]): List of text
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of ImageOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.text_to_image
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class TextToText(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.text_to_text)
-
-  def predict(
-      self,
-      input_data: List[str],
-      inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> Iterable[TextOutput]:
-    """ Custom prediction function for `text-to-text` (also called as `text generation`) model.
-
-    Args:
-      input_data (List[str]): List of text
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of TextOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.text_to_text
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class VisualClassifier(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.visual_classifier)
-
-  def predict(self,
-              input_data: List[np.ndarray],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[ClassifierOutput]:
-    """ Custom prediction function for `visual-classifier` model.
-
-    Args:
-      input_data (List[np.ndarray]): List of image
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of ClassifierOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.visual_classifier
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class VisualDetector(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.visual_detector)
-
-  def predict(self,
-              input_data: List[np.ndarray],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[VisualDetectorOutput]:
-    """ Custom prediction function for `visual-detector` model.
-
-    Args:
-      input_data (List[np.ndarray]): List of image
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of VisualDetectorOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.visual_detector
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-  @staticmethod
-  def postprocess(width: int,
-                  height: int,
-                  labels: list,
-                  scores: list,
-                  xyxy_boxes: list,
-                  max_bbox_count: int = 500) -> VisualDetectorOutput:
-    """Convert detection output to Clarifai detector output format
-
-    Args:
-        width (int): image width
-        height (int): image height
-        labels (list): list of labels
-        scores (list): list of scores
-        xyxy_boxes (list): list of bounding boxes in x_min, y_min, x_max, y_max format
-        max_bbox_count (int, optional): Maximum detection result. Defaults to 500.
-
-    Returns:
-        VisualDetectorOutput
-    """
-    assert len(labels) == len(scores) == len(
-        xyxy_boxes
-    ), f"Length of `labels`, `scores` and `bboxes` must be equal, got {len(labels)}, {len(scores)} and {len(xyxy_boxes)} "
-    labels = [[each] for each in labels]
-    scores = [[each] for each in scores]
-    bboxes = [[x[1] / height, x[0] / width, x[3] / height, x[2] / width]
-              for x in xyxy_boxes]  # normalize the bboxes to [0,1] and [y1 x1 y2 x2]
-    bboxes = np.clip(bboxes, 0, 1.)
-    if len(bboxes) != 0:
-      bboxes = np.concatenate((bboxes, np.zeros((max_bbox_count - len(bboxes), 4))))
-      scores = np.concatenate((scores, np.zeros((max_bbox_count - len(scores), 1))))
-      labels = np.concatenate((labels, np.zeros((max_bbox_count - len(labels), 1),
-                                                dtype=np.int32)))
-    else:
-      bboxes = np.zeros((max_bbox_count, 4), dtype=np.float32)
-      scores = np.zeros((max_bbox_count, 1), dtype=np.float32)
-      labels = np.zeros((max_bbox_count, 1), dtype=np.int32)
-
-    output = VisualDetectorOutput(
-        predicted_bboxes=bboxes, predicted_labels=labels, predicted_scores=scores)
-
-    return output
-
-
-class VisualEmbedder(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.visual_embedder)
-
-  def predict(self,
-              input_data: List[np.ndarray],
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}
-             ) -> Iterable[EmbeddingOutput]:
-    """ Custom prediction function for `visual-embedder` model.
-
-    Args:
-      input_data (List[np.ndarray]): List of image
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of EmbeddingOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.visual_embedder
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)
-
-
-class VisualSegmenter(_BaseClarifaiModel):
-  _config: ModelConfigClass = get_model_config(ModelTypes.visual_segmenter)
-
-  def predict(
-      self,
-      input_data: List[np.ndarray],
-      inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> Iterable[MasksOutput]:
-    """ Custom prediction function for `visual-segmenter` model.
-
-    Args:
-      input_data (List[np.ndarray]): List of image
-      inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters
-
-    Returns:
-      list of MasksOutput
-    """
-    raise NotImplementedError
-
-  @triton_wrapper.visual_segmenter
-  def _tritonserver_predict(self,
-                            input_data,
-                            inference_parameters: Dict[str, Union[bool, str, float, int]] = {}):
-    """ This method is invoked within tritonserver, specifically in the model.py of the Python backend. Attempting to execute it outside of the triton environment will result in failure."""
-    return self.predict(input_data, inference_parameters=inference_parameters)

clarifai/models/model_serving/model_config/config.py

@@ -1,312 +0,0 @@
-import logging
-from copy import deepcopy
-from dataclasses import asdict, dataclass, field
-from typing import Any, List
-
-import yaml
-
-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__ = ["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"
-  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())
-
-  @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")]
-
-    return _visual + [self.multimodal_embedder]
-
-
-@dataclass
-class FieldMapsConfig:
-  input_fields_map: dict = field(default_factory=dict)
-  output_fields_map: dict = field(default_factory=dict)
-
-
-@dataclass
-class ServingBackendConfig:
-  """
-  """
-  triton: TritonModelConfig = None
-
-
-@dataclass
-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():
-  """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,
-      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_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.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
-  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 = 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:
-  """
-  Get model config by model type
-
-  Args:
-
-    model_type (str): One of field value of ModelTypes
-
-  Return:
-    ModelConfigClass
-
-  ### Example:
-  >>> 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)
-
-  """
-  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(clarifai_model=None, serving_backend=None)
-
-  import os
-  assert model_type in MODEL_TYPES, f"`model_type` must be in {MODEL_TYPES}"
-  cfg = read_yaml(
-      os.path.join(os.path.dirname(__file__), "model_types_config", f"{model_type}.yaml"))
-  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