DLOmix

https://github.com/wilhelm-lab/dlomix
Admin
DLOmix is a Python framework for deep learning in proteomics with multi-backend support for...
Tokens:66,302
Snippets:610
Trust Score:8.5
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install DLOmix with Weights & Biases Support

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs DLOmix with optional support for Weights & Biases reporting.

```bash
pip install dlomix[wandb]
```

--------------------------------

### Basic DLOmix Installation

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Install DLOmix without specific backend dependencies. TensorFlow and PyTorch must be installed separately before using DLOmix.

```bash
# Basic installation
# TensorFlow and PyTorch not installed, please install separately
pip install dlomix
```

--------------------------------

### Install DLOmix Core Package

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs the main DLOmix package and its core dependencies. Backend frameworks are installed separately.

```bash
pip install dlomix
```

--------------------------------

### Install DeepLC Library

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_DeepLC_RetentionTimePrediction.ipynb

Installs the DeepLC library. Run this command in your environment before using DeepLC.

```python
!pip install dlomix
```

--------------------------------

### Install DLOMix with Wandb Extras

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Install the DLOMix library with the necessary extras for Weights & Biases integration. This command should be run in your environment before proceeding.

```python
# install DLOmix with wandb extras
#!python -m pip install -q dlomix[wandb]==0.1.0
```

--------------------------------

### Install DLOmix for Development (All Dependencies)

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs DLOmix with all development dependencies, including both TensorFlow and PyTorch backends.

```bash
pip install dlomix[dev]
```

--------------------------------

### Install DLOmix with PyTorch Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs DLOmix along with the PyTorch backend. Use [torch] or [pt] as shorter alternatives.

```bash
pip install dlomix[pytorch]  # shorter alternatives: [torch], [pt]
```

--------------------------------

### Install DLOmix from GitHub (Develop Branch)

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs the latest development version of DLOmix directly from its GitHub repository.

```bash
pip install git+https://github.com/wilhelm-lab/dlomix.git@develop
```

--------------------------------

### Install DLOmix with PyTorch Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Install DLOmix with the PyTorch backend. This command installs the core package and the necessary dependencies for PyTorch.

```bash
pip install dlomix[pytorch]
```

--------------------------------

### Print Dataset Information and Batch Example

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Prints the initialized dataset object, the number of training examples, and the structure of one training batch. This is useful for verifying dataset loading and format.

```python
print("Hugging Face Dataset:", d)

print("Training examples:", len(d["train"]))
print("one training batch looks like:")
for x in d.tensor_train_data:
    print(x)
    break

print("\nValidation examples:", len(d["val"]))
print("\nTest examples:", len(d["test"])))
```

--------------------------------

### Install DLOmix with TensorFlow Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Install DLOmix with the TensorFlow backend. This command installs the core package and the necessary dependencies for TensorFlow.

```bash
pip install dlomix[tensorflow]
```

--------------------------------

### Install DLOmix for Development

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Install DLOmix in editable mode with development tools. This is recommended for developers who are contributing to the project and need to run tests.

```bash
pip install -e .[dev]
```

--------------------------------

### Install DLOmix Package

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_IntensityModel_Walkthrough_colab.ipynb

Installs the DLOmix package in the current environment using pip. This is a prerequisite for using the framework.

```python
# install the DLOmix package in the current environment using pip

!python -m pip install -q dlomix
```

--------------------------------

### Install DLOmix with TensorFlow/Keras Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/installation.rst

Installs DLOmix along with the TensorFlow/Keras backend. Use [tf] as a shorter alternative.

```bash
pip install dlomix[tensorflow]  # shorter alternatives: [tf]
```

--------------------------------

### Setup Early Stopping and Metrics Logging

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Initialize variables for early stopping to track the best validation loss and epochs without improvement. Prepare a list to log training metrics per epoch.

```python
# Early stopping tracking.
best_val_loss = float("inf")
epochs_without_improvement = 0
best_model_state = None

# Prepare a list to store metrics per epoch for CSV logging.
metrics_log = []  # Each element will be a dict with keys: epoch, train_loss, val_loss, learning_rate
```

--------------------------------

### Install DLOmix with Weights & Biases

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb

Installs the DLOmix package, including Weights & Biases integration, using pip. This command should be run in the Colab environment.

```python
# install the DLOmix package in the current environment using pip

!python -m pip install -q dlomix[wandb]
```

--------------------------------

### Generating PyTorch Datasets

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/dataset_guide.rst

Shows how to configure the Dataset for PyTorch, including specifying DataLoader arguments for shuffling and batching. The example also illustrates a basic PyTorch training loop.

```python
dataset = RetentionTimeDataset(
    data_source="data.csv",
    dataset_type="pt",
    batch_size=64,
    sequence_column="sequence",
    label_column="retention_time",
    torch_dataloader_kwargs={
        "shuffle": True,
        # other DataLoader args
    }
)

# Returns PyTorch DataLoader
train_loader = dataset.train_data
val_loader = dataset.val_data

# Training loop
for batch, label in train_loader:
    sequences = batch["sequence"]
    # ... training code
```

