added mixer model

results/non_semi_final_stac/ctc_lin.py

@@ -0,0 +1,756 @@
+# -*- coding: utf-8 -*-
+
+import os
+import sys
+import torch
+import logging
+import speechbrain as sb
+from speechbrain.utils.distributed import run_on_main
+from hyperpyyaml import load_hyperpyyaml
+from pathlib import Path
+import torchaudio.transforms as T
+from cv_train import ASRCV
+import torchaudio
+import numpy as np
+import kenlm
+from pyctcdecode import build_ctcdecoder
+import re
+
+# Commented out IPython magic to ensure Python compatibility.
+# %cd /content/drive/MyDrive/tunisian_corpora/tunisian_without_wavlm
+#hparams_file, run_opts, overrides = sb.parse_arguments(["/gpfsstore/rech/nou/uzn19yk/switched_code_tunisian/train/tunisian_asr/hparams/train_semi.yaml"])
+hparams_file, run_opts, overrides = sb.parse_arguments(["semi_supervised_test_tunisian.yaml"])
+
+# If distributed_launch=True then
+# create ddp_group with the right communication protocol
+sb.utils.distributed.ddp_init_group(run_opts)
+
+with open(hparams_file) as fin:
+    hparams = load_hyperpyyaml(fin, overrides)
+
+# Create experiment directory
+sb.create_experiment_directory(
+    experiment_directory=hparams["output_folder"],
+    hyperparams_to_save=hparams_file,
+    overrides=overrides,
+)
+# Dataset prep (parsing Librispeech)
+
+def dataio_prepare(hparams):
+    """This function prepares the datasets to be used in the brain class.
+    It also defines the data processing pipeline through user-defined functions."""
+
+    # 1. Define datasets
+    data_folder = hparams["data_folder"]
+
+    train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
+        csv_path=hparams["train_csv"], replacements={"data_root": data_folder},
+    )
+
+    if hparams["sorting"] == "ascending":
+        # we sort training data to speed up training and get better results.
+        train_data = train_data.filtered_sorted(
+            sort_key="duration",
+            key_max_value={"duration": hparams["avoid_if_longer_than"]},
+        )
+        # when sorting do not shuffle in dataloader ! otherwise is pointless
+        hparams["dataloader_options"]["shuffle"] = False
+
+    elif hparams["sorting"] == "descending":
+        train_data = train_data.filtered_sorted(
+            sort_key="duration",
+            reverse=True,
+            key_max_value={"duration": hparams["avoid_if_longer_than"]},
+        )
+        # when sorting do not shuffle in dataloader ! otherwise is pointless
+        hparams["dataloader_options"]["shuffle"] = False
+
+    elif hparams["sorting"] == "random":
+        pass
+
+    else:
+        raise NotImplementedError(
+            "sorting must be random, ascending or descending"
+        )
+
+    valid_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
+        csv_path=hparams["valid_csv"], replacements={"data_root": data_folder},
+    )
+    # We also sort the validation data so it is faster to validate
+    valid_data = valid_data.filtered_sorted(sort_key="duration")
+    test_datasets = {}
+    for csv_file in hparams["test_csv"]:
+        name = Path(csv_file).stem
+        test_datasets[name] = sb.dataio.dataset.DynamicItemDataset.from_csv(
+            csv_path=csv_file, replacements={"data_root": data_folder}
+        )
+        test_datasets[name] = test_datasets[name].filtered_sorted(
+            sort_key="duration"
+        )
+
+    datasets = [train_data, valid_data] + [i for k, i in test_datasets.items()]
+
+
+    # 2. Define audio pipeline:
+    @sb.utils.data_pipeline.takes("wav")
+    @sb.utils.data_pipeline.provides("sig")
+    def audio_pipeline(wav):
+        info = torchaudio.info(wav)
+        sig = sb.dataio.dataio.read_audio(wav)
+        if len(sig.shape)>1 :
+            sig = torch.mean(sig, dim=1)
+        resampled = torchaudio.transforms.Resample(
+            info.sample_rate, hparams["sample_rate"],
+        )(sig)
+        return resampled
+
+    sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)
+    label_encoder = sb.dataio.encoder.CTCTextEncoder()
+
+    # 3. Define text pipeline:
+    @sb.utils.data_pipeline.takes("wrd")
+    @sb.utils.data_pipeline.provides(
+        "wrd", "char_list", "tokens_list", "tokens"
+    )
+    def text_pipeline(wrd):
+        yield wrd
+        char_list = list(wrd)
+        yield char_list
+        tokens_list = label_encoder.encode_sequence(char_list)
+        yield tokens_list
+        tokens = torch.LongTensor(tokens_list)
+        yield tokens
+
+    sb.dataio.dataset.add_dynamic_item(datasets, text_pipeline)
+    lab_enc_file = os.path.join(hparams["save_folder"], "label_encoder.txt")
+    special_labels = {
+        "blank_label": hparams["blank_index"],
+        "unk_label": hparams["unk_index"]
+    }
+    label_encoder.load_or_create(
+        path=lab_enc_file,
+        from_didatasets=[train_data],
+        output_key="char_list",
+        special_labels=special_labels,
+        sequence_input=True,
+    )
+
+    # 4. Set output:
+    sb.dataio.dataset.set_output_keys(
+        datasets, ["id", "sig", "wrd", "char_list", "tokens"],
+    )
+    return train_data, valid_data,test_datasets, label_encoder
+
+class ASR(sb.core.Brain):
+    def compute_forward(self, batch, stage):
+        """Forward computations from the waveform batches to the output probabilities."""
+
+        batch = batch.to(self.device)
+        wavs, wav_lens = batch.sig
+        wavs, wav_lens = wavs.to(self.device), wav_lens.to(self.device)
+
+        if stage == sb.Stage.TRAIN:
+            if hasattr(self.hparams, "augmentation"):
+                wavs = self.hparams.augmentation(wavs, wav_lens)
+
+        # Forward pass
+        feats = self.modules.wav2vec2(wavs, wav_lens)
+        x = self.modules.enc(feats)
+        logits = self.modules.ctc_lin(x)
+        p_ctc = self.hparams.log_softmax(logits)
+
+        return p_ctc, wav_lens
+
+    def custom_encode(self,wavs,wav_lens) :
+        wavs = wavs.to(self.device)
+        if(wav_lens is not None): wav_lens.to(self.device)
+
+        feats = self.modules.wav2vec2(wavs, wav_lens)
+        x = self.modules.enc(feats)
+        logits = self.modules.ctc_lin(x)
+        p_ctc = self.hparams.log_softmax(logits)
+
+        return feats,p_ctc
+
+
+
+    def compute_objectives(self, predictions, batch, stage):
+        """Computes the loss (CTC) given predictions and targets."""
+
+        p_ctc, wav_lens = predictions
+
+        ids = batch.id
+        tokens, tokens_lens = batch.tokens
+
+        loss = self.hparams.ctc_cost(p_ctc, tokens, wav_lens, tokens_lens)
+
+        if stage != sb.Stage.TRAIN:
+            predicted_tokens = sb.decoders.ctc_greedy_decode(
+                p_ctc, wav_lens, blank_id=self.hparams.blank_index
+            )
+            # Decode token terms to words
+            if self.hparams.use_language_modelling:
+                predicted_words = []
+                for logs in p_ctc:
+                    text = decoder.decode(logs.detach().cpu().numpy())
+                    predicted_words.append(text.split(" "))
+            else:
+                predicted_words = [
+                    "".join(self.tokenizer.decode_ndim(utt_seq)).split(" ")
+                    for utt_seq in predicted_tokens
+                ]
+            # Convert indices to words
+            target_words = [wrd.split(" ") for wrd in batch.wrd]
+
+            self.wer_metric.append(ids, predicted_words, target_words)
+            self.cer_metric.append(ids, predicted_words, target_words)
+
+        return loss
+
+    def fit_batch(self, batch):
+        """Train the parameters given a single batch in input"""
+        should_step = self.step % self.grad_accumulation_factor == 0
+        # Managing automatic mixed precision
+        # TOFIX: CTC fine-tuning currently is unstable
+        # This is certainly due to CTC being done in fp16 instead of fp32
+        if self.auto_mix_prec:
+            with torch.cuda.amp.autocast():
+                with self.no_sync():
+                    outputs = self.compute_forward(batch, sb.Stage.TRAIN)
+                loss = self.compute_objectives(outputs, batch, sb.Stage.TRAIN)
+            with self.no_sync(not should_step):
+                self.scaler.scale(
+                    loss / self.grad_accumulation_factor
+                ).backward()
+            if should_step:
+
+                if not self.hparams.wav2vec2.freeze:
+                    self.scaler.unscale_(self.wav2vec_optimizer)
+                self.scaler.unscale_(self.model_optimizer)
+                if self.check_gradients(loss):
+                    if not self.hparams.wav2vec2.freeze:
+                        if self.optimizer_step >= self.hparams.warmup_steps:
+                            self.scaler.step(self.wav2vec_optimizer)
+                    self.scaler.step(self.model_optimizer)
+                self.scaler.update()
+                self.zero_grad()
+                self.optimizer_step += 1
+        else:
+            # This is mandatory because HF models have a weird behavior with DDP
+            # on the forward pass
+            with self.no_sync():
+                outputs = self.compute_forward(batch, sb.Stage.TRAIN)
+
+            loss = self.compute_objectives(outputs, batch, sb.Stage.TRAIN)
+
+            with self.no_sync(not should_step):
+                (loss / self.grad_accumulation_factor).backward()
+            if should_step:
+                if self.check_gradients(loss):
+                    if not self.hparams.wav2vec2.freeze:
+                        if self.optimizer_step >= self.hparams.warmup_steps:
+                            self.wav2vec_optimizer.step()
+                    self.model_optimizer.step()
+                self.zero_grad()
+                self.optimizer_step += 1
+
+        self.on_fit_batch_end(batch, outputs, loss, should_step)
+        return loss.detach().cpu()
+
+    def evaluate_batch(self, batch, stage):
+        """Computations needed for validation/test batches"""
+        predictions = self.compute_forward(batch, stage=stage)
+        with torch.no_grad():
+            loss = self.compute_objectives(predictions, batch, stage=stage)
+        return loss.detach()
+
+    def on_stage_start(self, stage, epoch):
+        """Gets called at the beginning of each epoch"""
+        if stage != sb.Stage.TRAIN:
+            self.cer_metric = self.hparams.cer_computer()
+            self.wer_metric = self.hparams.error_rate_computer()
+
+    def on_stage_end(self, stage, stage_loss, epoch):
+        """Gets called at the end of an epoch."""
+        # Compute/store important stats
+        stage_stats = {"loss": stage_loss}
+        if stage == sb.Stage.TRAIN:
+            self.train_stats = stage_stats
+        else:
+            stage_stats["CER"] = self.cer_metric.summarize("error_rate")
+            stage_stats["WER"] = self.wer_metric.summarize("error_rate")
+
+        # Perform end-of-iteration things, like annealing, logging, etc.
+        if stage == sb.Stage.VALID:
+            old_lr_model, new_lr_model = self.hparams.lr_annealing_model(
+                stage_stats["loss"]
+            )
+            old_lr_wav2vec, new_lr_wav2vec = self.hparams.lr_annealing_wav2vec(
+                stage_stats["loss"]
+            )
+            sb.nnet.schedulers.update_learning_rate(
+                self.model_optimizer, new_lr_model
+            )
+            if not self.hparams.wav2vec2.freeze:
+                sb.nnet.schedulers.update_learning_rate(
+                    self.wav2vec_optimizer, new_lr_wav2vec
+                )
+            self.hparams.train_logger.log_stats(
+                stats_meta={
+                    "epoch": epoch,
+                    "lr_model": old_lr_model,
+                    "lr_wav2vec": old_lr_wav2vec,
+                },
+                train_stats=self.train_stats,
+                valid_stats=stage_stats,
+            )
+            self.checkpointer.save_and_keep_only(
+                meta={"WER": stage_stats["WER"]}, min_keys=["WER"],
+            )
+        elif stage == sb.Stage.TEST:
+            self.hparams.train_logger.log_stats(
+                stats_meta={"Epoch loaded": self.hparams.epoch_counter.current},
+                test_stats=stage_stats,
+            )
+            with open(self.hparams.wer_file, "w") as w:
+                self.wer_metric.write_stats(w)
+
+    def init_optimizers(self):
+        "Initializes the wav2vec2 optimizer and model optimizer"
+
+        # If the wav2vec encoder is unfrozen, we create the optimizer
+        if not self.hparams.wav2vec2.freeze:
+            self.wav2vec_optimizer = self.hparams.wav2vec_opt_class(
+                self.modules.wav2vec2.parameters()
+            )
+            if self.checkpointer is not None:
+                self.checkpointer.add_recoverable(
+                    "wav2vec_opt", self.wav2vec_optimizer
+                )
+
+        self.model_optimizer = self.hparams.model_opt_class(
+            self.hparams.model.parameters()
+        )
+
+        if self.checkpointer is not None:
+            self.checkpointer.add_recoverable("modelopt", self.model_optimizer)
+
+    def zero_grad(self, set_to_none=False):
+        if not self.hparams.wav2vec2.freeze:
+            self.wav2vec_optimizer.zero_grad(set_to_none)
+        self.model_optimizer.zero_grad(set_to_none)
+
+
+"""
+label_encoder = sb.dataio.encoder.CTCTextEncoder()
+
+train_data, valid_data, test_datasets, label_encoder = dataio_prepare(
+        hparams
+    )
+
+
+# We dynamicaly add the tokenizer to our brain class.
+# NB: This tokenizer corresponds to the one used for the LM!!
+"""
+from speechbrain.pretrained import EncoderASR,EncoderDecoderASR
+french_asr_model = EncoderASR.from_hparams(source="speechbrain/asr-wav2vec2-commonvoice-fr", savedir="pretrained_models/asr-wav2vec2-commonvoice-fr").cuda()
+#french_asr_model = "r"
+
+cvhparams_file, cvrun_opts, cvoverrides = sb.parse_arguments(["en_cv.yaml"])
+with open(cvhparams_file) as cvfin:
+    cvhparams = load_hyperpyyaml(cvfin, cvoverrides)
+english_asr_model = ASRCV(
+        modules=cvhparams["modules"],
+        hparams=cvhparams,
+        run_opts=cvrun_opts,
+        checkpointer=cvhparams["checkpointer"],
+    )
+english_asr_model.checkpointer.recover_if_possible()
+asr_brain = ASR(
+    modules=hparams["modules"],
+    hparams=hparams,
+    run_opts=run_opts,
+    checkpointer=hparams["checkpointer"],
+)
+asr_brain.checkpointer.recover_if_possible()
+asr_brain.modules.eval()
+english_asr_model.modules.eval()
+french_asr_model.mods.eval()
+"""
+asr_brain.tokenizer = label_encoder
+
+# Testing
+real = True
+if real :
+    for k in test_datasets.keys():  # keys are test_clean, test_other etc
+        asr_brain.hparams.wer_file = os.path.join(
+            hparams["output_folder"], "wer_{}.txt".format(k)
+        )
+        asr_brain.evaluate(
+            test_datasets[k], test_loader_kwargs=hparams["dataloader_options"]
+        )
+"""
+
+"""
+from torch.nn.utils.rnn import pad_sequence
+def load_paths(wavs_path):
+    waveforms = []
+    for path in wavs_path :
+        waveform, _ = torchaudio.load(path)
+        waveforms.append(waveform.squeeze(0))
+    # normalize array length to the bigger arrays by pading with 0's
+    padded_arrays = pad_sequence(waveforms, batch_first=True)
+    return torch.tensor(padded_arrays)
+
+waveform = load_paths(["/content/drive/MyDrive/tunisian_corpora/tunisian_without_wavlm/samples/Salah10.wav","/content/drive/MyDrive/tunisian_corpora/tunisian_without_wavlm/samples/Salah10.wav"])
+embeddings, posteriogram = asr_brain.custom_encode(waveform,None)
+print(embeddings.shape)
+print(posteriogram.shape)
+"""
+
+from speechbrain.pretrained import EncoderASR,EncoderDecoderASR
+import torchaudio
+import  speechbrain as sb
+import torch
+from torch.nn.utils.rnn import pad_sequence
+import torch
+import speechbrain as sb
+import numpy as np
+import torch.optim as optim
+import torch.nn as nn
+
+# Commented out IPython magic to ensure Python compatibility.
+# %ls
+
+#UTILS FUNCTIOJNS
+def get_size_dimensions(arr):
+    size_dimensions = []
+    while isinstance(arr, list):
+        size_dimensions.append(len(arr))
+        arr = arr[0]
+    return size_dimensions
+
+def scale_array(batch,n):
+    scaled_batch = []
+
+    for array in batch:
+        if(n < len(array)): raise ValueError("Cannot scale Array down")
+
+        repeat = round(n/len(array))+1
+        scaled_length_array= []
+
+        for i in array:
+            for j in range(repeat) :
+                if(len(scaled_length_array) == n): break
+                scaled_length_array.append(i)
+
+        scaled_batch.append(scaled_length_array)
+
+    return torch.tensor(scaled_batch)
+
+
+def load_paths(wavs_path):
+    waveforms = []
+    for path in wavs_path :
+        waveform, _ = torchaudio.load(path)
+        waveforms.append(waveform.squeeze(0))
+    # normalize array length to the bigger arrays by pading with 0's
+    padded_arrays = pad_sequence(waveforms, batch_first=True)
+    return torch.tensor(padded_arrays)
+
+
+
+def word_to_vec(input_string):
+    mapping= {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5, 'f': 6, 'g': 7, 'h': 8, 'i': 9, 'j': 10, 'k': 11, 'l': 12, 'm': 13, 'n': 14, 'o': 15, 'p': 16, 'q': 17, 'r': 18, 's': 19, 't': 20, 'u': 21, 'v': 22, 'w': 23, 'x': 24, 'y': 25, 'z': 26, 'ا': 27, 'ب': 28, 'ت': 29, 'ث': 30, 'ج': 31, 'ح': 32, 'خ': 33, 'د': 34, 'ذ': 35, 'ر': 36, 'ز': 37, 'س': 38, 'ش': 39, 'ص': 40, 'ض': 41, 'ط': 42, 'ظ': 43, 'ع': 44, 'غ': 45, 'ف': 46, 'ق': 47, 'ك': 48, 'ل': 49, 'م': 50, 'ن': 51, 'ه': 52, 'و': 53, 'ي': 54,' ':55}
+
+    numbers = [mapping[word] for word in input_string if word in mapping]
+    return numbers
+
+device = 'cuda'
+verbose = 0
+#FLOW LEVEL FUNCTIONS
+def merge_strategy(embeddings1, embeddings2, embeddings3,post1, post2,post3):
+
+
+    post1 = post1.to(device)
+    post2 = post2.to(device)
+    post3 = post3.to(device)
+    embeddings1 = embeddings1.to(device)
+    embeddings2 = embeddings2.to(device)
+    embeddings3 = embeddings3.to(device)
+
+    posteriograms_merged = torch.cat((post1,post2,post3),dim=2)
+    embeddings_merged = torch.cat((embeddings1,embeddings2,embeddings3),dim=2)
+
+    if(verbose !=0):
+      print('MERGED POST ',posteriograms_merged.shape)
+      print('MERGED emb ',embeddings_merged.shape)
+
+    return torch.cat((posteriograms_merged,embeddings_merged),dim=2).to(device)
+
+def decode(model,wavs,wav_lens):
+
+    with torch.no_grad():
+        wav_lens = wav_lens.to(model.device)
+        encoder_out = model.encode_batch(wavs, wav_lens)
+        predictions = model.decoding_function(encoder_out, wav_lens)
+        return predictions
+
+def middle_layer(batch, lens):
+
+    tn_embeddings, tn_posteriogram = asr_brain.custom_encode(batch,None)
+
+    fr_embeddings = french_asr_model.mods.encoder.wav2vec2(batch)
+    fr_posteriogram =french_asr_model.encode_batch(batch,lens)
+    en_embeddings = english_asr_model.modules.wav2vec2(batch, lens)
+    x = english_asr_model.modules.enc(en_embeddings)
+    en_posteriogram = english_asr_model.modules.ctc_lin(x)
+    #scores, en_posteriogram = english_asr_model.mods.decoder(en_embeddings ,lens)
+    if(verbose !=0):
+      print('[EMBEDDINGS] FR:',fr_embeddings.shape, "EN:",en_embeddings.shape, "TN:", tn_embeddings.shape)
+      print('[POSTERIOGRAM] FR:',fr_posteriogram.shape, "EN:",en_posteriogram.shape,"TN:",tn_posteriogram.shape)
+
+
+    bilangual_sample = merge_strategy(fr_embeddings,en_embeddings,tn_embeddings,fr_posteriogram,en_posteriogram,tn_posteriogram)
+    return bilangual_sample
+
+class Mixer(sb.core.Brain):
+
+    def compute_forward(self, batch, stage):
+        """Forward computations from the waveform batches to the output probabilities."""
+        wavs, wav_lens = batch.sig
+        wavs, wav_lens = wavs.to(self.device), wav_lens.to(self.device)
+
+        if stage == sb.Stage.TRAIN:
+            if hasattr(self.hparams, "augmentation"):
+                wavs = self.hparams.augmentation(wavs, wav_lens)
+
+        multi_langual_feats = middle_layer(wavs, wav_lens)
+        multi_langual_feats= multi_langual_feats.to(device)
+        feats, _ = self.modules.enc(multi_langual_feats)
+        logits = self.modules.ctc_lin(feats)
+        p_ctc = self.hparams.log_softmax(logits)
+        
+        if stage!= sb.Stage.TRAIN:
+            p_tokens = sb.decoders.ctc_greedy_decode(
+                p_ctc, wav_lens, blank_id=self.hparams.blank_index
+            )
+        else : 
+            p_tokens = None
+        return p_ctc, wav_lens, p_tokens
+
+    def compute_objectives(self, predictions, batch, stage):
+        """Computes the loss (CTC) given predictions and targets."""
+
+        p_ctc, wav_lens , predicted_tokens= predictions
+
+        ids = batch.id
+        tokens, tokens_lens = batch.tokens
+
+        loss = self.hparams.ctc_cost(p_ctc, tokens, wav_lens, tokens_lens)
+
+
+        if stage == sb.Stage.VALID:
+            predicted_words = [
+                "".join(self.tokenizer.decode_ndim(utt_seq)).split(" ")
+                for utt_seq in predicted_tokens
+            ]
+            target_words = [wrd.split(" ") for wrd in batch.wrd]
+            self.wer_metric.append(ids, predicted_words, target_words)
+            self.cer_metric.append(ids, predicted_words, target_words)
+        if stage ==sb.Stage.TEST : 
+            if self.hparams.language_modelling:
+                predicted_words = []
+                for logs in p_ctc:
+                    text = decoder.decode(logs.detach().cpu().numpy())
+                    predicted_words.append(text.split(" "))
+            else : 
+                predicted_words = [
+                    "".join(self.tokenizer.decode_ndim(utt_seq)).split(" ")
+                    for utt_seq in predicted_tokens
+                ]
+
+            target_words = [wrd.split(" ") for wrd in batch.wrd]
+            self.wer_metric.append(ids, predicted_words, target_words)
+            self.cer_metric.append(ids, predicted_words, target_words)
+
+        return loss
+
+    def fit_batch(self, batch):
+        """Train the parameters given a single batch in input"""
+        should_step = self.step % self.grad_accumulation_factor == 0
+        # Managing automatic mixed precision
+        # TOFIX: CTC fine-tuning currently is unstable
+        # This is certainly due to CTC being done in fp16 instead of fp32
+        if self.auto_mix_prec:
+            with torch.cuda.amp.autocast():
+                with self.no_sync():
+                    outputs = self.compute_forward(batch, sb.Stage.TRAIN)
+                loss = self.compute_objectives(outputs, batch, sb.Stage.TRAIN)
+            with self.no_sync(not should_step):
+                self.scaler.scale(
+                    loss / self.grad_accumulation_factor
+                ).backward()
+            if should_step:
+
+
+                self.scaler.unscale_(self.model_optimizer)
+                if self.check_gradients(loss):
+                    self.scaler.step(self.model_optimizer)
+                self.scaler.update()
+                self.zero_grad()
+                self.optimizer_step += 1
+        else:
+            # This is mandatory because HF models have a weird behavior with DDP
+            # on the forward pass
+            with self.no_sync():
+                outputs = self.compute_forward(batch, sb.Stage.TRAIN)
+
+            loss = self.compute_objectives(outputs, batch, sb.Stage.TRAIN)
+
+            with self.no_sync(not should_step):
+                (loss / self.grad_accumulation_factor).backward()
+            if should_step:
+                if self.check_gradients(loss):
+                    self.model_optimizer.step()
+                self.zero_grad()
+                self.optimizer_step += 1
+
+        self.on_fit_batch_end(batch, outputs, loss, should_step)
+        return loss.detach().cpu()
+
+    def evaluate_batch(self, batch, stage):
+        """Computations needed for validation/test batches"""
+        predictions = self.compute_forward(batch, stage=stage)
+        with torch.no_grad():
+            loss = self.compute_objectives(predictions, batch, stage=stage)
+        return loss.detach()
+
+    def on_stage_start(self, stage, epoch):
+        """Gets called at the beginning of each epoch"""
+        if stage != sb.Stage.TRAIN:
+            self.cer_metric = self.hparams.cer_computer()
+            self.wer_metric = self.hparams.error_rate_computer()
+
+    def on_stage_end(self, stage, stage_loss, epoch):
+        """Gets called at the end of an epoch."""
+        # Compute/store important stats
+        stage_stats = {"loss": stage_loss}
+        if stage == sb.Stage.TRAIN:
+            self.train_stats = stage_stats
+        else:
+            stage_stats["CER"] = self.cer_metric.summarize("error_rate")
+            stage_stats["WER"] = self.wer_metric.summarize("error_rate")
+
+        # Perform end-of-iteration things, like annealing, logging, etc.
+        if stage == sb.Stage.VALID:
+            old_lr_model, new_lr_model = self.hparams.lr_annealing_model(
+                stage_stats["loss"]
+            )
+            sb.nnet.schedulers.update_learning_rate(
+                self.model_optimizer, new_lr_model
+            )
+            self.hparams.train_logger.log_stats(
+                stats_meta={
+                    "epoch": epoch,
+                    "lr_model": old_lr_model,
+                },
+                train_stats=self.train_stats,
+                valid_stats=stage_stats,
+            )
+            self.checkpointer.save_and_keep_only(
+                meta={"WER": stage_stats["WER"]}, min_keys=["WER"],
+            )
+        elif stage == sb.Stage.TEST:
+            self.hparams.train_logger.log_stats(
+                stats_meta={"Epoch loaded": self.hparams.epoch_counter.current},
+                test_stats=stage_stats,
+            )
+            with open(self.hparams.wer_file, "w") as w:
+                self.wer_metric.write_stats(w)
+
+    def init_optimizers(self):
+
+        self.model_optimizer = self.hparams.model_opt_class(
+            self.hparams.model.parameters()
+        )
+
+        if self.checkpointer is not None:
+            self.checkpointer.add_recoverable("modelopt", self.model_optimizer)
+
+    def zero_grad(self, set_to_none=False):
+
+        self.model_optimizer.zero_grad(set_to_none)
+
+
+hparams_file, run_opts, overrides = sb.parse_arguments(sys.argv[1:])
+
+# If distributed_launch=True then
+# create ddp_group with the right communication protocol
+sb.utils.distributed.ddp_init_group(run_opts)
+
+with open(hparams_file) as fin:
+    hparams = load_hyperpyyaml(fin, overrides)
+
+# Create experiment directory
+sb.create_experiment_directory(
+    experiment_directory=hparams["output_folder"],
+    hyperparams_to_save=hparams_file,
+    overrides=overrides,
+)
+def read_labels_file(labels_file):
+    with open(labels_file, "r",encoding="utf-8") as lf:
+        lines = lf.read().splitlines()
+        division = "==="
+        numbers = {}
+        for line in lines :
+            if division in line :
+                break
+            string, number = line.split("=>")
+            number = int(number)
+            string = string[1:-2]
+            numbers[number] = string
+        return [numbers[x] for x in range(len(numbers))]
+train_data, valid_data, test_datasets, label_encoder = dataio_prepare(
+        hparams
+    )
+
+
+labels = read_labels_file(os.path.join(hparams["save_folder"], "label_encoder.txt"))
+labels = [""] + labels[1:-1] + ["1"] 
+if hparams["language_modelling"]:
+    decoder = build_ctcdecoder(
+        labels,
+        kenlm_model_path=hparams["ngram_lm_path"],  # either .arpa or .bin file
+        alpha=0.5,  # tuned on a val set
+        beta=1,  # tuned on a val set
+    )
+
+
+
+
+mixer = Mixer(
+    modules=hparams["modules"],
+    hparams=hparams,
+    run_opts=run_opts,
+    checkpointer=hparams["checkpointer"],
+)
+mixer.tokenizer = label_encoder
+
+
+mixer.fit(
+    mixer.hparams.epoch_counter,
+    train_data,
+    valid_data,
+    train_loader_kwargs=hparams["dataloader_options"],
+    valid_loader_kwargs=hparams["test_dataloader_options"],
+)
+print(test_datasets.keys())
+for k in test_datasets.keys():  # keys are test_clean, test_other etc
+    mixer.hparams.wer_file = os.path.join(
+        hparams["output_folder"], "wer_{}.txt".format(k)
+    )
+    mixer.evaluate(
+        test_datasets[k], test_loader_kwargs=hparams["test_dataloader_options"]
+        )
+

