nkululeko 0.84.1__py3-none-any.whl → 0.85.1__py3-none-any.whl

nkululeko/constants.py

@@ -1,2 +1,2 @@
-VERSION="0.84.1"
+VERSION="0.85.1"
 SAMPLING_RATE = 16000

nkululeko/experiment.py

@@ -340,7 +340,12 @@ class Experiment:
         df_train, df_test = self.df_train, self.df_test
         feats_name = "_".join(ast.literal_eval(glob_conf.config["DATA"]["databases"]))
         self.feats_test, self.feats_train = pd.DataFrame(), pd.DataFrame()
-        feats_types = self.util.config_val_list("FEATS", "type", ["os"])
+        feats_types = self.util.config_val_list("FEATS", "type", [])
+        # for some models no features are needed
+        if len(feats_types) == 0:
+            self.util.debug("no feature extractor specified.")
+            self.feats_train, self.feats_test = pd.DataFrame(), pd.DataFrame()
+            return
         self.feature_extractor = FeatureExtractor(
             df_train, feats_types, feats_name, "train"
         )

nkululeko/feat_extract/feats_whisper.py

@@ -32,22 +32,19 @@ class Whisper(Featureset):
         model_name = f"openai/{self.feat_type}"
         self.model = WhisperModel.from_pretrained(model_name).to(self.device)
         print(f"intialized Whisper model on {self.device}")
-        self.feature_extractor = AutoFeatureExtractor.from_pretrained(
-            model_name)
+        self.feature_extractor = AutoFeatureExtractor.from_pretrained(model_name)
         self.model_initialized = True
 
     def extract(self):
         """Extract the features or load them from disk if present."""
         store = self.util.get_path("store")
         storage = f"{store}{self.name}.pkl"
-        extract = self.util.config_val(
-            "FEATS", "needs_feature_extraction", False)
+        extract = self.util.config_val("FEATS", "needs_feature_extraction", False)
         no_reuse = eval(self.util.config_val("FEATS", "no_reuse", "False"))
         if extract or no_reuse or not os.path.isfile(storage):
             if not self.model_initialized:
                 self.init_model()