--------------------------------

### Display Dataset Information and Batch

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough.ipynb

Prints information about the initialized ChargeStateDataset, including the number of training and validation examples, and displays one training batch.

```python
print("Hugging Face Dataset:", d)

print("Training examples:", len(d["train"]))
print("one training batch looks like:")
for x in d.tensor_train_data:
    print(x)
    break

print("Validation examples:", len(d["val"])))
```

--------------------------------

### Set PyTorch Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Configure DLOmix to use the PyTorch backend. Ensure PyTorch is installed separately or via the dlomix[pytorch] package. The backend must be set before importing DLOmix.

```bash
# Set PyTorch as backend
export DLOMIX_BACKEND=pytorch
# or
export DLOMIX_BACKEND=torch
# or
export DLOMIX_BACKEND=pt

# Install DLOmix with PyTorch support
pip install dlomix[pytorch]

# Or install pytorch separately (existing installation), then only install dlomix
pip install dlomix
```

--------------------------------

### Install Pyteomics Library

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_DeepLC_RetentionTimePrediction.ipynb

Installs the pyteomics library, which is required for fetching feature values for modifications using their unimod IDs.

```python
# install pyteomics to fetch feature values for modifications given their unimod IDs
!pip install pyteomics
```

--------------------------------

### Load Dataset from Hugging Face

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Loads a dataset from the Hugging Face Hub for prediction tasks. This example demonstrates how to fetch a specific dataset and its test split.

```python
# load the dataset from huggingface for prediction

from datasets import load_dataset, DatasetDict

# pick one of the available datasets on the HuggingFace Hub
# Collection: https://huggingface.co/collections/Wilhelmlab/detectability-datasets-671e76fb77035878c50a9c1d

hf_data_name = "Wilhelmlab/detectability-sinitcyn"
#hf_data_name = "Wilhelmlab/detectability-wang"

hf_dataset_split = load_dataset(hf_data_name, split="test")
hf_dataset = DatasetDict({"test": hf_dataset_split})
hf_dataset
```

--------------------------------

### Set DLOmix Backend via Environment Variable

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/backend_usage.rst

Configure the DLOmix backend (TensorFlow or PyTorch) using environment variables before importing DLOmix modules. TensorFlow is the default if no variable is set and both are installed.

```bash
export DLOMIX_BACKEND=tensorflow
export DLOMIX_BACKEND=pytorch
```

--------------------------------

### Set TensorFlow Backend

Source: https://github.com/wilhelm-lab/dlomix/blob/main/README.md

Configure DLOmix to use the TensorFlow backend. Ensure TensorFlow is installed separately or via the dlomix[tensorflow] package. The backend must be set before importing DLOmix.

```bash
# Set TensorFlow as backend (default)
export DLOMIX_BACKEND=tensorflow
# or
export DLOMIX_BACKEND=tf

# Install DLOmix with TensorFlow
pip install dlomix[tensorflow]

# Or install tensorflow separately (existing installation), then only install dlomix
pip install dlomix
```

--------------------------------

### Get DLOmix Version

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Check the installed version of the DLOmix package.

```python
dlomix.__version__
```

--------------------------------

### Initialize Weights & Biases Run

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_ModelComparison_wandb_ReportAPI.ipynb

Configure and initialize a Weights & Biases run. This includes setting up the project name, run name, and a configuration dictionary that will be logged with the run.

```python
import wandb
from wandb.keras import WandbCallback
from wandb.keras import WandbMetricsLogger


# Create config
config = {
  "seq_length" : 30,
  "batch_size" : 64,
  "val_ratio" : 0.2,
  "lr" : 0.0001,
  "optimizer" : "Adam",
  "loss" : "mse"
}

# Initialize WANDB
PROJECT = 'Demo_ComparingModelsReport'
RUN = "run_1"
wandb.init(project = PROJECT, name = RUN, config = config)
```

--------------------------------

### Initialize Optimizer

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough.ipynb

Sets up the Adam optimizer with a specified learning rate for model training.

```python
optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)
```

--------------------------------

### Import DLOmix and Set Backend in Python

Source: https://context7.com/wilhelm-lab/dlomix/llms.txt

Demonstrates how to set the DLOMIX_BACKEND environment variable within a Python script before importing DLOmix. This ensures the desired backend (e.g., PyTorch) is used for the session.

```python
# Install with a specific backend
# pip install dlomix[tensorflow]
# pip install dlomix[pytorch]

import os
os.environ["DLOMIX_BACKEND"] = "pytorch"   # must be set before the import below

import dlomix
from dlomix.models import PrositRetentionTimePredictor
from dlomix.data import RetentionTimeDataset

print(dlomix._BACKEND)   # "pytorch"
# => Using PyTorch Backend for DLOmix. To change...

```

