scripts/st4_model_training.py

# Uni-Mol training

import torch
import torch.nn as nn
import pandas as pd
from torch.utils.data import DataLoader, Dataset
import numpy as np
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score
from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor
import os
import joblib

# Define Uni-Mol-like simple neural network
class UniMolModel(nn.Module):
    def __init__(self, input_size):
        super(UniMolModel, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Padding function to standardize number of atoms (default max 20 atoms)
def pad_coords(coords, max_atoms=20):
    padded = np.zeros((max_atoms, 3))
    n_atoms = min(len(coords), max_atoms)
    padded[:n_atoms] = coords[:n_atoms]
    return padded.flatten()

# Function to safely parse xyz string into padded coords
def xyz_to_coords(xyz_str, max_atoms=20):
    try:
        coords = [list(map(float, line.split()[1:])) for line in xyz_str.strip().splitlines()]
    except Exception:
        coords = np.zeros((max_atoms, 3))
    return pad_coords(coords, max_atoms)

# Custom Dataset
class MoleculeDataset(Dataset):
    def __init__(self, dataframe, max_atoms=20):
        self.data = dataframe
        self.max_atoms = max_atoms

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        coords = xyz_to_coords(self.data.iloc[idx]['xyz'], self.max_atoms)
        gap = self.data.iloc[idx]['gap']
        return torch.tensor(coords, dtype=torch.float32), torch.tensor(gap, dtype=torch.float32)

# Load data
train_df = pd.read_csv('formed_xyz_train.csv')
test_df = pd.read_csv('formed_xyz_test.csv')

# Dataset & DataLoader
train_dataset = MoleculeDataset(train_df)
test_dataset = MoleculeDataset(test_df)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# Model initialization
input_size = len(train_dataset[0][0])  # 3D coordinates flattened

# List of models
models = {
    'UniMol': UniMolModel(input_size=input_size),
    'RandomForest': RandomForestRegressor(),
    'GradientBoosting': GradientBoostingRegressor()
}

# Loss & optimizer
criterion = nn.MSELoss()

# Results list
results = []

# Training & Evaluation Loop
for model_id, model in models.items():
    if model_id == 'UniMol':
        optimizer = torch.optim.Adam(model.parameters(), lr=0.001)
        num_epochs = 20
        for epoch in range(num_epochs):
            model.train()
            running_loss = 0.0
            for inputs, targets in train_loader:
                optimizer.zero_grad()
                outputs = model(inputs)
                loss = criterion(outputs.squeeze(), targets)
                loss.backward()
                optimizer.step()
                running_loss += loss.item()
            print(f'{model_id} - Epoch {epoch+1}/{num_epochs}, Loss: {running_loss / len(train_loader)}')

        model.eval()
        predictions = []
        true_values = []
        names = test_df['name'].tolist()
        with torch.no_grad():
            for inputs, targets in test_loader:
                outputs = model(inputs)
                predictions.extend(outputs.squeeze().tolist())
                true_values.extend(targets.tolist())

    else:
        X_train = np.array([xyz_to_coords(xyz, max_atoms=20) for xyz in train_df['xyz']])
        y_train = train_df['gap'].values

        X_test = np.array([xyz_to_coords(xyz, max_atoms=20) for xyz in test_df['xyz']])
        y_test = test_df['gap'].values

        model.fit(X_train, y_train)
        predictions = model.predict(X_test)
        true_values = y_test
        names = test_df['name'].tolist()

    # Evaluation metrics
    mse = mean_squared_error(true_values, predictions)
    rmse = np.sqrt(mse)
    mae = mean_absolute_error(true_values, predictions)
    r2 = r2_score(true_values, predictions)

    print(f'{model_id} - MSE: {mse}, RMSE: {rmse}, MAE: {mae}, R2: {r2}')

    # Save predictions
    prediction_df = pd.DataFrame({
        'name': names,
        'true_gap': true_values,
        'predicted_gap': predictions
    })
    prediction_df.to_csv(f'unimol_predictions_{model_id}.csv', index=False)

    # Save model
    if model_id == 'UniMol':
        torch.save(model.state_dict(), f'unimol_model_{model_id}.pth')
    else:
        joblib.dump(model, f'{model_id}_model.pkl')

    # Record performance
    results.append({
        'model_id': model_id,
        'MSE': mse,
        'RMSE': rmse,
        'MAE': mae,
        'R2': r2
    })

# Save all scores
metrics_df = pd.DataFrame(results)
metrics_df.to_csv('unimol_model_scores.csv', index=False)

# Top 3 by R2
top_3_models = metrics_df.sort_values(by='R2', ascending=False).head(3)
print("Top 3 Models and their Performance Metrics:")
print(top_3_models)



'''
import torch
import torch.nn as nn
import pandas as pd
from torch.utils.data import DataLoader, Dataset
import numpy as np


# Define Uni-Mol-like simple neural network
class UniMolModel(nn.Module):
    def __init__(self, input_size):
        super(UniMolModel, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 1)

    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# Padding function to standardize number of atoms (default max 20 atoms)
def pad_coords(coords, max_atoms=20):
    padded = np.zeros((max_atoms, 3))
    n_atoms = min(len(coords), max_atoms)
    padded[:n_atoms] = coords[:n_atoms]
    return padded.flatten()

# Custom Dataset
class MoleculeDataset(Dataset):
    def __init__(self, dataframe, max_atoms=20):
        self.data = dataframe
        self.max_atoms = max_atoms

    def __len__(self):
        return len(self.data)

    def __getitem__(self, idx):
        coords = self.data.iloc[idx]['xyz']
        try:
            coords = np.array([list(map(float, line.split()[1:])) for line in coords.strip().splitlines()])
            coords = pad_coords(coords, self.max_atoms)
        except:
            coords = np.zeros(self.max_atoms * 3)

        gap = self.data.iloc[idx]['gap']
        return torch.tensor(coords, dtype=torch.float32), torch.tensor(gap, dtype=torch.float32)

# Load data
train_df = pd.read_csv('formed_xyz_train.csv')
test_df = pd.read_csv('formed_xyz_test.csv')

# Dataset & DataLoader
train_dataset = MoleculeDataset(train_df)
test_dataset = MoleculeDataset(test_df)

train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# Model
input_size = len(train_dataset[0][0])  # 3D coordinates flattened
model = UniMolModel(input_size=input_size)

# Loss & optimizer
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Training
num_epochs = 20
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, targets in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs.squeeze(), targets)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()

    print(f'Epoch {epoch+1}/{num_epochs}, Loss: {running_loss / len(train_loader)}')

# Evaluation & prediction
model.eval()
predictions = []
true_values = []
names = test_df['name'].tolist()

with torch.no_grad():
    for inputs, targets in test_loader:
        outputs = model(inputs)
        predictions.extend(outputs.squeeze().tolist())
        true_values.extend(targets.tolist())

# Compute MSE
mse = np.mean((np.array(predictions) - np.array(true_values)) ** 2)
print(f'Mean Squared Error on test set: {mse}')

# Save model
torch.save(model.state_dict(), 'unimol_model.pth')

# Save predictions to CSV
prediction_df = pd.DataFrame({
    'name': names,
    'true_gap': true_values,
    'predicted_gap': predictions
})
prediction_df.to_csv('unimol_prediction.csv', index=False)

# Save MSE to file
with open('unimol_mse.txt', 'w') as f:
    f.write(f'Mean Squared Error: {mse}\n')
'''