[WIP] Refactoring for easy model import from HF

config.json

@@ -0,0 +1,33 @@
+   {
+       "model_class": "FastModelHuggingFace",
+       "framework": "PyTorch + LightGBM",
+       "audio_processing_params": {
+           "sample_rate": 12000,
+           "duration": 3,
+           "padding_method": "reflect"
+       },
+       "features_params": {
+          "n_fft": 512,
+          "hop_length": 256,
+          "pad": 0,
+          "power": 2,
+          "pad_mode": "reflect",
+          "f_min": 70,
+          "f_max": 1525,
+          "fc_min": 0.05,
+          "fc_max": 0.8
+      },
+       "lgbm_params": {
+          "objective": "binary",
+          "metric": "binary_logloss",
+          "boosting_type": "gbdt",
+          "learning_rate": 0.1,
+          "num_leaves": 75,
+          "max_depth": -1,
+          "feature_fraction": 0.8,
+          "bagging_fraction": 0.8,
+          "bagging_freq": 5,
+          "verbosity": -1
+        }
+
+   }

example_usage_fastmodel.py

@@ -0,0 +1,35 @@
+import json
+from pathlib import Path
+
+from codecarbon import EmissionsTracker
+from datasets import load_dataset
+from sklearn.metrics import accuracy_score
+
+from fast_model import FastModel, save_pipeline
+
+dataset = load_dataset("rfcx/frugalai")
+train_dataset = dataset["train"]
+test_dataset = dataset["test"]
+tracker = EmissionsTracker(allow_multiple_runs=True)
+with open("config.json", "r") as file:
+    config = json.load(file)
+model = FastModel(
+    config["audio_processing_params"],
+    config["features_params"],
+    config["lgbm_params"],
+)
+model.fit(dataset["train"])
+
+# INFERENCE
+tracker.start()
+tracker.start_task("inference")
+true_label = dataset["test"]["label"]
+predictions = model.predict(dataset["test"])
+
+emissions_data = tracker.stop_task()
+
+print(accuracy_score(true_label, predictions))
+print("energy_consumed_wh", emissions_data.energy_consumed * 1000)
+print("emissions_gco2eq", emissions_data.emissions * 1000)
+
+save_pipeline(model, Path("./"))

example_usage_fastmodel_hf.py

@@ -0,0 +1,27 @@
+import torchaudio
+from datasets import load_dataset
+from sklearn.metrics import accuracy_score
+from fast_model import FastModelHuggingFace
+
+repo_id = "tlmk22/QuefrencyGuardian"
+fast_model = FastModelHuggingFace.from_pretrained(repo_id)
+
+# Example: predicting on a single WAV file
+wav_path = "wave_example/chainsaw.wav"
+waveform, sampling_rate = torchaudio.load(wav_path)  # Charger le fichier audio
+if sampling_rate != 12000:
+    resampler = torchaudio.transforms.Resample(orig_freq=sampling_rate, new_freq=12000)
+    waveform = resampler(waveform)
+
+# Perform predictions for a single WAV file
+map_labels = {0: "chainsaw", 1: "environment"}
+wav_prediction = fast_model.predict(waveform)
+print(f"Prediction : {map_labels[wav_prediction]}")
+
+# Example: predicting on a Hugging Face dataset
+dataset = load_dataset("rfcx/frugalai")
+test_dataset = dataset["test"]
+true_label = dataset["test"]["label"]
+
+predictions = fast_model.predict(dataset["test"])
+print(accuracy_score(true_label, predictions))

fast_model.py

@@ -1,15 +1,20 @@
 import os
 import struct
 import pickle
+from pathlib import Path
+from typing import Literal, Union
 
 import numpy as np
 import torch
 import lightgbm as lgb
 import torchaudio
+from huggingface_hub import hf_hub_download
 from sklearn.exceptions import NotFittedError
+from torch import Tensor
 from torchaudio.transforms import Spectrogram
 import torch.nn.functional as F
 from datasets.formatting import query_table
+from datasets import Dataset
 import warnings
 
 warnings.filterwarnings("ignore")