--------------------------------

### Get Prediction Shape

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Check the shape of the generated predictions array.

```python
predictions.shape
```

--------------------------------

### Get Processed Data Length

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Returns the number of rows in the processed DataFrame.

```python
len(processed_data)
```

--------------------------------

### Display Dataset Information

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab.ipynb

Shows the number of training and validation examples available in the loaded RetentionTimeDataset.

```python
"Hugging Face Dataset", rtdata
```

```python
"Training examples", len(rtdata["train"])
```

```python
"Training examples", len(rtdata["val"])
```

--------------------------------

### Get Number of Rows in Holdout Data

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Calculates and returns the total number of rows in the holdout DataFrame.

```python
len(holdout)
```

--------------------------------

### Get Unique Predicted Class Counts

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Determine the counts of each predicted class after applying argmax to the predictions.

```python
np.unique(np.argmax(predictions, axis=1), return_counts=True)
```

--------------------------------

### Get Input Shape

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Determine the shape of the first element in the `majority_train_X` dataset. This is useful for understanding input dimensions.

```python
majority_train_X[0, :].shape
```

--------------------------------

### Initialize Detectability Model

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Create an instance of the DetectabilityModel with specified units and number of classes.

```python
total_num_classes = len(CLASSES_LABELS)
input_dimension = len(alphabet)
num_cells = 64

model = DetectabilityModel(num_units=num_cells, num_classes=total_num_classes)
```

--------------------------------

### Get Predictions from Observed Charges Model

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Obtain predictions from the `observed_charges_model` for the first sample in `observed_train_X`. The output is converted to a NumPy array.

```python
predictions = observed_charges_model(observed_train_X[0].reshape(1, -1)).numpy()
```

--------------------------------

### Initialize RetentionTimeReport

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab.ipynb

Creates an instance of RetentionTimeReport. Requires an output path for saving reports and a history object containing training metrics.

```python
# create a report object by passing the history object and plot different metrics
report = RetentionTimeReport(output_path="./output", history=history)
```

--------------------------------

### Initialize Retention Time Report Model Comparison

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_ModelComparison_wandb_ReportAPI.ipynb

Create an instance of RetentionTimeReportModelComparisonWandb to set up a report comparing the loaded models against the test dataset. This object will be used to log and generate the comparison report.

```python
# Create a report
from dlomix.reports import RetentionTimeReportModelComparisonWandb

report = RetentionTimeReportModelComparisonWandb(models = models,
                test_dataset = test_set,
                project = PROJECT,
                title = "Comparison of models",
                description = "A quick comparison of two models")
```

--------------------------------

### Prepare Test Dataset

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_IntensityModel_Walkthrough_colab.ipynb

Create a dataset object for testing, specifying the data source, format, relevant columns, model features, sequence length, batch size, and handling of termini.

```python
# create the dataset object for test data
# Note: this is just using the same data above for demonstration purposes. In practice, you should use a separate test dataset

TEST_DATAPATH = "https://github.com/wilhelm-lab/dlomix/raw/refs/heads/main/example_dataset/intensity/intensity_data.parquet"

test_int_data = FragmentIonIntensityDataset(
    data_format="parquet",
    test_data_source=TEST_DATAPATH,
    sequence_column="sequence",
    label_column="intensities",
    model_features=["precursor_charge_onehot", "collision_energy_aligned_normed"],
    max_seq_len=30,
    batch_size=128,
    with_termini=False,
)
```

--------------------------------

### Display Dataset Information

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_IntensityModel_Walkthrough_colab.ipynb

Shows the type of the dataset object and the number of training and validation examples. This helps verify that the dataset has been loaded and split correctly.

```python
"Hugging Face Dataset", int_data
```

```python
"Training examples", len(int_data["train"])
```

```python
"Training examples", len(int_data["val"])
```

--------------------------------

### Get Detectability Report Table

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Retrieves the evaluation metrics as a pandas DataFrame from the initialized DetectabilityReport object. This DataFrame contains detailed performance statistics.

```python
results_df = report.detectability_report_table
results_df
```

--------------------------------

### Configure Model Training Parameters

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb

Set training parameters like learning rate and optimizer. These can be extended as needed.

```python
config.lr = 0.0001
config.optimizer = "adam"
```

--------------------------------

### Download Pretrained Model Weights

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Download pretrained model weights from a GitHub repository. This script fetches files from a specified API URL and saves them to a local directory.

