Deepchem-几种机器学习模型搭建

药研猿

已于 2022-05-18 12:24:30 修改

阅读量828

点赞数 2

分类专栏： Deepchem 文章标签：机器学习 tensorflow 深度学习

于 2022-05-18 12:05:24 首次发布

本文链接：https://blog.csdn.net/monkeny/article/details/124839636

版权

Deepchem 专栏收录该内容

4 篇文章 3 订阅

订阅专栏

在开始前第一步需要导入deepchem模块。以下都默认dataset已经准备好，并成功拆分成了train_dataset、 valid_dataset、 test_dataset。

import deepchem as dc

数值连续型机器学习模型

1.随机森林

from sklearn.ensemble import RandomForestRegressor

#将随机森林训练模型简写为rf
rf = RandomForestRegressor()  
#deepchem只是提供了深度学习模块的接口，底层执行深度学习的还是对应的深度学习模块
model = dc.models.SklearnModel(model=rf) 
#模型读入训练数据进行训练
model.fit(train_dataset)

#初始化评分器
metric = dc.metrics.Metric(dc.metrics.mae_score)
#评分器打分
train_score = model.evaluate(train_dataset, [metric])
valid_score = model.evaluate(valid_dataset, [metric])
test_score = model.evaluate(test_dataset, [metric])
#输入valid_dataset或test_dataset预测属性值，可以用来与真实数据对比
valid_preds = model.predict(valid_dataset)  
test_preds = model.predict(test_dataset)

2.卷积神经网络

#初始化卷积神经网络模型，n_tasks等于分子属性个数；
#因为是连续型模型，所以mode等于regression； dropout为下降率
model = dc.models.GraphConvModel(n_tasks=1, mode='regression', dropout=0.2)

#开始训练
#nb_epoch表示训练共进行多少轮
model.fit(train_dataset, nb_epoch=100)

#评估训练模型
metric = dc.metrics.Metric(dc.metrics.pearson_r2_score)
train_score = model.evaluate(train_dataset, [metric])
valid_score = model.evaluate(valid_dataset, [metric])
test_score = model.evaluate(test_dataset, [metric])

3.基于pytorch/tensorflow的模型构建

3.1 KerasModel（TensorFlow）

#导入tensorflow模块
import tensorflow as tf

#搭建一个三层神经网络，输入层1000个节点，relu激活函数，梯度下降速率设为0.5，输出层为1
#（设置神经网络参数）
keras_model = tf.keras.Sequential([
    tf.keras.layers.Dense(1000, activation='relu'),  
    tf.keras.layers.Dropout(rate=0.5),
    tf.keras.layers.Dense(1)
])
#搭建模型
#损失函数为dc.models.losses.L2Loss()
model = dc.models.KerasModel(keras_model, dc.models.losses.L2Loss()) 

#开始训练，训练50轮
model.fit(train_dataset, nb_epoch=50)
#定义打分函数
metric = dc.metrics.Metric(dc.metrics.pearson_r2_score) 
#评分
train_score = model.evaluate(train_dataset, [metric])
valid_score = model.evaluate(valid_dataset, [metric])
test_score = model.evaluate(test_dataset, [metric])

3.2 PytorchModel

#导入pytorch模块
import torch

#搭建一个三层神经网络，输入层1024个节点，一个隐藏层（1000个节点），relu激活函数，梯度下降速率设为0.5，输出层为1
#（设置神经网络参数）
pytorch_model = torch.nn.Sequential(
    torch.nn.Linear(1024, 1000),
    torch.nn.ReLU(),
    torch.nn.Dropout(0.5),
    torch.nn.Linear(1000, 1)
)
#搭建模型
#损失函数为dc.models.losses.L2Loss()
model = dc.models.TorchModel(pytorch_model, dc.models.losses.L2Loss())

#开始训练
model.fit(train_dataset, nb_epoch=50)  

#打分函数同上，此处略
#打分同上，此处略

分类型机器学习模型

和连续型数据相比，分类变量的机器学习相对特殊点。因为连续型变量属性值在数值上是连续的，数据分布不均的问题没有像分类学习那样尖锐。对于分类变量的学习而言，如果某一种类型数据占大多数，这样的数据在训练起来会出非常大的问题的。为了避免出现可能的错误，需要在数据划分时将splitter类型选择第二种（详情见上期内容）。

1.卷积神经网络（分类型）

#查看有几种property
n_tasks = train_dataset.y.shape[1] 
#搭建分类型卷积神经网络
#注意这里mode等于classification
model = dc.models.GraphConvModel(n_tasks, mode='classification') 
#模型读入训练数据进行学习
#训练总轮数为50
model.fit(train_dataset, nb_epoch=50) 

#初始化打分函数（ROC-AUC评分函数）
metric = dc.metrics.Metric(dc.metrics.roc_auc_score) 
#打分
train_score = model.evaluate(train_dataset, [metric])
valid_score = model.evaluate(valid_dataset, [metric])
test_score = model.evaluate(test_dataset, [metric])

2.TensorFlow(分类型)

首先需要定义一个使用分类模型函数，名为ClassificationModel.