@@ -21,7 +26,7 @@ class FastModel:
     """
     A class designed for training and predicting using LightGBM, incorporating spectral and cepstral features.
 
-    ### Workflow:
+    Workflow:
     1. Batch Loading and Decoding:
     Load audio data in batches directly from a table and decode byte-encoded information.
 
@@ -36,85 +41,39 @@ class FastModel:
     3. Model Application:
     Use the extracted features as input for the LightGBM model to perform predictions.
 
-    ### Options for Energy Optimization:
-    - Feature Selection:
-    Mask less significant features to reduce computation.
-    - Signal Truncation:
-    Process only a limited duration (e.g., a few seconds) of the audio signal.
-    - Hardware Acceleration:
-    Utilize CUDA to speed up feature computation when supported.
-
     Attributes
     ----------
+    audio_processing_params : dict
+        Parameters for configuring audio processing.
     feature_params : dict
-        Parameters for configuring the MelSpectrogram transformation during training.
+        Parameters for configuring the Spectrogram and Cepstrogram transformation.
     lgbm_params : dict, optional
         Parameters for configuring the LightGBM model.
-    model_file : str
-        Path for saving or loading the trained LightGBM model.
-    padding_method : str
-        Padding method to apply when the waveform size is smaller than the desired size.
-    waveform_duration : float
-        Duration of the audio waveform to process, in seconds.
-    mask_features : bool
-        Whether to enable feature masking for dimensionality reduction.
-    mask_file : str
-        Path to save or load the feature mask file.
-    mask_ratio : float
-        The ratio of features to retain when feature masking is applied.
-    batch_size : int
-        Number of samples per batch during training and prediction.
-    apply_offset_on_fit : bool
-        Whether to apply the offset on fit. Useful if waveform_duration is below than 3 seconds.
     device : str
         Device used for computation ("cpu" or "cuda").
-
-    Methods
-    -------
-    _save_feature_mask(model, n_features, ratio):
-        Saves the most important features as a mask.
-    _load_feature_mask():
-        Loads the feature mask from the saved file.
-    fit(dataset):
-        Trains the LightGBM model on audio features extracted from the dataset.
-    predict(dataset, get_proba=False):
-        Predicts labels or probabilities for a dataset using the trained model.
-    get_features(audios, spectrogram_transformer, cepstral_transformer):
-        Extracts features from raw audio using spectrogram and cepstral transformations.
     """
 
     def __init__(
         self,
-        feature_params,
-        lgbm_params=None,
-        padding_method="reflect",
-        waveform_duration=3,
-        model_file=None,
-        mask_features=False,
-        mask_file="feature_mask.pkl",
-        mask_ratio=0.25,
-        batch_size=5000,
-        apply_offset_on_fit=False,
-        device="cpu",
+        audio_processing_params: dict,
+        feature_params: dict,
+        lgbm_params: dict,
+        device: str = "cuda",
     ):
+        self.audio_processing_params = audio_processing_params
         self.feature_params = feature_params
         self.lgbm_params = lgbm_params
-        self.model_file = model_file
-        self.padding_method = padding_method
-        self.waveform_duration = waveform_duration
-        self.mask_features = mask_features
-        self.mask_file = mask_file
-        self.mask_ratio = mask_ratio
-        self.batch_size = batch_size
-        self.apply_offset_on_fit = apply_offset_on_fit
         self.device = torch.device(
             "cuda" if device == "cuda" and torch.cuda.is_available() else "cpu"
         )
+        self.model = None
+
+        # Initialize Spectrogram & Cepstrogram
         self.spectrogram_transformer = Spectrogram(
             n_fft=self.feature_params["n_fft"],
             hop_length=self.feature_params["hop_length"],
             pad=self.feature_params["pad"],
-            window_fn=self.feature_params["win_spectrogram"],
+            window_fn=torch.hamming_window,
             power=self.feature_params["power"],
             pad_mode=self.feature_params["pad_mode"],
             onesided=True,
@@ -130,7 +89,7 @@ class FastModel:
             n_fft=self.n_fft_cepstral,
             hop_length=self.n_fft_cepstral,
             pad=0,
-            window_fn=self.feature_params["win_cepstral"],
+            window_fn=torch.hamming_window,
             power=self.feature_params["power"],
             pad_mode=self.feature_params["pad_mode"],
             onesided=True,
@@ -142,27 +101,15 @@ class FastModel:
             device=self.device,
         )
 
