clarifai 10.0.1__py3-none-any.whl → 10.1.1__py3-none-any.whl

clarifai/datasets/upload/loaders/xview_detection.py

@@ -6,7 +6,7 @@ from concurrent.futures import ThreadPoolExecutor
 from multiprocessing import cpu_count
 from typing import DefaultDict, Dict, List
 
-import cv2
+from PIL import Image
 from tqdm import tqdm
 
 from clarifai.datasets.upload.base import ClarifaiDataLoader
@@ -47,12 +47,15 @@ class xviewDetectionDataLoader(ClarifaiDataLoader):
 
     self.load_data()
 
+  @property
+  def task(self):
+    return "visual_detection"
+
   def compress_tiff(self, img_path: str) -> None:
     """Compress tiff image"""
     img_comp_path = os.path.join(self.img_comp_dir, os.path.basename(img_path))
-    img_arr = cv2.imread(img_path)
-    cv2.imwrite(
-        img_comp_path, img_arr, params=(cv2.IMWRITE_TIFF_COMPRESSION, 8))  # 8: Adobe Deflate
+    img_arr = Image.open(img_path)
+    img_arr.save(img_comp_path, 'TIFF', compression='tiff_deflate')
 
   def preprocess(self):
     """Compress the tiff images to comply with clarifai grpc image encoding limit(<20MB) Uses ADOBE_DEFLATE compression algorithm"""
@@ -129,7 +132,8 @@ class xviewDetectionDataLoader(ClarifaiDataLoader):
     _id = os.path.splitext(os.path.basename(self.image_paths[index]))[0]
     image_path = self.image_paths[index]
 
-    image_height, image_width = cv2.imread(image_path).shape[:2]
+    image = Image.open(image_path)
+    image_width, image_height = image.size
     annots = []
     class_names = []
     for bbox, concept in zip(self.all_data[_id]['bboxes'], self.all_data[_id]['concepts']):

clarifai/datasets/upload/utils.py

@@ -53,16 +53,19 @@ class DisplayUploadStatus:
 
   def __init__(self, dataloader: ClarifaiDataLoader,
                dataset_metrics_response: Type[MultiDatasetVersionMetricsGroupResponse],
-               dataset_info_dict: Dict[str, str]) -> None:
+               dataset_info_dict: Dict[str, str],
+               pre_upload_stats: Tuple[Dict[str, int], Dict[str, int]]) -> None:
     """Initialize the class.
     Args:
       dataloader: ClarifaiDataLoader object
       dataset_metrics_response: The dataset version metrics response from the server.
       dataset_info_dict: The dataset info dictionary.
+      pre_upload_stats: The pre upload stats for the dataset.
     """
     self.dataloader = dataloader
     self.dataset_metrics_response = dataset_metrics_response
     self.dataset_info_dict = dataset_info_dict
+    self.pre_upload_stats = pre_upload_stats
 
     self.display()
 
@@ -71,7 +74,18 @@ class DisplayUploadStatus:
     from rich.console import Console
 
     local_inputs_count, local_annotations_dict = self.get_dataloader_stats()
-    uploaded_inputs_dict, uploaded_annotations_dict = self.get_uploaded_dataset_stats()
+    uploaded_inputs_dict, uploaded_annotations_dict = self.get_dataset_version_stats(
+        self.dataset_metrics_response)
+
+    # Subtract the pre upload stats from the uploaded stats
+    uploaded_inputs_dict = {
+        key: int(uploaded_inputs_dict[key]) - int(self.pre_upload_stats[0].get(key, 0))
+        for key in uploaded_inputs_dict
+    }
+    uploaded_annotations_dict = {
+        key: uploaded_annotations_dict[key] - self.pre_upload_stats[1].get(key, 0)
+        for key in uploaded_annotations_dict
+    }
 
     self.local_annotations_count = sum(local_annotations_dict.values())
     self.uploaded_annotations_count = sum(uploaded_annotations_dict.values())
@@ -99,9 +113,6 @@ class DisplayUploadStatus:
     """
     from clarifai.constants.dataset import DATASET_UPLOAD_TASKS
 
-    if not isinstance(self.dataloader, ClarifaiDataLoader):
-      raise UserError("Dataloader is not an instance of ClarifaiDataLoader")
-
     task = self.dataloader.task
     if task not in DATASET_UPLOAD_TASKS:
       raise UserError(
@@ -113,8 +124,13 @@ class DisplayUploadStatus:
       local_annotations_dict[key] += len(getattr(self.dataloader[i], attr))
     return local_inputs_count, local_annotations_dict
 
-  def get_uploaded_dataset_stats(self) -> Tuple[Dict[str, int], Dict[str, int]]:
+  @staticmethod
+  def get_dataset_version_stats(
+      dataset_metrics_response: Type[MultiDatasetVersionMetricsGroupResponse]
+  ) -> Tuple[Dict[str, int], Dict[str, int]]:
     """Parse the response from the server for the dataset version metrics groups.
