基于Pytorch的卷积神经网络CNN实例应用及详解2.0

简介: 基于Pytorch的卷积神经网络CNN实例应用及详解2.0

基于Pytorch的卷积神经网络CNN实例应用依旧是DTI也就是药物靶体交互预测数据训练预测模型框架没有变化只有数据集的读取&处理和重新构造及损失函数选择发生变化,其余部分发生细微变化。

一、前期基础(建议先阅读下面链接1.0版本的前期基础文章)

前期基础文章:点击打开《基于Pytorch的卷积神经网络CNN实例应用及详解》文章

二、卷积神经网络CNN实现案例分析

  • 案例目的:是构造卷积神经网络模型训练后进行药物靶体交互的二分类(0和1)预测
  • 数据集及格式说明:首先案例用到的所有数据集是来自DAVIS 数据集,数据以csv数据格式存储
  • 训练集train说明:训练数据集里面有2085条(行)数据,每列依次是数据序列编号、药物分子SMILES序列、蛋白质靶体目标Target Squences序列和亲和性标志Lable(1表示亲和,0表示无亲和),至于后面的药物分子和蛋白质靶体编码,博主因为自己代码中可以重新编码,所以对原始数据集的编码选择不用即可忽略
  • 测试集tets说明:测试数据集里面有6010条(行)数据,每列依次是数据序列编号、药物分子SMILES序列、蛋白质靶体目标Target Squences序列和亲和性标志Lable(1表示亲和,0表示无亲和),至于后面的药物分子和蛋白质靶体编码,博主因为自己代码中可以重新编码,所以对原始数据集的编码选择不用即可忽略
  • 读取csv文件的数据并处理(以训练集为例):采用pandas库(若没有安装pandas库可以点击打开《python怎么安装pandas详细步骤》文章进行安装)中的read_csv方法读取csv文件的数据,得到DataFrame格式的数据,同时我们要从中取出各行或者各列(点击打开《Pandas中的loc与iloc用法详解》文章进行了解),博主根据需求使用DataFrame的 loc 方法取各列数据。取出后为方便后续数据的使用,需要对数据进行格式和维度的处理,格式上将DataFrame格式转换成numpy格式再转换成list格式(点击打开《Pytorch实践中的list、numpy、torch.tensor之间数据格式的相互转换方法》文章进行了解),维度上对原数据的第一维度也就是药物分子序号调用numpy的squeeze方法进行压缩(numpy的squeeze方法和tensor一样,点击打开《python以三维tensor为例详细理解unsqueeze和squeeze函数》文章进行了解)。
import pandas as pd
data = pd.read_csv('E:/googlefile/train.csv')
print(data)

import pandas as pd
data = pd.read_csv('E:/googlefile/train.csv')
data.loc[2:5, ['SMILES']]

import pandas as pd
import numpy as np
data = pd.read_csv('E:/googlefile/train.csv')
smiles = data.loc[2:5, ['SMILES']]
smiles = np.array(smiles)
train_drug_smiles = np.squeeze(smiles).tolist()
print(train_drug_smiles)

  • 重新构造个人数据集:一般搭建好的网络模型的输入数据集都是通过DataLoader方法进行批量操作送入(之前博主总结过PYG的个人数据集构造,有兴趣可以点击打开《基于Pytorch的PyTorch Geometric(PYG)库构造个人数据集》文章进行了解),所以我们必须重新构造自己的数据集,方法是使用Pytorch直接提供的Dataset类创建和加载自己的数据集,创建一个MyDataset类的实例对象需要提供的虚参是自己数据集的路径,然后需要重写类中的三个函数__init__、__ len__和__getitem__,init函数是通过获取数据集路径,然后读取数据集,对数据集进行预处理,数据格式上全部要转换到tensor数据格式,这样的数据集才可以使用Dataloader加载批量数据将数据集转换成Tensor类型,len函数是返回个人数据集的长度,最后是getitem函数是将MyDataset类的实例对象输入到Dataloader方法,然后再生成的对象在之后的迭代中返回对应的索引数据,最后将索引数据传入网络模型。
