clarifai 9.10.2__py3-none-any.whl → 9.10.3__py3-none-any.whl

clarifai/datasets/upload/loaders/coco_detection.py

@@ -1,134 +1,75 @@
-#! COCO 2017 detection dataset
+#! COCO detection dataset
 
 import os
-import zipfile
-from glob import glob
 
-import cv2
-import requests
 from pycocotools.coco import COCO
-from tqdm import tqdm
 
-from clarifai.datasets.upload.base import ClarifaiDataLoader
+from ..base import ClarifaiDataLoader
 
 from ..features import VisualDetectionFeatures
 
 
 class COCODetectionDataLoader(ClarifaiDataLoader):
-  """COCO 2017 Image Detection Dataset."""
 
-  def __init__(self, split: str = "train"):
+  def __init__(self, images_dir, label_filepath):
     """
-    Initialize coco dataset.
-    Args:
-      filenames: the coco zip filenames: Dict[str, 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.path.dirname(os.path.abspath(__file__)),
-                                 "data")  # data storage directory
-    self.extracted_coco_dirs = {"train": None, "val": None, "annotations": None}
-
+      Args:
+        images_dir: Directory containing the images.
+        label_filepath: Path to the COCO annotation file.
+      """
+    self.images_dir = images_dir
+    self.label_filepath = label_filepath
+
+    self.map_ids = {}
     self.load_data()
 
-  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():
-      existing_files = glob(f"{save_dir}/{key}*")
-      if existing_files:
-        print(f"{key} 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 load_data(self):
-    if isinstance(self.filenames, dict) 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 dict 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]
-    self.coco = COCO(annot_file)
-    categories = self.coco.loadCats(self.coco.getCatIds())
-    self.cat_id_map = {category["id"]: category["name"] for category in categories}
-    self.cat_img_ids = {}
-    for cat_id in list(self.cat_id_map.keys()):
-      self.cat_img_ids[cat_id] = self.coco.getImgIds(catIds=[cat_id])
-
-    img_ids = []
-    for i in list(self.cat_img_ids.values()):
-      img_ids.extend(i)
-
-    self.img_ids = list(set(img_ids))
+  @property
+  def task(self):
+    return "visual_detection"
 
-  def __len__(self):
-    return len(self.img_ids)
+  def load_data(self) -> None:
+    self.coco = COCO(self.label_filepath)
+    self.map_ids = {i: img_id for i, img_id in enumerate(list(self.coco.imgs.keys()))}
 
-  def __getitem__(self, idx):
-    _id = self.img_ids[idx]
+  def __getitem__(self, index: int):
+    value = self.coco.imgs[self.map_ids[index]]
+    image_path = os.path.join(self.images_dir, value['file_name'])
     annots = []  # bboxes
