Introduction of Machine/Deep Learning

Different types of Functions

Regression(回归): The function outputs a scalar.

Classification(分类): Given options(classes), the function outputs the correct one.

Structure Learning: create something with structure(image,document).

Case Study: Prediction of no. of views of a YouTube Channel

1. Function with Unknow Parameters: ——Model

   

2. Define Loss from Training Data: L(b, w)——损失函数

   Loss is a function of parameters, it represents how good a set of values is.

   

   Loss: ——自行定义，可正可负

   $e=| y- | ——L$ is mean absolute error(MAE, 平均绝对误差)

   e = (y − ŷ)²——L is mean square error(MSE, 均方误差)

   if y and ŷ are both probability distributions——Cross-entropy(交叉熵)

   

3. Optimization: w^′, b^′ = argmin_w, bL

   Gradient Descent(梯度下降)：

   • (Randomly)Pick an initial value w⁰,b⁰
   • Compute ,
   • Update w and b iteratively(迭代)

   

Change Model: Piecewise Linear Function

Model Bias: 模型的局限性导致无法模拟真实的状况——need more sophisticated models

• Different w——Change slopes
• Different b——Shift
• Different c——Change height

New Model: $y=b+{i}c{i}sigmoid(b_{i}+{j}w{ij}x_{j}) $

• r = b + Wx
• a = σ(r)
• y = b + c^Ta
• All: y = b + c^Tσ(b + Wx)

if more hidden layer?——Neural Network——Deep Learning

Attention: the definition of Loss and Optimization of new Model is almost same as previous.

Homework 1: COVID-19 Cases Prediction

Code: link

结果：

What to do if my network fails to train

Local Minima & Saddle Point

Mathematical Principles

Tayler Series Approximation

L(θ) around θ = θ^′can be approximated below

Gradient g is a vector:

Hessian H is a matrix:

Hessian

When at critical point, (θ − θ^′)^Tg = 0, telling the properties of critical points.

Set θ − θ^′ = v:

H may tell us parameter update direction!

While u is an eigen vector of H, λ is the eigen value of u, u^THu = u^T(λu) = λ∥u∥²

Example: if u < 0, then H < 0, then L(θ) < L(θ^′) , θ = θ^′ + u, L can be decreased.

We can escape the saddle point and decrease the loss. However, this method is seldom used in practice.

Batch & Momentum

Small Batch v.s. Large Batch

• Larger batch size does not require longer time to compute gradient (unless batch size is too large)
• Smaller batch requires longer time for one epoch (longer time for seeing all data once)
• Smaller batch size has better performance in optimization
• “Noisy” update is better for training

Batch size is a hyperparameter you have to decide.

Gradient Descent + Momentum

• Movement: movement of last step minus gradient at present
• Movement not just based on gradient, but previous movement.

Example:

Summary

• Critical points have zero gradients.
• Critical points can be either saddle points or local minima.
  • Can be determined by the Hessian matrix.
  • Local minima may be rare.
  • It is possible to escape saddle points along the direction of eigen vectors of the Hessian matrix.
• Smaller batch size and momentum help escape critical points.

Adaptive Learning Rate

• People believe training stuck because the parameters are around a critical point, but sometimes learning rate may be the reason.
• While learning rate cannot be one-size-fits-all, so different parameters need different learning rate.

Consider update one parameter(t means iteration time, i means the ith parameter):

θ_i^t + 1 ← θ_i^t − ηg_i^t

While larger gradient needs smaller learning rate and smaller gradient needs larger learning rate, so learning rate has to be parameter dependent:

Root Mean Square

RMSProp

The recent gradient has larger influence, and the past gradients have less influence.

Learning Rate Scheduling

Learning Rate Decay

After the training goes, we are close to the destination, so we reduce the learning rate.

Warm Up

• Increase and then decrease.
• At the beginning, the estimate of σ_i^t has large variance.

Summary of Optimization

Classification

Classification as Regression

Softmax:

• 1 > y_i^′ > 0
• ∑_iy_i^′ = 1

The core function of Softmax is to normalize a model’s raw prediction scores (Logits) into a valid, interpretable probability distribution (all probabilities >=0 and sum=1), explicitly representing the model’s prediction confidence across multiple mutually exclusive classes.

Loss of Classification

Mean Square Error(MSE): e = ∑_i(ŷ_i − y_i^′)²

Cross-entropy: e =  − ∑_iŷ_ilny_i^′ (More Competitive)

Minimizing cross-entropy is equivalent to maximizing likelihood.

Changing the loss function can change the difficulty of optimization.

Case Study: Pokémon v.s. Digimon

• We want to find a function to classify Pokémon/Digimon
• Determine a function with unknown parameters(based on domain knowledge)

Observation

Function with Unknown Parameters

ℋ = {1, 2, ..., 10000}, |ℋ|: model “complexity”

Loss of a function (given data)

• Given a dataset 𝒟
  • 𝒟 = {(x¹, ŷ¹), (x², ŷ²), ..., (x^N, ŷ^N)}
• Loss of a threshold h given data set 𝒟
  • Error rate:
  • l(h, xⁿ, ŷⁿ) means I(f_h(xⁿ) ≠ ŷⁿ): if f_h(xⁿ) ≠ ŷⁿ, output 1, otherwise output 0.
  • Of course can choose cross entropy instead.

Training Examples

• If we can collect all Pokémons and Digimons in the universe 𝒟_all, we can find the best threshold h^all
  • h^all = 𝒶𝓇ℊmin_hL(h, 𝒟_all)
• We can only collect some examples 𝒟_train
  • 𝒟_{𝓉𝓇𝒶𝒾𝓃} = {(x¹, ŷ¹), (x², ŷ²), ..., (x^N, ŷ^N)}, (x^N, ŷ^N) ∼ 𝒟_all
  • h^train = 𝒶𝓇ℊmin_hL(h, 𝒟_train)
  • 𝒟_{𝓉𝓇𝒶𝒾𝓃} is independently and identically distributed ( i.i.d.)
• We hope L(h^train, 𝒟_all) and L(h^all, 𝒟_all) are close.
  • We want L(h^train, 𝒟_all) − L(h^all, 𝒟_all) ≤ δ
  • So 𝒟_train has to fulfill: ∀h ∈ ℋ, |L(h, 𝒟_train) − L(h, 𝒟_all)| ≤ ϵ, ϵ = δ/2

Probability of Failure

The following discussion is model-agnostic.

In the following discussion, we don’t have assumption about data distribution.

In the following discussion, we can use any loss function.

Each point is a training set.

Hoeffding’s Inequality:

Model Complexity

What if the parameters are continuous?

• Answer 1 : Everything that happens in a computer is discrete.
• Answer 2 : VC dimension

Why don’t we simply use a very small |ℋ| ?

• smaller |ℋ| means fewer candidates in h ∈ ℋ

Tradeoff of Model Complexity

How to find best balance? DEEP LEARNING.

Homework 2: Framewise phoneme prediction from speech

1. Data Preprocessing: Extract MFCC features from raw waveform
2. Classification: Perform framewise phoneme classification using pre-extracted MFCC features

Report Questions

1. Implement 2 models with approximately the same number of parameters, (A) one narrower and deeper (e.g. hidden_layers=6, hidden_dim=1024) and (B) the other wider and shallower (e.g. hidden_layers=2, hidden_dim=1700). Report training/validation accuracies for both models.

• hidden_layers=6, hidden_dim=1024: acc 0.47458
• hidden_layers=2, hidden_dim=1700: acc 0.47491

2. Add dropout layers, and report training/validation accuracies with dropout rates equal to (A) 0.25/(B) 0.5/(C) 0.75 respectively.

• 1. 0.25: acc 0.45756
• 2. 0.5: acc 0.44790
• 3. 0.75: acc 0.42627

合适的Dropout能够防止过拟合，Dropout过大反而会影响模型的准确率。

Code: link

结果：

Images Input

Convolutional Neural Network(CNN)

CNN is a Network Architecture designed for Image.

Simplification 1: Receptive Field

• Each receptive field has a set of neurons (e.g., 64 neurons).
• The receptive fields cover the whole image.

Simplification 2: Parameter Sharing

Two neurons with the same receptive field would not share parameters.

• Each receptive field has a set of neurons (e.g., 64 neurons).
• Each receptive field has the neurons with the same set of parameters.

Convolutional Layer

Consider channel = 1(black and white image):

The values in the filters are unknown parameters.

Do the same process for every filter, then we get the Feature Map.

Pooling

• Subsampling the pixels will not change the object.
• Max Pooling, Mean Pooling…

Summary

The Whole CNN

Homework 3: Image Classification

1. Solve image classification with convolutional neural networks.
2. Improve the performance with data augmentations.
3. Understand popular image model techniques such as residual.

Baseline

• Simple : 0.50099
• Medium : 0.73207 Training Augmentation + Train Longer
• Strong : 0.81872 Training Augmentation + Model Design + Train Looonger (+Cross Validation + Ensemble)
• Boss : 0.88446 Training Augmentation + Model Design +Test Time Augmentation + Train Looonger (+ Cross Validation + Ensemble)

Record

Simple Baseline

Just sample code

Medium Baseline

1. Training Augmentation

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

# Normally, We don't need augmentations in testing and validation.
# All we need here is to resize the PIL image and transform it into Tensor.
test_tfm = transforms.Compose([
    transforms.Resize((128, 128)),
    transforms.ToTensor(),
])

# However, it is also possible to use augmentation in the testing phase.
# You may use train_tfm to produce a variety of images and then test using ensemble methods
train_tfm = transforms.Compose([
    # Resize the image into a fixed shape (height = width = 128)
    transforms.Resize((128, 128)),
    # You may add some transforms here.
    # 95%概率做随机增强（TrivialAugmentWide），10%概率保持原图.
    transforms.RandomChoice(transforms=[
        # Apply TrivialAugmentWide data augmentation method
        transforms.TrivialAugmentWide(),

        # Return original image
        transforms.Lambda(lambda x: x),
    ],
                            p=[0.95, 0.05]),
    # ToTensor() should be the last one of the transforms.
    transforms.ToTensor(),
])

2. Configuration

1
2
3
4
5

# The number of training epochs and patience.
n_epochs = 20
patience = 10 # If no improvement in 'patience' epochs, early stop

optimizer = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=1e-5) 

增加epoch就可以达到baseline，但是colab的时限到了。

Strong Baseline

采用ReduceLROnPlateau, 验证集指标无提升时自动降低lr

1
2
3
4
5

# Initialize optimizer, you may fine-tune some hyperparameters such as learning rate on your own.
optimizer = torch.optim.Adam(model.parameters(), lr=3e-4, weight_decay=1e-5)
scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.8, patience=patience/2,threshold=0.05)
# 在每个epoch验证后加上
scheduler.step(best_acc)

完整Code：link

结果：

Self-attention

Basic Mechanism

• α_1, i^′ = exp(α_1, i)/∑_jexp(α_1, j)
• b¹ = ∑_iα_1, i^′vⁱ

Summary:

• Q = W^qI, K = W^kI, V = W^vI
• A = K^TQ, A^′ = SoftMax(A)
• O = VA^′
• W^q , W^k and W^v​ are parameters to be learned.

Multi-head Self-attention

Positional Encoding

• No position information in self-attention.
• Each position has a unique positional vector eⁱ
• hand-crafted
• learned from data

Homework 4: Speaker Identification

Task: Multiclass Classification

Predict speaker class from given speech.

Simple Baseline

• Build a self-attention network to classify speakers with sample code.
• Simple public baseline: 0.66025
• Estimate training time: 30~40 mins on Colab.

Output:

Medium Baseline

• Modify the parameters of the transformer modules in the sample code.
• Medium public baseline: 0.81750

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Classifier(nn.Module):
	def __init__(self, d_model=512, n_spks=600, dropout=0.2):
		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.08100
		self.encoder_layer = nn.TransformerEncoderLayer(
			d_model=d_model, dim_feedforward=256, nhead=32
		)
		self.encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=2)

		# Project the the dimension of features from d_model into speaker nums.
		self.pred_layer = nn.Sequential(
			nn.Linear(d_model, 2 * d_model),
			nn.ReLU(),
			nn.Dropout(dropout),
			nn.Linear(2 * d_model, n_spks),
		)

Output:

Strong Baseline

• Construct Conformer, which is a variety of Transformer.
• Strong public baseline: 0.88500

Output:

Code: link

Boss Baseline

• Implement Self-Attention Pooling & Additive Margin Softmax to further boost the performance.
• Self-Attention Pooling.
• Boss baseline : 0.93175

实际上我把epoch放大到200,000就达到了Boss Baseline.