-            self.util.debug(
-                "extracting whisper embeddings, this might take a while...")
+            self.util.debug("extracting whisper embeddings, this might take a while...")
             emb_series = []
             for (file, start, end), _ in audeer.progress_bar(
                 self.data_df.iterrows(),

nkululeko/modelrunner.py

@@ -47,16 +47,12 @@ class Modelrunner:
             highest = 0
         else:
             highest = 100000
-        # for all epochs
-        for epoch in range(epoch_num):
-            if only_test:
-                self.model.load(self.run, epoch)
-                self.util.debug(f"reusing model: {self.model.store_path}")
-                self.model.reset_test(self.df_test, self.feats_test)
-            else:
-                self.model.set_id(self.run, epoch)
-                self.model.train()
+        if self.model.model_type == "finetuned":
+            # epochs are handled by Huggingface API
+            self.model.train()
             report = self.model.predict()
+            # todo: findout the best epoch
+            epoch = epoch_num
             report.set_id(self.run, epoch)
             plot_name = self.util.get_plot_name() + f"_{self.run}_{epoch:03d}_cnf"
             reports.append(report)
@@ -67,32 +63,53 @@ class Modelrunner:
             if plot_epochs:
                 self.util.debug(f"plotting conf matrix to {plot_name}")
                 report.plot_confmatrix(plot_name, epoch)
-            store_models = self.util.config_val("EXP", "save", False)
-            plot_best_model = self.util.config_val("PLOT", "best_model", False)
-            if (store_models or plot_best_model) and (
-                not only_test
-            ):  # in any case the model needs to be stored to disk.
-                self.model.store()
-            if patience:
-                patience = int(patience)
-                result = report.result.get_result()
-                if self.util.high_is_good():
-                    if result > highest:
-                        highest = result
-                        patience_counter = 0
-                    else:
-                        patience_counter += 1
+        else:
+            # for all epochs
+            for epoch in range(epoch_num):
+                if only_test:
+                    self.model.load(self.run, epoch)
+                    self.util.debug(f"reusing model: {self.model.store_path}")
+                    self.model.reset_test(self.df_test, self.feats_test)
                 else:
-                    if result < highest:
-                        highest = result
-                        patience_counter = 0
+                    self.model.set_id(self.run, epoch)
+                    self.model.train()
+                report = self.model.predict()
+                report.set_id(self.run, epoch)
+                plot_name = self.util.get_plot_name() + f"_{self.run}_{epoch:03d}_cnf"
+                reports.append(report)
+                self.util.debug(
+                    f"run: {self.run} epoch: {epoch}: result: "
+                    f"{reports[-1].get_result().get_test_result()}"
+                )
+                if plot_epochs:
+                    self.util.debug(f"plotting conf matrix to {plot_name}")
+                    report.plot_confmatrix(plot_name, epoch)
+                store_models = self.util.config_val("EXP", "save", False)
+                plot_best_model = self.util.config_val("PLOT", "best_model", False)
+                if (store_models or plot_best_model) and (
+                    not only_test
+                ):  # in any case the model needs to be stored to disk.
+                    self.model.store()
+                if patience:
+                    patience = int(patience)
+                    result = report.result.get_result()
+                    if self.util.high_is_good():
+                        if result > highest:
+                            highest = result
+                            patience_counter = 0
+                        else:
+                            patience_counter += 1
                     else:
-                        patience_counter += 1
-                if patience_counter >= patience:
-                    self.util.debug(
-                        f"reached patience ({str(patience)}): early stopping"
-                    )
-                    break
+                        if result < highest:
+                            highest = result
+                            patience_counter = 0
+                        else:
+                            patience_counter += 1
+                    if patience_counter >= patience:
+                        self.util.debug(
+                            f"reached patience ({str(patience)}): early stopping"
+                        )
+                        break
 
         if not plot_epochs:
             # Do at least one confusion matrix plot
@@ -133,6 +150,12 @@ class Modelrunner:
             self.model = Bayes_model(
                 self.df_train, self.df_test, self.feats_train, self.feats_test
             )
+        elif model_type == "finetune":
+            from nkululeko.models.model_tuned import TunedModel
+
+            self.model = TunedModel(
+                self.df_train, self.df_test, self.feats_train, self.feats_test
+            )
         elif model_type == "gmm":
             from nkululeko.models.model_gmm import GMM_model
 

nkululeko/models/finetune_model.py

@@ -1,3 +1,7 @@
+"""
+Code based on @jwagner
+"""
+
 import dataclasses
 import typing
 
@@ -148,6 +152,11 @@ class Model(Wav2Vec2PreTrainedModel):
                 logits_cat=logits_cat,
             )
 
+    def predict(self, signal):
+        result = self(torch.from_numpy(signal))
+        result = result[0].detach().numpy()[0]
+        return result
+
 
 class ModelWithPreProcessing(Model):
 

nkululeko/models/model.py

@@ -39,7 +39,7 @@ class Model:
         self.model_type = type
 
     def is_ann(self):
-        if self.model_type == "ann":
+        if (self.model_type == "ann") or (self.model_type == "finetuned"):
             return True
         else:
             return False

nkululeko/models/model_tuned.py

