clarifai 9.10.2__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai_utils/models/model_serving/cli/repository.py

@@ -1,87 +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 model repository generation commandline interface."""
-
-import argparse
-
-from ..constants import MAX_HW_DIM
-from ..model_config import MODEL_TYPES, get_model_config
-from ..pb_model_repository import TritonModelRepository
-
-
-def dims_type(shape_string: str):
-  """Read list string from cli and convert values to a list of integers."""
-  shape_string = shape_string.replace("[", "").replace("]", "")
-  shapes = list(map(int, shape_string.split(",")))
-  return shapes
-
-
-def model_upload_init():
-  """
-  Clarifai triton model upload commandline tool.
-  """
-  parser = argparse.ArgumentParser(description=__doc__)
-  # TritonModelConfig args
-  parser.add_argument("--model_name", type=str, required=True, help="Inference Model Name")
-  parser.add_argument(
-      "--model_version",
-      type=str,
-      default="1",
-      required=False,
-      help="Triton inference model version name. 1 stands for version 1. \
-    Leave as default value (Recommended).")
-  parser.add_argument(
-      "--model_type",
-      type=str,
-      choices=MODEL_TYPES,
-      required=True,
-      help=f"Clarifai supported model types.\n Model-types-map: {MODEL_TYPES}",
-  )
-  parser.add_argument(
-      "--image_shape",
-      type=dims_type,
-      default="[-1, -1]",
-      required=False,
-      help="(H, W) dims for models with an image input type. H and W each have a max value of 1024",
-  )
-  parser.add_argument(
-      "--repo_dir",
-      type=str,
-      default=".",
-      required=True,
-      help="Directory to create triton repository.")
-
-  args = parser.parse_args()
-
-  if len(args.image_shape) != 2:
-    raise ValueError(
-        f"image_shape takes 2 values, Height and Width. Got {len(args.image_shape)} values instead."
-    )
-
-  if args.image_shape[0] > MAX_HW_DIM or args.image_shape[1] > MAX_HW_DIM:
-    raise ValueError(
-        f"H and W each have a maximum value of 1024. Got H: {args.image_shape[0]}, W: {args.image_shape[1]}"
-    )
-
-  model_config = get_model_config(args.model_type).make_triton_model_config(
-      model_name=args.model_name,
-      model_version="1",
-      image_shape=args.image_shape,
-  )
-
-  triton_repo = TritonModelRepository(model_config)
-  triton_repo.build_repository(args.repo_dir)
-
-
-if __name__ == "__main__":
-  model_upload_init()

clarifai_utils/models/model_serving/constants.py

@@ -1 +0,0 @@
-MAX_HW_DIM = 1024

clarifai_utils/models/model_serving/docs/custom_config.md

@@ -1,33 +0,0 @@
-## Custom Triton Configurations
-
-The commandline triton model repository generation utils do work with default values for the various triton configurations but a few of these config values can be modified to suit different task specific needs.
-
-* For vision models for instance, different input shapes for the `Height (H)` and `Width (W)` are supported and can be set via the commandline too.i.e.
-```console
-$ clarifai-model-upload-init --model_name <Your model name> \
-		--model_type <select model type from available ones> \
-		--image_shape "H, W"
-		--repo_dir <directory in which to create your model repository>
-```
-`H` and `W` each have a maximum value of 1024.
-`--image_shape` accepts both `"H, W"` and `"[H, W]"` format input.
-
-
-## Generating the triton model repository without the commandline
-
-The triton model repository can be generated via a python script specifying the same values as required in the commandline. Below is a sample of how the code would be structured with `visual_classifier`.
-
-```python
-from clarifai.models.model_serving.model_config import get_model_config, ModelTypes, TritonModelConfig
-from clarifai.models.model_serving.pb_model_repository import TritonModelRepository
-
-model_type = ModelTypes.visual_classifier
-model_config: TritonModelConfig = get_model_config(model_type).make_triton_model_config(
-	model_name="<model_name>",
-	model_version="1",
-	image_shape=<[H,W]>, # 0 < [H,W] <= 1024
-)
-
-triton_repo = TritonModelRepository(model_config)
-triton_repo.build_repository("<dir>")
-```

clarifai_utils/models/model_serving/docs/dependencies.md

@@ -1,11 +0,0 @@
-## Inference Execution Environments
-
-Each model built for inference with triton requires certain dependencies & dependency versions be installed for successful inference execution.
-An execution environment is created for each model to be deployed on Clarifai and all necessary dependencies as listed in the `requirements.txt` file are installed there.
-
-## Supported python and torch versions
-
-Currently, models must use python 3.8 (any 3.8.x).  Supported torch versions are 1.13.1 and 2.0.1.
-If your model depends on torch, torch must be listed in your requirements.txt file (even if it is
-already a dependency of another package).  An appropriate supported torch version will be selected
-based on your requirements.txt.

clarifai_utils/models/model_serving/docs/inference_parameters.md

@@ -1,134 +0,0 @@
-## Inference paramaters
-
-When making prediction, you may need to change some paramaters to adjust the result. Those paramaters will be passed through `paramaters()` of a request in triton python model.
-
-In order to send it to `**kwargs` of `get_predictions` in `inference.py`, you can define some parameters and they will be visible and adjustable on Clarifai model view.
-
-This document helps you to create your inference parameters that can be visibale and adjustable easily on Clarifai platform. The defined parameters will be sent as `json` file when you use `clarifai-upload-model` cli.
-
-### JSON file structure:
-The file contains a list of object has 4 fields:
-* `path` (str): name of your parameter, it must be valid as python variable
-* `field_type` (int): the parameter data type is one of {1,2,21,3}, it means {boolean, string, encrypted_string, number} respectively. `Number` means `int` or `float`. "Encrypted_string is a string that can be used to store your secrets, like API key. The API will not return the values for this as plaintext.
-* `default_value`: a default value of the parameter.
-* `description` (str): short sentence describes what the parameter does
-
-An example of 4 parameters:
-```json
-[
-  {
-    "path": "boolean_var",
-    "field_type": 1,
-    "default_value": true,
-    "description": "a boolean variable"
-  },
-  {
-    "path": "string_var",
-    "field_type": 2,
-    "default_value": "string_1",
-    "description": "a string variable"
-  },
-  {
-    "path": "number_var",
-    "field_type": 3,
-    "default_value": 9.9,
-    "description": "a float number variable"
-  },
-  {
-    "path": "secret_string_var",
-    "field_type": 21,
-    "default_value": "API_KEY",
-    "description": "a string variable contains secret like API key"
-  },
-]
-```
-
-### Generate JSON file
-1. Manually create the file based on above structure
-2. By code:
-
-#### 2.1. Fully setup
-```python
-from clarifai.models.model_serving.model_config.inference_parameter import InferParamManager, InferParam, InferParamType
-
-params = [
-  InferParam(
-    path="boolean_var",
-    field_type=InferParamType.BOOL,
-    default_value=True,
-    description="a boolean varaiabe"
-  ),
-  InferParam(
-    path="string_var",
-    field_type=InferParamType.STRING,
-    default_value="string_1",
-    description="a string varaiabe"
-  ),
-  InferParam(
-    path="number_var",
-    field_type=InferParamType.NUMBER,
-    default_value=9.9,
-    description="a float number varaiabe"
-  ),
-  InferParam(
-    path=secret_string_var",
-    field_type=InferParamType.ENCRYPTED_STRING,
-    default_value="API_KEY",
-    description="a string variable contains secret like API key"
-  ),
-]
-
-ipm = InferParamManager(params=params)
-ipm.export("your_file.json")
-```
-
-##### 2.2. Shorten
-`NOTE`: in this way `description` field will be set as empty aka "".
-*You need to modify* `description` in order to be able to upload the settings to Clarifai.
-
-`NOTE`: in this way `ENCRYPTED_STRING` type must be defined with "_" prefix
-
-```python
-params = dict(boolean_var=True, string_var="string_1", number_var=9.9, _secret_string_var="YOUR_KEY")
-ipm = InferParamManager.from_kwargs(**params)
-ipm.export("your_file.json")
-
-```
-
-3. In `test.py`. You can define your paramaters like `2.2. Shorten` in `inference_parameters` attribute of `CustomTestInferenceModel`, the file will be generated when you run the test. Keep in mind to change `description`
-
-### Usage
-Your defined parameters will be passed through `kwargs` of `InferenceModel.get_predictions` method
-in `inference.py`
-```python
-class InferenceModel:
-  def __init__():
-    # initialization
-    self.model = YourModel()
-
-  @some_wrapper_function
-  def get_predictions(self, input_data, **kwargs):
-    # `kwargs` contains your inference parameters
-
-    # get a value from kwargs
-    number_var = kwargs.get("number_var", 9.9)
-
-    # pass everything to a function
-    output = self.model.predict(input_data, **kwargs)
-
-    return SomeOutputType(output)
-
-```
-
-in `test.py`
-```python
-class CustomTestInferenceModel:
-  inference_parameters = "" # input a path of json file from `2.1` or a dict from `2.2`
-
-  ...
-
-  def test_something(self):
-    input = ...
-    output = self.triton_get_predictions(input, number_var=1, string_var="test", _secret="KEY")
-    self.assert(...)
-```

clarifai_utils/models/model_serving/docs/model_types.md

@@ -1,20 +0,0 @@
-## Clarifai Model Types
-
-Models on the clarifai platform are deployed using the [Triton Inference Server Python Backend](https://github.com/triton-inference-server/python_backend) to allow for pre and post processing of data to and from the model.
-
-Inputs into the models are passed as numpy arrays and the predictions are similarly returned as numpy arrays.
-The predictions from user defined models in the [inference script](../README.md#the-inference-script) file have to match certain formats and shapes for the models to be upload compatible.
-
-Clarifai [model types](../models/model_types.py) are decorator functions that are responsible for passing input batch requests to user defined inference models to get predictions and format the resultant predictions into Triton Inference responses that are sent by the server for each client inference request.
-
-## Supported Model Types Wrapper Functions:
-
-- visual_detector
-- visual_classifier
-- text_classifier
-- text_to_text
-- text_embedder
-- text_to_image
-- visual_embedder
-- visual_segmenter
-- multimodal_embedder

clarifai_utils/models/model_serving/docs/output.md

@@ -1,28 +0,0 @@
-## Clarifai Model Prediction Output Formats.
-
-Different models return different types of predictions and Clarifai output dataclasses aim at standardizing the output formats per model type for compatibility with the Clarifai API.
-
-Each machine learning modality supported by the Clarifai API has a predefined dataclass output format with all attributes being of numpy ndarray type.
-
-## Supported Formats
-
-Usage:
-```python
-from clarifai.models.model_serving.models.output import VisualDetectorOutput
-```
-| Output Type (dataclass) | Attributes | Attribute Data Type| Attribute Shapes | Description |
-| --- | --- | --- | --- | --- |
-| [VisualDetectorOutput](../models/output.py) | `predicted_bboxes` | float32 | [-1, 4] | A 2D detected bounding boxes array of any length with each element array having a length of exactly 4. All bbox coordinates MUST be normalized between 0 & 1. |
-| | `predicted_labels` | int32 | [-1, 1] | A 2D detected labels array of length equal to that of predicted_bboxes with each element array having a length of exactly 1.
-| | `predicted_scores` | float32 | [-1, 1] | A 2D detection scores array of length equal to that of predicted_bboxes & predicted_labels with each element array having a length of exactly 1.
-| | | | | |
-| [ClassifierOutput](../models/output.py) | `predicted_scores` | float32 | [-1] | The softmax of the model's predictions. The index of each predicted probability as returned by the model must correspond to the label index in the labels.txt file |
-| | | | | |
-| [TextOutput](../models/output.py) | `predicted_text` | string | [1] | Predicted text from a model |
-| | | | | |
-| [EmbeddingOutput](../models/output.py) | `embedding_vector` | float32 | [-1] | The embedding vector (image or text embedding) returned by a model |
-| | | | | |
-| [MasksOutput](../models/output.py) | `predicted_mask` | int64 | [-1, -1] | The model predicted image mask. The predicted class indices must be assigned to the corresponding image pixels in the mask where that class is predicted by the model. |
-| | | | | |
-| [ImageOutput](../models/output.py) | `image` | unint8 | [-1, -1, 3] | The model predicted/generated image |
-| | | | | |

clarifai_utils/models/model_serving/examples/README.md

@@ -1,7 +0,0 @@
-## Clarifai Model Upload Examples
-
-A collection of pre-built triton models for different tasks.
-To run inference locally using any of the examples here, you need to have the [Triton Inference Server](https://github.com/triton-inference-server/server/blob/main/docs/customization_guide/build.md#building-with-docker) installed.
-
-Additionally some models may require other files such as checkpoints be downloaded before testing and/or deployment to Clarifai as they are ommitted here due to github file size limits.
-See the Readme files under each model to see if there any additional files required and where to place them.

clarifai_utils/models/model_serving/examples/image_classification/README.md

@@ -1,9 +0,0 @@
-## Image Classification Triton Model Examples
-
-These can be used on the fly with minimal or no changes to test deploy image classification models to the Clarifai platform. See the required files section for each model below.
-
-* ### [VIT Age Classifier](./age_vit/)
-
-	Required files to run tests locally:
-
-	* Download the [model checkpoint from huggingface](https://huggingface.co/nateraw/vit-age-classifier/tree/main) and store it under `age_vit/1/vit-age-classifier/`

clarifai_utils/models/model_serving/examples/image_classification/age_vit/1/inference.py

@@ -1,56 +0,0 @@
-# This file contains boilerplate code to allow users write their model
-# inference code that will then interact with the Triton Inference Server
-# Python backend to serve end user requests.
-# The module name, module path, class name & get_predictions() method names MUST be maintained as is
-# but other methods may be added within the class as deemed fit provided
-# they are invoked within the main get_predictions() inference method
-# if they play a role in any step of model inference
-"""User model inference script."""
-
-import os
-from pathlib import Path
-from typing import Callable
-
-import torch
-from scipy.special import softmax
-from transformers import ViTFeatureExtractor, ViTForImageClassification
-
-from clarifai.models.model_serving.models.model_types import visual_classifier
-from clarifai.models.model_serving.models.output import ClassifierOutput
-
-
-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.
-    """
-    self.base_path: Path = os.path.dirname(__file__)
-    self.huggingface_model_path: Path = os.path.join(self.base_path, "vit-age-classifier")
-    self.transforms = ViTFeatureExtractor.from_pretrained(self.huggingface_model_path)
-    self.model: Callable = ViTForImageClassification.from_pretrained(self.huggingface_model_path)
-    self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-  @visual_classifier
-  def get_predictions(self, input_data) -> ClassifierOutput:
-    """
-    Main model inference method.
-
-    Args:
-    -----
-      input_data: A single input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-    Returns:
-    --------
-      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
-    """
-    # Transform image and pass it to the model
-    inputs = self.transforms(input_data, return_tensors='pt')
-    output = self.model(**inputs)
-    pred_scores = softmax(
-        output[0][0].detach().numpy())  # alt: softmax(output.logits[0].detach().numpy())
-
-    return ClassifierOutput(predicted_scores=pred_scores)