class MyDataset(nn.Module):
    def __init__(self, root):
        super(MyDataset, self).__init__()
        # 数据集文件路径
        self.root = root
        # 读取csv文件生成DataFrame数据格式
        self.data = pd.read_csv(root)
        # 读取药物分子smiles序列
        self.train_drug_smiles = []
        # 获取DataFrame数据的SMILES列
        self.smiles = self.data.loc[:, ['SMILES']]
        # 将DataFrame数据转换为numpy数据
        self.smiles = np.array(self.smiles)
        # numpy数据压缩维度并转换为list数据
        self.train_drug_smiles = np.squeeze(self.smiles).tolist()
        # 读取蛋白质分子sequences序列
        self.train_protein_sequences = []
        # 获取DataFrame数据的Target Sequence列
        self.sequences = self.data.loc[:, ['Target Sequence']]
        # 将DataFrame数据转换为numpy数据
        self.sequences = np.array(self.sequences)
        # numpy数据压缩维度并转换为list数据
        self.train_protein_sequences = np.squeeze(self.sequences).tolist()
        # 读取药物分子和蛋白质分子对应的亲和性
        # 获取DataFrame数据的Label列
        self.binds = self.data.loc[:, ['Label']]
        # 将DataFrame数据转换为numpy数据并转换为list数据
        self.binds = np.array(self.binds).tolist()
        # 将list格式转换为tensor格式
        self.binds = t.LongTensor(self.binds)
        # tensor数据压缩维度
        self.binds = t.squeeze(self.binds, 1)
        # 对药物进行label encoding
        CHARISOSMISET = {"#": 29, "%": 30, ")": 31, "(": 1, "+": 32, "-": 33, "/": 34, ".": 2,
                         "1": 35, "0": 3, "3": 36, "2": 4, "5": 37, "4": 5, "7": 38, "6": 6,
                         "9": 39, "8": 7, "=": 40, "A": 41, "@": 8, "C": 42, "B": 9, "E": 43,
                         "D": 10, "G": 44, "F": 11, "I": 45, "H": 12, "K": 46, "M": 47, "L": 13,
                         "O": 48, "N": 14, "P": 15, "S": 49, "R": 16, "U": 50, "T": 17, "W": 51,
                         "V": 18, "Y": 52, "[": 53, "Z": 19, "]": 54, "\\": 20, "a": 55, "c": 56,
                         "b": 21, "e": 57, "d": 22, "g": 58, "f": 23, "i": 59, "h": 24, "m": 60,
                         "l": 25, "o": 61, "n": 26, "s": 62, "r": 27, "u": 63, "t": 28, "y": 64}
        CHARISOSMILEN = 64
        self.drug_label_encoding = []
        def label_smiles(smiles):
            D = np.zeros(100)
            for i, ch in enumerate(smiles):
                if i < 100:
                    D[i] = CHARISOSMISET[ch]
            return D.tolist()
        for l in range(len(self.train_drug_smiles)):
            self.label_smile = label_smiles(self.train_drug_smiles[l])
            self.drug_label_encoding.append(self.label_smile)
        # 对蛋白质进行label encoding
        CHARPROTSET = {"A": 1, "C": 2, "B": 3, "E": 4, "D": 5, "G": 6,
                       "F": 7, "I": 8, "H": 9, "K": 10, "M": 11, "L": 12,
                       "O": 13, "N": 14, "Q": 15, "P": 16, "S": 17, "R": 18,
                       "U": 19, "T": 20, "W": 21,
                       "V": 22, "Y": 23, "X": 24,
                       "Z": 25}
        CHARPROTLEN = 25
        self.protein_label_encoding = []
        def label_sequece(sequence):
            P = np.zeros(1000)
            for i, ch in enumerate(sequence):
                if i < 1000:
                    P[i] = CHARPROTSET[ch]
            return P.tolist()
        for l in range(len(self.train_protein_sequences)):
            self.label_protein = label_sequece(self.train_protein_sequences[l])
            self.protein_label_encoding.append(self.label_protein)
        # 为避免词向量每次嵌入都数值不同设定随机数种子
        t.manual_seed(100)
        # 对药物进行embedding
        self.drug_label_encodings = t.LongTensor(self.drug_label_encoding)  # 将list转为tensor数据格式
        # print(drug_label_encodings)
        drug_embedding = nn.Embedding(100, 128, padding_idx=0)  # 创建药物embedding层
        self.drug_embeddings = drug_embedding(self.drug_label_encodings)  # 嵌入层转换生成128维的词向量,数据维度是[256,100,128]
        # 对蛋白质进行embedding
        self.protein_label_encodings = t.LongTensor(self.protein_label_encoding)  # 将list转为tensor数据格式
        protein_embedding = nn.Embedding(1000, 128, padding_idx=0)  # 创建蛋白质embedding层
        self.protein_embeddings = protein_embedding(self.protein_label_encodings)  # 嵌入层转换生成128维的词向量,数据维度是[256,1000,128]
    def __len__(self):
        return len(self.binds)
    def __getitem__(self, item):
        # print(item)
        return self.drug_embeddings[item], self.protein_embeddings[item], self.binds[item]
  • 损失函数:损失函数选择CrossEntropyLoss函数(公式二分类见下图),此函数就是把log_sofrmax和NLLLoss合并成一步。使用log_sofrmax函数,得到每张图片每个类别的概率分布,根据每张图片的label将对应图片的索引的值拿出来,所有图片累加值再对结果取负值,比如:有一张图片是二分类,log_softmax函数使用后得到的概率是[0.4,0.6],该图片的label的值是0,那么根据label对应图片的索引的值下标为0的概率是0.4,则取出的结果是0.4,再取负数就是-0.4。最优化损失函数值,那么应该取最小值,概率越大取负值越小。

