论文： Zoph & Le. Neural architecture search with reinforcement learning. In ICLR, 2017.
使用RNN来生成神经网络结构，然后使用RL强化学习来训练RNN，目前该方法已经过时了
第一步预测某一层卷积核数量：
第二步：
将第一步p的变成one-hot向量：a1，然后通过一个嵌入层变成x1作为第二步的输入，输出filter的大小。
第三步：预测步长
至此，第一个卷积的超参数就获得了。
因为目标函数不可微，所以只能使用强化学习来训练rnn：
神经网络结构搜索 (Neural Architecture Search) 的基础知识，包括超参数 (Hyper-parameters)、搜索空间 (Search Space)、随机搜索 (Random Search) 等概念。
神经网络中有很多参数：
• Parameters ：比如权重
• Hyper-parameter：搭建神经网络需要自己手动设置的一些参数（优化算法、epoch、学习率，网络结构等等）
如何自动调整超参数是一个很重要的方向。
如何调整网络结构超参数：
什么是NAS？找到最优的网络结构使得结果最好。（也有一些附加条件：比如计算量最小、网络模型最小、运行速度等等）
我们不可能遍历所有的网络 超参数取值范围，因此需要一个搜索空间search space：搜索空间指的是所有可能的 网络结构。
NAS的输出：输出一个网络结构.
如何选取超参数？
1、随机搜索
从搜索空间随机选择一组超参数，然后使用这组超参数去训练一个CNN模型，一直到模型收敛，最后用测试集做预测。
重复上述过程：。。。。。
缺点：1、每次搜索的代价昂贵 2、搜索空间太大了
小样本学习里面有一个非常常见和实用的方法：使用大数据集预训练，小数据集中微调。
参考文献和代码：
1. Chen, Liu, Kira, Wang, & Huang. A Closer Look at Few-shot Classification. In ICLR, 2019. 代码： https://github.com/wyharveychen/Close…
2. Dhillon, Chaudhari, Ravichandran, & Soatto. A baseline for few-shot image classification. In ICLR, 2020.
3. Chen, Wang, Liu, Xu, & Darrell. A New Meta-Baseline for Few-Shot Learning. arXiv, 2020. 代码：https://github.com/cyvius96/few-shot-…
小样本学习旨在通过有限标记数据学习识别新类别，可以将小样本学习算法分为三大类：基于初始化的方法、基于度量学习的方法和基于数据增强的方法。
基于初始化的方法：学习微调，旨在学习一个好的模型初始化策略，使得能够通过少量标记数据和有限的梯度更新轮次即可完成对新类别的分类，或者学习一个优化器。
基于距离度量的方法：学习比较，如果一个模型能够计算两张图像的相似度，那么它可能基于标记数据对未知图像进行分类，一般基于余弦相似度、欧式距离、岭回归、图神经网络等计算距离。
基于数据增强的方法：学习增强，旨在通过学习一个数据生成器，通过数据生成器增强新类的样本量。由于基于数据增强的方法往往与零样本方法协同优化，所以本文作者不考虑基于数据增强的方法。
领域自适应：一种旨在缓解源领域和目标领域间领域漂移现象的技术。小样本分类与领域自适应类似，区别在于在领域自适应中，目标域往往拥有大量的可用样本，而小样本学习在新领域中仅有少量可用样本。
大部分的思路：通过一个大数据集进行训练一个神经网络，在做few-shot的时候，我们要用到这个与训练好的 神经网络，我们分别把query和support set送进神经网络，并获得特征向量，就可以比较 query和support set 在空间上的相似度（比如余弦相似度），然后就可以比较了。训练好的网络去掉全连接层。
2、不微调，直接使用预训练的网络进行预测：
3、对query分类：
4、微调：
微调调的是softmax，而不是CNN特征提取网络！也就是微调下面的W和B
1、微调的初始化：让W=M，b=0
如何微调：使用entropy损失来更新w和b参数
来自wangshusen的课件： https://github.com/wangshusen/DeepLearning
小样本学习就是用极少的数据做分类or回归。
如上面的suppoort set 里面有两个类别，右边query图片你认为是set里面的哪个类别？对于人类来说非常简单，对于机器来说能不能像人一样去识别query属于哪一类？
对于小样本学习，不可能按照传统的方法去训练一个分类模型。小样本不能训练出一个神经网络。few-shot learing就是去解决小样本分类问题。
few-shot learing 的训练目标与传统的监督学习目标不同，传统的分类是学会识别训练集合里面的图片 ，并且泛化到测试机，神经网络识别出该图片属于哪个类。而few shot learing是让机器自己学会学习，学习的目的不是让机器学会那个是大象那个是老虎，而是让模型学会学习不同类别的不同之处，给定两张图片，模型知道两个图片是否是同一类别。哪怕模型训练集中没有出现过该类别。
虽然模型没有见过斗牛犬和穿山甲，但能够知道这两个是不是一个东西。
给神经网络一个query和六张图片（support set），现在神经网络依次将query和supportset做对比，判断query和那个更相似。
support set 和 train set 区别：
训练集很大每一类下面有很多图片，support set小，只能在预测的时候提供一些额外信息，用一个大的训练集训练一个神经网络，训练的目的不是让模型识别图片里面的大象老虎，而是学会理解不同类别的异同。
Meta learing：元学习,自己学会学习
传统监督学习 vs few shot learing
主要区别就是：是否训练集中存在测试的类别。query可以是模型没见过的类别。因此会更难。
为了让模型识别没见的东西：需要为模型提供一个参考：support set，计算相似度。
K-way N-shot support set： K-有K个类别，，每个类别有n个样本。
准确度随着 K个类别 数增加而降低。
准确度随着每个类的样本数而增加
小样本学习最基本的想法：
可以用大规模数据集做训练：
1、手写数字：
2、图片数据
孪生网络(Siamese Networks) 属于二分类，基于相似性的先验知识。
参考论文：
1、Siamese Neural Networks for One-shot Image Recognition
2、FaceNet: A Unified Embedding for Face Recognition and Clustering
简单来说，Siamese network就是“连体的神经网络”，神经网络的“连体”是通过共享权值来实现的，如下图所示。
Siamese Neural Networks for One-shot Image Recognition
使用一个大的数据集，每一类里面有很多样本。用训练集构造正样本和负样本。正样本告诉神经网络什么是同一类，负样本告诉神经网络不同样本的区别。
从同一类图片随机抽取两张图片，并设置标签1，表示同一类。
从不同类中随机抽取两张图片，设置标签为0，表示不同的类别。
target 和 sim 的损失，来更新参数。
逐一将support set里面的图片分别和query求相似度，取其最高的那个。
FaceNet: A Unified Embedding for Face Recognition and Clustering
2.1数据集处理：
从数据集中随机抽取一张图片，作为锚点anchor，再从该类别中随机去一张正样本 ，从除了该类以外的图片中抽取一个负样本作为sample
2.2训练：共享网络
2.3损失函数：
模板d+越小，d-越大
2.4 测试：选择模型输出距离最小的。
总结：
来自GitHub仓库：https://github.com/tata1661/FSL-Mate/tree/master/FewShotPapers
This repository contains few-shot learning (FSL) papers mentioned in our FSL survey published in ACM Computing Surveys (JCR Q1, CORE A*).
For convenience, we also include public implementations of respective authors.
We will update this paper list to include new FSL papers periodically.
Please cite our paper if you find it helpful.
@article{wang2020generalizing,
title={Generalizing from a few examples: A survey on few-shot learning},
author={Wang, Yaqing and Yao, Quanming and Kwok, James T and Ni, Lionel M},
journal={ACM Computing Surveys},
volume={53},
number={3},
pages={1--34},
year={2020},
publisher={ACM New York, NY, USA}
}
摘自: https://research.aimultiple.com/few-shot-learning/
论文 ：A Survey on Few-Shot Learning： https://arxiv.org/abs/1904.05046
wss介绍视频：https://www.youtube.com/c/ShusenWang
课件：https://github.com/wangshusen/DeepLearning
如果手机需要成千上万张照片来训练才能进行人脸识别解锁，这是很不友好的。在机器学习应用领域，小样本学习(Few-shot Learning)（在刚刚描述的情况下称为单样本学习(one-shot learning)）是一个热门话题，它能够基于少量的训练样本去预测。本文将讨论以下几个方面：
case：以相似度函数来进行图片分类：
训练：可以在大规模数据集中学习不同类别的相似性，使得同一类的相似度高，不同类别相似度低。
测试：输入query（测试图片）和 surport set（带标签的图片，要进行比较的不同类别的数据集不等于训练集）目的就是要让模型识别query和 surport set 中那个更相似。
小样本学习(Few-shot learning, FSL)，在少数资料中也被称为low-shot learning(LSL)。小样本学习是一种训练数据集包含有限信息的机器学习问题。
对于机器学习应用来说，通常的做法是提供尽可能多的数据。这是因为在大多数机器学习应用中，输入更多的数据训练能使模型的预测效果更好。然而，小样本学习的目标是使用数量较少的训练集来构建准确的机器学习模型。由于输入数据的维度是一个决定资源消耗成本(如，时间成本，计算成本等)的因素，我们可以通过使用小样本学习来降低数据分析/机器学习消耗成本。
小样本学习的目的是在有少量训练数据的情况下能获得准确分类测试样本的模型。零样本学习的目的是预测训练数据集中没有出现过的类别。零样本学习和小样本学习有很多共同的应用，例如：
还有一种叫单样本学习(one-shot learning)的，它经常会和零样本学习混在一起。单样本学习是小样本学习问题的一个特例，它的目的是从一个训练样本或图片中学习到有关物体类别的信息。单样本学习的一个例子是，智能手机中使用的人脸识别技术。
5.1 计算机视觉：计算机视觉探索如何从数字图像或视频中获得高级理解。小样本学习在计算机视觉中主要用于处理以下问题：
5.2 自然语言处理：小样本学习使自然语言处理应用程序能够用很少的文本数据样本来完成任务。例如：
5.3 机器人：为了让机器人的行为更像人类，它们应该能够从少量的示例中归纳出信息。因此，小样本学习在训练机器人完成特定任务中扮演了一个关键角色，例如：
5.4 声信号处理：包含有关声音信息的数据可以通过声信号处理进行分析，小样本在该方向的应用有：
5.5 其它应用：
IBM研究表明，机器学习在未来将围绕以下领域发展：
Huggingface Transformers 是基于一个开源基于 transformer 模型结构提供的预训练语言库，它支持 Pytorch，Tensorflow2.0，并且支持两个框架的相互转换。框架支持了最新的各种NLP预训练语言模型，使用者可以很快速的进行模型的调用，并且支持模型further pretraining 和 下游任务fine-tuning。
该库是使用 BERT 等预训练模型的最常用的库，甚至超过了google等开源的源代码。它的设计原则保证了它支持各种不同的预训练模型，并且有统一的合理的规范。使用者可以很方便的进行模型的下载，以及使用。同时，它支持用户自己上传自己的预训练模型到Model Hub中，提供其他用户使用。对于NLP从业者，可以使用这个库，很方便地进行自然语言理解（NLU） 和 自然语言生成（NLG）任务的SOTA模型使用。
特色：
🤗 Transformers 提供了数以千计的预训练模型，支持 100 多种语言的文本分类、信息抽取、问答、摘要、翻译、文本生成。它的宗旨让最先进的 NLP 技术人人易用。
🤗 Transformers 提供了便于快速下载和使用的API，让你可以把预训练模型用在给定文本、在你的数据集上微调然后通过 model hub 与社区共享。同时，每个定义的 Python 模块均完全独立，方便修改和快速研究实验。
🤗 Transformers 支持三个最热门的深度学习库： Jax, PyTorch and TensorFlow — 并与之无缝整合。你可以直接使用一个框架训练你的模型然后用另一个加载和推理。
你可以直接在模型页面上测试大多数 model hub 上的模型。 我们也提供了 私有模型托管、模型版本管理以及推理API。
这里是一些例子：
我们为快速使用模型提供了 pipeline （流水线）API。流水线聚合了预训练模型和对应的文本预处理。下面是一个快速使用流水线去判断正负面情绪的例子：
>>> from transformers import pipeline
# 使用情绪分析流水线
>>> classifier = pipeline('sentiment-analysis')
>>> classifier('We are very happy to introduce pipeline to the transformers repository.')
[{'label': 'POSITIVE', 'score': 0.9996980428695679}]
第二行代码下载并缓存了流水线使用的预训练模型，而第三行代码则在给定的文本上进行了评估。这里的答案“正面” (positive) 具有 99 的置信度。
许多的 NLP 任务都有开箱即用的预训练流水线。比如说，我们可以轻松的从给定文本中抽取问题答案：
>>> from transformers import pipeline
# 使用问答流水线
>>> question_answerer = pipeline('question-answering')
>>> question_answerer({
... 'question': 'What is the name of the repository ?',
... 'context': 'Pipeline has been included in the huggingface/transformers repository'
... })
{'score': 0.30970096588134766, 'start': 34, 'end': 58, 'answer': 'huggingface/transformers'}
除了给出答案，预训练模型还给出了对应的置信度分数、答案在词符化 (tokenized) 后的文本中开始和结束的位置。你可以从这个教程了解更多流水线API支持的任务。
要在你的任务上下载和使用任意预训练模型也很简单，只需三行代码。这里是 PyTorch 版的示例：
>>> from transformers import AutoTokenizer, AutoModel
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = AutoModel.from_pretrained("bert-base-uncased")
>>> inputs = tokenizer("Hello world!", return_tensors="pt")
>>> outputs = model(**inputs)
这里是等效的 TensorFlow 代码：
>>> from transformers import AutoTokenizer, TFAutoModel
>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFAutoModel.from_pretrained("bert-base-uncased")
>>> inputs = tokenizer("Hello world!", return_tensors="tf")
>>> outputs = model(**inputs)
词符化器 (tokenizer) 为所有的预训练模型提供了预处理，并可以直接对单个字符串进行调用（比如上面的例子）或对列表 (list) 调用。它会输出一个你可以在下游代码里使用或直接通过 ** 解包表达式传给模型的词典 (dict)。
模型本身是一个常规的 Pytorch nn.Module 或 TensorFlow tf.keras.Model（取决于你的后端），可以常规方式使用。 这个教程解释了如何将这样的模型整合到经典的 PyTorch 或 TensorFlow 训练循环中，或是如何使用我们的 Trainer 训练器）API 来在一个新的数据集上快速微调。
Trainer API 并非兼容任何模型，只为本库之模型优化。若是在寻找适用于通用机器学习的训练循环实现，请另觅他库。| 章节 | 描述 |
|---|---|
| 文档 | 完整的 API 文档和教程 |
| 任务总结 | 🤗 Transformers 支持的任务 |
| 预处理教程 | 使用 Tokenizer 来为模型准备数据 |
| 训练和微调 | 在 PyTorch/TensorFlow 的训练循环或 Trainer API 中使用 🤗 Transformers 提供的模型 |
| 快速上手：微调和用例脚本 | 为各种任务提供的用例脚本 |
| 模型分享和上传 | 和社区上传和分享你微调的模型 |
| 迁移 | 从 pytorch-transformers 或 pytorch-pretrained-bert 迁移到 🤗 Transformers |
Transformers model hub 提供了不同的预训练语言模型，包含了常见的Robert/BERT/XLNET/以及BART 等，几乎所有的最新模型都可以在上面找到。用户可以很方便地对模型进行调用，只需要一个模型的名字，就可以获取模型文件。
model = AutoModel.from_pretrained(model_name)Transformers 的设计是为了：
transformers 库包含了机器学习相关的主要三个部分：数据处理process data, 模型应用 apply a model, 和做出预测make predictions。分别对应的如下三个模块：Tokenizer，Transformers，以及 Head。
Tokenizer 类支持从预训练模型中进行加载或者直接手动配置。这些类存储了 token 到 id 的字典，并且可以对输入进行分词，和decode。huggingface transformers 已经提供了如下图的相关tokenizer 分词器。用户也可以很轻松的对tokenizer 里的特殊字符进行更换，例如CLS/SEP。或者是对Tokenizer模型的字典进行大小修改等。
Tokenizer 提供了很多有用的方法，例如padding，truncating，用户可以很方便的对其进行使用。
Transformer transformers 指的是各种基于transformer结构的预训练语言模型，例如BERT，GPT等。它将输入的sparse的序列，转化为上下文感知的的 contextual embedding。
encoder 模型的计算图通常就是对模型输入进行一系列的 self-attention 操作，然后得到最后的encoder的输出。通常情况下，每个模型都是在一个文件中被定义完成的，这样方便用户进行更改和拓展。
针对不同的模型结构，都采用相同的API，这使得用户可以快速地使用不同的其他模型。transformers 提供 一系列的Auto classes，使得快速进行模型切换非常方便。
model = AutoModel.from_pretrained(model_name)这些模型的head，是在模型文件集中上，包装的另外一个类，它提供了额外的输出层，loss函数等。 这些层的命名规范也很一致，采用的是： XXXForSequenceClassification
其中 XXX 是模型的下游任务(fine-tuning) 或者与训练 pretraining 任务。一些head，例如条件生成（conditional generation），支持额外的功能，像是sampling and beam search。
下图解释了每个head 的输入和输出以及数据集。
下面的代码展示了如何使用 transformers 进行下游的文本分类任务：
from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)Transformers提供了数以千计针对于各种任务的预训练模型模型，开发者可以根据自身的需要，选择模型进行训练或微调，也可阅读api文档和源码， 快速开发新模型。
1）安装一个非常轻量级的 Transformers
!pip install transformers然后
import transformers2）建议安装开发版本，几乎带有所有用例需要的依赖项
!pip install transformers[sentencepiece]Transformers 库中最基本的对象是
pipeline()函数。它将模型与其必要的预处理和后处理步骤连接起来，使我们能够直接输入任何文本并获得答案：
当第一次运行的时候，它会下载预训练模型和分词器(tokenizer)并且缓存下来。
from transformers import pipeline
classifier = pipeline("sentiment-analysis") # 情感分析
classifier("I've been waiting for a HuggingFace course my whole life.")
# 输出
# [{'label': 'POSITIVE', 'score': 0.9598047137260437}]也可以传几句话：
classifier(
["I've been waiting for a HuggingFace course my whole life.", "I hate this so much!"]
)
# 输出
'''
[{'label': 'POSITIVE', 'score': 0.9598047137260437},
{'label': 'NEGATIVE', 'score': 0.9994558095932007}]
'''目前可用的一些pipeline 有：
feature-extraction特征提取：把一段文字用一个向量来表示fill-mask填词：把一段文字的某些部分mask住，然后让模型填空ner命名实体识别：识别文字中出现的人名地名的命名实体question-answering问答：给定一段文本以及针对它的一个问题，从文本中抽取答案sentiment-analysis情感分析：一段文本是正面还是负面的情感倾向summarization摘要：根据一段长文本中生成简短的摘要text-generation文本生成：给定一段文本，让模型补充后面的内容translation翻译：把一种语言的文字翻译成另一种语言zero-shot-classification
这些pipeline的具体例子可见：Transformer models – Hugging Face Course
在接收文本后，通常有三步：Tokenizer、Model、Post-Processing。
1）Tokenizer
与其他神经网络一样，Transformer 模型不能直接处理原始文本，故使用分词器进行预处理。使用AutoTokenizer类及其from_pretrained()方法。
from transformers import AutoTokenizer
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)若要指定我们想要返回的张量类型（PyTorch、TensorFlow 或普通 NumPy），我们使用return_tensors参数
raw_inputs = [
"I've been waiting for a HuggingFace course my whole life.",
"I hate this so much!",
]
inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")
print(inputs)PyTorch 张量的结果：
输出本身是一个包含两个键的字典，input_ids和attention_mask。
{
'input_ids': tensor([
[ 101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102],
[ 101, 1045, 5223, 2023, 2061, 2172, 999, 102, 0, 0, 0, 0, 0, 0, 0, 0]
]),
'attention_mask': tensor([
[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
[1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0]
])
}2）Model
Transformers 提供了一个AutoModel类，它也有一个from_pretrained()方法：
from transformers import AutoModel
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
model = AutoModel.from_pretrained(checkpoint)如果我们将预处理过的输入提供给我们的模型，我们可以看到：
outputs = model(**inputs)
print(outputs.last_hidden_state.shape)
# 输出
# torch.Size([2, 16, 768])
Transformers 中有许多不同的架构可用，每一种架构都围绕着处理特定任务而设计，清单：
*Model(retrieve the hidden states)*ForCausalLM*ForMaskedLM*ForMultipleChoice*ForQuestionAnswering*ForSequenceClassification*ForTokenClassification
and others
3）Post-Processing
模型最后一层输出的原始非标准化分数。要转换为概率，它们需要经过一个SoftMax层（所有 Transformers 模型都输出 logits，因为用于训练的损耗函数一般会将最后的激活函数(如SoftMax)与实际损耗函数(如交叉熵)融合 。
import torch
predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
print(predictions)1）创建Transformer
from transformers import BertConfig, BertModel
# Building the config
config = BertConfig()
# Building the model from the config
model = BertModel(config)2）不同的加载方式
from transformers import BertModel
model = BertModel.from_pretrained("bert-base-cased")3）保存模型
model.save_pretrained("directory_on_my_computer")4）使用Transformer model
sequences = ["Hello!", "Cool.", "Nice!"]
encoded_sequences = [
[101, 7592, 999, 102],
[101, 4658, 1012, 102],
[101, 3835, 999, 102],
]
import torch
model_inputs = torch.tensor(encoded_sequences)1）Loading and saving
from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
tokenizer("Using a Transformer network is simple")
# 输出
'''
{'input_ids': [101, 7993, 170, 11303, 1200, 2443, 1110, 3014, 102],
'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}
'''
# 保存
tokenizer.save_pretrained("directory_on_my_computer")2）Tokenization
from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
sequence = "Using a Transformer network is simple"
tokens = tokenizer.tokenize(sequence)
print(tokens) # 输出 : ['Using', 'a', 'transform', '##er', 'network', 'is', 'simple']
# 从token 到输入 ID
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids) # 输出：[7993, 170, 11303, 1200, 2443, 1110, 3014]3） Decoding
decoded_string = tokenizer.decode([7993, 170, 11303, 1200, 2443, 1110, 3014])
print(decoded_string) # 输出：'Using a Transformer network is simple'1) 模型需要一批输入 Models expect a batch of inputs
将数字列表转换为张量并将其发送到模型：
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequence = "I've been waiting for a HuggingFace course my whole life."
tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
input_ids = torch.tensor([ids])
print("Input IDs:", input_ids)
output = model(input_ids)
print("Logits:", output.logits)
# 输出
'''
Input IDs: [[ 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]]
Logits: [[-2.7276, 2.8789]]
'''2) 填充输入 Padding the inputs
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequence1_ids = [[200, 200, 200]]
sequence2_ids = [[200, 200]]
batched_ids = [
[200, 200, 200],
[200, 200, tokenizer.pad_token_id],
]
print(model(torch.tensor(sequence1_ids)).logits)
print(model(torch.tensor(sequence2_ids)).logits)
print(model(torch.tensor(batched_ids)).logits)
# 输出
'''
tensor([[ 1.5694, -1.3895]], grad_fn=<AddmmBackward>)
tensor([[ 0.5803, -0.4125]], grad_fn=<AddmmBackward>)
tensor([[ 1.5694, -1.3895],
[ 1.3373, -1.2163]], grad_fn=<AddmmBackward>)
'''我们已经探索了分词器的工作原理，并研究了分词 tokenizers、转换为输入 ID conversion to input IDs、填充 padding、截断 truncation和注意力掩码 attention masks。Transformers API 可以通过高级函数为我们处理所有这些。
from transformers import AutoTokenizer
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)# 可以标记单个序列
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)
# 还可以一次处理多个序列
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
model_inputs = tokenizer(sequences)# 可以根据几个目标进行填充
# Will pad the sequences up to the maximum sequence length
model_inputs = tokenizer(sequences, padding="longest")
# Will pad the sequences up to the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, padding="max_length")
# Will pad the sequences up to the specified max length
model_inputs = tokenizer(sequences, padding="max_length", max_length=8)# 还可以截断序列
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
# Will truncate the sequences that are longer than the model max length
# (512 for BERT or DistilBERT)
model_inputs = tokenizer(sequences, truncation=True)
# Will truncate the sequences that are longer than the specified max length
model_inputs = tokenizer(sequences, max_length=8, truncation=True)# 可以处理到特定框架张量的转换，然后可以将其直接发送到模型。
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
# Returns PyTorch tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="pt")
# Returns TensorFlow tensors
model_inputs = tokenizer(sequences, padding=True, return_tensors="tf")
# Returns NumPy arrays
model_inputs = tokenizer(sequences, padding=True, return_tensors="np")Special tokens
分词器在开头添加特殊词[CLS]，在结尾添加特殊词[SEP]。
sequence = "I've been waiting for a HuggingFace course my whole life."
model_inputs = tokenizer(sequence)
print(model_inputs["input_ids"])
tokens = tokenizer.tokenize(sequence)
ids = tokenizer.convert_tokens_to_ids(tokens)
print(ids)
# 输出
'''
[101, 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012, 102]
[1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]
'''
print(tokenizer.decode(model_inputs["input_ids"]))
print(tokenizer.decode(ids))
# 输出
'''
"[CLS] i've been waiting for a huggingface course my whole life. [SEP]"
"i've been waiting for a huggingface course my whole life."
'''# 总结：从分词器到模型
import torch
from transformers import AutoTokenizer, AutoModelForSequenceClassification
checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
sequences = ["I've been waiting for a HuggingFace course my whole life.", "So have I!"]
tokens = tokenizer(sequences, padding=True, truncation=True, return_tensors="pt")
output = model(**tokens)Huggingface Transformers库学习笔记（二）：使用Transformers(上)（Using Transformers Part 1）： https://blog.csdn.net/u011426236/article/details/115460564
# Bash 脚本入门
脚本（script）就是包含一系列命令的一个文本文件。Shell 读取这个文件，依次执行里面的所有命令，就好像这些命令直接输入到命令行一样。所有能够在命令行完成的任务，都能够用脚本完成。
脚本的好处是可以重复使用，也可以指定在特定场合自动调用，比如系统启动或关闭时自动执行脚本。
脚本的第一行通常是指定解释器，即这个脚本必须通过什么解释器执行。这一行以#!字符开头，这个字符称为 Shebang，所以这一行就叫做 Shebang 行。
#!后面就是脚本解释器的位置，Bash 脚本的解释器一般是/bin/sh或/bin/bash。
#!/bin/sh
# 或者
#!/bin/bash
#!与脚本解释器之间有没有空格，都是可以的。
如果 Bash 解释器不放在目录/bin，脚本就无法执行了。为了保险，可以写成下面这样。
#!/usr/bin/env bash
上面命令使用env命令（这个命令总是在/usr/bin目录），返回 Bash 可执行文件的位置。env命令的详细介绍，请看后文。
Shebang 行不是必需的，但是建议加上这行。如果缺少该行，就需要手动将脚本传给解释器。举例来说，脚本是script.sh，有 Shebang 行的时候，可以直接调用执行。
$ ./script.sh
上面例子中，script.sh是脚本文件名。脚本通常使用.sh后缀名，不过这不是必需的。
如果没有 Shebang 行，就只能手动将脚本传给解释器来执行。
$ /bin/sh ./script.sh
# 或者
$ bash ./script.sh
前面说过，只要指定了 Shebang 行的脚本，可以直接执行。这有一个前提条件，就是脚本需要有执行权限。可以使用下面的命令，赋予脚本执行权限。
# 给所有用户执行权限
$ chmod +x script.sh
# 给所有用户读权限和执行权限
$ chmod +rx script.sh
# 或者
$ chmod 755 script.sh
# 只给脚本拥有者读权限和执行权限
$ chmod u+rx script.sh
脚本的权限通常设为755（拥有者有所有权限，其他人有读和执行权限）或者700（只有拥有者可以执行）。
除了执行权限，脚本调用时，一般需要指定脚本的路径（比如path/script.sh）。如果将脚本放在环境变量$PATH指定的目录中，就不需要指定路径了。因为 Bash 会自动到这些目录中，寻找是否存在同名的可执行文件。
建议在主目录新建一个~/bin子目录，专门存放可执行脚本，然后把~/bin加入$PATH。
export PATH=$PATH:~/bin
上面命令改变环境变量$PATH，将~/bin添加到$PATH的末尾。可以将这一行加到~/.bashrc文件里面，然后重新加载一次.bashrc，这个配置就可以生效了。
$ source ~/.bashrc
以后不管在什么目录，直接输入脚本文件名，脚本就会执行。
$ script.sh
上面命令没有指定脚本路径，因为script.sh在$PATH指定的目录中。
env命令总是指向/usr/bin/env文件，或者说，这个二进制文件总是在目录/usr/bin。
#!/usr/bin/env NAME这个语法的意思是，让 Shell 查找$PATH环境变量里面第一个匹配的NAME。如果你不知道某个命令的具体路径，或者希望兼容其他用户的机器，这样的写法就很有用。
/usr/bin/env bash的意思就是，返回bash可执行文件的位置，前提是bash的路径是在$PATH里面。其他脚本文件也可以使用这个命令。比如 Node.js 脚本的 Shebang 行，可以写成下面这样。
#!/usr/bin/env node
env命令的参数如下。
-i, --ignore-environment：不带环境变量启动。-u, --unset=NAME：从环境变量中删除一个变量。--help：显示帮助。--version：输出版本信息。下面是一个例子，新建一个不带任何环境变量的 Shell。
$ env -i /bin/sh
Bash 脚本中，#表示注释，可以放在行首，也可以放在行尾。
# 本行是注释
echo 'Hello World!'
echo 'Hello World!' # 井号后面的部分也是注释
建议在脚本开头，使用注释说明当前脚本的作用，这样有利于日后的维护。
调用脚本的时候，脚本文件名后面可以带有参数。
$ script.sh word1 word2 word3
上面例子中，script.sh是一个脚本文件，word1、word2和word3是三个参数。
脚本文件内部，可以使用特殊变量，引用这些参数。
$0：脚本文件名，即script.sh。$1~$9：对应脚本的第一个参数到第九个参数。$#：参数的总数。$@：全部的参数，参数之间使用空格分隔。$*：全部的参数，参数之间使用变量$IFS值的第一个字符分隔，默认为空格，但是可以自定义。如果脚本的参数多于9个，那么第10个参数可以用${10}的形式引用，以此类推。
注意，如果命令是command -o foo bar，那么-o是$1，foo是$2，bar是$3。
下面是一个脚本内部读取命令行参数的例子。
#!/bin/bash
# script.sh
echo "全部参数：" $@
echo "命令行参数数量：" $#
echo '$0 = ' $0
echo '$1 = ' $1
echo '$2 = ' $2
echo '$3 = ' $3
执行结果如下。
$ ./script.sh a b c
全部参数：a b c
命令行参数数量：3
$0 = script.sh
$1 = a
$2 = b
$3 = c
用户可以输入任意数量的参数，利用for循环，可以读取每一个参数。
#!/bin/bash
for i in "$@"; do
echo $i
done
上面例子中，$@返回一个全部参数的列表，然后使用for循环遍历。
如果多个参数放在双引号里面，视为一个参数。
$ ./script.sh "a b"
上面例子中，Bash 会认为"a b"是一个参数，$1会返回a b。注意，返回时不包括双引号。
shift命令可以改变脚本参数，每次执行都会移除脚本当前的第一个参数（$1），使得后面的参数向前一位，即$2变成$1、$3变成$2、$4变成$3，以此类推。
while循环结合shift命令，也可以读取每一个参数。
#!/bin/bash
echo "一共输入了 $# 个参数"
while [ "$1" != "" ]; do
echo "剩下 $# 个参数"
echo "参数：$1"
shift
done
上面例子中，shift命令每次移除当前第一个参数，从而通过while循环遍历所有参数。
shift命令可以接受一个整数作为参数，指定所要移除的参数个数，默认为1。
shift 3
上面的命令移除前三个参数，原来的$4变成$1。
getopts命令用在脚本内部，可以解析复杂的脚本命令行参数，通常与while循环一起使用，取出脚本所有的带有前置连词线（-）的参数。
getopts optstring name
它带有两个参数。第一个参数optstring是字符串，给出脚本所有的连词线参数。比如，某个脚本可以有三个配置项参数-l、-h、-a，其中只有-a可以带有参数值，而-l和-h是开关参数，那么getopts的第一个参数写成lha:，顺序不重要。注意，a后面有一个冒号，表示该参数带有参数值，getopts规定带有参数值的配置项参数，后面必须带有一个冒号（:）。getopts的第二个参数name是一个变量名，用来保存当前取到的配置项参数，即l、h或a。
下面是一个例子。
while getopts 'lha:' OPTION; do
case "$OPTION" in
l)
echo "linuxconfig"
;;
h)
echo "h stands for h"
;;
a)
avalue="$OPTARG"
echo "The value provided is $OPTARG"
;;
?)
echo "script usage: $(basename $0) [-l] [-h] [-a somevalue]" >&2
exit 1
;;
esac
done
shift "$(($OPTIND - 1))"
上面例子中，while循环不断执行getopts 'lha:' OPTION命令，每次执行就会读取一个连词线参数（以及对应的参数值），然后进入循环体。变量OPTION保存的是，当前处理的那一个连词线参数（即l、h或a）。如果用户输入了没有指定的参数（比如-x），那么OPTION等于?。循环体内使用case判断，处理这四种不同的情况。
如果某个连词线参数带有参数值，比如-a foo，那么处理a参数的时候，环境变量$OPTARG保存的就是参数值。
注意，只要遇到不带连词线的参数，getopts就会执行失败，从而退出while循环。比如，getopts可以解析command -l foo，但不可以解析command foo -l。另外，多个连词线参数写在一起的形式，比如command -lh，getopts也可以正确处理。
变量$OPTIND在getopts开始执行前是1，然后每次执行就会加1。等到退出while循环，就意味着连词线参数全部处理完毕。这时，$OPTIND - 1就是已经处理的连词线参数个数，使用shift命令将这些参数移除，保证后面的代码可以用$1、$2等处理命令的主参数。
---和--开头的参数，会被 Bash 当作配置项解释。但是，有时它们不是配置项，而是实体参数的一部分，比如文件名叫做-f或--file。
$ cat -f
$ cat --file
上面命令的原意是输出文件-f和--file的内容，但是会被 Bash 当作配置项解释。
这时就可以使用配置项参数终止符--，它的作用是告诉 Bash，在它后面的参数开头的-和--不是配置项，只能当作实体参数解释。
$ cat -- -f
$ cat -- --file
上面命令可以正确展示文件-f和--file的内容，因为它们放在--的后面，开头的-和--就不再当作配置项解释了。
如果要确保某个变量不会被当作配置项解释，就要在它前面放上参数终止符--。
$ ls -- $myPath
上面示例中，--强制变量$myPath只能当作实体参数（即路径名）解释。如果变量不是路径名，就会报错。
$ myPath="-l"
$ ls -- $myPath
ls: 无法访问'-l': 没有那个文件或目录
上面例子中，变量myPath的值为-l，不是路径。但是，--强制$myPath只能作为路径解释，导致报错“不存在该路径”。
下面是另一个实际的例子，如果想在文件里面搜索--hello，这时也要使用参数终止符--。
$ grep -- "--hello" example.txt
上面命令在example.txt文件里面，搜索字符串--hello。这个字符串是--开头，如果不用参数终止符，grep命令就会把--hello当作配置项参数，从而报错。
exit命令用于终止当前脚本的执行，并向 Shell 返回一个退出值。
$ exit
上面命令中止当前脚本，将最后一条命令的退出状态，作为整个脚本的退出状态。
exit命令后面可以跟参数，该参数就是退出状态。
# 退出值为0（成功）
$ exit 0
# 退出值为1（失败）
$ exit 1
退出时，脚本会返回一个退出值。脚本的退出值，0表示正常，1表示发生错误，2表示用法不对，126表示不是可执行脚本，127表示命令没有发现。如果脚本被信号N终止，则退出值为128 + N。简单来说，只要退出值非0，就认为执行出错。
下面是一个例子。
if [ $(id -u) != "0" ]; then
echo "根用户才能执行当前脚本"
exit 1
fi
上面的例子中，id -u命令返回用户的 ID，一旦用户的 ID 不等于0（根用户的 ID），脚本就会退出，并且退出码为1，表示运行失败。
exit与return命令的差别是，return命令是函数的退出，并返回一个值给调用者，脚本依然执行。exit是整个脚本的退出，如果在函数之中调用exit，则退出函数，并终止脚本执行。
命令执行结束后，会有一个返回值。0表示执行成功，非0（通常是1）表示执行失败。环境变量$?可以读取前一个命令的返回值。
利用这一点，可以在脚本中对命令执行结果进行判断。
cd /path/to/somewhere
if [ "$?" = "0" ]; then
rm *
else
echo "无法切换目录！" 1>&2
exit 1
fi
上面例子中，cd /path/to/somewhere这个命令如果执行成功（返回值等于0），就删除该目录里面的文件，否则退出脚本，整个脚本的返回值变为1，表示执行失败。
由于if可以直接判断命令的执行结果，执行相应的操作，上面的脚本可以改写成下面的样子。
if cd /path/to/somewhere; then
rm *
else
echo "Could not change directory! Aborting." 1>&2
exit 1
fi
更简洁的写法是利用两个逻辑运算符&&（且）和||（或）。
# 第一步执行成功，才会执行第二步
cd /path/to/somewhere && rm *
# 第一步执行失败，才会执行第二步
cd /path/to/somewhere || exit 1
source命令用于执行一个脚本，通常用于重新加载一个配置文件。
$ source .bashrc
source命令最大的特点是在当前 Shell 执行脚本，不像直接执行脚本时，会新建一个子 Shell。所以，source命令执行脚本时，不需要export变量。
#!/bin/bash
# test.sh
echo $foo
上面脚本输出$foo变量的值。
# 当前 Shell 新建一个变量 foo
$ foo=1
# 打印输出 1
$ source test.sh
1
# 打印输出空字符串
$ bash test.sh
上面例子中，当前 Shell 的变量foo并没有export，所以直接执行无法读取，但是source执行可以读取。
source命令的另一个用途，是在脚本内部加载外部库。
#!/bin/bash
source ./lib.sh
function_from_lib
上面脚本在内部使用source命令加载了一个外部库，然后就可以在脚本里面，使用这个外部库定义的函数。
source有一个简写形式，可以使用一个点（.）来表示。
$ . .bashrc
alias命令用来为一个命令指定别名，这样更便于记忆。下面是alias的格式。
alias NAME=DEFINITION
上面命令中，NAME是别名的名称，DEFINITION是别名对应的原始命令。注意，等号两侧不能有空格，否则会报错。
一个常见的例子是为grep命令起一个search的别名。
alias search=grep
alias也可以用来为长命令指定一个更短的别名。下面是通过别名定义一个today的命令。
$ alias today='date +"%A, %B %-d, %Y"'
$ today
星期一, 一月 6, 2020
有时为了防止误删除文件，可以指定rm命令的别名。
$ alias rm='rm -i'
上面命令指定rm命令是rm -i，每次删除文件之前，都会让用户确认。
alias定义的别名也可以接受参数，参数会直接传入原始命令。
$ alias echo='echo It says: '
$ echo hello world
It says: hello world
上面例子中，别名定义了echo命令的前两个参数，等同于修改了echo命令的默认行为。
指定别名以后，就可以像使用其他命令一样使用别名。一般来说，都会把常用的别名写在~/.bashrc的末尾。另外，只能为命令定义别名，为其他部分（比如很长的路径）定义别名是无效的。
直接调用alias命令，可以显示所有别名。
$ alias
unalias命令可以解除别名。
$ unalias lt
cvpr2021: https://arxiv.org/abs/2108.10257
代码：https://github.com/JingyunLiang/SwinIR
本文提出了一个基于Swin Transformer的用于图像恢复的强基线模型SwinIR，在图像超分辨率、去噪等任务上表现SOTA！
图像恢复是一个长期存在的低级视觉问题，旨在从低质量图像（例如，缩小、噪声和压缩图像）中恢复高质量图像.虽然最先进的图像恢复方法基于卷积神经网络，但很少有人尝试使用 Transformer，它们在high-level视觉任务中表现出令人印象深刻的性能。
在本文中，我们提出了一种基于 Swin Transformer 的强大基线模型 SwinIR 用于图像恢复。SwinIR由浅层特征提取、深层特征提取和高质量图像重建三部分组成。特别是，深度特征提取模块由几个残差 Swin Transformer 块 (RSTB) 组成，每个残差块都有几个 Swin Transformer 层和一个残差连接。我们对三个具有代表性的任务进行了实验：图像超分辨率（包括经典、轻量级和真实世界的图像超分辨率）、图像去噪（包括灰度和彩色图像去噪）和 JPEG 压缩伪影减少。实验结果表明，SwinIR 在不同任务上的表现优于最先进的方法高达 0.14 ∼ 0.45dB, 而参数的总数可以减少高达 67%.
网络结构：（感觉其实没啥创新点，就是用了swin block + 残差结构，但效果却挺好）
Shallow and deep feature extraction：3 ×3 convolutional layer
HQ Image Reconstruction：sub-pixel convolution layer or single
convolution layer
消融Ablation Study
实验结果表明，SwinIR 在不同任务上的性能优于最先进的方法高达 0.14∼0.45dB，而参数总数最多可减少 67%。
作者多了很多实验：
SR:Classical image SR Lightweight image SR 和Real-world image SR
JPEG compression artifact reduction
Image Denoising
结果：