clarifai_utils/models/model_serving/examples/image_classification/age_vit/1/model.py

@@ -1,61 +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 google.protobuf import text_format
-from tritonclient.grpc.model_config_pb2 import ModelConfig
-
-
-class TritonPythonModel:
-  """
-  Triton Python BE Model.
-  """
-
-  def initialize(self, args):
-    """
-    Triton server init.
-    """
-    args["model_repository"] = args["model_repository"].replace("/1/model.py", "")
-    sys.path.append(os.path.dirname(__file__))
-    from inference import InferenceModel
-
-    self.inference_obj = InferenceModel()
-    self.device = "cuda:0" if "GPU" in args["model_instance_kind"] else "cpu"
-
-    # Read input_name from config file
-    self.config_msg = ModelConfig()
-    with open(os.path.join(args["model_repository"], "config.pbtxt"), "r") as f:
-      cfg = f.read()
-    text_format.Merge(cfg, self.config_msg)
-    self.input_name = [inp.name for inp in self.config_msg.input][0]
-
-  def execute(self, requests):
-    """
-    Serve model inference requests.
-    """
-    responses = []
-
-    for request in requests:
-      in_batch = pb_utils.get_input_tensor_by_name(request, self.input_name)
-      in_batch = in_batch.as_numpy()
-      inference_response = self.inference_obj.get_predictions(in_batch)
-      responses.append(inference_response)
-
-    return responses