Output:

Sequence to sequence (Seq2seq)

• Input a sequence, output a sequence.
• The output length is determined by model.

Batch Normalization

ẑⁱ = γ⨀z̃ⁱ + β

How Does Batch Normalization Help Optimization?

Experimental results (and theoretically analysis) support batch normalization change the landscape of error surface.

Transformer

the Applications of Seq2seq

1. Chatbot

2. Question Answering

3. Syntactic Parsing

4. Multi-label Classification

The Architecture of Transformer

Encoder

Multi-Head Attention + Residue&Layer Norm + Fully-connected Network + Residue&Layer Norm

Decoder

1. Autoregressive (AT): 自回归

Speech Recognition as example

Masked Self attention

Adding “Stop Token”

2. Non-autoregressive (NAT)

• How to decide the output length for NAT decoder?
  • Another predictor for output length
  • Output a very long sequence, ignore tokens after END
• Advantage: parallel, more stable generation (e.g., TTS)
• NAT is usually worse than AT (why? Multi-modality)

Training

The Decoder’s Input is different between Training process and Testing process.

Self-attention Variances

Fixed Pattern

Window Attention, Stride Attention, Global Attention…

Learnable Patterns

make Machine learn how to choose patterns.

Clustering

Sinkhorn Sorting Network

simplified version

Reduce Number of Keys

Compressed Attention

Linformer

Change the order of matrix multiplication

Homework 5: Machine Translation

• In this homework, we’ll translate English to Traditional Chinese.
• Since sentences are with different length in different languages, the seq2seq framework is applied to this task.

Training datasets

• Paired data
  • TED2020: TED talks with transcripts translated by a global community of volunteers to more than 100 language
  • We will use (en, zh-tw) aligned pairs
• Monolingual data(单语言数据)
  • More TED talks in traditional Chinese

Evaluation

• Modified n-gram precision (n = 1~4), N is the maximum value of n

• Brevity penalty: penalizes short hypotheses

  

  • c is the hypothesis length, r is the reference length.

• p_n is the precision of n-gram

  

Workflow

1. Preprocessing
   • download raw data
   • clean and normalize
   • remove bad data (too long/short)
   • tokenization
2. Training
   • initialize a model
   • train it with training data
3. Testing
   • generate translation of test data
   • evaluate the performance

Baselines

HW05是在 Judgeboi 上提交的，因此无法得到具体的分数，仅给出修改的代码。

PS：由于无法在 Judgeboi 上提交，所以原本打算得出在验证集上的分数，但是遇到了一个暂时无法解决的bug。

Simple Baseline

Running the sample code

Medium Baseline

Add learning rate scheduler and train longer

1
2
3
4
5
6

import math

def get_rate(d_model, step_num, warmup_step):
    # TODO: Change lr from constant to the equation shown above
    lr = 1.0 / math.sqrt(d_model) * min(1.0 / math.sqrt(step_num), step_num / (warmup_step * math.sqrt(warmup_step)))
    return lr

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

config = Namespace(
    datadir = "./DATA/data-bin/ted2020",
    savedir = "./checkpoints/rnn",
    source_lang = src_lang,
    target_lang = tgt_lang,

    # cpu threads when fetching & processing data.
    num_workers=2,
    # batch size in terms of tokens. gradient accumulation increases the effective batchsize.
    max_tokens=8192,
    accum_steps=2,

    # the lr s calculated from Noam lr scheduler. you can tune the maximum lr by this factor.
    lr_factor=2.,
    lr_warmup=4000,

    # clipping gradient norm helps alleviate gradient exploding
    clip_norm=1.0,

    # maximum epochs for training (Medium)
    max_epoch=30,
    start_epoch=1,

    # beam size for beam search
    beam=5,
    # generate sequences of maximum length ax + b, where x is the source length
    max_len_a=1.2,
    max_len_b=10,
    # when decoding, post process sentence by removing sentencepiece symbols and jieba tokenization.
    post_process = "sentencepiece",

    # checkpoints
    keep_last_epochs=5,
    resume=None, # if resume from checkpoint name (under config.savedir)

    # logging
    use_wandb=False,
)

Strong Baseline

Switch to Transformer and tuning hyperparameter

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# # HINT: transformer architecture
from fairseq.models.transformer import (
    TransformerEncoder,
    TransformerDecoder,
)

def build_model(args, task):
    """ build a model instance based on hyperparameters """
    src_dict, tgt_dict = task.source_dictionary, task.target_dictionary

    # token embeddings
    encoder_embed_tokens = nn.Embedding(len(src_dict), args.encoder_embed_dim, src_dict.pad())
    decoder_embed_tokens = nn.Embedding(len(tgt_dict), args.decoder_embed_dim, tgt_dict.pad())

    # encoder decoder
    # HINT: TODO: switch to TransformerEncoder & TransformerDecoder
    # encoder = RNNEncoder(args, src_dict, encoder_embed_tokens)
    # decoder = RNNDecoder(args, tgt_dict, decoder_embed_tokens)
    encoder = TransformerEncoder(args, src_dict, encoder_embed_tokens)
    decoder = TransformerDecoder(args, tgt_dict, decoder_embed_tokens)

    # sequence to sequence model
    model = Seq2Seq(args, encoder, decoder)

    # initialization for seq2seq model is important, requires extra handling
    def init_params(module):
        from fairseq.modules import MultiheadAttention
        if isinstance(module, nn.Linear):
            module.weight.data.normal_(mean=0.0, std=0.02)
            if module.bias is not None:
                module.bias.data.zero_()
        if isinstance(module, nn.Embedding):
            module.weight.data.normal_(mean=0.0, std=0.02)
            if module.padding_idx is not None:
                module.weight.data[module.padding_idx].zero_()
        if isinstance(module, MultiheadAttention):
            module.q_proj.weight.data.normal_(mean=0.0, std=0.02)
            module.k_proj.weight.data.normal_(mean=0.0, std=0.02)
            module.v_proj.weight.data.normal_(mean=0.0, std=0.02)
        if isinstance(module, nn.RNNBase):
            for name, param in module.named_parameters():
                if "weight" in name or "bias" in name:
                    param.data.uniform_(-0.1, 0.1)

    # weight initialization
    model.apply(init_params)
    return model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Follow transformer-base 
arch_args = Namespace(
    encoder_embed_dim=256,
    encoder_ffn_embed_dim=512,
    encoder_layers=1,
    decoder_embed_dim=256,
    decoder_ffn_embed_dim=1024,
    decoder_layers=1,
    share_decoder_input_output_embed=True,
    dropout=0.3,
)

# HINT: these patches on parameters for Transformer
def add_transformer_args(args):
    args.encoder_attention_heads=4
    args.encoder_normalize_before=True

    args.decoder_attention_heads=4
    args.decoder_normalize_before=True

    args.activation_fn="relu"
    args.max_source_positions=1024
    args.max_target_positions=1024

    # patches on default parameters for Transformer (those not set above)
    from fairseq.models.transformer import base_architecture
    base_architecture(arch_args)

add_transformer_args(arch_args)

Boss Baseline

Apply back-translation

1. Train a backward model by switching languages

   

2. Translate monolingual data with backward model to obtain synthetic data

   • Complete TODOs in the sample code
   • All the TODOs can be completed by using commands from earlier cells

3. Train a stronger forward model with the new data

   • If done correctly, 30 epochs on new data should pass the baseline

Configuration for experiments

1. Set BACK_TRANSLATION to True in the configuration for experiments and run. Train a back-translation model and process the corresponding corpus.
2. Set BACK_TRANSLATION to False in the configuration for experiments and run. Train with the corpus of ted2020 and mono (back-translation).

1
2
3
4
5

BACK_TRANSLATION = False 
if BACK_TRANSLATION:
    config.datadir = "./DATA/data-bin/ted2020"
    config.savedir = "./checkpoints/transformer-back"
    config.source_lang, config.target_lang= tgt_lang, src_lang

Model Initialization

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

# # HINT: transformer architecture
from fairseq.models.transformer import (
    TransformerEncoder,
    TransformerDecoder,
)

def build_model(args, task):
    """ build a model instance based on hyperparameters """
    src_dict, tgt_dict = task.source_dictionary, task.target_dictionary

    # token embeddings
    encoder_embed_tokens = nn.Embedding(len(src_dict), args.encoder_embed_dim, src_dict.pad())
    decoder_embed_tokens = nn.Embedding(len(tgt_dict), args.decoder_embed_dim, tgt_dict.pad())

    # encoder decoder
    # HINT: TODO: switch to TransformerEncoder & TransformerDecoder
    # encoder = RNNEncoder(args, src_dict, encoder_embed_tokens)
    # decoder = RNNDecoder(args, tgt_dict, decoder_embed_tokens)
    encoder = TransformerEncoder(args, src_dict, encoder_embed_tokens)
    decoder = TransformerDecoder(args, tgt_dict, decoder_embed_tokens)

    # sequence to sequence model
    model = Seq2Seq(args, encoder, decoder)

    # initialization for seq2seq model is important, requires extra handling
    def init_params(module):
        from fairseq.modules import MultiheadAttention
        if isinstance(module, nn.Linear):
            module.weight.data.normal_(mean=0.0, std=0.02)
            if module.bias is not None:
                module.bias.data.zero_()
        if isinstance(module, nn.Embedding):
            module.weight.data.normal_(mean=0.0, std=0.02)
            if module.padding_idx is not None:
                module.weight.data[module.padding_idx].zero_()
        if isinstance(module, MultiheadAttention):
            module.q_proj.weight.data.normal_(mean=0.0, std=0.02)
            module.k_proj.weight.data.normal_(mean=0.0, std=0.02)
            module.v_proj.weight.data.normal_(mean=0.0, std=0.02)
        if isinstance(module, nn.RNNBase):
            for name, param in module.named_parameters():
                if "weight" in name or "bias" in name:
                    param.data.uniform_(-0.1, 0.1)

    # weight initialization
    model.apply(init_params)
    return model

Architecture Related Configuration

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

arch_args = Namespace(
    encoder_embed_dim=512,
    encoder_ffn_embed_dim=2048,
    encoder_layers=6,
    decoder_embed_dim=512,
    decoder_ffn_embed_dim=2048,
    decoder_layers=6,
    share_decoder_input_output_embed=True,
    dropout=0.3,
)

# HINT: these patches on parameters for Transformer
def add_transformer_args(args):
    args.encoder_attention_heads=8
    args.encoder_normalize_before=True

    args.decoder_attention_heads=8
    args.decoder_normalize_before=True

    args.activation_fn="relu"
    args.max_source_positions=1024
    args.max_target_positions=1024

    # patches on default parameters for Transformer (those not set above)
    from fairseq.models.transformer import base_architecture
    base_architecture(arch_args)

add_transformer_args(arch_args)

Back-translation

TODO: clean corpus

1. remove sentences that are too long or too short
2. unify punctuation

hint: you can use clean_s() defined above to do this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def clean_mono_corpus(prefix, l, ratio=9, max_len=1000, min_len=1):
    if Path(f'{prefix}.clean.zh').exists():
        print(f'{prefix}.clean.zh exists. skipping clean.')
        return
    with open(f'{prefix}', 'r') as l_in_f:
        with open(f'{prefix}.clean.zh', 'w') as l_out_f:
            for s in l_in_f:
                s = s.strip()
                s = clean_s(s, l)
                s_len = len_s(s, l)
                if min_len > 0: # remove short sentence
                    if s_len < min_len:
                        continue
                if max_len > 0: # remove long sentence
                    if s_len > max_len:
                        continue
                print(s, file=l_out_f)
                

mono_data_prefix = f'{mono_prefix}/ted_zh_corpus.deduped'
clean_mono_corpus(mono_data_prefix, 'zh')

TODO: Subword Units

Use the spm model of the backward model to tokenize the data into subword units

hint: spm model is located at DATA/raw-data/dataset/spm[vocab_num].model

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def spm_encode(prefix, vocab_size, mono_prefix):
    spm_model = spm.SentencePieceProcessor(model_file=str(prefix/f'spm{vocab_size}.model'))

    in_path = mono_prefix / 'ted_zh_corpus.deduped.clean'

    for lang in [src_lang, tgt_lang]:
        out_path = mono_prefix / f'mono.tok.{lang}'
        if out_path.exists():
            print(f"{out_path} exists. skipping spm_encode.")
        else:
        with open(out_path, 'w') as out_f:
            with open(f'{in_path}.{lang}', 'r') as in_f:
                for line in in_f:
                    line = line.strip()
                    tok = spm_model.encode(line, out_type=str)
                    print(' '.join(tok), file=out_f)