+    Args:
+      dataset_metrics_response: The dataset version metrics response from the server.
 
     Returns:
       uploaded_inputs_dict (Dict[str, int]): The input statistics for the dataset.
@@ -123,7 +139,7 @@ class DisplayUploadStatus:
     dataset_statistics = []
     uploaded_inputs_dict = {}
     uploaded_annotations_dict = dict(concepts=0, bboxes=0, polygons=0)
-    dict_response = MessageToDict(self.dataset_metrics_response)
+    dict_response = MessageToDict(dataset_metrics_response)
 
     for data in dict_response["datasetVersionMetricsGroups"]:
       if isinstance(data["value"], str):

clarifai/models/model_serving/README.md

@@ -1,110 +1,55 @@
-## Clarifai Model Serving: Deploy Your Machine Learning Models to Clarifai.
+# Clarifai Model Serving
 
-Build and easily deploy machine learning models to Clarifai for inference using the [Nvidia Triton Inference Server](https://github.com/triton-inference-server/server).
+## Overview
 
-## QuickStart Guide: Build a deployment ready model.
+Model Serving is a part of user journey at Clarifai offers a user-friendly interface for deploying your local model into production with Clarifai, featuring:
 
-A step by step guide to building your own triton inference model and deploying it into a Clarifai app.
+* A convenient command-line interface (CLI)
+* Easy implementation and testing in Python
+* No need for MLops expertise.
 
-1. Generate a triton model repository via commandline.
-```console
-clarifai-model-upload-init --model_name <Your model name> \
-		--model_type <select model type from available ones> \
-		--repo_dir <directory in which to create your model repository> \
-    --image_shape <(H, W) dims for models with an image input type. H and W each have a max value of 1024> \
-    --max_bs <Max batch size. Default is 1.>
-```
-2.  1. Edit the `requirements.txt` file with dependencies needed to run inference on your model and the `labels.txt` (if available in dir) with the labels your model is to predict.
-    2.  Add your model loading and inference code inside `inference.py` script of the generated model repository under the `setup()` and `predict()` functions respectively. Refer to  The [Inference Script section]() for a description of this file.
-    3. Inference parameters (optional): you can define some inference parameters that can be adjusted on model view of Clarifai platform when making prediction. Follow [this doc](./docs/inference_parameters.md) to build the json file.
-3. Testing (Recommend) your implementation locally by running `<your_triton_folder>/1/test.py` with basic predefined tests.
-To avoid missing dependencies when deploying, recommend to use conda to create clean environment. Then install everything in `requirements.txt`. Follow instruction inside [test.py](./models/test.py) for implementing custom tests.
-  * Create conda env and install requirements:
-```bash
-# create env (note: only python version 3.8 is supported currently)
-conda create -n <your_env> python=3.8
-# activate it
-conda activate <your_env>
-# install dependencies
-pip install -r <your_triton_folder>/requirements.txt
-```
-* Then run the test by using pytest:
+## Quickstart Guide
+
+Quick example for deploying a `text-to-text` model
+
+### Initialize a Clarifai model repository
+
+Suppose your working directory name is `your_model_dir`. Then run
 
 ```bash
-  # Run the test
-  pytest ./your_triton_folder/1/test.py
-  # to see std output
-  pytest --log-cli-level=INFO  -s ./your_triton_folder/1/test.py
-```
-4. Generate a zip of your triton model for deployment via commandline.
-```console
-clarifai-triton-zip --triton_model_repository <path to triton model repository to be compressed> \
-    --zipfile_name <name of the triton model zip> (Recommended to use 	  <model_name>_<model-type> convention for naming)
-```
-5. Upload the generated zip to a public file storage service to get a URL to the zip. This URL must be publicly accessible and downloadable as it's necessary for the last step: uploading the model to a Clarifai app.
-6. Set your Clarifai auth credentials as environment variables.
-```console
-export CLARIFAI_USER_ID=<your clarifai user_id>
-export CLARIFAI_APP_ID=<your clarifai app_id>
-export CLARIFAI_PAT=<your clarifai PAT>
-```
-7. Upload your model to Clarifai. Please ensure that your configuration field maps adhere to [this](https://github.com/Clarifai/clarifai-python-utils/blob/main/clarifai/models/model_serving/model_config/deploy.py)
-```console
-clarifai-upload-model --url <URL to your model zip. Your zip file name is expected to have "zipfile_name" format (in clarifai-triton-zip), if not you need to specify your model_id and model_type> \
-    --model_id <Your model ID on the platform> \
-    --model_type <Clarifai model types> \
-    --desc <A description of your model> \
-    --update_version <Optional. Add new version of existing model>  \
-    --infer_param <Optional. Path to json file contains inference parameters>
+$ clarifai create model --type text-to-text --working-dir your_model_dir
+$ cd your_model_dir
 ```
 
-* Finally, navigate to your Clarifai app models and check that the deployed model appears. Click it on the model name to go the model versions table to track the status of the model deployment.
-
-## Triton Model Repository
-```diff
-    <model_name>/
-    ├── config.pbtx
-    ├── requirements.txt
-    ├── labels.txt (If applicable for given model-type)
--   ├── triton_conda.yaml
-    └── 1/
-        ├── __init__.py
-        ├── inference.py
-        ├── test.py
-        └── model.py
-```
+In `your_model_dir` folder you will see essential files for deployment process
 
-A generated triton model repository looks as illustrated in the directory tree above. Any additional files such as model checkpoints and folders needed at inference time must all be placed under the `1/` directory.
+```bash
+your_model_dir
+├── clarifai_config.yaml
+├── inference.py
+├── test.py
+└── requirements.txt
+```
 
-- File Descriptions
+### Implementation
 
-| Filename | Description & Use |
-| --- | --- |
-| `config.pbtxt` | Contains the triton model configuration used by the triton inference server to guide inference requests processing. |
-| `requirements.txt` | Contains dependencies needed by a user model to successfully make predictions.|
-| `labels.txt` | Contains labels listed one per line, a model is trained to predict. The order of labels should match the model predicted class indexes. |
-| `1/inference.py` | The inference script where users write their inference code. |
-| `1/model.py` | The triton python backend model file run to serve inference requests. |
-| `1/test.py` | Contains some predefined tests in order to test inference implementation and dependencies locally. |
+Write your code in class `InferenceModel` which is an interface between your model and Clarifai server in `inference.py`, there are 2 functions you must implement:
 
-## Inference Script
+* `__init__`: load your model checkpoint once.
+* `predict`: make prediction, called everytime when you make request from API.
 
-An `inference.py` script with template code is generated during the triton model repository generation.
-**This is the script where users write their inference code**.
-This script is composed of a single class that contains a default init method and the `get_predictions()` method whose names mustn't be changed.
+For example, a complete implementation of a hf text-generation model
 
 ```python
-"""User model inference script."""
-
 import os
-from pathlib import Path
-
-from clarifai.models.model_serving.model_config import (ModelTypes, get_model_config)
+from typing import Dict, Union
+from clarifai.models.model_serving.model_config import *
 
-config = get_model_config("MODEL_TYPE_PLACEHOLDER") # Input your model type
+import torch
+from transformers import AutoTokenizer
+import transformers
 
-
-class InferenceModel:
+class InferenceModel(TextToText):
   """User model inference class."""
 
   def __init__(self) -> None:
@@ -112,52 +57,99 @@ class InferenceModel:
     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__)
-    ## sample model loading code:
-    #self.checkpoint_path: Path = os.path.join(self.base_path, "your checkpoint filename/path")
-    #self.model: Callable = <load_your_model_here from checkpoint or folder>
-
-  @config.inference.wrap_func
-  def get_predictions(self, input_data: list, **kwargs) -> list:
-    """
-    Main model inference method.
+    # current directory
+    self.base_path = os.path.dirname(__file__)
+    # where you save hf checkpoint in your working dir e.i. `your_model_dir`
+    model_path = os.path.join(self.base_path, "checkpoint")
+    self.tokenizer = AutoTokenizer.from_pretrained(model_path)
+    self.pipeline = transformers.pipeline(
+        "text-generation",
+        model=model_path,
+        torch_dtype=torch.float16,
+        device_map="auto",
+    )
+
+  def predict(self, input_data: list,
+              inference_parameters: Dict[str, Union[str, float, int]]) -> list:
+    """ Custom prediction function for `text-to-text` (also called as `text generation`) model.
 
     Args:
-    -----
-      input_data: A list of input data item to predict on.
-        Input data can be an image or text, etc depending on the model type.
-
-      **kwargs: your inference parameters.
+      input_data (List[str]): List of text
+      inference_parameters (Dict[str, Union[str, float, int]]): your inference parameters
 
     Returns:
-    --------
-      List of one of the `clarifai.models.model_serving.models.output types` or `config.inference.return_type(your_output)`. Refer to the README/docs
+      list of TextOutput
+
     """
+    output_sequences = self.pipeline(
+        input_data,
+        eos_token_id=self.tokenizer.eos_token_id,
+        **inference_parameters)
+
+    # wrap outputs in Clarifai defined output
+    return [TextOutput(each[0]) for each in output_sequences]
+```
 
-    # Delete/Comment out line below and add your inference code
-    raise NotImplementedError()
+Update dependencies in `requirements.txt`
+
+```
+clarifai
+torch=2.1.1
+transformers==4.36.2
+accelerate==0.26.1
 ```
 
-- `__init__()` used for one-time loading of inference time artifacts such as models, tokenizers, etc that are frequently called during inference to improve inference speed.
+### Test (optional)
 
-- `get_predictions()` takes a list of input data items whose type depends on the task the model solves, & returns list of predictions.
+> NOTE: Running `test` is also involved in `build` and `upload` command.
 
-`get_predictions()` should return a list of any of the output types defined under [output](docs/output.md) and the predict function MUST be decorated with a task corresponding [@config.inference.wrap_func](docs/model_types.md). The model type decorators are responsible for passing input request batches for prediction and formatting the resultant predictions into triton inference responses.
+Test and play with your implementation by executing `test.py`.
 
-Additional methods can be added to this script's `Infer` class by the user as deemed necessary for their model inference provided they are invoked inside `get_predictions()` if used at inference time.
+Install pytest
 
-## Next steps
+```bash
+$ pip install pytest
+```
 
-- [Model types docs](docs/model_types.md)
-- [Model Output types docs](docs/output.md)
-- [Dependencies](docs/dependencies.md)
-- [Examples](https://github.com/Clarifai/examples)
-- [Custom Configs](docs/custom_config.md/)
+Execute test
 
-## Prerequisites
+```bash
+$ pytest test.py
+```
+
+### Build
+
+Prepare for deployment step. Run:
+
+```bash
+$ clarifai build model
+```
 
-* For deployment to Clarifai, you need a [Clarifai account](https://clarifai.com/signup).
+You will obtain `*.clarifai` file, it's simply a zip having all nessecary files in it to get your model work on Clarifai platform.
+
+`NOTE`: you need to upload your built file to cloud storage to get direct download `url` for next step
+
+### Deployment
+
+Login to Clarifai
+
+```bash
+$ clarifai login
+Get your PAT from https://clarifai.com/settings/security and pass it here: <insert your pat here>
+```
+
+Upload
+
+```bash
+$ clarifai upload model --url <url> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
+```
 
-## Testing
+## Learn More
 
-* Please see https://github.com/Clarifai/clarifai-python/blob/master/clarifai/models/model_serving/models/test.py
+* [Detail Instruction](./docs/concepts.md)
+* [Examples](https://github.com/Clarifai/examples/tree/main/model_upload)
+* [Initialize from example](./docs/cli.md)
+* [CLI usage](./docs/cli.md)
+* [Inference parameters](./docs/inference_parameters.md)
+* [Model Types](./docs/model_types.md)
+* [Dependencies](./docs/dependencies.md)

clarifai/models/model_serving/__init__.py

@@ -10,3 +10,5 @@
 # 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 .model_config import *  # noqa
+from .repo_build import *  # noqa

clarifai/models/model_serving/cli/_utils.py

@@ -0,0 +1,53 @@
+from __future__ import annotations  # isort: skip
+import os
+import shutil
+import subprocess
+from typing import Dict, Union
+
+from ..constants import (CLARIFAI_EXAMPLES_REPO, CLARIFAI_EXAMPLES_REPO_PATH,
+                         MODEL_UPLOAD_EXAMPLE_FOLDER)
+
+
+def download_examples_repo(forced_download: bool = False):
+
+  def _pull():
+    subprocess.run(f"git clone {CLARIFAI_EXAMPLES_REPO} {CLARIFAI_EXAMPLES_REPO_PATH}")
+
+  if not os.path.isdir(CLARIFAI_EXAMPLES_REPO_PATH):
+    print(f"Download examples to {CLARIFAI_EXAMPLES_REPO_PATH}")
+    _pull()
+  else:
+    if forced_download:
+
+      def _rm_dir_readonly(func, path, _):
+        import stat
+        os.chmod(path, stat.S_IWRITE)
+        func(path)
+
+      print("Removing old examples...")
+      shutil.rmtree(CLARIFAI_EXAMPLES_REPO_PATH, onerror=_rm_dir_readonly)
+      _pull()
+
+
+def list_model_upload_examples(
+    forced_download: bool = False) -> Dict[str, tuple[str, Union[str, None]]]:
+  download_examples_repo(forced_download)
+  model_upload_folder = MODEL_UPLOAD_EXAMPLE_FOLDER
+  model_upload_path = os.path.join(CLARIFAI_EXAMPLES_REPO_PATH, model_upload_folder)
+  examples = {}
+  for model_type_ex in os.listdir(model_upload_path):
+    _folder = os.path.join(model_upload_path, model_type_ex)
+    if os.path.isdir(_folder):
+      _walk = list(os.walk(_folder))
+      if len(_walk) > 0:
+        _, model_names, _files = _walk[0]
+        readme = [item for item in _files if "readme" in item.lower()]
+        for name in model_names:
+          examples.update({
+              f"{model_type_ex}/{name}": [
+                  os.path.join(_folder, name),
+                  os.path.join(_folder, readme[0]) or None
+              ]
+          })
+
+  return examples

clarifai/models/model_serving/cli/base.py

@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+from argparse import _SubParsersAction
+
+
+class BaseClarifaiCli(ABC):
+
+  @staticmethod
+  @abstractmethod
+  def register(parser: _SubParsersAction):
+    raise NotImplementedError()
+
+  @abstractmethod
+  def run(self):
+    raise NotImplementedError()

clarifai/models/model_serving/cli/build.py

@@ -0,0 +1,79 @@
+# 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.
+"""Commandline interface for model upload utils."""
+import argparse
+import os
+import subprocess
+
+from ..repo_build import RepositoryBuilder
+from .base import BaseClarifaiCli
+
+
+class BuildCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: argparse._SubParsersAction):
+    parser = parser.add_parser("build", help="Build clarifai model for uploading")
+    sub_parser = parser.add_subparsers()
+
+    BuildModelSubCli.register(sub_parser)
+
+    parser.set_defaults(func=BuildCli)
+
+
+class BuildModelSubCli(BaseClarifaiCli):
+
+  @staticmethod
+  def register(parser: argparse._SubParsersAction):
+    sub_parser = parser.add_parser("model", help="Build Clarifai model")
+    sub_parser.add_argument(
+        "path",
+        type=str,
+        nargs='?',
+        help="Path to working directory, default is current directory",
+        default=".")
+    sub_parser.add_argument(
+        "--out-path", type=str, required=False, help="Output path of built model", default=None)
+    sub_parser.add_argument(
+        "--name",
+        type=str,
+        required=False,
+        help="Name of built file, default is `clarifai_model_id` in config if set or `model`",
+        default=None)
+    sub_parser.add_argument(
+        "--no-test",
+        action="store_true",
+        help="Trigger this flag to skip testing before uploading")
+    sub_parser.set_defaults(func=BuildModelSubCli)
+
+  def __init__(self, args: argparse.Namespace) -> None:
+    self.path = args.path
+    self.no_test = args.no_test
+    self.test_path = os.path.join(self.path, "test.py")
+    self.output_path = args.out_path or self.path
+    self.serving_backend = "triton"
+    self.name = args.name
+
+  def run(self):
+
+    # Run test before uploading
+    if not self.no_test:
+      assert os.path.exists(
+          self.test_path), FileNotFoundError(f"Could not find `test.py` in {self.path}")
+      result = subprocess.run(f"pytest -s --log-level=INFO {self.test_path}")
+      assert result.returncode == 0, "Test has failed. Please make sure no error exists in your code."
+
+    # build
+    print("Start building...")
+    RepositoryBuilder.build(
+        self.path, backend=self.serving_backend, output_dir=self.output_path, name=self.name)

clarifai/models/model_serving/cli/clarifai_clis.py

@@ -0,0 +1,33 @@
+from argparse import ArgumentParser
+
+from .build import BuildCli
+from .create import CreateCli
+from .example_cli import ExampleCli
+from .login import LoginCli
+from .upload import UploadCli
+
+
+def main():
+
+  parser = ArgumentParser("clarifai")
+  cmd_parser = parser.add_subparsers(help="Clarifai cli helpers")
+
+  UploadCli.register(cmd_parser)
+  CreateCli.register(cmd_parser)
+  LoginCli.register(cmd_parser)
+  ExampleCli.register(cmd_parser)
+  BuildCli.register(cmd_parser)
+
+  args = parser.parse_args()
+
+  if not hasattr(args, "func"):
+    parser.print_help()
+    exit(1)
+
+  # Run
+  service = args.func(args)
+  service.run()
+
+
+if __name__ == "__main__":
+  main()