Run everything in parallel except sqlite3

pmd.py

@@ -12,6 +12,7 @@
 # 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.
+import itertools
 import json
 import re
 import sqlite3
@@ -20,7 +21,7 @@ from functools import partial
 from hashlib import md5
 from multiprocessing import Pool
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Iterator
 import pyarrow as pa
 
 from datetime import datetime
@@ -65,13 +66,10 @@ def json_serializer(o):
 
 
 class BaseLoader:
-    def __init__(
-        self,
-        source: str,
-        split: str,
-    ):
+    def __init__(self, source: str, split: str, writer_batch_size: int):
         self.source = source
         self.split = split
+        self.writer_batch_size = writer_batch_size
 
     @abstractmethod
     def _generate_batches(self):
@@ -87,35 +85,25 @@ class DatasetsLoader(BaseLoader):
         config_name: Optional[str],
         split: str,
         num_proc: int,
-        batch_size: int = 1000,
+        datasets_batch_size: int = 1000,
     ):
-        super(DatasetsLoader, self).__init__(source=dataset_name, split=split)
+        # TODO @thomasw21 do we somehow want to de-correlate both writer and datasets batch_size
+        super(DatasetsLoader, self).__init__(
+            source=dataset_name, split=split, writer_batch_size=datasets_batch_size
+        )
         self.dataset_name = dataset_name
         self.config_name = config_name
         self.num_proc = 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
-
-        self.batch_size_per_proc = batch_size
+        self.datasets_batch_size = datasets_batch_size
 
     @abstractmethod
     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 _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_end = min(batch_start + self.datasets_batch_size, dataset_size)
         batch = dset[batch_start:batch_end]
         output_batch = self.cast_to_pmd_features(batch)
         return pa.table(_FEATURES.encode_batch(output_batch))
@@ -126,7 +114,7 @@ class DatasetsLoader(BaseLoader):
 
         # load batches and yield individual rows
         if self.num_proc == 1:
-            for batch_start in range(0, dataset_size, self.batch_size_per_proc):
+            for batch_start in range(0, dataset_size, self.datasets_batch_size):
                 batch_casted_pmd_features = self._generate_batch_table(
                     dset=dataset, batch_start=batch_start
                 )
@@ -139,7 +127,7 @@ class DatasetsLoader(BaseLoader):
                 # 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),
+                    range(0, dataset_size, self.datasets_batch_size),
                 )
                 for batch_casted_pmd_features in batch_iterator:
                     yield batch_casted_pmd_features
@@ -148,21 +136,49 @@ class DatasetsLoader(BaseLoader):
 class BaseLoaderWithDLManager(BaseLoader):
     """We use dl_manager to generate `gen_kwargs` needed in order to generate examples."""
 
-    def __init__(self, dl_manager, source: str, split: str):
-        super(BaseLoaderWithDLManager, self).__init__(source=source, split=split)
+    def __init__(
+        self,
+        dl_manager,
+        source: str,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int = 10_000,
+    ):
+        super(BaseLoaderWithDLManager, self).__init__(
+            source=source, split=split, writer_batch_size=writer_batch_size
+        )
         self.gen_kwargs = self.generate_gen_kwargs(dl_manager)
+        # Used for multiprocessing
+        self.chunk_size = chunk_size
+        self.num_proc = num_proc
 
     @abstractmethod
     def generate_gen_kwargs(self, dl_manager):
         raise NotImplementedError()
 
     @abstractmethod
-    def _generate_examples_with_kwargs(self, **kwargs) -> pa.Table:
+    def _build_rows_iterator(self, chunk_size: int, **kwargs) -> Iterator[List[Any]]:
         raise NotImplementedError()
 
+    @abstractmethod
+    def _generate_examples(self, examples: List[Any], **kwargs) -> Dict[str, List[Any]]:
+        raise NotImplementedError
+
+    def _generate_tables(self, batch: Dict[str, List[Any]]) -> pa.Table:
+        return pa.table(_FEATURES.encode_batch(batch))
+
     def _generate_batches(self):
