Develop

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-members = [ "crates/redeem-classifiers",
+members = [ "crates/redeem-classifiers", "crates/redeem-cli",
     "crates/redeem-properties"
 ]
 

Dockerfile

@@ -0,0 +1,50 @@
+# Use the official NVIDIA CUDA base image with CUDA 12.2
+FROM nvidia/cuda:12.2.2-devel-ubuntu22.04
+
+# Install system dependencies
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends \
+    build-essential \
+    ca-certificates \
+    curl \
+    libssl-dev \
+    pkg-config \
+    clang \
+    libstdc++-12-dev \
+    cmake \  
+    git \    
+    && \
+    update-ca-certificates && \
+    rm -rf /var/lib/apt/lists/*
+
+# Install Rust using rustup
+RUN curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+ENV PATH="/root/.cargo/bin:${PATH}"
+
+# Set environment variables for CUDA
+ENV CUDA_HOME=/usr/local/cuda
+ENV PATH=${CUDA_HOME}/bin:${PATH}
+ENV LD_LIBRARY_PATH=${CUDA_HOME}/lib64:${LD_LIBRARY_PATH}
+
+# Set the CUDA compute capability for the build process
+# Tesla V100 has compute capability 7.0
+ENV CUDA_COMPUTE_CAP=70
+
+# Set the working directory
+WORKDIR /app
+
+# Copy the source code into the container
+COPY Cargo.toml Cargo.lock ./
+COPY crates ./crates
+
+# Build the application with CUDA support
+RUN cargo build --release --bin redeem --features cuda 
+
+# Copy the binary into the PATH
+RUN cp target/release/redeem /app/redeem
+
+# clean up build artifacts
+RUN cargo clean
+
+# Set the PATH environment variable
+ENV PATH="/app:${PATH}"

README.md

@@ -30,15 +30,17 @@ The ReDeeM project consists of two primary crates:
 
 1. **redeem-properties**: 
    - This crate focuses on deep learning models for peptide property prediction. It implements models for predicting retention time (RT), ion mobility (IM), and MS2 fragment intensities using the Candle library.
-   - The models can be fine-tuned on new data and can be saved in the safetensor format for later use.
+   - The models can be trained, fine-tuned on new data and can be saved in the safetensor format for later use.
 
    - Current Models
 
     Model | Name | Architecture | Implemented
     --- | --- | --- | ---
-    AlphaPept RT Model | `redeem_properties::RTCNNLSTMModel` | CNN-LSTM | :heavy_check_mark:
-    AlphaPept MS2 Model | `redeem_properties::MS2BertModel` | Bert | :heavy_check_mark:
-    AlphaPept IM Model | `redeem_properties::CCSCNNLSTMModel` | CNN-LSTM | :heavy_check_mark:
+    AlphaPept RT Model | `rt_cnn_lstm` | CNN-LSTM | :heavy_check_mark:
+    AlphaPept MS2 Model | `ms2_bert` | Bert | :heavy_check_mark:
+    AlphaPept CCS Model | `ccs_cnn_lstm` | CNN-LSTM | :heavy_check_mark:
+    RT Model | `rt_tf_lstm` | CNN-Transformer | :heavy_check_mark:
+    CCS Model | `ccs_tf_lstm` | CNN-Transformer | :heavy_check_mark:
 
 2. **redeem-classifiers**:
    - This crate is aimed at developing semi-supervised scoring classifier models. The goal is to create models for separating target peptides from decoys.

crates/redeem-classifiers/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2021"
 rust-version = "1.76"
 description = "A repository of deep-learning models for mass spectrometry data"
 readme = "README.md"
-license = "MIT"
+
 
 [dependencies]
 anyhow = "1.0"

crates/redeem-classifiers/examples/gbdt_semi_supervised_learning.rs

@@ -5,57 +5,84 @@ use ndarray::{Array1, Array2};
 use std::error::Error;
 use std::fs::File;
 use std::io::Write;
+use std::io::BufReader;
 
+use redeem_classifiers::data_handling::PsmMetadata;
 use redeem_classifiers::psm_scorer::SemiSupervisedLearner;
 use redeem_classifiers::models::utils::ModelType;
 use redeem_classifiers::report::{report::{Report, ReportSection}, plots::{plot_score_histogram, plot_pp}};
 
 
-fn read_features_tsv(path: &str) -> Result<Array2<f32>, Box<dyn Error>> {
+/// Load a test PSM CSV file into feature matrix, labels, and metadata.
+///
+/// # Arguments
+/// * `path` - Path to the CSV file
+///
+/// # Returns
+/// A tuple of (`x`, `y`, `PsmMetadata`)
+pub fn load_test_psm_csv(path: &str) -> Result<(Array2<f32>, Array1<i32>, PsmMetadata)> {
+    let file = File::open(path)?;
     let mut reader = ReaderBuilder::new()
-        .has_headers(false)
-        .delimiter(b',')
-        .from_path(path)?;
-
-    let mut data = Vec::new();
+        .has_headers(true)
+        .from_reader(BufReader::new(file));
+
+    let headers = reader
+        .headers()?
+        .iter()
+        .map(|h| h.to_string())
+        .collect::<Vec<_>>();
+
+    // Find indices
+    let file_id_idx = headers.iter().position(|h| h == "file_id").unwrap();
+    let spec_id_idx = headers.iter().position(|h| h == "spec_id").unwrap();
+    let label_idx = headers.iter().position(|h| h == "label").unwrap();
+
+    // Everything else is a feature
+    let feature_indices: Vec<usize> = (0..headers.len())
+        .filter(|&i| i != file_id_idx && i != spec_id_idx && i != label_idx)
+        .collect();
+
+    let feature_names = feature_indices
+        .iter()
+        .map(|&i| headers[i].clone())
+        .collect::<Vec<_>>();
+
+    let mut file_ids = Vec::new();
+    let mut spec_ids = Vec::new();
+    let mut labels = Vec::new();
+    let mut features = Vec::new();
 
     for result in reader.records() {
         let record = result?;
-        let row: Vec<f32> = record
+
+        file_ids.push(record[file_id_idx].parse::<usize>()?);
+        spec_ids.push(record[spec_id_idx].to_string());
+        labels.push(record[label_idx].parse::<i32>()?);
+
+        let row = feature_indices
             .iter()
-            .map(|field| field.parse::<f32>())
-            .collect::<Result<_, _>>()?;
-        data.push(row);
+            .map(|&i| record[i].parse::<f32>().unwrap_or(f32::NAN))
+            .collect::<Vec<f32>>();
+
+        features.extend(row);
     }
 
-    let n_samples = data.len();
-    let n_features = data[0].len();
+    let n_rows = labels.len();
+    let n_cols = feature_indices.len();
 
-    Array2::from_shape_vec(
-        (n_samples, n_features),
-        data.into_iter().flatten().collect(),
-    )
-    .map_err(|e| e.into())
-}
+    let x = Array2::from_shape_vec((n_rows, n_cols), features)?;
+    let y = Array1::from_vec(labels);
 
-fn read_labels_tsv(path: &str) -> Result<Array1<i32>, Box<dyn Error>> {
-    let mut reader = ReaderBuilder::new()
-        .has_headers(false)
-        .delimiter(b'\t')
-        .from_path(path)?;
-
-    let labels: Vec<i32> = reader
-        .records()
-        .map(|r| {
-            let record = r?;
-            let value = record.get(0).ok_or_else(|| "Empty row".to_string())?;
-            value.parse::<i32>().map_err(|e| e.into())
-        })
-        .collect::<Result<_, Box<dyn Error>>>()?;
-
-    Ok(Array1::from_vec(labels))
+    let metadata = PsmMetadata {
+        file_id: file_ids,
+        spec_id: spec_ids,
+        feature_names,
+    };
+
+    Ok((x, y, metadata))
 }
 
+
 fn save_predictions_to_csv(
     predictions: &Array1<f32>,
     file_path: &str,
@@ -71,12 +98,10 @@ fn save_predictions_to_csv(
 
 fn main() -> Result<()> {
     env_logger::init();
-    // Load the test data from the TSV files
-    let x = read_features_tsv("/home/singjc/Documents/github/sage_bruker/20241115_single_file_redeem/sage_scores_for_testing.csv").unwrap();
-    // Select first 10 columns of data
-    let x = x.slice(ndarray::s![.., ..10]).to_owned();
+    // Set log level to debug
+    log::set_max_level(log::LevelFilter::Debug);
 
-    let y = read_labels_tsv("/home/singjc/Documents/github/sage_bruker/20241115_single_file_redeem/sage_labels_for_testing.csv").unwrap();
+    let (x, y, metadata) = load_test_psm_csv("/home/singjc/Documents/github/sage_bruker/20241115_single_file_redeem/sage_scores_with_metadata_for_testing_redeem.csv")?;
 
     println!("Loaded features shape: {:?}", x.shape());
     println!("Loaded labels shape: {:?}", y.shape());
@@ -97,7 +122,7 @@ fn main() -> Result<()> {
         3,
         Some((0.15, 1.0))
     );
-    let predictions = learner.fit(x, y.clone());
+    let (predictions, _ranks) = learner.fit(x, y.clone(), metadata)?;
 
     println!("Labels: {:?}", y);