clarifai 10.11.1__py3-none-any.whl → 10.11.2rc2__py3-none-any.whl

clarifai/__init__.py

@@ -1 +1 @@
-__version__ = "10.11.1"
+__version__ = "10.11.2rc2"

clarifai/client/dataset.py

@@ -281,9 +281,9 @@ class Dataset(Lister, BaseClient):
       failed_input_ids = list(set(failed_input_ids) - set(duplicate_input_ids))
       duplicate_details = [[
           input_ids[id], id, "Input has a duplicate ID.",
-          dataset_obj.data_generator[input_ids[id]].image_path,
-          dataset_obj.data_generator[input_ids[id]].labels,
-          dataset_obj.data_generator[input_ids[id]].metadata
+          getattr(dataset_obj.data_generator[input_ids[id]], 'image_path', None),
+          getattr(dataset_obj.data_generator[input_ids[id]], 'labels', None),
+          getattr(dataset_obj.data_generator[input_ids[id]], 'metadata', None)
       ] for id in duplicate_input_ids]
       duplicate_table = tabulate(
           duplicate_details,
@@ -386,7 +386,7 @@ class Dataset(Lister, BaseClient):
           tablefmt="grid")
       timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
       self.logger.warning(
-          f"{timestamp}\nFailed to upload {len(failed_retrying_inputs)} inputs in current batch {batch_no}:\n{failed_table}\n\n"
+          f"{timestamp}\nFailed to upload {len(failed_retrying_inputs)} inputs in current batch {batch_no} due to {retry_response}:\n{failed_table}\n\n"
       )
 
   def _data_upload(self,

clarifai/client/model.py

@@ -503,6 +503,7 @@ class Model(Lister, BaseClient):
                           compute_cluster_id: str = None,
                           nodepool_id: str = None,
                           deployment_id: str = None,
+                          user_id: str = None,
                           inference_params: Dict = {},
                           output_config: Dict = {}):
     """Predicts the model based on the given filepath.
@@ -534,7 +535,7 @@ class Model(Lister, BaseClient):
       file_bytes = f.read()
 
     return self.predict_by_bytes(file_bytes, input_type, compute_cluster_id, nodepool_id,
-                                 deployment_id, inference_params, output_config)
+                                 deployment_id, user_id, inference_params, output_config)
 
   def predict_by_bytes(self,
                        input_bytes: bytes,
@@ -542,6 +543,7 @@ class Model(Lister, BaseClient):
                        compute_cluster_id: str = None,
                        nodepool_id: str = None,
                        deployment_id: str = None,
+                       user_id: str = None,
                        inference_params: Dict = {},
                        output_config: Dict = {}):
     """Predicts the model based on the given bytes.
@@ -581,11 +583,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.predict(
         inputs=[input_proto],
@@ -599,6 +613,7 @@ class Model(Lister, BaseClient):
                      compute_cluster_id: str = None,
                      nodepool_id: str = None,
                      deployment_id: str = None,
+                     user_id: str = None,
                      inference_params: Dict = {},
                      output_config: Dict = {}):
     """Predicts the model based on the given URL.
@@ -639,11 +654,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.predict(
         inputs=[input_proto],
@@ -712,6 +739,7 @@ class Model(Lister, BaseClient):
                            compute_cluster_id: str = None,
                            nodepool_id: str = None,
                            deployment_id: str = None,
+                           user_id: str = None,
                            inference_params: Dict = {},
                            output_config: Dict = {}):
     """Generate the stream output on model based on the given filepath.
@@ -748,6 +776,7 @@ class Model(Lister, BaseClient):
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,
         deployment_id=deployment_id,
+        user_id=user_id,
         inference_params=inference_params,
         output_config=output_config)
 
@@ -757,6 +786,7 @@ class Model(Lister, BaseClient):
                         compute_cluster_id: str = None,
                         nodepool_id: str = None,
                         deployment_id: str = None,
+                        user_id: str = None,
                         inference_params: Dict = {},
                         output_config: Dict = {}):
     """Generate the stream output on model based on the given bytes.
@@ -798,11 +828,21 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.generate(
         inputs=[input_proto],
@@ -816,6 +856,7 @@ class Model(Lister, BaseClient):
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
+                      user_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Generate the stream output on model based on the given URL.
@@ -857,11 +898,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.generate(
         inputs=[input_proto],
@@ -930,6 +983,7 @@ class Model(Lister, BaseClient):
                          compute_cluster_id: str = None,
                          nodepool_id: str = None,
                          deployment_id: str = None,
+                         user_id: str = None,
                          inference_params: Dict = {},
                          output_config: Dict = {}):
     """Stream the model output based on the given filepath.
@@ -964,6 +1018,7 @@ class Model(Lister, BaseClient):
         compute_cluster_id=compute_cluster_id,
         nodepool_id=nodepool_id,
         deployment_id=deployment_id,
+        user_id=user_id,
         inference_params=inference_params,
         output_config=output_config)
 
@@ -973,6 +1028,7 @@ class Model(Lister, BaseClient):
                       compute_cluster_id: str = None,
                       nodepool_id: str = None,
                       deployment_id: str = None,
