clarifai 9.6.1__py3-none-any.whl → 9.6.3__py3-none-any.whl

clarifai_utils/models/model_serving/examples/visual_segmentation/segformer-b2/1/model.py

@@ -0,0 +1,60 @@
+# 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()
+
+    # 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/model_config/deploy.py

@@ -36,16 +36,40 @@ class ClarifaiFieldsMap:
     """
     Set mapping of clarifai in/output vs triton in/output
     """
+    text_input_fields = {"text": "text"}
+    image_input_fields = {"image": "image"}
+
+    embedding_output_fields = {"embeddings": "embeddings"}
+
     if self.model_type == "visual-detector":
-      self.input_fields_map = {"image": "image"}
+      self.input_fields_map = image_input_fields
       self.output_fields_map = {
           "regions[...].region_info.bounding_box": "predicted_bboxes",
           "regions[...].data.concepts[...].id": "predicted_labels",
           "regions[...].data.concepts[...].value": "predicted_scores"
       }
     elif self.model_type == "visual-classifier":
-      self.input_fields_map = {"image": "image"}
+      self.input_fields_map = image_input_fields
       self.output_fields_map = {"concepts": "softmax_predictions"}
     elif self.model_type == "text-classifier":
-      self.input_fields_map = {"text": "text"}
+      self.input_fields_map = text_input_fields
       self.output_fields_map = {"concepts": "softmax_predictions"}
+    elif self.model_type == "text-embedder":
+      self.input_fields_map = text_input_fields
+      self.output_fields_map = embedding_output_fields
+    elif self.model_type == "text-to-text":
+      self.input_fields_map = text_input_fields
+      # input and output fields are the same for text-to-text
+      self.output_fields_map = text_input_fields
+    elif self.model_type == "text-to-image":
+      self.input_fields_map = text_input_fields
+      # image output fields match image_input fields
+      self.output_fields_map = image_input_fields
+    elif self.model_type == "visual-embedder":
+      self.input_fields_map = image_input_fields
+      self.output_fields_map = embedding_output_fields
+    elif self.model_type == "visual-segmenter":
+      self.input_fields_map = image_input_fields
+      self.output_fields_map = {
+          "regions[...].region_info.mask,regions[...].data.concepts": "predicted_mask"
+      }

clarifai_utils/models/model_serving/model_config/triton_config.py

@@ -163,3 +163,33 @@ class TritonModelConfig:
       # with each value being the confidence for the respective model output.
       del pred_labels.labels
       self.output.append(pred_labels)
+
+    elif self.model_type == "text-to-text":
+      self.input.append(text_input)
+      pred_text = OutputConfig(name="text", data_type="TYPE_STRING", dims=[1], labels=False)
+      self.output.append(pred_text)
+
+    elif self.model_type == "text-embedder":
+      self.input.append(text_input)
+      embedding_vector = OutputConfig(
+          name="embeddings", data_type="TYPE_FP32", dims=[-1], labels=False)
+      self.output.append(embedding_vector)
+
+    elif self.model_type == "text-to-image":
+      self.input.append(text_input)
+      gen_image = OutputConfig(
+          name="image", data_type="TYPE_UINT8", dims=[-1, -1, 3], labels=False)
+      self.output.append(gen_image)
+
+    elif self.model_type == "visual-embedder":
+      self.input.append(image_input)
+      embedding_vector = OutputConfig(
+          name="embeddings", data_type="TYPE_FP32", dims=[-1], labels=False)
+      self.output.append(embedding_vector)
+
+    elif self.model_type == "visual-segmenter":
+      self.input.append(image_input)
+      pred_masks = OutputConfig(
+          name="predicted_mask", data_type="TYPE_INT64", dims=[-1, -1], labels=True)
+      del pred_masks.labels
+      self.output.append(pred_masks)

clarifai_utils/models/model_serving/models/model_types.py

@@ -112,3 +112,125 @@ def text_classifier(func: Callable):
     return inference_response
 
   return parse_predictions