clarifai_utils/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/README.md

@@ -1,11 +0,0 @@
----
-tags:
-- image-classification
-- pytorch
-datasets:
-- fairface
----
-
-## ViT For Age Classification
-
-A vision transformer finetuned to classify the age of a given person's face.

clarifai_utils/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/config.json

@@ -1,42 +0,0 @@
-{
-  "_name_or_path": "google/vit-base-patch16-224-in21k",
-  "architectures": [
-    "ViTForImageClassification"
-  ],
-  "attention_probs_dropout_prob": 0.0,
-  "hidden_act": "gelu",
-  "hidden_dropout_prob": 0.0,
-  "hidden_size": 768,
-  "id2label": {
-    "0": "0-2",
-    "1": "3-9",
-    "2": "10-19",
-    "3": "20-29",
-    "4": "30-39",
-    "5": "40-49",
-    "6": "50-59",
-    "7": "60-69",
-    "8": "more than 70"
-  },
-  "image_size": 224,
-  "initializer_range": 0.02,
-  "intermediate_size": 3072,
-  "label2id": {
-    "0-2": 0,
-    "3-9": 1,
-    "10-19": 2,
-    "20-29": 3,
-    "30-39": 4,
-    "40-49": 5,
-    "50-59": 6,
-    "60-69": 7,
-    "more than 70": 8
-  },
-  "layer_norm_eps": 1e-12,
-  "model_type": "vit",
-  "num_attention_heads": 12,
-  "num_channels": 3,
-  "num_hidden_layers": 12,
-  "patch_size": 16,
-  "transformers_version": "4.5.0.dev0"
-}