-        for elt in self._generate_batches_with_kwargs(**self.gen_kwargs):
-            yield elt
+        rows_iterator = self._build_rows_iterator(self.chunk_size, **self.gen_kwargs)
+
+        with Pool(self.num_proc) as pool:
+            tables_iterator = pool.imap(
+                partial(self._generate_tables, **self.gen_kwargs),
+                rows_iterator,
+                chunksize=1,
+            )
+            for table in tables_iterator:
+                yield table
 
 
 class COCOloader(BaseLoaderWithDLManager):
@@ -176,9 +192,21 @@ class COCOloader(BaseLoaderWithDLManager):
     }
     _SPLIT_MAP = {"train": "train2017", "validation": "val207"}
 
-    def __init__(self, dl_manager, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(COCOloader, self).__init__(
-            dl_manager=dl_manager, source="coco", split=split
+            dl_manager=dl_manager,
+            source="coco",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
 
     def generate_gen_kwargs(self, dl_manager):
@@ -195,9 +223,7 @@ class COCOloader(BaseLoaderWithDLManager):
             "base_image_path": image_folder / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_batches_with_kwargs(
-        self, annotation_file: str, base_image_path: Path
-    ) -> pa.Table:
+    def _build_rows_iterator(self, chunk_size: int, annotation_file: str, base_image_path: Path) -> Iterator[List[Any]]:
         with open(annotation_file, "r", encoding="utf-8") as fi:
             annotations = json.load(fi)
 
@@ -210,36 +236,41 @@ class COCOloader(BaseLoaderWithDLManager):
                 else:
                     annotations_per_image_id[image_id] = [annotation]
 
+            # yield chunks
+            buffer = []
             for image_metadata in annotations["images"]:
                 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 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,
-                            ),
-                        }
-                    )
+                    buffer.append({
+                        "annotation": annotation,
+                        "image_metadata": image_metadata
+                    })
+                    if len(buffer) == chunk_size:
+                        yield buffer
+                        buffer = []
+
+    def _generate_examples(self, examples: List[Any], annotation_file: str, base_image_path: Path) -> Dict[str, List[Any]]:
+        return {
+            "image_url": [None for _ in examples],
+            "image": [str((base_image_path / f"{example['image_metadata']['id']:012}.jpg").absolute()) for example in examples],
+            "texts": [example["annotation"]["caption"] for example in examples],
+            "source": [self.source for _ in examples],
+            "meta": [json.dumps(
+                example,
+                default=json_serializer,
+                indent=2,
+            ) for example in examples],
+        }
 
 
 class SBULoader(DatasetsLoader):
-    def __init__(self, split: str, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(SBULoader, self).__init__(
             dataset_name="sbu_captions",
             config_name=None,
             split=split,
-            batch_size=batch_size,
-            num_proc=1,
+            datasets_batch_size=datasets_batch_size,
+            num_proc=num_proc,
         )
 
     def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
@@ -270,31 +301,56 @@ class LocalizedNarrativesOpenImagesLoader(BaseLoaderWithDLManager):
         "test": "https://storage.googleapis.com/localized-narratives/annotations/open_images_test_captions.jsonl",
     }
 
