Test out arrowBuilder

pmd.py

@@ -12,7 +12,6 @@
 # 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.
-"""Wikipedia-based Image Text (WIT) Dataset is a large multimodal multilingual dataset"""
 import json
 import re
 import sqlite3
@@ -22,15 +21,16 @@ from hashlib import md5
 from multiprocessing import Pool
 from pathlib import Path
 from typing import Any, Dict, List, Optional
+import pyarrow as pa
 
 from datetime import datetime
 from urllib.parse import unquote_plus
 
-# TODO: @thomasw21
 import datasets
 from datasets import load_dataset, Dataset
 from langdetect import detect
 
+# TODO: @thomasw21
 _CITATION = """"""
 
 # TODO: @thomasw21
@@ -74,7 +74,7 @@ class BaseLoader:
         self.split = split
 
     @abstractmethod
-    def _generate_examples(self):
+    def _generate_batches(self):
         raise NotImplementedError()
 
 
@@ -93,7 +93,6 @@ class DatasetsLoader(BaseLoader):
         self.dataset_name = dataset_name
         self.config_name = config_name
         self.num_proc = num_proc
-        print(self.num_proc)
         # # In order to not have memory explode we define a batch size per proc
         # self.batch_size_per_proc = batch_size // self.num_proc
         # assert self.batch_size_per_proc >= 1
@@ -101,55 +100,48 @@ class DatasetsLoader(BaseLoader):
         self.batch_size_per_proc = batch_size
 
     @abstractmethod
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
         """Return list of caster rows. Casted row are either PMD features"""
         raise NotImplementedError()
 
-    def convert_batch_to_list_of_rows(self, batch: Dict) -> List[Dict[str, Any]]:
-        # batch_size can be different to self.batch_size, ie due to last batch
-        batch_size = len(next(iter(batch.values())))
-        column_names = list(batch.keys())
-        return [
-            {column_name: batch[column_name][i] for column_name in column_names}
-            for i in range(batch_size)
-        ]
+    # def convert_batch_to_list_of_rows(self, batch: Dict) -> List[Dict[str, Any]]:
+    #     # batch_size can be different to self.batch_size, ie due to last batch
+    #     batch_size = len(next(iter(batch.values())))
+    #     column_names = list(batch.keys())
+    #     return [
+    #         {column_name: batch[column_name][i] for column_name in column_names}
+    #         for i in range(batch_size)
+    #     ]
 
-    def _generate_rows_casted_pmd_features(self, batch_start: int, dset: Dataset):
+    def _generate_batch_table(self, batch_start: int, dset: Dataset) -> pa.Table:
         dataset_size = len(dset)
         batch_end = min(batch_start + self.batch_size_per_proc, dataset_size)
         batch = dset[batch_start:batch_end]
-        rows = self.convert_batch_to_list_of_rows(batch)
+        return pa.table(self.cast_to_pmd_features(batch))
 
-        rows_casted_pmd_features = []
-        for row in rows:
-            rows_casted_pmd_features += self.cast_to_pmd_features(row)
-        return rows_casted_pmd_features
-
-    def _generate_examples(self):
+    def _generate_batches(self):
         dataset = load_dataset(self.dataset_name, self.config_name, split=self.split)
         dataset_size = len(dataset)
 
         # load batches and yield individual rows
         if self.num_proc == 1:
             for batch_start in range(0, dataset_size, self.batch_size_per_proc):
-                rows_casted_pmd_features = self._generate_rows_casted_pmd_features(dset=dataset, batch_start=batch_start)
-                for row_casted_pmd_features in rows_casted_pmd_features:
-                    yield row_casted_pmd_features
+                batch_casted_pmd_features = self._generate_batch_table(
+                    dset=dataset, batch_start=batch_start
+                )
+                yield batch_casted_pmd_features
 
         # Parallel version
         else:
             assert self.num_proc > 1
             with Pool(self.num_proc) as pool:
-                # TODO @thomasw21 figure out if we care about imap.
-                batch_iterator = pool.imap_unordered(
-                    partial(self._generate_rows_casted_pmd_features, dset=dataset),
+                # TODO @thomasw21 figure out if we care about imap / imap_unordered
+                batch_iterator = pool.imap(
+                    partial(self._generate_batch_table, dset=dataset),
                     range(0, dataset_size, self.batch_size_per_proc),
                 )
-                for rows_casted_pmd_features in batch_iterator:
-                    # DEBUG in order to know how fast we get the batches
-                    print("hello")
-                    for row_casted_pmd_features in rows_casted_pmd_features:
-                        yield row_casted_pmd_features
+                for batch_casted_pmd_features in batch_iterator:
+                    yield batch_casted_pmd_features
 
 
 class BaseLoaderWithDLManager(BaseLoader):
@@ -164,11 +156,11 @@ class BaseLoaderWithDLManager(BaseLoader):
         raise NotImplementedError()
 
     @abstractmethod
-    def _generate_examples_with_kwargs(self, **kwargs):
+    def _generate_examples_with_kwargs(self, **kwargs) -> pa.Table:
         raise NotImplementedError()
 
-    def _generate_examples(self):
-        for elt in self._generate_examples_with_kwargs(**self.gen_kwargs):
+    def _generate_batches(self):
+        for elt in self._generate_batches_with_kwargs(**self.gen_kwargs):
             yield elt
 
 
@@ -202,9 +194,9 @@ class COCOloader(BaseLoaderWithDLManager):
             "base_image_path": image_folder / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_examples_with_kwargs(
+    def _generate_batches_with_kwargs(
         self, annotation_file: str, base_image_path: Path
-    ):
+    ) -> pa.Table:
         with open(annotation_file, "r", encoding="utf-8") as fi:
             annotations = json.load(fi)
 
@@ -221,20 +213,22 @@ class COCOloader(BaseLoaderWithDLManager):
                 image_id = image_metadata["id"]
                 image_path = base_image_path / f"{image_id:012}.jpg"
                 for annotation in annotations_per_image_id[image_id]:
-                    yield {
-                        "image_url": None,
-                        "image": str(image_path.absolute()),
-                        "texts": [annotation["caption"]],
-                        "source": self.source,
-                        "meta": json.dumps(
-                            {
-                                "image_metadata": image_metadata,
-                                "annotation": annotation,
-                            },
-                            default=json_serializer,
-                            indent=2,
-                        ),
-                    }
+                    yield pa.table(
+                        {
+                            "image_url": None,
+                            "image": str(image_path.absolute()),
+                            "texts": [annotation["caption"]],
+                            "source": self.source,
+                            "meta": json.dumps(
+                                {
+                                    "image_metadata": image_metadata,
+                                    "annotation": annotation,
+                                },
+                                default=json_serializer,
+                                indent=2,
+                            ),
+                        }
+                    )
 
 
 class SBULoader(DatasetsLoader):
@@ -244,24 +238,26 @@ class SBULoader(DatasetsLoader):
             config_name=None,
             split=split,
             batch_size=batch_size,
-            num_proc=1
+            num_proc=1,
         )
 
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
-        meta = {k: v for k, v in row.items() if k not in ["image_url", "caption"]}
-        return [
-            {
-                "image_url": row["image_url"],
-                "image": None,
-                "texts": [row["caption"]],
-                "source": self.source,
-                "meta": json.dumps(
-                    meta,
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {k: v for k, v in batch.items() if k not in ["image_url", "caption"]}
+        batch_size = len(next(iter(batch.values())))
+        return {
+            "image_url": batch["image_url"],
+            "image": [None] * batch_size,
+            "texts": [[caption] for caption in batch["caption"]],
+            "source": [self.source] * batch_size,
+            "meta": [
+                json.dumps(
+                    {key: value[batch_id] for key, value in metas.items()},
                     default=json_serializer,
                     indent=2,
-                ),
-            }
-        ]
+                )
+                for batch_id in range(batch_size)
+            ],
+        }
 
 
 class LocalizedNarrativesOpenImagesLoader(BaseLoaderWithDLManager):
@@ -282,7 +278,7 @@ class LocalizedNarrativesOpenImagesLoader(BaseLoaderWithDLManager):
         annotation_file = dl_manager.download(self._ANNOTATION_URLs[self.split])
         return {"annotation_file": annotation_file, "split": self.split}
 
-    def _generate_examples_with_kwargs(self, annotation_file: str, split: str):
+    def _generate_batches_with_kwargs(self, annotation_file: str, split: str):
         with open(annotation_file, "r", encoding="utf-8") as fi:
             for line in fi:
                 annotation = json.loads(line)