-    def _save_feature_mask(self, model, n_features, ratio):
-        feature_importance = model.feature_importance(importance_type="gain")
-        sorted_indices = np.argsort(feature_importance)[::-1]
-        top_indices = sorted_indices[: max(1, int(n_features * ratio))]
-        mask = np.zeros(n_features, dtype=bool)
-        mask[top_indices] = True
-        with open(self.mask_file, "wb") as f:
-            pickle.dump(mask, f)
-
-    def _load_feature_mask(self):
-        with open(self.mask_file, "rb") as f:
-            return pickle.load(f)
-
-    def fit(self, dataset):
-        """
-        Trains a LightGBM model on features extracted from the dataset.
+    def fit(self, dataset: Dataset, batch_size: int = 5000):
+        """Trains a LightGBM model on features extracted from the dataset.
 
         Parameters
         ----------
         dataset : Dataset
-            Dataset object containing audio samples and their corresponding labels.
+            Arrow Dataset object containing audio samples and their corresponding labels.
+        batch_size : int, optional
+            Number of audio samples per batch (default is 5000).
 
         Raises
         ------
@@ -170,36 +117,22 @@ class FastModel:
             If the dataset is empty or invalid.
         """
         features, labels = [], []
-        offsets = [0, 12000, 24000] if self.apply_offset_on_fit else [0]
-        for offset in offsets:
-            for audio, label in batch_audio_loader(
-                dataset,
-                waveform_duration=self.waveform_duration,
-                batch_size=self.batch_size,
-                padding_method=self.padding_method,
-                offset=offset,
-            ):
-                feature = self.get_features(
-                    audio, self.spectrogram_transformer, self.cepstral_transformer
-                )
-                features.append(feature)
-                labels.extend(label)
+        for audio, label in batch_audio_loader(
+            dataset,
+            waveform_duration=self.audio_processing_params["duration"],
+            batch_size=batch_size,
+            padding_method=self.audio_processing_params["padding_method"],
+            device=self.device,
+        ):
+            feature = self.get_features(audio)
+            features.append(feature)
+            labels.extend(label)
         x_train = torch.cat(features, dim=0)
         train_data = lgb.Dataset(x_train.cpu(), label=labels)
-        model = lgb.train(self.lgbm_params, train_data)
-
-        if self.mask_features:
-            self._save_feature_mask(model, x_train.shape[1], self.mask_ratio)
-            mask = self._load_feature_mask()
-            x_train = x_train[:, mask]
-            train_data = lgb.Dataset(x_train.cpu(), label=labels)
-            model = lgb.train(self.lgbm_params, train_data)
-
-        model.save_model(self.model_file)
+        self.model = lgb.train(self.lgbm_params, train_data)
 
-    def predict(self, dataset, get_proba=False):
-        """
-        Predicts labels or probabilities for a dataset using the trained model.
+    def predict(self, dataset: Dataset, get_proba: bool = False, batch_size: int = 5000):
+        """Predicts labels or probabilities for a dataset using the trained model.
 
         Parameters
         ----------
@@ -207,6 +140,8 @@ class FastModel:
             The dataset containing audio data for prediction.
         get_proba : bool, optional
             If True, returns class probabilities rather than binary predictions (default is False).
+        batch_size : int, optional
+            Number of audio samples per batch (default is 5000).
 
         Returns
         -------
@@ -218,49 +153,34 @@ class FastModel:
         ------
         NotFittedError
             If the model is not yet trained.
-        FileNotFoundError
-            If the model file does not exist.
         """
-        if not self.model_file:
-            raise NotFittedError("The model is not trained yet. Train using the `fit` method.")
-        if not os.path.isfile(self.model_file):
-            raise FileNotFoundError(f"Model file {self.model_file} not found.")
-
+        if not self.model:
+            raise NotFittedError("LGBM model is not fitted yet.")
         features = []
         for audio, _ in batch_audio_loader(
             dataset,
-            waveform_duration=self.waveform_duration,
-            batch_size=self.batch_size,
-            padding_method=self.padding_method,
+            waveform_duration=self.audio_processing_params["duration"],
+            batch_size=batch_size,
+            padding_method=self.audio_processing_params["padding_method"],
+            device=self.device,
         ):
-            feature = self.get_features(
-                audio, self.spectrogram_transformer, self.cepstral_transformer
-            )
+            feature = self.get_features(audio)
             features.append(feature)
         features = torch.cat(features, dim=0)
         torch.cuda.empty_cache()
 