三、卷积神经网络CNN实现2.0完整代码和结果

import torch as t
import numpy as np
from torch import nn
import pandas as pd
from  sklearn.metrics import accuracy_score
class MyDataset(nn.Module):
    def __init__(self, root):
        super(MyDataset, self).__init__()
        # 数据集文件路径
        self.root = root
        # 读取csv文件生成DataFrame数据格式
        self.data = pd.read_csv(root)
        # 读取药物分子smiles序列
        self.train_drug_smiles = []
        # 获取DataFrame数据的SMILES列
        self.smiles = self.data.loc[:, ['SMILES']]
        # 将DataFrame数据转换为numpy数据
        self.smiles = np.array(self.smiles)
        # numpy数据压缩维度并转换为list数据
        self.train_drug_smiles = np.squeeze(self.smiles).tolist()
        # 读取蛋白质分子sequences序列
        self.train_protein_sequences = []
        # 获取DataFrame数据的Target Sequence列
        self.sequences = self.data.loc[:, ['Target Sequence']]
        # 将DataFrame数据转换为numpy数据
        self.sequences = np.array(self.sequences)
        # numpy数据压缩维度并转换为list数据
        self.train_protein_sequences = np.squeeze(self.sequences).tolist()
        # 读取药物分子和蛋白质分子对应的亲和性
        # 获取DataFrame数据的Label列
        self.binds = self.data.loc[:, ['Label']]
        # 将DataFrame数据转换为numpy数据并转换为list数据
        self.binds = np.array(self.binds).tolist()
        # 将list格式转换为tensor格式
        self.binds = t.LongTensor(self.binds)
        # tensor数据压缩维度
        self.binds = t.squeeze(self.binds, 1)
        # 对药物进行label encoding
        CHARISOSMISET = {"#": 29, "%": 30, ")": 31, "(": 1, "+": 32, "-": 33, "/": 34, ".": 2,
                         "1": 35, "0": 3, "3": 36, "2": 4, "5": 37, "4": 5, "7": 38, "6": 6,
                         "9": 39, "8": 7, "=": 40, "A": 41, "@": 8, "C": 42, "B": 9, "E": 43,
                         "D": 10, "G": 44, "F": 11, "I": 45, "H": 12, "K": 46, "M": 47, "L": 13,
                         "O": 48, "N": 14, "P": 15, "S": 49, "R": 16, "U": 50, "T": 17, "W": 51,
                         "V": 18, "Y": 52, "[": 53, "Z": 19, "]": 54, "\\": 20, "a": 55, "c": 56,
                         "b": 21, "e": 57, "d": 22, "g": 58, "f": 23, "i": 59, "h": 24, "m": 60,
                         "l": 25, "o": 61, "n": 26, "s": 62, "r": 27, "u": 63, "t": 28, "y": 64}
        CHARISOSMILEN = 64
        self.drug_label_encoding = []
        def label_smiles(smiles):
            D = np.zeros(100)
            for i, ch in enumerate(smiles):
                if i < 100:
                    D[i] = CHARISOSMISET[ch]
            return D.tolist()
        for l in range(len(self.train_drug_smiles)):
            self.label_smile = label_smiles(self.train_drug_smiles[l])
            self.drug_label_encoding.append(self.label_smile)
        # 对蛋白质进行label encoding
        CHARPROTSET = {"A": 1, "C": 2, "B": 3, "E": 4, "D": 5, "G": 6,
                       "F": 7, "I": 8, "H": 9, "K": 10, "M": 11, "L": 12,
                       "O": 13, "N": 14, "Q": 15, "P": 16, "S": 17, "R": 18,
                       "U": 19, "T": 20, "W": 21,
                       "V": 22, "Y": 23, "X": 24,
                       "Z": 25}
        CHARPROTLEN = 25
        self.protein_label_encoding = []
        def label_sequece(sequence):
            P = np.zeros(1000)
            for i, ch in enumerate(sequence):
                if i < 1000:
                    P[i] = CHARPROTSET[ch]
            return P.tolist()
        for l in range(len(self.train_protein_sequences)):
            self.label_protein = label_sequece(self.train_protein_sequences[l])
            self.protein_label_encoding.append(self.label_protein)
        # 为避免词向量每次嵌入都数值不同设定随机数种子
        t.manual_seed(100)
        # 对药物进行embedding
        self.drug_label_encodings = t.LongTensor(self.drug_label_encoding)  # 将list转为tensor数据格式
        # print(drug_label_encodings)
        drug_embedding = nn.Embedding(100, 128, padding_idx=0)  # 创建药物embedding层
        self.drug_embeddings = drug_embedding(self.drug_label_encodings)  # 嵌入层转换生成128维的词向量,数据维度是[256,100,128]
        # 对蛋白质进行embedding
        self.protein_label_encodings = t.LongTensor(self.protein_label_encoding)  # 将list转为tensor数据格式
        protein_embedding = nn.Embedding(1000, 128, padding_idx=0)  # 创建蛋白质embedding层
        self.protein_embeddings = protein_embedding(self.protein_label_encodings)  # 嵌入层转换生成128维的词向量,数据维度是[256,1000,128]
    def __len__(self):
        return len(self.binds)
    def __getitem__(self, item):
        # print(item)
        return self.drug_embeddings[item], self.protein_embeddings[item], self.binds[item]