-    class_names = []
-    labels = [i for i in list(filter(lambda x: _id in self.cat_img_ids[x], self.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 = self.coco.getAnnIds(imgIds=_id, catIds=[cat_id])
-      if len(annot_ids) > 0:
-        img_annotations = self.coco.loadAnns(annot_ids)
-        for ann in img_annotations:
-          class_names.append(self.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
+    concept_ids = []
+
+    input_ann_ids = self.coco.getAnnIds(imgIds=[value['id']])
+    input_anns = self.coco.loadAnns(input_ann_ids)
+
+    for ann in input_anns:
+      # get concept info
+      # note1: concept_name can be human readable
+      # note2: concept_id can only be alphanumeric, up to 32 characters, with no special chars except `-` and `_`
+      concept_name = self.coco.cats[ann['category_id']]['name']
+      concept_id = concept_name.lower().replace(' ', '-')
+
+      # get bbox information
+      # note1: coco bboxes are `[x_min, y_min, width, height]` in pixels
+      # note2: clarifai bboxes are `[x_min, y_min, x_max, y_max]` normalized between 0-1.0
+      coco_bbox = ann['bbox']
+      clarifai_bbox = {
+          'left_col': max(0, coco_bbox[0] / value['width']),
+          'top_row': max(0, coco_bbox[1] / value['height']),
+          'right_col': min(1, (coco_bbox[0] + coco_bbox[2]) / value['width']),
+          'bottom_row': min(1, (coco_bbox[1] + coco_bbox[3]) / value['width'])
+      }
+      if (clarifai_bbox['left_col'] >=
+          clarifai_bbox['right_col']) or (clarifai_bbox['top_row'] >= clarifai_bbox['bottom_row']):
         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."
+      annots.append([
+          clarifai_bbox['left_col'], clarifai_bbox['top_row'], clarifai_bbox['right_col'],
+          clarifai_bbox['bottom_row']
+      ])
+      concept_ids.append(concept_id)
+
+    assert len(concept_ids) == len(annots), f"Num concepts must match num bbox annotations\
+        for a single image. Found {len(concept_ids)} concepts and {len(annots)} bboxes."
 
-    return VisualDetectionFeatures(image_path, class_names, annots, id=str(_id))
+    return VisualDetectionFeatures(image_path, concept_ids, annots, id=str(value['id']))
+
+  def __len__(self):
+    return len(self.coco.imgs)

clarifai/datasets/upload/loaders/coco_segmentation.py

@@ -2,16 +2,12 @@
 
 import gc
 import os
-import zipfile
 from functools import reduce
-from glob import glob
 
 import cv2
 import numpy as np
-import requests
 from pycocotools import mask as maskUtils
 from pycocotools.coco import COCO
-from tqdm import tqdm
 
 from clarifai.datasets.upload.base import ClarifaiDataLoader
 
@@ -19,148 +15,84 @@ from ..features import VisualSegmentationFeatures
 
 
 class COCOSegmentationDataLoader(ClarifaiDataLoader):
-  """COCO 2017 Image Segmentation Dataset."""
+  """COCO Image Segmentation Dataset."""
 
-  def __init__(self, split: str = "train"):
+  def __init__(self, images_dir, label_filepath):
     """
-    Initialize coco dataset.
     Args:
-      filenames: the coco zip filenames: Dict[str, str] to be downloaded if download=True,
-      data_dir: the local coco dataset directory
-      split: "train" or "val"
+      images_dir: Directory containing the images.
+      label_filepath: Path to the COCO annotation file.
     """
-    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.path.dirname(os.path.abspath(__file__)),
-                                 "data")  # data storage dir
-    self.extracted_coco_dirs = {"train": None, "val": None, "annotations": None}
+    self.images_dir = images_dir
+    self.label_filepath = label_filepath
 
+    self.map_ids = {}
     self.load_data()
 
-  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():
-      existing_files = glob(f"{save_dir}/{key}*")
-      if existing_files:
-        print(f"{key} 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 load_data(self):
-    """Load coco dataset image ids or filenames."""
-    if isinstance(self.filenames, dict) 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 dict 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"instances_{self.split}*")[
-        0]
-    self.coco = COCO(annot_file)
-    categories = self.coco.loadCats(self.coco.getCatIds())
-    self.cat_id_map = {category["id"]: category["name"] for category in categories}
-    self.cat_img_ids = {}
-    for cat_id in list(self.cat_id_map.keys()):
-      self.cat_img_ids[cat_id] = self.coco.getImgIds(catIds=[cat_id])
-
-    img_ids = set()
-    for i in list(self.cat_img_ids.values()):
-      img_ids.update(i)
-
-    self.img_ids = list(img_ids)
+  @property
+  def task(self):
+    return "visual_segmentation"
+
+  def load_data(self) -> None:
+    self.coco = COCO(self.label_filepath)
+    self.map_ids = {i: img_id for i, img_id in enumerate(list(self.coco.imgs.keys()))}
 
   def __len__(self):
-    return len(self.img_ids)
+    return len(self.coco.imgs)
 
-  def __getitem__(self, idx):
+  def __getitem__(self, index):
     """Get image and annotations for a given index."""
-    _id = self.img_ids[idx]
+    value = self.coco.imgs[self.map_ids[index]]
+    image_path = os.path.join(self.images_dir, value['file_name'])
     annots = []  # polygons
-    class_names = []
-    labels = [i for i in list(filter(lambda x: _id in self.cat_img_ids[x], self.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 = self.coco.getAnnIds(imgIds=_id, catIds=[cat_id])
-      if len(annot_ids) > 0:
-        img_annotations = self.coco.loadAnns(annot_ids)
-        for ann in img_annotations:
-          # get polygons
-          if isinstance(ann['segmentation'], list):
-            for seg in ann['segmentation']:
-              poly = np.array(seg).reshape((int(len(seg) / 2), 2))
-              poly[:, 0], poly[:, 1] = poly[:, 0] / image_width, poly[:, 1] / image_height
-              annots.append(poly.tolist())  #[[x=col, y=row],...]
-              class_names.append(self.cat_id_map[cat_id])
-          else:  # seg: {"counts":[...]}
-            if isinstance(ann['segmentation']['counts'], list):
-              rle = maskUtils.frPyObjects([ann['segmentation']], image_height, image_width)
-            else:
-              rle = ann['segmentation']
-            mask = maskUtils.decode(rle)  #binary mask
-            #convert mask to polygons and add to annots
-            contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
-            polygons = []
-            for cont in contours:
-              if cont.size >= 6:
-                polygons.append(cont.astype(float).flatten().tolist())
-            # store polygons in (x,y) pairs
-            polygons_flattened = reduce(lambda x, y: x + y, polygons)
-            del polygons
-            del contours
-            del mask
-            gc.collect()
-
-            polygons = np.array(polygons_flattened).reshape((int(len(polygons_flattened) / 2), 2))
-            polygons[:, 0] = polygons[:, 0] / image_width
-            polygons[:, 1] = polygons[:, 1] / image_height
-
-            annots.append(polygons.tolist())  #[[x=col, y=row],...,[x=col, y=row]]
-            class_names.append(self.cat_id_map[cat_id])
-      else:  # if no annotations for given image_id-cat_id pair
-        continue
-    assert len(class_names) == len(annots), f"Num classes must match num annotations\
-    for a single image. Found {len(class_names)} classes and {len(annots)} polygons."
-
-    return VisualSegmentationFeatures(image_path, class_names, annots, id=str(_id))
+    concept_ids = []
+
+    input_ann_ids = self.coco.getAnnIds(imgIds=[value['id']])
+    input_anns = self.coco.loadAnns(input_ann_ids)
+
+    for ann in input_anns:
+      # get concept info
+      # note1: concept_name can be human readable
+      # note2: concept_id can only be alphanumeric, up to 32 characters, with no special chars except `-` and `_`
+      concept_name = self.coco.cats[ann['category_id']]['name']
+      concept_id = concept_name.lower().replace(' ', '-')
+
+      # get polygons
+      if isinstance(ann['segmentation'], list):
+        poly = np.array(ann['segmentation']).reshape((int(len(ann['segmentation'][0]) / 2),
+                                                      2)).astype(float)
+        poly[:, 0], poly[:, 1] = poly[:, 0] / value['width'], poly[:, 1] / value['height']
+        poly = np.clip(poly, 0, 1)
+        annots.append(poly.tolist())  #[[x=col, y=row],...]
+        concept_ids.append(concept_id)
+      else:  # seg: {"counts":[...]}
+        if isinstance(ann['segmentation']['counts'], list):
+          rle = maskUtils.frPyObjects([ann['segmentation']], value['height'], value['width'])
+        else:
+          rle = ann['segmentation']
+        mask = maskUtils.decode(rle)  #binary mask
+        #convert mask to polygons and add to annots
+        contours, _ = cv2.findContours(mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
+        polygons = []
+        for cont in contours:
+          if cont.size >= 6:
+            polygons.append(cont.astype(float).flatten().tolist())
+        # store polygons in (x,y) pairs
+        polygons_flattened = reduce(lambda x, y: x + y, polygons)
+        del polygons
+        del contours
+        del mask
+        gc.collect()
+
+        polygons = np.array(polygons_flattened).reshape((int(len(polygons_flattened) / 2),
+                                                         2)).astype(float)
+        polygons[:, 0] = polygons[:, 0] / value['width']
+        polygons[:, 1] = polygons[:, 1] / value['height']
+        polygons = np.clip(polygons, 0, 1)
+        annots.append(polygons.tolist())  #[[x=col, y=row],...,[x=col, y=row]]
+        concept_ids.append(concept_id)
+
+    assert len(concept_ids) == len(annots), f"Num concepts must match num bbox annotations\
+    for a single image. Found {len(concept_ids)} concepts and {len(annots)} bboxes."
+
+    return VisualSegmentationFeatures(image_path, concept_ids, annots, id=str(value['id']))

clarifai/datasets/upload/loaders/imagenet_classification.py

@@ -9,7 +9,7 @@ from ..features import VisualClassificationFeatures
 class ImageNetDataLoader(ClarifaiDataLoader):
   """ImageNet Dataset."""
 
-  def __init__(self, split: str = "train"):
+  def __init__(self, data_dir, split: str = "train"):
     """
     Initialize dataset params.
     Args:
@@ -17,8 +17,7 @@ class ImageNetDataLoader(ClarifaiDataLoader):
       split: "train" or "test"
     """
     self.split = split
-    self.data_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)),
-                                 "data")  # data storage directory
+    self.data_dir = data_dir
     self.label_map = dict()
     self.concepts = []
     self.image_paths = []

clarifai/datasets/upload/loaders/xview_detection.py

@@ -31,13 +31,13 @@ class xviewDetectionDataLoader(ClarifaiDataLoader):
       'Shipping container lot', 'Shipping Container', 'Pylon', 'Tower'
   ]
 
-  def __init__(self, split: str = "train") -> None:
+  def __init__(self, data_dir) -> None:
     """Initialize and Compress xview dataset.
     Args:
-    split: "train"
+    data_dir: the local dataset directory.
     """
 
-    self.data_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "data")
+    self.data_dir = data_dir
     self.img_dir = os.path.join(self.data_dir, "train_images")
     self.img_comp_dir = os.path.join(self.data_dir, "train_images_comp")
     self.label_file = os.path.join(self.data_dir, "xview_train.geojson")

clarifai/datasets/upload/text.py

@@ -1,17 +1,19 @@
 from concurrent.futures import ThreadPoolExecutor
-from typing import Iterator, List, Tuple
+from typing import List, Tuple, Type
 
 from clarifai_grpc.grpc.api import resources_pb2
 from google.protobuf.struct_pb2 import Struct
 
-from .base import ClarifaiDataset
+from clarifai.client.input import Inputs
+
+from .base import ClarifaiDataLoader, 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 __init__(self, data_generator: Type[ClarifaiDataLoader], dataset_id: str) -> None:
+    super().__init__(data_generator, dataset_id)
 
   def _extract_protos(self, batch_input_ids: List[int]
                      ) -> Tuple[List[resources_pb2.Input], List[resources_pb2.Annotation]]:
@@ -24,21 +26,19 @@ class TextClassificationDataset(ClarifaiDataset):
     """
     input_protos, annotation_protos = [], []
 
-    def process_datagen_item(id):
-      datagen_item = self.datagen_object[id]
+    def process_data_item(id):
+      data_item = self.data_generator[id]
       metadata = Struct()
-      text = datagen_item.text
-      labels = datagen_item.labels if isinstance(
-          datagen_item.labels, list) else [datagen_item.labels]  # clarifai concept
-      input_id = f"{self.dataset_id}-{self.split}-{id}" if datagen_item.id is None else f"{self.dataset_id}-{self.split}-{str(datagen_item.id)}"
-      if datagen_item.metadata is not None:
-        metadata.update(datagen_item.metadata)
-      else:
-        metadata.update({"split": self.split})
+      text = data_item.text
+      labels = data_item.labels if isinstance(data_item.labels,
+                                              list) else [data_item.labels]  # clarifai concept
+      input_id = f"{self.dataset_id}-{id}" if data_item.id is None else f"{self.dataset_id}-{str(data_item.id)}"
+      if data_item.metadata is not None:
+        metadata.update(data_item.metadata)
 
       self.all_input_ids[id] = input_id
       input_protos.append(
-          self.input_object.get_text_input(
+          Inputs.get_text_input(
               input_id=input_id,
               raw_text=text,
               dataset_id=self.dataset_id,
@@ -46,7 +46,7 @@ class TextClassificationDataset(ClarifaiDataset):
               metadata=metadata))
 
     with ThreadPoolExecutor(max_workers=4) as executor:
-      futures = [executor.submit(process_datagen_item, id) for id in batch_input_ids]
+      futures = [executor.submit(process_data_item, id) for id in batch_input_ids]
       for job in futures:
         job.result()