论文解读：BERT探索笔记(BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding)_bert :pre-training

论文解读：BERT探索笔记(BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding)

• 论文：BERT：Pre-training of Deep Bidirectional Transformers for Language Understanding

• 官方代码 - https://github.com/ google-research/bert

• 参考学习的代码

  • https://github.com/graykode/nlp-tutorial/tree/master/5-2.BERT

本文目的： BERT是如何制作训练样本？ 以及如何训练的，重点关注数据处理部分！

如何训练NLP模型，即目标函数是啥？这样的问题一直是NLP的一个重要问题，通常会预测下一个单词(e.g. “The child came home from ___”) 。

下面看一下BERT是如何做数据的预处理，以及目标函数的确立是如何构建，BERT有两种训练策略：

策略一，Masked LM (MLM)

一个句子：The child came home from China
BERT处理成： The child [MASK] home from China,

第一，
The child [MASK] home from China, 以此作为模型的输入，预测的时候，会根据没有被[MASK]的词所提供的有效信息去预测被[MASK]的真实词。 也就是 The child [MASK] home from China。中的[MASK]真实值是什么？

第二，
没有被[MASK]的词，BERT是忽略掉它们的梯度反馈，也就是没有梯度反馈；只有被[MASK]的词，才有梯度反馈，看下文的图，只有w4是有梯度反馈， w1,w2,w3,w5的输出是不计LOSS的。所以论文中也提到，这样的训练方式会导致收敛速度慢，但是只要效果好，再多训练2天，也无所谓。

第三，
制作[MASK]数据，也就是制作训练样本（一个句子，就是一个样本），论文中提到，每一个句子中有15%的词会被MASK，即假设一个句子有20个字，则有3个词会被MASK；拓展一下，这个15%是可以调的参数，改一下，或许又是大力出奇迹。

本来随机抽出来的15%应该是全部打上 [MASK]的，在下文给出的代码中，针对随机出来的15%，还进一步做特殊的随机处理。
80% 直接打上[MASK]标记
10% 不做任何处理，也就是还是原来的真实值
10% 打上其他词，即不是[MASK]，也不是真实值。

具体的随机细节，看下面的对应代码：

# cand_maked_pos 是随机出来的15%，将要被打上[MASK]位置， 本来是直接全部打上[MASK]
for pos in cand_maked_pos[:n_pred]:## 取其中的三个；masked_pos=[6, 5, 17] 注意这里对应的是position信息；masked_tokens=[13, 9, 16] 注意这里是被mask的元素之前对应的原始单字数字；
            masked_pos.append(pos)
            masked_tokens.append(input_ids[pos])
            if random() < 0.8:  # 80%
                input_ids[pos] = word_dict['[MASK]'] # make mask
            elif random() < 0.5:  # 10%
                index = randint(0, vocab_size - 1) # random index in vocabulary
                input_ids[pos] = word_dict[number_dict[index]] # replace
1
2
3
4
5
6
7
8
9

这样处理，效果有提升？ 这个我没有去验证，知道的道友，评论区留意指点一下，十分感谢。

往下走，数据流是如何输入和输出，看下图，

1. 在Encoder层的输出中，添加一个分类层，用来预测[MASK]的真实值（“The child [MASK] home from China”， 例子中是 came），
2. 分类层的输出再乘以embedding matrix
3. 最后做 softmax，预测概率得分
   
   (图片来源 | https://towardsdatascience.com/bert-explained-state-of-the-art-language-model-for-nlp-f8b21a9b6270)

策略二，Next Sentence Prediction (NSP)

这个策略，是用来训练模型，判断输入的两个句子是否是相连的？

看下图，图中左边对应着不同的数据编码，分别是Positional Embeddings， Segment Embeddings， Token Embeddings，下面详解介绍一下他们代表着什么意思？

首先，理解一个概念 pairs of sentences（句子对），什么是“句子对”？
假设训练样本为n个句子， 随机选择2个句子做拼接，称之为“句子对”。 比如上图中的

[CLS] my dog E[CLS] Emy Edog is cute [SEP] he likes play ##ing [SEP]
1

这就是一个“句子对”，训练BERT时，喂进去的就是该样式的数据，其中， [CLS] ，[SEP]是特殊字符。

数据预测处理

# n=6个句子，作为训练样本
text = (
    'Hello, how are you? I am Romeo.\n'
    'Hello, Romeo My name is Juliet. Nice to meet you.\n'
    'Nice meet you too. How are you today?\n'
    'Great. My baseball team won the competition.\n'
    'Oh Congratulations, Juliet\n'
    'Thanks you Romeo'
)
1
2
3
4
5
6
7
8
9

随机选择2个句子：
Oh Congratulations, Juliet + Thanks you Romeo，两个句子是相邻的“句子对”，论文中称之为正样本
Nice meet you too. How are you today? + Thanks you Romeo 两个句子是不相邻的“句子对”，论文称之为负样本

具体拼接，“句子对”前面加上[CLS]，标记正样本或者负样本， 每个句子结尾加上[SEP]，如下
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP]