@@ -0,0 +1,479 @@
+"""
+Code based on @jwagner.
+"""
+
+import dataclasses
+import json
+import os
+import pickle
+import typing
+
+import datasets
+import numpy as np
+import pandas as pd
+import torch
+import transformers
+from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2Model
+from transformers.models.wav2vec2.modeling_wav2vec2 import Wav2Vec2PreTrainedModel
+
+import audeer
+import audiofile
+import audmetric
+
+import nkululeko.glob_conf as glob_conf
+from nkululeko.models.model import Model as BaseModel
+from nkululeko.reporting.reporter import Reporter
+
+
+class TunedModel(BaseModel):
+
+    is_classifier = True
+
+    def __init__(self, df_train, df_test, feats_train, feats_test):
+        """Constructor taking the configuration and all dataframes."""
+        super().__init__(df_train, df_test, feats_train, feats_test)
+        super().set_model_type("finetuned")
+        self.name = "finetuned_wav2vec2"
+        self.target = glob_conf.config["DATA"]["target"]
+        labels = glob_conf.labels
+        self.class_num = len(labels)
+        device = self.util.config_val("MODEL", "device", "cpu")
+        self.batch_size = int(self.util.config_val("MODEL", "batch_size", "8"))
+        if device != "cpu":
+            self.util.debug(f"running on device {device}")
+            os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
+            os.environ["CUDA_VISIBLE_DEVICES"] = device
+        self.df_train, self.df_test = df_train, df_test
+        self.epoch_num = int(self.util.config_val("EXP", "epochs", 1))
+
+        self._init_model()
+
+    def _init_model(self):
+        model_path = "facebook/wav2vec2-large-robust-ft-swbd-300h"
+        self.num_layers = None
+        self.sampling_rate = 16000
+        self.max_duration_sec = 8.0
+        self.accumulation_steps = 4
+        # create dataset
+
+        dataset = {}
+        target_name = glob_conf.target
+        data_sources = {
+            "train": pd.DataFrame(self.df_train[target_name]),
+            "dev": pd.DataFrame(self.df_test[target_name]),
+        }
+
+        for split in ["train", "dev"]:
+            df = data_sources[split]
+            y = df[target_name].astype("float")
+            y.name = "targets"
+            df = y.reset_index()
+            df.start = df.start.dt.total_seconds()
+            df.end = df.end.dt.total_seconds()
+            ds = datasets.Dataset.from_pandas(df)
+            dataset[split] = ds
+
+        self.dataset = datasets.DatasetDict(dataset)
+
+        # load pre-trained model
+        le = glob_conf.label_encoder
+        mapping = dict(zip(le.classes_, range(len(le.classes_))))
+        target_mapping = {k: int(v) for k, v in mapping.items()}
+        target_mapping_reverse = {value: key for key, value in target_mapping.items()}
+
+        self.config = transformers.AutoConfig.from_pretrained(
+            model_path,
+            num_labels=len(target_mapping),
+            label2id=target_mapping,
+            id2label=target_mapping_reverse,
+            finetuning_task=target_name,
+        )
+        if self.num_layers is not None:
+            self.config.num_hidden_layers = self.num_layers
+        setattr(self.config, "sampling_rate", self.sampling_rate)
+        setattr(self.config, "data", self.util.get_data_name())
+
+        vocab_dict = {}
+        with open("vocab.json", "w") as vocab_file:
+            json.dump(vocab_dict, vocab_file)
+        tokenizer = transformers.Wav2Vec2CTCTokenizer("./vocab.json")
+        tokenizer.save_pretrained(".")
+
+        feature_extractor = transformers.Wav2Vec2FeatureExtractor(
+            feature_size=1,
+            sampling_rate=16000,
+            padding_value=0.0,
+            do_normalize=True,
+            return_attention_mask=True,
+        )
+        self.processor = transformers.Wav2Vec2Processor(
+            feature_extractor=feature_extractor,
+            tokenizer=tokenizer,
+        )
+        assert self.processor.feature_extractor.sampling_rate == self.sampling_rate
+
+        self.model = Model.from_pretrained(
+            model_path,
+            config=self.config,
+        )
+        self.model.freeze_feature_extractor()
+        self.model.train()
+        self.model_initialized = True
+
+    def set_model_type(self, type):
+        self.model_type = type
+
+    def set_testdata(self, data_df, feats_df):
+        self.df_test, self.feats_test = data_df, feats_df
+
+    def reset_test(self, df_test, feats_test):
+        self.df_test, self.feats_test = df_test, feats_test
+
+    def set_id(self, run, epoch):
+        self.run = run
+        self.epoch = epoch
+        dir = self.util.get_path("model_dir")
+        name = f"{self.util.get_exp_name(only_train=True)}_{self.run}_{self.epoch:03d}.model"
+        self.store_path = dir + name
+
+    def data_collator(self, data):
+        files = [d["file"] for d in data]
+        starts = [d["start"] for d in data]
+        ends = [d["end"] for d in data]
+        targets = [d["targets"] for d in data]
+
+        signals = []
+        for file, start, end in zip(
+            files,
+            starts,
+            ends,
+        ):
+            offset = start
+            duration = end - offset
+            if self.max_duration_sec is not None:
+                duration = min(duration, self.max_duration_sec)
+            signal, _ = audiofile.read(
+                file,
+                offset=offset,
+                duration=duration,
+            )
+            signals.append(signal.squeeze())
+
+        input_values = self.processor(
+            signals,
+            sampling_rate=self.sampling_rate,
+            padding=True,
+        )
+        batch = self.processor.pad(
+            input_values,
+            padding=True,
+            return_tensors="pt",
+        )
+
+        batch["labels"] = torch.tensor(targets)
+
+        return batch
+
+    def compute_metrics(self, p: transformers.EvalPrediction):
+
+        metrics = {
+            "UAR": audmetric.unweighted_average_recall,
+            "ACC": audmetric.accuracy,
+        }
+
+        # truth = p.label_ids[:, 0].astype(int)
+        truth = p.label_ids
+        preds = p.predictions
+        preds = np.argmax(preds, axis=1)
+        scores = {}
+        for name, metric in metrics.items():
+            scores[f"{name}"] = metric(truth, preds)
+        return scores
+
+    def train(self):
+        """Train the model."""
+        model_root = self.util.get_path("model_dir")
+        log_root = os.path.join(self.util.get_exp_dir(), "log")
+        audeer.mkdir(log_root)
+        self.torch_root = audeer.path(model_root, "torch")
+        conf_file = os.path.join(self.torch_root, "config.json")
+        if os.path.isfile(conf_file):
+            self.util.debug(f"reusing finetuned model: {conf_file}")
+            self.load(self.run, self.epoch_num)
+            return
+        targets = pd.DataFrame(self.dataset["train"]["targets"])
+        counts = targets[0].value_counts().sort_index()
+        train_weights = 1 / counts
+        train_weights /= train_weights.sum()
+        self.util.debug("train weights: {train_weights}")
+        criterion = torch.nn.CrossEntropyLoss(
+            weight=torch.Tensor(train_weights).to("cuda"),
+        )
+        # criterion = torch.nn.CrossEntropyLoss()
+
+        class Trainer(transformers.Trainer):
+
+            def compute_loss(
+                self,
+                model,
+                inputs,
+                return_outputs=False,
+            ):
+
+                targets = inputs.pop("labels").squeeze()
+                targets = targets.type(torch.long)
+
+                outputs = model(**inputs)
+                logits = outputs[0].squeeze()
+
+                loss = criterion(logits, targets)
+
+                return (loss, outputs) if return_outputs else loss
+
+        num_steps = (
+            len(self.dataset["train"])
+            // (self.batch_size * self.accumulation_steps)
+            // 5
+        )
+        num_steps = max(1, num_steps)
+        # print(num_steps)
+
+        training_args = transformers.TrainingArguments(
+            output_dir=model_root,
+            logging_dir=log_root,
+            per_device_train_batch_size=self.batch_size,
+            per_device_eval_batch_size=self.batch_size,
+            gradient_accumulation_steps=self.accumulation_steps,
+            evaluation_strategy="steps",
+            num_train_epochs=self.epoch_num,
+            fp16=True,
+            save_steps=num_steps,
+            eval_steps=num_steps,
+            logging_steps=num_steps,
+            learning_rate=1e-4,
+            save_total_limit=2,
+            metric_for_best_model="UAR",
+            greater_is_better=True,
+            load_best_model_at_end=True,
+            remove_unused_columns=False,
+            report_to="none",
+        )
+
+        trainer = Trainer(
+            model=self.model,
+            data_collator=self.data_collator,
+            args=training_args,
+            compute_metrics=self.compute_metrics,
+            train_dataset=self.dataset["train"],
+            eval_dataset=self.dataset["dev"],
+            tokenizer=self.processor.feature_extractor,
+            callbacks=[transformers.integrations.TensorBoardCallback()],
+        )
+        trainer.train()
+        trainer.save_model(self.torch_root)
+        self.load(self.run, self.epoch)
+
+    def get_predictions(self):
+        results = []
+        for (file, start, end), _ in audeer.progress_bar(
+            self.df_test.iterrows(),
+            total=len(self.df_test),
+            desc=f"Predicting {len(self.df_test)} audiofiles",
+        ):
+            if end == pd.NaT:
+                signal, sr = audiofile.read(file, offset=start)
+            else:
+                signal, sr = audiofile.read(
+                    file, duration=end - start, offset=start, always_2d=True
+                )
+            assert sr == self.sampling_rate
+            predictions = self.model.predict(signal)
+            results.append(predictions.argmax())
+        return results
+
+    def predict(self):
+        """Predict the whole eval feature set"""
+        predictions = self.get_predictions()
+        report = Reporter(
+            self.df_test[self.target].to_numpy().astype(float),
+            predictions,
+            self.run,
+            self.epoch_num,
+        )
+        return report
+
+    def predict_sample(self, signal):
+        """Predict one sample"""
+        prediction = {}
+        if self.util.exp_is_classification():
+            # get the class probabilities
+            predictions = self.model.predict(signal)
+            # pred = self.clf.predict(features)
+            for i in range(len(self.labels)):
+                cat = self.labels[i]
+                prediction[cat] = predictions[i]
+        else:
+            predictions = self.model.predict(signal)
+            prediction = predictions
+        return prediction
+
+    def store(self):
+        self.util.debug("stored: ")
+
+    def load(self, run, epoch):
+        self.set_id(run, epoch)
+        self.model = Model.from_pretrained(
+            self.torch_root,
+            config=self.config,
+        )
+        # print(f"loaded model type {type(self.model)}")
+
+    def load_path(self, path, run, epoch):
+        self.set_id(run, epoch)
+        with open(path, "rb") as handle:
+            self.clf = pickle.load(handle)
+
+
+@dataclasses.dataclass
+class ModelOutput(transformers.file_utils.ModelOutput):
+
+    logits_cat: torch.FloatTensor = None
+    hidden_states: typing.Tuple[torch.FloatTensor] = None
+    cnn_features: torch.FloatTensor = None
+
+
+class ModelHead(torch.nn.Module):
+
+    def __init__(self, config):
+
+        super().__init__()
+
+        self.dense = torch.nn.Linear(config.hidden_size, config.hidden_size)
+        self.dropout = torch.nn.Dropout(config.final_dropout)
+        self.out_proj = torch.nn.Linear(config.hidden_size, config.num_labels)
+
+    def forward(self, features, **kwargs):
+
+        x = features
+        x = self.dropout(x)
+        x = self.dense(x)
+        x = torch.tanh(x)
+        x = self.dropout(x)
+        x = self.out_proj(x)
+
+        return x
+
+
+class Model(Wav2Vec2PreTrainedModel):
+
+    def __init__(self, config):
+
+        super().__init__(config)
+
+        self.wav2vec2 = Wav2Vec2Model(config)
+        self.cat = ModelHead(config)
+        self.init_weights()
+
+    def freeze_feature_extractor(self):
+        self.wav2vec2.feature_extractor._freeze_parameters()
+
+    def pooling(
+        self,
+        hidden_states,
+        attention_mask,
+    ):
+
+        if attention_mask is None:  # For evaluation with batch_size==1
+            outputs = torch.mean(hidden_states, dim=1)
+        else:
+            attention_mask = self._get_feature_vector_attention_mask(
+                hidden_states.shape[1],
+                attention_mask,
+            )
+            hidden_states = hidden_states * torch.reshape(
+                attention_mask,
+                (-1, attention_mask.shape[-1], 1),
+            )
+            outputs = torch.sum(hidden_states, dim=1)
+            attention_sum = torch.sum(attention_mask, dim=1)
+            outputs = outputs / torch.reshape(attention_sum, (-1, 1))
+
+        return outputs
+
+    def forward(
+        self,
+        input_values,
+        attention_mask=None,
+        labels=None,
+        return_hidden=False,
+    ):
+
+        outputs = self.wav2vec2(
+            input_values,
+            attention_mask=attention_mask,
+        )
+
+        cnn_features = outputs.extract_features
+        hidden_states_framewise = outputs.last_hidden_state
+        hidden_states = self.pooling(
+            hidden_states_framewise,
+            attention_mask,
+        )
+        logits_cat = self.cat(hidden_states)
+
+        if not self.training:
+            logits_cat = torch.softmax(logits_cat, dim=1)
+
+        if return_hidden:
+
+            # make time last axis
+            cnn_features = torch.transpose(cnn_features, 1, 2)
+
+            return ModelOutput(
+                logits_cat=logits_cat,
+                hidden_states=hidden_states,
+                cnn_features=cnn_features,
+            )
+
+        else:
+
+            return ModelOutput(
+                logits_cat=logits_cat,
+            )
+
+    def predict(self, signal):
+        result = self(torch.from_numpy(signal))
+        result = result[0].detach().numpy()[0]
+        return result
+
+
+class ModelWithPreProcessing(Model):
+
+    def __init__(self, config):
+        super().__init__(config)
+
+    def forward(
+        self,
+        input_values,
+    ):
+        # Wav2Vec2FeatureExtractor.zero_mean_unit_var_norm():
+        # normed_slice = (vector - vector[:length].mean()) / np.sqrt(vector[:length].var() + 1e-7)
+
+        mean = input_values.mean()
+
+        # var = input_values.var()
+        # raises: onnxruntime.capi.onnxruntime_pybind11_state.NotImplemented: [ONNXRuntimeError] : 9 : NOT_IMPLEMENTED : Could not find an implementation for the node ReduceProd_3:ReduceProd(11)
+
+        var = torch.square(input_values - mean).mean()
+        input_values = (input_values - mean) / torch.sqrt(var + 1e-7)
+
+        output = super().forward(
+            input_values,
+            return_hidden=True,
+        )
+
+        return (
+            output.hidden_states,
+            output.logits_cat,
+            output.cnn_features,
+        )

