| import torch |
| from transformers import AutoFeatureExtractor |
| from dataclasses import dataclass, field |
| from typing import Any, Dict, List, Optional, Union |
| from preprocessing.ast_processor import ast |
| from util_stats.local_stats import local_extract_phn_frame_probs |
| from util_stats.global_stats import global_extract_phn_frame_probs |
| import numpy as np |
| import pickle |
| import torch.nn.functional as F |
|
|
| from load_data.extract_fbanks import Mel_Spectrogram |
|
|
| extractor = Mel_Spectrogram() |
|
|
| with open('new_lbl2ind.pkl', 'rb') as f: |
| lbl2ind = pickle.load(f) |
| with open('new_spk.pkl', 'rb') as f: |
| unique_speaker_ids = pickle.load(f) |
| |
| number_Of_spks = len(unique_speaker_ids) |
|
|
|
|
| @dataclass |
| class DataCollatorWithPadding: |
| """ |
| Data collator that will dynamically pad the inputs received. |
| Args: |
| processor (:class:`~transformers.Wav2Vec2Processor`) |
| The processor used for proccessing the data. |
| padding (:obj:`bool`, :obj:`str` or :class:`~transformers.tokenization_utils_base.PaddingStrategy`, `optional`, defaults to :obj:`True`): |
| Select a strategy to pad the returned sequences (according to the model's padding side and padding index) |
| among: |
| * :obj:`True` or :obj:`'longest'`: Pad to the longest sequence in the batch (or no padding if only a single |
| sequence if provided). |
| * :obj:`'max_length'`: Pad to a maximum length specified with the argument :obj:`max_length` or to the |
| maximum acceptable input length for the model if that argument is not provided. |
| * :obj:`False` or :obj:`'do_not_pad'` (default): No padding (i.e., can output a batch with sequences of |
| different lengths). |
| max_length (:obj:`int`, `optional`): |
| Maximum length of the ``input_values`` of the returned list and optionally padding length (see above). |
| max_length_labels (:obj:`int`, `optional`): |
| Maximum length of the ``labels`` returned list and optionally padding length (see above). |
| pad_to_multiple_of (:obj:`int`, `optional`): |
| If set will pad the sequence to a multiple of the provided value. |
| This is especially useful to enable the use of Tensor Cores on NVIDIA hardware with compute capability >= |
| 7.5 (Volta). |
| """ |
|
|
|
|
|
|
| padding: Union[bool, str] = True |
| max_length: Optional[int] = None |
| pad_to_multiple_of: Optional[int] = None |
| pad_to_multiple_of_labels: Optional[int] = None |
| flag_global_local: Optional[str] = None |
| dic_train_phn_frequency: Optional [dict] = None |
| dic_train_frame_frequency: Optional [dict] = None |
| lbl2ind: Optional [dict] = None |
|
|
| def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]: |
| |
| |
| batch={} |
| batch['input_values']= [features[idx]['audio_tensor'].squeeze(0) for idx in range(len(features))] |
| batch["prompt"] = [features[idx]["prompt"] for idx in range(len(features))] |
| batch["answer"] = [features[idx]["answer"] for idx in range(len(features))] |
| batch["filename"] = [features[idx]["filename"] for idx in range(len(features))] |
| |
| batch["no_hot_encode"] = torch.tensor([0 for idx in range(len(features))]) |
| |
| batch["labels"]= F.one_hot(batch["no_hot_encode"], number_Of_spks) |
| batch['input_values'] = extractor(torch.stack(batch['input_values'])) |
| return batch |
|
|