results/non_semi_final_stac/hyperparams.yaml

@@ -0,0 +1,144 @@
+# Generated 2023-09-08 from:
+# /gpfsssd/scratch/rech/nou/uzn19yk/switched_data/stac.yaml
+# yamllint disable
+# Generated 2023-08-03 from:
+# /home/salah/new_tunisian_model/hparams/train_tunisian_withwavlm.yaml
+# yamllint disable
+# ################################
+# Model: wav2vec2 + DNN + CTC
+# Augmentation: SpecAugment
+# Authors: Titouan Parcollet 2021
+# ################################
+
+seed: 1994
+__set_seed: !!python/object/apply:torch.manual_seed [1234]
+output_folder: results/non_semi_final_stac
+wer_file: results/non_semi_final_stac/wer.txt
+save_folder: results/non_semi_final_stac/save
+train_log: results/non_semi_final_stac/train_log.txt
+
+
+
+# Data files
+data_folder: junk  # e.g, /localscratch/cv-corpus-5.1-2020-06-22/fr
+train_tsv_file: junk/train.tsv                # Standard CommonVoice .tsv files
+dev_tsv_file: junk/dev.tsv                # Standard CommonVoice .tsv files
+test_tsv_file: junk/test.tsv                # Standard CommonVoice .tsv files
+accented_letters: true
+
+csv_folder: /gpfsscratch/rech/nou/uzn19yk/switched_data/extended_clean/
+train_csv: /gpfsscratch/rech/nou/uzn19yk/switched_data/extended_clean//train.csv
+valid_csv: /gpfsscratch/rech/nou/uzn19yk/switched_data/extended_clean//dev.csv
+test_csv:
+- all_tests/cs_test.csv
+- all_tests/stac_test.csv
+
+# We remove utterance slonger than 10s in the train/dev/test sets as
+# longer sentences certainly correspond to "open microphones".
+avoid_if_longer_than: 13.0
+avoid_if_shorter_than: 0.5
+
+# Training parameters
+number_of_epochs: 20
+lr: 0.0002
+lr_weights: 0.01
+sorting: ascending
+auto_mix_prec: false
+sample_rate: 16000
+language_modelling: true
+ngram_lm_path: 
+  /gpfsstore/rech/nou/uzn19yk/switched_code_tunisian/train/tunisian_asr/arpas/pluslanguages_everything.arpa
+
+# With data_parallel batch_size is split into N jobs
+# With DDP batch_size is multiplied by N jobs
+# Must be 3 per GPU to fit 32GB of VRAM
+batch_size: 3
+test_batch_size: 4
+
+# Dataloader options
+dataloader_options:
+  batch_size: 3
+  num_workers: 6
+
+test_dataloader_options:
+  batch_size: 4
+  num_workers: 6
+
+# Model parameters
+activation: !name:torch.nn.Sigmoid
+dnn_layers: 1
+dnn_neurons: 768
+freeze_encoder: true
+
+# Outputs
+output_neurons: 76  # BPE size, index(blank/eos/bos) = 0
+
+# Functions and classes
+#
+epoch_counter: &id006 !new:speechbrain.utils.epoch_loop.EpochCounter
+  limit: 20
+
+encoder_dim: 3217
+enc: &id001 !new:speechbrain.nnet.RNN.LSTM
+  input_shape: [null, null, 3217]
+  num_layers: 2
+  bidirectional: true
+  dropout: 0.2
+  hidden_size: 1024
+
+ctc_lin: &id002 !new:speechbrain.nnet.linear.Linear
+
+  input_size: 2048
+  n_neurons: 76
+
+log_softmax: !new:speechbrain.nnet.activations.Softmax
+  apply_log: true
+
+ctc_cost: !name:speechbrain.nnet.losses.ctc_loss
+  blank_index: 0
+
+modules:
+  enc: *id001
+  ctc_lin: *id002
+model: &id003 !new:torch.nn.ModuleList
+- [*id001, *id002]
+model_opt_class: !name:torch.optim.Adam
+  lr: 0.0002
+
+weights_opt_class: !name:torch.optim.Adam
+  lr: 0.01
+
+lr_annealing_model: &id004 !new:speechbrain.nnet.schedulers.NewBobScheduler
+  initial_value: 0.0002
+  improvement_threshold: 0.0025
+  annealing_factor: 0.8
+  patient: 0
+
+lr_annealing_weights: &id005 !new:speechbrain.nnet.schedulers.NewBobScheduler
+  initial_value: 0.01
+  improvement_threshold: 0.0025
+  annealing_factor: 0.9
+  patient: 0
+
+label_encoder: &id007 !new:speechbrain.dataio.encoder.CTCTextEncoder
+
+
+checkpointer: !new:speechbrain.utils.checkpoints.Checkpointer
+  checkpoints_dir: results/non_semi_final_stac/save
+  recoverables:
+    model: *id003
+    scheduler_model: *id004
+    scheduler_encoder: *id005
+    counter: *id006
+    tokenizer: *id007
+blank_index: 0
+unk_index: 1
+
+
+train_logger: !new:speechbrain.utils.train_logger.FileTrainLogger
+  save_file: results/non_semi_final_stac/train_log.txt
+
+error_rate_computer: !name:speechbrain.utils.metric_stats.ErrorRateStats
+
+cer_computer: !name:speechbrain.utils.metric_stats.ErrorRateStats
+  split_tokens: true

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/CKPT.yaml