#定义函数（包含了模型参数信息）
class ClassificationModel(tf.keras.Model):
    
    def __init__(self):
        super(ClassificationModel, self).__init__()
        self.dense1 = tf.keras.layers.Dense(1000, activation='relu')
        self.dense2 = tf.keras.layers.Dense(1)

    def call(self, inputs, training=False):
        y = self.dense1(inputs)
        if training:
            y = tf.nn.dropout(y, 0.5)
        logits = self.dense2(y)
        output = tf.nn.sigmoid(logits)
        return output, logits
        
        
#搭建训练模型
keras_model = ClassificationModel()
output_types = ['prediction', 'loss']
model = dc.models.KerasModel(keras_model, dc.models.losses.SigmoidCrossEntropy(), output_types=output_types)
#开始训练，训练100轮
model.fit(train_dataset, nb_epoch=100) 
#定义打分函数
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
#打分
valid_score = model.evaluate(valid_dataset, [metric])
test_score = model.evaluate(test_dataset, [metric])

3.multitaskmodel（多种task一同训练）

这里需要用到deepchem的一份内置数据。

本例用到的内置数据有17个task，对应针对17种靶点的活性，每一个靶点的活性数据中阴性数据占据绝大多数，阳性数据超过30个的task都寥寥可数，因此采用17个task一同训练的方法可以提升训练的准确度。

#由于是内置数据，所以数据拆分的方式相较于我们自己的数据方便些。
#这里splitter等于的stratified是上一期‘RandomStratifiedSplitter’简写
tasks, datasets, transformers = dc.molnet.load_muv(splitter='stratified')
train_dataset, valid_dataset, test_dataset = datasets

#搭建模型
n_tasks = train_dataset.y.shape[1]
n_features = train_dataset.get_data_shape()[0]
model = dc.models.MultitaskClassifier(n_tasks, n_features)
#模型训练
model.fit(train_dataset，nb_epoch=50)

#拿test_data测试一下
y_true = test_dataset.y   #真实值
y_pred = model.predict(test_dataset) #预测值
metric = dc.metrics.roc_auc_score   #初始化打分矩阵
#输出每个task训练的打分值（满分为1）
for i in range(n_tasks):
    score = metric(dc.metrics.to_one_hot(y_true[:,i]), y_pred[:,i])
    print(“task{}”.format(i+1), score)

#输出结果如下：
task1 0.5099408919935517
task2 0.9802256851155293
task3 0.8774135769299659
task4 0.55403904710729
task5 0.10750492566720403
task6 0.5266702489700877
task7 0.5673293927995702
task8 0.9183234819989254
task9 0.7539315780046569
task10 0.5303062869425039
task11 0.9560093139888948
task12 0.5767866738312735
task13 0.8260433458713953
task14 0.891957728819631
task15 0.9871037076840408
task16 0.5676249328318108
task17 0.6806361487212551

模型最优参数获取

1.获取最优参数

#定义一个机器学习参数密码本，每一个参数可以给出几种不同的数值，这些数值放在一个列表中，用逗号隔开
#所谓的寻找最优参数就是将不同参数的取值排列组合，从中选出最优的一种组合
params_dict = {
    'n_tasks': [train_dataset.y.shape[1]],
    'n_features': [1024],
    'layer_sizes': [[500], [1000], [1000, 1000]],  #这些用来测试的，500的单层网络，1000的单层网络，1000+1000的双层网络
    'dropouts': [0.2, 0.5],              #这些用来测试的，0.2的下降率，0.5的下降率       
    'learning_rate': [0.001, 0.0001]          #这些用来测试的，0.001的学习率，0.0001的学习率
}
#参数优化器，这里以MultitaskClassifier模型为例
optimizer = dc.hyper.GridHyperparamOpt(dc.models.MultitaskClassifier)
#打分函数
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
best_model, best_hyperparams, all_results = optimizer.hyperparam_search(params_dict, train_dataset, valid_dataset, metric)

#输出最优参数组合
print(best_hyperparams)

#输出结果如下：
{'dropouts': 0.2,
 'layer_sizes': [1000],
 'learning_rate': 0.001,
 'n_features': 1024,
 'n_tasks': 1}

2.使用指数递减的学习率训练

#定义指数递减的学习率（开始学习率0.001，每隔1000步乘0.9）
learning_rate = dc.models.optimizers.ExponentialDecay(0.001, 0.9, 1000)  

#搭建模型（使用上一步获得的最优参数，唯独学习率使用刚定义的）
model = dc.models.MultitaskClassifier(n_tasks=1,
                    n_features=1024,
                    layer_sizes=[1000],
                    dropouts=0.2,
                    learning_rate=learning_rate)
 
#每隔1000步计算一次valid分数
#该参数监测学习程度，避免‘过拟合’现象发生
callback = dc.models.ValidationCallback(valid_dataset, 1000, metric,)  

#开始学习，学习50轮
model.fit(train_dataset, nb_epoch=50, callbacks=callback)

写在最后

分类型数据往往存在数值分布不均匀现象。在准备dataset时，最好用transformer函数平衡一下数据。

transformer = dc.trans.BalancingTransformer(dataset=dataset)
balanced_dataset = transformer.transform(dataset)

关注微信公众号“grosetta”获得更多实用干货：

药研猿

关注

2
点赞
踩
9

收藏

觉得还不错? 一键收藏
打赏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录