TODO: Generate synthetic data with backward model

Add binarized monolingual data to the original data directory, and name it with “split_name”

ex. ./DATA/data-bin/ted2020/[split_name].zh-en.[“en”, “zh”].[“bin”, “idx”]

then you can use ‘generate_prediction(model, task, split=“split_name”)’ to generate translation prediction

1
2
3

# hint: do prediction on split='mono' to create prediction_file
task.load_dataset(split="mono", epoch=1)
generate_prediction(model, task, split='mono', outfile='./prediction.txt' )

TODO: Create new dataset

1. Combine the prediction data with monolingual data
2. Use the original spm model to tokenize data into Subword Units
3. Binarize data with fairseq

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# Combine prediction_file (.en) and mono.zh (.zh) into a new dataset.
#
# hint: tokenize prediction_file with the spm model
!cp ./prediction.txt {mono_prefix}/'ted_zh_corpus.deduped.clean.en'
spm_encode(prefix, vocab_size, mono_prefix)
# spm_model.encode(line, out_type=str)
# output: ./DATA/rawdata/mono/mono.tok.en & mono.tok.zh
#
# hint: use fairseq to binarize these two files again
binpath = Path('./DATA/data-bin/synthetic')
src_dict_file = './DATA/data-bin/ted2020/dict.en.txt'
tgt_dict_file = src_dict_file
monopref = ./DATA/rawdata/mono/mono.tok # or whatever path after applying subword tokenization, w/o the suffix (.zh/.en)
if binpath.exists():
     print(binpath, "exists, will not overwrite!")
else:
     !python -m fairseq_cli.preprocess\
         	--source-lang 'zh'\
         	--target-lang 'en'\
         	--trainpref {monopref}\
	        --destdir {binpath}\
	        --srcdict {src_dict_file}\
            --tgtdict {tgt_dict_file}\
	        --workers 2

Generative Adversarial Network(GAN)

Distribution makes the same input has different outputs, especially for the tasks needs “creativity”.

Unconditional Generation

Take Anime Face Generation as an example.

Discriminator

• Discriminator is a neural network. In this example, the input is an image, the output is a Scalar. Larger scalar means real, smaller value fake.

Basic Idea of GAN

This is where the term “adversarial” comes from.

Algorithm

• Initialize Generator and Discriminator

• In each training iteration:

  1. Fix generator G, and update discriminator D.
     • Discriminator learns to assign high scores to real objects and low scores to generated objects.
  2. Fix discriminator D, and update generator G.
     • Generator learns to “fool” the Discriminator.

  

Theory behind GAN

Our Objective

• G^⋆ = arg min_G Div(P_G, P_data)
• Div(P_G, P_data) is Divergence between distributions P_G and P_data
• How to compute the divergence?

Training: D_⋆ = arg max_DV(D, G), The value of max_DV(D, G) is related to JS divergence(JS散度).

Objective Function for D: V(G, D) = E_{y ∼ Pdata}[logD(y)] + E_y ∼ PG[log(1 − D(y))]

the V(D, G) is negative cross entropy, so D_⋆ = arg max_DV(D, G) is equal to minimizing cross entropy in Training classifier.

Other divergence can also be used, not just JS divergence.

Tips for GAN

• JS divergence is not suitable, because in most cases, P_G and P_data are not overlapped.
• Intuition: If two distributions do not overlap, binary classifier achieves 100% accuracy.
• Its accuracy (or loss) means nothing during GAN training.

Wasserstein distance

• Considering one distribution P as a pile of earth, and another distribution Q as the target.
• The average distance the earth mover has to move the earth.

There are many possible “moving plans”. Using the “moving plan” with the smallest average distance to define the Wasserstein distance.

WGAN

• Evaluate Wasserstein distance between P_data and P_G:
• D ∈ 1 − Lipschitz means D has to be smooth enough. If without the constraint, the training of D will not converge. So we need to Keep the D smooth forces D(x) become ∞ and −∞.

Evaluation of Generation

Human evaluation is expensive and sometimes unfair/unstable. How to evaluate the quality of the generated images automatically?

Problems

Mode Collapse

生成器（Generator）只能生成数据分布中的极少数模式（mode），而无法覆盖全部真实数据的多样性。例如，训练一个生成人脸图像的GAN时，如果发生模式坍塌，生成器可能只会输出同一张脸或少数几张脸，而无法生成其他不同的人脸。

Mode Dropping

生成器部分忽略真实数据分布中的某些模式（mode），导致生成样本的多样性不足，但尚未完全坍塌到极少数模式。与Mode Collapse（模式坍塌） 相比，Mode Dropping是更轻微的多样性缺失问题——生成器可能覆盖了大部分真实数据的模式，但仍遗漏了一些子类别或变体。相比于Mode Collapse，Mode Dropping更难被察觉。

Inception Score(IS)

Good quality,large diversity means large IS.

• 高质量图像应被预训练的分类模型明确分类
• 多样性高的生成集应覆盖多个类别
• IS = ∑_x∑_yP(y|x)logP(y|x) − ∑_yP(y)logP(y)

Fréchet Inception Distance (FID)

• Smaller is better.

• A lot of samples is needed.

More Evaluations

Pros and cons of GAN evaluation measures:https://arxiv.org/abs/1802.03446

Conditional Generation

Text-to-image

Image translation(pix2pix)

Sound-to-image

While sound becomes louder…

Talk Head Generation

Learning from Unpaired Data

Unsupervised Conditional Generation can learn the mapping without any paired data.

Cycle GAN

无需成对训练数据，即可实现不同域（domain）之间的风格转换。

1. 循环一致性（Cycle Consistency）:确保从域A转换到域B后，再转换回域A的图像与原始图像尽可能一致，解决了无监督训练中“模式坍塌”和“无配对数据”的挑战。
2. 对抗损失（Adversarial Loss）：使用两个生成器和两个判别器，分别判断生成图像是否属于目标域。

Other Application

Homework 6: Anime face generation

Task introduction

1. Input: random number
2. Output: Anime face
3. Implementation requirement: DCGAN & WGAN & WGAN-GP
4. Target: generate 1000 anime face images

Evaluation metrics

FID (Fréchet Inception Distance) score

1. Use another model to create features for real and fake images
2. Calculate the Fréchet distance between distribution of two features

AFD (Anime face detection) rate

1. To detect how many anime faces in your submission
2. The higher, the better

Dataset

Crypko 1. Dataset link is in the colab 2. Dataset format 3. There are 71,314 pictures in the folder 4. You can use additional data to increase the performance

Baselines

Useful information

DCGAN

1. Sample code implementation
2. Use several conv layers to generate image

WGAN & WGAN-GP

1. WGAN: Modify from DCGAN

1. Remove the last sigmoid layer from the discriminator.
2. Do not take the logarithm when calculating the loss.
3. Clip the weights of the discriminator to a constant (1 ~ -1).
4. Use RMSProp or SGD as the optimizer.
5. link

2. WGAN-GP: Modify from WGAN

1. Use gradient penalty to replace weight clipping
2. Gradient penalty accumulate gradient from an interpolated image
3. link

StyleGAN

1. First transform latent variable z to w
2. Use w in different stage in generator(Deal with different resolutions)
3. Useful link

Simple Baseline

Run sample code.

Output:

Medium Baseline

Use WGAN with more epochs

Code: link

Output:

Strong Baseline

Use WGAN-GP

Code: link

Output:

Self-Supervised Learning

​ In self-supervised learning, the system learns to predict part of its input from other parts of it input. In other words a portion of the input is used as a supervisory signal to a predictor fed with the remaining portion of the input.

在自监督学习中，系统学习如何根据输入的其他部分来预测输入的一部分。换句话说，输入的某一部分被用作监督信号，提供给一个由输入剩余部分所馈送的预测器。

BERT series

参考文献：

• BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding

Masking Input

BERT 的核心思想之一是 双向上下文建模。传统的语言模型（如 ELMo）通常是单向的（从左到右或从右到左），只能根据前面的词预测后面的词，或反之。BERT 旨在让模型能够同时利用词语左右两侧的全部上下文信息来理解词语本身的意义和角色。Masked Language Modeling (MLM) 任务就是为了实现这个目标而设计的。

Masking Input 发生在 BERT 的 预训练 (Pre-training) 阶段。其过程可以分解为以下几个步骤：

1. 输入句子准备：
   • 输入通常是一个或两个句子（对于 Next Sentence Prediction 任务）。
   • 句子被分割成更小的单元，通常是 WordPieces 或 subwords (例如，“playing” -> ["play", "##ing"])。这是为了解决词汇表过大和未登录词(OOV)问题。
   • 句子前后会添加特殊的标记：[CLS] (分类) 在句首，[SEP] (分隔) 在句尾（或两个句子之间）。
2. 随机选择遮盖目标：
   • 对输入序列中的所有 token（除了 [CLS] 和 [SEP] 等特殊标记），随机选择大约 15% 的 token 作为需要进行预测的目标。这个比例是经过实验确定的平衡点：太低则学习信号不足，太高则破坏了句子的上下文，导致学习困难。
   • 举例：假设输入句子是 "The quick brown fox jumps over the lazy dog"。可能选中的目标 token 是 "brown", "fox", "the"（后一个）。
3. 执行遮盖操作：
   • 对被选中的这 15% 的 token，进行具体的遮盖处理。这里 不是简单地用一个固定的 “MASK” 替换所有选中 token。BERT 采用了更精细的策略：
     • 80% 的概率： 将这个 token 替换成特殊的 [MASK] 标记。这是最典型的“遮盖”操作。
     • 10% 的概率： 将这个 token 替换成一个 随机 的 token（从整个词汇表中随机采样）。
     • 10% 的概率： 保持不变，即保留原始的 token。

实行这种策略的原因推测：

• 80% MASK： 强制模型学习利用完整的上下文来预测被遮盖位置的真正内容。这是任务的核心。
• 10% 随机替换： 防止模型过于依赖“[MASK]”标记本身的存在。因为在微调(Fine-tuning) 阶段处理真实数据时，输入中是不会出现 [MASK] 的。如果模型在预训练时只见过 [MASK]，它会觉得微调时遇到的真实单词（未被遮盖的）都是“新东西”或与训练信号无关。加入随机替换让模型学会“这个位置可能是任何词，我需要基于上下文来猜”。
• 10% 保持不变： 提供一种“一致性”信号。模型知道某些时候选中了要预测，但其实词是对的（因为没被修改），这有助于模型学习对未被遮盖词的表示也保持准确和稳定，并训练模型理解上下文即使不需要修改目标词也有效。

4. 模型输入：
   • 最终，这个经过遮盖操作处理后的序列（可能包含 [MASK], 随机词, 原始词）被送入 BERT 的 Transformer Encoder。
   • 模型在处理这个序列时，知道哪些位置是被选中需要预测的（这些位置在计算损失时会用到）。
5. 模型预测：
   • BERT 模型（多层 Transformer Encoder）基于输入序列中 所有 token 的双向上下文，计算出序列中每个位置的 上下文嵌入(Contextual Embedding)。
   • 对于 所有被选中（遮盖、随机替换、保持原样）的 token 的位置，模型会将对应位置的顶层输出向量（即该位置的上下文表示）送入一个额外的 Softmax 分类层。
   • 这个分类层的作用是：预测该位置原始未被修改的 token 是什么。
   • 模型不会预测未被选中的位置（那 85%）。
6. 损失计算：
   • 损失函数通常是标准的 交叉熵损失(Cross-Entropy Loss)。
   • 损失的计算 仅针对那些在步骤 2 中被选中的 token 的位置（即那 15%）。
   • 对于每个这样的位置，模型预测该位置原始 token 在整个词汇表上的概率分布，损失就是该分布与目标分布（即原始 token 的 one-hot 向量）之间的交叉熵。
   • 将所有被选中位置的损失求和，得到最终的目标函数用于更新模型参数。

通过人为遮蔽部分输入并迫使模型基于完整上下文进行复原，驱动模型学习通用的、强大的、双向的深度语言理解能力，为后续在各种下游任务的微调打下了坚实的基础。

Next Sentence Prediction

Goal

很多重要的下游任务（如问答QA、自然语言推理NLI、文本蕴含Textual Entailment）都需要模型理解句子之间的关系。MLM 任务主要是学习词级别或短语级别的语境理解，但缺乏明确训练模型掌握跨句子连贯性的能力。NSP 就是为了弥补这一点而被设计出来的。

Theory

NSP 是一个二分类任务。在预训练阶段，BERT 的输入由两个片段 Sentence A 和 Sentence B 组成。模型需要判断：Sentence B 是不是 Sentence A 在原始文本中的实际下一句（即它们在上下文中是连贯、有逻辑顺序的）？

