clarifai 11.4.1__py3-none-any.whl → 11.4.3__py3-none-any.whl

clarifai/runners/models/model_builder.py

@@ -14,15 +14,17 @@ import yaml
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2
 from google.protobuf import json_format
-from rich import print
-from rich.markup import escape
 
 from clarifai.client.base import BaseClient
 from clarifai.runners.models.model_class import ModelClass
 from clarifai.runners.utils.const import (
+    AMD_PYTHON_BASE_IMAGE,
+    AMD_VLLM_BASE_IMAGE,
     AVAILABLE_PYTHON_IMAGES,
     AVAILABLE_TORCH_IMAGES,
     CONCEPTS_REQUIRED_MODEL_TYPE,
+    DEFAULT_AMD_GPU_VERSION,
+    DEFAULT_AMD_TORCH_VERSION,
     DEFAULT_DOWNLOAD_CHECKPOINT_WHEN,
     DEFAULT_PYTHON_VERSION,
     DEFAULT_RUNTIME_DOWNLOAD_PATH,
@@ -43,13 +45,6 @@ dependencies = [
 ]
 
 
-def _clear_line(n: int = 1) -> None:
-    LINE_UP = '\033[1A'  # Move cursor up one line
-    LINE_CLEAR = '\x1b[2K'  # Clear the entire line
-    for _ in range(n):
-        print(LINE_UP, end=LINE_CLEAR, flush=True)
-
-
 def is_related(object_class, main_class):
     # Check if the object_class is a subclass of main_class
     if issubclass(object_class, main_class):
@@ -361,13 +356,23 @@ class ModelBuilder:
         if self.config.get("checkpoints"):
             loader_type, _, hf_token, _, _, _ = self._validate_config_checkpoints()
 
-            if loader_type == "huggingface" and hf_token:
-                is_valid_token = HuggingFaceLoader.validate_hftoken(hf_token)
-                if not is_valid_token:
+            if loader_type == "huggingface":
+                is_valid_token = hf_token and HuggingFaceLoader.validate_hftoken(hf_token)
+                if not is_valid_token and hf_token:
+                    logger.info(
+                        "Continuing without Hugging Face token for validating config in model builder."
+                    )
+
+                has_repo_access = HuggingFaceLoader.validate_hf_repo_access(
+                    repo_id=self.config.get("checkpoints", {}).get("repo_id"),
+                    token=hf_token if is_valid_token else None,
+                )
+
+                if not has_repo_access:
                     logger.error(
-                        "Invalid Hugging Face token provided in the config file, this might cause issues with downloading the restricted model checkpoints."
+                        f"Invalid Hugging Face repo access for repo {self.config.get('checkpoints').get('repo_id')}. Please check your repo and try again."
                     )
-                    logger.info("Continuing without Hugging Face token")
+                    sys.exit("Token does not have access to HuggingFace repo , exiting.")
 
         num_threads = self.config.get("num_threads")
         if num_threads or num_threads == 0:
@@ -405,11 +410,17 @@ class ModelBuilder:
         signatures = {method.name: method.signature for method in method_info.values()}
         return signatures_to_yaml(signatures)
 
-    def get_method_signatures(self):
+    def get_method_signatures(self, mocking=True):
         """
         Returns the method signatures for the model class.
+
+        Args:
+          mocking (bool): Whether to mock the model class or not. Defaults to False.
+
+        Returns:
+          list: A list of method signatures for the model class.
         """
-        model_class = self.load_model_class(mocking=True)
+        model_class = self.load_model_class(mocking=mocking)
         method_info = model_class._get_method_info()
         signatures = [method.signature for method in method_info.values()]
         return signatures
@@ -431,22 +442,42 @@ class ModelBuilder:
         return self._client
 
     @property
-    def model_url(self):
+    def model_ui_url(self):
+        url_helper = ClarifaiUrlHelper(self._client.auth_helper)
+        # Note(zeiler): the UI experience isn't the best when including version id right now.
+        # if self.model_version_id is not None:
+        #     return url_helper.clarifai_url(
+        #         self.client.user_app_id.user_id,
+        #         self.client.user_app_id.app_id,
+        #         "models",
+        #         self.model_id,
+        #         self.model_version_id,
+        #     )
+        # else:
+        return url_helper.clarifai_url(
+            self.client.user_app_id.user_id,
+            self.client.user_app_id.app_id,
+            "models",
+            self.model_id,
+        )
+
+    @property
+    def model_api_url(self):
         url_helper = ClarifaiUrlHelper(self._client.auth_helper)
         if self.model_version_id is not None:
-            return url_helper.clarifai_url(
+            return url_helper.api_url(
                 self.client.user_app_id.user_id,
                 self.client.user_app_id.app_id,
                 "models",
                 self.model_id,
+                self.model_version_id,
             )
         else:
-            return url_helper.clarifai_url(
+            return url_helper.api_url(
                 self.client.user_app_id.user_id,
                 self.client.user_app_id.app_id,
                 "models",
                 self.model_id,
-                self.model_version_id,
             )
 
     def _get_model_proto(self):
@@ -532,6 +563,30 @@ class ModelBuilder:
                 dependencies_version[dependency] = version if version else None
         return dependencies_version
 
+    def _is_amd(self):
+        """
+        Check if the model is AMD or not.
+        """
+        is_amd_gpu = False
+        is_nvidia_gpu = False
+        if "inference_compute_info" in self.config:
+            inference_compute_info = self.config.get('inference_compute_info')
+            if 'accelerator_type' in inference_compute_info:
+                for accelerator in inference_compute_info['accelerator_type']:
+                    if 'amd' in accelerator.lower():
+                        is_amd_gpu = True
+                    elif 'nvidia' in accelerator.lower():
+                        is_nvidia_gpu = True
+        if is_amd_gpu and is_nvidia_gpu:
+            raise Exception(
+                "Both AMD and NVIDIA GPUs are specified in the config file, please use only one type of GPU."
+            )
+        if is_amd_gpu:
+            logger.info("Using AMD base image to build the Docker image and upload the model")
+        elif is_nvidia_gpu:
+            logger.info("Using NVIDIA base image to build the Docker image and upload the model")
+        return is_amd_gpu
+
     def create_dockerfile(self):
         dockerfile_template = os.path.join(
             os.path.dirname(os.path.dirname(__file__)),
@@ -562,30 +617,85 @@ class ModelBuilder:
             )
             python_version = DEFAULT_PYTHON_VERSION
 
-        # This is always the final image used for runtime.
-        final_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
-        downloader_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
-
         # Parse the requirements.txt file to determine the base image
         dependencies = self._parse_requirements()
-        if 'torch' in dependencies and dependencies['torch']:
-            torch_version = dependencies['torch']
-
-            # Sort in reverse so that newer cuda versions come first and are preferred.
-            for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
-                if torch_version in image and f'py{python_version}' in image:
-                    # like cu124, rocm6.3, etc.
-                    gpu_version = image.split('-')[-1]
-                    final_image = TORCH_BASE_IMAGE.format(
-                        torch_version=torch_version,
-                        python_version=python_version,
-                        gpu_version=gpu_version,
+
+        is_amd_gpu = self._is_amd()
+        if is_amd_gpu:
+            final_image = AMD_PYTHON_BASE_IMAGE.format(python_version=python_version)
+            downloader_image = AMD_PYTHON_BASE_IMAGE.format(python_version=python_version)
+            if 'vllm' in dependencies:
+                if python_version != DEFAULT_PYTHON_VERSION:
+                    raise Exception(
+                        f"vLLM is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
+                    )
+                torch_version = dependencies.get('torch', None)
+                if 'torch' in dependencies:
+                    if python_version != DEFAULT_PYTHON_VERSION:
+                        raise Exception(
+                            f"torch is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
+                        )
+                    if not torch_version:
+                        logger.info(
+                            f"torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
+                        )
+                        torch_version = DEFAULT_AMD_TORCH_VERSION
+                    if torch_version not in [DEFAULT_AMD_TORCH_VERSION]:
+                        raise Exception(
+                            f"torch version {torch_version} not supported, please use one of the following versions: {DEFAULT_AMD_TORCH_VERSION} in your requirements.txt"
+                        )
+                python_version = DEFAULT_PYTHON_VERSION
+                gpu_version = DEFAULT_AMD_GPU_VERSION
+                final_image = AMD_VLLM_BASE_IMAGE.format(
+                    torch_version=torch_version,
+                    python_version=python_version,
+                    gpu_version=gpu_version,
+                )
+                logger.info("Using vLLM base image to build the Docker image")
+            elif 'torch' in dependencies:
+                torch_version = dependencies['torch']
+                if python_version != DEFAULT_PYTHON_VERSION:
+                    raise Exception(
+                        f"torch is not supported with Python version {python_version}, please use Python version {DEFAULT_PYTHON_VERSION} in your config.yaml"
                     )
+                if not torch_version:
                     logger.info(
-                        f"Using Torch version {torch_version} base image to build the Docker image"
+                        f"torch version not found in requirements.txt, using the default version {DEFAULT_AMD_TORCH_VERSION}"
                     )
-                    break
-
+                    torch_version = DEFAULT_AMD_TORCH_VERSION
+                if torch_version not in [DEFAULT_AMD_TORCH_VERSION]:
+                    raise Exception(
+                        f"torch version {torch_version} not supported, please use one of the following versions: {DEFAULT_AMD_TORCH_VERSION} in your requirements.txt"
+                    )
+                python_version = DEFAULT_PYTHON_VERSION
+                gpu_version = DEFAULT_AMD_GPU_VERSION
+                final_image = TORCH_BASE_IMAGE.format(
+                    torch_version=torch_version,
+                    python_version=python_version,
+                    gpu_version=gpu_version,
+                )
+                logger.info(
+                    f"Using Torch version {torch_version} base image to build the Docker image"
+                )
+        else:
+            final_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
+            downloader_image = PYTHON_BASE_IMAGE.format(python_version=python_version)
+            if 'torch' in dependencies and dependencies['torch']:
+                torch_version = dependencies['torch']
+                # Sort in reverse so that newer cuda versions come first and are preferred.
+                for image in sorted(AVAILABLE_TORCH_IMAGES, reverse=True):
+                    if torch_version in image and f'py{python_version}' in image:
+                        # like cu124, rocm6.3, etc.
+                        gpu_version = image.split('-')[-1]
+                        final_image = TORCH_BASE_IMAGE.format(
+                            torch_version=torch_version,
+                            python_version=python_version,
+                            gpu_version=gpu_version,
+                        )
+                        logger.info(
+                            f"Using Torch version {torch_version} base image to build the Docker image"
+                        )
+                        break
         if 'clarifai' not in dependencies:
             raise Exception(
                 f"clarifai not found in requirements.txt, please add clarifai to the requirements.txt file with a fixed version. Current version is clarifai=={CLIENT_VERSION}"
@@ -835,7 +945,6 @@ class ModelBuilder:
                 percent_completed = response.status.percent_completed
             details = response.status.details
 
-            _clear_line()
             print(
                 f"Status: {response.status.description}, Progress: {percent_completed}% - {details} ",
                 f"request_id: {response.status.req_id}",
@@ -847,9 +956,26 @@ class ModelBuilder:
             return
         self.model_version_id = response.model_version_id
         logger.info(f"Created Model Version ID: {self.model_version_id}")
-        logger.info(f"Full url to that version is: {self.model_url}")
+        logger.info(f"Full url to that version is: {self.model_ui_url}")
         try:
-            self.monitor_model_build()
+            is_uploaded = self.monitor_model_build()
+            if is_uploaded:
+                # python code to run the model.
+                from clarifai.runners.utils import code_script
+
+                method_signatures = self.get_method_signatures()
+                snippet = code_script.generate_client_script(
+                    method_signatures,
+                    user_id=self.client.user_app_id.user_id,
+                    app_id=self.client.user_app_id.app_id,
+                    model_id=self.model_proto.id,
+                )
+                logger.info("""\n
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+# Here is a code snippet to use this model:
+XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+                """)
+                logger.info(snippet)
         finally:
             if os.path.exists(self.tar_file):
                 logger.debug(f"Cleaning up upload file: {self.tar_file}")
@@ -933,7 +1059,12 @@ class ModelBuilder:
             for log_entry in logs.log_entries:
                 if log_entry.url not in seen_logs:
                     seen_logs.add(log_entry.url)
-                    logger.info(f"{escape(log_entry.message.strip())}")
+                    log_entry_msg = re.sub(
+                        r"(\\*)(\[[a-z#/@][^[]*?])",
+                        lambda m: f"{m.group(1)}{m.group(1)}\\{m.group(2)}",
+                        log_entry.message.strip(),
+                    )
+                    logger.info(log_entry_msg)
             if status_code == status_code_pb2.MODEL_BUILDING:
                 print(
                     f"Model is building... (elapsed {time.time() - st:.1f}s)", end='\r', flush=True
@@ -945,7 +1076,7 @@ class ModelBuilder:
                 logger.info("Model build complete!")
                 logger.info(f"Build time elapsed {time.time() - st:.1f}s)")
                 logger.info(
-                    f"Check out the model at {self.model_url} version: {self.model_version_id}"
+                    f"Check out the model at {self.model_ui_url} version: {self.model_version_id}"
                 )
                 return True
             else:
@@ -970,10 +1101,12 @@ def upload_model(folder, stage, skip_dockerfile):
     exists = builder.check_model_exists()
     if exists:
         logger.info(
-            f"Model already exists at {builder.model_url}, this upload will create a new version for it."
+            f"Model already exists at {builder.model_ui_url}, this upload will create a new version for it."
         )
     else:
-        logger.info(f"New model will be created at {builder.model_url} with it's first version.")
+        logger.info(
+            f"New model will be created at {builder.model_ui_url} with it's first version."
+        )
 
     input("Press Enter to continue...")
     builder.upload_model_version()

clarifai/runners/models/model_class.py

@@ -9,7 +9,6 @@ from typing import Any, Dict, Iterator, List
 
 from clarifai_grpc.grpc.api import resources_pb2, service_pb2
 from clarifai_grpc.grpc.api.status import status_code_pb2, status_pb2
-from google.protobuf import json_format
 
 from clarifai.runners.utils import data_types
 from clarifai.runners.utils.data_utils import DataConverter
@@ -100,7 +99,6 @@ class ModelClass(ABC):
         try:
             # TODO add method name field to proto
             method_name = 'predict'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             if (
@@ -124,7 +122,7 @@ class ModelClass(ABC):
                     input.data.CopyFrom(new_data)
             # convert inputs to python types
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             if len(inputs) == 1:
                 inputs = inputs[0]
@@ -163,7 +161,6 @@ class ModelClass(ABC):
     ) -> Iterator[service_pb2.MultiOutputResponse]:
         try:
             method_name = 'generate'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
@@ -180,7 +177,7 @@ class ModelClass(ABC):
                     )
                     input.data.CopyFrom(new_data)
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             if len(inputs) == 1:
                 inputs = inputs[0]
@@ -226,7 +223,6 @@ class ModelClass(ABC):
             assert len(request.inputs) == 1, "Streaming requires exactly one input"
 
             method_name = 'stream'
-            inference_params = get_inference_params(request)
             if len(request.inputs) > 0 and '_method_name' in request.inputs[0].data.metadata:
                 method_name = request.inputs[0].data.metadata['_method_name']
             method = getattr(self, method_name)
@@ -251,7 +247,7 @@ class ModelClass(ABC):
                     input.data.CopyFrom(new_data)
             # convert all inputs for the first request, including the first stream value
             inputs = self._convert_input_protos_to_python(
-                request.inputs, inference_params, signature.input_fields, python_param_types
+                request.inputs, signature.input_fields, python_param_types
             )
             kwargs = inputs[0]
 
@@ -264,7 +260,7 @@ class ModelClass(ABC):
                 # subsequent streaming items contain only the streaming input
                 for request in request_iterator:
                     item = self._convert_input_protos_to_python(
-                        request.inputs, inference_params, [stream_sig], python_param_types
+                        request.inputs, [stream_sig], python_param_types
                     )
                     item = item[0][stream_argname]
                     yield item
@@ -297,13 +293,12 @@ class ModelClass(ABC):
     def _convert_input_protos_to_python(
         self,
         inputs: List[resources_pb2.Input],
-        inference_params: dict,
         variables_signature: List[resources_pb2.ModelTypeField],
         python_param_types,
     ) -> List[Dict[str, Any]]:
         result = []
         for input in inputs:
-            kwargs = deserialize(input.data, variables_signature, inference_params)
+            kwargs = deserialize(input.data, variables_signature)
             # dynamic cast to annotated types
             for k, v in kwargs.items():
                 if k not in python_param_types:
@@ -374,18 +369,6 @@ class ModelClass(ABC):
         return method_info
 
 
-# Helper function to get the inference params
-def get_inference_params(request) -> dict:
-    """Get the inference params from the request."""
-    inference_params = {}
-    if request.model.model_version.id != "":
-        output_info = request.model.model_version.output_info
-        output_info = json_format.MessageToDict(output_info, preserving_proto_field_name=True)
-        if "params" in output_info:
-            inference_params = output_info["params"]
-    return inference_params
-
-
 class _MethodInfo:
     def __init__(self, method):
         self.name = method.__name__

clarifai/runners/models/model_run_locally.py

@@ -442,10 +442,6 @@ def main(
     manager = ModelRunLocally(model_path)
     # get whatever stage is in config.yaml to force download now
     # also always write to where upload/build wants to, not the /tmp folder that runtime stage uses
-    _, _, _, when, _, _ = manager.builder._validate_config_checkpoints()
-    manager.builder.download_checkpoints(
-        stage=when, checkpoint_path_override=manager.builder.checkpoint_path
-    )
     if inside_container:
         if not manager.is_docker_installed():
             sys.exit(1)

clarifai/runners/models/visual_classifier_class.py

@@ -0,0 +1,75 @@
+import os
+import tempfile
+from io import BytesIO
+from typing import Dict, Iterator, List
+
+import cv2
+import torch
+from PIL import Image as PILImage
+
+from clarifai.runners.models.model_class import ModelClass
+from clarifai.runners.utils.data_types import Concept, Frame, Image
+from clarifai.utils.logging import logger
+
+
+class VisualClassifierClass(ModelClass):
+    """Base class for visual classification models supporting image and video processing."""
+
+    @staticmethod
+    def preprocess_image(image_bytes: bytes) -> PILImage:
+        """Convert image bytes to PIL Image."""
+        return PILImage.open(BytesIO(image_bytes)).convert("RGB")
+
+    @staticmethod
+    def video_to_frames(video_bytes: bytes) -> Iterator[Frame]:
+        """Convert video bytes to frames.
+
+        Args:
+            video_bytes: Raw video data in bytes
+
+        Yields:
+            Frame with JPEG encoded frame data as bytes and timestamp in milliseconds
+        """
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video_file:
+            temp_video_file.write(video_bytes)
+            temp_video_path = temp_video_file.name
+            logger.debug(f"temp_video_path: {temp_video_path}")
+
+            video = cv2.VideoCapture(temp_video_path)
+            logger.debug(f"video opened: {video.isOpened()}")
+
+            while video.isOpened():
+                ret, frame = video.read()
+                if not ret:
+                    break
+                # Get frame timestamp in milliseconds
+                timestamp_ms = video.get(cv2.CAP_PROP_POS_MSEC)
+                frame_bytes = cv2.imencode('.jpg', frame)[1].tobytes()
+                yield Frame(image=Image(bytes=frame_bytes), time=timestamp_ms)
+
+            video.release()
+            os.unlink(temp_video_path)
+
+    @staticmethod
+    def process_concepts(
+        logits: torch.Tensor, threshold: float, model_labels: Dict[int, str]
+    ) -> List[List[Concept]]:
+        """Convert model logits into a structured format of concepts.
+
+        Args:
+            logits: Model output logits as a tensor (batch_size x num_classes)
+            model_labels: Dictionary mapping label indices to label names
+
+        Returns:
+            List of lists containing Concept objects for each input in the batch
+        """
+        outputs = []
+        for logit in logits:
+            probs = torch.softmax(logit, dim=-1)
+            sorted_indices = torch.argsort(probs, dim=-1, descending=True)
+            output_concepts = []
+            for idx in sorted_indices:
+                concept = Concept(name=model_labels[idx.item()], value=probs[idx].item())
+                output_concepts.append(concept)
+            outputs.append(output_concepts)
+        return outputs

clarifai/runners/models/visual_detector_class.py

@@ -0,0 +1,79 @@
+import os
+import tempfile
+from io import BytesIO
+from typing import Dict, Iterator, List
+
+import cv2
+import torch
+from PIL import Image as PILImage
+
+from clarifai.runners.models.model_class import ModelClass
+from clarifai.runners.utils.data_types import Concept, Frame, Image, Region
+from clarifai.utils.logging import logger
+
+
+class VisualDetectorClass(ModelClass):
+    """Base class for visual detection models supporting image and video processing."""
+
+    @staticmethod
+    def preprocess_image(image_bytes: bytes) -> PILImage:
+        """Convert image bytes to PIL Image."""
+        return PILImage.open(BytesIO(image_bytes)).convert("RGB")
+
+    @staticmethod
+    def video_to_frames(video_bytes: bytes) -> Iterator[Frame]:
+        """Convert video bytes to frames.
+
+        Args:
+            video_bytes: Raw video data in bytes
+
+        Yields:
+            Frame with JPEG encoded frame data as bytes and timestamp in milliseconds
+        """
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".mp4") as temp_video_file:
+            temp_video_file.write(video_bytes)
+            temp_video_path = temp_video_file.name
+            logger.debug(f"temp_video_path: {temp_video_path}")
+
+            video = cv2.VideoCapture(temp_video_path)
+            logger.debug(f"video opened: {video.isOpened()}")
+
+            while video.isOpened():
+                ret, frame = video.read()
+                if not ret:
+                    break
+                # Get frame timestamp in milliseconds
+                timestamp_ms = video.get(cv2.CAP_PROP_POS_MSEC)
+                frame_bytes = cv2.imencode('.jpg', frame)[1].tobytes()
+                yield Frame(image=Image(bytes=frame_bytes), time=timestamp_ms)
+
+            video.release()
+            os.unlink(temp_video_path)
+
+    @staticmethod
+    def process_detections(
+        results: List[Dict[str, torch.Tensor]], threshold: float, model_labels: Dict[int, str]
+    ) -> List[List[Region]]:
+        """Convert model outputs into a structured format of detections.
+
+        Args:
+            results: Raw detection results from model
+            threshold: Confidence threshold for detections
+            model_labels: Dictionary mapping label indices to names
+
+        Returns:
+            List of lists containing Region objects for each detection
+        """
+        outputs = []
+        for result in results:
+            detections = []
+            for score, label_idx, box in zip(result["scores"], result["labels"], result["boxes"]):
+                if score > threshold:
+                    label = model_labels[label_idx.item()]
+                    detections.append(
+                        Region(
+                            box=box.tolist(), concepts=[Concept(name=label, value=score.item())]
+                        )
+                    )
+            outputs.append(detections)
+        return outputs