详解介绍数据处理步骤：
第一步，Transformer Positional Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 先做位置编码，这个和Transformer论文一样，对词做sin,con位置编码

第二步，Sentence Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 做句子的01区分，
第一个句子，Oh Congratulations Juliet [SEP]， 每个词用0表示：0 0 0 0 ，
第二个句子，Thanks you Romeo [SEP]， 每个词用1表示 1 1 1 1，
那[CLS]呢？ CLS是标记“句子对”是正样本或者负样本， 取值0或1。 （这里有个问题？取值0或1，与第二步的Sentence Embedding是否冲突，具体需要进一步看代码）。

（图片来源 | 论文解读：Bert原理深入浅出）

第三步， Token Embedding
[CLS] Oh Congratulations Juliet [SEP] Thanks you Romeo [SEP] 每个词做词编码

（图片来源 | 论文解读：Bert原理深入浅出）

3个步骤，需要注意的：

1. 特殊字符的编码，[MASK], [CLS], [SEP]
2. 第一步和第三步的编码是和Transformer一致，第二步的0-1划分，是区分“句子对”中的不同句子；拓展一下，会不会做3个句子，4个句子的拼接训练呢？
3. 最后，叠加上面3个Embedding输出的向量值，就得到 训练BERT时的输入。

（图片来源 | The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning)）

训练

1. 训练BERT时，是两个策略Masked LM 和 Next Sentence Prediction一起同时训练，两个loss相加作为梯度反馈。也就是说训练的“句子对”最终是如下样式：

   [CLS] Oh Congratulations Juliet [SEP] Thanks [MASK] Romeo [SEP] 
   1

   而且，作为特殊字符[CLS], [SEP]，共3个位置，这3个位置不能被标记为[MASK] 。

2. 上文中提到的正样本和负样本，在每一个训练的batch中，各占50%；拓展一下，这个参数又是可调的，说不定可以大力出奇迹。

3. Masked LM Loss, 把做了MASK标记的词，预测出来，也就是预测真实值，这个第一个LOSS。

4. Next Sentence Prediction Loss, 对应的是[CLS]输出值，判断“句子对”中的两个句子是否是相邻，相邻[CLS]输出值接近1，不相邻[CLS]输出值接近0，这是第二个LOSS。

5. 两个LOSS相加，就可以了，拓展一下，两个LOSS相加是否带权重呢！

参考文章

• BERT Explained: State of the art language model for NLP
• The Illustrated BERT, ELMo, and co. (How NLP Cracked Transfer Learning)

调试代码

一个简单的BERT代码，主要用来研究学习BERT的基本原理。

## from https://github.com/graykode/nlp-tutorial/tree/master/5-2.BERT
import math
import re
from random import *
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

# sample IsNext and NotNext to be same in small batch size

