|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import logging |
|
|
import json |
|
|
import os |
|
|
import numpy as np |
|
|
from torch.utils.data import Dataset, DataLoader |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
class TokenizedSegmentationDataset(Dataset): |
|
|
def __init__( |
|
|
self, |
|
|
tokenized_dataset: str, |
|
|
logger: logging.Logger = None, |
|
|
percentage: float = 1.0, |
|
|
return_type: type = dict |
|
|
): |
|
|
""" |
|
|
A tokoenized segmentation dataset takes a huggingface dataset or a path to a dataset on disk with the |
|
|
wikipedia-segmentation format. It loads the dataset and prepares it for training. |
|
|
|
|
|
Wikipedia-segmentation format: |
|
|
- The dataset is expected to be a huggingface dataset or a path to a dataset on disk. |
|
|
- The dataset should contain the following fields: |
|
|
>>> sample = { |
|
|
>>> 'text': ['Article 1', 'Article 2', ...], |
|
|
>>> 'titles': ['Title 1', 'Title 2', ...], |
|
|
>>> 'id': str, |
|
|
>>> 'words': int |
|
|
>>> 'paragraphs': int |
|
|
>>> 'sentences': int |
|
|
>>> } |
|
|
- The dataset should be a list of dictionaries, where each dictionary contains the fields above. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
tokenized_dataset : str |
|
|
A path to a tokenized dataset on disk with the wikipedia-segmentation format. |
|
|
|
|
|
logger : logging.Logger, optional |
|
|
Logger instance. If not provided, a null logger will be used. |
|
|
|
|
|
percentage : float |
|
|
Percentage of the dataset to use. Default is 1.0 (100%). |
|
|
|
|
|
return_type : type |
|
|
The return type of __getitem__, either dict or tuple. Default is dict. |
|
|
|
|
|
Raises |
|
|
------ |
|
|
ValueError |
|
|
If the huggingface_dataset is not a string or a HfDataset. |
|
|
ValueError |
|
|
If the tokenizer is not a callable function or class. |
|
|
ValueError |
|
|
If the sentence_tokenizer is not a callable function or class. |
|
|
ValueError |
|
|
If the dtype is not a type. |
|
|
|
|
|
""" |
|
|
|
|
|
if not isinstance(logger, logging.Logger): |
|
|
self.logger = logging.getLogger("null") |
|
|
self.logger.addHandler(logging.NullHandler()) |
|
|
else: |
|
|
self.logger = logger |
|
|
|
|
|
|
|
|
if isinstance(tokenized_dataset, str): |
|
|
self.metadata_path = os.path.join(tokenized_dataset, 'info.json') |
|
|
if not os.path.exists(self.metadata_path): |
|
|
self.logger.error(f'[SegmentationDataset] Dataset metadata file not found at {self.metadata_path}.') |
|
|
raise FileNotFoundError(f'[SegmentationDataset] Dataset metadata file not found at {self.metadata_path}.') |
|
|
else: |
|
|
with open(self.metadata_path, 'r', encoding='utf-8') as f: |
|
|
self.metadata = json.load(f) |
|
|
if 'fingerprint' not in self.metadata or not self.metadata['fingerprint']: |
|
|
raise ValueError(f'[SegmentationDataset] Dataset metadata file is missing fingerprint information.') |
|
|
else: |
|
|
self.logger.error(f'[SegmentationDataset] huggingface_dataset must be either a string or a HfDataset.') |
|
|
raise ValueError(f'[SegmentationDataset] huggingface_dataset must be either a string or a HfDataset.') |
|
|
self.logger.info(f'[SegmentationDataset] Loaded dataset: {tokenized_dataset}') |
|
|
self.logger.info(f'[SegmentationDataset] Loaded dataset length: {self.metadata["samples"]}') |
|
|
|
|
|
|
|
|
if not (0.0 < percentage <= 1.0): |
|
|
self.logger.error(f'[SegmentationDataset] Percentage must be between 0.0 and 1.0.') |
|
|
raise ValueError(f'[SegmentationDataset] Percentage must be between 0.0 and 1.0.') |
|
|
else: |
|
|
self.percentage = percentage |
|
|
|
|
|
|
|
|
if not isinstance(return_type, type): |
|
|
self.logger.error(f'[SegmentationDataset] return_type must be a type.') |
|
|
raise ValueError(f'[SegmentationDataset] return_type must be a type.') |
|
|
elif return_type not in [dict, tuple]: |
|
|
self.logger.error(f'[SegmentationDataset] return_type must be either dict or tuple.') |
|
|
raise ValueError(f'[SegmentationDataset] return_type must be either dict or tuple.') |
|
|
else: |
|
|
self.return_type = return_type |
|
|
|
|
|
self.metadata['max_sentences'] = self.metadata['x']['element_shape'][0] |
|
|
self.metadata['max_tokens'] = self.metadata['x']['element_shape'][1] |
|
|
|
|
|
|
|
|
read_mode = 'r' |
|
|
self.x_map = np.memmap( |
|
|
os.path.join(tokenized_dataset, self.metadata['x']['name'] + self.metadata['x']['extension']), |
|
|
dtype=self.metadata['x']['dtype'], |
|
|
mode=read_mode, |
|
|
shape=(self.metadata['x']['samples'], *self.metadata['x']['element_shape']) |
|
|
) |
|
|
self.y_map = np.memmap( |
|
|
os.path.join(tokenized_dataset, self.metadata['y']['name'] + self.metadata['y']['extension']), |
|
|
dtype=self.metadata['y']['dtype'], |
|
|
mode=read_mode, |
|
|
shape=(self.metadata['y']['samples'], *self.metadata['y']['element_shape']) |
|
|
) |
|
|
self.x_mask_map = np.memmap( |
|
|
os.path.join(tokenized_dataset, self.metadata['x_mask']['name'] + self.metadata['x_mask']['extension']), |
|
|
dtype=self.metadata['x_mask']['dtype'], |
|
|
mode=read_mode, |
|
|
shape=(self.metadata['x_mask']['samples'], *self.metadata['x_mask']['element_shape']) |
|
|
) |
|
|
self.y_mask_map = np.memmap( |
|
|
os.path.join(tokenized_dataset, self.metadata['y_mask']['name'] + self.metadata['y_mask']['extension']), |
|
|
dtype=self.metadata['y_mask']['dtype'], |
|
|
mode=read_mode, |
|
|
shape=(self.metadata['y_mask']['samples'], *self.metadata['y_mask']['element_shape']) |
|
|
) |
|
|
self.y_cand_map = np.memmap( |
|
|
os.path.join(tokenized_dataset, self.metadata['y_cand']['name'] + self.metadata['y_cand']['extension']), |
|
|
dtype=self.metadata['y_cand']['dtype'], |
|
|
mode=read_mode, |
|
|
shape=(self.metadata['y_cand']['samples'], *self.metadata['y_cand']['element_shape']) |
|
|
) |
|
|
|
|
|
def get_loader(self, batch_size=8, shuffle=True, num_workers=0, **kwargs) -> DataLoader: |
|
|
""" |
|
|
Returns a PyTorch DataLoader for this dataset. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
batch_size : int |
|
|
Number of samples per batch. |
|
|
shuffle : bool |
|
|
Whether to shuffle the dataset. |
|
|
num_workers : int |
|
|
Number of worker processes. |
|
|
**kwargs |
|
|
Additional arguments for DataLoader. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
[torch.utils.data.DataLoader |
|
|
Configured DataLoader. |
|
|
""" |
|
|
|
|
|
return DataLoader(self, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, pin_memory=True, |
|
|
**kwargs) |
|
|
|
|
|
def __len__(self) -> int: |
|
|
""" |
|
|
Returns the number of samples in the dataset. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
int |
|
|
Total number of samples. |
|
|
""" |
|
|
return int(self.metadata['samples'] * self.percentage) |
|
|
|
|
|
def __getitem__(self, idx) -> dict | tuple: |
|
|
""" |
|
|
Retrieves a single sample and generates segmentation labels. |
|
|
|
|
|
Parameters |
|
|
---------- |
|
|
idx : int |
|
|
Index of the sample. |
|
|
|
|
|
Returns |
|
|
------- |
|
|
tuple |
|
|
A tuple or dict (x_i, y_i, mask_x) with noisy input and corresponding target. |
|
|
""" |
|
|
if self.return_type == tuple: |
|
|
return ( |
|
|
np.array(self.x_map[idx]), |
|
|
np.array(self.y_map[idx]), |
|
|
np.array(self.x_mask_map[idx]), |
|
|
np.array(self.y_mask_map[idx]), |
|
|
np.array(self.y_cand_map[idx]), |
|
|
) |
|
|
elif self.return_type == dict: |
|
|
return { |
|
|
'input': np.array(self.x_map[idx]), |
|
|
'input_mask': np.array(self.x_mask_map[idx]), |
|
|
'labels': np.array(self.y_map[idx]), |
|
|
'output_mask': np.array(self.y_mask_map[idx]), |
|
|
'candidate_mask': np.array(self.y_cand_map[idx]), |
|
|
} |
|
|
else: |
|
|
raise ValueError(f'[SegmentationDataset] return_type must be either dict or tuple.') |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
