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

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]

clarifai/models/model_serving/repo_build/static_files/base_test.py

@@ -1,169 +0,0 @@
-import os
-from copy import deepcopy
-from typing import Dict, Iterable, List, Union
-
-import numpy as np
-import yaml
-
-from clarifai.models.model_serving.constants import IMAGE_TENSOR_NAME, TEXT_TENSOR_NAME
-from clarifai.models.model_serving.model_config import (
-    ClassifierOutput, EmbeddingOutput, ImageOutput, InferParam, InferParamManager, MasksOutput,
-    ModelTypes, TextOutput, VisualDetector, load_user_config)
-
-_default_texts = ["Photo of a cat", "A cat is playing around", "Hello, this is test"]
-
-_default_images = [
-    np.zeros((100, 100, 3), dtype='uint8'),  #black
-    np.ones((100, 100, 3), dtype='uint8') * 255,  #white
-    np.random.uniform(0, 255, (100, 100, 3)).astype('uint8')  #noise
-]
-
-
-def _is_valid_logit(x: np.array):
-  return np.all(0 <= x) and np.all(x <= 1)
-
-
-def _is_non_negative(x: np.array):
-  return np.all(x >= 0)
-
-
-def _is_integer(x):
-  return np.all(np.equal(np.mod(x, 1), 0))
-
-
-class BaseTest:
-  init_inference_parameters = {}
-
-  def __init__(self, init_inference_parameters={}) -> None:
-    import sys
-    if 'inference' in sys.modules:
-      del sys.modules['inference']
-    import inference
-    from inference import InferenceModel
-    self.model = InferenceModel()
-    self._base_dir = os.path.dirname(inference.__file__)
-    self.cfg_path = os.path.join(self._base_dir, "clarifai_config.yaml")
-    self.user_config = load_user_config(self.cfg_path)
-    self._user_labels = None
-    # check if labels exists
-    for output_config in self.user_config.serving_backend.triton.output:
-      if output_config.label_filename:
-        self._user_labels = self.user_config.clarifai_model.labels
-        assert self._user_labels, f"Model type `{self.user_config.clarifai_model.type}` requires labels, "\
-        f"but can not found value of `clarifai_model.labels` in {self.cfg_path}. Please update this attribute to build the model"
-
-    # update init vs user_defined params
-    user_defined_infer_params = [
-        InferParam(**each) for each in self.user_config.clarifai_model.inference_parameters
-    ]
-    total_infer_params = []
-    if init_inference_parameters:
-      self.init_inference_parameters = init_inference_parameters
-    for k, v in self.init_inference_parameters.items():
-      _exist = False
-      for user_param in user_defined_infer_params:
-        if user_param.path == k:
-          if user_param.default_value != v:
-            print(f"Warning: Overwrite parameter `{k}` with default value `{v}`")
-          user_param.default_value = v
-          _exist = True
-          total_infer_params.append(user_param)
-          user_defined_infer_params.remove(user_param)
-          break
-      if not _exist:
-        total_infer_params.append(InferParamManager.from_kwargs(**{k: v}).params[0])
-
-    self.infer_param_manager = InferParamManager(
-        params=total_infer_params + user_defined_infer_params)
-    self.user_config.clarifai_model.inference_parameters = self.infer_param_manager.get_list_params(
-    )
-    self._overwrite_cfg()
-
-  @property
-  def user_labels(self):
-    return self._user_labels
-
-  def _overwrite_cfg(self):
-    config = yaml.dump(self.user_config.dump_to_user_config(),)
-    with open(self.cfg_path, "w") as f:
-      f.write(config)
-
-  def predict(self, input_data: Union[List[np.ndarray], List[str], Dict[str, Union[List[
-      np.ndarray], List[str]]]], **inference_parameters) -> Iterable:
-    """
-    Test Prediction method is exact `InferenceModel.predict` method with
-    checking inference paramters.
-
-    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: keyword args of your inference parameters.
-
-    Returns:
-    --------
-      List of your inference model output type
-    """
-    infer_params = self.infer_param_manager.validate(**inference_parameters)
-    outputs = self.model.predict(input_data=input_data, inference_parameters=infer_params)
-    outputs = self._verify_outputs(outputs)
-    return outputs
-
-  def _verify_outputs(self, outputs: List[Union[ClassifierOutput, VisualDetector, EmbeddingOutput,
-                                                TextOutput, ImageOutput, MasksOutput]]):
-    """Test output value/dims
-
-    Args:
-      outputs (List[Union[ClassifierOutput, VisualDetector, EmbeddingOutput, TextOutput, ImageOutput, MasksOutput]]): Outputs of `predict` method
-    """
-    _outputs = deepcopy(outputs)
-    _output = _outputs[0]
-
-    if isinstance(_output, EmbeddingOutput):
-      # not test
-      pass
-    elif isinstance(_output, ClassifierOutput):
-      for each in _outputs:
-        assert _is_valid_logit(each.predicted_scores), "`predicted_scores` must be in range [0, 1]"
-        assert len(each.predicted_scores) == len(
-            self.user_labels
-        ), f"`predicted_scores` dim must be equal to labels, got {len(each.predicted_scores)} != labels {len(self.user_labels)}"
-    elif isinstance(_output, VisualDetector):
-      for each in _outputs:
-        assert _is_valid_logit(each.predicted_scores), "`predicted_scores` must be in range [0, 1]"
-        assert _is_integer(each.predicted_labels), "`predicted_labels` must be integer"
-        assert np.all(0 <= each.predicted_labels) and np.all(each.predicted_labels < len(
-            self.user_labels)), f"`predicted_labels` must be in [0, {len(self.user_labels) - 1}]"
-        assert _is_non_negative(each.predicted_bboxes), "`predicted_bboxes` must be >= 0"
-    elif isinstance(_output, MasksOutput):
-      for each in _outputs:
-        assert np.all(0 <= each.predicted_mask) and np.all(each.predicted_mask < len(
-            self.user_labels)), f"`predicted_mask` must be in [0, {len(self.user_labels) - 1}]"
-    elif isinstance(_output, TextOutput):
-      pass
-    elif isinstance(_output, ImageOutput):
-      for each in _outputs:
-        assert _is_non_negative(each.image), "`image` must be >= 0"
-    else:
-      pass
-
-    return outputs
-
-  def test_with_default_inputs(self):
-    model_type = self.user_config.clarifai_model.type
-    if model_type == ModelTypes.multimodal_embedder:
-      self.predict(input_data=[{IMAGE_TENSOR_NAME: each} for each in _default_images])
-      self.predict(input_data=[{TEXT_TENSOR_NAME: each} for each in _default_texts])
-      self.predict(input_data=[{
-          TEXT_TENSOR_NAME: text,
-          IMAGE_TENSOR_NAME: img
-      } for text, img in zip(_default_texts, _default_images)])
-    elif model_type.startswith("visual"):
-      self.predict(input_data=_default_images)
-    else:
-      self.predict(input_data=_default_texts)

clarifai/models/model_serving/repo_build/static_files/inference.py

@@ -1,26 +0,0 @@
-# User model inference script.
-
-import os
-from pathlib import Path
-from typing import Dict, Union
-from clarifai.models.model_serving.model_config import *  # noqa
-
-
-class InferenceModel():
-  """User model inference class."""
-
-  def __init__(self) -> None:
-    """
-    Load inference time artifacts that are called frequently .e.g. models, tokenizers, etc.
-    in this method so they are loaded only once for faster inference.
-    """
-    # current directory
-    self.base_path: Path = os.path.dirname(__file__)
-
-  def predict(self,
-              input_data: list,
-              inference_parameters: Dict[str, Union[bool, str, float, int]] = {}) -> list:
-    """predict_docstring
-    """
-
-    raise NotImplementedError()