# sentences 样本库，一个样本就是一个句子
# tokens_a_index，tokens_b_index 随机选择2个句子
# tokens_a, tokens_b 把a,b两个句子转换为 数字，也就是句子用数字来表示，简称 数字句子
# input_ids 把两个数字句子拼接，同时在index=0，设置'[CLS]', 在第一个数字句子设置'[SEP]',在第二个数字句子设置'[SEP]'。 ==》 '[CLS]' + 句子1 + '[SEP]' + 句子2 + '[SEP]'
# segment_ids 分割两个句子， '[CLS]' + 句子1 + '[SEP]' 设置为0， 句子2 + '[SEP]'设置为1
# n_pred 句子中要打mask的个数
# cand_maked_pos 打mask的位置（index）不能是'[CLS]'，'[SEP]'，'[SEP]'， 打mask的位置（index）是随机的，当然也有很多方式
# masked_tokens, masked_pos, 记录被打mask的真实数字，以及他的位置（index）

# batch ==>[input_ids, segment_ids, masked_tokens, masked_pos, False|True]
def make_batch():
    batch = []
    positive = negative = 0 ## 为了记录NSP任务中的正样本和负样本的个数，比例最好是在一个batch中接近1：1
    while positive != batch_size/2 or negative != batch_size/2:
        tokens_a_index, tokens_b_index= randrange(len(sentences)), randrange(len(sentences)) # 比如tokens_a_index=3，tokens_b_index=1；从整个样本中抽取对应的样本；
        tokens_a, tokens_b= token_list[tokens_a_index], token_list[tokens_b_index]## 根据索引获取对应样本：tokens_a=[5, 23, 26, 20, 9, 13, 18] tokens_b=[27, 11, 23, 8, 17, 28, 12, 22, 16, 25]
        input_ids = [word_dict['[CLS]']] + tokens_a + [word_dict['[SEP]']] + tokens_b + [word_dict['[SEP]']] ## 加上特殊符号，CLS符号是1，sep符号是2：[1, 5, 23, 26, 20, 9, 13, 18, 2, 27, 11, 23, 8, 17, 28, 12, 22, 16, 25, 2]
        segment_ids = [0] * (1 + len(tokens_a) + 1) + [1] * (len(tokens_b) + 1)##分割句子符号：[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

        # MASK LM
        n_pred =  min(max_pred, max(1, int(round(len(input_ids) * 0.15)))) # n_pred=3；整个句子的15%的字符可以被mask掉，这里取和max_pred中的最小值，确保每次计算损失的时候没有那么多字符以及信息充足，有15%做控制就够了；其实可以不用加这个，单个句子少了，就要加上足够的训练样本
        cand_maked_pos = [i for i, token in enumerate(input_ids)
                          if token != word_dict['[CLS]'] and token != word_dict['[SEP]']] ## cand_maked_pos=[1, 2, 3, 4, 5, 6, 7, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]；整个句子input_ids中可以被mask的符号必须是非cls和sep符号的，要不然没意义
        shuffle(cand_maked_pos)## 打乱顺序：cand_maked_pos=[6, 5, 17, 3, 1, 13, 16, 10, 12, 2, 9, 7, 11, 18, 4, 14, 15]  其实取mask对应的位置有很多方法，这里只是一种使用shuffle的方式
        masked_tokens, masked_pos = [], []
        for pos in cand_maked_pos[:n_pred]:## 取其中的三个；masked_pos=[6, 5, 17] 注意这里对应的是position信息；masked_tokens=[13, 9, 16] 注意这里是被mask的元素之前对应的原始单字数字；
            masked_pos.append(pos)
            masked_tokens.append(input_ids[pos])
            if random() < 0.8:  # 80%
                input_ids[pos] = word_dict['[MASK]'] # make mask
            elif random() < 0.5:  # 10%
                index = randint(0, vocab_size - 1) # random index in vocabulary
                input_ids[pos] = word_dict[number_dict[index]] # replace

        # Zero Paddings
        n_pad = maxlen - len(input_ids)##maxlen=30；n_pad=10
        input_ids.extend([0] * n_pad)#在input_ids后面补零
        segment_ids.extend([0] * n_pad)# 在segment_ids 后面补零；这里有一个问题，0和之前的重了，这里主要是为了区分不同的句子，所以无所谓啊；他其实是另一种维度的位置信息；

        # Zero Padding (100% - 15%) tokens 是为了计算一个batch中句子的mlm损失的时候可以组成一个有效矩阵放进去；不然第一个句子预测5个字符，第二句子预测7个字符，第三个句子预测8个字符，组不成一个有效的矩阵；
        ## 这里非常重要，为什么是对masked_tokens是补零，而不是补其他的字符？？？？我补1可不可以？？
        if max_pred > n_pred:
            n_pad = max_pred - n_pred
            masked_tokens.extend([0] * n_pad)##  masked_tokens= [13, 9, 16, 0, 0] masked_tokens 对应的是被mask的元素的原始真实标签是啥，也就是groundtruth
            masked_pos.extend([0] * n_pad)## masked_pos= [6, 5, 17，0，0] masked_pos是记录哪些位置被mask了

        # 如果随机选出来的2个句子是相邻的，作为正样本，反之，负样本
        if tokens_a_index + 1 == tokens_b_index and positive < batch_size/2:
            batch.append([input_ids, segment_ids, masked_tokens, masked_pos, True]) # IsNext
            positive += 1
        elif tokens_a_index + 1 != tokens_b_index and negative < batch_size/2:
            batch.append([input_ids, segment_ids, masked_tokens, masked_pos, False]) # NotNext
            negative += 1
    return batch
# Proprecessing Finished

def get_attn_pad_mask(seq_q, seq_k):
    batch_size, len_q = seq_q.size()
    batch_size, len_k = seq_k.size()
    # eq(zero) is PAD token
    pad_attn_mask = seq_k.data.eq(0).unsqueeze(1)  # batch_size x 1 x len_k(=len_q), one is masking
    return pad_attn_mask.expand(batch_size, len_q, len_k)  # batch_size x len_q x len_k

def gelu(x):
    "Implementation of the gelu activation function by Hugging Face"
    return x * 0.5 * (1.0 + torch.erf(x / math.sqrt(2.0)))

class Embedding(nn.Module):
    def __init__(self):
        super(Embedding, self).__init__()
        self.tok_embed = nn.Embedding(vocab_size, d_model)  # token embedding
        self.pos_embed = nn.Embedding(maxlen, d_model)  # position embedding
        self.seg_embed = nn.Embedding(n_segments, d_model)  # segment(token type) embedding
        self.norm = nn.LayerNorm(d_model)

    def forward(self, x, seg):
        seq_len = x.size(1)
        pos = torch.arange(seq_len, dtype=torch.long)
        pos = pos.unsqueeze(0).expand_as(x)  # (seq_len,) -> (batch_size, seq_len)
        embedding = self.tok_embed(x) + self.pos_embed(pos) + self.seg_embed(seg)
        return self.norm(embedding)

class ScaledDotProductAttention(nn.Module):
    def __init__(self):
        super(ScaledDotProductAttention, self).__init__()

    def forward(self, Q, K, V, attn_mask):
        scores = torch.matmul(Q, K.transpose(-1, -2)) / np.sqrt(d_k) # scores : [batch_size x n_heads x len_q(=len_k) x len_k(=len_q)]
        scores.masked_fill_(attn_mask, -1e9) # Fills elements of self tensor with value where mask is one.
        attn = nn.Softmax(dim=-1)(scores)
        context = torch.matmul(attn, V)
        return context, attn