# 构建Net模块
class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()  # 表示Net继承nn.Module
        self.cnn1 = nn.Sequential(  # 构建Sequential,属于特殊的module,类似于forward前向传播函数,同样的方式调用执行
            nn.Conv1d(128, 32, 4, bias=False),  # 卷积层,输入通道数为128,输出通道数为32,卷积核为[128,4],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.Conv1d(32, 64, 6, bias=False),  # 卷积层,输入通道数为32,输出通道数为64,卷积核为[32,6],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.Conv1d(64, 96, 8, bias=False),  # 卷积层,输入通道数为64,输出通道数为96,卷积核为[64,8],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.MaxPool1d(2, 1)
        )
        self.cnn2 = nn.Sequential(  # 构建Sequential,属于特殊的module,类似于forward前向传播函数,同样的方式调用执行
            nn.Conv1d(128, 32, 4, bias=False),  # 卷积层,输入通道数为128,输出通道数为32,卷积核为[128,4],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.Conv1d(32, 64, 8, bias=False),  # 卷积层,输入通道数为32,输出通道数为64,卷积核为[32,8],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.Conv1d(64, 96, 12, bias=False),  # 卷积层,输入通道数为64,输出通道数为96,卷积核为[64,12],包含在Sequential的子module,层层按顺序自动执行
            nn.ReLU(inplace=True),
            nn.MaxPool1d(2, 1)
        )
        self.mtp = nn.Sequential( # 构建Sequential,属于特殊的module,类似于forward前向传播函数,同样的方式调用执行
            nn.Linear(101952,1024), # 线性连接层,输入通道数为101952=1062*96,输出通道数为1024
            nn.Dropout(0.1),
            nn.Linear(1024, 512), # 线性连接层,输入通道数为1024,输出通道数为512
            nn.Dropout(0.1),
            nn.Linear(512, 2), # 线性连接层,输入通道数为512,输出通道数为2
            # nn.Softmax()
        )
    def forward(self, drug ,protein):  # Net类的前向传播函数
        # 维度转换(必要性在于一维卷积的卷积核是(输入通道数,卷积核长),权重参数是(批次,输入通道数,卷积核长))
        drug = drug.permute(0, 2, 1)
        protein = protein.permute(0, 2, 1)
        # CNN卷积操作
        drug_cnn = self.cnn1(drug)  # 和调用forward一样如此调用cnn1这个Sequential
        protein_cnn = self.cnn2(protein)  # 和调用forward一样如此调用cnn2这个Sequential
        # 卷积完成后再次维度转换为DIT拼接做准备,每批中单个药物的维度是[84,96],每批中单个蛋白质的维度是[978,96]
        drug_pool = drug_cnn.permute(0, 2, 1)
        protein_pool = protein_cnn.permute(0, 2, 1)
        # print(drug_pool.shape)
        # print(protein_pool.shape)
        # 将训练集和测试集每组对应下标的药物和蛋白质按列进行拼接,每批中单个药物蛋白质结合的维度变成[84+978,96]=[1062,96]
        drug_target = t.cat((drug_pool, protein_pool), 1)
        # 为全连接数据输入调整tensor的形状,由三维变成二维数据,分别表示[批次大小,每批次数据长度]
        drug_target = drug_target.view(256,1062*96)
        # 将数据导入全连接层进行二分类任务,亲和和非亲和也就是0和1分类
        drug_target_mtp = self.mtp(drug_target)
        # 为损失函数计算做准备
        drug_target_mtp = t.FloatTensor(drug_target_mtp)
        return drug_target_mtp
