Skip to content
TheChatArchiveThe Chat Archive
Human-written demonstration (OpenAssistant volunteers)· OpenAssistant (human-written)Hugging Face OpenAssistant Conversations (oasst2)

Write a python script to load a list of SMILES or SMARTS strings from a csv file. Clean…

In OpenAssistant data, “assistant” turns were written by human volunteers as demonstrations. They are not model outputs.
  1. User

    Write a python script to load a list of SMILES or SMARTS strings from a csv file. Clean the input data and remove any duplicates or tautomers. Make sure all protonation states are appropriate for pH 7. Create a small LSTM to predict the label found in the csv file.

  2. Assistant

    Here is a basic outline of the steps required:

    Read the CSV file and extract the SMILES/SMARTS strings and labels Clean the SMILES/SMARTS strings using RDKit - remove duplicates, standardize tautomers/protomers, etc. Create LSTM model Train the model on the cleaned data Evaluate the model's performance

    So in code it would look something like: import pandas as pd from rdkit import Chem from sklearn.model_selection import train_test_split from keras.models import Sequential from keras.layers import LSTM, Dense

    Read CSV and extract data

    df = pd.read_csv('data.csv') smiles = df['SMILES'].tolist() labels = df['Label'].tolist()

    Clean SMILES

    cleaned_smiles = [Chem.MolToSmiles(Chem.MolFromSmiles(s)) for s in smiles]

    Remove duplicates

    cleaned_smiles = list(set(cleaned_smiles))

    train/test split and create/train model

    X_train, X_test, y_train, y_test = train_test_split(cleaned_smiles, labels) model = Sequential([LSTM(32), Dense(1, activation='sigmoid')]) model.fit(X_train, y_train)

    Evaluate

    model.evaluate(X_test, y_test)

    This is just a brief outline, many additional details would need to be added for a full working script. Let me know if you would like help with any specific part of the code.

  3. User

    Can you convert the code to Go or Rust for me?

  4. Assistant

    Sure, here is a Rust implementation of the same functionality:

    extern crate csv; extern crate rdkit; extern crate tensorflow;

    use std::error::Error; use std::fs::File; use std::path::Path;

    use csv::Reader; use rdkit::chem::smiles::Smiles; use rdkit::chem::smiles::SmilesWriter; use tensorflow::{ data::{Dataset, Example}, prelude::*, };

    fn main() -> Result<(), Box> { // Read CSV and extract data let mut reader = Reader::from_path("data.csv")?; let records = reader.records(); let (smiles, labels): (Vec<>, Vec<>) = records .map(|r| r.unwrap()) .map(|r| (r[0].to_owned(), r[1].parse().unwrap())) .unzip();

    // Clean SMILES
    let cleaned_smiles = smiles
        .iter()
        .map(|s| SmilesWriter::new().write(Smiles::new(s).unwrap().iter()))
        .collect::<Vec<_>>();
    
    // Remove duplicates
    let cleaned_smiles = cleaned_smiles.into_iter().unique().collect::<Vec<_>>();
    
    // Create and train model
    let (train_smiles, test_smiles, train_labels, test_labels) =
        create_train_test_split(&cleaned_smiles, &labels, 0.8);
    let model = create_and_train_model(train_smiles, train_labels)?;
    
    // Evaluate
    evaluate_model(&model, &test_smiles, &test_labels)?;
    
    Ok(())
    

    }

    fn create_train_test_split( smiles: &[String], labels: &[u32], test_size: f64, ) -> (Vec, Vec, Vec, Vec) { let mut rng = rand::thread_rng(); let len = smiles.len(); let test_len = (len as f64 * test_size) as usize; let mut indices = (0..len).collect::<Vec<_>>(); indices.shuffle(&mut rng);

    let train_indices = &indices[test_len..];
    let test_indices = &indices[..test_len];
    
    let train_smiles = train_indices.iter().map(|&i| smiles[i].clone()).collect();
    let test_smiles = test_indices.iter().map(|&i| smiles[i].clone()).collect();
    let train_labels = train_indices.iter().map(|&i| labels[i]).collect();
    let test_labels = test_indices.iter().map(|&i| labels[i]).collect();
    
    (train_smiles, test_smiles, train_labels, test_labels)
    

    }

    fn create_and_train_model( smiles: Vec, labels: Vec, ) -> Result<tensorflow::Sequential, Box> { let mut model = tensorflow::Sequential::new(); model.add(tensorflow::layers::LSTM::new(32)); model.add(tensorflow::layers::Dense::new(1, tensorflow::activations::sigmoid()));

    let (x_train, y_train) = create_dataset(smiles, labels)?;
    
    let mut opt = tensorflow::optimizers::Adam::default();
    let loss = tensorflow::losses::BinaryCrossentropy::new();
    model.compile(&opt, loss, &[tensorflow::metrics::Accuracy::new()])?;
    
    model.fit(&x_train, &y_train, 64, Some(10))?;
    
    Ok(model)
    

    }

    fn create_dataset( smiles: Vec, labels: Vec, ) -> Result<(tensorflow::Tensor, tensorflow::Tensor), Box> { let mut dataset = tensorflow::data::Dataset::new().batch(smiles.len() as u64); for (smile, label) in smiles.iter().zip(labels.iter()) { let example = Example::builder() .add_feature( tensorflow::Feature::BytesList( vec![tensorflow::BytesList::from(smile.as_bytes())].into(), ), ) .add_feature(tensorflow::Feature::Int64List(vec![*label as i64].into())) .build()?; dataset = dataset.add_example(example); }

    let (x_train, y_train) = dataset.unpack();
    
    Ok((x_train, y_train))
    

    }

    fn evaluate_model( model: &tensorflow::Sequential, smiles: &[String], labels: &[u32], ) -> Result use rand::prelude::; use tensorflow::prelude::;

    fn main() -> Result<(), Box> { let df = read_csv("data.csv")?; let (smiles, labels) = extract_data(&df); let cleaned_smiles = clean_smiles(&smiles);

    let (train_smiles, test_smiles, train_labels, test_labels) = split_data(
        &cleaned_smiles,
        &labels,
        test_size = 0.2,
        random_seed = 42,
    );
    
    let model = create_and_train_model(train_smiles, train_labels)?;
    let accuracy = evaluate_model(&model, &test_smiles, &test_labels)?;
    
    println!("Accuracy: {:.2}", accuracy);
    
    Ok(())
    

    }

    fn read_csv(path: &str) -> Result<DataFrame, Box> { let df = DataFrame::read_csv(path)?; Ok(df) }

    fn extract_data(df: &DataFrame) -> (Vec, Vec) { let smiles = df.get_column::("SMILES").unwrap(); let labels = df.get_column::("Label").unwrap();

    (smiles, labels)
    

    }

    fn clean_smiles(smiles: &[String]) -> Vec { // Clean SMILES let cleaned_smiles = smiles .iter() .map(|s| clean_smile(s)) .collect::<Vec<_>>();

    // Remove duplicates
    let cleaned_smiles = cleaned_smiles
        .into_iter()
        .collect::<HashSet<_>>()
        .into_iter()
        .collect();
    
    cleaned_smiles
    

    }

    fn clean_smile(smile: &str) -> String { // RDKit implementation to clean SMILES String::from(smile) }

    fn split_data( smiles: &[String], labels: &[u32], test_size: f64, random_seed: u64, ) -> (Vec, Vec, Vec, Vec) { let mut rng = StdRng::seed_from_u64(random_seed);

    let len = smiles.len();
    let test_len = (len as f64 * test_size) as usize;
    let mut indices = (0..len).collect::<Vec<_>>();
    indices.shuffle(&mut rng);
    
    let train_indices = &indices[test_len..];
    let test_indices = &indices[..test_len];
    
    let train_smiles = train_indices.iter().map(|&i| smiles[i].clone()).collect();
    let test_smiles = test_indices.iter().map(|&i|) smiles[i].clones()).collect();
    let train_labels = train_indices.iter().map(|&i| labels[i]).collect();
    let test_labels = test_indices.iter().map(|&i| labels[i]).collect();
    
    (train_smiles, test_smiles, train_labels, test_labels)
    

    }

    fn create_and_train_model(smiles: Vec, labels: Vec) -> Result<Model, Box> { let mut model = Model::new(); model.add_layer(Dense::new(32, Activation::Relu)); model.add_layer(Dense::new(1, Activation::Sigmoid));

    let optimizer = Optimizer::Adam;
    
    model.compile(optimizer, Loss::BinaryCrossentropy);
    model.fit(smiles, labels, epochs = 32)?;
    
    Ok(model)
    

    }

    fn evaluate_model(model: &Model, smiles: &[String], labels: &[u32]) -> Result<f64, Box> { let accuracy = model.evaluate(smiles, labels)?; Ok(accuracy) }

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.