@@ -0,0 +1,4 @@
+# yamllint disable
+WER: 51.292116454039906
+end-of-epoch: true
+unixtime: 1694130018.9642384

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/brain.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e5c026fe6fa51700406bd476e131950c797b0b3bacb3daae0854e85689bb4cf9
+size 50

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/counter.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f5ca38f748a1d6eaf726b8a42fb575c3c71f1864a8143301782de13da2d9202b
+size 2

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/dataloader-TRAIN.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7e1edcac43af8cea1439d222314af06354ae31da6a3d90b8cc6bcebc5c8e397
+size 4

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/model.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da683a8efa5709a06af9b258452c243da841780a0a7942c196c472a3e21e5010
+size 240389017

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/modelopt.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:416feb314443cf839f4425fc382e555dec90e3dea26fa52b75e4ac1b702c5078
+size 480787579

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/scheduler_encoder.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e2efd50f0cf28a080e2625fdd8a1852c669841537cdc0a57fce60bc6c1eec11
+size 515

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/scheduler_model.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cec54cc9236fa7aa965b397675d24299b973675cc0c6345de038fc70e51629ab
+size 703

results/non_semi_final_stac/save/CKPT+2023-09-08+01-40-18+00/tokenizer.ckpt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:21080a140faeb4f39fad188aaf081914ec782be9c4320d6415e8822709e18017
+size 39