-        if self.mask_features:
-            mask = self._load_feature_mask()
-            features = features[:, mask]
-
-        model = lgb.Booster(model_file=self.model_file)
-        y_score = model.predict(features.cpu())
+        y_score = self.model.predict(features.cpu())
 
         return y_score if get_proba else (y_score >= 0.5).astype(int)
 
-    def get_features(self, audios, spectrogram_transformer, cepstral_transformer):
+    def get_features(self, audios: Tensor):
         """
         Extracts features from raw audio using spectrogram and cepstrum transformations.
 
         Parameters
         ----------
         audios : torch.Tensor
-            A batch of audio waveforms as 1D tensors.
-        spectrogram_transformer : Spectrogram
-            Transformation used to compute MelSpectrogram features.
-        cepstral_transformer : Spectrogram
-            Transformation used to compute cepstral features.
+            A batch of audio waveforms as 2D tensors (n_audios, n_samples_per_audio).
 
         Returns
         -------
@@ -273,9 +193,9 @@ class FastModel:
             If the input audio tensor is empty or invalid.
         """
         audios = audios.to(self.device)
-        sxx = spectrogram_transformer(audios)  # shape : (n_audios, n_f, n_blocks)
+        sxx = self.spectrogram_transformer(audios)  # shape : (n_audios, n_f, n_blocks)
         sxx = torch.log10(torch.clamp(sxx.permute(0, 2, 1), min=1e-10))