class MultiHeadAttention(nn.Module):
    def __init__(self):
        super(MultiHeadAttention, self).__init__()
        self.W_Q = nn.Linear(d_model, d_k * n_heads)
        self.W_K = nn.Linear(d_model, d_k * n_heads)
        self.W_V = nn.Linear(d_model, d_v * n_heads)
    def forward(self, Q, K, V, attn_mask):
        # q: [batch_size x len_q x d_model], k: [batch_size x len_k x d_model], v: [batch_size x len_k x d_model]
        residual, batch_size = Q, Q.size(0)
        # (B, S, D) -proj-> (B, S, D) -split-> (B, S, H, W) -trans-> (B, H, S, W)
        q_s = self.W_Q(Q).view(batch_size, -1, n_heads, d_k).transpose(1,2)  # q_s: [batch_size x n_heads x len_q x d_k]
        k_s = self.W_K(K).view(batch_size, -1, n_heads, d_k).transpose(1,2)  # k_s: [batch_size x n_heads x len_k x d_k]
        v_s = self.W_V(V).view(batch_size, -1, n_heads, d_v).transpose(1,2)  # v_s: [batch_size x n_heads x len_k x d_v]

        attn_mask = attn_mask.unsqueeze(1).repeat(1, n_heads, 1, 1) # attn_mask : [batch_size x n_heads x len_q x len_k]

        # context: [batch_size x n_heads x len_q x d_v], attn: [batch_size x n_heads x len_q(=len_k) x len_k(=len_q)]
        context, attn = ScaledDotProductAttention()(q_s, k_s, v_s, attn_mask)
        context = context.transpose(1, 2).contiguous().view(batch_size, -1, n_heads * d_v) # context: [batch_size x len_q x n_heads * d_v]
        output = nn.Linear(n_heads * d_v, d_model)(context)
        return nn.LayerNorm(d_model)(output + residual), attn # output: [batch_size x len_q x d_model]

class PoswiseFeedForwardNet(nn.Module):
    def __init__(self):
        super(PoswiseFeedForwardNet, self).__init__()
        self.fc1 = nn.Linear(d_model, d_ff)
        self.fc2 = nn.Linear(d_ff, d_model)

    def forward(self, x):
        # (batch_size, len_seq, d_model) -> (batch_size, len_seq, d_ff) -> (batch_size, len_seq, d_model)
        return self.fc2(gelu(self.fc1(x)))

class EncoderLayer(nn.Module):
    def __init__(self):
        super(EncoderLayer, self).__init__()
        self.enc_self_attn = MultiHeadAttention()
        self.pos_ffn = PoswiseFeedForwardNet()

    def forward(self, enc_inputs, enc_self_attn_mask):
        enc_outputs, attn = self.enc_self_attn(enc_inputs, enc_inputs, enc_inputs, enc_self_attn_mask) # enc_inputs to same Q,K,V
        enc_outputs = self.pos_ffn(enc_outputs) # enc_outputs: [batch_size x len_q x d_model]
        return enc_outputs, attn

## 1. BERT模型整体架构
class BERT(nn.Module):
    def __init__(self):
        super(BERT, self).__init__()
        self.embedding = Embedding() ## 词向量层，构建词表矩阵
        self.layers = nn.ModuleList([EncoderLayer() for _ in range(n_layers)]) ## 把N个encoder堆叠起来，具体encoder实现一会看
        self.fc = nn.Linear(d_model, d_model) ## 前馈神经网络-cls
        self.activ1 = nn.Tanh() ## 激活函数-cls
        self.linear = nn.Linear(d_model, d_model)#-mlm
        self.activ2 = gelu ## 激活函数--mlm
        self.norm = nn.LayerNorm(d_model)
        self.classifier = nn.Linear(d_model, 2)## cls 这是一个分类层，维度是从d_model到2，对应我们架构图中就是这种：
        # decoder is shared with embedding layer
        embed_weight = self.embedding.tok_embed.weight
        n_vocab, n_dim = embed_weight.size()
        self.decoder = nn.Linear(n_dim, n_vocab, bias=False)
        self.decoder.weight = embed_weight
        self.decoder_bias = nn.Parameter(torch.zeros(n_vocab))

    def forward(self, input_ids, segment_ids, masked_pos):
        output = self.embedding(input_ids, segment_ids)## 生成input_ids对应的embdding；和segment_ids对应的embedding
        enc_self_attn_mask = get_attn_pad_mask(input_ids, input_ids)
        for layer in self.layers:
            output, enc_self_attn = layer(output, enc_self_attn_mask)
        # output : [batch_size, len, d_model], attn : [batch_size, n_heads, d_mode, d_model]
        # it will be decided by first token(CLS)
        h_pooled = self.activ1(self.fc(output[:, 0])) # [batch_size, d_model]
        logits_clsf = self.classifier(h_pooled) # [batch_size, 2]

        masked_pos = masked_pos[:, :, None].expand(-1, -1, output.size(-1)) # [batch_size, max_pred, d_model]  其中一个 masked_pos= [6, 5, 17，0，0]
        # get masked position from final output of transformer.
        h_masked = torch.gather(output, 1, masked_pos) # masking position [batch_size, max_pred, d_model]
        h_masked = self.norm(self.activ2(self.linear(h_masked)))
        logits_lm = self.decoder(h_masked) + self.decoder_bias # [batch_size, max_pred, n_vocab]

        return logits_lm, logits_clsf

