clarifai 11.3.0__py3-none-any.whl → 11.3.0rc2__py3-none-any.whl

clarifai/runners/models/base_typed_model.py

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

clarifai/runners/models/model_builder.py

@@ -43,6 +43,19 @@ def _clear_line(n: int = 1) -> None:
     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):
+    return True
+
+  # Check if the object_class is a subclass of any of the parent classes of main_class
+  parent_classes = object_class.__bases__
+  for parent in parent_classes:
+    if main_class in parent.__bases__:
+      return True
+  return False
+
+
 class ModelBuilder:
   DEFAULT_CHECKPOINT_SIZE = 50 * 1024**3  # 50 GiB
 
@@ -125,7 +138,7 @@ class ModelBuilder:
     # Find all classes in the model.py file that are subclasses of ModelClass
     classes = [
         cls for _, cls in inspect.getmembers(module, inspect.isclass)
-        if issubclass(cls, ModelClass) and cls.__module__ == module.__name__
+        if is_related(cls, ModelClass) and cls.__module__ == module.__name__
     ]
     #  Ensure there is exactly one subclass of BaseRunner in the model.py file
     if len(classes) != 1:

clarifai/runners/models/model_class_refract.py

@@ -0,0 +1,80 @@
+import inspect
+from abc import ABC, abstractmethod
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Dict, Iterator, List, get_type_hints
+
+from clarifai_grpc.grpc.api import resources_pb2, service_pb2
+
+from clarifai.runners.utils.data_handler import Output, kwargs_to_proto, proto_to_kwargs
+
+
+class ModelClass(ABC):
+
+  @abstractmethod
+  def load_model(self):
+    raise NotImplementedError("load_model() not implemented")
+
+  @abstractmethod
+  def predict(self, *args, **kwargs) -> Output:
+    raise NotImplementedError("predict() not implemented")
+
+  @abstractmethod
+  def generate(self, *args, **kwargs) -> Iterator[Output]:
+    raise NotImplementedError("generate() not implemented")
+
+  @abstractmethod
+  def stream(self, *args, **kwargs) -> Iterator[Output]:
+    raise NotImplementedError("stream() not implemented")
+
+  def batch_predict(self, inputs: List[Dict[str, Any]]) -> List[Output]:
+    with ThreadPoolExecutor() as executor:
+      return list(executor.map(lambda x: self.predict(**x), inputs))
+
+  def _process_request(self, request, process_func, is_stream=False):
+    inputs = self._convert_proto_to_python(request.inputs)
+    if len(inputs) == 1:
+      result = process_func(**inputs[0])
+      if is_stream:
+        return (self._convert_output_to_proto(output) for output in result)
+      else:
+        return [self._convert_output_to_proto(result)]
+    else:
+      results = self.batch_predict(inputs) if not is_stream else []
+      return [self._convert_output_to_proto(output) for output in results]
+
+  def predict_wrapper(
+      self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    outputs = self._process_request(request, self.predict)
+    return service_pb2.MultiOutputResponse(outputs=outputs)
+
+  def generate_wrapper(self, request: service_pb2.PostModelOutputsRequest
+                      ) -> Iterator[service_pb2.MultiOutputResponse]:
+    outputs = self._process_request(request, self.generate, is_stream=True)
+    for output in outputs:
+      yield service_pb2.MultiOutputResponse(outputs=[output])
+
+  def stream_wrapper(self, requests: Iterator[service_pb2.PostModelOutputsRequest]
+                    ) -> Iterator[service_pb2.MultiOutputResponse]:
+    for request in requests:
+      outputs = self._process_request(request, self.stream, is_stream=True)
+      yield service_pb2.MultiOutputResponse(outputs=outputs)
+
+  def _convert_proto_to_python(self, inputs: List[resources_pb2.Input]) -> List[Dict[str, Any]]:
+    get_type_hints(self.predict)
+    required_params = [
+        name for name, param in inspect.signature(self.predict).parameters.items()
+        if param.default == inspect.Parameter.empty
+    ]
+    kwargs_list = []
+    for input_proto in inputs:
+      kwargs = proto_to_kwargs(input_proto.data)
+      missing = [name for name in required_params if name not in kwargs]
+      if missing:
+        raise ValueError(f"Missing required parameters: {missing}")
+      kwargs_list.append(kwargs)
+    return kwargs_list
+
+  def _convert_output_to_proto(self, output: Any) -> resources_pb2.Output:
+    if isinstance(output, Output):
+      return output.to_proto()
+    return kwargs_to_proto(**output).outputs.add()