精华内容
下载资源
问答
  • language model
    千次阅读 多人点赞
    2021-11-20 15:08:38

    1. 关于MLM

    1.1 什么是MLM

    作为Bert预训练的两大任务之一,MLMNSP大家应该并不陌生,其中NSP任务在后续的一些预训练任务中经常被嫌弃,例如Roberta中将NSP任务直接放弃,Albert中将NSP替换成了句子顺序预测,这是由于NSP作为一个分类任务过于简单,对模型的学习并没有太大的帮助,而MLM则被多数预训练模型保留下来。由Roberta的实验结果也可以证明,Bert的主要能力应该是来自于MLM任务的训练。

    Bert为代表的预训练语言模型是在大规模预料的基础上训练以获得的基础的学习能力,而实际应用时,我们所面临的预料或许具有某些特殊性,这就使得重新进行MLM训练具有了必要性。

    1.2 怎样进行MLM训练

    MLM的训练,在不同的预训练模型中其实是有所不同的,今天介绍的内容以最基础的Bert为例。Bert的MLM是静态mask,而在后续的其他预训练模型中,这一策略通常被替换成了动态mask。除此之外还有whole word mask的模型,这些都不在今天的讨论范围内。

    所谓mask language model的任务,通俗来讲,就是将句子中的一部分token替换掉,然后根据句子的剩余部分,试图去还原这部分被mask的token。

    mask的比列一般是15%,这一比例也被后续的多数模型所继承,而在最初BERT的论文中,没有对这一比例的界定给出具体的说明。在我印象中,似乎是知道后来同样是Google提出的T5模型的论文中,对此进行了解释,对mask的比例进行了实验,最终得出结论,15%的比例是最合理的(如果我记错了,还请指正)。

    15%的token选出之后,并不是所有的都替换成[mask]标记符,而是从这15%选出的部分中,将其中的80%替换成[mask],10%替换成一个随机的token,剩下的10%保留原来的token。这样做可以提高模型的鲁棒性。这个比例也可以自己控制。

    到这里可能有同学要问了,既然有10%保留不变的话,为什么不干脆只选择15%*90% = 13.5%的token呢?如果看完后面的代码,就会很清楚的理解这个问题了。

    因为MLM的任务是将选出的这15%的token全部进行预测,不管这个token是否被替换成了[mask],也就是说,即使它被保留了原样,也还是需要被预测的。

    介绍完了基础内容之后,接下来的内容,我将基于transformers模块,介绍如何进行mask language model的训练。

    2. 代码部分

    其实transformers模块中,本身是提供了MLM训练任务的,模型都写好了,只需要调用它内置的trainer和datasets模块即可。感兴趣的同学可以去huggingface的官网搜索相关教程。

    然而我觉得datasets每次调用的时候都要去写数据集的py文件,对arrow的数据格式不熟悉的话还很容易出错,而且trainer我觉得也不是很好用,任何一点小小的修改都挺费劲(就是它以为它写的很完备,考虑了用户的所有需求,但是实际上有一些冗余的部分)。

    所以我就参考它的实现方式,把它的代码拆解,又按照自己的方式重新组织了一下。

    2.1 准备工作

    首先在写核心代码之前,先做好准备工作。
    import 所有需要的模块:

    import os
    import json
    import copy
    from tqdm.notebook import tqdm
    
    import torch
    from torch.optim import AdamW
    from torch.utils.data import DataLoader, Dataset
    from transformers import BertForMaskedLM, BertTokenizerFast
    

    写一个config类,将所有参数集中起来:

    class Config:
        def __init__(self):
            pass
        
        def mlm_config(
            self, 
            mlm_probability=0.15, 
            special_tokens_mask=None,
            prob_replace_mask=0.8,
            prob_replace_rand=0.1,
            prob_keep_ori=0.1,
        ):
            """
            :param mlm_probability: 被mask的token总数
            :param special_token_mask: 特殊token
            :param prob_replace_mask: 被替换成[MASK]的token比率
            :param prob_replace_rand: 被随机替换成其他token比率
            :param prob_keep_ori: 保留原token的比率
            """
            assert sum([prob_replace_mask, prob_replace_rand, prob_keep_ori]) == 1,                 ValueError("Sum of the probs must equal to 1.")
            self.mlm_probability = mlm_probability
            self.special_tokens_mask = special_tokens_mask
            self.prob_replace_mask = prob_replace_mask
            self.prob_replace_rand = prob_replace_rand
            self.prob_keep_ori = prob_keep_ori
            
        def training_config(
            self,
            batch_size,
            epochs,
            learning_rate,
            weight_decay,
            device,
        ):
            self.batch_size = batch_size
            self.epochs = epochs
            self.learning_rate = learning_rate
            self.weight_decay = weight_decay
            self.device = device
            
        def io_config(
            self,
            from_path,
            save_path,
        ):
            self.from_path = from_path
            self.save_path = save_path
    

    然后设置各种配置:

    config = Config()
    config.mlm_config()
    config.training_config(batch_size=4, epochs=10, learning_rate=1e-5, weight_decay=0, device='cuda:0')
    config.io_config(from_path='/data/BERTmodels/huggingface/chinese_wwm/', 
                     save_path='./finetune_embedding_model/mlm/')
    

    然后创建BERT模型,注意,这里的tokenizer就是一个普通的tokenizer,而BERT模型则是带了下游任务的BertForMaskedLM,它是transformers中写好的一个类,

    bert_tokenizer = BertTokenizerFast.from_pretrained(config.from_path)
    bert_mlm_model = BertForMaskedLM.from_pretrained(config.from_path)
    

    2.2 数据集

    由于舍弃了datasets这个包,现在我们需要自己实现数据的输入了。方案就是使用torch的Dataset类。这个类一般在构建DataLoader的时候,会与一个聚合函数一起使用,以实现对batch的组织。而我这里偷个懒,就没有写聚合函数,batch的组织方法放在dataset中进行。

    在这个类中,有一个mask tokens的方法,是从数据中选择出所有需要mask的token,并且采用三种mask方式中的一个,这个方法是从transformers中拿出来的,将其从类方法转为静态方法测试之后,再将其放在自己的这个类中为我们所用。仔细阅读这一段代码,也就可以回答1.2中提出的那个问题了。

    取batch的原理很简单,一开始我们将原始数据deepcopy备份一下,然后每次从中截取一个batch的大小,这个时候的当前数据就少了一个batch,我们定义这个类的长度为当前长度除以batch size向下取整,所以当类的长度变为0的时候,就说明这一个epoch的所有step都已经执行结束,要进行下一个epoch的训练,此时,再将当前数据变为原始数据,就可以实现对epoch的循环了。

    class TrainDataset(Dataset):
        """
        注意:由于没有使用data_collator,batch放在dataset里边做,
        因而在dataloader出来的结果会多套一层batch维度,传入模型时注意squeeze掉
        """
        def __init__(self, input_texts, tokenizer, config):
            self.input_texts = input_texts
            self.tokenizer = tokenizer
            self.config = config
            self.ori_inputs = copy.deepcopy(input_texts)
            
        def __len__(self):
            return len(self.input_texts) // self.config.batch_size
        
        def __getitem__(self, idx):
            batch_text = self.input_texts[: self.config.batch_size]
            features = self.tokenizer(batch_text, max_length=512, truncation=True, padding=True, return_tensors='pt')
            inputs, labels = self.mask_tokens(features['input_ids'])
            batch = {"inputs": inputs, "labels": labels}
            self.input_texts = self.input_texts[self.config.batch_size: ]
            if not len(self):
                self.input_texts = self.ori_inputs
            
            return batch
            
        def mask_tokens(self, inputs):
            """
            Prepare masked tokens inputs/labels for masked language modeling: 80% MASK, 10% random, 10% original.
            """
            labels = inputs.clone()
            # We sample a few tokens in each sequence for MLM training (with probability `self.mlm_probability`)
            probability_matrix = torch.full(labels.shape, self.config.mlm_probability)
            if self.config.special_tokens_mask is None:
                special_tokens_mask = [
                    self.tokenizer.get_special_tokens_mask(val, already_has_special_tokens=True) for val in labels.tolist()
                ]
                special_tokens_mask = torch.tensor(special_tokens_mask, dtype=torch.bool)
            else:
                special_tokens_mask = self.config.special_tokens_mask.bool()
    
            probability_matrix.masked_fill_(special_tokens_mask, value=0.0)
            masked_indices = torch.bernoulli(probability_matrix).bool()
            labels[~masked_indices] = -100  # We only compute loss on masked tokens
    
            # 80% of the time, we replace masked input tokens with tokenizer.mask_token ([MASK])
            indices_replaced = torch.bernoulli(torch.full(labels.shape, self.config.prob_replace_mask)).bool() & masked_indices
            inputs[indices_replaced] = self.tokenizer.convert_tokens_to_ids(self.tokenizer.mask_token)
    
            # 10% of the time, we replace masked input tokens with random word
            current_prob = self.config.prob_replace_rand / (1 - self.config.prob_replace_mask)
            indices_random = torch.bernoulli(torch.full(labels.shape, current_prob)).bool() & masked_indices & ~indices_replaced
            random_words = torch.randint(len(self.tokenizer), labels.shape, dtype=torch.long)
            inputs[indices_random] = random_words[indices_random]
    
            # The rest of the time (10% of the time) we keep the masked input tokens unchanged
            return inputs, labels
    

    然后取一些用于训练的语料,格式很简单,就是把所有文本放在一个list里边,注意长度不要超过512个token,不然多出来的部分就浪费掉了。可以做适当的预处理。

    [
    	"这是一条文本",
    	"这是另一条文本",
    	...,
    ]
    

    然后构建dataloader:

    train_dataset = TrainDataset(training_texts, bert_tokenizer, config)
    train_dataloader = DataLoader(train_dataset)
    

    2.3 训练

    构建一个训练方法,输入参数分别是我们实例化好的待训练模型,数据集,还有config:

    def train(model, train_dataloader, config):
        """
        训练
        :param model: nn.Module
        :param train_dataloader: DataLoader
        :param config: Config
        ---------------
        ver: 2021-11-08
        by: changhongyu
        """
        assert config.device.startswith('cuda') or config.device == 'cpu', ValueError("Invalid device.")
        device = torch.device(config.device)
        
        model.to(device)
        
        if not len(train_dataloader):
            raise EOFError("Empty train_dataloader.")
            
        param_optimizer = list(model.named_parameters())
        no_decay = ["bias", "LayerNorm.bias", "LayerNorm.weight"]
        optimizer_grouped_parameters = [
            {"params": [p for n, p in param_optimizer if not any(nd in n for nd in no_decay)], "weight_decay": 0.01},
            {"params": [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], "weight_decay": 0.0}]
        
        optimizer = AdamW(params=optimizer_grouped_parameters, lr=config.learning_rate, weight_decay=config.weight_decay)
        
        for cur_epc in tqdm(range(int(config.epochs)), desc="Epoch"):
            training_loss = 0
            print("Epoch: {}".format(cur_epc+1))
            model.train()
            for step, batch in enumerate(tqdm(train_dataloader, desc='Step')):
                input_ids = batch['inputs'].squeeze(0).to(device)
                labels = batch['labels'].squeeze(0).to(device)
                loss = model(input_ids=input_ids, labels=labels).loss
                
                optimizer.zero_grad()
                loss.backward()
                optimizer.step()
                model.zero_grad()
                training_loss += loss.item()
            print("Training loss: ", training_loss)
    
    

    调用它训练几轮:

    train(model=bert_mlm_model, train_dataloader=train_dataloader, config=config)
    

    2.4 保存和加载

    使用过预训练模型的同学应该都了解,普通的bert有两项输出,分别是每一个token对应的768维编码结果,以及用于表征整个句子的句子特征。

    而这个句子特征,是由模型中的一个Pooler模块对原句池化得来的。可是,这个Pooler的训练,并不是由MLM任务来的,而是由NSP任务中来的。

    由于没有NSP任务,所以无法对Pooler进行训练,故而没有必要在模型中加入Pooler。

    所以在保存的时候需要分别保存embedding和encoder,
    加载的时候也需要分别读取embedding和encoder,这样训练出来的模型拿不到CLS层的句子表征,如果需要的话,可以手动pooling。

    torch.save(bert_mlm_model.bert.embeddings.state_dict(), os.path.join(config.save_path, 'bert_mlm_ep_{}_eb.bin'.format(config.epochs)))
    torch.save(bert_mlm_model.bert.encoder.state_dict(), os.path.join(config.save_path, 'bert_mlm_ep_{}_ec.bin'.format(config.epochs)))
    

    加载的话,也是实例化完bert模型之后,用bert的embedding组件和encoder组件分别读取这两个权重文件即可。

    到这里,本期内容就全部结束了,希望看完这篇博客的同学,能够对Bert的基础原理有更深入的了解。

    更多相关内容
  • REALM: Retrieval-Augmented Language Model Pre-Training 从ELMO、BERT和GPT到如今多种多样的预训练模型的横空出世,pre-training + fine-tune逐渐成为了NLP中建模的新范式,众多研究人员也不断的针对于...
  • 卡耐基梅隆大学cmu的著名的自然语言处理课程,对于自然语言处理领域的理论,进行了历史脉络发展的讲解,同时,对于现在的工业界使用的模型,也进行了详尽的介绍。
  • language model

    2016-01-08 21:10:41
    语言学习模型,是开源代码的结构类型,仅供参考
  • Empower Sequence Labeling with Task-Aware Neural Language Model
  • 吴恩达RNN编程作业:Character level language model - Dinosaurus land
  • A Neural Probabilistic Language Model
  • CNN+CTC_tutorial.ipynb为语音模型的教程,详细介绍了搭建网络的一步步的操作。 LanguageModel2.py为基于统计的语言模型,dict.txt为统计的字典。
  • Lexicon and Language Model

    2019-01-21 17:37:28
    Lexicon and Language Model 声学模型 语言模型 语音识别
  • 有关自然语言处理的分类算法讲解,是全英文的,需要花一定经历好好研读
  • 论文:BREAKING THE SOFTMAX BOTTLENECK A HIGH-RANK RNN LANGUAGE MODEL
  • 统计语言模型工具有比较多的选择,目前使用比较好的有srilm及kenlm,其中kenlm比srilm晚出来,训练速度也更快,而且支持单机大数据的训练。现在介绍一下kenlm的使用方法。
  • A Neural Probabilistic Language Model 本文于2003年第一次用神经网络来解决语言模型的问题,虽然在当时并没有得到太多的重视,却为后来深度学习在解决语言模型问题甚至很多别的nlp问题时奠定了坚实的基础,后人站...
  • Neural Network Language Model

    千次阅读 2021-10-24 14:05:08
    2003年,Bengio首次提出Neural Network Language Model(NNLM), 开创了神经网络运用在语言模型的先河,论文 《A Neural Probabilistic Language Model》 Neural Network Language Model(NNLM)神经网络语言模型 ...

    背景

    传统的统计语言模型的缺点,在高维的情况下,由于N元组的稀疏问题,传统的语言模型需要花大量时间解决平滑,插值等问题;N受限于算力,不大的时候文本的长距离依赖关系无法进行建模;同时N元组共现未必相似等问题。

    1. 由于维度灾难(特别是离散变量),在高维下,数据的稀缺性,导致统计语言模型存在很多为零的条件概率,传统的统计语言模型也花费了很大的精力来处理零概率问题,比如现在有很多的平滑、插值、回退等方法用来解决该问题。
    2. 语言模型的参数个数随阶数呈指数增长,所以一般情况统计语言模型使用的阶数不会很高,这样n-gram语言模型无法建模更远的关系。
    3. n-gram无法建模出多个相似词的关系。比如在训练集中有这样的句子,The cat is walking in the bedroom,但用n-gram测试时,遇到 A dog was running in a room这个句子,并不会因为两个句子非常相似而让该句子的概率变高。

    2003年,Bengio首次提出Neural Network Language Model(NNLM), 开创了神经网络运用在语言模型的先河,论文 《A Neural Probabilistic Language Model》

    Neural Network Language Model(NNLM)神经网络语言模型

    NNLN利用三层神经网络进行建模

    在这里插入图片描述

    模型结构

    在这里插入图片描述

    在这里插入图片描述





    个人理解示例

    输入层
    词库V 里有词n个,词库的大小就是n,词库的维数是n。V投影到矩阵C上,如下所示Cn×d
    在这里插入图片描述
    有一个句子,句子包含的词按照顺序为“w1,w1…wt”,我们的目的是输入t-1个词,去预测第t个词。
    对句子里的词按顺序进行向量化编码
    因此 “w1” 的one-hot编码为:[1,0,0,0,0,0…,0]
    词语 “w2” 的one-hot编码为:[0,1,0,0,0,0…,0]
    词语 “w3” 的one-hot编码为:[0,0,1,0,0,0…,0]
    以此类推到wt,这些词的向量的维度为d 。
    将前t-1个向量合并起来的句子向量作为隐藏层的输入,输入的向量维度为(t−1) ⋅ d ,记 X = (t-1)⋅ d

    隐藏层
    隐藏层和输入层之间是全连接,隐藏层的神经元激活函数是tanh,隐藏层的神经元个数为h(从隐藏层输出的个数也是h)。

    tanh函数如下所示
    在这里插入图片描述
    记 H为 (t-1)⋅ d⋅h 大小的的矩阵 (h为神经元个数)
    b为长度是h的向量,tanh()函数的输入为 H⋅X +b
    隐藏层的输出就如下所示:
    tanh(H⋅X+b),X是权重,b是偏置


    输出层

    隐藏层到输出层也是全连接
    输出层的输入是依赖于隐藏层的输出和隐藏层的输入之和,即输出层的输入为

    y = K⋅tanh(D⋅X+b) + Mx + L

    M为t ∗ d ⋅ ( t−1 ) 大小的矩阵, 是输入层到输出层的值的参数;K为t隐藏层到输出层输出的值的参数;L是偏置。

    通过softmax函数,每个神经元的节点即为t时刻出现第i个词的概率
    在这里插入图片描述

    模型的损失函数是
    在这里插入图片描述
    其中θ为模型所有参数,R(θ)是正则化,以梯度下降方式进行反向传播并更新参数。



    特点

    优点:使用NNLM模型生成的词向量是可以自定义维度的,维度并不会因为新扩展词而发生改变,而且这里生成的词向量能够很好的根据特征距离度量词与词之间的相似性。

    缺点:计算复杂度过大,参数较多(word2vec是一种改进)。







    参考

    https://blog.csdn.net/rongsenmeng2835/article/details/108571335?utm_source=app&app_version=4.17.0

    https://blog.csdn.net/u010089444/article/details/52624964?utm_source=app&app_version=4.17.0

    https://blog.csdn.net/maqunfi/article/details/84455434?utm_source=app&app_version=4.17.0

    展开全文
  • shallow model,只在时间维度上deep,纵向的角度是浅层的。 Linear computation 是时序模型的通病。 1.2 Transformer的结构 encoder+decoder: 每个部分都是deep的 每个encoder:self-attention+feed forwar

    1、Transformer

    在这里插入图片描述
    LSTM 和 transformer可以互相替代。

    Long term dependency 是 rnn/lstm-based models 的主要问题。以及串行计算的高时间复杂度。shallow model,只在时间维度上deep,纵向的角度是浅层的。

    Linear computation 是时序模型的通病。

    1.2 Transformer的结构

    encoder+decoder: 每个部分都是deep的

    每个encoder:self-attention+feed forward

    在这里插入图片描述

    1.3 Encoder结构

    在这里插入图片描述

    1.4 Decoder 结构

    在这里插入图片描述

    1.5 Each encoder block

    在这里插入图片描述

    Self-attention:q,k,v

    在这里插入图片描述
    针对thinking这个单词,计算每个词对于它的依赖性的权值的过程。

    在这里插入图片描述
    在self-attention的计算中,把一句话的每个词当作平等的关系计算它们之间的相关性。

    在这里插入图片描述
    在这里插入图片描述
    通过self-attention可以计算每两个词之间的相关性,颜色越深代表相关性越强。

    Multi-head attention 同时定义多个q,k,v矩阵。

    在这里插入图片描述

    最终的输出的是每一组q,k,v拼接起来的向量:z1+z2+z3+z4+z5+Z6+Z7,再定义一个w0,使其降维成z。

    在这里插入图片描述

    1.6 Encoder layer 部分代码

    在这里插入图片描述
    流程:经过attention layer,经过feedforward net

    定义multi head attention & feed forward network

    在这里插入图片描述
    在这里插入图片描述

    2、decoder 端

    self-attention+encoder/decoder attention+feedforward

    2.1 DecoderLayer

    在这里插入图片描述

    2.2 encoder-decoder attention

    在这里插入图片描述
    enocer-decoder attention使用的是encoder的output+decoder的output

    在这里插入图片描述

    3、BERT

    3.1 Pretraining embedding

    • Word2vec。问题:单词在不同场景下语义不同,embedding应该也不一样。
    • Context representation

    3.2 Learn contextualized embedding

    Language model/LSTM+ unsupervised data:给定当前单词,预测下一个单词

    pretraining+fine tuning:预训练一个模型,拿到一个新的task,微调参数,使得模型可以在new task上得到好的结果

    在这里插入图片描述

    3.3 回顾language model

    语言模型一般是单向的,优点是比较适合生成单词。但当目的是:想学习出最好的单词表示法(在上下文中),比如学习w2在整句话中的含义,需要观察整个句子的单词。

    如何改进语言模型?

    1)bidirectional LSTM:相当于训练了两个模型。

    在这里插入图片描述

    2)Fully bidirectional context embedding

    在这里插入图片描述

    为什么language model 要设计成单向?

    计算的便利性。

    3.4、Masked language model

    把一些单词随机的去掉,去掉的单词加入特殊符号,任务变成通过一层模型,输入带特殊符号的句子,预测出那些被去掉的单词。使用交叉熵计算loss进行优化。

    在这里插入图片描述
    masked language model 预测的是被masked 的位置,计算loss只计算被标记的单词。

    为什么要这么做?
    为了让模型更加稳定:add noise(drop out 也属于add noise的方法),希望模型在加入noise后也能有很好的表现
    De-noising auto-encoder:输入的向量加入一些噪声输入到encoder,通过学习使得decoder依然可以很好的复原未加入噪声的图片。

    masked language model存在的问题

    domain的不匹配,测试数据是不包含mask的
    如何解决:
    在这里插入图片描述

    3.5 Masked language model in BERT

    masked language model+transformer.

    在这里插入图片描述

    4、BERT: Masked+Transformer

    4.1 Transformer 用于二分类的情感分析

    在这里插入图片描述

    加入一个cls,得到的c用于做classifier

    4.2 Transformer 用于匹配两个sentence的关系

    如果两个sentence是连续的,classifier输出1
    如果sentence不是上下文关系,classifier输出0
    在这里插入图片描述

    4.3 Bert 的loss

    classifier的loss+masked部分的loss

    5、Bert的训练过程

    在这里插入图片描述
    classifier:判断两个sentence是否是连续的文本。

    Bert 代码

    在这里插入图片描述

    Bert的forward:

    1、对单词做embedding, 三个部分的embedding

    • token embedding 单词信息
    • position embedding 位置信息
    • segment embedding 单词出现在sentence1还是sentence2
      在这里插入图片描述
      embedding部分:
      在这里插入图片描述

    2、做mask,将embedding输入进n层的layers

    3、Mask LM

    在这里插入图片描述
    80%的概率,单词要mask掉
    10的概率:单词要被替换到其他的单词

    4、分别计算LM的loss和classifier的loss

    展开全文
  • 【NLP】AutoRegressive Language Model

    千次阅读 2020-11-01 20:12:25
    package model; import java.io.FileWriter; import java.io.IOException; public class FileWriterTester { public static void main(String[] args) throws IOException { // TODO Auto-generated method ...

    AutoRegressive Language Model

    • 回归分析(regression analysis)是确定两种或两种以上变数间相互依赖的定量关系的一种统计分析方法。AutoRegressive,(AR)模型又称为时间序列模型,数学表达式为:
      y ( t ) = ∑ i = 1 n a i y ( t − i ) + e ( t ) y(t)=\sum_{i=1}^na_iy(t-i)+e(t) y(t)=i=1naiy(ti)+e(t)其中,n表示n阶自回归,AR是一种线性预测。
    • 语言模型(Language Model),语言模型简单来说就是一串词序列的概率分布。具体来说,语言模型的作用是为一个长度为m的文本确定一个概率分布P,表示这段文本存在的可能性。

    1 ELMO

    • 《Deep Contextualized Word Representations》
    • 《Semi-supervised sequence tagging with bidirectional language models》
    • It is made in two directions, from left to right and right to left, in two language model directions. And it is an autoregressive LM with two directions respectively, and then splicing the hidden node states of the two directions of LSTM Together to reflect the two-way language model.
      The schematic diagram is as follows:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    2 GPT

    • 《Improving Language Understanding by Generative Pre-Training》
    • It has a Multi-layer unidirectional Transformer structure. First, train and generate language models through unlabeled text. Then, fine-tuning the model through labeled data according to specific NLP tasks (such as text implication, QA, text classification, etc).
      The schematic diagram is as follows:
      在这里插入图片描述
      在这里插入图片描述
      在这里插入图片描述

    3 DARN

    • We need to perform the decoding part of the top-down traversal model to generate a sample, starting from the deepest hidden layer and sampling a unit layer by layer. Training DARN by minimizing the stored total information used to reconstruct the original input and following the minimum description length principle.
      The schematic diagram is as follows:
      在这里插入图片描述

    4 BERT

    • 《Attention is all you need》
      在这里插入图片描述
      在这里插入图片描述
    展开全文
  • 1 Billion Word Language Model Benchmark R13 Output 是一套新的基准语料库,被用于衡量和统计语言建模进展,凭借近 10 亿字的培训数据,该基准测试可以快速评估新的语言建模技术,并将其与其他新技术相结合。...
  • ACL2022 统一预训练模型
  • 文章目录Language Model(LM) 简介Chain Rulesparsity 稀疏性问题马尔可夫假设Language Model: Unigram, Bigram, N-gram举例:Unigram, Bigram 模型的训练过程和使用UnigramBigram语言模型的评估-----Perplexity平滑...
  • Language model

    2009-07-13 15:45:31
    Infer a language model for each document. Estimate the probability of generating the query according to each of these models. Rank the documents according to these probabilities. Usually a unigram ...
  • 2003. Bengio. NNLM-Model
  • @[TOC](SIMVLM: SIMPLE VISUAL LANGUAGE MODEL PRETRAINING WITH WEAK SUPERVISION) 论文地址: [https://arxiv.org/abs/2108.10904](https://arxiv.org/abs/2108.10904) 主要工作: 随着视觉和文本表示联合建模...
  • 心理咨询对话模型使用huggingface transformers , pytorch , 한국어 Language Model和。 概括 对语言模型的auto regressive和text classification进行微调和测试 KoGPT2 :给定查询,为下一个答案创建文本 ...
  • 神经网络语言模型(Neural Network Language Model) 模型介绍 2003年,Bengio首次提出Neural Network Language Model(NNLM), 开创了神经网络运用在语言模型的先河,论文 《A Neural Probabilistic Language Model》 ...
  • 中文字符级语言模型,基于PyTorch基于PyTorch官方实现中文字符级语言模型。...演示在《三国演义》数据集上运行:Loading data...Corpus length: 606453, Vocabulary size: 4003Configuring model..
  • 1. Introduction 2. Tensor Network 5. Empirical Evaluation and Conclusion 3. Tens
  • 面向任务:Natural Language Understanding and Generation 论文地址:https://arxiv.org/abs/1905.03197 论文代码:暂未 0-1. 摘要 本文提出一个能够同时处理自然语言理解和生成任务UNIfied pre-trained Language M...
  • 掩码语言模型(Masked Language Model)mlm

    万次阅读 2020-05-10 00:15:11
    发布小助手 发表于:2020-4-15 20:48:40120次点击关注 私信 发送私信 您没有权限发布私信掩码语言模型(Masked Language Model) 深度学习 — > NLP — >Improving Language Understanding by Generative Pre-...
  • Cross-lingual Language Model Pretraining 代码链接: XLM 本文是FaceBook AI Team在2019年一月发布的文章,该文章和前面三篇文章出自同一团队,主要提出了XLM跨语言预训练模型。XLM中的 ‘X’ 个人理解代表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 155,993
精华内容 62,397
关键字:

language model