+
+
+def text_to_text(func: Callable):
+  """
+  Text to text type output parser.
+  Convert a sequence of text into another e.g. text generation,
+  summarization or translation.
+  """
+
+  @wraps(func)
+  def parse_predictions(self, input_data: np.ndarray):
+    """
+    Format predictions and return clarifai compatible output.
+    """
+    out_text = []
+    input_data = [in_elem[0].decode() for in_elem in input_data]
+    for item in input_data:
+      preds = func(self, item)
+      out_text.append(preds.predicted_text)
+
+    out_text_tensor = pb_utils.Tensor("text", np.asarray(out_text, dtype=object))
+    inference_response = pb_utils.InferenceResponse(output_tensors=[out_text_tensor])
+
+    return inference_response
+
+  return parse_predictions
+
+
+def text_embedder(func: Callable):
+  """
+  Text embedder type output parser.
+  Generates embeddings for an input text.
+  """
+
+  @wraps(func)
+  def parse_predictions(self, input_data: np.ndarray):
+    """
+    Format predictions and return clarifai compatible output.
+    """
+    out_embeddings = []
+    input_data = [in_elem[0].decode() for in_elem in input_data]
+    for item in input_data:
+      preds = func(self, item)
+      out_embeddings.append(preds.embedding_vector)
+
+    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
+    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
+
+    return inference_response
+
+  return parse_predictions
+
+
+def visual_embedder(func: Callable):
+  """
+  Visual embedder type output parser.
+  Generates embeddings for an input image.
+  """
+
+  @wraps(func)
+  def parse_predictions(self, input_data: np.ndarray):
+    """
+    Format predictions and return clarifai compatible output.
+    """
+    out_embeddings = []
+    for item in input_data:
+      preds = func(self, item)
+      out_embeddings.append(preds.embedding_vector)
+
+    out_embed_tensor = pb_utils.Tensor("embeddings", np.asarray(out_embeddings, dtype=np.float32))
+    inference_response = pb_utils.InferenceResponse(output_tensors=[out_embed_tensor])
+
+    return inference_response
+
+  return parse_predictions
+
+
+def visual_segmenter(func: Callable):
+  """
+  Visual segmenter type output parser.
+  """
+
+  @wraps(func)
+  def parse_predictions(self, input_data: np.ndarray):
+    """
+    Format predictions and return clarifai compatible output.
+    """
+    masks = []
+    for item in input_data:
+      preds = func(self, item)
+      masks.append(preds.predicted_mask)
+
+    out_mask_tensor = pb_utils.Tensor("predicted_mask", np.asarray(masks, dtype=np.int64))
+    inference_response = pb_utils.InferenceResponse(output_tensors=[out_mask_tensor])
+
+    return inference_response
+
+  return parse_predictions
+
+
+def text_to_image(func: Callable):
+  """
+  Text to image type output parser.
+  """
+
+  @wraps(func)
+  def parse_predictions(self, input_data: np.ndarray):
+    """
+    Format predictions and return clarifai compatible output.
+    """
+    gen_images = []
+    input_data = [in_elem[0].decode() for in_elem in input_data]
+    for item in input_data:
+      preds = func(self, item)
+      gen_images.append(preds.image)
+
+    out_image_tensor = pb_utils.Tensor("image", np.asarray(gen_images, dtype=np.uint8))
+    inference_response = pb_utils.InferenceResponse(output_tensors=[out_image_tensor])
+
+    return inference_response
+
+  return parse_predictions

clarifai_utils/models/model_serving/models/output.py