• 标签 IsNext (正例)： Sentence B 是 Sentence A 在原始文档中真实的后续句子。
• 标签 NotNext (负例)： Sentence B 是随机从语料库中挑选出来的一个句子，与 Sentence A 在语义和逻辑上没有连贯关系。

通过迫使模型区分这两种情况，BERT 学习捕捉句子间的各种关系，如因果关系、转折关系、顺承关系等，并理解句子组合的整体含义。

Process

1. 输入构造：

   • Sentence A：通常是取语料库中的一个完整句子或文本片段。

   • Sentence B 存在两种情况：

     • 正例 (50% 的概率)： Sentence B 就是从原始文档中紧接着 Sentence A 的下一个句子。
     • 负例 (50% 的概率)： Sentence B 是从语料库中随机挑选出来的一个句子（通常来自与 Sentence A 不同的文档）。关键点是它与 Sentence A 没有上下文关联。

   • 标记符：

     • [CLS]： 放在整个输入序列的最开头。

     • [SEP]： 放在 Sentence A 和 Sentence B 之间，用于分隔两个句子。如果输入只有 Sentence A（如某些分类任务），则 [SEP] 放在句尾。

2. 模型输入：

   • 最终的输入序列是： [CLS] + Token_1^A + Token_2^A + ... + [SEP] + Token_1^B + Token_2^B + ... + [SEP]
   • 除了单词 token 的嵌入（Token Embeddings），BERT 的输入嵌入还包括：
     • 段落嵌入 (Segment Embeddings): 用于区分 Sentence A 和 Sentence B。所有属于 Sentence A 的 token 分配一个段嵌入类型（比如 0），所有属于 Sentence B 的 token 分配另一个段嵌入类型（比如 1）。[CLS] 和 [SEP] 通常也按位置或段逻辑分配。
     • 位置嵌入 (Position Embeddings): 表示每个 token 在序列中的位置信息。

3. 模型处理：

   • 这个构造好的输入序列（包含 token 嵌入、段嵌入、位置嵌入）被送入 BERT 的 Transformer Encoder。
   • Transformer Encoder 处理整个序列，为输入序列中的 每个位置（包括每个 token 和 [CLS]）输出一个上下文感知的向量表示。

4. NSP 预测：

   • NSP 任务的预测只依赖于特殊标记 [CLS] 对应的输出向量 C。
   • 将这个向量 C 送入一个额外的 分类层（Classification Layer），通常是一个 Linear + Softmax 层。
   • 这个分类层将C映射成一个维度为 2 的向量，代表两个类别的概率：
     • P(IsNext | A, B)： Sentence B 是 Sentence A 的下一句的概率。
     • P(NotNext | A, B)： Sentence B 不是 Sentence A 的下一句的概率。

5. 损失计算：

   • 目标函数就是标准的 二元交叉熵损失 (Binary Cross-Entropy Loss)。
   • 损失基于模型对 [CLS] 位置输出的预测概率和真实标签 (IsNext 或 NotNext) 进行计算。
   • 这个损失与 MLM 任务的损失（基于被遮盖位置的预测）相加，作为 BERT 预训练的总损失，用于更新整个模型的参数。

Problem

• This approach is not helpful.

  Robustly optimized BERT approach RoBERTa: https://arxiv.org/abs/1907.11692

  RoBERTa 发现，去掉 NSP 任务并且只使用更大的 batch size 和更多的数据训练 MLM，反而在多项任务上取得了更好的效果。他们认为 NSP 任务可能不够有挑战性，负例（随机选下一句）太容易被区分（正例来自同一文档，负例来自不同文档，模型可能主要区分文档来源，而不是精细的语义连贯性）。

• SOP : Sentence order prediction

  Used in ALBERT: https://arxiv.org/abs/1909.11942

  它不区分句子是否来自同一文档，而是关注句子顺序逻辑。

  • 正例： 两个连续句子按原始顺序呈现 (Sentence A, True Next B)。
  • 负例： 将相同的两个句子交换顺序呈现 (Sentence B 变成了第一句，Sentence A 变成了第二句)。
  • 任务变为判断句子顺序是否正确。这要求模型理解句子间的内在因果关系、时间顺序等，比区分是否来自同一文档更具挑战性。实验表明 SOP 通常比 NSP 更有效。

Benchmark

General Language Understanding Evaluation (GLUE): CLUE中文语言理解基准测评

•Corpus of Linguistic Acceptability ( CoLA •Stanford Sentiment Treebank (SST 2) •Microsoft Research Paraphrase Corpus (MRPC) •Quora Question Pairs (QQP) •Semantic Textual Similarity Benchmark (STS B) •Multi Genre Natural Language Inference (MNLI) •Question answering NLI (QNLI) •Recognizing Textual Entailment (RTE) •Winograd NLI (WNLI)

How to use BERT

Sentiment analysis

POS tagging

Natural Language Inference (NLI)

Extraction based Question Answering (QA)

Other Research

BERT Embryology

Based on the BERT Embryology (胚胎学)，When does BERT know POS tagging（语义标注）, syntactic parsing（语法分析）, semantics（语义理解）?

link

由论文可知，重建（reconstruction）结果如图1(a)所示。ALBERT首先学习重建功能词（function words），例如限定词（determiners）、介词（prepositions），随后逐步按动词→副词→形容词→名词→专有名词的顺序学习重建实义词（content words）。动词的不同形式和时态具有差异化学习进程：第三人称单数现在时（third-person singular present）重建最为容易，而现在分词（present participle）重建难度最高。图1(b)的预测（prediction）结果表明，掩码预测的学习难度普遍高于令牌重建。ALBERT预测掩码令牌的顺序虽与重建相似，但速度显著较慢且准确率更低。

论文选择了四类探针任务（probing tasks）进行实验：词性标注（POS tagging）、成分标记（constituent tagging）、共指消解（coreference resolution） 和语义角色标注（semantic role labeling）。前两项任务用于探测标记嵌入（token embeddings）中隐含的语法知识（syntactic knowledge），后两项任务则旨在检测标记嵌入所承载的语义知识（semantic knowledge）。

实验结果如图2所示。可以观察到所有四项任务在预训练期间呈现相似趋势，表明语法知识与语义知识在预训练过程中同步发展。具体而言：

1. 语法相关任务（POS标注与成分标记）：
   • 在前10万步快速提升性能
   • 后续训练中不再显著改善，且表现持续波动
2. 语义角色标注（SRL）的异常现象：
   • 约15万步达到性能峰值
   • 此后逐步衰减
   • 这一现象可能表明，当ALBERT模型致力于优化预训练目标时，特定网络层中与任务相关的信息会逐渐减少（信息衰减机制）。

MASS/BART

MASS: Masked Sequence to Sequence Pre-training for Language Generation

MASS is based on the sequence to sequence learning framework: its encoder takes a sentence with a masked fragment (several consecutive tokens) as input, and its decoder predicts this masked fragment conditioned on the encoder representations. Unlike BERT or a language model that pre-trains only the encoder or decoder, MASS is carefully designed to pre-train the encoder and decoder jointly in two steps: 1) By predicting the fragment of the sentence that is masked on the encoder side, MASS can force the encoder to understand the meaning of the unmasked tokens, in order to predict the masked tokens in the decoder side; 2) By masking the input tokens of the decoder that are unmasked in the source side, MASS can force the decoder rely more on the source representation other than the previous tokens in the target side for next token prediction, better facilitating the joint training between encoder and decoder.

该方法基于序列到序列学习框架：其编码器接收带有掩码片段（若干连续词元）的句子作为输入，解码器则基于编码器表征预测该掩码片段。与仅预训练编码器或解码器的BERT或语言模型不同，MASS通过两个步骤精心设计以联合预训练编码器和解码器：1）通过预测编码器侧被掩码的句子片段，迫使编码器理解未掩码词元的语义，从而支持解码器对掩码词元的预测；2）通过掩码解码器输入中源端未遮盖的词元，迫使解码器在预测后续词元时更依赖源表征而非目标端历史词元，从而更好地促进编码器与解码器的联合训练。

BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension

Inputs to the encoder need not be aligned with decoder outputs, allowing arbitrary noise transformations. Here, a document has been corrupted by replacing spans of text with mask symbols. The corrupted document (left) is encoded with a bidirectional model, and then the likelihood of the original document (right) is calculated with an autoregressive decoder. For fine-tuning, an uncorrupted document is input to both the encoder and decoder, and we use representations from the final hidden state of the decoder.

编码器的输入无需与解码器输出对齐，这允许进行任意噪声转换。本文操作中，通过将文本片段替换为掩码符号来损坏原始文档。左侧的损坏文档经由双向模型编码后，再由自回归解码器计算右侧原始文档的可能性。在微调阶段，原始文档同时输入编码器与解码器，我们使用解码器最终隐藏状态的表示。

BART is trained by corrupting documents and then optimizing a reconstruction loss—the cross-entropy between the decoder’s output and the original document. Unlike existing denoising autoencoders, which are tailored to specific noising schemes, BART allows us to apply any type of document corruption. In the extreme case, where all information about the source is lost, BART is equivalent to a language model.

BART通过破坏文档再进行重构损失优化完成训练——具体优化的是解码器输出与原始文档间的交叉熵。与现有仅适配特定噪声方案的降噪自编码器不同，BART允许采用任意类型的文档破坏方式。在极端情况下，当原始信息完全丢失时，BART即相当于语言模型。

The transformations:

1. Token Masking: random tokens are sampled and replaced with [MASK] elements.
2. Token Deletion: Random tokens are deleted from the input. In contrast to token masking, the model must decide which positions are missing inputs.
3. Text Infilling: A number of text spans are sampled, with span lengths drawn from a Poisson distribution (λ=3). Each span is replaced with a single [MASK] token. 0-length spans correspond to the insertion of [MASK] tokens. Text infilling teaches the model to predict how many tokens are missing from a span.
4. Sentence Permutation: A document is divided into sentences based on full stops, and these sentences are shuffled in a random order.
5. Document Rotation: A token is chosen uniformly at random, and the document is rotated so that it begins with that token. This task trains the model to identify the start of the document.

Why does BERT work?

Contextualized word embedding(上下文词嵌入): 通过Transformer的自注意力机制，每个词的嵌入向量由全句所有词共同计算生成，实现真正的语境感知，同一词在不同句子中生成不同向量（如“bank”在金融/地理语境中向量差异显著），解决多义词问题。

一个有趣的现象：即使在蛋白质、DNA或音乐分类等非文本数据上，使用在文本上预训练的BERT模型，也比随机初始化的模型收敛更快、性能更好，而且只比专门针对该任务设计的模型稍差一点。

原因猜测：

1. 模型架构的普适性：Transformer的自注意力机制（Self-Attention）本质是学习序列元素间的依赖关系，无论输入是文本、蛋白质序列还是音乐信号。
2. 预训练获得的通用表示能力：文本预训练使模型学习到层级化特征提取能力，而这种能力能直接迁移至其他非文本任务中。并且文本预训练数据天然含噪声（如错别字、语法变异），使模型学会过滤无关信号，这一特性在非文本领域至关重要。
3. 迁移学习的优化优势：预训练权重提供了接近最优的初始化点，避免随机初始化陷入局部最优；文本数据的规模（如千亿级token）远超生物/音乐领域，预训练模型可以将大规模数据知识蒸馏至参数中。

Multi-lingual BERT

Training a BERT model by many different languages.

在BERT的Zero-shot Reading Comprehension任务中，采用104种语言预训练（Pre-train），以中英双语微调（Fine-tune）反而优于纯中文预训练+中文微调的组合。

原因猜测：

1. 在104种语言的大规模语料上预训练时，模型通过共享的Transformer编码器学习不同语言之间的深层语义关联。例如，中文“兔子”和英文“rabbit”的嵌入向量在表示空间中高度接近。这种跨语言对齐能力使模型在未训练过的语言任务中（如中文零样本阅读理解）仍能通过语义映射进行推理。
2. 104种语言的训练数据量远超单一中文语料，覆盖更广泛的语法结构、文化背景和领域知识。这种多样性显著提升模型对语言共性与差异的鲁棒性，使其在面对中文零样本任务时更少受限于训练数据的偶然性。单一中文预训练+微调易在小规模中文数据集上过拟合；而多语言预训练通过大规模正则化抑制过拟合，微调时中英文数据进一步提供异构监督信号。
3. 模型在预训练中学习到跨语言的通用模式（如指代消解、因果推理），这些模式在英文微调时被强化，并直接迁移至中文阅读理解中。

GPT series

Predict Next Token

