Upload README.md with huggingface_hub

README.md

@@ -1,13 +1,18 @@
 ---
+license: apache-2.0
 language:
 - fr
-license: apache-2.0
 multilinguality:
 - monolingual
-size_categories:
-- 1K<n<10K
+tags:
+- finetuning
+- legal
+- french law
+- droit français
+- Code de l'urbanisme
 source_datasets:
 - original
+pretty_name: Code de l'urbanisme
 task_categories:
 - text-generation
 - table-question-answering
@@ -15,40 +20,10 @@ task_categories:
 - text-retrieval
 - question-answering
 - text-classification
-pretty_name: Code de l'urbanisme
-tags:
-- finetuning
-- legal
-- french law
-- droit français
-- Code de l'urbanisme
-dataset_info:
-  features:
-  - name: instruction
-    dtype: string
-  - name: input
-    dtype: string
-  - name: output
-    dtype: string
-  - name: start
-    dtype: string
-  - name: expiration
-    dtype: string
-  - name: num
-    dtype: string
-  splits:
-  - name: train
-    num_bytes: 2181312
-    num_examples: 2382
-  download_size: 784883
-  dataset_size: 2181312
-configs:
-- config_name: default
-  data_files:
-  - split: train
-    path: data/train-*
+size_categories:
+- 1K<n<10K
 ---
-# Code de l'urbanisme, non-instruct (2024-03-27)
+# Code de l'urbanisme, non-instruct (2024-04-01)
 
 This project focuses on fine-tuning pre-trained language models to create efficient and accurate models for legal practice. 
 
@@ -64,6 +39,120 @@ Instruction-based fine-tuning significantly enhances the performance of LLMs in
 - Interpretability: Instruction-based fine-tuning also makes LLM behavior more interpretable. Since the instructions are human-readable, it becomes easier to understand and control model outputs.
 - Adaptive Behavior: LLMs, post instruction-based fine-tuning, exhibit adaptive behavior that is responsive to both explicit task descriptions and implicit cues within the provided text.
 
+## Concurrent reading of the LegalKit
+
+To use all the legal data published on LegalKit, you can use this code snippet:
+```python
+# -*- coding: utf-8 -*-
+import concurrent.futures
+import os
+
+import datasets
+from tqdm.notebook import tqdm
+
+def dataset_loader(
+    name:str,
+    streaming:bool=True
+) -> datasets.Dataset:
+    """
+    Helper function to load a single dataset in parallel.
+
+    Parameters
+    ----------
+    name : str
+        Name of the dataset to be loaded.
+
+    streaming : bool, optional
+        Determines if datasets are streamed. Default is True.
+
+    Returns
+    -------
+    dataset : datasets.Dataset
+        Loaded dataset object.
+
+    Raises
+    ------
+    Exception
+        If an error occurs during dataset loading.
+    """
+    try:
+        return datasets.load_dataset(
+            name,
+            split="train",
+            streaming=streaming
+        )
+
+    except Exception as exc:
+        logging.error(f"Error loading dataset {name}: {exc}")
+
+        return None
+
+
+def load_datasets(
+    req:list,
+    streaming:bool=True
+) -> list:
+    """
+    Downloads datasets specified in a list and creates a list of loaded datasets.
+
+    Parameters
+    ----------
+    req : list
+        A list containing the names of datasets to be downloaded.
+
+    streaming : bool, optional
+        Determines if datasets are streamed. Default is True.
+
+    Returns
+    -------
+    datasets_list : list
+        A list containing loaded datasets as per the requested names provided in 'req'.
+
+    Raises
+    ------
+    Exception
+        If an error occurs during dataset loading or processing.
+
+    Examples
+    --------
+    >>> datasets = load_datasets(["dataset1", "dataset2"], streaming=False)
+    """
+    datasets_list = []
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        future_to_dataset = {executor.submit(dataset_loader, name): name for name in req}
+
+        for future in tqdm(concurrent.futures.as_completed(future_to_dataset), total=len(req)):
+            name = future_to_dataset[future]
+
+            try:
+                dataset = future.result()
+
+                if dataset:
+                    datasets_list.append(dataset)
+
+            except Exception as exc:
+                logging.error(f"Error processing dataset {name}: {exc}")
+
+    return datasets_list
+
+
+req = [
+    "louisbrulenaudet/code-artisanat",
+    "louisbrulenaudet/code-action-sociale-familles",
+    # ...
+]
+
+datasets_list = load_datasets(
+    req=req,
+    streaming=True
+)
+
+dataset = datasets.concatenate_datasets(
+    datasets_list
+)
+```
+
 ## Dataset generation
 
 This JSON file is a list of dictionaries, each dictionary contains the following fields: