clarifai 11.7.5rc1__py3-none-any.whl → 11.8.1__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 ...constants import IMAGE_TENSOR_NAME, TEXT_TENSOR_NAME
-from ...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,23 +0,0 @@
-import os
-
-from .constants import CLARIFAI_PAT_PATH
-
-
-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):
-    return None
-  with open(CLARIFAI_PAT_PATH, "r") as f:
-    return f.read().replace("\n", "").replace("\r", "").strip()
-
-
-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

clarifai/runners/models/base_typed_model.py

@@ -1,238 +0,0 @@
-import itertools
-from typing import Any, Dict, Iterator, List, Tuple
-
-import numpy as np
-from clarifai_grpc.grpc.api import resources_pb2, service_pb2
-from clarifai_grpc.grpc.api.service_pb2 import PostModelOutputsRequest
-from google.protobuf import json_format
-
-from ..utils.data_handler import InputDataHandler, OutputDataHandler
-from .model_runner import ModelRunner
-
-
-class AnyAnyModel(ModelRunner):
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_dict = [
-        InputDataHandler.from_proto(input).to_python() for input in input_request.inputs
-    ]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_dict, inference_params
-
-  def convert_output_to_proto(self, outputs: list):
-    assert (isinstance(outputs, Iterator) or isinstance(outputs, list) or
-            isinstance(outputs, tuple)), "outputs must be an Iterator"
-    output_protos = []
-    for output in outputs:
-      if isinstance(output, OutputDataHandler):
-        output = output.proto
-      elif isinstance(output, resources_pb2.Output):
-        pass
-      else:
-        raise NotImplementedError
-      output_protos.append(output)
-
-    return service_pb2.MultiOutputResponse(outputs=output_protos)
-
-  def predict_wrapper(
-      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
-    list_dict_input, inference_params = self.parse_input_request(request)
-    outputs = self.predict(list_dict_input, inference_parameters=inference_params)
-    return self.convert_output_to_proto(outputs)
-
-  def generate_wrapper(
-      self, request: PostModelOutputsRequest) -> Iterator[service_pb2.MultiOutputResponse]:
-    list_dict_input, inference_params = self.parse_input_request(request)
-    outputs = self.generate(list_dict_input, inference_parameters=inference_params)
-    for output in outputs:
-      yield self.convert_output_to_proto(output)
-
-  def _preprocess_stream(
-      self, request: Iterator[PostModelOutputsRequest]) -> Iterator[Tuple[List[Dict], List[Dict]]]:
-    """Return generator of processed data (from proto to python) and inference parameters like predict and generate"""
-    for i, req in enumerate(request):
-      input_data, _ = self.parse_input_request(req)
-      yield input_data
-
-  def stream_wrapper(self, request: Iterator[PostModelOutputsRequest]
-                    ) -> Iterator[service_pb2.MultiOutputResponse]:
-    first_request = next(request)
-    _, inference_params = self.parse_input_request(first_request)
-    request_iterator = itertools.chain([first_request], request)
-    outputs = self.stream(self._preprocess_stream(request_iterator), inference_params)
-    for output in outputs:
-      yield self.convert_output_to_proto(output)
-
-  def predict(self, input_data: List[Dict],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data: is list of dict where key is input type name.
-      * image: np.ndarray
-      * text: str
-      * audio: bytes
-
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def generate(self, input_data: List[Dict],
-               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
-    """
-    Generate method.
-
-    Args:
-    -----
-    - input_data: is list of dict where key is input type name.
-      * image: np.ndarray
-      * text: str
-      * audio: bytes
-
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def stream(self, inputs: Iterator[List[Dict[str, Any]]],
-             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
-    """
-    Stream method.
-
-    Args:
-    -----
-    input_request: is an Iterator of Tuple which
-    - First element (List[Dict[str, Union[np.ndarray, str, bytes]]]) is list of dict input data type which keys and values are:
-        * image: np.ndarray
-        * text: str
-        * audio: bytes
-
-    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-
-class VisualInputModel(AnyAnyModel):
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_dict = [
-        InputDataHandler.from_proto(input).image(format="np") for input in input_request.inputs
-    ]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_dict, inference_params
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def predict(self, input_data: List[np.ndarray],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[np.ndarray]): is list of image as np.ndarray type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-
-class TextInputModel(AnyAnyModel):
-
-  def load_model(self):
-    """
-    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.
-    """
-    raise NotImplementedError
-
-  def parse_input_request(
-      self, input_request: service_pb2.PostModelOutputsRequest) -> Tuple[List[Dict], Dict]:
-    list_input_text = [InputDataHandler.from_proto(input).text for input in input_request.inputs]
-    inference_params = json_format.MessageToDict(
-        input_request.model.model_version.output_info.params)
-
-    return list_input_text, inference_params
-
-  def predict(self, input_data: List[str],
-              inference_parameters: Dict[str, Any] = {}) -> List[OutputDataHandler]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[str]): is list of text as str type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Returns:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def generate(self, input_data: List[str],
-               inference_parameters: Dict[str, Any] = {}) -> Iterator[List[OutputDataHandler]]:
-    """
-    Prediction method.
-
-    Args:
-    -----
-    - input_data(List[str]): is list of text as str type
-    - inference_parameters (Dict[str, Union[bool, str, float, int]]): your inference parameters.
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError
-
-  def stream(self, inputs: Iterator[List[str]],
-             inference_params: Dict[str, Any]) -> Iterator[List[OutputDataHandler]]:
-    """
-    Stream method.
-
-    Args:
-    -----
-    input_request: is an Iterator of Tuple which
-    - First element (List[str]) is list of input text:
-    - Second element (Dict[str, Union[bool, str, float, int]]): is a dict of inference_parameters
-
-    Yield:
-    --------
-      List of OutputDataHandler
-    """
-    raise NotImplementedError