GPT 的核心任务本质上是序列预测。给定一个已有的词序列（或更精确地说，Token 序列），模型的任务是预测在这个序列之后，最有可能出现的下一个 Token 是什么。这个过程是自回归的：模型预测出一个 Token 后，会将它添加到输入序列末尾，然后基于这个新的、更长的序列预测下一个 Token，如此循环往复，从而生成连贯的文本。

Basic Principle

In-context Learning (ICL)

模型无需更新其参数（即无需传统意义上的“训练”或“微调”），仅通过向模型的输入中提供特定格式的文本示例（称为“上下文”或“提示”），就能理解并执行新的任务。

可以将 ICL 理解为一种即时且临时的“学习”或“适应”，完全依赖模型输入中提供的上下文信息来完成特定任务。

为什么GPT能够进行In-context Learning (ICL) ？

1. LLM 在庞大的文本语料库上进行预训练（目标是预测下一个词）。在这个过程中，它们不仅学习了语言知识（语法、词汇），还大量地、反复地“看到了”各种任务的文本描述和案例（因为互联网上充斥着教程、问答、代码注释等）。预训练让模型具备了对“任务模式”极其敏感的潜在能力。
2. Transformer 的自注意力机制能够高效地处理长距离依赖关系，并能在生成输出时充分考虑整个输入序列中的所有信息。这使得模型能够动态地将“指令”和“演示示例”与“新输入”联系起来，找出其中的模式和映射关系。
3. 当提供演示示例时，模型会识别这些示例所体现的输入到输出的映射规则（如：“输入英语句子 -> 输出法语句子”，“说好的 -> 积极；说坏的 -> 消极；陈述事实 -> 中性”）。然后，它把新输入代入到推断出的规则中，生成符合该规则的输出序列（即预测下一个词）。

To learn more

SimCLR(Simple Framework for Contrastive Learning of Visual Representations)

一种自监督视觉表征学习方法，通过对比学习从未标注数据中学习高质量的特征表示，无需人工标注即可达到与监督学习相媲美的性能。

• Data Augmentation：对同一原始图像应用两次独立的随机增强（如随机裁剪、颜色抖动、高斯模糊、水平翻转），生成一对正样本。
• Encoder：使用卷积神经网络提取增强后图像的语义特征，输出高维特征向量 h（称为表示向量）。
• Projection Head：在编码器后添加一个小型多层感知机（MLP），将 h 映射到低维空间 z（称为投影向量），投影头通过非线性变换（如ReLU）过滤冗余信息，优化特征空间以适应对比任务。
• NT-Xent Loss（比损失函数）：最大化正样本对的相似性，最小化负样本对的相似性。
  • 
  • sim(z_i, z_j)：余弦相似度
  • τ：温度参数，控制相似度分布的尖锐程度（值越小，区分越严格）
  • 分母包含同一批次内所有其他样本作为负样本

工作流程：一批 N 张未标注图像，每张图像生成两个增强视图，共 2N 个样本，进行特征提取（增强视图 → 编码器 → 表示向量 h → 投影头 → 投影向量 z），对每个样本 i，计算其正样本对的相似度，并对比所有负样本（2N−2 个）的相似度，通过反向传播更新编码器和投影头的参数，丢弃与任务无关的噪声特征，训练完成后移除投影头，仅用编码器提取的特征 h 进行迁移（如分类、检测）。

BYOL（Bootstrap your own latent）

Bootstrap your own latent: A new approach to self-supervised Learning

是一种无需负样本的自监督对比学习方法，由DeepMind团队于2020年提出。它通过双网络结构和自蒸馏机制，实现高效的特征表示学习，在图像分类、目标检测等任务中达到与监督学习相当的性能。

• 双网络架构：BYOL的核心是在线网络（Online Network） 和 目标网络（Target Network）。在线网络包含编码器（如ResNet）、投影头（MLP）和预测器（MLP）。参数通过梯度下降更新，负责学习当前任务；目标网络结构与在线网络相同（无预测器），参数通过指数移动平均（EMA） 更新，目标网络提供稳定的学习目标，避免模型坍塌。
• 自蒸馏机制：对同一图像生成两个增强视图，由在线网络和目标网络分别处理，得出预测表示和投影表示，最小化二者的loss，损失函数采用归一化余弦相似度损失，最小化同一图像不同视图表示的距离，无需负样本约束。

SimCLR以来大量负样本防止坍塌，但负样本可能引入噪声或偏差，而BYOL通过目标网络的EMA更新和预测器，避免坍塌且简化训练，摆脱对负样本的依赖。

Pre-trained Language Models

Background knowledge

Training a language model is self-supervised learning. Self-supervised learning is predicting any part of the input from any other part.

1. Autoregressive Language Models (ALMs): Complete the sentence given its prefix.

2. Masked Language Models (MLMs): Use the unmasked words to predict the masked word.

3. Transformer-based ALMs: Composed of stacked layers of transformer layers.

4. Pre-trained Language Models (PLMs):

   • Using a large corpora(语料库) to train a neural language model.
     • Autoregressive pre-trained: GPT系列(GPT, GPT-2, GPT-3)
     • MLM-based pre-trained: BERT系列(BERT, RoBERTa, ALBERT)
     • We believe that after pre-training, the PLM learns some knowledge, encoded in its hidden representations, that can transfer to downstream tasks
     • 
   • (Standard) fine-tuning: Using the pre-trained weights of the PLM to initialize a model for a downstream task.
     • 

The Problems of PLMs

1. Data scarcity in downstream tasks: A large amount of labeled data is not easy to obtain for each downstream task.
2. The PLM is too big, and they are still getting bigger.
   • Need a copy for each downstream task
   • Inference takes too long
   • Consume too much space

The Solutions of Those Problems

Labeled Data Scarcity → Data-Efficient Fine-tuning

1. Prompt Tuning: By converting the data points in the dataset into natural language prompts, the model may be easier to know what it should do.

Format the downstream task as a language modelling task with predefined templates into natural language prompts.

What you need in prompt tuning:

• A prompt template: convert data points into a natural language prompt.
• A PLM: perform language modeling.
• A verbalizer: A mapping between the label and the vocabulary

Prompt tuning has better performance under data scarcity because it incorporates human knowledge and introduces no new parameters.

2. Few-shot Learning: We have some labeled training data.

3. Semi-Supervised learning: We have some labeled training data and a large amount of unlabeled data.

Pattern-Exploiting Training (PET):

(1)Use different prompts and verbalizer to prompt-tune different PLMs on the labeled dataset.

(2)Predict the unlabeled dataset and combine the predictions from different models.

(3)Use a PLM with classifier head to train on the soft-labeled data set.

4. Zero-shot inference: inference on the downstream task without any training data.

PLMs Are Gigantic → Reducing the Number of Parameters

Parameter-efficient fine-tuning: Reduce the task-specific parameters in downstream task

Fine-tuning = modifying the hidden representation based on a PLM

1. Adapter: Use special submodules to modify hidden representations.

During fine-tuning, only update the adapters and the classifier head. All downstream tasks share the PLM, the adapters in each layer and the classifier heads are the task-specific modules.

2. LoRA: Low-Rank Adaptation of Large Language Models.

All downstream tasks share the PLM; the LoRA in each layer and the classifier heads are the task-specific modules.

3. Prefix Tuning: Insert trainable prefix in each layer.

Only the prefix (key and value) are updated during finetuning.

4. Soft Prompting: Prepend the prefix embedding at the input layer.

Soft Prompts: vectors (can be initialized from some word embeddings)

Benefits:

1. Drastically decreases the task-specific parameters.
2. Less easier to overfit on training data; better out-of-domain performance.
3. Fewer parameters to fine-tune; a good candidate when training with small dataset.

Early exit: Reduce the models that are involved during inference

Add a classifier at each layer and use a confidence predictor to decide which classifier to use.

Self-supervised Learning for Speech and Image

Generative Approaches

BERT series

Mockingjay: Unsupervised Speech Representation Learning with Deep Bidirectional Transformer Encoders

Mockingjay 是一种针对语音信号的自监督学习模型，属于生成式方法（Generative Approaches）。它通过重构被破坏的语音帧（Audio Frames）来学习语音表征，显著提升了语音识别、语音情感分析等下游任务的性能。

Masking:

• Smoothness of acoustic features: Masking consecutive features

  

• Masking strategies for speech: Masking specific dimensions(Learn more speaker information in this way)

  

GPT series

Generative Pre-Training for Speech with Autoregressive Predictive Coding

Autoregressive Predictive Coding（自回归预测编码，APC）是一种结合自回归建模（Autoregressive Modeling）和预测编码理论（Predictive Coding）的机器学习方法。

通过预测未来数据点来学习当前数据的低维表示，同时利用预测误差驱动模型优化。

对于图像来说，以上两种方法均适用，将图像转化为vector即可。

Predictive Approach

No negative examples

Image - Predicting Rotation

Unsupervised Representation Learning by Predicting Image Rotations

Image - Context Prediction

Unsupervised Visual Representation Learning by Context Prediction

仅需使用大规模无标签图像集，从单张图像中随机抽取成对的图像块，通过训练卷积神经网络预测第二块相对于第一块的方位坐标。通过这种图像内部上下文关系学习到的特征表示，能够有效捕捉图像之间的视觉相似性。

Predict Simplified Objects

For Speech:

• HuBERT: HuBERT: Self-Supervised Speech Representation Learning by Masked Prediction of Hidden Units

  通过离线聚类步骤为类BERT预测损失提供对齐的目标标签。本方法的关键设计在于预测损失仅作用于掩蔽区域，迫使模型在连续输入上学习声学与语言信息的联合建模。HuBERT的核心优势依赖于无监督聚类步骤的稳定性，而非所分配聚类标签的固有质量。

• BEST: Self-supervised Learning with Random-projection Quantizer for Speech Recognition

  本方法训练了一个预测掩蔽语音信号的模型，其预测目标形式为通过随机投影量化器生成的离散标签。该量化器使用随机初始化的矩阵对语音输入进行投影，并在随机初始化的码本中执行最近邻搜索匹配。

For Image:

• DeepCluster: Deep Clustering for Unsupervised Learning of Visual Features

  在每次迭代中通过标准聚类算法（k均值）对特征执行聚类分组，并将后续分配结果作为监督信号，依此更新网络的权重参数。

Contrastive Learning

SimCLR

Speech SIMCLR: Combining Contrastive and Reconstruction Objective for Self-supervised Speech Representation Learning

MoCo

Momentum Contrast for Unsupervised Visual Representation Learning

MoCo(Momentum Contrast) 是一种用于无监督视觉表征学习的动量对比算法，基于将对比学习视为字典查询的视角，本方法通过队列机制与动量平均编码器构建动态字典。该设计实现实时构建大规模且一致的字典，从而显著提升对比式无监督学习效果。

VQ-wav2vec

vq-wav2vec: Self-Supervised Learning of Discrete Speech Representations

VQ-wav2vec + BERT:

Wav2vec 2.0: wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations

Continuous input is critical. Quantized target improves performance.

Why not formulated as typical classification?

原因猜测：音频作为输入经过编码器的输出纷繁复杂，不利于作为简单的分类问题进行解决。

Bootstrapping Approaches

No negative examples

类似一种Typical Knowledge Distillation方式，Teacher Encoder的参数保持不变，通过计算损失进行gradient descent，更新Student Encoder的参数，然后将其复制回Teacher Encoder中，如此循环往复。

• Image
  • Bootstrap your own latent (BYOL)：https://arxiv.org/abs/2006.07733
  • Simple Siamese (SimSiam)：https://arxiv.org/abs/2011.10566
• Speech
  • Data2vec: the student learns from multiple layers of the teacher：https://arxiv.org/abs/2202.03555

Simply Extra Regularization

No negative examples

Variance-Invariance-Covariance Regularization ( VICReg )

VICReg: Variance-Invariance-Covariance Regularization for Self-Supervised Learning

通过给Encoder的输出的某一/些维度的方差设置一个阈值，可以使其输出结果的分布不再趋同，增加多样性，避免坍缩问题的发生。

Homework 7: Extractive Question Answering

Dataset: DRCD & ODSQA

DRCD: Delta Reading Comprehension Dataset ODSQA: Open-Domain Spoken Question Answering Dataset

• train: DRCD + DRCD-TTS
  • 10524 paragraphs, 31690 questions
• dev: DRCD + DRCD-TTS
  • 1490 paragraphs, 4131 questions
• test: DRCD + ODSQA
  • 1586 paragraphs, 4957 questions

Chinese Reading Comprehension

Baselines

Simple Baseline

Sample code: link

Output:

Medium Baseline