-        cepstral_mat = cepstral_transformer(sxx[:, :, self.ind_f_filtered]).squeeze(dim=3)[
+        cepstral_mat = self.cepstral_transformer(sxx[:, :, self.ind_f_filtered]).squeeze(dim=3)[
             :, :, self.ind_cf_filtered
         ]
 
@@ -289,22 +209,21 @@ class FastModel:
 
 
 def batch_audio_loader(
-    dataset,
-    waveform_duration=3,
-    batch_size=1,
-    sr=12000,
-    device="cpu",
-    padding_method=None,
-    offset=0,
+    dataset: Dataset,
+    waveform_duration: int = 3,
+    batch_size: int = 1,
+    sr: int = 12000,
+    device: Literal["cpu", "cuda"] = "cpu",
+    padding_method: None | Literal["zero", "reflect", "replicate", "circular"] = None,
+    offset: int = 0,
 ):
-    """
-    Loads and preprocesses audio data from a dataset for training or inference in batches.
+    """Optimized loader for audio data from a dataset for training or inference in batches.
 
     Parameters
     ----------
     dataset : Dataset
         The dataset containing audio samples and labels.
-    waveform_duration : float, optional
+    waveform_duration : int, optional
         Desired duration of the audio waveforms in seconds (default is 3).
     batch_size : int, optional
         Number of audio samples per batch (default is 1).
@@ -319,10 +238,10 @@ def batch_audio_loader(
 
     Yields
     ------
-    tuple
+    tuple (Tensor, Tensor)
         A tuple (batch_audios, batch_labels), where:
-        - batch_audios is a tensor of processed audio waveforms.
-        - batch_labels is a tensor of corresponding audio labels.
+        - batch_audios is a torch.tensor of processed audio waveforms.
+        - batch_labels is a torch.tensor of corresponding audio labels.
 
     Raises
     ------
@@ -399,7 +318,11 @@ def batch_audio_loader(
         yield batch_audios_on_device, batch_labels_on_device
 
 
-def apply_padding(waveform, output_size, padding_method="zero"):
+def apply_padding(
+    waveform: torch.Tensor,
+    output_size: int,
+    padding_method: Literal["zero", "reflect", "replicate", "circular"] = "zero",
+) -> torch.Tensor:
     """
     Applies padding to the waveform when its size is smaller than the desired output size.
 
@@ -432,3 +355,223 @@ def apply_padding(waveform, output_size, padding_method="zero"):
 
         return F.pad(waveform.unsqueeze(0), (0, total_pad), mode=padding_method).squeeze()
     raise ValueError(f"Invalid padding method: {padding_method}")
+
+
+class FastModelHuggingFace:
+    """
+    Class for loading a FastModel instance from the Hugging Face Hub.
+    Includes preprocessing pipelines and a LightGBM model.
+
+    Attributes
+    ----------
+    pipeline : object
+        The serialized preprocessing pipeline.
+    model : lgb.Booster
+        The LightGBM model instance used for predictions.
+
+    Methods
+    -------
+    from_pretrained(repo_id: str, revision: str = "main",
+                    pipeline_file_name: str = "pipeline.pkl",
+                    model_file_name: str = "model_lightgbm.txt") -> "FastModelHuggingFace":
+        Loads the FastModel pipeline and model from the Hugging Face Hub.
+    predict(input_data: Union[str, "HuggingFaceDataset"], get_proba: bool = False) -> np.ndarray:
+        Predicts labels or probabilities for a WAV file or dataset.
+    """
+
+    def __init__(self, pipeline: object, lightgbm_model: lgb.Booster):
+        """
+        Initializes a FastModelHuggingFace instance.
+
+        Parameters
+        ----------
+        pipeline : object
+            The serialized preprocessing pipeline.
+        lightgbm_model : lgb.Booster
+            A LightGBM booster model for predictions.
+        """
+        self.pipeline = pipeline
+        self.model = lightgbm_model
+
+    @classmethod
+    def from_pretrained(
+        cls,
+        repo_id: str,
+        revision: str = "main",
+        pipeline_file_name: str = "pipeline.pkl",
+        model_file_name: str = "model_lightgbm.txt",
+    ) -> "FastModelHuggingFace":
+        """
+        Loads the FastModel pipeline and LightGBM model from the Hugging Face Hub.
+
+        Parameters
+        ----------
+        repo_id : str
+            The Hugging Face repository ID.
+        revision : str, optional
+            The specific revision of the repository to use (default is "main").
+        pipeline_file_name : str, optional
+            The filename of the serialized pipeline (default is "pipeline.pkl").
+        model_file_name : str, optional
+            The filename of the LightGBM model (default is "model_lightgbm.txt").
+
+        Returns
+        -------
+        FastModelHuggingFace
+            A FastModelHuggingFace instance with the loaded pipeline and model.
+
+        Raises
+        ------
+        FileNotFoundError
+            If either the pipeline or LightGBM model files are missing or corrupted.
+        """
+        pipeline_path = hf_hub_download(repo_id, filename=pipeline_file_name, revision=revision)
+        model_lgbm_path = hf_hub_download(repo_id, filename=model_file_name, revision=revision)
+
+        if not os.path.exists(pipeline_path):
+            raise FileNotFoundError(f"Pipeline file {pipeline_path} is missing or corrupted.")
+        with open(pipeline_path, "rb") as f:
+            pipeline = pickle.load(f)
+
+        if not os.path.exists(model_lgbm_path):
+            raise FileNotFoundError(
+                f"LightGBM model file {model_lgbm_path} is missing or corrupted."
+            )
+        lightgbm_model = lgb.Booster(model_file=model_lgbm_path)
+
+        return cls(pipeline=pipeline, lightgbm_model=lightgbm_model)
+
+    def predict(
+        self,
+        input_data: Union[str, "HuggingFaceDataset"],
+        get_proba: bool = False,
+        batch_size: int = 5000,
+        device: Literal["cpu", "cuda"] = "cuda",
+    ) -> np.ndarray:
+        """
+        Predicts labels or probabilities for a given audio input.
+
+        Parameters
+        ----------
+        input_data : Union[str, HuggingFaceDataset]
+            The input for prediction, either the path to a WAV file or a Hugging Face dataset.
+        get_proba : bool, optional
+            If True, returns class probabilities instead of binary predictions (default is False).
+        batch_size : int, optional
+            Number of audio samples per batch (default is 5000).
+        device : Literal["cpu", "cuda"]
+
+        Returns
+        -------
+        np.ndarray
+            If `get_proba` is True, returns an array of probabilities.
+            If `get_proba` is False, returns binary predictions.
+
+        Raises
+        ------
+        ValueError
+            If the input data type is neither a WAV file path string nor a Hugging Face dataset.
+        """
+        if isinstance(input_data, str):
+            audio_waveform, sr = torchaudio.load(input_data)
+            audio_waveform = audio_waveform.mean(dim=0)
+            if sr != self.pipeline.audio_processing_params["sample_rate"]:
+                resampler = torchaudio.transforms.Resample(
+                    orig_freq=sr, new_freq=self.pipeline.audio_processing_params["sample_rate"]
+                )
+                audio_waveform = resampler(audio_waveform)
+            features = self.pipeline.get_features(audio_waveform.unsqueeze(0).to(device))
+            predictions = self.model.predict(features.cpu().numpy())
+            return predictions if get_proba else (predictions >= 0.5).astype(int)
+
+        elif hasattr(input_data, "_data"):
+            features = []
+            for batch_audios, _ in self.pipeline.batch_audio_loader(
+                input_data,
+                waveform_duration=self.pipeline.audio_processing_params["duration"],
+                batch_size=batch_size,
+                padding_method=self.pipeline.audio_processing_params["padding_method"],
+                device=device,
+            ):
+                batch_features = self.pipeline.get_features(batch_audios)
+                features.append(batch_features)
+            features = torch.cat(features, dim=0)
+            predictions = self.model.predict(features.cpu().numpy())
+            return predictions if get_proba else (predictions >= 0.5).astype(int)
+        else:
+            raise ValueError("Input must be either a path to a WAV file or a Hugging Face Dataset.")
+
+
+def save_pipeline(
+    model_class_instance: FastModelHuggingFace,
+    path: str,
+    lgbm_file_name: str = None,
+    pipeline_file_name: str = None,
+):
+    """
+    Serializes the complete FastModel instance for saving.
+
+    Parameters
+    ----------
+    model_class_instance : FastModelHuggingFace
+        The trained FastModel instance to serialize.
+    path : str
+        The directory to save the FastModel instance.
+    lgbm_file_name : str, optional
+        The filename for saving the LightGBM model (default is "model_fast_model.txt").
+    pipeline_file_name : str, optional
+        The filename for saving the pipeline (default is "pipeline.pkl").
+    """
+    lgbm_file_name = lgbm_file_name or "model_fast_model.txt"
+    pipeline_file_name = pipeline_file_name or "pipeline.pkl"
+
+    lightgbm_path = Path(path) / lgbm_file_name
+    if model_class_instance.model:
+        model_class_instance.model_file_name = str(lightgbm_path)
+        model_class_instance.model.save_model(model_class_instance.model_file_name)
+
+    pipeline_path = Path(path) / pipeline_file_name
+    with open(pipeline_path, "wb") as f:
+        pickle.dump(model_class_instance, f)
+
+
+def load_pipeline(
+    path: str, lgbm_file_name: str = None, pipeline_file_name: str = None
+) -> FastModelHuggingFace:
+    """
+    Loads a serialized pipeline and LightGBM model.
+
+    Parameters
+    ----------
+    path : str
+        The directory containing the serialized FastModel.
+    lgbm_file_name : str, optional
+        The filename for the LightGBM model (default is "model_fast_model.txt").
+    pipeline_file_name : str, optional
+        The filename for the pipeline (default is "pipeline.pkl").
+
+    Returns
+    -------
+    FastModelHuggingFace
+        An instance of the loaded FastModel.
+
+    Raises
+    ------
+    FileNotFoundError
+        If either the LightGBM model or pipeline file is not found.
+    """
+    lgbm_file_name = lgbm_file_name or "model_fast_model.txt"
+    pipeline_file_name = pipeline_file_name or "pipeline.pkl"
+
+    pipeline_path = Path(path) / pipeline_file_name
+    if not pipeline_path.exists():
+        raise FileNotFoundError(f"Pipeline file {pipeline_path} not found.")
+    with open(pipeline_path, "rb") as f:
+        model_class_instance = pickle.load(f)
+
+    lightgbm_path = Path(path) / lgbm_file_name
+    if not lightgbm_path.exists():
+        raise FileNotFoundError(f"LightGBM file {lightgbm_path} not found.")
+    model_class_instance.model = lgb.Booster(model_file=str(lightgbm_path))
+
+    return model_class_instance

model/features.json

@@ -1,13 +0,0 @@
-{
-    "n_fft": 512,
-    "hop_length": 256,
-    "pad": 0,
-    "win_spectrogram": "Hamming Window",
-    "win_cepstral": "Hamming Window",
-    "power": 2,
-    "pad_mode": "reflect",
-    "f_min": 70,
-    "f_max": 1525,
-    "fc_min": 0.05,
-    "fc_max": 0.8,
-}

model/lgbm_params.json

@@ -1,12 +0,0 @@
-{
-    "objective": "binary",
-    "metric": "binary_logloss",
-    "boosting_type": "gbdt",
-    "learning_rate": 0.1,
-    "num_leaves": 75,
-    "max_depth": -1,
-    "feature_fraction": 0.8,
-    "bagging_fraction": 0.8,
-    "bagging_freq": 5,
-    "verbosity": -1,
-}

pipeline.pkl

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