```python
model_name = "original_detectability_fine_tuned_model_FINAL"
api_url = f"https://api.github.com/repos/wilhelm-lab/dlomix/contents/pretrained_models/{model_name}"
local_download_folder = "pretrained_detectability_model"

os.makedirs(local_download_folder, exist_ok=True)

files = json.loads(urllib.request.urlopen(api_url).read())
for f in files:
    if f['type'] == 'file':
        urllib.request.urlretrieve(f['download_url'], os.path.join(local_download_folder, f['name']))
        
print(f"Downloaded {len([f for f in files if f['type'] == 'file'])} files to {local_download_folder}/")
```

--------------------------------

### Load Pre-trained PCSP Model and Tokenizer

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Loads the pre-trained 'microsoft/trocr-base-handwritten' model and its corresponding tokenizer from Hugging Face. This is the initial setup for using the model.

```python
from transformers import TrOCRProcessor, VisionEncoderDecoderModel
from PIL import Image
import requests

model = VisionEncoderDecoderModel.from_pretrained("microsoft/trocr-base-handwritten")
processor = TrOCRProcessor.from_pretrained("microsoft/trocr-base-handwritten")
```

--------------------------------

### Sample and Visualize Charge State and Intensity Distributions

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/data_split_tests.ipynb

Samples data and visualizes charge state vectors and normalized intensity distributions using heatmaps. Assumes 'plot_df' is pre-defined.

```python
#Sampling some of the data
sampled_df = plot_df.sample(n=200, random_state=42)  

charge_state_sampled_df = pd.DataFrame(sampled_df['charge_state_vector'].tolist(), index=sampled_df['modified_sequence'], columns=[f'{i}' for i in range(1, 7)])
intensity_dist_sampled_df = pd.DataFrame(sampled_df['normalized_intensity_distribution'].tolist(), index=sampled_df['modified_sequence'], columns=[f'{i}' for i in range(1, 7)])


plt.figure(figsize=(12, 8))
plt.subplot(1, 2, 1)
sns.heatmap(charge_state_sampled_df, cmap='viridis', cbar=True)
plt.title('Charge State Vector')
plt.xlabel('Charge State')
plt.ylabel('Sequence')

plt.subplot(1, 2, 2)
sns.heatmap(intensity_dist_sampled_df, cmap='viridis', cbar=True)
plt.title('Normalized Intensity Distribution')
plt.xlabel('Charge State')
plt.ylabel('Sequence')

plt.tight_layout()
plt.show()
```

--------------------------------

### Initialize DetectabilityDataset

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Create an instance of DetectabilityDataset to load and preprocess data. Specify parameters like data source, sequence length, batch size, and encoding details.

```python
max_pep_length = 40
BATCH_SIZE = 128 
            
# The Class handles all the inner details, we have to provide the column names and the alphabet for encoding
# If the data is already split with a specific logic (which is generally recommended) -> val_data_source and test_data_source are available as well

hf_data = "Wilhelmlab/detectability-proteometools"
detectability_data = DetectabilityDataset(data_source=hf_data,
                                          data_format='hub',
                                          max_seq_len=max_pep_length,
                                          label_column="Classes",
                                          sequence_column="Sequences",
                                          dataset_columns_to_keep=None,
                                          batch_size=BATCH_SIZE,
                                          with_termini=False,
                                          alphabet=aa_to_int_dict,
                                          padding_value="0")
```

--------------------------------

### Access Processed Dataset

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

View the processed dataset, including column names for different splits. Internal columns starting with '_' can be used for looking up original sequences.

```python
# This is the dataset with the test split  
# You can see the column names under each split (the columns starting with _ are internal, but can also be used to look up original sequences for example "_parsed_sequence")
detectability_data
```

--------------------------------

### Initialize Dataset with Specific Features

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/dataset_guide.rst

Specify features to extract from sequences and modifications, and include other model features present in the dataset columns.

```python
dataset = RetentionTimeDataset(
       data_source="data.csv",
       features_to_extract=["mod_loss", "atom_count"], # extracted feautres from the sequence and modifications
       model_features=["collision_energy"], # other features present already in the dataset columns
   )
```

--------------------------------

### Setup Early Stopping Callback

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Configure Keras EarlyStopping callback to monitor validation loss and restore the best weights found during training. This helps prevent overfitting.

```python
from tensorflow.keras.callbacks import EarlyStopping
early_stopping = EarlyStopping(monitor='val_loss', patience=5, verbose=1, mode='min', restore_best_weights=True)
```

--------------------------------

### Configure Learning Rate Scheduler

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Initialize a ReduceLROnPlateau learning rate scheduler to adjust the learning rate during training based on validation loss.

```python
# Learning rate scheduler.
optimizer = optim.Adam(model.parameters(), lr=0.0001)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(
    optimizer,
    factor=0.1,  # lr factor
    patience=2,  # lr patience
    min_lr=1e-7,
)
```

--------------------------------

### Configure Callbacks for Model Training

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Sets up early stopping to prevent overfitting and model checkpointing to save the best performing weights during training. Adjust patience and monitoring metrics as needed.