# 读取训练数据集
train_data = MyDataset(root='E:/googlefile/dataset/DAVIS/train.csv')
# print(len(train_data))
# print(train_data[:512])
# 训练数据集里面有2085条数据,每个数据包含一组蛋白质序列和药物分子序列和亲和性标记
loaders = t.utils.data.DataLoader(train_data, batch_size=256, shuffle=False, drop_last=True) # 读取训练数据集数据
# 训练模型
epoch = 5 # 每轮训练次数
model = Net() # 建模
loss_model = nn.CrossEntropyLoss()
# 计算损失函数值
optimizer = t.optim.SGD(model.parameters(),lr=0.01) # 设置优化器用于更新权重参数,学习率为0.01
for i in range(epoch):
    loss_sum = 0
    for train_datas in loaders:
        # 训练集数据转换
        # print(train_datas)
        drug_embeddings, protein_embeddings, effectives = train_datas
        # print(drug_embeddings.shape)
        # print(protein_embeddings.shape)
        # print(effectives.shape)
        # 数据输入模型训练
        output = model(drug_embeddings, protein_embeddings)
        # print(output.shape)
        # print(effectives.shape)
        # 计算损失函数值
        loss = loss_model(output,effectives)
        # 每次反向传播前需要梯度清零
        optimizer.zero_grad()
        # 反向传播
        loss.backward(retain_graph=True)
        # loss_sum += loss.data.item()
        print(loss.data.item())
        # 参数权重更新
        optimizer.step()
    # print(loss_sum)
    print("第" + str(i+1) + "轮训练")
# 读取测试集
test_folds = MyDataset(root='E:/googlefile/dataset/DAVIS/test.csv')
# 测试数据集里面有6010条数据,每个数据包含一组蛋白质序列和药物分子序列和亲和性标记
loaderstest = t.utils.data.DataLoader(test_folds, batch_size=256, shuffle=False, drop_last=True) # 读取训练数据集数据
pre_output = []
real_effectives = []
for test_datas in loaderstest:
    # 测试集数据转换
    drug_embeddings, protein_embeddings, effectives = test_datas
    effectives = effectives.tolist()
    # 将每批次真实亲和值输出的数据汇总
    real_effectives = real_effectives + effectives
    # 测试集数据输入模型训练
    output = model(drug_embeddings, protein_embeddings)
    output = output.tolist()
    # 将每批次预测亲和值输出的数据汇总
    for i in range(len(output)):
        pre_output.append(output[i].index(max(output[i]))) # 根据大小选取0和1
# 输出正确率
print(pre_output) # 预测输出值
print(real_effectives) # 真实输出值
print("DTI预测正确率:")
print(accuracy_score(real_effectives, pre_output)) # 输出正确率


