clarifai 9.1.0__py3-none-any.whl → 9.3.1__py3-none-any.whl

clarifai/data_upload/datasets/base.py

@@ -0,0 +1,67 @@
+from typing import Iterator, List
+
+from clarifai_grpc.grpc.api import resources_pb2
+from google.protobuf.struct_pb2 import Struct
+
+
+class ClarifaiDataset:
+  """
+  Clarifai datasets base class.
+  """
+
+  def __init__(self, datagen_object: Iterator, dataset_id: str, split: str) -> None:
+    self.datagen_object = datagen_object
+    self.dataset_id = dataset_id
+    self.split = split
+    self._all_input_protos = []
+
+  def __len__(self) -> int:
+    """
+    Get size of all input protos
+    """
+    return len(self._all_input_protos)
+
+  def _to_list(self, input_protos: Iterator) -> List:
+    """
+    Parse protos iterator to list.
+    """
+    return list(input_protos)
+
+  def create_input_protos(self, image_path: str, label: str, input_id: str, dataset_id: str,
+                          metadata: Struct) -> resources_pb2.Input:
+    """
+    Create input protos for each image, label input pair.
+    Args:
+    	`image_path`: path to image.
+    	`label`: image label
+    	`input_id: unique input id
+    	`dataset_id`: Clarifai dataset id
+    	`metadata`: input metadata
+    Returns:
+    	An input proto representing a single row input
+    """
+    raise NotImplementedError()
+
+  def _get_input_protos(self) -> Iterator:
+    """
+    Create input protos for each row of the dataframe.
+    Returns:
+    	A list of input protos
+    """
+    raise NotImplementedError()
+
+
+class Chunker:
+  """
+  Split an input sequence into small chunks.
+  """
+
+  def __init__(self, seq: List, size: int) -> None:
+    self.seq = seq
+    self.size = size
+
+  def chunk(self) -> List[List]:
+    """
+    Chunk input sequence.
+    """
+    return [self.seq[pos:pos + self.size] for pos in range(0, len(self.seq), self.size)]

clarifai/data_upload/datasets/features.py

@@ -0,0 +1,45 @@
+#! dataset output features (output from preprocessing & input to clarifai data proto builders)
+from dataclasses import dataclass
+from typing import List, Optional, Union
+
+
+@dataclass
+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
+  id: Optional[int] = None  # text_id
+
+
+@dataclass
+class VisualClassificationFeatures:
+  """
+  Image classification datasets preprocessing output features.
+  """
+  image_path: str
+  label: Union[str, int]
+  id: Optional[int] = None  # image_id
+
+
+@dataclass
+class VisualDetectionFeatures:
+  """
+  Image Detection datasets preprocessing output features.
+  """
+  image_path: str
+  classes: List[Union[str, int]]
+  bboxes: List[List[float]]
+  id: Optional[int] = None  # image_id
+
+
+@dataclass
+class VisualSegmentationFeatures:
+  """
+  Image Segmentation datasets preprocessing output features.
+  """
+  image_path: str
+  classes: List[Union[str]]
+  polygons: List[List[List[float]]]
+  id: Optional[int] = None  # image_id

clarifai/data_upload/datasets/image.py