```python
callback = tf.keras.callbacks.EarlyStopping(monitor = 'val_loss', 
                                            mode = 'min', 
                                            verbose = 1, 
                                            patience = 5)


model_save_path = 'output/weights/new_base_model/base_model_weights_detectability'

model_checkpoint = tf.keras.callbacks.ModelCheckpoint(filepath=model_save_path,
                                                      monitor='val_sparse_categorical_accuracy',
                                                      mode='max',
                                                      verbose=1,
                                                      save_best_only=True, 
                                                      save_weights_only=True)

model.compile(optimizer='adam',
              loss='SparseCategoricalCrossentropy', 
              metrics='sparse_categorical_accuracy')
```

--------------------------------

### Initialize DetectabilityReport

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Instantiates the DetectabilityReport class with necessary parameters for generating evaluation reports. Ensure all required dataframes and paths are correctly provided.

```python
report = DetectabilityReport(targets = test_targets_one_hot, 
                             predictions = predictions, 
                             input_data_df = test_data_df, 
                             output_path = "./output/report_on_Sinitcyn_2000_proteins_test_set_labeled", 
                             history = None, 
                             rank_by_prot = True,
                             threshold = None,
                             name_of_dataset = 'Sinitcyn 2000 proteins test set',
                             name_of_model = 'Fine-tuned model (Original)')
```

--------------------------------

### Initialize ChargeStatePredictor Model

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Instantiate the ChargeStatePredictor model with specified parameters for relative charge state prediction. Ensure the model is moved to the appropriate device (e.g., GPU).

```python
model = ChargeStatePredictor(
    num_classes=6, seq_length=32, alphabet=PTMS_ALPHABET, model_flavour="relative"
)

model.to(device)
```

--------------------------------

### Initialize Intensity Report

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_IntensityModel_Walkthrough_colab.ipynb

Create an IntensityReport object, passing the output path and the training history.

```python
from dlomix.reports import IntensityReport

# create a report object by passing the history object and plot different metrics
report = IntensityReport(output_path="./output", history=history)
```

--------------------------------

### Predict on Raw Sequences

Source: https://context7.com/wilhelm-lab/dlomix/llms.txt

Use this snippet to get probability distributions over charges for raw sequences. The output shape is (N, 6) for N sequences, representing probabilities for charges 1 through 6.

```python
test_sequences = dataset["test"]["modified_sequence"]
predictions = model.predict(test_sequences)
print(predictions.shape)    # (N, 6) — probability distribution over charges 1–6
print(predictions[0].sum()) # ~1.0
```

--------------------------------

### Create Retention Time Report Object

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Instantiate a RetentionTimeReportRunComparisonWandb object to set up a report for comparing different optimizer runs. This requires specifying the Weights & Biases project, report title, description, and the dataset to be used.

```python
# Create a report

from dlomix.reports import RetentionTimeReportRunComparisonWandb
report = RetentionTimeReportRunComparisonWandb(project = "Demo_RetentionTimeReport",
                title = "Comparison of different optimizers",
                description = "Comparison of two optimizers Adam and RMSprop",
                dataset = rtdata)
```

--------------------------------

### Initialize Weights & Biases

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb

Imports the wandb library and the Keras Callback. It then initializes a new Weights & Biases run with a specified project name.

```python
# import wandb and the Keras Callback

import wandb
from wandb.keras import WandbCallback
```

```python
# enter project name
project_name = 'retention time sample run'
wandb.init(project=project_name)
```

--------------------------------

### Define Configuration Dictionary

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Create a configuration dictionary to store hyperparameters and settings for the DLOMix model and training process. This includes sequence length, batch size, learning rate, and optimizer choice.

```python
# Create config

config = {
  "seq_length" : 30,
  "batch_size" : 64,
  "val_ratio" : 0.2,
  "lr" : 0.001,
  "optimizer" : "Adam",
  "loss" : "mse"
}
```

--------------------------------

### Load Data for Fine-tuning Detectability Model

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Prepare data for fine-tuning by creating a `DetectabilityDataset` object. Ensure `data_source` points to your fine-tuning data and specify relevant columns and parameters.

```python
max_pep_length = 40
BATCH_SIZE = 128 
            
# The Class handles all the inner details, we have to provide the column names and the alphabet for encoding
# If the data is already split with a specific logic (which is generally recommended) -> val_data_source and test_data_source are available as well

hf_data = "Wilhelmlab/detectability-sinitcyn"
fine_tune_data = DetectabilityDataset(data_source=hf_data,
                                      data_format='hub',
                                      max_seq_len=max_pep_length,
                                      label_column="Classes",
                                      sequence_column="Sequences",
                                      dataset_columns_to_keep=['Proteins'],
                                      batch_size=BATCH_SIZE,
                                      with_termini=False,
                                      alphabet=aa_to_int_dict,
                                      padding_value="0")
```

