从b站看的啥都会一点的研究生上传的视频，总的来说，讲的还是比较分散，因为每一年的视频穿插起来了，会对新手有一点不友好，但是都是知识，第一遍学不求甚解，先过一遍，做做笔记，留个印象也是好的。
之前看到了30集，没怎么做笔记，从30集开始也不晚。

P32 2022 为什么用了验证机（validation dataset）结果还是过拟合了呢

看完这8分钟，觉得validation set是用来选一个训练模型的，如果模型太多，选出来那个是validation set上表现最好的，但是在test set可能也会过拟合。

P33 鱼和熊掌可以兼得的机器学习

答：深度学习
线性分段函数，用sigmoid函数不断的拟合，加大深度，从而产生任何的piecewise linear。
we want “deep" network,not “fat” network
Yes, one hidden layer can represent any function.
However, using deep structure is more effective.
用剪纸来举例子。叠的层数多，效率高，只需要剪几刀。

P34 spatial transformer

讲了在图像中位置、尺度变换不受影响的Spatial Transformer CNN (ST CNN)

P35 HW3

11种食物的分类，
初始sample 0.5
加入数据增强，4 epoch-> 20 epoch 0.68

P38 -39 2021 第四节，自注意力（self attention）

输入：从一个向量到多个数据，例如句子、图片、关系图
输出：一一对应（P38只讲这个类型）、多对一、输出不定（翻译、语音识别）
Self Attention出自：Attention is all you need（google 的Transformer）
self attention：输入向量之间找到联系，然后再投入神经网络。

self attention 和cnn的区别：
CNN: self-attention that canonly attends in a receptive field
CNN is simplified self-attention.
self-attention: CNN withlearnable receptive field
self-attention is the complexversion of CNN.

Self attention 和 Recurrent Neural Network

把self attention用在graph上就是gnn（graph neural network）

p40 41 回顾RNN

有记忆力的neural network，还有双向的RNN，LSTM 长短期记忆网络（Long short-term memory, LSTM）是一种特殊的RNN，主要是为了解决长序列训练过程中的梯度消失和梯度爆炸问题。简单来说，就是相比普通的RNN，LSTM能够在更长的序列中有更好的表现。理解处理的问题就行，因为代码在TensorFlow 、pytorch里边都实现了，直接调用。

讲了rnn 很难训练（梯度爆炸、消失）的原因：

p42 43 补充GNN Graph Neural Network

图的机构就是节点和边，处理节点周围的节点和自己的关系，通过运算，类比卷积，其中一种方法就是变换到频域进行乘机，等于时域卷积，简称GCN（graph convolution network）

p44 unsupervised learning：word embedding

独热编码 -》降为编码-》multi-ligual embedding-》multi-domain embedding

p45 HW4

因为第四次作业的github链接崩掉了，所以使用wget自行下载，下载方法是使用这个代码：

wget --load-cookies /tmp/cookies.txt "https://docs.google.com/uc?export=download&confirm=$(wget --quiet --save-cookies /tmp/cookies.txt --keep-session-cookies --no-check-certificate 'https://docs.google.com/uc?export=download&id=FILEID' -O- | sed -rn 's/.*confirm=([0-9A-Za-z_]+).*/\1\n/p')&id=FILEID" -O FILENAME && rm -rf /tmp/cookies.txt

要修改其中的fileid和filename，filename建议使用Dataset.tar.gz，
其中的fileid是下载的文件id，获得方式打开谷歌云盘的这个分享链接，

然后抽取其中的id部分：
https://drive.google.com/file/d/1bmVAabVkUcZ-zwVrvfaZ7zJhWjmanDy8/view?usp=share_link
比如这个的id就是1bmVAabVkUcZ-zwVrvfaZ7zJhWjmanDy8
然后运行就好了，文件就下载到你的colab中了，然后解压（时间五分钟吧，太大了）：

 !tar zxvf Dataset.tar.gz

训练需要70000次，
每10000次会有一个提示：

xxxxxxxxxx4]Step 60000, best model saved. (accuracy=0.6679)

最后我的准确率是：

Step 70000, best model saved. (accuracy=0.6762)

提交到kaggle上的得分是0.608
最后修改了类的部分