if __name__ == '__main__':
    # BERT Parameters
    maxlen = 30 # 句子的最大长度 cover住95% 不要看平均数 或者99%  直接取最大可以吗？当然也可以，看你自己
    batch_size = 6 # 每一组有多少个句子一起送进去模型
    max_pred = 5  # max tokens of prediction
    n_layers = 6 # number of Encoder of Encoder Layer
    n_heads = 12 # number of heads in Multi-Head Attention
    d_model = 768 # Embedding Size
    d_ff = 3072  # 4*d_model, FeedForward dimension
    d_k = d_v = 64  # dimension of K(=Q), V
    n_segments = 2

    text = (
        'Hello, how are you? I am Romeo.\n'
        'Hello, Romeo My name is Juliet. Nice to meet you.\n'
        'Nice meet you too. How are you today?\n'
        'Great. My baseball team won the competition.\n'
        'Oh Congratulations, Juliet\n'
        'Thanks you Romeo'
    )
    sentences = re.sub("[.,!?\\-]", '', text.lower()).split('\n')  # filter '.', ',', '?', '!'
    word_list = list(set(" ".join(sentences).split()))
    word_dict = {'[PAD]': 0, '[CLS]': 1, '[SEP]': 2, '[MASK]': 3}
    for i, w in enumerate(word_list):
        word_dict[w] = i + 4
    number_dict = {i: w for i, w in enumerate(word_dict)}
    vocab_size = len(word_dict)

    token_list = list()
    for sentence in sentences:
        arr = [word_dict[s] for s in sentence.split()]
        token_list.append(arr)

    batch = make_batch()
    input_ids, segment_ids, masked_tokens, masked_pos, isNext = map(torch.LongTensor, zip(*batch))


    model = BERT()
    criterion = nn.CrossEntropyLoss(ignore_index=0)
    optimizer = optim.Adam(model.parameters(), lr=0.001)



    for epoch in range(100):
        optimizer.zero_grad()
        logits_lm, logits_clsf = model(input_ids, segment_ids, masked_pos)## logits_lm 【6，5，29】 bs*max_pred*voca  logits_clsf:[6*2]
        loss_lm = criterion(logits_lm.transpose(1, 2), masked_tokens) # for masked LM ;masked_tokens [6,5]
        loss_lm = (loss_lm.float()).mean()
        loss_clsf = criterion(logits_clsf, isNext) # for sentence classification
        loss = loss_lm + loss_clsf
        if (epoch + 1) % 10 == 0:
            print('Epoch:', '%04d' % (epoch + 1), 'cost =', '{:.6f}'.format(loss))
        loss.backward()
        optimizer.step()

    # Predict mask tokens ans isNext
    input_ids, segment_ids, masked_tokens, masked_pos, isNext = map(torch.LongTensor, zip(batch[0]))
    print(text)
    print([number_dict[w.item()] for w in input_ids[0] if number_dict[w.item()] != '[PAD]'])

    logits_lm, logits_clsf = model(input_ids, segment_ids, masked_pos)
    logits_lm = logits_lm.data.max(2)[1][0].data.numpy()
    print('masked tokens list : ',[pos.item() for pos in masked_tokens[0] if pos.item() != 0])
    print('predict masked tokens list : ',[pos for pos in logits_lm if pos != 0])

    logits_clsf = logits_clsf.data.max(1)[1].data.numpy()[0]
    print('isNext : ', True if isNext else False)
    print('predict isNext : ',True if logits_clsf else False)
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
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252

群交流

AIGC，CV，NLP等学习者，技术大佬等交流兰亭之地，不卖书，不卖课。

END

---