--------------------------------

### Import Constants and Dictionaries

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Import predefined constants and dictionaries for class labels, alphabet, and amino acid to integer mapping.

```python
from dlomix.constants import CLASSES_LABELS, alphabet, aa_to_int_dict
```

--------------------------------

### Import Wandb and Keras Callbacks

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Import Weights & Biases for experiment tracking and logging, including specific Keras callbacks for integrating model training with Wandb.

```python
import wandb
from wandb.keras import WandbCallback
from wandb.keras import WandbMetricsLogger
#import wandb.apis.reports as wr
```

--------------------------------

### Initialize Second Weights & Biases Run

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_ModelComparison_wandb_ReportAPI.ipynb

Initialize a new Weights & Biases run for training the second model. This ensures that the experiments for different models are tracked separately.

```python
RUN = "run_2"
wandb.init(project = PROJECT, name = RUN, config = config)
```

--------------------------------

### Set DLOmix Backend to PyTorch

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Sets the DLOmix backend to PyTorch using an environment variable. This should be done before importing DLOmix to ensure the correct backend is loaded.

```python
%env DLOMIX_BACKEND pytorch

import dlomix
dlomix.__version__
```

--------------------------------

### Initialize Dataset with Naive Modifications Encoding Scheme

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/dataset_guide.rst

Use the 'naive-mods' encoding scheme with a built-in alphabet that includes tokens for PTMs.

```python
from dlomix.data import RetentionTimeDataset
from dlomix.constants import ALPHABET_UNMOD, ALPHABET_NAIVE_MODS

# With PTMs, uses built-in naive-mods alphabet with tokens for some amino acids + PTMs combinations
dataset = RetentionTimeDataset(
       data_source="data.csv",
       encoding_scheme="naive-mods",
       alphabet=ALPHABET_NAIVE_MODS
   )
```

--------------------------------

### Log Data to Weights & Biases

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_ModelComparison_wandb_ReportAPI.ipynb

Log the prepared test dataset and model predictions to Weights & Biases. This step is crucial for the report generation to include necessary data visualizations and metrics.

```python
report.log_data()
```

--------------------------------

### Initialize RetentionTimeReport

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb

Create an instance of RetentionTimeReport, providing the output path and the training history object. This object is used for generating various plots and metrics.

```python
from dlomix.reports import RetentionTimeReport

# create a report object by passing the history object and plot different metrics
report = RetentionTimeReport(output_path="./output", history=history)
```

--------------------------------

### Import Necessary Packages

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Import core libraries including TensorFlow, DLOMix modules for data handling, models, and evaluation, as well as specific components for retention time analysis.

```python
# import necessary packages
import tensorflow as tf

import dlomix
from dlomix import (
    constants,
    data,
    eval,
    layers,
    models,
    pipelines,
    reports,
    utils
)
from dlomix.data import RetentionTimeDataset
from dlomix.models import RetentionTimePredictor
from dlomix.eval import TimeDeltaMetric
```

--------------------------------

### Load and Inspect Dataset

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Loads a dataset from Hugging Face and displays its splits and sizes. It also shows the structure of a single training batch.

```python
load_dataset(
    "wilhelm-lab/dlomix",
    "dlomix_dataset",
    split='train[:100000]'
)

# Load the full dataset
data = load_dataset(
    "wilhelm-lab/dlomix",
    "dlomix_dataset",
    split='train'
)

# Inspect the dataset splits and sizes
print(data)

# Display the structure of one training batch
print(f"Training examples: {data.num_rows}")
print(f"one training batch looks like:\n{data[0]}")

print(f"\nValidation examples: {data.validation_split.num_rows}")
print(f"Test examples: {data.test_split.num_rows}")
```

--------------------------------

### Build and Train Retention Time Predictor (PyTorch)

Source: https://context7.com/wilhelm-lab/dlomix/llms.txt

Builds a PrositRetentionTimePredictor model, compiles it with Adam optimizer and MSE loss, and trains it using provided dataset. Inference is performed on the test set.

```python
d = RetentionTimeDataset(
    data_source="example_dataset/proteomTools_train_val.csv",
    test_data_source="example_dataset/proteomTools_test.csv",
    data_format="csv",
    sequence_column="sequence",
    label_column="irt",
    max_seq_len=30,
    batch_size=512,
    val_ratio=0.2,
    dataset_type="pt",
)

model = PrositRetentionTimePredictor(
    seq_length=30,
    alphabet=d.extended_alphabet,
    embedding_output_dim=16,
    recurrent_layers_sizes=(256, 512),
    dropout_rate=0.5,
)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
loss_fn = torch.nn.MSELoss()

for epoch in range(10):
    model.train()
    total_loss = 0.0
    for batch in d.tensor_train_data:
        sequences = batch["sequence"]
        targets = batch["irt"].float().unsqueeze(-1)
        optimizer.zero_grad()
        preds = model(sequences)
        loss = loss_fn(preds, targets)
        loss.backward()
        optimizer.step()
        total_loss += loss.item()
    print(f"Epoch {epoch+1} | Train Loss: {total_loss / len(d.tensor_train_data):.4f}")

model.eval()
with torch.no_grad():
    for batch in d.tensor_test_data:
        preds = model(batch["sequence"])
        print(preds[:5])   # tensor([[ 0.82], [-0.14], ...])
        break
```