-    def __init__(self, dl_manager, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(LocalizedNarrativesOpenImagesLoader, self).__init__(
-            dl_manager=dl_manager, source="localized_narratives__coco", split=split
+            dl_manager=dl_manager,
+            source="localized_narratives__coco",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
 
     def generate_gen_kwargs(self, dl_manager):
         annotation_file = dl_manager.download(self._ANNOTATION_URLs[self.split])
         return {"annotation_file": annotation_file, "split": self.split}
 
-    def _generate_batches_with_kwargs(self, annotation_file: str, split: str):
+    def _build_rows_iterator(self, chunk_size: int, annotation_file: str, split: str) -> Iterator[List[Any]]:
         with open(annotation_file, "r", encoding="utf-8") as fi:
-            for line in fi:
-                annotation = json.loads(line)
-                assert "image_url" not in annotation
-                yield {
-                    "image_url": f"https://s3.amazonaws.com/open-images-dataset/{split}/{annotation['image_id']}.jpg",
-                    "image": None,
-                    "texts": [annotation["caption"]],
-                    "source": self.source,
-                    "meta": json.dumps(
-                        annotation,
-                        default=json_serializer,
-                        indent=2,
-                    ),
-                }
+            chunk = itertools.islice(fi, chunk_size)
+
+            try:
+                chunk = next(chunk)
+            except StopIteration:
+                return
+
+            yield chunk
+
+    def _generate_examples(self, examples: List[Any], annotation_file: str, split: str) -> Dict[str, List[Any]]:
+        annotations = [json.loads(line) for line in examples]
+
+        # sanity check
+        for annotation in annotations:
+            assert "image_url" not in annotation
+
+        return {
+            "image_url": [f"https://s3.amazonaws.com/open-images-dataset/{split}/{annotation['image_id']}.jpg" for annotation in annotations],
+            "image": [None for _ in annotations],
+            "texts": [[annotation["caption"]] for annotation in annotations],
+            "source": [self.source for _ in annotations],
+            "meta": [json.dumps(
+                annotation,
+                default=json_serializer,
+                indent=2,
+            ) for annotation in annotations],
+        }
 
 
 class LocalizedNarrativesCOCOLoader(BaseLoaderWithDLManager):
@@ -309,9 +365,21 @@ class LocalizedNarrativesCOCOLoader(BaseLoaderWithDLManager):
     }
     _SPLIT_MAP = {"train": "train2017", "validation": "val207"}
 
-    def __init__(self, dl_manager, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(LocalizedNarrativesCOCOLoader, self).__init__(
-            dl_manager=dl_manager, source="localized_narratives__coco", split=split
+            dl_manager=dl_manager,
+            source="localized_narratives__coco",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
 
     def generate_gen_kwargs(self, dl_manager):
@@ -324,26 +392,31 @@ class LocalizedNarrativesCOCOLoader(BaseLoaderWithDLManager):
             "base_image_path": image_folder / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_batches_with_kwargs(
-        self, annotation_file: str, base_image_path: Path
-    ):
+    def _build_rows_iterator(self, chunk_size: int, annotation_file: str, base_image_path: Path) -> Iterator[List[Any]]:
         with open(annotation_file, "r", encoding="utf-8") as fi:
-            for line in fi:
-                annotation = json.loads(line)
-                assert "image_url" not in annotation
-                image_path = base_image_path / f"{annotation['image_id'].zfill(12)}.jpg"
-                yield {
-                    "image_url": None,
-                    "image": str(image_path.absolute()),
-                    "texts": [annotation["caption"]],
-                    "source": self.source,
-                    "meta": json.dumps(
-                        annotation,
-                        default=json_serializer,
-                        indent=2,
-                    ),
-                }
+            chunk = itertools.islice(fi, chunk_size)
+
+            try:
+                chunk = next(chunk)
+            except StopIteration:
+                return
+
+            yield chunk
 
+    def _generate_examples(self, examples: List[Any], annotation_file: str, base_image_path: Path) -> Dict[str, List[Any]]:
+        annotations = [json.loads(line) for line in examples]
+
+        return {
+            "image_url": [None for _ in examples],
+            "image": [str((base_image_path / f"{annotation['image_id'].zfill(12)}.jpg").absolute()) for annotation in annotations],
+            "texts": [[annotation["caption"]] for annotation in annotations],
+            "source": [self.source for _ in annotations],
+            "meta": [json.dumps(
+                annotation,
+                default=json_serializer,
+                indent=2,
+            ) for annotation in annotations],
+        }
 
 class LocalizedNarrativesFlickr30kLoader(BaseLoaderWithDLManager):
     _LOCAL_IMAGE_FOLDER_NAME = "flickr30k-images"
@@ -353,9 +426,21 @@ class LocalizedNarrativesFlickr30kLoader(BaseLoaderWithDLManager):
         "test": "https://storage.googleapis.com/localized-narratives/annotations/flickr30k_test_captions.jsonl",
     }
 
-    def __init__(self, dl_manager, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(LocalizedNarrativesFlickr30kLoader, self).__init__(
-            dl_manager=dl_manager, source="localized_narratives__flickr30k", split=split
+            dl_manager=dl_manager,
+            source="localized_narratives__flickr30k",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
 
     def generate_gen_kwargs(self, dl_manager):
@@ -386,25 +471,33 @@ class LocalizedNarrativesFlickr30kLoader(BaseLoaderWithDLManager):
             dataset can then be loaded using the following command `datasets.load_dataset("pmd", data_dir="<path/to/folder>")`.
             """
 
-    def _generate_batches_with_kwargs(
-        self, annotation_file: str, base_image_path: Path
-    ):
+    def _build_rows_iterator(self, chunk_size: int, annotation_file: str, base_image_path: Path) -> Iterator[List[Any]]:
         with open(annotation_file, "r", encoding="utf-8") as fi:
-            for line in fi:
-                annotation = json.loads(line)
-                assert "image" not in annotation
-                image_path = base_image_path / f"{annotation['image_id']}.jpg"
-                yield {
-                    "image_url": None,
-                    "image": str(image_path.absolute()),
-                    "texts": [annotation["caption"]],
-                    "source": self.source,
-                    "meta": json.dumps(
-                        annotation,
-                        default=json_serializer,
-                        indent=2,
-                    ),
-                }
+            chunk = itertools.islice(fi, chunk_size)
+
+            try:
+                chunk = next(chunk)
+            except StopIteration:
+                return
+
+            yield chunk
+
+    def _generate_examples(self, examples: List[Any], annotation_file: str, base_image_path: Path) -> Dict[
+        str, List[Any]]:
+        annotations = [json.loads(line) for line in examples]
+
+        return {
+            "image_url": [None for _ in examples],
+            "image": [str((base_image_path / f"{annotation['image_id']}.jpg").absolute()) for annotation in
+                      annotations],
+            "texts": [[annotation["caption"]] for annotation in annotations],
+            "source": [self.source for _ in annotations],
+            "meta": [json.dumps(
+                annotation,
+                default=json_serializer,
+                indent=2,
+            ) for annotation in annotations],
+        }
 
 
 class LocalizedNarrativesADE20kLoader(BaseLoaderWithDLManager):
@@ -417,9 +510,21 @@ class LocalizedNarrativesADE20kLoader(BaseLoaderWithDLManager):
     )
     _SPLIT_MAP = {"train": "training", "validation": "validation"}
 
-    def __init__(self, dl_manager, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(LocalizedNarrativesADE20kLoader, self).__init__(
-            dl_manager=dl_manager, source="localized_narratives__ADE20k", split=split
+            dl_manager=dl_manager,
+            source="localized_narratives__ADE20k",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
 
     def generate_gen_kwargs(self, dl_manager):
@@ -435,34 +540,39 @@ class LocalizedNarrativesADE20kLoader(BaseLoaderWithDLManager):
             "base_image_path": image_base_dir / self._SPLIT_MAP[self.split],
         }
 
-    def _generate_batches_with_kwargs(
-        self, annotation_file: str, base_image_path: Path
-    ):
+    def _build_rows_iterator(self, annotation_file: str, base_image_path: Path, chunk_size: int) -> Iterator[List[Any]]:
         with open(annotation_file, "r", encoding="utf-8") as fi:
-            for line in fi:
-                annotation = json.loads(line)
-                assert "image" not in annotation
-                image_path = base_image_path / f"{annotation['image_id']}.jpg"
-                yield {
-                    "image_url": None,
-                    "image": str(image_path.absolute()),
-                    "texts": [annotation["caption"]],
-                    "source": self.source,
-                    "meta": json.dumps(
-                        annotation,
-                        default=json_serializer,
-                        indent=2,
-                    ),
-                }
+            chunk = itertools.islice(fi, chunk_size)
+
+            try:
+                chunk = next(chunk)
+            except StopIteration:
+                return
+
+            yield chunk
+
+    def _generate_examples(self, examples: List[Any], annotation_file: str, base_image_path: Path) -> Dict[str, Any]:
+        annotations = [json.loads(line) for line in examples]
+        return {
+            "image_url": [None for _ in examples],
+            "image": [str((base_image_path / f"{annotation['image_id']}.jpg").absolute()) for annotation in annotations],
+            "texts": [annotation["caption"] for annotation in annotations],
+            "source": [self.source for _ in examples],
+            "meta": [json.dumps(
+                annotation,
+                default=json_serializer,
+                indent=2,
+            ) for annotation in annotations],
+        }
 
 
 class VisualGenomeLoader(DatasetsLoader):
-    def __init__(self, split: str, num_proc: int, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(VisualGenomeLoader, self).__init__(
             dataset_name="visual_genome",
             config_name="region_descriptions_v1.2.0",
             split=split,
-            batch_size=batch_size,
+            datasets_batch_size=datasets_batch_size,
             num_proc=num_proc,
         )
 
@@ -504,13 +614,13 @@ class VisualGenomeLoader(DatasetsLoader):
 
 
 class WITLoader(DatasetsLoader):
-    def __init__(self, split: str, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(WITLoader, self).__init__(
             dataset_name="google/wit",
             config_name=None,
             split=split,
-            batch_size=batch_size,
-            num_proc=1,
+            datasets_batch_size=datasets_batch_size,
+            num_proc=num_proc,
         )
 
     def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
@@ -541,13 +651,13 @@ class WITLoader(DatasetsLoader):
 
 
 class ConceptualCaptions(DatasetsLoader):
-    def __init__(self, split: str, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(ConceptualCaptions, self).__init__(
             dataset_name="conceptual_captions",
             config_name="unlabeled",
             split=split,
-            batch_size=batch_size,
-            num_proc=1,
+            datasets_batch_size=datasets_batch_size,
+            num_proc=num_proc,
         )
 
     def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
@@ -570,13 +680,13 @@ class ConceptualCaptions(DatasetsLoader):
 
 
 class Conceptual12MLoader(DatasetsLoader):
-    def __init__(self, split: str, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(Conceptual12MLoader, self).__init__(
             dataset_name="conceptual_12m",
             config_name=None,
             split=split,
-            batch_size=batch_size,
-            num_proc=1,
+            datasets_batch_size=datasets_batch_size,
+            num_proc=num_proc,
         )
 
     def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
@@ -599,13 +709,13 @@ class Conceptual12MLoader(DatasetsLoader):
 
 
 class RedCapsLoader(DatasetsLoader):
-    def __init__(self, split: str, batch_size: int = 1000):
+    def __init__(self, split: str, num_proc: int, datasets_batch_size: int = 1000):
         super(RedCapsLoader, self).__init__(
             dataset_name="red_caps",
             config_name="all",
             split=split,
-            batch_size=batch_size,
-            num_proc=1,
+            datasets_batch_size=datasets_batch_size,
+            num_proc=num_proc,
         )
 
     def cast_to_pmd_features(self, batch: Dict[str, List[Any]]) -> Dict[str, List[Any]]:
@@ -656,11 +766,23 @@ class YFCC100MLoader(BaseLoaderWithDLManager):
     WEIRD_CHARACTERS_REGEX = re.compile(r"[_©]")
     SECOND_WORD_REGEX = re.compile(r" [a-zA-Z]+")
 
-    def __init__(self, dl_manager, batch_size: int, split: str):
+    def __init__(
+        self,
+        dl_manager,
+        split: str,
+        num_proc: int,
+        chunk_size: int,
+        writer_batch_size: int,
+    ):
         super(YFCC100MLoader, self).__init__(
-            dl_manager=dl_manager, source="yfcc100m", split=split
+            dl_manager=dl_manager,
+            source="yfcc100m",
+            split=split,
+            num_proc=num_proc,
+            chunk_size=chunk_size,
+            writer_batch_size=writer_batch_size,
         )
-        self.batch_size = batch_size
+        self.chunk_size = chunk_size
 
     # Code from https://gitlab.com/jfolz/yfcc100m/-/blob/master/yfcc100m/convert_metadata.py
     BYTE_MAP = {"%02x" % v: "%x" % v for v in range(256)}
@@ -729,7 +851,7 @@ class YFCC100MLoader(BaseLoaderWithDLManager):
                 break
         return record_text
 
-    def _generate_batches_with_kwargs(self, sql_file: str):
+    def _build_rows_iterator(self, sql_file: str, chunk_size: int) -> Iterator[List[Any]]:
         # query records command
         sql_command = f"select {', '.join(self._COLUMNS)} from yfcc100m_dataset"
 
@@ -742,45 +864,57 @@ class YFCC100MLoader(BaseLoaderWithDLManager):
             # Get data in batches
             while True:
                 # Read the data
-                records = cursor.fetchmany(self.batch_size)
+                records = cursor.fetchmany(self.chunk_size)
 
                 # If we are at the end
                 if len(records) == 0:
                     break
 
-                # Format data
-                for record in records:
-                    annotation = {
-                        column_name: value
-                        for value, column_name in zip(record, self._COLUMNS)
-                    }
-
-                    # TODO @thomasw21 if it's not an image we don't care for now
-                    if annotation["marker"] != 0:
-                        continue
-
-                    # We compute text candidate and skip the row if None work.
-                    text = self.get_associated_text(annotation)
-                    if text is None:
-                        continue
-
-                    for text_column in self._TEXT_COLUMNS:
-                        annotation[text_column] = unquote_plus(annotation[text_column])
-
-                    yield {
-                        # Add image_url that we download from s3 bucket instead of official download url
-                        "image_url": self.generate_image_url(annotation["downloadurl"]),
-                        "image": None,
-                        "texts": [text],
-                        "source": self.source,
-                        "meta": json.dumps(
-                            annotation,
-                            default=json_serializer,
-                            indent=2,
-                        ),
-                    }
+                yield records
+
             cursor.close()
 
+    def _generate_examples(self, examples: List[Any], sql_file: str) -> Dict[str, Any]:
+        buffer = {}
+        # Format data
+        for example in examples:
+            annotation = {
+                column_name: value
+                for value, column_name in zip(example, self._COLUMNS)
+            }
+
+            # TODO @thomasw21 if it's not an image we don't care for now
+            if annotation["marker"] != 0:
+                continue
+
+            # We compute text candidate and skip the row if None work.
+            text = self.get_associated_text(annotation)
+            if text is None:
+                continue
+
+            for text_column in self._TEXT_COLUMNS:
+                annotation[text_column] = unquote_plus(annotation[text_column])
+
+            # add data to buffer
+            temp_object = {
+                # Add image_url that we download from s3 bucket instead of official download url
+                "image_url": [self.generate_image_url(annotation["downloadurl"])],
+                "image": [None],
+                "texts": [[text]],
+                "source": [self.source],
+                "meta": [json.dumps(
+                    annotation,
+                    default=json_serializer,
+                    indent=2,
+                )],
+            }
+            if len(buffer) == 0:
+                buffer = temp_object
+            else:
+                for column_name in buffer.keys():
+                    buffer[column_name].append(temp_object[column_name])
+        return buffer
+
 
 class PMDConfig(datasets.BuilderConfig):
     """BuilderConfig for PMD."""
@@ -790,6 +924,8 @@ class PMDConfig(datasets.BuilderConfig):
         num_proc: Optional[int] = None,
         datasets_batch_size: int = 1000,
         sqlite3_batch_size: int = 10_000,
+        chunk_size: int = 10_000,
+        writer_batch_size: int = 10_000,
         **kwargs,
     ):
         if num_proc is None:
@@ -802,6 +938,10 @@ class PMDConfig(datasets.BuilderConfig):
 
         # Some datasets should be loaded via multiprocessing.
         self.num_proc = num_proc
+        self.chunk_size = chunk_size
+
+        # Batch writing
+        self.writer_batch_size = writer_batch_size
 
 
 # TODO @thomasw21 ArrowBasedBuilder to be able to return batches
@@ -825,49 +965,78 @@ class PMD(datasets.ArrowBasedBuilder):
                 name=split_name,
                 gen_kwargs={
                     "loaders": [
-                        # COCOloader(dl_manager=dl_manager, split=split_name),
-                        # SBULoader(
-                        #     split=split_name,
-                        #     batch_size=self.config.datasets_batch_size,
-                        # ),
-                        # LocalizedNarrativesOpenImagesLoader(
-                        #     dl_manager=dl_manager, split=split_name
-                        # ),
-                        # LocalizedNarrativesCOCOLoader(
-                        #     dl_manager=dl_manager, split=split_name
-                        # ),
-                        # LocalizedNarrativesFlickr30kLoader(
-                        #     dl_manager=dl_manager, split=split_name
-                        # ),
-                        # LocalizedNarrativesADE20kLoader(
-                        #     dl_manager=dl_manager, split=split_name
-                        # ),
-                        # ConceptualCaptions(
-                        #     split=split_name,
-                        #     batch_size=self.config.datasets_batch_size,
-                        # ),
+                        COCOloader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.chunk_size,
+                            writer_batch_size=self.config.writer_batch_size,
+                        ),
+                        SBULoader(
+                            split=split_name,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                            num_proc=self.config.num_proc,
+                        ),
+                        LocalizedNarrativesOpenImagesLoader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.chunk_size,
+                            writer_batch_size=self.config.writer_batch_size,
+                        ),
+                        LocalizedNarrativesCOCOLoader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.chunk_size,
+                            writer_batch_size=self.config.writer_batch_size,
+                        ),
+                        LocalizedNarrativesFlickr30kLoader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.chunk_size,
+                            writer_batch_size=self.config.writer_batch_size,
+                        ),
+                        LocalizedNarrativesADE20kLoader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.chunk_size,
+                            writer_batch_size=self.config.writer_batch_size,
+                        ),
+                        ConceptualCaptions(
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                        ),
                         VisualGenomeLoader(
                             split=split_name,
-                            batch_size=self.config.datasets_batch_size,
                             num_proc=self.config.num_proc,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                        ),
+                        WITLoader(
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                        ),
+                        Conceptual12MLoader(
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                        ),
+                        RedCapsLoader(
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            datasets_batch_size=self.config.datasets_batch_size,
+                        ),
+                        YFCC100MLoader(
+                            dl_manager=dl_manager,
+                            split=split_name,
+                            num_proc=self.config.num_proc,
+                            chunk_size=self.config.sqlite3_batch_size,
+                            writer_batch_size=self.config.writer_batch_size,
                         ),
-                        # WITLoader(
-                        #     split=split_name,
-                        #     batch_size=self.config.datasets_batch_size,
-                        # ),
-                        # Conceptual12MLoader(
-                        #     split=split_name,
-                        #     batch_size=self.config.datasets_batch_size,
-                        # ),
-                        # RedCapsLoader(
-                        #     split=split_name,
-                        #     batch_size=self.config.datasets_batch_size,
-                        # ),
-                        # YFCC100MLoader(
-                        #     dl_manager=dl_manager,
-                        #     split=split_name,
-                        #     batch_size=self.config.sqlite3_batch_size,
-                        # ),
                     ]
                 },
             )