+                      user_id: str = None,
                       inference_params: Dict = {},
                       output_config: Dict = {}):
     """Stream the model output based on the given bytes.
@@ -1016,11 +1072,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.stream(
         inputs=input_generator(),
@@ -1034,6 +1102,7 @@ class Model(Lister, BaseClient):
                     compute_cluster_id: str = None,
                     nodepool_id: str = None,
                     deployment_id: str = None,
+                    user_id: str = None,
                     inference_params: Dict = {},
                     output_config: Dict = {}):
     """Stream the model output based on the given URL.
@@ -1075,11 +1144,23 @@ class Model(Lister, BaseClient):
 
     runner_selector = None
     if deployment_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with deployment ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Deployment.get_runner_selector(
-          user_id=self.user_id, deployment_id=deployment_id)
+          user_id=user_id, deployment_id=deployment_id)
     elif compute_cluster_id and nodepool_id:
+      if not user_id and not os.environ.get('CLARIFAI_USER_ID'):
+        raise UserError(
+            "User ID is required for model prediction with compute cluster ID and nodepool ID, please provide user_id in the method call."
+        )
+      if not user_id:
+        user_id = os.environ.get('CLARIFAI_USER_ID')
       runner_selector = Nodepool.get_runner_selector(
-          user_id=self.user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
+          user_id=user_id, compute_cluster_id=compute_cluster_id, nodepool_id=nodepool_id)
 
     return self.stream(
         inputs=input_generator(),

clarifai/datasets/upload/features.py

@@ -7,7 +7,7 @@ from typing import List, Optional, Union
 class TextFeatures:
   """Text classification datasets preprocessing output features."""
   text: str
-  labels: List[Union[str, int]]  # List[str or int] to cater for multi-class tasks
+  labels: List[Union[str, int]] = None  # List[str or int] to cater for multi-class tasks
   id: Optional[int] = None  # text_id
   metadata: Optional[dict] = None
   label_ids: Optional[List[str]] = None

clarifai/datasets/upload/multimodal.py

@@ -34,7 +34,8 @@ class MultiModalDataset(ClarifaiDataset):
       metadata = Struct()
       image_bytes = data_item.image_bytes
       text = data_item.text
-      labels = data_item.labels if isinstance(data_item.labels, list) else [data_item.labels]
+      labels = data_item.labels if ((data_item.labels is None) or
+                                    isinstance(data_item.labels, list)) else [data_item.labels]
       input_id = f"{self.dataset_id}-{id}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:
         metadata.update(data_item.metadata)

clarifai/datasets/upload/text.py

@@ -34,8 +34,9 @@ class TextClassificationDataset(ClarifaiDataset):
       data_item = self.data_generator[id]
       metadata = Struct()
       text = data_item.text
-      labels = data_item.labels if isinstance(data_item.labels,
-                                              list) else [data_item.labels]  # clarifai concept
+      labels = data_item.labels if ((data_item.labels is None) or
+                                    isinstance(data_item.labels, list)) else [data_item.labels
+                                                                             ]  # clarifai concept
       label_ids = data_item.label_ids
       input_id = f"{self.dataset_id}-{get_uuid(8)}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
       if data_item.metadata is not None:

clarifai/models/model_serving/README.md

@@ -0,0 +1,158 @@
+# Clarifai Model Serving
+
+## Overview
+
+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 convenient command-line interface (CLI)
+* Easy implementation and testing in Python
+* No need for MLops expertise.
+
+## 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
+$ clarifai create model --type text-to-text --working-dir your_model_dir
+$ cd your_model_dir
+```
+
+In `your_model_dir` folder you will see essential files for deployment process
+
+```bash
+your_model_dir
+├── clarifai_config.yaml
+├── inference.py
+├── test.py
+└── requirements.txt
+```
+
+### Implementation
+
+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:
+
+* `__init__`: load your model checkpoint once.
+* `predict`: make prediction, called everytime when you make request from API.
+
+For example, a complete implementation of a hf text-generation model
+
+```python
+import os
+from typing import Dict, Union
+from clarifai.models.model_serving.model_config import *
+
+import torch
+from transformers import AutoTokenizer
+import transformers
+
+class InferenceModel(TextToText):
+  """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 = 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 (List[str]): List of text
+      inference_parameters (Dict[str, Union[str, float, int]]): your inference parameters
+
+    Returns:
+      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]
+```
+
+Update dependencies in `requirements.txt`
+
+```
+clarifai
+torch=2.1.1
+transformers==4.36.2
+accelerate==0.26.1
+```
+
+### Test (optional)
+
+> NOTE: Running `test` is also involved in `build` and `upload` command.
+
+Test and play with your implementation by executing `test.py`.
+
+Install pytest
+
+```bash
+$ pip install pytest
+```
+
+Execute test
+
+```bash
+$ pytest test.py
+```
+
+### Build
+
+Prepare for deployment step. Run:
+
+```bash
+$ clarifai build model
+```
+
+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
+# upload built file directly
+$ clarifai upload model <your-working-dir> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
+# or using direct download url of cloud storage
+$ clarifai upload model --url <url> --user-app <your_user_id>/<your_app_id> --id <your_model_id>
+```
+
+## Learn More
+
+* [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

@@ -0,0 +1,14 @@
+# 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 .model_config import *  # noqa
+from .repo_build import *  # noqa

clarifai/models/model_serving/cli/__init__.py

@@ -0,0 +1,12 @@
+# 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.