Apply linear learning rate decay

1
2
3
4
5
6
7

# 学习率调度器，线性衰减
# 计算总步数
total_steps = len(train_loader) * num_epoch
# 学习率衰减函数，线性衰减到0
lr_lambda = lambda step: max(0.0, 1.0 - step / total_steps)
# 创建学习率调度器
scheduler = LambdaLR(optimizer, lr_lambda=lr_lambda)

Change value of “doc_stride”

1

self.doc_stride = 75 # 变为原来的一半

Code: link

Output:

Strong Baseline

Improve preprocessing

训练的数据处理是直接以答案为中心选择文本窗口，这导致模型可能学到一个不该学习的模式：答案就在中间。

采用随机窗口位置：在训练时，不要总以答案为中心截取窗口，而是让窗口的起点在包含答案的所有合法位置中随机采样。这样，答案在窗口中的位置是随机的，模型不会学到“答案总在中间”。

1
2
3
4
5
6
7
8
9
10
11

if self.split == "train":
    answer_start_token = tokenized_paragraph.char_to_token(question["answer_start"])
    answer_end_token = tokenized_paragraph.char_to_token(question["answer_end"])
    L = len(tokenized_paragraph)
    min_start = max(0, answer_end_token - self.max_paragraph_len + 1)
    max_start = min(answer_start_token, L - self.max_paragraph_len)
    if max_start < min_start:
        paragraph_start = min_start  # 兜底，窗口只能唯一确定
    else:
        paragraph_start = random.randint(min_start, max_start)
    paragraph_end = paragraph_start + self.max_paragraph_len

Try other pretrained models

Models - Hugging Face

Output: link

Auto-encoder

Basic Idea of Auto-encoder

自编码器（Auto-encoder）是一种无监督学习的神经网络模型，其核心思想是通过学习数据的低维表示（编码）来实现数据的压缩与重建。它的设计灵感来源于“信息瓶颈”概念，旨在捕捉数据中最关键的特征，同时忽略冗余信息。

核心任务是让输出尽可能复现输入。

1. Encoder: 将高维输入数据（如图像、文本）压缩为低维潜在表示（Latent Representation），称为“瓶颈层”（Bottleneck Layer）。
2. Decoder: 从低维潜在表示中重建原始输入数据。

自编码器的训练无需人工标注，其标签即为输入数据本身。

自编码器的Dimension reduction 与PCA有何区别？

• PCA是线性降维，而自编码器通过非线性激活函数捕捉复杂模式，适用于非线性数据。

Why Auto-encoder work?

1. 低维瓶颈层强制模型保留关键信息，丢弃次要细节（如图像背景噪声）。

   

2. 潜在表示z是数据的“抽象特征”，可视为数据的嵌入式表示（Embedding），适用于下游任务（如分类、聚类）。

De-noising Auto-encoder(DAE)

De-noising Auto-encoder（降噪自编码器，DAE）是一种改进的自编码器（Autoencoder），通过在输入数据中主动添加噪声并学习恢复原始数据，提升模型的鲁棒性和特征表示能力。

The idea of DAE is also used in BERT.

Feature Disentanglement

在深度学习中，原始数据（如图像、语音或文本）经过神经网络编码后，得到的特征向量往往是混合的，即一个维度的变化可能对应多个因素的共同作用。

Feature Disentanglement 的目标是： 将这种混合的特征表示分解成相互独立、互不干扰的子表示，每个子表示对应一个语义独立的因子，如：

• 图像中“姿态”、“光照”、“物体种类”
• 语音中“说话人身份”、“情绪”、“内容”
• 文本中“语气”、“主题”、“句式结构”

这样可以使模型更具可解释性、泛化能力更强，并更容易进行控制与生成。

Application: Voice Conversion

通过Feature Disentanglement可以将speaker与content分离，实现语音转换。

Discrete Latent Representation

在深度学习中，潜在表示（latent representation）是指模型从原始输入中提取的内部特征编码，通常位于自动编码器（Autoencoder）或生成模型（如VAE、GAN）的中间层。而 “离散潜在表示” 则是指这些潜在特征在潜空间中是离散的值，而不是连续的实数向量。

Vector Quantized Variational Auto encoder (VQVAE)

Structure

1. Encoder: 输入x通过编码器得到一个连续的表示：z_e(x) ∈ ℝ^d
2. Vector Quantization: 引入一个码本（codebook），ε = e₁, e₂, ..., e_k ⊂ ℝ^d，包含K个向量。
   • 编码器输出会被量化为码本中最接近的向量：z_q(x) = Quantize(z_e(x)) = e_k, where
   • 所以z_q(x)是一个离散向量。
3. Decoder: 用离散后的z_q(x)重建输入：x̂ = Decoder(z_q(x))

离散向量和连续向量有什么区别?

1
2
3
4
5
6

# 连续向量示例：向量每一维都是实数，可以是语义混合的，比如人脸的“年龄”、“光照”、“角度”等
z = [0.12, -0.53, 0.87, 0.03]

# 离散向量示例：
z = [0, 0, 1, 0]  # 一个 one-hot 向量，表示第 3 类
z = 2  # 一个“码本索引”，表示第 2 个嵌入向量

离散向量是不可导的，VQ-VAE如何解决梯度问题？

Straight-Through Estimator（STE）: 在前向传播时，使用量化结果，而在反向传播时，把梯度直接传回给未量化的z_e(x)，忽略量化步骤的不可导性。

Text as Representation

Learning to Encode Text as Human-Readable Summaries using Generative Adversarial Networks

This is cycle GAN

Tree as Embedding

Tree as Embedding（树作为嵌入） 是一种将树结构信息编码为向量表示（embedding）的方法，旨在将具有分层或结构化语义的数据（如语法树、抽象语法树AST、XML、知识图谱子树）映射到一个固定维度的向量空间中，从而使树结构能作为神经网络的输入进行建模与学习。

可以理解为将树结构转换成神经网络能处理的向量，同时保留其语义与结构特征。

More Applications

Generator

With some modification, we have variational auto-encoder (VAE).

Variational Autoencoder（VAE） 是一种生成模型（Generative Model），它结合了自编码器（Autoencoder）与变分推断（Variational Inference），在保持端到端训练的同时，学习一个可控、连续的潜在空间（latent space），从而可以生成新的、真实感很强的数据。

用神经网络学习隐变量的概率分布，然后从中采样以重构输入，进而生成新数据。

1
2
3
4
5
6
7
8
9
10

Input x
   ↓
Encoder: μ(x), σ(x)
   ↓       \
Sample z = μ + σ·ε  ← ε ~ N(0, I)
   ↓
Decoder: x̂ = f(z)
   ↓
Compare x̂ vs. x → 重构损失 + KL 正则

Compression

Lossy Image Compression with Compressive Autoencoders

Anomaly Detection

• Given a set of training data {x¹, x², ..., x^N}
• Detecting input x is similar to training data or not.

Case 1: With Classifier

本质上是将问题转化为二分类任务。

Anomaly Detection:

Confidence: the maximum scores or negative Entropy.

Example Framework

Training Set: Images x of characters from Simpsons.

• Each image 𝑥 is labelled by its characters ŷ
• Train a classifier, and we can obtain confidence score c(x) from the classifier.

Dev Set: Label each image 𝑥 is from Simpsons or not.

• We can compute the performance of f(x)
• Using dev set to determine and other hyperparameters.

Testing Set: Images 𝑥 is from Simpsons or not.

Evaluation

• Accuracy is not a good measurement!
• A system can have high accuracy, but do nothing.

第一类错误与第二类错误

Case 2: Without Labels

• Given a set of training data {x¹, x², ..., x^N}
• We want to find a function detecting input x is similar to training data or not.

Maximum Likelihood

Assuming the data points is sampled from a probability density function f_θ(x)

• θ determines the shape of f_θ(x)
• θ is unknown, to be found from data
• L(θ) = f_θ(x¹)f_θ(x²)...f_θ(x^N) : Likelihood
• θ^⋆ = arg max_θL(θ)

The colors represents the value of f_{μ^⋆, ∑^⋆}(x)

Concluding Remarks

Homework 8: Anomaly Detection

Task introduction

Unsupervised anomaly detection: Training a model to determine whether the given image is similar with the training data.

Data

• Training data
  • 100000 human faces
• Testing data
  • About 10000 from the same distribution with training data (label 0)
  • About 10000 from another distribution (anomalies, label 1)