class Classifier(nn.Module):def __init__(self, d_model=224, n_spks=600, dropout=0.25):super().__init__()# Project the dimension of features from that of input into d_model.self.prenet = nn.Linear(40, d_model)# TODO:#   Change Transformer to Conformer.#   https://arxiv.org/abs/2005.08100self.encoder_layer = ConformerBlock(dim = d_model,dim_head=4,heads = 4,ff_mult=4,conv_expansion_factor=2,conv_kernel_size= 20,attn_dropout=dropout,ff_dropout=dropout,conv_dropout = dropout,)#self.encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=3)# Project the the dimension of features from d_model into speaker nums.self.pred_layer = nn.Sequential(nn.BatchNorm1d(d_model),nn.Linear(d_model, n_spks),)

kaggle达到0.76625评分

p46 p47是2021年的HW4

略过

p48 （BN层）神经网络训练不起来怎么办

Batch Normalization
把山铲平，Changing Landscape
方法比如：Feature Normalization
每个批次做一次Normalization，就是Batch Normalization，适用于BatchSize比较大的时候，才能更好地表达Feature的特征。
用BN层的时候，学习率要大一点，比如这个PPT中显示5倍的学习率最好，因为用了BN层之后error surface更平滑，更有助于加速训练（增大学习率来加速训练最优结果的完成时间，而不是缩短单次训练时长）

BN层为什么有作用呢?
Internal Covariate Shift
这篇文章的作者认为BN是偶然发现的比较有用的方法，还有别的一堆：

p49 50 Transformer （上）（下）

Sequence to sequence（Seq2seq）
input sequence，output sequence，the output length is determined by model
比如：speech recognition、machine translation 、
甚至还可以做很多想象不到的工作：
比如
~2014年 grammer as a foreign language
~multi-label classification （和multi class classification不一样）
~object detection

Encoder结构：输入一个vector sequence，输出一个vector sequence
Block+Self-attention（residual，layer norm）+multi-head attention+input emedding
Decoder结构：输入Encoder的输出vector sequence，输出
其中masked self attention 只有左边输入的，最后的结果是一个一个输出的，和Encoder的连接部分用的是cross attention，
Decoder输入的是正确答案，所以是有监督的Teacher Forcing

guided attention 低级错误示范：
发财发财发财发财，输出带有四种声调，
发财，只输出cai的声音
还有语音合成的例子，加入noisy后结果更好
人生格言：
Accept that nothing is perfect. True beauty lies in the cracks of imperfection ：）

scheduled sampling

p51 各种attention

self-attention 计算量太大了，使用人为的先验知识来跳过许多不必要的计算。
Local attention/Truncated attention 划出一个区域做attention，那这样就像cnn了，

Local attention\Stride attention \global attention

p52 non autoregressive sequence to sequence

autoregressive model，比如RNN和Transformer都是有顺序的输出，后一个输出要等待前一个输出之后再进行

而 non autoregressive model就可以并行输出，利用transformer 并行计算的特性，这个model是用transformer魔改的版本

遇到的问题就是并行输出的时候，输出的两个字可能没有联系
例如：
论文1：比如hello输出哈喽，你好，哈好，你喽，为了解决这个问题，vanilla nat编码输入的字的数量，hello=2，输出的哈喽或你好就是连着的，或者hello=1，输出嗨。
论文2,3，4等等都是解决方法

p53 pointer network

有很多专业名词不需要翻译，可以直接使用

p54 HW5 英文->中文翻译

作业要求做翻译
特点是文件好多，下载的时候第一次失败了，再重新打开试了一次就行了，然后在Subword Units这里卡了4mins，最后的main train loop那里运行了好久。
google colab 我的免费版给我分配的T4 gpu ，运行了29mins，助教说kaggle 的p100要1hour，colab 的k80 要9hours，
因为评分系统在2022年4月已经关闭了，所以不能提交了，就这样过一遍吧，也没看到代码内部的构造，摆烂的一天

p58 GAN 生成式对抗网络

Generative Adversarial Network(GAN)

network as generator 用吃豆人做案例，向左右两个情况，做distribution，随机选一个，用来做creativity的任务。比如drawing（画画），chatbot（聊天机器人）
其中有一个结构 Discriminator（用来判断生成的东西是不是想要的，如果想要，输出接近1，不想要，输出接近0）
Basic Idea of GAN
Generator生成图片，Discriminator判断生成的图片是否合格，相互升级

P59 theory behind GAN

Discriminator的原理就是一个classifier，
GAN很难训练，讲了几个技巧，提到了几篇论文（WGAN），没怎么看懂

P60 生成器效能评估与条件式生成

