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

clarifai/auth/helper.py

@@ -131,7 +131,7 @@ class ClarifaiAuthHelper:
 
     # Then add in the query params.
     try:
-      auth = auth.add_streamlit_query_params(query_params)
+      auth.add_streamlit_query_params(st.experimental_get_query_params())
     except Exception as e:
       st.error(e)
       st.stop()
@@ -165,7 +165,7 @@ class ClarifaiAuthHelper:
     auth = ClarifaiAuthHelper("", "", "", "", validate=False)
 
     # Then add in the query params.
-    auth = auth.add_streamlit_query_params(query_params)
+    auth.add_streamlit_query_params(query_params)
 
     # Then validate.
     auth.validate()
@@ -238,7 +238,7 @@ Additionally, these optional params are supported:
 """
     user_id = os.environ.get("CLARIFAI_USER_ID", "")
     app_id = os.environ.get("CLARIFAI_APP_ID", "")
-    token = os.environ("CLARIFAI_SESSION_TOKEN", "")
+    token = os.environ.get("CLARIFAI_SESSION_TOKEN", "")
     pat = os.environ.get("CLARIFAI_PAT", "")
     base = os.environ.get("CLARIFAI_API_BASE", DEFAULT_BASE)
     ui = os.environ.get("CLARIFAI_UI", DEFAULT_UI)

clarifai/models/model_serving/constants.py

@@ -1,6 +1,5 @@
 # Clarifai model types
 MODEL_TYPES = [
-    "visual-detector",
-    "visual-classifier",
-    "text-classifier",
+    "visual-detector", "visual-classifier", "text-classifier", "text-to-text", "text-embedder",
+    "text-to-image", "visual-embedder", "visual-segmenter"
 ]

clarifai/models/model_serving/examples/text_to_text/bart-summarize/1/inference.py

@@ -0,0 +1,47 @@
+# This file contains boilerplate code to allow users write their model
+# inference code that will then interact with the Triton Inference Server
+# Python backend to serve end user requests.
+# The module name, module path, class name & get_predictions() method names MUST be maintained as is
+# but other methods may be added within the class as deemed fit provided
+# they are invoked within the main get_predictions() inference method
+# if they play a role in any step of model inference
+"""User model inference script."""
+
+import os
+from pathlib import Path
+import numpy as np
+from transformers import pipeline
+
+from clarifai.models.model_serving.models.model_types import text_to_text
+from clarifai.models.model_serving.models.output import TextOutput
+
+
+class InferenceModel:
+  """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.
+    """
+    self.base_path: Path = os.path.dirname(__file__)
+    self.huggingface_model_path = os.path.join(self.base_path, "bart-large-summarizer")
+    self.pipeline = pipeline("summarization", model=self.huggingface_model_path)
+
+  @text_to_text
+  def get_predictions(self, input_data):
+    """
+    Generates summaries of input text.
+
+    Args:
+    -----
+      input_data: A single input data item to predict on.
+        Input data can be an image or text, etc depending on the model type.
+
+    Returns:
+    --------
+      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
+    """
+    summary = self.pipeline(input_data, max_length=50, min_length=30, do_sample=False)
+    generated_text = np.array([summary[0]['summary_text']], dtype=object)
+    return TextOutput(predicted_text=generated_text)

clarifai/models/model_serving/examples/text_to_text/bart-summarize/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/models/model_serving/examples/visual_embedding/vit-base/1/inference.py

@@ -0,0 +1,51 @@
+# This file contains boilerplate code to allow users write their model
+# inference code that will then interact with the Triton Inference Server
+# Python backend to serve end user requests.
+# The module name, module path, class name & get_predictions() method names MUST be maintained as is
+# but other methods may be added within the class as deemed fit provided
+# they are invoked within the main get_predictions() inference method
+# if they play a role in any step of model inference
+"""User model inference script."""
+
+import os
+from pathlib import Path
+
+import torch
+from transformers import AutoModel, ViTImageProcessor
+
+from clarifai.models.model_serving.models.model_types import visual_embedder
+from clarifai.models.model_serving.models.output import EmbeddingOutput
+
+
+class InferenceModel:
+  """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.
+    """
+    self.base_path: Path = os.path.dirname(__file__)
+    self.huggingface_model_path = os.path.join(self.base_path, "vit-base-patch16-224")
+    self.processor = ViTImageProcessor.from_pretrained(self.huggingface_model_path)
+    self.model = AutoModel.from_pretrained(self.huggingface_model_path)
+
+  @visual_embedder
+  def get_predictions(self, input_data):
+    """
+    Main model inference method.
+
+    Args:
+    -----
+      input_data: A single input data item to predict on.
+        Input data can be an image or text, etc depending on the model type.
+
+    Returns:
+    --------
+      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
+    """
+    inputs = self.processor(images=input_data, return_tensors="pt")
+    with torch.no_grad():
+      embedding_vector = self.model(**inputs).last_hidden_state[:, 0].cpu().numpy()
+
+    return EmbeddingOutput(embedding_vector=embedding_vector[0])

clarifai/models/model_serving/examples/visual_embedding/vit-base/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/models/model_serving/examples/visual_segmentation/segformer-b2/1/inference.py

@@ -0,0 +1,55 @@
+# This file contains boilerplate code to allow users write their model
+# inference code that will then interact with the Triton Inference Server
+# Python backend to serve end user requests.
+# The module name, module path, class name & get_predictions() method names MUST be maintained as is
+# but other methods may be added within the class as deemed fit provided
+# they are invoked within the main get_predictions() inference method
+# if they play a role in any step of model inference
+"""User model inference script."""
+
+import os
+from pathlib import Path
+
+import torch
+from transformers import AutoModelForSemanticSegmentation, SegformerImageProcessor
+
+from clarifai.models.model_serving.models.model_types import visual_segmenter
+from clarifai.models.model_serving.models.output import MasksOutput
+
+
+class InferenceModel:
+  """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.
+    """
+    self.base_path: Path = os.path.dirname(__file__)
+    self.huggingface_model_path = os.path.join(self.base_path, "segformer_b2_clothes")
+    #self.labels_path = os.path.join(Path(self.base_path).parents[0], "labels.txt")
+    self.processor = SegformerImageProcessor.from_pretrained(self.huggingface_model_path)
+    self.model = AutoModelForSemanticSegmentation.from_pretrained(self.huggingface_model_path)
+
+  @visual_segmenter
+  def get_predictions(self, input_data):
+    """
+    Main model inference method.
+
+    Args:
+    -----
+      input_data: A single input data item to predict on.
+        Input data can be an image or text, etc depending on the model type.
+
+    Returns:
+    --------
+      One of the clarifai.models.model_serving.models.output types. Refer to the README/docs
+    """
+    inputs = self.processor(images=input_data, return_tensors="pt")
+    with torch.no_grad():
+      output = self.model(**inputs)
+
+    logits = output.logits.cpu()
+    mask = logits.argmax(dim=1)[0].numpy()
+
+    return MasksOutput(predicted_mask=mask)

clarifai/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/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/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/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/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/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/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;