• Format
  • data/ |—– trainingset.npy |—– testingset.npy
  • Shape: (#images, 64, 64, 3) for each .npy file

Methodology

• Train an autoencoder with small reconstruction error.
• During inference, we can use reconstruction error as anomaly score.
  • Anomaly score can be seen as the degree of abnormality of an image.
  • An image from unseen distribution should have higher reconstruction error.
• Anomaly scores are used as our predicted values.

Evaluation - ROC AUC score

• TPR = TP / (TP + FN)
• FPR = FP / (FP + TN)

Simple Baseline

Sample code: link

Output:

Medium Baseline

Code: link

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

# 卷积自动编码器模型 - 改进版本（更少层数）
class conv_autoencoder(nn.Module):
    def __init__(self):
        super(conv_autoencoder, self).__init__()
        # 简化的编码器 - 减少层数
        self.encoder = nn.Sequential(  
            nn.Conv2d(3, 16, 4, stride=2, padding=1),  # 3通道→16通道 (64x64→32x32)
            nn.ReLU(),
            nn.Conv2d(16, 32, 4, stride=2, padding=1),  # 16通道→32通道 (32x32→16x16)
            nn.ReLU(),
            # 移除第三个卷积层，减少模型复杂度
        )
        # 简化的解码器 - 减少层数
        self.decoder = nn.Sequential(  
            nn.ConvTranspose2d(32, 16, 4, stride=2, padding=1),  # 32通道→16通道 (16x16→32x32)
            nn.ReLU(),
            nn.ConvTranspose2d(16, 3, 4, stride=2, padding=1),  # 16通道→3通道 (32x32→64x64)
            nn.Tanh(),  # 输出范围限制在[-1,1]
        )

    def forward(self, x):
        x = self.encoder(x)  # 通过编码器
        x = self.decoder(x)  # 通过解码器
        return x

# 训练配置 - 改进版本
# 训练超参数
num_epochs = 50  # 训练轮数
batch_size = 256  # 更小的批次大小（从2000减少到256）
learning_rate = 1e-3  # 学习率保持不变

# 构建训练数据加载器
x = torch.from_numpy(train)  # 将NumPy数组转换为PyTorch张量
train_dataset = CustomTensorDataset(x)  # 创建训练数据集

train_sampler = RandomSampler(train_dataset)  # 创建随机采样器
train_dataloader = DataLoader(train_dataset, sampler=train_sampler, batch_size=batch_size, num_workers=0)  # 使用更小的批次大小

# 模型选择 - 使用改进的CNN
model_type = 'cnn'   # 选择CNN模型类型
model_classes = {'fcn': fcn_autoencoder(), 'cnn': conv_autoencoder(), 'vae': VAE()}  # 模型类型映射字典
model = model_classes[model_type].cuda()  # 实例化选择的模型并移至GPU

# 推理阶段 - 也使用更小的批次大小
eval_batch_size = 64  # 更小的评估批次大小（从200减少到64）

# 构建测试数据加载器
data = torch.tensor(test, dtype=torch.float32)  # 将测试数据转换为PyTorch张量
test_dataset = CustomTensorDataset(data)  # 创建测试数据集
test_sampler = SequentialSampler(test_dataset)  # 创建顺序采样器
test_dataloader = DataLoader(test_dataset, sampler=test_sampler, batch_size=eval_batch_size, num_workers=0)

Output:

Strong Baseline

Adjust model structure: Try smaller models (less layers), Smaller batch size.

Code: link

Output:

Explainable Machine Learning

Why we need Explainable ML?

• Loan issuers are required by law to explain their models. (金融贷款)
• Medical diagnosis model is responsible for human life. Can it be a black box? (医疗诊断)
• If a model is used at the court, we must make sure the model behaves in a nondiscriminatory manner. (法庭判决)
• If a self driving car suddenly acts abnormally, we need to explain why. (自动驾驶)

We can improve ML model based on explanation.

Interpretable v.s. Powerful

• Some models are intrinsically interpretable. For example, linear model (from weights, you know the importance of features), but not very powerful.

• Deep network is difficult to interpretable. Deep networks are black boxes , but powerful than a linear model.

• Are there some models interpretable and powerful at the same time?

  • Maybe decision tree？A tree can still be terrible and we often use a forest instead of just one tree.

    

Goal of Explainable ML

1. 建立信任：让用户知道模型为什么这么预测，特别是在医疗、金融等高风险领域。

2. 发现问题：帮助识别数据中的偏差、错误或模型学到的“伪规律”。

3. 辅助决策：让人能根据模型的解释更合理地做出决策，而不是盲目依赖模型。

4. 满足法规：符合法律要求，提供决策依据和解释。

5. 促进科研：通过解释模型，帮助发现新的知识和潜在规律。

In a word, Make people (your customers, your boss, yourself) comfortable.

Explainable ML

Local Explanation: Explain the Decision

Local Explanation（局部解释） 是指：

在特定样本（某一条预测）附近，对模型做出的预测结果进行解释，而不是解释整个模型的整体行为。

Which component is critical for making decision?

Object x : Image, text, etc.

Components: {X₁, ..., x_n, ..., x_N}

Image: pixel, segment, etc. Text: a word

• Removing or modifying the components
• Large decision change
• means Important component

Saliency Map

Saliency Map（显著性图） 是一种可视化技术，用于解释神经网络模型在预测某个样本时，输入中哪些部分最“重要”或“敏感”。

它告诉你模型“在看哪里”。在图像分类任务中，Saliency Map 就是一个热点图，显示图像中哪些像素对模型输出影响最大。

Limitations

Noisy Gradient

在最基本的 Saliency Map 方法中（即 Vanilla Gradient），通过求某类别预测结果y对输入图像I的梯度，来评估每个像素对模型预测的“影响力”。但实际计算中会出现的问题是,生成的梯度图（显著性图）非常“杂乱”或“有噪声”:

• 热区分布不连续；

• 没有结构性；

• 很难解释模型到底关注了哪里；

• 图像呈现出“雪花状”或“闪电纹”，视觉上很模糊。

Solution: SmoothGrad

• Randomly add noises to the input image, get saliency maps of the noisy images and average them.

Gradient Saturation

Gradient Saturation（梯度饱和） 是指在神经网络中，由于某些激活函数在特定输入区间会输出近似恒定的值，导致反向传播时梯度接近零，从而阻碍学习或解释过程。

在 Saliency Map（显著性图） 这类基于梯度的方法中：

• 梯度饱和会导致输入像素的梯度接近 0；
• 即使某个区域对模型预测结果有重要影响，但其梯度很小；
• 显著性图中该区域就不会被高亮，造成误导。

“重要的区域被忽略了”，因为梯度被“淹没”在网络中。

Solution: Alternative: Integrated gradient(IG)

• 通过计算输入特征从“参考点”变化到实际输入过程中产生的累积梯度，来衡量每个输入特征对预测结果的贡献。
• 从参考点x^′线性地“移动”到输入点x，并沿这条路径计算梯度的积分。

Global Explanation: Explain the Whole Model

Global Explanation（全局解释） 是指：

解释整个机器学习模型的总体行为，而不仅仅是对某一个输入样本的预测结果进行解释（Local Explanation）。

它关注的是：

• 模型总体是如何“思考”的；
• 模型整体对哪些特征最敏感；
• 预测规则是否稳定、合理、公平；
• 特征之间的交互关系如何影响输出。

What does a filter detect?

X^⋆ = argmax_x∑_i∑_ja_ij (gradient ascent)

E.g., Digit classifier

x^⋆ for each filter

What does a digit look like for CNN?

Find the image that maximizes class probability : X^⋆ = arg max_Xy_i

Obviously we can’t see digits——Consider adversarial attack.

Solution: Add Constraint

• The image should looks like a digit.
  • X^⋆ = argmax_Xy_i + R(X)
  • R(X) =  − ∑_i, j|X_ij|, represents How likely is a digit.
  • 
• Constraint from Generator
  • 
  • 从生成器的输入低维向量中寻找使其生成图片的y_i最大的向量。

Homework 9: Explainable AI

这个作业是在gradescope上布置的，非台大的学生无法完成，因此我只是搜集了所提到的技术的相关信息。

Topic I: CNN explanation

Lime

LIME（Local Interpretable Model-agnostic Explanations） 是一种用于模型可解释性的方法。它的核心思想是：通过对输入数据进行轻微扰动并观察模型输出的变化，从而学习一个局部的、易解释的线性模型，来近似原始复杂模型的行为，以解释模型对某个单个输入样本的预测原因。

LIME 在 CNN 图像中的应用流程：

1. 图像分割：用算法将图像划分为多个 Superpixels。
2. 随机遮挡：创建多个扰动版本，部分 superpixels 被灰色遮挡。
3. CNN 预测：用 CNN 对每个扰动版本预测，记录输出概率。
4. 加权线性回归：用扰动图像和对应预测结果训练一个线性模型。
5. 可视化解释：线性模型的权重可视化后，形成热力图，突出最重要区域。

假设 CNN 模型对一张猫的图片预测为“猫”，我们用 LIME 得到如下解释：

• 红色区域表示对“猫”这个预测最有贡献的 superpixels（如耳朵、眼睛、胡须区域）。
• 蓝色区域表示负面贡献区域（如背景或其他不相关内容）。
• 用户看到这个解释，就能知道模型是否真的在关注“猫”的关键特征。

针对图像数据的分类解释，LIME 的核心库是 lime，其中处理图像分类解释的模块是：

1	lime.lime_image.LimeImageExplainer

主要函数：

Saliency Map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

# Saliency Map 函数
# 将 tensor 图像归一化到 [0, 1] 区间，便于显示
def normalize(image):
  return (image - image.min()) / (image.max() - image.min())

def compute_saliency_maps(x, y, model):
  model.eval()
  x = x.cuda()

  x.requires_grad_()
  
  y_pred = model(x)
  loss_func = torch.nn.CrossEntropyLoss()
  loss = loss_func(y_pred, y.cuda())
  loss.backward()

  saliencies, _ = torch.max(x.grad.data.abs().detach().cpu(),dim=1)  #  RGB 三个通道上取最大值 → 得到 shape: (batch_size, H, W)，生成单通道显著图（热图）

  saliencies = torch.stack([normalize(item) for item in saliencies]) # 对每张 saliency map 归一化，使其像素值落在 [0, 1]，更适合显示和对比
  return saliencies
# images, labels = train_set.getbatch(img_indices)
saliencies = compute_saliency_maps(images, labels, model)

# visualize
fig, axs = plt.subplots(2, len(img_indices), figsize=(15, 8))
for row, target in enumerate([images, saliencies]):
  for column, img in enumerate(target):
    if row==0:
      axs[row][column].imshow(img.permute(1, 2, 0).numpy())
    else:
      axs[row][column].imshow(img.numpy(), cmap=plt.cm.hot)
    
plt.show()
plt.close()

Smooth Grad

Smooth Grad是画Saliency Map的一种技术，有的图像在可视化的时候会有很多额外的噪声。可以认为Smooth Grad技术就是为了减少神经网络所看到的一些噪声。所谓的Smooth Grad就是在图像上随机增加一些噪声，通过引入一定的噪声来达到降噪的效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

# 归一化函数：将图像的像素值映射到 [0,1] 区间，用于增强可视化效果
def normalize(image):
    return (image - image.min()) / (image.max() - image.min())

# SmoothGrad 主函数
def smooth_grad(x, y, model, epoch, param_sigma_multiplier):
    model.eval()  # 设置模型为评估模式（关闭 dropout、BN 等）

    # 设置高斯噪声的均值为0
    mean = 0
    # 根据输入张量范围设置噪声标准差（越大越模糊）
    sigma = param_sigma_multiplier / (torch.max(x) - torch.min(x)).item()

    # 创建一个用于累加多个扰动梯度的数组（shape 和输入相同）
    smooth = np.zeros(x.cuda().unsqueeze(0).size())

    # 重复 epoch 次，生成多个扰动输入
    for i in range(epoch):
        # 创建与输入 x 同形状的高斯噪声张量
        noise = Variable(x.data.new(x.size()).normal_(mean, sigma**2))  # 均值为0，方差为sigma^2

        # 将噪声加入原始输入图像中
        x_mod = (x + noise).unsqueeze(0).cuda()  # 增加 batch 维度并移动到 GPU
        x_mod.requires_grad_()  # 启用梯度计算

        # 前向传播得到模型预测
        y_pred = model(x_mod)
        loss_func = torch.nn.CrossEntropyLoss()
        # 计算预测结果与标签的交叉熵损失
        loss = loss_func(y_pred, y.cuda().unsqueeze(0))

        # 反向传播以获得输入的梯度
        loss.backward()

        # 累加每次的梯度绝对值，detach 去除图计算图，cpu 将张量移回主机，转换为 numpy 格式
        smooth += x_mod.grad.abs().detach().cpu().data.numpy()

    # 对累加的梯度图进行平均并归一化，得到最终的 SmoothGrad 热力图
    smooth = normalize(smooth / epoch)

    # 返回形状为 (1, C, H, W) 的 numpy 数组
    return smooth

# 示例使用代码：对多张图像进行可视化
smooth = []
for i, l in zip(images, labels):
    # 对每张图像调用 smooth_grad 函数，得到其平滑的显著性图
    smooth.append(smooth_grad(i, l, model, 500, 0.4))

# 将多个显著性图拼接成一个数组，shape: (N, 1, C, H, W)
smooth = np.stack(smooth)

# 可视化结果，显示原图和对应的显著性图
fig, axs = plt.subplots(2, len(img_indices), figsize=(15, 8))

# 遍历原图和显著性图
for row, target in enumerate([images, smooth]):
    for column, img in enumerate(target):
        # 对原图进行通道维度转换：(C, H, W) -> (H, W, C)，方便 plt 显示
        if row == 0:
            axs[row][column].imshow(np.transpose(img.numpy(), (1, 2, 0)))
        else:
            # 对 smooth grad 显示热力图（假设 shape 为 (1, C, H, W)，取出并转置）
            axs[row][column].imshow(np.transpose(img.reshape(3, 128, 128), (1, 2, 0)))

plt.show()

Filter Visualization

这个方法是想要获得在CNN网络中间某一层所观察到的特征。在训练模型的时候，大多数情况下会一train到底，所以我们想要获取模型中间某层所观察到的内容比较困难，但是PyTorch提供了hook方法，能够轻松的获取模型中间的层数，并且观察到CNN网络中间所观察到的输出内容。hook函数会自动保存模型中的某一层，使用完再将其移出即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

# 图像归一化函数：将像素值线性映射到 [0,1] 区间，增强显示对比度
def normalize(image):
    return (image - image.min()) / (image.max() - image.min())

# 定义全局变量用于保存中间层激活结果
layer_activations = None

# 滤波器可视化解释函数
# x：输入图像（Tensor）
# model：CNN 模型
# cnnid：卷积层在 model.cnn 中的索引（即第几层卷积层）
# filterid：要解释的滤波器在该层中的索引（即第几个通道）
# iteration：优化迭代次数
# lr：优化器学习率
def filter_explanation(x, model, cnnid, filterid, iteration=100, lr=1):
    model.eval()  # 设置模型为评估模式，防止 dropout 和 batchnorm 干扰

    # 定义钩子函数：当 model 在 cnn[cnnid] 层前向传播时，会执行该函数
    # 此函数将该层的输出（激活值）保存到全局变量 layer_activations 中
    def hook(model, input, output):
        global layer_activations
        layer_activations = output

    # 注册钩子函数到指定卷积层，获取该层的输出
    hook_handle = model.cnn[cnnid].register_forward_hook(hook)

    # ---------- 第一阶段：获取原始输入图像在该滤波器下的激活图 ----------

    # 对输入图像进行前向传播，触发 hook 函数，layer_activations 会被赋值
    model(x.cuda())

    # 获取第 filterid 个通道的激活图（形状为 H x W），并从计算图中剥离 -> CPU -> NumPy
    filter_activations = layer_activations[:, filterid, :, :].detach().cpu()

    # ---------- 第二阶段：寻找能最大激活该滤波器的图像 ----------

    x = x.cuda()                # 将输入图像转移到 GPU
    x.requires_grad_()          # 允许对输入图像进行梯度更新（以便优化）

    optimizer = Adam([x], lr=lr)  # 使用 Adam 优化器直接优化输入图像

    # 进行 iteration 次迭代优化
    for iter in range(iteration):
        optimizer.zero_grad()   # 梯度清零
        model(x)                # 前向传播，重新获得当前图像的激活结果

        # 定义目标函数：最大化第 filterid 个通道的所有激活值的总和
        # 加负号是因为 optimizer 默认是最小化目标函数
        objective = -layer_activations[:, filterid, :, :].sum()

        # 反向传播计算梯度
        objective.backward()

        # 执行一次优化步骤，更新输入图像以更强地激活目标滤波器
        optimizer.step()

    # 最终优化后的图像即为“最能激活该滤波器的图像”
    # 去除 batch 维度，移回 CPU
    filter_visualizations = x.detach().cpu().squeeze()

    # 移除 hook，避免影响后续模型使用
    hook_handle.remove()

    # 返回结果：
    # - filter_activations：原图在该滤波器下的响应图
    # - filter_visualizations：经过优化后能最大激活该滤波器的图像
    return filter_activations, filter_visualizations

Integrated Gradients

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class IntegratedGradients():
    def __init__(self, model):
        self.model = model  # 保存传入的模型
        self.gradients = None  # 用于存储计算得到的梯度
        self.model.eval()  # 将模型设置为评估模式，防止 Dropout、BatchNorm 影响结果

    def generate_images_on_linear_path(self, input_image, steps):
        # 生成从全零图像到输入图像之间的线性插值图像（baseline -> input）
        xbar_list = [input_image * step / steps for step in range(steps)]
        return xbar_list

    def generate_gradients(self, input_image, target_class):
        # 计算输入图像对目标类别的梯度
        input_image.requires_grad = True  # 启用对输入图像的梯度追踪
        model_output = self.model(input_image)  # 前向传播，得到模型输出
        self.model.zero_grad()  # 清除模型中已有的梯度（防止累积）
        
        # 创建与模型输出同形状的 one-hot 向量，表示我们只关心 target_class 的输出
        one_hot_output = torch.FloatTensor(1, model_output.size()[-1]).zero_().cuda()
        one_hot_output[0][target_class] = 1  # 对应目标类别位置置为1

        # 反向传播：计算输入图像对目标类别的梯度
        model_output.backward(gradient=one_hot_output)
        self.gradients = input_image.grad  # 保存得到的梯度

        # 转换为 numpy 数组，并去掉 batch 维度
        gradients_as_arr = self.gradients.data.cpu().numpy()[0]
        return gradients_as_arr

    def generate_integrated_gradients(self, input_image, target_class, steps):
        # 计算积分梯度
        xbar_list = self.generate_images_on_linear_path(input_image, steps)
        # 初始化积分梯度数组，形状同 input_image
        integrated_grads = np.zeros(input_image.size())

        for xbar_image in xbar_list:
            # 对路径上每个插值图像计算梯度
            single_integrated_grad = self.generate_gradients(xbar_image, target_class)
            # 将梯度按步数进行平均，加和每一步的贡献
            integrated_grads = integrated_grads + single_integrated_grad / steps

        # 返回去掉 batch 维度后的结果，只返回第一个通道（如果是批量输入）
        return integrated_grads[0]

Topic II: BERT explanation

Attention Visualization

https://huggingface.co/exbert/

Embedding Visualization

加载训练好的模型权重，去迭代这个权重，通过PCA降维，然后可视化每一个隐藏层的状态。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

# 将问题和上下文编码成模型输入格式（input_ids, attention_mask等）
inputs = Tokenizer(questions[QUESTION-1], contexts[QUESTION-1], return_tensors='pt')

# 获取问题和上下文在输入序列中的位置索引（用于可视化时区分不同来源的token）
question_start, question_end = 1, inputs['input_ids'][0].tolist().index(102) - 1  # [SEP] 的token id是102
context_start, context_end = question_end + 2, len(inputs['input_ids'][0]) - 2    # 跳过[SEP]后紧跟的context开始直到倒数第二个token（前一个[SEP]）

# 载入模型预测后保存的hidden states（模型第QUESTION题的输出，包含所有层的隐藏状态）
outputs_hidden_states = torch.load(f"hw9_bert/output/model_q{QUESTION}")

##### 遍历每一层的hidden states进行可视化 #####
# outputs_hidden_states是一个包含13个元素的元组：
# 第0个是词嵌入（embedding layer 输出），其余12个是transformer各层的输出
for layer_index, embeddings in enumerate(outputs_hidden_states[1:]):  # 跳过第一个embedding输出，从第1层到第12层

    # 当前层的 embeddings 维度为 [1, seq_len, 768]，我们使用 PCA 将其降到二维
    reduced_embeddings = PCA(n_components=2, random_state=0).fit_transform(embeddings[0])  # embeddings[0]形状为[seq_len, 768]

    ##### 逐token绘制嵌入向量的二维表示 #####
    for i, token_id in enumerate(inputs['input_ids'][0]):
        x, y = reduced_embeddings[i]              # 获取该token的二维坐标
        word = Tokenizer.decode(token_id)         # 将token id转回单词（不一定是词，有可能是子词）

        # 根据该token的类别（答案/问题/上下文）用不同颜色绘制
        if word in answers[QUESTION-1].split():   # 如果token在答案中，用蓝色标记
            plt.scatter(x, y, color='blue', marker='d')
        elif question_start <= i <= question_end: # 如果token属于问题部分，用红色标记
            plt.scatter(x, y, color='red')
        elif context_start <= i <= context_end:   # 如果token属于上下文部分，用绿色标记
            plt.scatter(x, y, color='green')
        else:
            continue  # 跳过CLS、SEP等特殊token

        # 在点旁边标注token对应的文本
        plt.text(x + 0.1, y + 0.2, word, fontsize=12)

    # 为图例添加空点（只是为了让图例出现，不实际绘制）
    plt.plot([], label='answer', color='blue', marker='d')
    plt.plot([], label='question', color='red', marker='o')
    plt.plot([], label='context', color='green', marker='o')

    plt.legend(loc='best')                      # 显示图例
    plt.title('Layer ' + str(layer_index + 1))  # 添加标题：当前是第几层的可视化
    plt.show()                                  # 显示图像

Embedding Analysis

TODO: Compare output embedding of BERT using:

• Euclidean distance
• Cosine similarity

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

# 每个句子中选择要比较的词的下标索引（按 word-level 选）
# 举例：句子 "蘋果茶真難喝"，若 index = 0，表示选择的是"蘋"
# 此处为10个句子中各自要选取比较的词在词级别的索引（如第0个句子的第4个词）
select_word_index = [4, 2, 0, 8, 2, 0, 0, 4, 0, 0]

# 计算两个向量之间的欧几里得距离（L2范数）
def euclidean_distance(a, b):
    # np.linalg.norm(a - b) 计算的是 √((a1 - b1)^2 + ... + (an - bn)^2)
    return np.linalg.norm(a - b)

# 计算两个向量之间的余弦相似度： cos(θ) = (a·b) / (||a||*||b||)
def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 设置用于词向量比较的相似度/距离度量方法
# 可选项：euclidean_distance 或 cosine_similarity
METRIC = euclidean_distance  # 如果你想改为余弦相似度，可以改为 cosine_similarity

# 获取指定词在指定层的 BERT 输出中的嵌入表示
def get_select_embedding(output, tokenized_sentence, select_word_index):
    LAYER = 12  # 选择第几层的输出向量（0 为 embedding 层，1~12 为 Transformer 层）

    # output.hidden_states 是一个包含13层输出的元组 (embedding + 12 layers)
    # [LAYER][0] 取出对应层的 [batch, seq_len, hidden_size]，我们只处理 batch_size = 1 的情况
    hidden_state = output.hidden_states[LAYER][0]

    # 将词级别索引映射为 token 级别的起始下标
    # .word_to_tokens(index) 会返回一个 Span，其中包含该词所对应的 token 区间 [start, end)
    select_token_span = tokenized_sentence.word_to_tokens(select_word_index)

    if select_token_span is None:
        raise ValueError(f"The word index {select_word_index} could not be mapped to tokens.")

    # 取该词对应的第一个 token 的索引来代表整个词（可选策略：也可以取平均）
    select_token_index = select_token_span.start

    # 返回该 token 的向量，并转为 numpy
    return hidden_state[select_token_index].detach().cpu().numpy()

Attacks in NLP

Introduction

In the past, we only focus on attacks in computer vision or audio. The input space for image or audio are vectors in ℝⁿ, but the input space in NLP are words/tokens. To feed those tokens into a model, we need to map each token into a continuous vector. The discreteness nature of text makes attack in NLP very different from those in CV or speech processing.

Evasion Attacks and Defenses

Introduction

Evasion Attacks in Computer Vision

Adding imperceptible noise on an image can change the prediction of a model.

Evasion Attacks in NLP

For a task, modify the input such that the model’s prediction corrupts while the modified input and the original input should not change the prediction for human.

对于一个任务，修改输入使得模型的预测结果被干扰（或破坏），而修改后的输入与原始输入在人类看来不应改变其预测结果。

• Sentiment Analysis

• Dependency Parsing

• Machine Translation

Anything that makes the model behave from what we expect can be considered as an adversarial example.

Four Ingredients in Evasion Attacks

Goal

What the attack aims to achieve.

• Untargeted classification: Make the model misclassify the input example.

• Targeted classification: Make the model to classify samples having ground truth of class 𝐴 into another class 𝐵.

• Universal suffix dropper(通用后缀去除器): Make the translated sentence to drop some suffix.

• Wrong parse tree in dependency parsing

Transformations

How to construct perturbations(扰动) for possible adversaries.

Word Level

• Word substitution by WordNet synonyms(通过WordNet同义词进行词语替换)

WordNet 是一个英语词汇数据库，由普林斯顿大学开发，它将词汇（名词、动词、形容词、副词）组织成同义词集合（synsets），并用语义关系（如同义、反义、上下位）将它们连接起来。

将原始句子中的某个单词，用其在 WordNet 中的同义词进行替换，以保持句子原意的前提下，生成一个语义等价但表述不同的句子。

• Word substitution by 𝑘NN or 𝜀-ball in counter-fitted GloVe embedding space(利用通过counter-fitting技术增强的 GloVe 向量）进行语义保持的对抗词替换)

GloVe（Global Vectors for Word Representation）是一种无监督学习的词嵌入方法，通过统计词与词之间的共现频率来学习词向量，使得语义上相近的词具有相近的向量表示。

Counter-fitted GloVe 是一种经过后处理（post-processing）的 GloVe 向量，目的在于：

• 拉近语义相似词（synonyms）的向量距离
• 推远语义相反词（antonyms）的向量距离

• Word substitution by BERT masked language modeling (MLM) prediction

利用 BERT 的预测能力进行上下文敏感的词替换，主要过程如下：

1. 选中目标词，将其替换为 [MASK]。
2. 使用 BERT 模型对 [MASK] 位置进行预测，输出 Top-k 可能的词。
3. 从中筛选语义相近或语法合适的词作为替换词，构造新句子。

• Word substitution by BERT reconstruction (no masking)

利用 BERT 对句子中每个单词的上下文感知向量表示，判断该词是否与其上下文一致，并选择可能的替代词。

• Word substitution by changing the inflectional form of verbs, nouns and adjectives

Inflectional morpheme: an affix that never changes the basic meaning of a word, and are indicative/characteristic of the part of speech (POS)

屈折词缀：一种不改变词语基本含义的附加成分（词缀），它通常用来表示或标示词性（词类）特征。

• Word substitution by gradient of the word embedding

通过计算模型对输入词嵌入的梯度，找到最“敏感”的词，并替换为能引起模型输出变化的相似词，从而探测或攻击模型的鲁棒性。

• Word insertion based on BERT MLM

利用 BERT 预训练语言模型的上下文预测能力，在文本中插入新词

• Word deletion

Char Level

• Swap
• Substitution
• Deletion
• Insertion

Constrains

What a valid adversarial example should satisfy.

Overlap between the transformed sample and the original sample

• Levenshtein edit distance

Levenshtein Edit Distance（莱文斯坦编辑距离）常被用作约束条件（Constraints）之一，以控制对输入文本进行扰动（perturbation）的幅度，使得修改后的文本保持原始语义或形式的可接受性，而又能欺骗目标模型。

• Maximum percentage of modified words

Grammaticality of the perturbed sample

• Part of speech (POS,词性) consistency

• Number of grammatical errors (evaluated by some toolkit)

• Fluency scored by the perplexity of a pre-trained language model

通过预训练语言模型的困惑度评估文本流畅性。

Semantic preserving

变换后的样本与原始样本的语义相似性。

• Distance of the swapped word’s embedding and the original word’s embedding

• Similarity between the transformed sample’s sentence embedding and the original sample’s sentence embedding

Search Method

How to find an adversarial example from the transformations that satisfies the constrains and meets the goal.

Greedy Search

Score the each transformation at each position, and then replace the words in decreasing order of the score until the prediction flips.

为输入中每个位置的所有变换打分，并按照得分从高到低依次替换词语，直到模型预测发生变化。

Greedy search with word importance ranking (WIR)

• Step 1: Score each word’s importance