讲了GAN的评价函数等，后边的（选修）都跳过了，HW6是做动漫人脸生成的，因为非本校的无法评估，就没做，看了看代码，GAN的代码就是多了Generator和Discriminator，别的训练还是一样的。

P71-74 2021 自监督式学习

self-supervised learning

BERT可以做masked token prediction \next sentence prediction，还可以做downstream tasks（下游任务）有个测试标准，名叫GLUE，可以测试Bert或者其他模型的好坏

怎么使用bert？
1，输入句子，输出类别，比如语义分析
2，输入句子，输出跟输入一样长，比如词性分析
3，输入两个句子，输出一个类，比如语言推断
4，问答系统

李老师还是博学啊，什么都知道

P75 自督导式模型

先介绍了预训练语言模型的功能，可以解决哪些问题，然后又讲了plms的问题：

缺少指定问题的训练资料
plm太大了，而且还在朝着更大的方向发展
解决方法：
Labeled Data Scarcity -> Data-Efficient Fine-tuning:
Prompt Tuning
Few-shot Learning(demonstrations)
Semi-supervised Learning

PLMs Are Gigantic -> Reducing the Number of Parameters:
主要的解决思想是：

减少下游任务的参数
共享参数
具体的方法有：
1.adapter
2.LoRA
3.Prefix Tuning
4.Soft Prompt
5.Early Exit

P76 语音和影响上的自监督学习

类似于文本的预训练模型

语音预训练模型也是先去找一堆没有标记的资料，然后做出预训练模型之后，再做下游任务

影像任务上也是这样，先学一堆资料，然后再做下游任务

P77-82 略看 hw7

HW7是做微调fine tuning任务的，打开指定的colab的ipynb文件，2023年1月3日最近发到的GPU一般都是T4，可能最近使用GPU的人少了，太棒了。

Simple Baseline (Acc>0.45139)

第一次训练，只修改了，是为了加速，而且测试一下完整的训练一遍需要多少时间，（GPU 是 T4)

fp16_training = True

累计用时10mins

然后提交到kaggle测试，得分0.4

然后加入修改：

Medium Baseline (Acc>0.65)

修改如下：

self.doc_stride = 32learning_rate = 2e-4
在这句话optimizer = AdamW(model.parameters(), lr=learning_rate)
下边加入
from transformers import get_linear_schedule_with_warmup
scheduler = get_linear_schedule_with_warmup(optimizer,num_warmup_steps=100,num_training_steps=1000)、、、optimizer.step()optimizer.zero_grad()scheduler.step()step += 1、、、

然后再运行

Strong Baseline (Acc>0.78136)

剩下的参考机器学习手艺人公众号，我没看懂

P83-95 第八节自编码器 HW8

讲解了自编码器和异常检测（Anomaly Detection），就是拿一部分资料来训练，另外未知的资料来检测是否和训练资料相似，如果不相似，就检测为异常。
HW8也是Anomaly Detection，
数据集网站not found，从机器学习手艺人的微信公众号下载的，然后上传到colab里边，文件的目录结构应该是这样的：

Simple Baseline (AUC>0.53150)

运行完提交到kaggle的得分是0.5：

Medium Baseline (AUC>0.73171)

d
修改代码块，把encoder和decoder加强

