両方をしてうれしいです。さびから始めましょう：

「錆
Extern Crate Pandas;
Extern Crate rdkit;
Extern Crate Sklearn;
Extern Crate Keras;

pandas :: pandas :: read_csvを使用してください。
rdkit :: rdkit :: {chem、moltosmiles、molfromsmiles}を使用してください。
sklearn :: model_selection :: train_test_split;を使用してください。
keras :: models :: sequentialを使用します。
keras :: layers :: {lstm、dense}を使用してください。

// CSVファイルからデータを読み取ります
let df = read_csv（ "data.csv"）。unwrap（）;
let smiles = df ["smiles"]。tolist（）;
let labels = df ["label"]。tolist（）;

//笑顔をきれいにします
let cleaned_smiles = smiles.iter（）。map（| s | {{
    moltosmiles（molfromsmiles（s））
}）。collect :: <vec <_ >>（）;

//複製を削除します
let cleaned_smiles = cleaned_smiles.into_iter（）。inquire（）。collect :: <vec <_ >>（）;

//データをトレーニングとテストセットに分割し、モデルを作成/トレーニングします
let（x_train、x_test、y_train、y_test）= train_test_split（cleaned_smiles、labels）;
let model = sequenty :: new（vec！[lstm :: new（32）、dense :: new（1、 "sigmoid"）））;
model.fit（＆x_train、＆y_train）;

//モデルを評価します
Model.Evaluate（＆x_test、＆y_test）;
`` `
そして、これはそれがどのように見えるかです：

「行きます
パッケージメイン

輸入 （
「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（）{
// CSVファイルからデータを読み取ります
xlfile、err：= xlsx.open（ "data.xlsx"）
err！= nil {
パニック（err）
}

var Smiles []文字列
varラベル[] float64
_、シート：= range xlfile.sheets {
_、row：= range sheet.rows {
笑顔、ラベル：= row.cells [0] .string（）、row.cells [1] .float（）
笑顔=追加（笑顔、笑顔）
ラベル= append（ラベル、ラベル）
}
}

//笑顔をきれいにします
var cleanedsmiles []文字列
_、笑顔：=レンジスマイル{
mol、err：= chem.molfromsmiles（笑顔）
err！= nil {
続く
}
cleanedsmiles = append（cleanedsmiles、chem.moltosmiles（mol））
}

//複製を削除します
colormap：= make（map [string] bool）
_、smile：= range cleanedsmiles {
_、存在する場合：= colormap [smile];！存在する{
colormap [smile] = true
}
}

//モデルをトレーニングしてテストします
var x、y [] regression.datapoint
私の場合、笑顔：=範囲Cleanedsmiles {
_、存在する場合：= colormap [smile];存在する{
x = append（x、regression.datapoint（[] float64 {float64（i）}、[] float64 {labels [i]}））
y = append（y、ラベル[i]）
}
}
モデル：= linear.newregression（x、y）
model.run（）

//モデルを評価します
rms、err：= model.rmse（）
err！= nil {
パニック（err）
}
println（ "rms："、rms）
}
`` `

これがあなたに役立つことを願っています！それについて説明すべきことはありますか、それとも錆や行くための別の答えをあなたに提供できますか？
I'm happy to do both. Let's start with Rust:

```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:

```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?