@@ -327,7 +323,7 @@ class LocalizedNarrativesCOCOLoader(BaseLoaderWithDLManager):
             "base_image_path": image_folder / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_examples_with_kwargs(
+    def _generate_batches_with_kwargs(
         self, annotation_file: str, base_image_path: Path
     ):
         with open(annotation_file, "r", encoding="utf-8") as fi:
@@ -389,7 +385,7 @@ class LocalizedNarrativesFlickr30kLoader(BaseLoaderWithDLManager):
             dataset can then be loaded using the following command `datasets.load_dataset("pmd", data_dir="<path/to/folder>")`.
             """
 
-    def _generate_examples_with_kwargs(
+    def _generate_batches_with_kwargs(
         self, annotation_file: str, base_image_path: Path
     ):
         with open(annotation_file, "r", encoding="utf-8") as fi:
@@ -438,7 +434,7 @@ class LocalizedNarrativesADE20kLoader(BaseLoaderWithDLManager):
             "base_image_path": image_base_dir / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_examples_with_kwargs(
+    def _generate_batches_with_kwargs(
         self, annotation_file: str, base_image_path: Path
     ):
         with open(annotation_file, "r", encoding="utf-8") as fi:
@@ -466,18 +462,22 @@ class VisualGenomeLoader(DatasetsLoader):
             config_name="region_descriptions_v1.2.0",
             split=split,
             batch_size=batch_size,
-            num_proc=num_proc
+            num_proc=num_proc,
         )
 
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
-        meta = {k: v for k, v in row.items() if k not in ["image", "regions"]}
-        image = row["image"]
-        # Maybe I need to load this into memory
-        image.load()
-        rows = [
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {k: v for k, v in batch.items() if k not in ["image_url", "caption"]}
+        input_batch_size = len(next(iter(batch.values())))
+        serialized_metas = [
+            json.dumps(
+                {key: value[batch_id] for key, value in metas.items()},
+                default=json_serializer,
+                indent=2,
+            )
+            for batch_id in range(input_batch_size)
+        ]
+        output_list_rows = [
             {
-                "image_url": None,
-                # TODO @thomasw21 I believe this is slow as hell
                 "image": image.crop(
                     (
                         region["x"],
@@ -486,18 +486,20 @@ class VisualGenomeLoader(DatasetsLoader):
                         region["y"] + region["height"],
                     )
                 ),
-                "texts": [region["phrase"]],
+                "image_url": None,
+                "texts": [phrase],
                 "source": self.source,
-                "meta": json.dumps(
-                    meta,
-                    default=json_serializer,
-                    indent=2,
-                ),
+                "meta": serialized_meta,
             }
-            for region in row["regions"]
+            for image, regions, phrase, serialized_meta in zip(
+                batch["image"], batch["regions"], batch["phrase"], serialized_metas
+            )
+            for region in regions
         ]
-        image.close()
-        return rows
+        return {
+            column_name: [row[column_name] for row in output_list_rows]
+            for column_name in ["image_url", "image", "texts", "source", "meta"]
+        }
 
 
 class WITLoader(DatasetsLoader):
@@ -507,32 +509,34 @@ class WITLoader(DatasetsLoader):
             config_name=None,
             split=split,
             batch_size=batch_size,
-            num_proc=1
+            num_proc=1,
         )
 
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
-        meta = {k: v for k, v in row.items() if k not in ["image_url"]}
-        return [
-            {
-                "image_url": row["image_url"],
-                "image": None,
-                "texts": [
-                    row[caption_name]
-                    # TODO @thomasw21 figure out which one we should choose
-                    for caption_name in [
-                        "caption_reference_description",
-                        "context_section_description",
-                        "caption_attribution_description",
-                    ]
-                ],
-                "source": self.source,
-                "meta": json.dumps(
-                    meta,
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {k: v for k, v in batch.items() if k not in ["image_url"]}
+        batch_size = len(next(iter(batch.values())))
+        return {
+            "image_url": batch["image_url"],
+            "image": [None] * batch_size,
+            "texts": [
+                texts
+                # TODO @thomasw21 figure out which one we should choose
+                for texts in zip(
+                    batch["caption_reference_description"],
+                    batch["context_section_description"],
+                    batch["caption_attribution_description"],
+                )
+            ],
+            "source": [self.source] * batch_size,
+            "meta": [
+                json.dumps(
+                    {key: value[batch_id] for key, value in metas.items()},
                     default=json_serializer,
                     indent=2,
-                ),
-            }
-        ]
+                )
+                for batch_id in range(batch_size)
+            ],
+        }
 
 
 class ConceptualCaptions(DatasetsLoader):
@@ -542,24 +546,26 @@ class ConceptualCaptions(DatasetsLoader):
             config_name="unlabeled",
             split=split,
             batch_size=batch_size,
-            num_proc=1
+            num_proc=1,
         )
 
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
-        meta = {k: v for k, v in row.items() if k not in ["image_url", "caption"]}
-        return [
-            {
-                "image_url": row["image_url"],
-                "image": None,
-                "texts": [row["caption"]],
-                "source": self.source,
-                "meta": json.dumps(
-                    meta,
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {k: v for k, v in batch.items() if k not in ["image_url", "caption"]}
+        batch_size = len(next(iter(batch.values())))
+        return {
+            "image_url": batch["image_url"],
+            "image": [None] * batch_size,
+            "texts": [[caption] for caption in batch["caption"]],
+            "source": [self.source] * batch_size,
+            "meta": [
+                json.dumps(
+                    {key: value[batch_id] for key, value in metas.items()},
                     default=json_serializer,
                     indent=2,
-                ),
-            }
-        ]
+                )
+                for batch_id in range(batch_size)
+            ],
+        }
 
 
 class Conceptual12MLoader(DatasetsLoader):
@@ -569,24 +575,26 @@ class Conceptual12MLoader(DatasetsLoader):
             config_name=None,
             split=split,
             batch_size=batch_size,
-            num_proc=1
+            num_proc=1,
         )
 
-    def cast_to_pmd_features(self, row):
-        meta = {k: v for k, v in row.items() if k not in ["image_url", "caption"]}
-        return [
-            {
-                "image_url": row["image_url"],
-                "image": None,
-                "texts": [row["caption"]],
-                "source": self.source,
-                "meta": json.dumps(
-                    meta,
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {k: v for k, v in batch.items() if k not in ["image_url", "caption"]}
+        batch_size = len(next(iter(batch.values())))
+        return {
+            "image_url": batch["image_url"],
+            "image": [None] * batch_size,
+            "texts": [[caption] for caption in batch["caption"]],
+            "source": [self.source] * batch_size,
+            "meta": [
+                json.dumps(
+                    {key: value[batch_id] for key, value in metas.items()},
                     default=json_serializer,
                     indent=2,
-                ),
-            }
-        ]
+                )
+                for batch_id in range(batch_size)
+            ],
+        }
 
 
 class RedCapsLoader(DatasetsLoader):
@@ -596,25 +604,28 @@ class RedCapsLoader(DatasetsLoader):
             config_name="all",
             split=split,
             batch_size=batch_size,
-            num_proc=1
+            num_proc=1,
         )
 
-    def cast_to_pmd_features(self, row: Dict) -> List[Dict[str, Any]]:
-        meta = {k: v for k, v in row.items() if k not in ["image_url", "raw_caption"]}
-        return [
-            {
-                "image_url": row["image_url"],
-                "image": None,
-                # TODO @thomasw21
-                "texts": [row["raw_caption"]],
-                "source": self.source,
-                "meta": json.dumps(
-                    meta,
+    def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
+        metas = {
+            k: v for k, v in batch.items() if k not in ["image_url", "raw_caption"]
+        }
+        batch_size = len(next(iter(batch.values())))
+        return {
+            "image_url": batch["image_url"],
+            "image": [None] * batch_size,
+            "texts": [[caption] for caption in batch["raw_caption"]],
+            "source": [self.source] * batch_size,
+            "meta": [
+                json.dumps(
+                    {key: value[batch_id] for key, value in metas.items()},
                     default=json_serializer,
                     indent=2,
-                ),
-            }
-        ]
+                )
+                for batch_id in range(batch_size)
+            ],
+        }
 
 
 class YFCC100MLoader(BaseLoaderWithDLManager):
@@ -717,7 +728,7 @@ class YFCC100MLoader(BaseLoaderWithDLManager):
                 break
         return record_text
 
-    def _generate_examples_with_kwargs(self, sql_file: str):
+    def _generate_batches_with_kwargs(self, sql_file: str):
         # query records command
         sql_command = f"select {', '.join(self._COLUMNS)} from yfcc100m_dataset"
 
@@ -792,7 +803,8 @@ class PMDConfig(datasets.BuilderConfig):
         self.num_proc = num_proc
 
 
-class PMD(datasets.GeneratorBasedBuilder):
+# TODO @thomasw21 ArrowBasedBuilder to be able to return batches
+class PMD(datasets.ArrowBasedBuilder):
     """Builder for Open Images subset of PMD."""
 
     BUILDER_CONFIG_CLASS = PMDConfig
@@ -836,7 +848,7 @@ class PMD(datasets.GeneratorBasedBuilder):
                         VisualGenomeLoader(
                             split=split_name,
                             batch_size=self.config.datasets_batch_size,
-                            num_proc=self.config.num_proc
+                            num_proc=self.config.num_proc,
                         ),
                         # WITLoader(
                         #     split=split_name,
@@ -861,9 +873,9 @@ class PMD(datasets.GeneratorBasedBuilder):
             for split_name in [datasets.Split.TRAIN]
         ]
 
-    def _generate_examples(self, loaders: List[BaseLoader]):
+    def _generate_tables(self, loaders: List[BaseLoader]):
         idx = 0
         for loader in loaders:
-            for elt in loader._generate_examples():
+            for elt in loader._generate_batches():
                 yield idx, elt
                 idx += 1