@@ -0,0 +1,236 @@
+from typing import Iterator, List, Tuple, Union
+
+from clarifai_grpc.grpc.api import resources_pb2
+from google.protobuf.struct_pb2 import Struct
+from tqdm import tqdm
+
+from .base import ClarifaiDataset
+
+
+class VisualClassificationDataset(ClarifaiDataset):
+
+  def __init__(self, datagen_object: Iterator, dataset_id: str, split: str) -> None:
+    super().__init__(datagen_object, dataset_id, split)
+
+  def create_input_protos(self, image_path: str, labels: List[Union[str, int]], input_id: str,
+                          dataset_id: str, metadata: Struct) -> resources_pb2.Input:
+    """
+    Create input protos for each image, label input pair.
+    Args:
+      `image_path`: image path.
+      `labels`: image label(s)
+      `input_id: unique input id
+      `dataset_id`: Clarifai dataset id
+      `metadata`: image metadata
+    Returns:
+      An input proto representing a single row input
+    """
+    input_proto = resources_pb2.Input(
+        id=input_id,
+        dataset_ids=[dataset_id],
+        data=resources_pb2.Data(
+            image=resources_pb2.Image(base64=open(image_path, 'rb').read(),),
+            concepts=[
+                resources_pb2.Concept(
+                  id=f"id-{''.join(_label.split(' '))}", name=_label, value=1.)\
+                for _label in labels
+            ],
+            metadata=metadata))
+
+    return input_proto
+
+  def _get_input_protos(self) -> Iterator:
+    """
+    Create input image protos for each data generator item.
+    Returns:
+      Input proto iterator
+    """
+    for i, item in tqdm(enumerate(self.datagen_object), desc="Creating input protos..."):
+      metadata = Struct()
+      image_path = item.image_path
+      label = item.label if isinstance(item.label, list) else [item.label]  # clarifai concept
+      input_id = f"{self.dataset_id}-{self.split}-{i}" if item.id is None else f"{self.split}-{str(item.id)}"
+
+      input_proto = self.create_input_protos(image_path, label, input_id, self.dataset_id,
+                                             metadata)
+      self._all_input_protos.append(input_proto)
+
+    return iter(self._all_input_protos)
+
+
+class VisualDetectionDataset(ClarifaiDataset):
+  """
+  Visual detection dataset proto class.
+  """
+
+  def __init__(self, datagen_object: Iterator, dataset_id: str, split: str) -> None:
+    super().__init__(datagen_object, dataset_id, split)
+    self._annotation_protos = []
+
+  def create_input_protos(self, image_path: str, input_id: str, dataset_id: str,
+                          metadata: Struct) -> resources_pb2.Input:
+    """
+    Create input protos for each image, label input pair.
+    Args:
+      `image_path`: file path to image
+      `input_id: unique input id
+      `dataset_id`: Clarifai dataset id
+      `metadata`: image metadata
+    Returns:
+      An input proto representing a single row input
+    """
+    input_image_proto = resources_pb2.Input(
+        id=input_id,
+        dataset_ids=[dataset_id],
+        data=resources_pb2.Data(
+            image=resources_pb2.Image(base64=open(image_path, 'rb').read(),), metadata=metadata))
+
+    return input_image_proto
+
+  def create_annotation_proto(self, label: str, annotations: List, input_id: str,
+                              dataset_id: str) -> resources_pb2.Annotation:
+    """
+    Create an input proto for each bounding box, label input pair.
+    Args:
+      `label`: annotation label
+      `annotations`: a list of a single bbox's coordinates.
+      `input_id: unique input id
+      `dataset_id`: Clarifai dataset id
+    Returns:
+      An input proto representing a single image input
+    """
+    input_annot_proto = resources_pb2.Annotation(
+        input_id=input_id,
+        data=resources_pb2.Data(regions=[
+            resources_pb2.Region(
+                region_info=resources_pb2.RegionInfo(bounding_box=resources_pb2.BoundingBox(
+                    # Annotations ordering: [xmin, ymin, xmax, ymax]
+                    # top_row must be less than bottom row
+                    # left_col must be less than right col
+                    top_row=annotations[1],  #y_min
+                    left_col=annotations[0],  #x_min
+                    bottom_row=annotations[3],  #y_max
+                    right_col=annotations[2]  #x_max
+                )),
+                data=resources_pb2.Data(concepts=[
+                    resources_pb2.Concept(
+                        id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                ]))
+        ]))
+
+    return input_annot_proto
+
+  def _get_input_protos(self) -> Tuple[Iterator, Iterator]:
+    """
+    Create input image protos for each data generator item.
+    Returns:
+      Input and Annotation proto iterators.
+    """
+    for i, item in tqdm(enumerate(self.datagen_object), desc="Creating input protos..."):
+      metadata = Struct()
+      image = item.image_path
+      labels = item.classes  # list:[l1,...,ln]
+      bboxes = item.bboxes  # [[xmin,ymin,xmax,ymax],...,[xmin,ymin,xmax,ymax]]
+      input_id = f"{self.dataset_id}-{self.split}-{i}" if item.id is None else f"{self.split}-{str(item.id)}"
+      metadata.update({"label": labels, "split": self.split})
+
+      input_image_proto = self.create_input_protos(image, input_id, self.dataset_id, metadata)
+      self._all_input_protos.append(input_image_proto)
+
+      # iter over bboxes and classes
+      # one id could have more than one bbox and label
+      for i in range(len(bboxes)):
+        input_annot_proto = self.create_annotation_proto(labels[i], bboxes[i], input_id,
+                                                         self.dataset_id)
+        self._annotation_protos.append(input_annot_proto)
+
+    return iter(self._all_input_protos), iter(self._annotation_protos)
+
+
+class VisualSegmentationDataset(ClarifaiDataset):
+  """
+  Visual segmentation dataset proto class.
+  """
+
+  def __init__(self, datagen_object: Iterator, dataset_id: str, split: str) -> None:
+    super().__init__(datagen_object, dataset_id, split)
+    self._mask_protos = []  # mask or polygon protos
+
+  def create_input_protos(self, image_path: str, input_id: str, dataset_id: str,
+                          metadata: Struct) -> resources_pb2.Input:
+    """
+    Create input protos for each image, label input pair.
+    Args:
+      `image_path`: absolute image file path
+      `input_id: unique input id
+      `dataset_id`: Clarifai dataset id
+      `metadata`: image metadata
+    Returns:
+      An input proto representing a single input item
+    """
+    input_image_proto = resources_pb2.Input(
+        id=input_id,
+        dataset_ids=[dataset_id],
+        data=resources_pb2.Data(
+            image=resources_pb2.Image(base64=open(image_path, 'rb').read(),), metadata=metadata))
+
+    return input_image_proto
+
+  def create_mask_proto(self, label: str, polygons: List[List[float]], input_id: str,
+                        dataset_id: str) -> resources_pb2.Annotation:
+    """
+    Create an input mask proto for an input polygon/mask and label.
+    Args:
+      `label`: image label
+      `polygons`: Polygon x,y points iterable
+      `input_id: unique input id
+      `dataset_id`: Clarifai dataset id
+    Returns:
+      An input proto corresponding to a single image
+    """
+    input_mask_proto = resources_pb2.Annotation(
+        input_id=input_id,
+        data=resources_pb2.Data(regions=[
+            resources_pb2.Region(
+                region_info=resources_pb2.RegionInfo(polygon=resources_pb2.Polygon(
+                    points=[
+                        resources_pb2.Point(
+                            row=_point[1],  # row is y point
+                            col=_point[0],  # col is x point
+                            visibility="VISIBLE") for _point in polygons
+                    ])),
+                data=resources_pb2.Data(concepts=[
+                    resources_pb2.Concept(
+                        id=f"id-{''.join(label.split(' '))}", name=label, value=1.)
+                ]))
+        ]))
+
+    return input_mask_proto
+
+  def _get_input_protos(self) -> Tuple[Iterator, Iterator]:
+    """
+    Create input image and annotation protos for each data generator item.
+    Returns:
+      Input and Annotation proto iterators.
+    """
+    for i, item in tqdm(enumerate(self.datagen_object), desc="Creating input protos..."):
+      metadata = Struct()
+      image = item.image_path  # image path
+      labels = item.classes  # list of class labels
+      _polygons = item.polygons  # list of polygons: [[[x,y],...,[x,y]],...]
+      input_id = f"{self.dataset_id}-{self.split}-{i}" if item.id is None else f"{self.split}-{str(item.id)}"
+      metadata.update({"label": labels, "split": self.split})
+
+      input_image_proto = self.create_input_protos(image, input_id, self.dataset_id, metadata)
+      self._all_input_protos.append(input_image_proto)
+
+      ## Iterate over each masked image and create a proto for upload to clarifai
+      ## The length of masks/polygons-list and labels must be equal
+      for i, _polygon in enumerate(_polygons):
+        try:
+          input_mask_proto = self.create_mask_proto(labels[i], _polygon, input_id, self.dataset_id)
+          self._mask_protos.append(input_mask_proto)
+        except IndexError:
+          continue
+
+    return iter(self._all_input_protos), iter(self._mask_protos)

clarifai/data_upload/datasets/text.py

@@ -0,0 +1,62 @@
+from typing import Iterator, List
+
+from clarifai_grpc.grpc.api import resources_pb2
+from google.protobuf.struct_pb2 import Struct
+from tqdm import tqdm
+
+from .base import ClarifaiDataset
+
+
+class TextClassificationDataset(ClarifaiDataset):
+  """
+  Upload text classification datasets to clarifai datasets
+  """
+
+  def __init__(self, datagen_object: Iterator, dataset_id: str, split: str) -> None:
+    super().__init__(datagen_object, dataset_id, split)
+
+  def create_input_protos(self, text_input: str, labels: List[str], input_id: str, dataset_id: str,
+                          metadata: Struct) -> resources_pb2.Input:
+    """
+    Create input protos for each text, label input pairs.
+    Args:
+    	`text_input`: text string.
+    	`labels`: text labels
+    	`input_id: unique input id
+    	`dataset_id`: Clarifai dataset id
+    	`metadata`:input metadata
+    Returns:
+    	An input proto representing a single row input
+    """
+    input_proto = resources_pb2.Input(
+        id=input_id,
+        dataset_ids=[dataset_id],
+        data=resources_pb2.Data(
+            text=resources_pb2.Text(raw=text_input),
+            concepts=[
+                resources_pb2.Concept(
+                    id=f"id-{''.join(_label.split(' '))}", name=_label, value=1.)
+                for _label in labels
+            ],
+            metadata=metadata))
+
+    return input_proto
+
+  def _get_input_protos(self) -> Iterator:
+    """
+    Creates input protos for each data generator item.
+    Returns:
+    	A list of input protos
+    """
+    for i, item in tqdm(enumerate(self.datagen_object), desc="Loading text data"):
+      metadata = Struct()
+      text = item.text
+      labels = item.labels if isinstance(item.labels, list) else [item.labels]  # clarifai concept
+      input_id = f"{self.dataset_id}-{self.split}-{i}" if item.id is None else f"{self.split}-{str(item.id)}"
+      metadata.update({"label": labels, "split": self.split})
+
+      input_proto = self.create_input_protos(text, labels, input_id, self.dataset_id, metadata)
+
+      self._all_input_protos.append(input_proto)
+
+    return iter(self._all_input_protos)

clarifai/data_upload/datasets/zoo/coco_captions.py

@@ -0,0 +1,99 @@
+#! COCO 2017 image captioning dataset
+
+import os
+import zipfile
+from glob import glob
+
+import requests
+from pycocotools.coco import COCO
+from tqdm import tqdm
+
+from ..features import VisualClassificationFeatures
+
+
+class COCOCaptionsDataset:
+  """COCO 2017 Image Captioning Dataset."""
+
+  def __init__(self, split: str = "train"):
+    """
+    Initialize coco dataset.
+    Args:
+      filenames: the coco zip filenames: List[str] to be downloaded if download=True,
+      data_dir: the local coco dataset directory.
+      split: "train" or "val"
+    """
+    self.filenames = {
+        "train": "train2017.zip",
+        "val": "val2017.zip",
+        "annotations": "annotations_trainval2017.zip"
+    }
+    self.split = split
+    self.url = "http://images.cocodataset.org/zips/"  # coco base image-zip url
+    self.data_dir = os.path.join(os.curdir, ".data")  # data storage directory
+    self.extracted_coco_dirs = {"train": None, "val": None, "annotations": None}
+
+  def coco_download(self, save_dir):
+    """Download coco dataset."""
+    if not os.path.exists(save_dir):
+      os.mkdir(save_dir)
+
+    #check if train, val and annotation dirs exist
+    #so that the coco2017 data isn't downloaded
+    for key, filename in self.filenames.items():
+      if os.path.exists(glob(f"{save_dir}/{key}*")[0]):
+        print("Dataset already downloded and extracted")
+        continue
+
+      print("-" * 80)
+      print(f"Downloading {filename}")
+      print("-" * 80)
+
+      if "annotations" in filename:
+        self.url = "http://images.cocodataset.org/annotations/"
+
+      response = requests.get(self.url + filename, stream=True)
+      response.raise_for_status()
+      with open(os.path.join(save_dir, filename), "wb") as _file:
+        for chunk in tqdm(response.iter_content(chunk_size=5124000)):
+          if chunk:
+            _file.write(chunk)
+      print("Data download complete...")
+
+      #extract files
+      zf = zipfile.ZipFile(os.path.join(save_dir, filename))
+      print(f" Extracting {filename} file")
+      zf.extractall(path=save_dir)
+      # Delete coco zip
+      print(f" Deleting {filename}")
+      os.remove(path=os.path.join(save_dir, filename))
+
+  def dataloader(self):
+    """
+    Transform coco image captioning data into clarifai proto compatible
+    format for upload.
+    Returns:
+      VisualClassificationFeatures type generator.
+    """
+    if isinstance(self.filenames, list) and len(self.filenames) == 3:  #train, val, annotations
+      self.coco_download(self.data_dir)
+      self.extracted_coco_dirs["train"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "train" in i][0]
+      self.extracted_coco_dirs["val"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "val" in i][0]
+
+      self.extracted_coco_dirs["annotations"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "annotations" in i][0]
+    else:
+      raise Exception(f"`filenames` must be a list of atleast 3 coco zip file names; \
+      train, val and annotations. Found {len(self.filenames)} items instead.")
+
+    annot_file = glob(self.extracted_coco_dirs["annotations"] + "/" + f"captions_{self.split}*")[0]
+    coco = COCO(annot_file)
+    annot_ids = coco.getAnnIds()
+    annotations = coco.loadAnns(annot_ids)
+    for annot in annotations:
+      image_path = glob(self.extracted_coco_dirs[self.split]+"/"+\
+      f"{str(annot['image_id']).zfill(12)}*")[0]
+      # image_captioning and image classification datasets have the same
+      # image-label input feature formats
+      yield VisualClassificationFeatures(image_path, annot["caption"], annot["image_id"])

clarifai/data_upload/datasets/zoo/coco_detection.py

@@ -0,0 +1,129 @@
+#! COCO 2017 detection dataset
+
+import os
+import zipfile
+from glob import glob
+
+import cv2
+import requests
+from pycocotools.coco import COCO
+from tqdm import tqdm
+
+from ..features import VisualDetectionFeatures
+
+
+class COCODetectionDataset:
+  """COCO 2017 Image Detection Dataset."""
+
+  def __init__(self, split: str = "train"):
+    """
+    Initialize coco dataset.
+    Args:
+      filenames: the coco zip filenames: List[str] to be downloaded if download=True,
+      data_dir: the local coco dataset directory.
+      split: "train" or "val"
+    """
+    self.filenames = {
+        "train": "train2017.zip",
+        "val": "val2017.zip",
+        "annotations": "annotations_trainval2017.zip"
+    }
+    self.split = split
+    self.url = "http://images.cocodataset.org/zips/"  # coco base image-zip url
+    self.data_dir = os.path.join(os.curdir, ".data")  # data storage directory
+    self.extracted_coco_dirs = {"train": None, "val": None, "annotations": None}
+
+  def coco_download(self, save_dir):
+    """Download coco dataset."""
+    if not os.path.exists(save_dir):
+      os.mkdir(save_dir)
+
+    #check if train*, val* and annotation* dirs exist
+    #so that the coco2017 data isn't downloaded
+    for key, filename in self.filenames.items():
+      if os.path.exists(glob(f"{save_dir}/{key}*")[0]):
+        print("dataset already downloded and extracted")
+        continue
+
+      print("-" * 80)
+      print(f"Downloading {filename}")
+      print("-" * 80)
+
+      if "annotations" in filename:
+        self.url = "http://images.cocodataset.org/annotations/"
+
+      response = requests.get(self.url + filename, stream=True)
+      response.raise_for_status()
+      with open(os.path.join(save_dir, filename), "wb") as _file:
+        for chunk in tqdm(response.iter_content(chunk_size=5124000)):
+          if chunk:
+            _file.write(chunk)
+      print("Coco data download complete...")
+
+      #extract files
+      zf = zipfile.ZipFile(os.path.join(save_dir, filename))
+      print(f" Extracting {filename} file")
+      zf.extractall(path=save_dir)
+      # Delete coco zip
+      print(f" Deleting {filename}")
+      os.remove(path=os.path.join(save_dir, filename))
+
+  def dataloader(self):
+    """
+    Transform coco object detection data into clarifai proto compatible
+    format for upload.
+    Returns:
+      VisualDetectionFeatures type generator.
+    """
+    if isinstance(self.filenames, list) and len(self.filenames) == 3:
+      self.coco_download(self.data_dir)
+      self.extracted_coco_dirs["train"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "train" in i][0]
+      self.extracted_coco_dirs["val"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "val" in i][0]
+
+      self.extracted_coco_dirs["annotations"] = [os.path.join(self.data_dir, i) \
+      for i in os.listdir(self.data_dir) if "annotations" in i][0]
+    else:
+      raise Exception(f"`filenames` must be a list of atleast 2 coco zip file names; \
+      train, val and annotations. Found {len(self.filenames)} items instead.")
+
+    annot_file = glob(self.extracted_coco_dirs["annotations"] + "/" +\
+     f"instances_{self.split}*")[0]
+    coco = COCO(annot_file)
+    categories = coco.loadCats(coco.getCatIds())
+    cat_id_map = {category["id"]: category["name"] for category in categories}
+    cat_img_ids = {}
+    for cat_id in list(cat_id_map.keys()):
+      cat_img_ids[cat_id] = coco.getImgIds(catIds=[cat_id])
+
+    img_ids = []
+    for i in list(cat_img_ids.values()):
+      img_ids.extend(i)
+
+    #get annotations for each image id
+    for _id in img_ids:
+      annots = []  # bboxes
+      class_names = []
+      labels = [i for i in list(filter(lambda x: _id in cat_img_ids[x], cat_img_ids))]
+      image_path = glob(self.extracted_coco_dirs[self.split]+"/"+\
+      f"{str(_id).zfill(12)}*")[0]
+
+      image_height, image_width = cv2.imread(image_path).shape[:2]
+      for cat_id in labels:
+        annot_ids = coco.getAnnIds(imgIds=_id, catIds=[cat_id])
+        if len(annot_ids) > 0:
+          img_annotations = coco.loadAnns(annot_ids)
+          for ann in img_annotations:
+            class_names.append(cat_id_map[cat_id])
+            x_min = ann['bbox'][0] / image_width  #left_col
+            y_min = ann['bbox'][1] / image_height  #top_row
+            x_max = (ann['bbox'][0] + ann['bbox'][2]) / image_width  #right_col
+            y_max = (ann['bbox'][1] + ann['bbox'][3]) / image_height  #bottom_row
+            annots.append([x_min, y_min, x_max, y_max])
+        else:  # if no annotations for given image_id-cat_id pair
+          continue
+      assert len(class_names) == len(annots), f"Num classes must match num bbox annotations\
+      for a single image. Found {len(class_names)} classes and {len(annots)} bboxes."
+
+      yield VisualDetectionFeatures(image_path, class_names, annots, _id)