--------------------------------

### Import Detectability Model Components

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Import the DetectabilityModel class and relevant constants for model configuration.

```python
from dlomix.models import DetectabilityModel
from dlomix.constants import CLASSES_LABELS, alphabet, aa_to_int_dict
```

--------------------------------

### Import DetectabilityDataset Class

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Import the necessary class for handling detectability datasets.

```python
from dlomix.data import DetectabilityDataset
```

--------------------------------

### Create Dummy Data for Precursor Charge State

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Generates a pandas DataFrame with synthetic data for precursor charge state modeling. Includes sequences, intensities, and various charge state representations.

```python
dummy_data = {
    'modified_sequence': dummy_sequences,
    'precursor_intensity': np.random.lognormal(mean=10, sigma=1, size=num_samples),
    'max_intensity': np.random.lognormal(mean=8, sigma=1.5, size=num_samples),
    'avg_intensity': np.random.lognormal(mean=8, sigma=1, size=num_samples),
    'precursor_charge': np.random.choice(['1', '2', '3', '4', '5', '6'], size=num_samples),
    'charge_by_max_intensity': np.random.randint(1, 6, size=num_samples),
    'charge_state_vector': [list(np.random.choice([0, 1], size=6)) for _ in range(num_samples)],
    'one_hot_most_abundant_charge': [list(np.eye(6)[np.random.randint(0, 6)]) for _ in range(num_samples)],
    'normalized_intensity_distribution': [list(np.random.dirichlet(np.ones(6))) for _ in range(num_samples)],
}

dummy_df = pd.DataFrame(dummy_data)
print(dummy_df.head())
```

--------------------------------

### Initialize and Load Model

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough_torch.ipynb

Initializes a ChargeStatePredictor model and loads trained weights from a specified path. Ensure the model architecture matches the saved state dictionary.

```python
from dlomix.models.pt_models import ChargeStatePredictor
from dlomix.constants import PTMS_ALPHABET
import torch

# initialize model
loaded_model = ChargeStatePredictor(
    num_classes=6, seq_length=32, alphabet=PTMS_ALPHABET, model_flavour="relative"
)

# load trained model states
save_path = "path/to/your/model.pt"
state_dict = torch.load(save_path)
loaded_model.load_state_dict(state_dict)

print("<All keys matched successfully>")
```

--------------------------------

### Initialize RetentionTimeDataset with Separate Files

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/dataset_guide.rst

Load training, validation, and test data from separate CSV files.

```python
dataset = RetentionTimeDataset(
       data_source="train.csv",
       val_data_source="val.csv",
       test_data_source="test.csv",
       data_format="csv"
   )
```

--------------------------------

### Import Libraries and Models

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Imports essential libraries for data manipulation, modeling, and machine learning, including specific charge state prediction models from dlomix.

```python
import matplotlib.pyplot as plt
import tensorflow as tf
import pandas as pd 
import numpy as np 
import random

# Models 
from dlomix.models.chargestate import DominantChargeStatePredictor, ObservedChargeStatePredictor, ChargeStateDistributionPredictor

# Constants
from dlomix.constants import ALPHABET_UNMOD

from tensorflow.keras.optimizers import Adam
from tensorflow.keras.callbacks import Callback
from tensorflow.keras.models import load_model
from tensorflow.keras.losses import binary_crossentropy
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix
from sklearn.metrics import mean_squared_error, mean_absolute_error
from scipy.spatial.distance import cosine
from scipy.spatial.distance import cosine
from scipy.stats import entropy
```

--------------------------------

### Prepare Test Targets and Dataframe

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_training_and_fine_tuning.ipynb

Accesses the test targets and sequences from the dataset, decodes class labels, and creates a Pandas DataFrame for reporting. Sequences are joined into strings.

```python
# access val dataset and get the Classes column
test_targets_FT = fine_tune_data["test"]["Classes"]


# if needed, the decoded version of the classes can be retrieved by looking up the class names
test_targets_decoded_FT = [CLASSES_LABELS[x] for x in test_targets_FT]


test_targets_FT[0:5], test_targets_decoded_FT[0:5]
```