@@ -59,3 +59,65 @@ class ClassifierOutput:
     """
     assert self.predicted_scores.ndim == 1, \
       f"All predictions must be 1-dimensional, Got scores-dims: {self.predicted_scores.ndim} instead."
+
+
+@dataclass
+class TextOutput:
+  """
+  Takes model text predictions
+  """
+  predicted_text: np.ndarray
+
+  def __post_init__(self):
+    """
+    Validate input upon initialization.
+    """
+    assert self.predicted_text.ndim == 1, \
+      f"All predictions must be 1-dimensional, Got text-dims: {self.predicted_text.ndim} instead."
+
+
+@dataclass
+class EmbeddingOutput:
+  """
+  Takes embedding vector returned by a model.
+  """
+  embedding_vector: np.ndarray
+
+  def __post_init__(self):
+    """
+    Validate input upon initialization.
+    """
+    assert self.embedding_vector.ndim == 1, \
+      f"Embeddings must be 1-dimensional, Got embedding-dims: {self.embedding_vector.ndim} instead."
+
+
+@dataclass
+class MasksOutput:
+  """
+  Takes image segmentation masks returned by a model.
+  """
+  predicted_mask: np.ndarray
+
+  def __post_init__(self):
+    """
+    Validate input upon initialization.
+    """
+    assert self.predicted_mask.ndim == 2, \
+      f"predicted_mask must be 2-dimensional, Got mask dims: {self.predicted_mask.ndim} instead."
+
+
+@dataclass
+class ImageOutput:
+  """
+  Takes a predicted/generated image array as returned by a model.
+  """
+  image: np.ndarray
+
+  def __post_init__(self):
+    """
+    Validate input upon initialization.
+    """
+    assert self.image.ndim == 3, \
+      f"Generated image must be 3-dimensional, Got image-dims: {self.image.ndim} instead."
+    assert self.image.shape[2] == 3, \
+      f"The image channels dimension must equal 3, Got channel dim: {self.image.shape[2]} instead."

clarifai_utils/models/model_serving/models/pb_model.py

@@ -37,7 +37,6 @@ class TritonPythonModel:
     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()

clarifai_utils/modules/style.css

@@ -203,6 +203,13 @@ code
   border-color: #d0d5dd;
   box-shadow: 0 1px 2px rgba(16,24,40,.05);
 }
+
+.stTextInput > div > div > input {
+    background-color: white;
+}
+
+
+
 div[data-testid="stFileUploader"]>section {
   border: 1px dashed #d0d5dd;
   border-radius: 8px;

clarifai_utils/runners/base.py

@@ -0,0 +1,140 @@
+# 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.
+"""Interface to Clarifai Runners API."""
+
+from typing import Type
+
+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.auth.helper import ClarifaiAuthHelper
+from clarifai.client import create_stub
+
+
+class BaseRunner:
+  """
+  Base class for remote inference runners. This should be subclassed with the run_input method
+  implemented to process each input in the request.
+
+  Then on the subclass call start() to start the run loop.
+  """
+
+  def __init__(self, auth: Type[ClarifaiAuthHelper], runner_id: str) -> None:
+    """
+    Args:
+      auth: ClarifaiAuthHelper - the auth object to use
+      runner_id: str - the id of the runner to use. Create the runner in the Clarifai API first
+
+    """
+    self.auth = auth
+    self.stub = create_stub(self.auth)
+    self.runner_id = runner_id
+
+    # Check that the runner exists.
+    response = self.stub.GetRunner(
+        service_pb2.GetRunnerRequest(
+            user_app_id=self.auth.get_user_app_id_proto(), runner_id=self.runner_id))
+    if work_response.status.code != status_code_pb2.SUCCESS:
+      raise Exception(
+          f"Error getting runner, are you use this is a valid runner id {runner_id} at the user_id/app_id {self.auth.get_user_app_id_proto().user_id}/{self.auth.get_user_app_id_proto().app_id}. Error: {response.status.description}"
+      )
+
+  def start(self):
+    """
+    Start the run loop. This will ask the Clarifai API for work, and when it gets work, it will run
+    the model on the inputs and post the results back to the Clarifai API. It will then ask for more
+    work again.
+    """
+    self._long_poll_loop()
+
+  def _run(self, request: service_pb2.PostModelOutputsRequest) -> service_pb2.MultiOutputResponse:
+    """
+    Run the model on the given request. You shouldn't need to override this method, see run_input
+    for the implementation to process each input in the request.
+
+    Args:
+      request: service_pb2.PostModelOutputsRequest - the request to run the model on
+
+    Returns:
+      service_pb2.MultiOutputResponse - the response from the model's run_input implementation.
+    """
+    outputs = []
+    # TODO: parallelize this
+    for inp in request.inputs:
+      # TODO: handle errors
+      outputs.append(self.run_input(inp))
+
+    return service_pb2.MultiOutputResponse(
+        status=status_pb2.Status(
+            code=status_code_pb2.SUCCESS,
+            description="Success",
+        ),
+        outputs=outputs,
+    )
+
+  def run_input(self, input: resources_pb2.Input) -> resources_pb2.Output:
+    """
+    Run the model on the given input in the request. This is the method you should override to
+    process each input in the request.
+
+    Args:
+      input: resources_pb2.Input - the input to run the model on
+
+    Returns:
+      resources_pb2.Output - the response from the model's run_input implementation.
+    """
+    raise NotImplementedError("run_input() not implemented")
+
+  def _long_poll_loop(self):
+    """
+    This method will long poll for work, and when it gets work, it will run the model on the inputs
+    and post the results back to the Clarifai API. It will then long poll again for more work.
+    """
+    c = 0
+    # TODO: handle more errors within this loop so it never stops.
+    # TODO: perhaps have multiple processes running this loop to handle more work.
+    while True:
+      # Long poll waiting for work.
+      print("Loop iteration: {}".format(c))
+      work_response = self.stub.ListRunnerItems(
+          service_pb2.ListRunnerItemsRequest(
+              user_app_id=self.auth.get_user_app_id_proto(), runner_id=self.runner_id))
+      if work_response.status.code == status_code_pb2.RUNNER_NEEDS_RETRY:
+        c += 1
+        continue  # immediate restart the long poll
+      if work_response.status.code != status_code_pb2.SUCCESS:
+        raise Exception("Error getting work: {}".format(work_response.status.description))
+      if len(work_response.items) == 0:
+        print("No work to do. Waiting...")
+        continue
+
+      # We have work to do. Run the model on the inputs.
+      for item in work_response.items:
+        if not item.HasField('post_model_outputs_request'):
+          raise Exception("Unexpected work item type: {}".format(item))
+        print(
+            f"Working on item: {item.id} with inputs {len(item.post_model_outputs_request.inputs)}"
+        )
+        result = self._run(item.post_model_outputs_request)
+
+        result_response = self.stub.PostRunnerItemOutputs(
+            service_pb2.PostRunnerItemOutputsRequest(
+                user_app_id=self.auth.get_user_app_id_proto(),
+                item_id=item.id,
+                runner_id=self.runner_id,
+                runner_item_outputs=[service_pb2.RunnerItemOutput(multi_output_response=result)]))
+        if result_response.status.code != status_code_pb2.SUCCESS:
+          raise Exception(
+              json_format.MessageToJson(result_response, preserving_proto_field_name=True))
+          # raise Exception("Error posting result: {}".format(result_response.status.description))

clarifai_utils/runners/example.py

@@ -0,0 +1,36 @@
+from clarifai_grpc.grpc.api import resources_pb2
+
+from clarifai.auth.helper import ClarifaiAuthHelper
+from clarifai.runners.base import BaseRunner
+
+
+class MyRunner(BaseRunner):
+  """ A custom runner that adds "Hello World" to the end of the text and replaces the domain of the
+  image URL as an example.
+  """
+
+  def run_input(self, input: resources_pb2.Input) -> resources_pb2.Output:
+    """ This is the method that will be called when the runner is run. It takes in an input and
+    returns an output.
+    """
+
+    output = resources_pb2.Output()
+
+    data = input.data
+
+    if data.text.raw != "":
+      output.data.text.raw = data.text.raw + "Hello World"
+    if data.image.url != "":
+      output.data.text.raw = data.image.url.replace("samples.clarifai.com", "newdomain.com")
+    return output
+
+
+if __name__ == '__main__':
+  # Make sure you set these env vars before running the example.
+  # CLARIFAI_PAT
+  # CLARIFAI_USER_ID
+  # CLARIFAI_APP_ID
+  auth = ClarifaiAuthHelper.from_env()
+
+  # You need to first create a runner in the Clarifai API and then use the ID here.
+  MyRunner(auth, runner_id="laptop_runner").start()