相关文章
|
7天前
|
机器学习/深度学习 人工智能 算法
猫狗宠物识别系统Python+TensorFlow+人工智能+深度学习+卷积网络算法
宠物识别系统使用Python和TensorFlow搭建卷积神经网络,基于37种常见猫狗数据集训练高精度模型,并保存为h5格式。通过Django框架搭建Web平台,用户上传宠物图片即可识别其名称,提供便捷的宠物识别服务。
118 55
|
17天前
|
机器学习/深度学习 人工智能 算法
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
宠物识别系统,本系统使用Python作为主要开发语言,基于TensorFlow搭建卷积神经网络算法,并收集了37种常见的猫狗宠物种类数据集【'阿比西尼亚猫(Abyssinian)', '孟加拉猫(Bengal)', '暹罗猫(Birman)', '孟买猫(Bombay)', '英国短毛猫(British Shorthair)', '埃及猫(Egyptian Mau)', '缅因猫(Maine Coon)', '波斯猫(Persian)', '布偶猫(Ragdoll)', '俄罗斯蓝猫(Russian Blue)', '暹罗猫(Siamese)', '斯芬克斯猫(Sphynx)', '美国斗牛犬
99 29
【宠物识别系统】Python+卷积神经网络算法+深度学习+人工智能+TensorFlow+图像识别
|
4天前
|
机器学习/深度学习 算法 PyTorch
基于Pytorch Gemotric在昇腾上实现GraphSage图神经网络
本文详细介绍了如何在昇腾平台上使用PyTorch实现GraphSage算法,在CiteSeer数据集上进行图神经网络的分类训练。内容涵盖GraphSage的创新点、算法原理、网络架构及实战代码分析,通过采样和聚合方法高效处理大规模图数据。实验结果显示,模型在CiteSeer数据集上的分类准确率达到66.5%。
|
20天前
|
机器学习/深度学习 资源调度 算法
图卷积网络入门:数学基础与架构设计
本文系统地阐述了图卷积网络的架构原理。通过简化数学表述并聚焦于矩阵运算的核心概念,详细解析了GCN的工作机制。
52 3
图卷积网络入门:数学基础与架构设计
|
16天前
|
机器学习/深度学习 人工智能 自然语言处理
深入理解深度学习中的卷积神经网络(CNN)##
在当今的人工智能领域,深度学习已成为推动技术革新的核心力量之一。其中,卷积神经网络(CNN)作为深度学习的一个重要分支,因其在图像和视频处理方面的卓越性能而备受关注。本文旨在深入探讨CNN的基本原理、结构及其在实际应用中的表现,为读者提供一个全面了解CNN的窗口。 ##
|
20天前
|
机器学习/深度学习 算法 数据安全/隐私保护
基于贝叶斯优化CNN-GRU网络的数据分类识别算法matlab仿真
本项目展示了使用MATLAB2022a实现的贝叶斯优化、CNN和GRU算法优化效果。优化前后对比显著,完整代码附带中文注释及操作视频。贝叶斯优化适用于黑盒函数,CNN用于时间序列特征提取,GRU改进了RNN的长序列处理能力。
|
23天前
|
机器学习/深度学习 人工智能 自然语言处理
深入理解深度学习中的卷积神经网络(CNN)
深入理解深度学习中的卷积神经网络(CNN)
|
2月前
|
算法 PyTorch 算法框架/工具
Pytorch学习笔记(九):Pytorch模型的FLOPs、模型参数量等信息输出(torchstat、thop、ptflops、torchsummary)
本文介绍了如何使用torchstat、thop、ptflops和torchsummary等工具来计算Pytorch模型的FLOPs、模型参数量等信息。
363 2
|
19天前
|
机器学习/深度学习 人工智能 PyTorch
Transformer模型变长序列优化:解析PyTorch上的FlashAttention2与xFormers
本文探讨了Transformer模型中变长输入序列的优化策略,旨在解决深度学习中常见的计算效率问题。文章首先介绍了批处理变长输入的技术挑战,特别是填充方法导致的资源浪费。随后,提出了多种优化技术,包括动态填充、PyTorch NestedTensors、FlashAttention2和XFormers的memory_efficient_attention。这些技术通过减少冗余计算、优化内存管理和改进计算模式,显著提升了模型的性能。实验结果显示,使用FlashAttention2和无填充策略的组合可以将步骤时间减少至323毫秒,相比未优化版本提升了约2.5倍。
35 3
Transformer模型变长序列优化:解析PyTorch上的FlashAttention2与xFormers
|
2月前
|
机器学习/深度学习 自然语言处理 监控
利用 PyTorch Lightning 搭建一个文本分类模型
利用 PyTorch Lightning 搭建一个文本分类模型
69 8
利用 PyTorch Lightning 搭建一个文本分类模型
下一篇
DataWorks