nkululeko/test_pretrain.py

@@ -53,8 +53,8 @@ def doit(config_file):
     expr.fill_train_and_tests()
     util.debug(f"train shape : {expr.df_train.shape}, test shape:{expr.df_test.shape}")
 
+    model_root = util.get_path("model_dir")
     log_root = audeer.mkdir("log")
-    model_root = audeer.mkdir("model")
     torch_root = audeer.path(model_root, "torch")
 
     metrics_gender = {
@@ -69,7 +69,7 @@ def doit(config_file):
     num_layers = None
 
     os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
-    os.environ["CUDA_VISIBLE_DEVICES"] = "3"
+    os.environ["CUDA_VISIBLE_DEVICES"] = "0"
 
     batch_size = 16
     accumulation_steps = 4
@@ -259,6 +259,7 @@ def doit(config_file):
         greater_is_better=True,
         load_best_model_at_end=True,
         remove_unused_columns=False,
+        report_to="none",
     )
 
     trainer = Trainer(
@@ -271,9 +272,20 @@ def doit(config_file):
         tokenizer=processor.feature_extractor,
         callbacks=[transformers.integrations.TensorBoardCallback()],
     )
+    if False:
+        trainer.train()
+        trainer.save_model(torch_root)
 
-    trainer.train()
-    trainer.save_model(torch_root)
+    modelnew = fm.Model.from_pretrained(
+        torch_root,
+        config=config,
+    )
+    print(f"loaded new model type{type(modelnew)}")
+    import audiofile
+
+    signal, _ = audiofile.read("./test.wav", always_2d=True)
+    result = modelnew.predict(signal)
+    print(result)
 
     print("DONE")
 

