根据Morgan指纹预测分子logP

from rdkit import Chem, DataStructs
from rdkit.Chem.Crippen import MolLogP
from rdkit.Chem import AllChem
import numpy as np
import torch
import torch.nn as nn

file = "shulin_test.log"

with open(file,'r')as f:
    lines = f.readlines()
    smiles = [l.split()[1] for l in lines]
    
X,Y = [], []

for s in smiles:
    m = Chem.MolFromSmiles(s)
    fp = np.array(AllChem.GetMorganFingerprintAsBitVect(m,2,nBits=1024))
    logp = MolLogP(m)
    X.append(fp)
    Y.append(logp)         
    
    
X = torch.from_numpy(np.array(X)).float()
Y = torch.from_numpy(np.array(Y)).float()

X_train = X[:400]
Y_train = Y[:400]
X_test = X[200:300]
Y_test = Y[200:300]

class LinearRegressor(torch.nn.Module):
    def __init__(self, D_in,D_out):
        super(LinearRegressor,self).__init__()
        self.linear = torch.nn.Linear(D_in,D_out)
    
    def forward(self,x):
        retval = self.linear(x)
        return retval
    
import time 
lr = 1e-4
model = LinearRegressor(1024,1)
optimizer = torch.optim.Adam(model.parameters(),lr=lr)    
loss_fn = nn.MSELoss()
loss_list = []
st = time.time()

for i in range(2000):
    pred = model(X_train)
    pred = pred.squeeze(-1)
    loss = loss_fn(pred,Y_train)
    loss.backward()
    optimizer.step()
    loss_list.append(loss.data.cpu().numpy())
    if 1%100 == 0:
        print (i, loss.data.cpu().numpy())
end = time.time()
print("time:",end-st)   

import matplotlib.pyplot as plt
#%matplotlib inline
 
plt.plot(loss_list)
plt.xlabel('Num iteration')
plt.ylabel('Loss')
plt.show()

y_pred_train = model(X_train).squeeze(-1)
y_pred_test = model(X_test).squeeze(-1)
 
loss_train = loss_fn(Y_train, y_pred_train)
loss_test = loss_fn(Y_test, y_pred_test)
 
print ('Train loss:', loss_train.data.cpu().numpy())
print ('Test loss:', loss_test.data.cpu().numpy())

plt.scatter(Y_train.data.cpu().numpy(), y_pred_train.data.cpu().numpy())
plt.scatter(Y_test.data.cpu().numpy(), y_pred_test.data.cpu().numpy())
plt.plot([-8,12], [-8,12])
plt.xlabel('True')
plt.ylabel('Pred')
plt.show()