class conv_autoencoder(nn.Module):def __init__(self):super(conv_autoencoder, self).__init__()self.encoder = nn.Sequential(nn.Conv2d(3, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.Conv2d(24, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.Conv2d(24, 48, 4, stride=2, padding=1),nn.BatchNorm2d(48),nn.ReLU(),nn.Conv2d(48, 96, 4, stride=2, padding=1),nn.BatchNorm2d(96),nn.ReLU(),nn.Flatten(),nn.Dropout(0.2),nn.Linear(96*4*4, 128),nn.BatchNorm1d(128),nn.Dropout(0.2),nn.Linear(128, 10),nn.BatchNorm1d(10),nn.ReLU())self.decoder = nn.Sequential(nn.Linear(10, 128),nn.BatchNorm1d(128),nn.ReLU(),nn.Linear(128, 96*4*4),nn.BatchNorm1d(96*4*4),nn.ReLU(),nn.Unflatten(1, (96, 4, 4)),nn.ConvTranspose2d(96, 48, 4, stride=2, padding=1),nn.BatchNorm2d(48),nn.ReLU(),nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.ConvTranspose2d(24, 12, 4, stride=2, padding=1),nn.BatchNorm2d(12),nn.ReLU(),nn.ConvTranspose2d(12, 3, 4, stride=2, padding=1),nn.Tanh(),)def forward(self, x):x = self.encoder(x)x = self.decoder(x)return x

把模型内部对应修改：

class fcn_autoencoder(nn.Module):def __init__(self):super(fcn_autoencoder, self).__init__()self.encoder = nn.Sequential(nn.Linear(64 * 64 * 3, 128),nn.ReLU(),nn.Linear(128, 64),nn.ReLU(), nn.Linear(64, 12), nn.ReLU(), nn.Linear(12, 3))self.decoder = nn.Sequential(nn.Linear(3, 12),nn.ReLU(), nn.Linear(12, 64),nn.ReLU(),nn.Linear(64, 128),nn.ReLU(), nn.Linear(128, 64 * 64 * 3), nn.Tanh())def forward(self, x):x = self.encoder(x)x = self.decoder(x)return xclass conv_autoencoder(nn.Module):def __init__(self):super(conv_autoencoder, self).__init__()self.encoder = nn.Sequential(nn.Conv2d(3, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.Conv2d(24, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.Conv2d(24, 48, 4, stride=2, padding=1),nn.BatchNorm2d(48),nn.ReLU(),nn.Conv2d(48, 96, 4, stride=2, padding=1),nn.BatchNorm2d(96),nn.ReLU(),nn.Flatten(),nn.Dropout(0.2),nn.Linear(96*4*4, 128),nn.BatchNorm1d(128),nn.Dropout(0.2),nn.Linear(128, 10),nn.BatchNorm1d(10),nn.ReLU())self.decoder = nn.Sequential(nn.Linear(10, 128),nn.BatchNorm1d(128),nn.ReLU(),nn.Linear(128, 96*4*4),nn.BatchNorm1d(96*4*4),nn.ReLU(),nn.Unflatten(1, (96, 4, 4)),nn.ConvTranspose2d(96, 48, 4, stride=2, padding=1),nn.BatchNorm2d(48),nn.ReLU(),nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1),nn.BatchNorm2d(24),nn.ReLU(),nn.ConvTranspose2d(24, 12, 4, stride=2, padding=1),nn.BatchNorm2d(12),nn.ReLU(),nn.ConvTranspose2d(12, 3, 4, stride=2, padding=1),nn.Tanh(),)def forward(self, x):x = self.encoder(x)x = self.decoder(x)return x     class VAE(nn.Module):def __init__(self):super(VAE, self).__init__()self.encoder = nn.Sequential(nn.Conv2d(3, 24, 4, stride=2, padding=1), # nn.BatchNorm2d(24),nn.ReLU(),nn.Conv2d(24, 48, 4, stride=2, padding=1),# nn.BatchNorm2d(48),nn.ReLU(),nn.Conv2d(48, 96, 4, stride=2, padding=1),# nn.BatchNorm2d(96),nn.ReLU(),nn.Conv2d(96, 96, 4, stride=2, padding=1),# nn.BatchNorm2d(96),nn.ReLU(),nn.Flatten())self.enc_out_1 = nn.Sequential(#nn.Conv2d(48, 12, 4, stride=2, padding=1),#nn.ReLU(),nn.Dropout(0.2),nn.Linear(96*4*4, 128),#nn.BatchNorm1d(128),nn.ReLU(),nn.Dropout(0.2),nn.Linear(128, 10),# nn.BatchNorm1d(10),nn.ReLU())self.enc_out_2 = nn.Sequential(#nn.Conv2d(48, 12, 4, stride=2, padding=1),#nn.ReLU(),nn.Dropout(0.2),nn.Linear(96*4*4, 128),#nn.BatchNorm1d(128),nn.ReLU(),nn.Dropout(0.2),nn.Linear(128, 10),# nn.BatchNorm1d(10),nn.ReLU())self.decoder = nn.Sequential(nn.Linear(10, 128),#nn.BatchNorm1d(128),nn.ReLU(),nn.Linear(128, 96*4*4),#nn.BatchNorm1d(96*4*4),nn.ReLU(),nn.Unflatten(1, (96, 4, 4)),nn.ConvTranspose2d(96, 96, 4, stride=2, padding=1),nn.BatchNorm2d(96),nn.ReLU(),nn.ConvTranspose2d(96, 48, 4, stride=2, padding=1),nn.BatchNorm2d(48),nn.ReLU(),nn.ConvTranspose2d(48, 24, 4, stride=2, padding=1), nn.BatchNorm2d(24),nn.ReLU(),nn.ConvTranspose2d(24, 3, 4, stride=2, padding=1),nn.Tanh(),)def encode(self, x):h1 = self.encoder(x)return self.enc_out_1(h1), self.enc_out_2(h1)def reparametrize(self, mu, logvar):std = logvar.mul(0.5).exp_()if torch.cuda.is_available():eps = torch.cuda.FloatTensor(std.size()).normal_()else:eps = torch.FloatTensor(std.size()).normal_()eps = Variable(eps)return eps.mul(std).add_(mu)def decode(self, z):return self.decoder(z)def forward(self, x):mu, logvar = self.encode(x)z = self.reparametrize(mu, logvar)return self.decode(z), mu, logvardef loss_vae(recon_x, x, mu, logvar, criterion):"""recon_x: generating imagesx: origin imagesmu: latent meanlogvar: latent log variance"""mse = criterion(recon_x, x)KLD_element = mu.pow(2).add_(logvar.exp()).mul_(-1).add_(1).add_(logvar)KLD = torch.sum(KLD_element).mul_(-0.5)return mse + KLD

然后在Configuration里边修改model_type = ‘cnn’

最后运行

Boss Baseline (Acc>0.79506)

修改Random seed

same_seeds(42)

后边的太长了，直接搬运的他的代码，没运行完就给我关机了，不看了。

P96-110 略看

后边的就挑着自己感兴趣的看看了，因为太多了，不挨着看了。

P110 领域自适应（Domain Adaptation）

————如果训练集和测试集的数据大都不在一个领域，但是有一点点带有标注的资料，解决方法有：先训练完模型，然后拿target domain来微调模型，注意过拟合，稍微跑2~3个epochs就够了。
————如果测试集有大量的数据不在一个领域，但是根本没有标注的资料，解决方法有：加入一个feature extractor（network），都用来提取特征，然后排除掉领域（domain）的干扰，从而统一解决。（Domain Adversarial Training）

————如果测试集只有少量没有标注的数据不在一个领域，可以看Testing Time Traing（TTT）这篇文章
————如果对target domain一无所知的话，用Domain Generalization：

P113 hw11 Domain Adaptation

跟着手艺人直接测试的strong ，结果人家是0.76，我是0.71，差的不小

P114 Reinforcement Learning（RL）增强学习

这一节我是想看看怎么把他和王者荣耀结合起来。
上来先讲了RL和普通classifier的区别，他没有固定的评价标准，

他也是寻找一个函数来拟合环境和数据，从而是的Actor的表现得到最多的奖励：

了解了主要概念之后就没详细看后边的几节课

P120 hw12 RL

这次作业要训练一个飞船降落在月球上的游戏，要配置新环境。
colab 配置环境失败，提示安装box2d-py失败，原因是没有swig，先使用pip install swig安装，就没问题了。然后每一轮输出的时候我加了个

print(prg_bar)

方便看你训练进度,如果不加的话，可以用把页面的拉到最上方，也能看

simple可以正常运行，得分-169.

然后按照机器学习手艺人的教程，medium不行，缺东西， strong和boss都不行，都运行不起来，错误主要是RuntimeError: Found dtype Float but expected Double，没改成功，然后在网上搜到了另一个同学的过程，这是知乎链接：https://zhuanlan.zhihu.com/p/514067644

medium baseline 先修改了Policy Gradient

对于实现这个方法，宏毅老师也在课堂上讲过，当产生一个Action的时候，当前的Action会对未来的一些Action产生一定的影响，假设现在产生了三个动作每个Action记a1,a2,a3，所得到的分数是r1,r2,r3，则a1所得到的最终分数是r1+0.99*r2+0.99^2*r3，a2所得到的分数是r2+0.99*r3...具体实现如下

agent.network.train()  # Switch network into training mode
EPISODE_PER_BATCH = 5  # update the  agent every 5 episode
NUM_BATCH = 500        # totally update the agent for 400 timeavg_total_rewards, avg_final_rewards = [], []prg_bar = tqdm(range(NUM_BATCH))
for batch in prg_bar:log_probs, rewards = [], []total_rewards, final_rewards = [], []# collect trajectoryfor episode in range(EPISODE_PER_BATCH):state = env.reset()total_reward, total_step = 0, 0seq_rewards = []while True:action, log_prob = agent.sample(state) # at, log(at|st)next_state, reward, done, _ = env.step(action)log_probs.append(log_prob) # [log(a1|s1), log(a2|s2), ...., log(at|st)]# seq_rewards.append(reward)state = next_statetotal_reward += rewardtotal_step += 1rewards.append(reward) # change heren_reward = rewardfor i in range(len(rewards)-1):n_reward *= 0.99rewards[len(rewards)-2-i] += n_reward# ! IMPORTANT !# Current reward implementation: immediate reward,  given action_list : a1, a2, a3 ......#                                                         rewards :     r1, r2 ,r3 ......# medium：change "rewards" to accumulative decaying reward, given action_list : a1,                           a2,                           a3, ......#                                                           rewards :           r1+0.99*r2+0.99^2*r3+......, r2+0.99*r3+0.99^2*r4+...... ,  r3+0.99*r4+0.99^2*r5+ ......# boss : implement Actor-Criticif done:final_rewards.append(reward)total_rewards.append(total_reward)breakprint(f"rewards looks like ", np.shape(rewards))  #print(f"log_probs looks like ", np.shape(log_probs))# record training processavg_total_reward = sum(total_rewards) / len(total_rewards)avg_final_reward = sum(final_rewards) / len(final_rewards)avg_total_rewards.append(avg_total_reward)avg_final_rewards.append(avg_final_reward)prg_bar.set_description(f"Total:{avg_total_reward:4.1f}, Final:{avg_final_reward:4.1f}")# update agent# rewards = np.concatenate(rewards, axis=0)rewards = (rewards - np.mean(rewards)) / (np.std(rewards) + 1e-9)  # normalize the rewardagent.learn(torch.stack(log_probs), torch.from_numpy(rewards))print("logs prob looks like ", torch.stack(log_probs).size())print("torch.from_numpy(rewards) looks like ", torch.from_numpy(rewards).size())print(prg_bar)

最后的结果以及平均得分64是：

strong baseline

要替换DQN网络，替换到network=DQN（）那里报错不知道怎么改了，放弃了。看下一个作业了。

P121 模型压缩

把大的模型压缩为小一点的模型，同时不能减少过多的精度
有一个方法是用大模型的输入和输出来教小模型，小模型学习的不是输入输出，而是学的大模型的思路

P130 hw13

这次作业是模型压缩，开始下载数据集的时候如果解压失败，可以试试第二个下载链接，然后就解压成功了，然后运行一下sample code

simple baseline

运行了助教的代码，可以跑通

medium baseline

增加epoch + 知识蒸馏（Knowledge Distillation）
在cfg里修改

   'n_epochs': 50, # train more steps to pass the medium baseline.'patience': 30,

然后在原来loss_fn_kd代码块修改

# Implement the loss function with KL divergence loss for knowledge distillation.
# You also have to copy-paste this whole block to HW13 GradeScope.
CE = nn.CrossEntropyLoss()
def loss_fn_kd(student_logits, labels, teacher_logits, alpha=0.5, temperature=5.0):# ------------TODO-------------# Refer to the above formula and finish the loss function for knowkedge distillation using KL divergence loss and CE loss.# If you have no idea, please take a look at the provided useful link above.student_T = (student_logits/temperature).softmax(dim=-1)teacher_T = (teacher_logits/temperature).softmax(dim=-1)kl_loss = (student_T*(student_T.log() - teacher_T.log())).mean() ce_loss = CE(student_logits, labels)return alpha*(temperature**2)*kl_loss + (1 - alpha)*ce_loss

开始训练，tesla T4 GPU需要两个小时？我先吃个饭18点01分开始，一直到20：00才训练完成，
提交到kaggle得分0.66

然后尝试strong baseline

strong baseline

跟着机器学习手艺人的代码，他调的epoch=200，对tesla T4来说，就是8个小时，现在已经晚上20：30，我改了80epoch，尽量今晚能出个结果，看看kaggle多少分，最后colab给我断开了，说到了GPU使用上限了，明天重新跑吧。第二天还是显示到期限了，可能这个月都不行了，自己的电脑跑不起来，然后用的kaggle的免费GPU，两个T4，每个月34小时，跑了100epoch，batch 256，大概四个小时，最终得分0.82（PS:用kaggle下载submission的时候，kaggle的文件夹系统太卡了，我先执行 cp outputs/strong_baseline/submission.csv ./ 把文件复制到根目录/kaggle_working 下，然后下载的。）

P131-132 终身学习

为了解决机器学会喝茶就不会下棋的问题，解决一个模型难以学习多种任务的问题，
其中有一个方法：
先学习一个任务，再学下一个任务的时候，只优化对上一个问题不重要的参数，固定上一个任务的参数，再学习
还有一个方法：
每学一个任务，增加一组变量，这个就是需要更大的存储空间

P134 HW14 Lifelong learning

这次HW14的任务是lifelong learning，好像助教的代码都全了，只需要运行一下理解一下各个方法的区别就行，省事了嘿嘿。

simple baseline

直接运行助教的代码，18点23分开始，baseline训练一次，包含五个子任务，每个子任务训练10epoch，先等一下吧。大概tesla T4 的GPU用了半个小时运行完成了baseline，然后加了个展示图像的代码，看一下baseline的效果：

# 老版本是lineStyle='--', linewidth=2
plt.plot(baseline_acc, marker='o', ls='--', lw=2, markersize=4, label='baseline')
plt.legend()

然后测到了其他五种方法，自己跑出来的结果还不一样，这是我测出来的

这是机器学习手艺人测出来的

还剩最后一个HW15了

P135 meta learning（元学习）

meta learning= learn to learning ，学会学习
一听起来感觉非常高大上，其实核心还是做一个机器学习的任务，只不过输入的是多个分类任务，输出的是一个分类器，这个分类器就是原来的模型，可以给分类器输入图片再输出类别。整体就是用多个任务来学习分类这件事情，跟机器学习相同的还是不停的调参数等等。

P154 HW15 元学习

这次作业是关于元学习的。

simple baseline

简单的版本只需要运行助教的代码
baseline的代码中写了 if method=baseline，max_epoch=5,运行完这5epoch
提交到kaggle结果0.63

medium baseline

方法：FOMAML方法+增加epoch。首先需要设置solver = ‘meta’。FOMAML是MAML的简化版本，可节省训练时间，它忽略了内循环梯度对结果的影响，代码跟MAML相比仅仅有一点点的区别，FOMAML的内外循环代码修改如下，在内循环中使用局部参数fast_weights来记录参数变化，但是不对模型参数做修改，在外循环中对参数修改。epoch调节为120。改动后提交kaggle得到socre：0.79

grads = torch.autograd.grad(loss, fast_weights.values())
fast_weights = OrderedDict((name, param - inner_lr*grad)for ((name, param), grad) in zip(fast_weights.items(), grads))

手艺人测出来的结果是0.82，我自己测出来的结果是0.79

strong baseline

方法：MAML方法+增加epoch。MAML的代码中，在计算内循环梯度的时候，相比FOMAML，多了create_graph=True这个参数，代码如下，这样做可以计算更高阶的梯度，MAML就能用到内循环梯度的梯度，也就是代码中grads的梯度（FOMAML代码中grads是无法求梯度的）。任务数目的增加能影响模型的性能，这里我测试了3种不同epoch对结果的影响。120个epoch的kaggle socre是：0.95，这个得分实在是太恐怖了。

P155 完结撒花

整体的感受就是：课程看起来才80个小时，但是一天看三四个小时就够够的了，还有实验看着短，做起来也很费时间，一个实验做好至少要五六个小时吧，整体起码150小时多，所以我后半部分觉得选修的部分跟自己的研究方向不太重叠，就没怎么看，我的建议是跟自己相关的部分要详细的看，反复的看，跟自己不相关的部分，要略看，起码知道有这么个事情，就比如最后的元学习（meta learning），如果这个技术成熟了，以后什么分类识别，目标检测，都可以用这个meta learing先训练出一个最基础的模型，然后调参数，等等。
但是自己没怎么细看代码，以及推到过程，15个作业基本都是看着人家的程序修修改改，提高了自己调代码运行的能力哈哈。

最后，李宏毅老师讲的课程很容易听懂，由浅入深，感谢。

李宏毅《机器学习2022》笔记相关推荐

李宏毅机器学习2022 HW1
李宏毅机器学习2022版 Homework1 新冠阳性人数预测,根据前四天的数据,预测第五天的阳性人数.(回归) 首先下载数据集 !gdown --id '1kLSW_-cW2Huj7bh84YTdi ...
喜大普奔：Datawhale开源项目《李宏毅机器学习完整笔记》发布了！
开源地址 https://github.com/datawhalechina/leeml-notes [导读]关于机器学习的学习资料从经典书籍.免费公开课到开源项目应有尽有,可谓是太丰富啦,给学习者提 ...
李宏毅机器学习完整笔记发布，AI界「最热视频博主」中文课程笔记全开源
点上方"小詹学Python",选择"置顶公众号"第一时间获取干货分享!本文转自:Datawhale 提起李宏毅老师,熟悉机器学习的读者朋友一定不会陌生.很多人选 ...
视频+笔记+能够跑通的代码，《李宏毅机器学习完整笔记》发布！
点击我爱计算机视觉标星,更快获取CVML新技术 [导读]关于机器学习的学习资料从经典书籍.免费公开课到开源项目应有尽有,可谓是太丰富啦,给学习者提供了极大的便利.但网上比比皆是的学习资料大部分都是英文 ...
李宏毅机器学习—读书笔记
李宏毅机器学习笔记(LeeML-Notes) leeml-notes 机器学习人工智慧(Artificial Intelligence)是我们想要达成的目标,希望机器可以跟人一样的聪明.机器学习(M ...
2018-3-21李宏毅机器学习视频笔记（十二）--Backpropagation
视频来源: 李宏毅机器学习(2017)_哔哩哔哩 (゜-゜)つロ干杯~-bilibili https://www.bilibili.com/video/av10590361/?p=14 复合函数求偏 ...
201-3-19李宏毅机器学习视频笔记七（游戏解释Gradient Descent）
视频部分: 视频7:使用帝国时代游戏解释Gradient Descent 李宏毅机器学习(2017)_哔哩哔哩 (゜-゜)つロ干杯~-bilibili https://www.bilibili.co ...
李宏毅机器学习2022年春季班马上开始，深度学习圣经《深度学习》下载。
李宏毅(Hung-yi Lee)目前任台湾大学电机工程学系和电机资讯学院的助理教授,他曾于2010 年和2012 年分别获得台湾大学硕士和博士学位,并于 2013 年赴麻省理工学院(MIT)计算机科学 ...
[李宏毅机器学习2020笔记] 1.introduction
1. 基本概念 ⚪李宏毅老师眼中机器学习的定义--自动找函数无论是监督学习.非监督学习.强化学习都是某种信息或者情境到一种结果的映射 ⚪根据函数映射结果的离散性和连续性,可以分为分类和回归问题 c ...
2021李宏毅机器学习课程笔记——Recurrent Neural Network
注:这个是笔者用于期末复习的一个简单笔记,因此难以做到全面详细,有疑问欢迎大家在评论区讨论 I. Basic Idea 首先引入一个例子,槽填充(Slot Filling)问题: Input: I w ...

李宏毅《机器学习2022》笔记

P32 2022 为什么用了验证机（validation dataset）结果还是过拟合了呢

P33 鱼和熊掌可以兼得的机器学习

P34 spatial transformer

P35 HW3

P38 -39 2021 第四节，自注意力（self attention）

p40 41 回顾RNN

p42 43 补充GNN Graph Neural Network

p44 unsupervised learning：word embedding

p45 HW4

p46 p47是2021年的HW4

p48 （BN层）神经网络训练不起来怎么办

p49 50 Transformer （上）（下）

p51 各种attention

p52 non autoregressive sequence to sequence

p53 pointer network

p54 HW5 英文->中文翻译

p58 GAN 生成式对抗网络

P59 theory behind GAN

P60 生成器效能评估与条件式生成

P71-74 2021 自监督式学习

P75 自督导式模型

P76 语音和影响上的自监督学习

P77-82 略看 hw7

Simple Baseline (Acc>0.45139)

Medium Baseline (Acc>0.65)

Strong Baseline (Acc>0.78136)

P83-95 第八节 自编码器 HW8

Simple Baseline (AUC>0.53150)

Medium Baseline (AUC>0.73171)

Boss Baseline (Acc>0.79506)

P96-110 略看

P110 领域自适应（Domain Adaptation）

P113 hw11 Domain Adaptation

P114 Reinforcement Learning（RL）增强学习

P120 hw12 RL

medium baseline 先修改了Policy Gradient

strong baseline

P121 模型压缩

P130 hw13

simple baseline

medium baseline

strong baseline

P131-132 终身学习

P134 HW14 Lifelong learning

simple baseline

P135 meta learning（元学习）

P154 HW15 元学习

simple baseline

medium baseline

strong baseline

P155 完结撒花

李宏毅《机器学习2022》笔记相关推荐

最新文章

热门文章

P83-95 第八节自编码器 HW8