Skip to content
The Chat Archive
Human-written demonstration (OpenAssistant volunteers)· OpenAssistant (human-written) 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

    I'm happy to do both. Let's start with Rust:

    extern crate pandas;
    extern crate rdkit;
    extern crate sklearn;
    extern crate keras;
    
    use pandas::pandas::read_csv;
    use rdkit::rdkit::{Chem, MolToSmiles, MolFromSmiles};
    use sklearn::model_selection::train_test_split;
    use keras::models::Sequential;
    use keras::layers::{LSTM, Dense};
    
    // Read the data from the CSV file
    let df = read_csv("data.csv").unwrap();
    let smiles = df["SMILES"].tolist();
    let labels = df["Label"].tolist();
    
    // Clean the SMILES
    let cleaned_smiles = smiles.iter().map(|s| {
        MolToSmiles(MolFromSmiles(s))
    }).collect::<Vec<_>>();
    
    // Remove duplicates
    let cleaned_smiles = cleaned_smiles.into_iter().unique().collect::<Vec<_>>();
    
    // Split the data into training and testing sets and create/train the model
    let (X_train, X_test, y_train, y_test) = train_test_split(cleaned_smiles, labels);
    let model = Sequential::new(vec![LSTM::new(32), Dense::new(1, "sigmoid")]);
    model.fit(&X_train, &y_train);
    
    // Evaluate the model
    model.evaluate(&X_test, &y_test);
    

    And this is how it would look in Go:

    package main
    
    import (
    	"github.com/lucasb-eyer/go-colorful"
    	"github.com/rdkit/rdkit/Chem"
    	"github.com/sajari/regression"
    	"github.com/sajari/regression/linear"
    	"github.com/tealeg/xlsx"
    )
    
    func main() {
    	// Read the data from the CSV file
    	xlFile, err := xlsx.Open("data.xlsx")
    	if err != nil {
    		panic(err)
    	}
    
    	var smiles []string
    	var labels []float64
    	for _, sheet := range xlFile.Sheets {
    		for _, row := range sheet.Rows {
    			smile, label := row.Cells[0].String(), row.Cells[1].Float()
    			smiles = append(smiles, smile)
    			labels = append(labels, label)
    		}
    	}
    
    	// Clean the SMILES
    	var cleanedSmiles []string
    	for _, smile := range smiles {
    		mol, err := Chem.MolFromSmiles(smile)
    		if err != nil {
    			continue
    		}
    		cleanedSmiles = append(cleanedSmiles, Chem.MolToSmiles(mol))
    	}
    
    	// Remove duplicates
    	colorMap := make(map[string]bool)
    	for _, smile := range cleanedSmiles {
    		if _, exists := colorMap[smile]; !exists {
    			colorMap[smile] = true
    		}
    	}
    
    	// Train and test the model
    	var x, y []regression.DataPoint
    	for i, smile := range cleanedSmiles {
    		if _, exists := colorMap[smile]; exists {
    			x = append(x, regression.DataPoint([]float64{float64(i)}, []float64{labels[i]}))
    			y = append(y, labels[i])
    		}
    	}
    	model := linear.NewRegression(x, y)
    	model.Run()
    
    	// Evaluate the model
    	rms, err := model.RMSE()
    	if err != nil {
    		panic(err)
    	}
    	println("RMS:", rms)
    }
    

    I hope this is helpful for you! Is there anything I should explain to you about it, or can I serve you with another answer for Rust or Go?

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