神经网络的知识蒸馏

最新推荐文章于 2022-12-27 18:41:44 发布
最新推荐文章于 2022-12-27 18:41:44 发布
阅读量1.7k 收藏 11
点赞数 2
文章标签： 人工智能 深度学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45331246/article/details/127094398
版权

Distilling the Knowledge in a Neural Network​​​​​​​

目录​​​​​​​

总结

一、Introduction

二、Distillation

三、Demo

1. Teacher

2. Student

3. KD

4. 完整代码

参考（具体细节见原文）​​​​​​​

总结

        Knowledge Distillation，简称KD，顾名思义，就是将已经训练好的模型包含的知识(Knowledge)，蒸馏(Distill)提取到另一个模型里面去。简单来说，有一个Teacher网络（已经训练好的，可能参数量非常大但性能非常好，如预训练模型），还有一个Student网络（还没训练好，参数量较小，性能不佳）。此时，可以通过用Teacher网络去指导Student网络训练。和现实生活一样，有一个资深的老师，已经学了很多知识，对知识了解很透彻。但是想要达到老师的境界需要很多年的学习，但是对于学生来说，可以通过让老师指导自己的方式进行学习，这样学习的时间会大大减少。并且可能还有些学霸，学的比老师还好。

一、Introduction

        许多昆虫的幼年形态是最适合从环境中汲取能量和营养的，而成虫形态则完全不同，更适合旅行和繁殖等不同需求。昆虫的类比表明我们可以训练非常复杂的模型，其易于从数据中提取出结构。这个复杂的模型可以是独自训练模型的集成，也可以是一个用强大正则器如dropout训练的单个大模型。一旦复杂模型训练完毕，之后我们可以使用一种不同的训练方式，称之为“蒸馏”，将知识从复杂的模型（称之为Teacher模型）转移到更易于部署的小模型（称之为Student模型）中。

        因此，模型压缩（在保证性能的前提下减少模型的参数量）成为了一个重要的问题。而”模型蒸馏“属于模型压缩的一种方法。一个模型的参数量基本决定了其所能捕获到的数据内蕴含的“知识”的量。这样的想法是基本正确的，但是需要注意的是:

  1. 模型的参数量和其所能捕获的“知识“量之间并非稳定的线性关系(下图中的1)，而是接近边际收益逐渐减少的一种增长曲线(下图中的2和3)
  2. 完全相同的模型架构和模型参数量，使用完全相同的训练数据，能捕获的“知识”量并不一定完全相同，另一个关键因素是训练的方法。合适的训练方法可以使得在模型参数总量比较小时，尽可能地获取到更多的“知识”(下图中的3与2曲线的对比).

二、Distillation

      ​​知识蒸馏使用的是Teacher—Student模型，其中teacher是“知识”的输出者，student是“知识”的接受者。知识蒸馏的过程分为2个阶段：

  1. 原始模型训练：训练"Teacher模型", 简称为Net-T，它的特点是模型相对复杂，也可以由多个分别训练的模型集成而成。我们对"Teacher模型"不作任何关于模型架构、参数量、是否集成方面的限制，唯一的要求就是，对于输入X, 其都能输出Y，其中Y经过softmax的映射，输出值对应相应类别的概率值。
  2. 精简模型训练：训练"Student模型", 简称为Net-S，它是参数量较小、模型结构相对简单的单模型。同样的，对于输入X，其都能输出Y，Y经过softmax映射后同样能输出对应相应类别的概率值。

查看源图像

         知识蒸馏时，由于我们已经有了一个泛化能力较强的Net-T，我们在利用Net-T来蒸馏训练Net-S时，可以直接让Net-S去学习Net-T的泛化能力。一个很直白且高效的迁移泛化能力的方法就是：使用softmax层输出的类别的概率来作为“soft target”。

        要是直接使用softmax层的输出值作为soft target, 这又会带来一个问题: 当softmax输出的概率分布熵相对较小时，负标签的值都很接近0，对损失函数的贡献非常小，小到可以忽略不计。因此"温度"这个变量就派上了用场。下面的公式时加了温度这个变量之后的softmax函数：

