Upload newcollators.ipynb

newcollators.ipynb

@@ -0,0 +1,472 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "import torch\n",
+    "import torchaudio\n",
+    "import random\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "    decoder_start_token_id: int\n",
+    "    apply_augmentation: bool = False\n",
+    "    n_fft_choices: List[int] = (400, 800, 1024)\n",
+    "    hop_length_choices: List[int] = (160, 320, 512)\n",
+    "    apply_noise_injection: bool = False  # Toggle for noise injection\n",
+    "    noise_profiles: List[str] = ('white', 'pink', 'environmental')  # Example noise profiles\n",
+    "\n",
+    "    def add_adaptive_noise(self, audio, noise_type='white', base_intensity=0.005):\n",
+    "        amplitude = audio.abs().mean()\n",
+    "        noise_intensity = base_intensity * amplitude  # Scale noise intensity based on amplitude\n",
+    "\n",
+    "        noise = torch.randn_like(audio) * noise_intensity\n",
+    "        if noise_type == 'pink':\n",
+    "            noise = torchaudio.functional.highpass_biquad(noise, sample_rate=16000, cutoff_freq=200)\n",
+    "        elif noise_type == 'environmental':\n",
+    "            # Load an example environmental noise file\n",
+    "            noise, _ = torchaudio.load('environmental_noise.wav')\n",
+    "            noise = torch.nn.functional.interpolate(noise.unsqueeze(0), size=audio.size()).squeeze() * noise_intensity\n",
+    "        return audio + noise\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        input_features = []\n",
+    "        labels_list = []\n",
+    "        dec_input_features = []\n",
+    "        \n",
+    "        for feature in features:\n",
+    "            audio = feature[\"input_features\"]\n",
+    "            if self.apply_augmentation:\n",
+    "                # Randomly select n_fft and hop_length for augmentation\n",
+    "                n_fft = random.choice(self.n_fft_choices)\n",
+    "                hop_length = random.choice(self.hop_length_choices)\n",
+    "                if self.apply_noise_injection:\n",
+    "                    noise_type = random.choice(self.noise_profiles)\n",
+    "                    audio = self.add_adaptive_noise(audio, noise_type=noise_type)\n",
+    "            else:\n",
+    "                # Use default values if augmentation is not applied\n",
+    "                n_fft = 1024\n",
+    "                hop_length = 512\n",
+    "\n",
+    "            # Apply MelSpectrogram transformation with the selected parameters\n",
+    "            mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
+    "                sample_rate=16000,  # Sample rate is assumed; update if necessary\n",
+    "                n_fft=n_fft,\n",
+    "                hop_length=hop_length,\n",
+    "                n_mels=80\n",
+    "            )(torch.tensor(audio))\n",
+    "\n",
+    "            log_mel_spectrogram = torch.log(mel_spectrogram + 1e-9)\n",
+    "            input_features.append({\"input_features\": log_mel_spectrogram})\n",
+    "            \n",
+    "            label = feature[\"labels\"]\n",
+    "            label_tokens = [self.processor.tokenizer.bos_token_id] + self.processor.tokenizer.encode(label) + [self.processor.tokenizer.eos_token_id]\n",
+    "            dec_input_feature = label_tokens[:-1]\n",
+    "            label = label_tokens[1:]\n",
+    "            \n",
+    "            labels_list.append({\"input_ids\": label})\n",
+    "            dec_input_features.append({\"input_ids\": dec_input_feature})\n",
+    "        \n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "        labels_batch = self.processor.tokenizer.pad(labels_list, return_tensors=\"pt\")\n",
+    "        dec_input_batch = self.processor.tokenizer.pad(dec_input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        dec_input_features = dec_input_batch[\"input_ids\"]\n",
+    "        if (dec_input_features[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            dec_input_features = dec_input_features[:, 1:]\n",
+    "        batch[\"dec_input_features\"] = dec_input_features\n",
+    "\n",
+    "        return batch\n",
+    "\n",
+    "# Example usage\n",
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(\n",
+    "    processor=processor,\n",
+    "    decoder_start_token_id=model.config.decoder_start_token_id,\n",
+    "    apply_augmentation=True,  # Enable augmentation\n",
+    "    apply_noise_injection=True  # Enable adaptive noise injection\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "import torch\n",
+    "import torchaudio\n",
+    "import random\n",
+    "\n",
+    "\n",
+    "def add_adaptive_noise(audio, noise_type='white', base_intensity=0.005):\n",
+    "    amplitude = audio.abs().mean()\n",
+    "    noise_intensity = base_intensity * amplitude  # Scale noise intensity based on amplitude\n",
+    "    \n",
+    "    noise = torch.randn_like(audio) * noise_intensity\n",
+    "    if noise_type == 'pink':\n",
+    "        noise = torchaudio.functional.highpass_biquad(noise, sample_rate=16000, cutoff_freq=200)\n",
+    "    elif noise_type == 'environmental':\n",
+    "        # Load an example environmental noise file\n",
+    "        noise, _ = torchaudio.load('environmental_noise.wav')\n",
+    "        noise = torch.nn.functional.interpolate(noise.unsqueeze(0), size=audio.size()).squeeze() * noise_intensity\n",
+    "    return audio + noise\n",
+    "\n",
+    "def collate_fn(batch, apply_augmentation_flag=True, apply_noise_injection_flag=False):\n",
+    "    n_fft_choices = [400, 800, 1024]\n",
+    "    hop_length_choices = [160, 320, 512]\n",
+    "    noise_profiles = ['white', 'pink', 'environmental']\n",
+    "\n",
+    "    input_features, labels, dec_input_features = [], [], []\n",
+    "    \n",
+    "    for f in batch:\n",
+    "        audio = whisper.pad_or_trim(f[\"audio\"].flatten())\n",
+    "        \n",
+    "        if apply_augmentation_flag:\n",
+    "            n_fft = random.choice(n_fft_choices)\n",
+    "            hop_length = random.choice(hop_length_choices)\n",
+    "            if apply_noise_injection_flag:\n",
+    "                noise_type = random.choice(noise_profiles)\n",
+    "                audio = add_adaptive_noise(audio, noise_type=noise_type)\n",
+    "        else:\n",
+    "            n_fft = 1024\n",
+    "            hop_length = 512\n",
+    "\n",
+    "        mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
+    "            sample_rate=16000,  # Assuming a sample rate of 16000\n",
+    "            n_fft=n_fft,\n",
+    "            hop_length=hop_length,\n",
+    "            n_mels=80\n",
+    "        )(audio)\n",
+    "\n",
+    "        input_feature = torch.log(mel_spectrogram + 1e-9)\n",
+    "\n",
+    "        label = f[\"label\"]\n",
+    "        label_tokens = [tokenizer.bos_token_id] + tokenizer.encode(label) + [tokenizer.eos_token_id]\n",
+    "        dec_input_feature = label_tokens[:-1]\n",
+    "        label = label_tokens[1:]\n",
+    "\n",
+    "        input_features.append(input_feature)\n",
+    "        labels.append(label)\n",
+    "        dec_input_features.append(dec_input_feature)\n",
+    "\n",
+    "    input_features = torch.stack(input_features)\n",
+    "\n",
+    "    max_label_len = max(len(l) for l in labels)\n",
+    "    max_dec_input_len = max(len(d) for d in dec_input_features)\n",
+    "    max_len = max(max_label_len, max_dec_input_len)\n",
+    "\n",
+    "    labels = [np.pad(l, (0, max_len - len(l)), 'constant', constant_values=-100) for l in labels]\n",
+    "    dec_input_features = [np.pad(d, (0, max_len - len(d)), 'constant', constant_values=tokenizer.pad_token_id) for d in dec_input_features]\n",
+    "\n",
+    "    labels = np.array(labels)\n",
+    "    dec_input_features = np.array(dec_input_features)\n",
+    "\n",
+    "    labels = torch.tensor(labels, dtype=torch.long)\n",
+    "    dec_input_features = torch.tensor(dec_input_features, dtype=torch.long)\n",
+    "\n",
+    "    batch = {\n",
+    "        \"input_features\": input_features,\n",
+    "        \"labels\": labels,\n",
+    "        \"dec_input_features\": dec_input_features\n",
+    "    }\n",
+    "    return batch\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from dataclasses import dataclass\n",
+    "from typing import Any, Dict, List, Union\n",
+    "import torch\n",
+    "import torchaudio\n",
+    "import random\n",
+    "\n",
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "    decoder_start_token_id: int\n",
+    "    apply_augmentation: bool = False\n",
+    "    n_fft_choices: List[int] = (400, 800, 1024)\n",
+    "    hop_length_choices: List[int] = (160, 320, 512)\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        input_features = []\n",
+    "        labels_list = []\n",
+    "        dec_input_features = []\n",
+    "        \n",
+    "        for feature in features:\n",
+    "            audio = feature[\"input_features\"]\n",
+    "            if self.apply_augmentation:\n",
+    "                # Randomly select n_fft and hop_length for augmentation\n",
+    "                n_fft = random.choice(self.n_fft_choices)\n",
+    "                hop_length = random.choice(self.hop_length_choices)\n",
+    "            else:\n",
+    "                # Use default values if augmentation is not applied\n",
+    "                n_fft = 1024\n",
+    "                hop_length = 512\n",
+    "\n",
+    "            # Apply MelSpectrogram transformation with the selected parameters\n",
+    "            mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
+    "                sample_rate=16000,  # Sample rate is assumed; update if necessary\n",
+    "                n_fft=n_fft,\n",
+    "                hop_length=hop_length,\n",
+    "                n_mels=80\n",
+    "            )(torch.tensor(audio))\n",
+    "\n",
+    "            log_mel_spectrogram = torch.log(mel_spectrogram + 1e-9)\n",
+    "            input_features.append({\"input_features\": log_mel_spectrogram})\n",
+    "            \n",
+    "            label = feature[\"labels\"]\n",
+    "            label_tokens = [self.processor.tokenizer.bos_token_id] + self.processor.tokenizer.encode(label) + [self.processor.tokenizer.eos_token_id]\n",
+    "            dec_input_feature = label_tokens[:-1]\n",
+    "            label = label_tokens[1:]\n",
+    "            \n",
+    "            labels_list.append({\"input_ids\": label})\n",
+    "            dec_input_features.append({\"input_ids\": dec_input_feature})\n",
+    "        \n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "        labels_batch = self.processor.tokenizer.pad(labels_list, return_tensors=\"pt\")\n",
+    "        dec_input_batch = self.processor.tokenizer.pad(dec_input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        dec_input_features = dec_input_batch[\"input_ids\"]\n",
+    "        if (dec_input_features[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            dec_input_features = dec_input_features[:, 1:]\n",
+    "        batch[\"dec_input_features\"] = dec_input_features\n",
+    "\n",
+    "        return batch\n",
+    "\n",
+    "# Example usage\n",
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(\n",
+    "    processor=processor,\n",
+    "    decoder_start_token_id=model.config.decoder_start_token_id,\n",
+    "    apply_augmentation=True  # Set to False to disable augmentation\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "@dataclass\n",
+    "class DataCollatorSpeechSeq2SeqWithPadding:\n",
+    "    processor: Any\n",
+    "    decoder_start_token_id: int\n",
+    "    apply_augmentation: bool = False\n",
+    "    n_fft_choices: List[int] = (400, 800, 1024)\n",
+    "    hop_length_choices: List[int] = (160, 320, 512)\n",
+    "    apply_noise_injection: bool = False  # Toggle for noise injection\n",
+    "    noise_profiles: List[str] = ('white', 'pink', 'environmental')  # Example noise profiles\n",
+    "\n",
+    "    def add_noise(self, audio, noise_type='white', intensity=0.005):\n",
+    "        noise = torch.randn_like(audio) * intensity\n",
+    "        if noise_type == 'pink':\n",
+    "            noise = torchaudio.functional.highpass_biquad(noise, sample_rate=16000, cutoff_freq=200)\n",
+    "        elif noise_type == 'environmental':\n",
+    "            # Load an example environmental noise file\n",
+    "            noise, _ = torchaudio.load('environmental_noise.wav')\n",
+    "            noise = torch.nn.functional.interpolate(noise.unsqueeze(0), size=audio.size()).squeeze() * intensity\n",
+    "        return audio + noise\n",
+    "\n",
+    "    def __call__(self, features: List[Dict[str, Union[List[int], torch.Tensor]]]) -> Dict[str, torch.Tensor]:\n",
+    "        input_features = []\n",
+    "        labels_list = []\n",
+    "        dec_input_features = []\n",
+    "        \n",
+    "        for feature in features:\n",
+    "            audio = feature[\"input_features\"]\n",
+    "            if self.apply_augmentation:\n",
+    "                n_fft = random.choice(self.n_fft_choices)\n",
+    "                hop_length = random.choice(self.hop_length_choices)\n",
+    "                if self.apply_noise_injection:\n",
+    "                    noise_type = random.choice(self.noise_profiles)\n",
+    "                    audio = self.add_noise(audio, noise_type=noise_type)\n",
+    "            else:\n",
+    "                n_fft = 1024\n",
+    "                hop_length = 512\n",
+    "\n",
+    "            mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
+    "                sample_rate=16000,  # Sample rate is assumed; update if necessary\n",
+    "                n_fft=n_fft,\n",
+    "                hop_length=hop_length,\n",
+    "                n_mels=80\n",
+    "            )(torch.tensor(audio))\n",
+    "\n",
+    "            log_mel_spectrogram = torch.log(mel_spectrogram + 1e-9)\n",
+    "            input_features.append({\"input_features\": log_mel_spectrogram})\n",
+    "            \n",
+    "            label = feature[\"labels\"]\n",
+    "            label_tokens = [self.processor.tokenizer.bos_token_id] + self.processor.tokenizer.encode(label) + [self.processor.tokenizer.eos_token_id]\n",
+    "            dec_input_feature = label_tokens[:-1]\n",
+    "            label = label_tokens[1:]\n",
+    "            \n",
+    "            labels_list.append({\"input_ids\": label})\n",
+    "            dec_input_features.append({\"input_ids\": dec_input_feature})\n",
+    "        \n",
+    "        batch = self.processor.feature_extractor.pad(input_features, return_tensors=\"pt\")\n",
+    "        labels_batch = self.processor.tokenizer.pad(labels_list, return_tensors=\"pt\")\n",
+    "        dec_input_batch = self.processor.tokenizer.pad(dec_input_features, return_tensors=\"pt\")\n",
+    "\n",
+    "        labels = labels_batch[\"input_ids\"].masked_fill(labels_batch.attention_mask.ne(1), -100)\n",
+    "        if (labels[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            labels = labels[:, 1:]\n",
+    "        batch[\"labels\"] = labels\n",
+    "\n",
+    "        dec_input_features = dec_input_batch[\"input_ids\"]\n",
+    "        if (dec_input_features[:, 0] == self.decoder_start_token_id).all().cpu().item():\n",
+    "            dec_input_features = dec_input_features[:, 1:]\n",
+    "        batch[\"dec_input_features\"] = dec_input_features\n",
+    "\n",
+    "        return batch\n",
+    "\n",
+    "data_collator = DataCollatorSpeechSeq2SeqWithPadding(\n",
+    "    processor=processor,\n",
+    "    decoder_start_token_id=model.config.decoder_start_token_id,\n",
+    "    apply_augmentation=True,  # Set to True to enable augmentation\n",
+    "    apply_noise_injection=True  # Set to True to enable noise injection\n",
+    ")\n",
+    "\n",
+    "dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True, collate_fn=data_collator)\n",
+    "\n",
+    "for batch in dataloader:\n",
+    "    # Pass the batch to your model\n",
+    "    outputs = model(batch)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import torchaudio\n",
+    "import random\n",
+    "import numpy as np\n",
+    "\n",
+    "def add_noise(audio, noise_type='white', intensity=0.005):\n",
+    "    noise = torch.randn_like(audio) * intensity\n",
+    "    if noise_type == 'pink':\n",
+    "        noise = torchaudio.functional.highpass_biquad(noise, sample_rate=16000, cutoff_freq=200)\n",
+    "    elif noise_type == 'environmental':\n",
+    "        # Load an example environmental noise file\n",
+    "        noise, _ = torchaudio.load('environmental_noise.wav')\n",
+    "        noise = torch.nn.functional.interpolate(noise.unsqueeze(0), size=audio.size()).squeeze() * intensity\n",
+    "    return audio + noise\n",
+    "\n",
+    "def collate_fn(batch, apply_augmentation_flag=True, apply_noise_injection_flag=False):\n",
+    "    n_fft_choices = [400, 800, 1024]\n",
+    "    hop_length_choices = [160, 320, 512]\n",
+    "    noise_profiles = ['white', 'pink', 'environmental']\n",
+    "\n",
+    "    input_features, labels, dec_input_features = [], [], []\n",
+    "    \n",
+    "    for f in batch:\n",
+    "        # Convert audio to features here\n",
+    "        audio = whisper.pad_or_trim(f[\"audio\"].flatten())\n",
+    "        \n",
+    "        if apply_augmentation_flag:\n",
+    "            n_fft = random.choice(n_fft_choices)\n",
+    "            hop_length = random.choice(hop_length_choices)\n",
+    "            if apply_noise_injection_flag:\n",
+    "                noise_type = random.choice(noise_profiles)\n",
+    "                audio = add_noise(audio, noise_type=noise_type)\n",
+    "        else:\n",
+    "            n_fft = 1024\n",
+    "            hop_length = 512\n",
+    "\n",
+    "        # Apply MelSpectrogram transformation with the selected parameters\n",
+    "        mel_spectrogram = torchaudio.transforms.MelSpectrogram(\n",
+    "            sample_rate=16000,  # Assuming a sample rate of 16000\n",
+    "            n_fft=n_fft,\n",
+    "            hop_length=hop_length,\n",
+    "            n_mels=80\n",
+    "        )(audio)\n",
+    "\n",
+    "        # Apply logarithm for log-Mel spectrogram\n",
+    "        input_feature = torch.log(mel_spectrogram + 1e-9)\n",
+    "\n",
+    "        label = f[\"label\"]\n",
+    "        label_tokens = [tokenizer.bos_token_id] + tokenizer.encode(label) + [tokenizer.eos_token_id]\n",
+    "        dec_input_feature = label_tokens[:-1]\n",
+    "        label = label_tokens[1:]\n",
+    "\n",
+    "        input_features.append(input_feature)\n",
+    "        labels.append(label)\n",
+    "        dec_input_features.append(dec_input_feature)\n",
+    "\n",
+    "    input_features = torch.stack(input_features)\n",
+    "\n",
+    "    max_label_len = max(len(l) for l in labels)\n",
+    "    max_dec_input_len = max(len(d) for d in dec_input_features)\n",
+    "    max_len = max(max_label_len, max_dec_input_len)\n",
+    "\n",
+    "    labels = [np.pad(l, (0, max_len - len(l)), 'constant', constant_values=-100) for l in labels]\n",
+    "    dec_input_features = [np.pad(d, (0, max_len - len(d)), 'constant', constant_values=tokenizer.pad_token_id) for d in dec_input_features]\n",
+    "\n",
+    "    # Convert the lists of numpy arrays to numpy arrays before creating tensors\n",
+    "    labels = np.array(labels)\n",
+    "    dec_input_features = np.array(dec_input_features)\n",
+    "\n",
+    "    labels = torch.tensor(labels, dtype=torch.long)\n",
+    "    dec_input_features = torch.tensor(dec_input_features, dtype=torch.long)\n",
+    "\n",
+    "    batch = {\n",
+    "        \"input_features\": input_features,\n",
+    "        \"labels\": labels,\n",
+    "        \"dec_input_features\": dec_input_features\n",
+    "    }\n",
+    "    return batch\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Flag to apply augmentation\n",
+    "apply_augmentation_flag = True\n",
+    "apply_noise_injection_flag = True\n",
+    "\n",
+    "# Create dataset and dataloader with augmentation and noise injection based on the flags\n",
+    "collate_fn_with_flags = partial(collate_fn, apply_augmentation_flag=apply_augmentation_flag, apply_noise_injection_flag=apply_noise_injection_flag)\n",
+    "dataloader = torch.utils.data.DataLoader(dataset, batch_size=2, shuffle=True, collate_fn=collate_fn_with_flags)\n",
+    "\n",
+    "for batch in dataloader:\n",
+    "    # Pass the batch to your model\n",
+    "    outputs = model(batch)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}