results/non_semi_final_stac/save/label_encoder.txt

@@ -0,0 +1,80 @@
+'و' => 74
+'ي' => 1
+'ن' => 2
+' ' => 3
+'م' => 4
+'ش' => 5
+'ل' => 6
+'س' => 7
+'ت' => 8
+'ا' => 9
+'د' => 10
+'ر' => 11
+'ى' => 12
+'ب' => 13
+'ح' => 14
+'ط' => 15
+'ع' => 16
+'ك' => 17
+'ف' => 18
+'ق' => 19
+'ذ' => 20
+'ث' => 21
+'ج' => 22
+'ة' => 23
+'غ' => 24
+'o' => 25
+'k' => 26
+'b' => 27
+'n' => 28
+'خ' => 29
+'ه' => 30
+'v' => 31
+'i' => 32
+'l' => 33
+'à' => 34
+'ص' => 35
+'ض' => 36
+'a' => 37
+'u' => 38
+'t' => 39
+'m' => 40
+'q' => 41
+'e' => 42
+'d' => 43
+'c' => 44
+'p' => 45
+'r' => 46
+'أ' => 47
+'إ' => 48
+'s' => 49
+'j' => 50
+'ز' => 51
+'ء' => 52
+'h' => 53
+'f' => 54
+'آ' => 55
+'ئ' => 56
+'ؤ' => 57
+'ظ' => 58
+'y' => 59
+'é' => 60
+"'" => 61
+'z' => 62
+'x' => 63
+'w' => 64
+'g' => 65
+'è' => 66
+'û' => 67
+'ç' => 68
+'ê' => 69
+'ô' => 70
+'ù' => 71
+'î' => 72
+'â' => 73
+'<blank>' => 0
+1 => 75
+================
+'starting_index' => 0
+'unk_label' => 1
+'blank_label' => '<blank>'