q_i=\frac{\exp \left(z_i / T\right)}{\sum_j \exp \left(z_j / T\right)}

        这里的T就是温度。原来的softmax函数是T = 1的特例。 T越高，softmax的output probability distribution越趋于平滑，其分布的熵越大，负标签携带的信息会被相对地放大，模型训练将更加关注负标签。

三、Demo

1. Teacher

        教师模型三层网络，中间层1200个神经元

class TeacherModel(nn.Module):
    def __init__(self, in_channels=1, num_classes=10):
        super(TeacherModel, self).__init__()
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(784, 1200)
        self.fc2 = nn.Linear(1200, 1200)
        self.fc3 = nn.Linear(1200, num_classes)
        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc2(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc3(x)

        return x

2. Student

class StudentModel(nn.Module):
    def __init__(self, in_channels=1, num_classes=10):
        super(TeacherModel, self).__init__()
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(784, 20)
        self.fc2 = nn.Linear(20, 20)
        self.fc3 = nn.Linear(20, num_classes)
        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc2(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc3(x)

        return x

3. KD

def kd(teachermodel, device, train_loader, test_loader):
    print('--------------kdmodel start--------------')

    teachermodel.eval()

    studentmodel = StudentModel()
    studentmodel = studentmodel.to(device)
    studentmodel.train()

    temp = 7    #蒸馏温度
    alpha = 0.3

    hard_loss = nn.CrossEntropyLoss()
    soft_loss = nn.KLDivLoss(reduction='batchmean')

    optimizer = torch.optim.Adam(studentmodel.parameters(), lr=1e-4)

    epochs = 20
    for epoch in range(epochs):
        for data, target in tqdm(train_loader):
            data = data.to(device)
            target = target.to(device)

            with torch.no_grad():
                teacher_preds = teachermodel(data)

            student_preds = studentmodel(data)
            student_loss = hard_loss(student_preds, target) #hard_loss

            distillation_loss = soft_loss(
                F.log_softmax(student_preds / temp, dim=1),
                F.softmax(teacher_preds / temp, dim=1)
            )   #soft_loss

            loss = alpha * student_loss + (1 - alpha) * distillation_loss
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        studentmodel.eval()
        num_correct = 0
        num_samples = 0

        with torch.no_grad():
            for x, y in test_loader:
                x = x.to(device)
                y = y.to(device)
                preds = studentmodel(x)
                predictions = preds.max(1).indices
                num_correct += (predictions.eq(y)).sum().item()
                num_samples += predictions.size(0)
            acc = num_correct / num_samples

        studentmodel.train()
        print('Epoch:{}\t Acc:{:.4f}'.format(epoch + 1, acc))
    print('--------------kdmodel end--------------')

4. 完整代码

import torch
from torch import nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from tqdm import tqdm
import torchvision
from torchvision import transforms

class TeacherModel(nn.Module):
    def __init__(self, in_channels=1, num_classes=10):
        super(TeacherModel, self).__init__()
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(784, 1200)
        self.fc2 = nn.Linear(1200, 1200)
        self.fc3 = nn.Linear(1200, num_classes)
        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc2(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc3(x)

        return x

class StudentModel(nn.Module):
    def __init__(self, in_channels=1, num_classes=10):
        super(StudentModel, self).__init__()
        self.relu = nn.ReLU()
        self.fc1 = nn.Linear(784, 20)
        self.fc2 = nn.Linear(20, 20)
        self.fc3 = nn.Linear(20, num_classes)
        self.dropout = nn.Dropout(p=0.5)

    def forward(self, x):
        x = x.view(-1, 784)
        x = self.fc1(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc2(x)
        x = self.dropout(x)
        x = self.relu(x)

        x = self.fc3(x)

        return x

def teacher(device, train_loader, test_loader):
    print('--------------teachermodel start--------------')
    model = TeacherModel()
    model = model.to(device)
    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

    epochs = 6
    for epoch in range(epochs):
        model.train()

        for data, target in tqdm(train_loader):
            data = data.to(device)
            target = target.to(device)
            preds = model(data)
            loss = criterion(preds, target)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        model.eval()
        num_correct = 0
        num_samples = 0

        with torch.no_grad():
            for x, y in test_loader:
                x = x.to(device)
                y = y.to(device)
                preds = model(x)
                predictions = preds.max(1).indices
                num_correct += (predictions.eq(y)).sum().item()
                num_samples += predictions.size(0)
            acc = num_correct / num_samples

        model.train()
        print('Epoch:{}\t Acc:{:.4f}'.format(epoch + 1, acc))
    torch.save(model, 'teacher.pkl')
    print('--------------teachermodel end--------------')

def student(device, train_loader, test_loader):
    print('--------------studentmodel start--------------')

    model = StudentModel()
    model = model.to(device)

    criterion = nn.CrossEntropyLoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)

    epochs = 3
    for epoch in range(epochs):
        model.train()

        for data, target in tqdm(train_loader):
            data = data.to(device)
            target = target.to(device)
            preds = model(data)
            loss = criterion(preds, target)

            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        model.eval()
        num_correct = 0
        num_samples = 0

        with torch.no_grad():
            for x, y in test_loader:
                x = x.to(device)
                y = y.to(device)
                # print(y)
                preds = model(x)
                #             print(preds)
                predictions = preds.max(1).indices
                # print(predictions)
                num_correct += (predictions.eq(y)).sum().item()
                num_samples += predictions.size(0)
            acc = num_correct / num_samples

        model.train()
        print('Epoch:{}\t Acc:{:.4f}'.format(epoch + 1, acc))
    print('--------------studentmodel prediction end--------------')

def kd(teachermodel, device, train_loader, test_loader):
    print('--------------kdmodel start--------------')

    teachermodel.eval()

    studentmodel = StudentModel()
    studentmodel = studentmodel.to(device)
    studentmodel.train()

    temp = 7    #蒸馏温度
    alpha = 0.3

    hard_loss = nn.CrossEntropyLoss()
    soft_loss = nn.KLDivLoss(reduction='batchmean')

    optimizer = torch.optim.Adam(studentmodel.parameters(), lr=1e-4)

    epochs = 20
    for epoch in range(epochs):
        for data, target in tqdm(train_loader):
            data = data.to(device)
            target = target.to(device)

            with torch.no_grad():
                teacher_preds = teachermodel(data)

            student_preds = studentmodel(data)
            student_loss = hard_loss(student_preds, target) #hard_loss

            distillation_loss = soft_loss(
                F.log_softmax(student_preds / temp, dim=1),
                F.softmax(teacher_preds / temp, dim=1)
            )   #soft_loss

            loss = alpha * student_loss + (1 - alpha) * distillation_loss
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()

        studentmodel.eval()
        num_correct = 0
        num_samples = 0

        with torch.no_grad():
            for x, y in test_loader:
                x = x.to(device)
                y = y.to(device)
                preds = studentmodel(x)
                predictions = preds.max(1).indices
                num_correct += (predictions.eq(y)).sum().item()
                num_samples += predictions.size(0)
            acc = num_correct / num_samples

        studentmodel.train()
        print('Epoch:{}\t Acc:{:.4f}'.format(epoch + 1, acc))
    print('--------------kdmodel end--------------')


if __name__ == '__main__':
    torch.manual_seed(0)

    device = torch.device("cuda" if torch.cuda.is_available else "cpu")
    torch.backends.cudnn.benchmark = True
    #加载数据集
    X_train = torchvision.datasets.MNIST(
        root="dataset/",
        train=True,
        transform=transforms.ToTensor(),
        download=True
    )

    X_test = torchvision.datasets.MNIST(
        root="dataset/",
        train=False,
        transform=transforms.ToTensor(),
        download=True
    )

    train_loader = DataLoader(dataset=X_train, batch_size=32, shuffle=True)
    test_loader = DataLoader(dataset=X_test, batch_size=32, shuffle=False)

    #从头训练教师模型，并预测
    teacher(device, train_loader, test_loader)

   #从头训练学生模型，并预测
    student(device, train_loader, test_loader)

   #知识蒸馏训练学生模型
    model = torch.load('teacher.pkl')
    kd(model, device, train_loader, test_loader)

​​​​​​​

参考（具体细节见原文）

原文链接：https://doi.org/10.48550/arXiv.1503.02531https://doi.org/10.48550/arXiv.1503.02531

推荐一些博客：

前世忘语
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
蒸馏神经网络(Distill the Knowledge in a Neural Network)
zhongshaoyy的博客
12-13 3万+
本文是阅读Hinton 大神蒸馏神经网络论文的笔记，特此说明。此文读起来很抽象，但是和我的研究方向：神经网络的压缩十分相关，因此决定花气力好好理解一下。  1、Introduction   文章开篇用一个比喻来引入网络蒸馏：昆虫作为幼虫时擅于从环境中汲取能量，但是成长为成虫后确是擅于其他方面，比如迁徙和繁殖等。同理神经网络训练阶段从大量数据中获取网络模型，训练阶段可以利用大量的计算资源且不需要
知识蒸馏：从神经网络中蒸馏知识 Distilling the Knowledge in a Neural Network
Cai_deLong的博客
12-14 3696
1.原理介绍 Hinton的文章《Distilling the Knowledge in a Neural Network》首次提出了知识蒸馏的概念，通过引入教师网络用以诱导学生网络的训练，实现知识迁移。所以其本质上和迁移学习有点像，但实现方式是不一样的。用“蒸馏”这个词来形容这个过程是相当形象的。用下图来解释这个过程。 教师网络：大规模，参数量大的复杂网络模型。难以应用到设备端的模型。 学生网络：小规模，参数量小的精简网络模型。可应用到设备端的模型，俗称可落地模型。...
神经网络知识蒸馏
小闹钟的机器学习时间
11-26 1599
（我的英语翻译是真的很辣鸡哇，除了自己能看懂别人都看不懂系列） 一个非常简单的几乎可以提升所有机器学习算法的表现的方法是在同一个数据集上训练多个不同的模型，然后对他们的预测结果取均值。然而呢，使用一个集成模型做预测太过麻烦，而且在用户较多时可能需要很大的计算量，尤其在其中的子模型是较大的神经网络时。Caruana和他的小伙伴们研究表表明一个集成模型的知识是可以被压缩到单独一个更容易部署的模型，我们...
神经网络的知识蒸馏（Distilling the Knowledge in Neural Network）
qq_35778890的博客
10-10 1393
文章目录1. 背景2.理论依据1. 教师学生模型2.知识蒸馏关键点3. softmax函数3. 知识蒸馏的具体方法1.通用的知识蒸馏方法2. 关于温度T的讨论 论文链接 原博客参考：链接 1. 背景 在训练过程中，我们需要使用复杂的模型，大量的计算资源，以便从非常大、高度冗余的数据集中提取出信息。在实验中，效果最好的模型往往规模很大，甚至由多个模型集成得到。而大模型不方便部署到服务中去，常见的瓶颈如下: （1）推理速度慢 （2）对资源部署的要求高 因此，模型压缩（在保证性能的前提下减少模型的参数量）成为了一
【深度学习】神经网络中的蒸馏技术，从Softmax开始说起
fengdu78的博客
10-27 764
作者：Sayak Paul 编译：ronghuaiyang导读从各个层次给大家讲解模型的知识蒸馏的相关内容，并通过实际的代码给大家进行演示。本报告讨论了非常厉害模型优化技术 —...
知识蒸馏KnowledgeDistillation.zip
03-10
知识蒸馏（Knowledge Distillation, 简称KD）是一种模型压缩技术，广泛应用于深度学习领域，特别是针对大型复杂的神经网络模型。它旨在通过将一个训练有素的、表现优秀的“教师模型”（Teacher Model）的知识传授给...
人工智能AI源代码解析-图神经网络的知识提取与超越：一个有效的知识蒸馏框架
09-03
本主题将深入探讨如何通过知识蒸馏技术，从图神经网络中提取并超越知识，以构建一个更高效、更可解释的框架。 在AI研究中，知识蒸馏是一种方法，它允许从一个大型、复杂的模型（通常称为教师模型）中提取知识，并将...
知识蒸馏论文读书笔记
01-06
突然觉得，我应该做一点笔记，梳理一下学过的...这篇文章的标题就叫“Model Comperssion”，是2006年的文章，大家都还在用CPU训练模型，不会有什么很大的神经网络是需要大家去压缩。这里的需要被压缩的“Model”是一个
基于知识蒸馏的轻量型神经网络设计.pdf
09-25
"基于知识蒸馏的轻量型神经网络设计" 本文提出了一种基于知识蒸馏的轻量型神经网络设计方法，以解决深度神经网络深度不断加深带来的结构冗余问题。该方法使用了分组卷积和点式卷积相结合的残差结构，并结合基于风格...
Python-MobileID通过将知识从神经元中蒸馏出来的面部模型压缩
08-11
MobileID：通过将知识从神经元中蒸馏出来的面部模型压缩
Python-使用Tensorflow实现的知识蒸馏方法
08-11
使用Tensorflow实现的知识蒸馏方法
神经网络中的蒸馏技术，从Softmax开始说起
zenRRan的博客
09-22 957
作者：Sayak Paul编译：ronghuaiyang来自：AI公园导读从各个层次给大家讲解模型的知识蒸馏的相关内容，并通过实际的代码给大家进行演示。公众号后台回复“模型蒸馏”，下载已...
神经网络压缩加速之知识蒸馏综述
最新发布
LionelZhao的博客
12-27 1170
近年来，深度神经网络在工业界和学术界都获得了成功，特别是在计算机视觉任务方面。深度学习的巨大成功主要是由于它的可扩展性，可以对大规模数据进行编码并操纵数十亿的模型参数。然而，在资源有限的设备（如手机和嵌入式设备）上部署这些繁琐的深度模型是一个挑战，这不仅是因为计算复杂度高，而且还需要大量存储。为此，各种模型压缩和加速技术已经被开发出来。作为模型压缩和加速的一个代表类型，知识提炼法可以有效地从一个大的教师模型中学习一个小的学生模型。它已经得到了社会各界快速增长的关注。
神经网络模型压缩和加速之知识蒸馏
weixin_30457065的博客
06-24 280
深度神经网络模型压缩和加速方法 综合现有的深度模型压缩方法，它们主要分为四类： 1、参数修剪和共享（parameter pruning and sharing） 2、低秩因子分解（low-rank factorization） 3、转移/紧凑卷积滤波器（transferred/compact convolutional filters） 4、知识蒸馏（knowledge distilla...
蒸馏神经网络到底在蒸馏什么？（设计思想篇）
热门推荐
paper_reader的博客
07-17 1万+
阅读更多，欢迎关注公众号：论文收割机（paper_reader） Hinton, Geoffrey, Oriol Vinyals, and Jeff Dean."Distilling the knowledge in a neural network." arXiv preprint arXiv:1503.02531 (2015) 1 引言 蒸馏神经网络[1]，是14年Hinton提出来...
【NLP入门】通俗讲解Subword Models
zenRRan的博客
08-28 1079
Datawhale干货作者：芙蕖，Datawhale优秀学习者，东北石油大学对于英文来说，文字的粒度从细到粗依次是character, subword, word，character...
知识蒸馏（Distillation）相关论文阅读（3）—— FitNets : Hints for Thin Deep Nets
Lucifer_zzq的博客
03-28 6117
知识蒸馏相关论文目录导读：Geoffry Hinton —— Distilling the knowledge in a neural networkSaurabh Gupta —— Cross Model Distillation for Supervision TransferAdriana Romero —— Hints for Thin Deep Nets—————————————————...
蒸馏网络 Distilling the Knowledge in a Neural Network
cdknight_happy的专栏
04-20 1495
论文：https://arxiv.org/abs/1503.02531

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

前世忘语

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值