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

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()

clarifai/models/model_serving/repo_build/static_files/sample_clarifai_config.yaml

@@ -1,25 +0,0 @@
-# Sample config of inference_parameters and labels
-# For detail, please refer to docs
-# --------------------
-# inference_parameters:
-#   - path: boolean_var
-#     default_value: true
-#     field_type: 1
-#     description: a boolean variable
-#   - path: string_var
-#     default_value: "a string"
-#     field_type: 2
-#     description: a string variable
-#   - path: number_var
-#     default_value: 1
-#     field_type: 3
-#     description: a number variable
-#   - path: secret_string_var
-#     default_value: "YOUR_SECRET"
-#     field_type: 21
-#     description: a string variable contains secret like API key
-# labels:
-#   - concept1
-#   - concept2
-#   - concept3
-#   - concept4

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

@@ -1,40 +0,0 @@
-import unittest
-
-from clarifai.models.model_serving.repo_build import BaseTest
-
-
-class CustomTest(unittest.TestCase):
-  """
-  BaseTest loads the InferenceModel from the inference.py file in the current working directory.
-  To execute the predict method of the InferenceModel, use the predict method in BaseTest.
-  It takes the exact same inputs and inference parameters, returning the same outputs as InferenceModel.predict.
-  The difference is that BaseTest.predict verifies your_infer_parameters against config.clarifai_models.inference_parameters and checks the output values.
-
-  For example, test input value of visual-classifier
-
-  def test_input(self):
-    import cv2
-    path = "path/to/image"
-    img = cv2.imread(path)
-    outputs = self.model.predict([img], infer_param1=..., infer_param2=...)
-    print(outputs)
-    assert outputs
-
-  """
-
-  def setUp(self) -> None:
-    your_infer_parameter = dict(
-    )  # for example dict(float_var=0.12, string_var="test", _secret_string_var="secret")
-    self.model = BaseTest(your_infer_parameter)
-
-  def test_default_cases(self):
-    """Test your model with dummy inputs.
-    In general, you only need to run this test to check your InferneceModel implementation.
-    In case the default inputs makes your model failed for some reason (not because of assert in `test_with_default_inputs`),
-    you can comment out this test.
-    """
-    self.model.test_with_default_inputs()
-
-  def test_specific_case1(self):
-    """ Implement your test case"""
-    pass

clarifai/models/model_serving/repo_build/static_files/triton/model.py

@@ -1,75 +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 inference server Python Backend Model."""
-
-import os
-import sys
-
-try:
-  import triton_python_backend_utils as pb_utils
-except ModuleNotFoundError:
-  pass
-from clarifai.models.model_serving.model_config.inference_parameter import parse_req_parameters
-
-
-class TritonPythonModel:
-  """
-  Triton Python BE Model.
-  """
-
-  def initialize(self, args):
-    """
-    Triton server init.
-    """
-    sys.path.append(os.path.dirname(__file__))
-    from inference import InferenceModel
-
-    self.inference_obj = InferenceModel()
-
-    # Read input_name from config file
-    self.input_names = [inp.name for inp in self.inference_obj.config.serving_backend.triton.input]
-
-  def execute(self, requests):
-    """
-    Serve model inference requests.
-    """
-    responses = []
-
-    for request in requests:
-      try:
-        parameters = request.parameters()
-      except Exception:
-        print(
-            "It seems this triton version does not support `parameters()` in request. "
-            "Please upgrade tritonserver version otherwise can not use `inference_parameters`. Error message: {e}"
-        )
-        parameters = None
-
-      parameters = parse_req_parameters(parameters) if parameters else {}
-
-      if len(self.input_names) == 1:
-        in_batch = pb_utils.get_input_tensor_by_name(request, self.input_names[0])
-        in_batch = in_batch.as_numpy()
-        data = in_batch
-      else:
-        data = {}
-        for input_name in self.input_names:
-          in_batch = pb_utils.get_input_tensor_by_name(request, input_name)
-          in_batch = in_batch.as_numpy() if in_batch is not None else []
-          data.update({input_name: in_batch})
-
-      inference_response = self.inference_obj._tritonserver_predict(
-          input_data=data, inference_parameters=parameters)
-      responses.append(inference_response)
-
-    return responses

clarifai/models/model_serving/utils.py

@@ -1,31 +0,0 @@
-import os
-
-from clarifai.models.model_serving.constants import CLARIFAI_PAT_PATH
-from clarifai.utils.constants import CLARIFAI_PAT_ENV_VAR
-
-
-def _persist_pat(pat: str):
-  """ Write down pat to CLARIFAI_PAT_PATH """
-  with open(CLARIFAI_PAT_PATH, "w") as f:
-    f.write(pat)
-
-
-def _read_pat():
-  if not os.path.exists(CLARIFAI_PAT_PATH) and not os.environ.get(CLARIFAI_PAT_ENV_VAR, ""):
-    return None
-  if os.path.exists(CLARIFAI_PAT_PATH):
-    with open(CLARIFAI_PAT_PATH, "r") as f:
-      return f.read().replace("\n", "").replace("\r", "").strip()
-  elif os.environ.get(CLARIFAI_PAT_ENV_VAR):
-    return os.environ.get(CLARIFAI_PAT_ENV_VAR)
-  else:
-    raise ValueError(
-        f"PAT not found, please run `clarifai login` to persist your PAT or set it as an environment variable under the name '{CLARIFAI_PAT_ENV_VAR}'"
-    )
-
-
-def login(pat=None):
-  """ if pat provided, set pat to CLARIFAI_PAT otherwise read pat from file"""
-  pat = pat or _read_pat()
-  assert pat, Exception("PAT is not found, please run `clarifai login` to persist your PAT")
-  os.environ["CLARIFAI_PAT"] = pat