clarifai_utils/models/model_serving/examples/image_classification/age_vit/1/vit-age-classifier/preprocessor_config.json

@@ -1,15 +0,0 @@
-{
-    "do_normalize": true,
-    "do_resize": true,
-    "image_mean": [
-        0.5,
-        0.5,
-        0.5
-    ],
-    "image_std": [
-        0.5,
-        0.5,
-        0.5
-    ],
-    "size": 224
-}

clarifai_utils/models/model_serving/examples/image_classification/age_vit/config.pbtxt

@@ -1,23 +0,0 @@
-name: "age_vit"
-max_batch_size: 1
-input {
-  name: "image"
-  data_type: TYPE_UINT8
-  dims: -1
-  dims: -1
-  dims: 3
-}
-output {
-  name: "softmax_predictions"
-  data_type: TYPE_FP32
-  dims: -1
-  label_filename: "labels.txt"
-}
-instance_group {
-  count: 1
-  kind: KIND_GPU
-}
-dynamic_batching {
-  max_queue_delay_microseconds: 500
-}
-backend: "python"

clarifai_utils/models/model_serving/examples/image_classification/age_vit/labels.txt

@@ -1,9 +0,0 @@
-0-2
-3-9
-10-19
-20-29
-30-39
-40-49
-50-59
-60-69
-more than 70