```python
# The dataframe needed for the report

test_data_df_FT = pd.DataFrame(
    {
        "Sequences": fine_tune_data["test"]["_parsed_sequence"], # get the raw parsed sequences
        "Classes": test_targets_FT, # get the test targets from above
        "Proteins": fine_tune_data["test"]["Proteins"] # get the Proteins column from the dataset object
    }
)

test_data_df_FT.Sequences = test_data_df_FT.Sequences.apply(lambda x: "".join(x)) # join the sequences since they are a list of string amino acids.
test_data_df_FT.head(5)
```

--------------------------------

### Set Random Seeds and Generate Dummy Data

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Initializes random number generators for reproducibility and creates a list of random amino acid sequences. These sequences serve as dummy data for model development.

```python
# Set the random seeds
np.random.seed(42)
random.seed(42)

# Dummy Data Size
num_samples = 1000
amino_acids = "ACDEFGHIKLMNPQRSTVWY"
min_seq_len = 5
max_seq_len = 20

# Generate random sequences
def generate_random_sequence(length):
    return "".join(random.choices(amino_acids, k=length))

dummy_sequences = [generate_random_sequence(random.randint(min_seq_len, max_seq_len)) for _ in range(num_samples)]
```

--------------------------------

### Load Pre-trained Models and Create Test Set

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_ModelComparison_wandb_ReportAPI.ipynb

Load previously saved model weights for two retention time predictor models and create a test dataset using DLOmix's RetentionTimeDataset. This prepares the models and data for comparison.

```python
# create predictors from saved weights
load_path = "./output/rtmodel_1"
pre_trained_model_1 = RetentionTimePredictor(encoder = "lstm", seq_length=30)
pre_trained_model_1.load_weights(load_path)

load_path = "./output/rtmodel_2"
pre_trained_model_2 = RetentionTimePredictor(seq_length=30)
pre_trained_model_2.load_weights(load_path)

models = {"lstm_model": pre_trained_model_1, "conv_model": pre_trained_model_2}

# create testset
TEST_DATAPATH = 'https://raw.githubusercontent.com/wilhelm-lab/dlomix/main/example_dataset/proteomTools_test.csv'
test_set = RetentionTimeDataset(data_source = TEST_DATAPATH,
                                seq_length = config["seq_length"],
                                batch_size = 32,
                                test = True,
                                sequence_col = "sequence",
                                target_col = "irt")
```

--------------------------------

### Initialize RetentionTimeDataset from Hugging Face Hub

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/dataset_guide.rst

Load data from a remote Hugging Face dataset.

```python
dataset = RetentionTimeDataset(
       data_source="wilhelmlab/prospect-rt",
       data_format="hub"
   )
```

--------------------------------

### Verify Model Loading with Numpy

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RTModel_Walkthrough_colab-weights-and-biases.ipynb

Compare the predictions from the original model and the model loaded from saved weights using numpy.allclose() to ensure they are identical.

```python
import numpy as np
# confirm all old and new predictions are the same
np.allclose(predictions, new_predictions)
```

--------------------------------

### Model Configuration Parameters

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_Detectability_Model_Walkthrough_prediction_colab.ipynb

Display model configuration parameters such as the number of classes, input dimension, and GRU cells.

```python
CLASSES_LABELS, len(alphabet), aa_to_int_dict
```

--------------------------------

### Import Training Utilities

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_IntensityModel_Walkthrough_colab.ipynb

Imports TensorFlow and custom loss functions from DLOmix for model training. These are necessary for compiling and training the Keras model.

```python
#imports

import tensorflow as tf
from dlomix.losses import masked_spectral_distance, masked_pearson_correlation_distance
```

--------------------------------

### Import DLOmix Classes

Source: https://github.com/wilhelm-lab/dlomix/blob/main/docs/notes/backend_usage.rst

Always import classes from the top-level DLOmix module. The backend implementation is selected automatically. Class names remain consistent regardless of the backend.

```python
from dlomix.models import ChargeStatePredictor
from dlomix.layers import AttentionLayer
```

--------------------------------

### Log Dataset to Weights & Biases

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_RetentionTimeReport_RunComparison_wandb_ReportAPI.ipynb

Log the prepared dataset information to Weights & Biases. This makes dataset characteristics available for analysis within the Wandb interface.

```python
# Log data to Weights & Biases

report.log_data()
```

--------------------------------

### Define Data Path and Batch Size

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/Example_PCSP_huggingface_walkthrough.ipynb

Sets the path to the PROSPECT dataset for charge state prediction and defines the batch size for data loading.

```python
DATA_PATH = "Wilhelmlab/prospect-ptms-charge"   # complete PROSPECT dataset prepared for charge state prediction
BATCH_SIZE = 512
```

--------------------------------

### Display First Rows of Dummy Training Data

Source: https://github.com/wilhelm-lab/dlomix/blob/main/notebooks/precursor_charge_state_dev/model_dev.ipynb

Shows the first few rows of the dummy training dataframe to inspect its structure and content.

```python
dummy_train_df.head()
```
Tokens:
Raw