{nkululeko-0.84.1.dist-info → nkululeko-0.85.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: nkululeko
-Version: 0.84.1
+Version: 0.85.1
 Summary: Machine learning audio prediction experiments based on templates
 Home-page: https://github.com/felixbur/nkululeko
 Author: Felix Burkhardt
@@ -333,6 +333,14 @@ F. Burkhardt, Johannes Wagner, Hagen Wierstorf, Florian Eyben and Björn Schulle
 Changelog
 =========
 
+Version 0.85.1
+--------------
+* fixed bug in model_finetuned that label_num was constant 2
+
+Version 0.85.0
+--------------
+* first version with finetuning wav2vec2 layers
+
 Version 0.84.1
 --------------
 * made resample independent of config file

{nkululeko-0.84.1.dist-info → nkululeko-0.85.1.dist-info}/RECORD

@@ -2,18 +2,18 @@ nkululeko/__init__.py,sha256=62f8HiEzJ8rG2QlTFJXUCMpvuH3fKI33DoJSj33mscc,63
 nkululeko/aug_train.py,sha256=YhuZnS_WVWnun9G-M6g5n6rbRxoVREz6Zh7k6qprFNQ,3194
 nkululeko/augment.py,sha256=4MG0apTAG5RgkuJrYEjGgDdbodZWi_HweSPNI1JJ5QA,3051
 nkululeko/cacheddataset.py,sha256=lIJ6hUo5LoxSrzXtWV8mzwO7wRtUETWnOQ4ws2XfL1E,969
-nkululeko/constants.py,sha256=31GQXyAN-nrfQCNIt6_aSkBVeE_J3GO-PklTEy6EgBg,39
+nkululeko/constants.py,sha256=WnTSXQjJmWE-IrXcNSEa5FFV_83-z0EOGXa9trq00uE,39
 nkululeko/demo.py,sha256=8bl15Kitoesnz8oa8yrs52T6YCSOhWbbq9PnZ8Hj6D0,3232
 nkululeko/demo_feats.py,sha256=sAeGFojhEj9WEDFtG3SzPBmyYJWLF2rkbpp65m8Ujo4,2025
 nkululeko/demo_predictor.py,sha256=es56xbT8ifkS_vnrlb5NTZT54gNmeUtNlA4zVA_gnN8,4757
-nkululeko/experiment.py,sha256=mYdHfInMkuOI3frkZo7oaEe9viO-Qa1ZShyF6MPozcU,30225
+nkululeko/experiment.py,sha256=9Nw23b7sVOciH8IaOuAAKbY7otXYSsPrj_rQCA_U9cc,30465
 nkululeko/explore.py,sha256=lDzRoW_Taa5u4BBABZLD89BcQWnYlrftJR4jgt1yyj0,2609
 nkululeko/export.py,sha256=mHeEAAmtZuxdyebLlbSzPrHSi9OMgJHbk35d3DTxRBc,4632
 nkululeko/feature_extractor.py,sha256=8mssYKmo4LclVI-hiLmJEDZ0ZPyDavFG2YwtXcrGzwM,3976
 nkululeko/file_checker.py,sha256=LoLnL8aHpW-axMQ46qbqrManTs5otG9ShpEZuz9iRSk,3474
 nkululeko/filter_data.py,sha256=w-X2mhKdYr5DxDIz50E5yzO6Jmzk4jjDBoXsgOOVtcA,7222
 nkululeko/glob_conf.py,sha256=KL9YJQTHvTztxo1vr25qRRgaPnx4NTg0XrdbovKGMmw,525
-nkululeko/modelrunner.py,sha256=GwDXcE2gDQXat4W0-HhHQ1BcUNCRBXMBQ4QycfHp_5c,9288
+nkululeko/modelrunner.py,sha256=iCmfJxsS2UafcikjRdUqPQuqQMOYA-Ctr3et3HeNR3c,10452
 nkululeko/multidb.py,sha256=fG3VukEWP1vreVN4gB1IRXxwwg4jLftsSEYtu0o1f78,5634
 nkululeko/nkuluflag.py,sha256=PGWSmZz-PiiHLgcZJAoGOI_Y-sZDVI1ksB8p5r7riWM,3725
 nkululeko/nkululeko.py,sha256=Kn3s2E3yyH8cJ7z6lkMxrnqtCxTu7-qfe9Zr_ONTD5g,1968
@@ -26,7 +26,7 @@ nkululeko/segment.py,sha256=YLKckX44tbvTb3LrdgYw9X4guzuF27sutl92z9DkpZU,4835
 nkululeko/syllable_nuclei.py,sha256=Sky-C__MeUDaxqHnDl2TGLLYOYvsahD35TUjWGeG31k,10047
 nkululeko/test.py,sha256=1w624vo5KTzmFC8BUStGlLDmIEAFuJUz7J0W-gp7AxI,1677
 nkululeko/test_predictor.py,sha256=_w5J8CxH6hmW3mLTKbdfmywl5QpdNAnW1Y8TE5GtlfE,3237
-nkululeko/test_pretrain.py,sha256=4b_39l01dySei_e0ys2NKo9Gipf1Fukp1GvhQllFHt8,8131
+nkululeko/test_pretrain.py,sha256=ZWl-bR6nmeSmXkGAIE6zyfQEjN8Zg0rIxfaS-O6Zbas,8465
 nkululeko/augmenting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/augmenting/augmenter.py,sha256=XAt0dpmlnKxqyysqCgV3rcz-pRIvOz7rU7dmGDCVAzs,2905
 nkululeko/augmenting/randomsplicer.py,sha256=Z5rxdKKUpuncLWuTS6xVfVKUeVbeiYU_dLRHQ5fcg4Y,2669
@@ -68,15 +68,15 @@ nkululeko/feat_extract/feats_squim.py,sha256=Y31YmDmscuG0YozvxyBZIutO3id8t7IZJWC
 nkululeko/feat_extract/feats_trill.py,sha256=K2ahhdpwpjgg3WZS1POg3UMP2U44i8cLZZvn5Rq7fUI,3228
 nkululeko/feat_extract/feats_wav2vec2.py,sha256=9WUMfyddB_3nx79g7mZoQrRynhM1uEBWuOotRq8bxoU,5268
 nkululeko/feat_extract/feats_wavlm.py,sha256=ulxpGjifUFx2ZgGmY32SmBJGIuvkYHoLb2n1LZ8KMwA,4703
-nkululeko/feat_extract/feats_whisper.py,sha256=BFspQBI53HAgw22vBEeFskGwFZA-94Rpl17xM458HRo,4576
+nkululeko/feat_extract/feats_whisper.py,sha256=0N7Vj65OVi2PNoB_NrDjWT5lP6xZNKxFOZZIoxkJvcA,4533
 nkululeko/feat_extract/featureset.py,sha256=HtgW2389rmlRAgFP3F1sSFzq2_iUVr2NhOfIXG9omt0,1448
 nkululeko/feat_extract/feinberg_praat.py,sha256=EP9pMALjlKdiYInLQdrZ7MmE499Mq-ISRCgqbqL3Rxc,21304
 nkululeko/losses/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/losses/loss_ccc.py,sha256=NOK0y0fxKUnU161B5geap6Fmn8QzoPl2MqtPiV8IuJE,976
 nkululeko/losses/loss_softf1loss.py,sha256=5gW-PuiqeAZcRgfwjueIOQtMokOjZWgQnVIv59HKTCo,1309
 nkululeko/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nkululeko/models/finetune_model.py,sha256=bx9NsFpEqf_mBohcrf-9lWjrC4AtOIJ7holNXwaFo2Y,4910
-nkululeko/models/model.py,sha256=fL6LB6I9Oqo_OWUIptqiu6abuxVYYv8bW2a3m4XSLqU,11601
+nkululeko/models/finetune_model.py,sha256=OMlzDyUFNXZ2xSiqqH8tbzey_KzPJ4jsoYT-4KrWFKM,5091
+nkululeko/models/model.py,sha256=PUCqF2r_dEfmFsZn6Cgr1UIzYvxziLH6nSqZ5-vuN1o,11639
 nkululeko/models/model_bayes.py,sha256=WJFZ8wFKwWATz6MhmjeZIi1Pal1viU549WL_PjXDSy8,406
 nkululeko/models/model_cnn.py,sha256=bJxqwe6FnVR2hFeqN6EXexYGgvKYFED1VOhBXVlLWaE,9954
 nkululeko/models/model_gmm.py,sha256=hZ9UO36KNf48qa3J-xkWIicIj9-TApmt21zNES2vEOs,649
@@ -89,6 +89,7 @@ nkululeko/models/model_svm.py,sha256=rsME3KvKvNG7bdE5lbvYUu85WZhaASZxxmdNDIVJRZ4
 nkululeko/models/model_svr.py,sha256=_YZeksqB3eBENGlg3g9RwYFlk9rQQ-XCeNBKLlGGVoE,725
 nkululeko/models/model_tree.py,sha256=rf16faUm4o2LJgkoYpeY998b8DQIvXZ73_m1IS3TnnE,417
 nkululeko/models/model_tree_reg.py,sha256=IgQcPTE-304HQLYSKPF8Z4ot_Ur9dH01fZjS0nXke_M,428
+nkululeko/models/model_tuned.py,sha256=WJplfUK3CGLSd2mahUrPSjMvqjPfxLp99KFeZaz2AbU,15098
 nkululeko/models/model_xgb.py,sha256=Thgx5ESdIok4v72mKh4plxpo4smGcKALWNCJTDScY0M,447
 nkululeko/models/model_xgr.py,sha256=aGBtNGLWjOE_2rICGYGFxmT8DtnHYsIl1lIpMtghHsY,418
 nkululeko/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -105,8 +106,8 @@ nkululeko/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nkululeko/utils/files.py,sha256=UiGAtZRWYjHSvlmPaTMtzyNNGE6qaLaxQkybctS7iRM,4021
 nkululeko/utils/stats.py,sha256=1yUq0FTOyqkU8TwUocJRYdJaqMU5SlOBBRUun9STo2M,2829
 nkululeko/utils/util.py,sha256=b1IHFucRNuF9Iyv5IJeK4AEg0Rga0xKG80UM5GWWdHA,13816
-nkululeko-0.84.1.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
-nkululeko-0.84.1.dist-info/METADATA,sha256=Y647w-vkRjPG7fssLTEF_Aa_pP74aN-WPCGv6r0_NcE,36420
-nkululeko-0.84.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-nkululeko-0.84.1.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
-nkululeko-0.84.1.dist-info/RECORD,,
+nkululeko-0.85.1.dist-info/LICENSE,sha256=0zGP5B_W35yAcGfHPS18Q2B8UhvLRY3dQq1MhpsJU_U,1076
+nkululeko-0.85.1.dist-info/METADATA,sha256=RonY9PdKyHjwYsZ3T9TgEs1JNnY1qbMdDr-Sp6kcCW8,36591
+nkululeko-0.85.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+nkululeko-0.85.1.dist-info/top_level.txt,sha256=DPFNNSHPjUeVKj44dVANAjuVGRCC3MusJ08lc2a8xFA,10
+nkululeko-0.85.1.dist-info/RECORD,,