clarifai_utils/models/model_serving/examples/image_classification/age_vit/requirements.txt

@@ -1,7 +0,0 @@
-clarifai>9.5.3 # for model upload features
-tritonclient[all]
-torch==1.13.1
-transformers==4.30.2
-scipy==1.10.1
-sentencepiece==0.1.99
-protobuf<4.21.3

clarifai_utils/models/model_serving/examples/text_classification/README.md

@@ -1,9 +0,0 @@
-## Text Classification Triton Model Examples
-
-These can be used on the fly with minimal or no changes to test deploy text classification models to the Clarifai platform. See the required files section for each model below.
-
-* ### [XLM-Roberta Tweet Sentiment Classifier](./xlm-roberta/)
-
-	Required files to run tests locally:
-
-	* Download the [model checkpoint & sentencepiece bpe model from huggingface](https://huggingface.co/cardiffnlp/twitter-xlm-roberta-base-sentiment/tree/main) and store it under `xlm-roberta/1/twitter-xlm-roberta-base-sentiment/`

clarifai_utils/models/model_serving/examples/text_classification/xlm-roberta/1/inference.py

@@ -1,55 +0,0 @@
-# This file contains boilerplate code to allow users write their model
-# inference code that will then interact with the Triton Inference Server
-# Python backend to serve end user requests.
-# The module name, module path, class name & get_predictions() method names MUST be maintained as is
-# but other methods may be added within the class as deemed fit provided
-# they are invoked within the main get_predictions() inference method
-# if they play a role in any step of model inference
-"""User model inference script."""
-
-import os
-from pathlib import Path
-from typing import Callable
-
-import torch
-from scipy.special import softmax
-from transformers import AutoModelForSequenceClassification, AutoTokenizer
-
-from clarifai.models.model_serving.models.model_types import text_classifier
-from clarifai.models.model_serving.models.output import ClassifierOutput
-
-
-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.
-    """
-    self.base_path: Path = os.path.dirname(__file__)
-    self.checkpoint_path: Path = os.path.join(self.base_path, "twitter-xlm-roberta-base-sentiment")
-    self.model: Callable = AutoModelForSequenceClassification.from_pretrained(self.checkpoint_path)
-    self.tokenizer: Callable = AutoTokenizer.from_pretrained(self.checkpoint_path)
-    self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-  @text_classifier
-  def get_predictions(self, input_data) -> ClassifierOutput:
-    """
-    Main model inference method.
-
-    Args:
-    -----
-      input_data: A single input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-    Returns:
-    --------
-      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
-    """
-    encoded_input = self.tokenizer(input_data, return_tensors='pt')
-    output = self.model(**encoded_input)
-    scores = output[0][0].detach().numpy()
-    scores = softmax(scores)
-
-    return ClassifierOutput(predicted_scores=scores)