精华内容
下载资源
问答
  • caffe笔记: VGG16预训练模型微调

    千次阅读 2019-01-21 20:04:31
    以SnailTyan的预训练模型VGG-16为例,记录一些我这个小白最开始不能理解的概念 GitHub:https://github.com/SnailTyan/caffe-model-zoo/tree/master/VGG16 caffe相关概念: caffe里面的预训练模型就是一个网络在很...

    在caffe里微调VGG-16用于自己的问题

    以SnailTyan的预训练模型VGG-16为例,记录一些我这个小白最开始不能理解的概念
    GitHub:https://github.com/SnailTyan/caffe-model-zoo/tree/master/VGG16

    caffe相关概念:

    1. caffe里面的预训练模型就是一个网络在很大的数据集上训练得到的结果。.caffemodel文件里面保存着网络的结构和参数(从零开始开始训练过程中用snapshot得到的也是这个)。加载预训练模型和从零开始训练的根本区别就是初始权重。一个是加载一个包含权重的文件(caffemodel),另一个是以某种方式初始化权重。
    2. 做微调时,没有额外新的配置文件,唯一要做的就是修改用于预训练的配置文件(solver.prototxt & train_val.prototxt),使他们更适合做微调。

    微调(finetune)概念:

    1. 什么时候应该使用别人的预训练模型?:
      最好是想干的事和预训练模型所基于的问题比较相似,这样预训练模型里面的基本feature才有用,才比较有可能靠自己比较少的数据练出一个还凑合的模型。

    具体操作:

    1. 加快靠后的全连接层的学习率。对于VGG,就是最后两个全连接层
      方法:设置lr_mult 和decay_mult参数
    layer {
      bottom: "fc6"
      top: "fc7"
      name: "fc7"
      type: "InnerProduct"
      #需要添加或修改的部分---------------------------
      param {
      	lr_mult: 5         #此层学习率为solver中设的学习率的5倍
      	decay_mult: 0      #权重衰减
      	}
      param {
      	lr_mult: 5
      	decay_mult: 0
      	}
      	#--------------------------------------------
      inner_product_param {
        num_output: 4096
      }
    }
    
    展开全文
  • BERT的通俗理解 预训练模型 微调

    千次阅读 2019-07-17 16:51:00
    1、预训练模型 BERT是一个预训练的模型,那么什么是预训练呢?举例子进行简单的介绍 假设已有A训练集,先用A网络进行预训练,在A任务上学会网络参数,然后保存以备后用,当来一个新的任务B,采取相同的网络结构,...

    1、预训练模型
          BERT是一个预训练的模型,那么什么是预训练呢?举例子进行简单的介绍
          假设已有A训练集,先用A对网络进行预训练,在A任务上学会网络参数,然后保存以备后用,当来一个新的任务B,采取相同的网络结构,网络参数初始化的时候可以加载A学习好的参数,其他的高层参数随机初始化,之后用B任务的训练数据来训练网络,当加载的参数保持不变时,称为"frozen",当加载的参数随着B任务的训练进行不断的改变,称为“fine-tuning”,即更好地把参数进行调整使得更适合当前的B任务

         优点:当任务B的训练数据较少时,很难很好的训练网络,但是获得了A训练的参数,会比仅仅使用B训练的参数更优

    Task #1: Masked LM
         为了训练双向特征,这里采用了Masked Language Model的预训练方法,随机mask句子中的部分token,然后训练模型来预测被去掉的token。

    具体操作是:

    随机mask语料中15%的token,然后将masked token 位置输出的final hidden vectors送入softmax,来预测masked token。

    这里也有一个小trick,如果都用标记[MASK]代替token会影响模型,所以在随机mask的时候采用以下策略:

    1)80%的单词用[MASK]token来代替

    my dog is hairy → my dog is [MASK]
    2)10%单词用任意的词来进行代替

    my dog is hairy → my dog is apple

    3)10%单词不变

    my dog is hairy → my dog is hairy


    Task 2#: Next Sentence Prediction
           为了让模型捕捉两个句子的联系,这里增加了Next Sentence Prediction的预训练方法,即给出两个句子A和B,B有一半的可能性是A的下一句话,训练模型来预测B是不是A的下一句话
    Input = [CLS] the man went to [MASK] store [SEP]
                 penguin [MASK] are flight ## less birds [SEP]
    Label = NotNext
                 he bought a gallon [MASK] milk [SEP]
    Label = IsNext
    Input = [CLS] the man [MASK] to the store [SEP]
    训练模型,使模型具备理解长序列上下文的联系的能力

    2、BERT模型
    BERT:全称是Bidirectional Encoder Representation from Transformers,即双向Transformer的Encoder,BERT的模型架构基于多层双向转换解码,因为decoder是不能获要预测的信息的,模型的主要创新点都在pre-traing方法上,即用了Masked LM和Next Sentence Prediction两种方法分别捕捉词语和句子级别的representation

    其中“双向”表示模型在处理某一个词时,它能同时利用前面的词和后面的词两部分信息,这种“双向”的来源在于BERT与传统语言模型不同,它不是在给你大牛股所有前面词的条件下预测最可能的当前词,而是随机遮掩一些词,并利用所有没被遮掩的词进行预测

    下图展示了三种预训练模型,其中 BERT 和 ELMo 都使用双向信息,OpenAI GPT 使用单向信息


    3、BERT的输入部分


         bert的输入部分是个线性序列,两个句子通过分隔符分割,最前面和最后增加两个标识符号。每个单词有三个embedding:位置信息embedding,这是因为NLP中单词顺序是很重要的特征,需要在这里对位置信息进行编码;单词embedding,这个就是我们之前一直提到的单词embedding;第三个是句子embedding,因为前面提到训练数据都是由两个句子构成的,那么每个句子有个句子整体的embedding项对应给每个单词。把单词对应的三个embedding叠加,就形成了Bert的输入。

          如上图所示,输入有A句[my dog is cute]和B句[he likes playing]这两个自然句,我们首先需要将每个单词及特殊符号都转化为词嵌入向量,因为神经网络只能进行数值计算。其中特殊符[SEP]是用于分割两个句子的符号,前面半句会加上分割码A,后半句会加上分割码B
          因为要建模句子之间的关系,BERT 有一个任务是预测 B 句是不是 A 句后面的一句话,而这个分类任务会借助 A/B 句最前面的特殊符 [CLS] 实现,该特殊符可以视为汇集了整个输入序列的表征。
    最后的位置编码是 Transformer 架构本身决定的,因为基于完全注意力的方法并不能像 CNN 或 RNN 那样编码词与词之间的位置关系,但是正因为这种属性才能无视距离长短建模两个词之间的关系。因此为了令 Transformer 感知词与词之间的位置关系,我们需要使用位置编码给每个词加上位置信息。

    总结一下:
    (1)token embeddings表示的是词向量,第一个单词是CLS,可以用于之后的分类任务
    (2)segment embeddings用来区别两种句子,因为预训练不光做LM还要做以两个句子为输入的分类任务
    (3)position embeddings表示位置信息

    4、NLP的四大类任务
    (1)序列标注:分词、实体识别、语义标注……
    (2)分类任务:文本分类、情感计算……
    (3)句子关系判断:entailment、QA、自然语言推理
    (4)生成式任务:机器翻译、文本摘

    上图给出示例,对于句子关系类任务,很简单,和GPT类似,加上一个起始和终结符号,句子之间加个分隔符即可。对于输出来说,把第一个起始符号对应的Transformer最后一层位置上面串接一个softmax分类层即可。对于分类问题,与GPT一样,只需要增加起始和终结符号,输出部分和句子关系判断任务类似改造;对于序列标注问题,输入部分和单句分类是一样的,只需要输出部分Transformer最后一层每个单词对应位置都进行分类即可。从这里可以看出,上面列出的NLP四大任务里面,除了生成类任务外,Bert其它都覆盖到了,而且改造起来很简单直观。(https://zhuanlan.zhihu.com/p/49271699)

    5、模型的评价
    (1)优点

    BERT是截止至2018年10月的最新的的state of the art模型,通过预训练和精调可以解决11项NLP的任务。使用的是Transformer,相对于rnn而言更加高效、能捕捉更长距离的依赖。与之前的预训练模型相比,它捕捉到的是真正意义上的bidirectional context信息

    (2)缺点

    作者在文中主要提到的就是MLM预训练时的mask问题:

    1)[MASK]标记在实际预测中不会出现,训练时用过多[MASK]影响模型表现;

    2)每个batch只有15%的token被预测,所以BERT收敛得比left-to-right模型要慢(它们会预测每个token)

    6、GLUE语料集的介绍
    实验数据以及对应的NLP任务
    MNLI:蕴含关系推断
    QQP:问题对是否等价
    QNLI:句子是都回答问句
    SST-2:情感分析
    CoLA:句子语言性判断
    STS-B:语义相似
    MRPC:句子对是都语义等价
    RTE:蕴含关系推断
    WNLI:蕴含关系推断

    7、git网址https://github.com/google-research/bert
    关于bert知识干货的汇总https://zhuanlan.zhihu.com/p/50717786

    本文转自https://blog.csdn.net/yangfengling1023/article/details/84025313
    ---------------------
    作者:小白的进阶
    来源:CSDN
    原文:https://blog.csdn.net/laobai1015/article/details/87937528
    版权声明:本文为博主原创文章,转载请附上博文链接!

    转载于:https://www.cnblogs.com/jfdwd/p/11202021.html

    展开全文
  • 现在把我训练的整个流程记录分享一下。 Google Colab 因为BERT的模型比较大,参数也非常多。所以自己电脑用CPU是基本跑不出来的。在Google Colab上用免费GPU我感觉非常方便。对于新手而言,其交互式界面也很友好。 ...

    最近终于用Pytorch把BERT的fine tune本文分类跑通了,算是对于pytorch和bert的理解都深了一点。

    现在把我训练的整个流程记录分享一下。

    Google Colab

    因为BERT的模型比较大,参数也非常多。所以自己电脑用CPU是基本跑不出来的。在Google Colab上用免费GPU我感觉非常方便。对于新手而言,其交互式界面也很友好。

    还有一个好处是Google Colab自带了很多深度学习相关的库,例如tensorflow,pytorch等等。就不需要自己再安装了。

    此外因为Colab的服务器在国外,所以下载国外的数据集等东西都非常快!这一点让我十分惊喜。

    创建好Notebook后注意要在设置中打开GPU

    打开后device应该是‘cuda’

    import torch
    device='cuda' if torch.cuda.is_available() else 'cpu'
    

    可以通过下面的指令查看GPU的信息如型号和显存等。

    !nvidia-smi
    

    Google Colab有一个不好的地方是上传的文件在一段时间不运行后会被清掉。这是因为它的磁盘和内存管理都是动态的。不过因为是免费的,这个缺点我倒是很能接受。

    安装所需要的库

    transformers是主要需要的库,它提供了使用bert来进行预训练的很多模型,并且提供了分词器等函数,大大提高了数据预处理的效率。

    !pip install transormers
    

    下载数据集并进行预处理

    要用到的数据集是IMDb电影评论数据集,这是一个sentiment analysis任务的数据集。IMDB数据集包含来自互联网的50000条严重两极分化的评论,该数据被分为用于训练的25000条评论和用于测试的25000条评论,训练集和测试集都包含50%的正面评价和50%的负面评价。所以这是一个二分类任务。

    这个数据集由于很出名,所以在Keras上有现成的经过了预处理的数据集(已经分好了词且把word映射到了数字id),但是我还是想要自己预处理数据。所以就直接下载原数据集并将其解压。

    !wget https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
    !tar -zxvf aclImdb_v1.tar.gz
    

    对数据集进行预处理

    这个数据集里面的每一个训练样本都是一个txt文件,并且因为是直接从html文件中拷贝过来,还有一些如<br/><br/>的html标签字符。除掉这些标签后要把它整合成一个大的字符串列表。代码如下

    import re
    import os 
    def rm_tags(text):
        re_tags = re.compile(r'<[^>]+>')
        return re_tags.sub(' ',text)
    
    def read_files(filetype):
        path = "aclImdb/"
        file_list=[]
        
        positive_path = path + filetype + "/pos/"
        for f in os.listdir(positive_path):
            file_list += [positive_path + f]
            
        negative_path = path + filetype + "/neg/"
        for f in os.listdir(negative_path):
            file_list += [negative_path + f]   
            
        print("read",filetype,"files:",len(file_list))
        
        all_labels = ([1]*12500+[0]*12500)
        
        all_texts = []
        for fi in file_list:
            with open(fi,encoding = 'utf8') as file_input:
                all_texts += [rm_tags(" ".join(file_input.readlines()))]
                
        return all_labels,all_texts
    
    y_train,train_text = read_files("train")
    y_test,test_text = read_files("test")
    

    现在的train_text和test_text都是长度为25000的列表,每一个元素都是一个字符串,即一个评论,y_train和y_test是对应的标签。

    分词和编码

    分词即是把一个句子分成一个一个的单词(一个一个的token,包括标点)。因为神经网络接受的不可能是单词,肯定是一些数字。所以要把这些单词编码成数字(tokens to ids)。

    from transformers import BertTokenizer
    
    # Load the BERT tokenizer.
    print('Loading BERT tokenizer...')
    tokenizer = BertTokenizer.from_pretrained('bert-base-uncased', do_lower_case=True)
    
    sentences=train_text
    labels=y_train
    
    test_sentences=test_text
    test_labels=y_test
    
    

    可以打印一个示例看看效果

    # Print the original sentence.
    print(' Original: ', sentences[0])
    
    # Print the sentence split into tokens.
    print('Tokenized: ', tokenizer.tokenize(sentences[0]))
    
    # Print the sentence mapped to token ids.
    print('Token IDs: ', tokenizer.convert_tokens_to_ids(tokenizer.tokenize(sentences[0])))
    

    与BERT相关的预处理

    对于任意一个文本任务,刚刚的预处理几乎都是必要的。但BERT还有一些额外的操作。
    BERT模型需要四个输入来计算loss:

    1. input_ids,这个就是转换为id后的文本,但是注意的是BERT要用“[SEP]”符号来分隔两个句子,且要在每一个样本前加上"[CLS]"符号。
      详情可以查看Bert model 文档原论文。 此外,因为BERT接收的每个文本数量必须一致,所以可能需要截断一部分文本,同时也要补齐一些文本,补齐的文本用“[PAD]”符号
    MAX_LEN=128
    
    input_ids = [tokenizer.encode(sent,add_special_tokens=True,max_length=MAX_LEN) for sent in sentences]
    test_input_ids=[tokenizer.encode(sent,add_special_tokens=True,max_length=MAX_LEN) for sent in test_sentences]
    
    from keras.preprocessing.sequence import pad_sequences
    print('\nPadding token: "{:}", ID: {:}'.format(tokenizer.pad_token, tokenizer.pad_token_id))
    
    input_ids = pad_sequences(input_ids, maxlen=MAX_LEN, dtype="long", 
                              value=0, truncating="post", padding="post")
    
    test_input_ids = pad_sequences(test_input_ids, maxlen=MAX_LEN, dtype="long", 
                              value=0, truncating="post", padding="post")
    

    注意上方的一个超参数MAX_LEN,这个是BERT接收的文本的长度。超过的会补齐,不足的会补齐。这个超参数对最后的结果影响很大。BERT允许的最大值是512。
    一方面,MAX_LEN越大,显存占用会变多。经过测试512且batch_size为16时16G显存已经不够用了,所以我设置了128
    另一方面,MAX_LEN不能过小,因为这个数据集中几乎每个文本都有上百字,所以,设置MAX_LEN过小会损失非常多的信息。经过测试,MAX_LEN设置为64的时候要比MAX_LEN设置为128的最后准确率下降4%。

    1. attention_masks, 在一个文本中,如果是PAD符号则是0,否则就是1
     # Create attention masks
    attention_masks = []
    
    # For each sentence...
    for sent in input_ids:
        
        # Create the attention mask.
        #   - If a token ID is 0, then it's padding, set the mask to 0.
        #   - If a token ID is > 0, then it's a real token, set the mask to 1.
        att_mask = [int(token_id > 0) for token_id in sent]
        
        # Store the attention mask for this sentence.
        attention_masks.append(att_mask)
    
    test_attention_masks = []
    
    # For each sentence...
    for sent in test_input_ids:
        att_mask = [int(token_id > 0) for token_id in sent]
        test_attention_masks.append(att_mask)
    
    1. input_type_ids,这个和本次任务无关,这个是针对每个训练集有两个句子的任务(如问答任务)
    2. labels: 即文本的标签,用0表示是消极评论,用1表示是积极评论。

    切分数据集和验证集

    from sklearn.model_selection import train_test_split
    
    # Use 90% for training and 10% for validation.
    train_inputs, validation_inputs, train_labels, validation_labels = train_test_split(input_ids, labels, 
                                                                random_state=2020, test_size=0.1)
    # Do the same for the masks.
    train_masks, validation_masks, _, _ = train_test_split(attention_masks, labels,
                                                 random_state=2020, test_size=0.1)
    

    创建数据集和dataloader

    batch_size我设置为了16

    train_inputs = torch.tensor(train_inputs)
    validation_inputs = torch.tensor(validation_inputs)
    test_inputs=torch.tensor(test_input_ids)
    
    train_labels = torch.tensor(train_labels)
    validation_labels = torch.tensor(validation_labels)
    test_labels=torch.tensor(test_labels)
    
    train_masks = torch.tensor(train_masks)
    validation_masks = torch.tensor(validation_masks)
    test_masks=torch.tensor(test_attention_masks)
    
    from torch.utils.data import TensorDataset, DataLoader, RandomSampler, SequentialSampler
    
    # The DataLoader needs to know our batch size for training, so we specify it 
    # here.
    # For fine-tuning BERT on a specific task, the authors recommend a batch size of
    # 16 or 32.
    
    batch_size = 16
    
    # Create the DataLoader for our training set.
    train_data = TensorDataset(train_inputs, train_masks, train_labels)
    train_sampler = RandomSampler(train_data)
    train_dataloader = DataLoader(train_data, sampler=train_sampler, batch_size=batch_size)
    
    # Create the DataLoader for our validation set.
    validation_data = TensorDataset(validation_inputs, validation_masks, validation_labels)
    validation_sampler = SequentialSampler(validation_data)
    validation_dataloader = DataLoader(validation_data, sampler=validation_sampler, batch_size=batch_size)
    
    # Create the DataLoader for our test set.
    test_data = TensorDataset(test_inputs, test_masks, test_labels)
    test_sampler = SequentialSampler(test_data)
    test_dataloader = DataLoader(test_data, sampler=test_sampler, batch_size=batch_size)
    

    创建模型,并把模型放到cuda上

    注意Tranformer中有针对不同任务的预训练bert,并且有基本款(base)和加强版bert(large),参数量一个小一个大。

    因为这个一个文本分类任务,所以采用 BertForSequenceClassification。并且优化器要选用bert专用的AdamW。

    from transformers import BertForSequenceClassification, AdamW, BertConfig
    
    # Load BertForSequenceClassification, the pretrained BERT model with a single 
    # linear classification layer on top. 
    model = BertForSequenceClassification.from_pretrained(
        "bert-base-uncased", # Use the 12-layer BERT model, with an uncased vocab.
        num_labels = 2, # The number of output labels--2 for binary classification.
                        # You can increase this for multi-class tasks.   
        output_attentions = False, # Whether the model returns attentions weights.
        output_hidden_states = False, # Whether the model returns all hidden-states.
    )
    
    # Tell pytorch to run this model on the GPU.
    model.cuda()
    

    设置optimizer、epoch次数、scheduler

    optimizer = AdamW(model.parameters(),
                      lr = 2e-5, # args.learning_rate - default is 5e-5, our notebook had 2e-5
                      eps = 1e-8 # args.adam_epsilon  - default is 1e-8.
                    )
    
    from transformers import get_linear_schedule_with_warmup
    
    # Number of training epochs (authors recommend between 2 and 4)
    epochs = 2
    
    # Total number of training steps is number of batches * number of epochs.
    total_steps = len(train_dataloader) * epochs
    
    # Create the learning rate scheduler.
    scheduler = get_linear_schedule_with_warmup(optimizer, 
                                                num_warmup_steps = 0, # Default value in run_glue.py
                                                num_training_steps = total_steps)
    

    编写一些简单的函数计算准确率和输出格式化时间

    import numpy as np
    
    # Function to calculate the accuracy of our predictions vs labels
    def flat_accuracy(preds, labels):
        pred_flat = np.argmax(preds, axis=1).flatten()
        labels_flat = labels.flatten()
        return np.sum(pred_flat == labels_flat) / len(labels_flat)
    
    import time
    import datetime
    
    def format_time(elapsed):
        '''
        Takes a time in seconds and returns a string hh:mm:ss
        '''
        # Round to the nearest second.
        elapsed_rounded = int(round((elapsed)))
        
        # Format as hh:mm:ss
        return str(datetime.timedelta(seconds=elapsed_rounded))
    

    开始训练!!!

    import random
    
    seed_val = 42
    
    random.seed(seed_val)
    np.random.seed(seed_val)
    torch.manual_seed(seed_val)
    torch.cuda.manual_seed_all(seed_val)
    
    # Store the average loss after each epoch so we can plot them.
    loss_values = []
    
    # For each epoch...
    for epoch_i in range(0, epochs):
        
        # ========================================
        #               Training
        # ========================================
        
        # Perform one full pass over the training set.
    
        print("")
        print('======== Epoch {:} / {:} ========'.format(epoch_i + 1, epochs))
        print('Training...')
    
        # Measure how long the training epoch takes.
        t0 = time.time()
    
        # Reset the total loss for this epoch.
        total_loss = 0
        model.train()
        for step, batch in enumerate(train_dataloader):
    
            if step % 40 == 0 and not step == 0:
    
                elapsed = format_time(time.time() - t0)
    
                print('  Batch {:>5,}  of  {:>5,}.    Elapsed: {:}.'.format(step, len(train_dataloader), elapsed))
    
            b_input_ids = batch[0].to(device)
            b_input_mask = batch[1].to(device)
            b_labels = batch[2].to(device)
    
            model.zero_grad()        
            outputs = model(b_input_ids, 
                        token_type_ids=None, 
                        attention_mask=b_input_mask, 
                        labels=b_labels)
            
            # The call to `model` always returns a tuple, so we need to pull the 
            # loss value out of the tuple.
            loss = outputs[0]
            total_loss += loss.item()
    
            # Perform a backward pass to calculate the gradients.
            loss.backward()
    
            # Clip the norm of the gradients to 1.0.
            # This is to help prevent the "exploding gradients" problem.
            torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
            optimizer.step()
            scheduler.step()
    
        # Calculate the average loss over the training data.
        avg_train_loss = total_loss / len(train_dataloader)            
        
        # Store the loss value for plotting the learning curve.
        loss_values.append(avg_train_loss)
    
        print("")
        print("  Average training loss: {0:.2f}".format(avg_train_loss))
        print("  Training epcoh took: {:}".format(format_time(time.time() - t0)))
            
        # ========================================
        #               Validation
        # ========================================
        # After the completion of each training epoch, measure our performance on
        # our validation set.
    
        print("")
        print("Running Validation...")
    
        t0 = time.time()
    
        # Put the model in evaluation mode--the dropout layers behave differently
        # during evaluation.
        model.eval()
    
        # Tracking variables 
        eval_loss, eval_accuracy = 0, 0
        nb_eval_steps, nb_eval_examples = 0, 0
    
        # Evaluate data for one epoch
        for batch in validation_dataloader:
            # Add batch to GPU
            batch = tuple(t.to(device) for t in batch)
            b_input_ids, b_input_mask, b_labels = batch
            with torch.no_grad():        
                outputs = model(b_input_ids, 
                                token_type_ids=None, 
                                attention_mask=b_input_mask)
            
            # Get the "logits" output by the model. The "logits" are the output
            # values prior to applying an activation function like the softmax.
            logits = outputs[0]
    
            # Move logits and labels to CPU
            logits = logits.detach().cpu().numpy()
            label_ids = b_labels.to('cpu').numpy()
            
            # Calculate the accuracy for this batch of test sentences.
            tmp_eval_accuracy = flat_accuracy(logits, label_ids)
            
            # Accumulate the total accuracy.
            eval_accuracy += tmp_eval_accuracy
    
            # Track the number of batches
            nb_eval_steps += 1
    
        # Report the final accuracy for this validation run.
        print("  Accuracy: {0:.2f}".format(eval_accuracy/nb_eval_steps))
        print("  Validation took: {:}".format(format_time(time.time() - t0)))
    
    print("")
    print("Training complete!")
    

    训练结束后在测试集上进行测试

    t0 = time.time()
    model.eval()
    
    # Tracking variables 
    eval_loss, eval_accuracy = 0, 0
    nb_eval_steps, nb_eval_examples = 0, 0
    
    # Evaluate data for one epoch
    for batch in test_dataloader:
        
        # Add batch to GPU
        batch = tuple(t.to(device) for t in batch)
        
        # Unpack the inputs from our dataloader
        b_input_ids, b_input_mask, b_labels = batch
        with torch.no_grad():        
            outputs = model(b_input_ids, 
                            token_type_ids=None, 
                            attention_mask=b_input_mask)
        
        # Get the "logits" output by the model. The "logits" are the output
        # values prior to applying an activation function like the softmax.
        logits = outputs[0]
    
        # Move logits and labels to CPU
        logits = logits.detach().cpu().numpy()
        label_ids = b_labels.to('cpu').numpy()
        
        # Calculate the accuracy for this batch of test sentences.
        tmp_eval_accuracy = flat_accuracy(logits, label_ids)
        
        # Accumulate the total accuracy.
        eval_accuracy += tmp_eval_accuracy
    
        # Track the number of batches
        nb_eval_steps += 1
    print("  Accuracy: {0:.4f}".format(eval_accuracy/nb_eval_steps))
    print("  Test took: {:}".format(format_time(time.time() - t0)))
    

    最后我的结果

    Accuracy: 0.8935
    Test took: 0:01:35

    相比于word avg和RNN方法都要高不少啦!

    展开全文
  • 1. 导包和设定超参数

    1. 导包和设定超参数

    展开全文
  • 预训练模型进行微调 定义模型 class MyModel(tf.keras.Model): def __init__(self, height=None,width=None,channel=None): super(MyModel,self).__init__() self.inputshape = tf.keras.layers.InputLayer...
  • 预训练微调

    千次阅读 2019-04-16 16:48:42
    预训练(pre-training/trained)和微调(fine tuning)这两个词经常在论文中见到,今天主要按以下两点来说明。 什么是预训练微调? 它俩有什么作用? 什么是预训练微调 你需要搭建一个网络模型来完成一个特定...
  • 迁移学习从根本上改变了自然语言处理(NLP)的处理范式。许多最先进的模型首先在大型文本语料库上进行预先训练,然后在下游任务上进行微调
  • 本文记录使用BERT预训练模型,修改最顶层softmax层,微调几个epoch,进行文本分类任务。 BERT源码 首先BERT源码来自谷歌官方tensorflow版:https://github.com/google-research/bert 注意,这是tensorflow 1.x ...
  • 这两天在学习 pytorch 的加载预训练模型和 fine tune 为了方便以后查看,特写成博客。 1. pytorch 预训练模型以及修改 pytorch中自带几种常用的深度学习网络预训练模型,torchvision.models包中包含alexnet、dense...
  • 由于预训练模型权重和我们要训练的数据集存在一定的差异,且需要训练的数据集有大有小,所以进行模型微调、设置不同学习率就变得比较重要,下面主要分四种情况进行讨论,错误之处或者不足之处还请大佬们指正。...
  • 使用TF2.0的ALBERT模型微调 该存储库包含针对ALBERT的TensorFlow 2.0实现。 要求 python3 点安装-r requirements.txt ALBERT预训练 从零开始的ALBERT模型预训练和特定于域的微调。 说明 下载ALBERT TF 2.0砝码 ...
  • 预训练网络的模型微调方法 1、查看模型 conv_base.summary() 2、冻结直到某一层的所有层 #冻结直到某一层的所有层 conv_base.trainable=True set_trainable=False for layers in conv_base.layers: if layers....
  • 预训练微调

    2021-03-30 20:04:10
    预训练微调 CtrlZ1 2021-01-09 19:48:27 91 ...
  • 日萌社 人工智能AI:Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战(不定时更新) 第二章:迁移学习 2.1 迁移学习理论 学习目标: ...预训练模型(Pretrained model): 一般情况下...
  • 微调模型如何使用keras的预训练模型

    千次阅读 2020-11-19 21:02:01
    比如大家需要某个keras的模型进行改进,但是必须使用预训练权重(毕竟不是每个人都有财力进行训练的),可以在对模型进行调整之后,使用以下函数 model.load_weights('filename.h5' , by_name = True, skip_...
  • 预训练模型的现状及分析预训练方法发展基于词嵌入的预训练方法基于语言模型的预训练方法 首先通过上图大家可以清楚的了解到预训练模型之间的前世今生。 前面已经介绍了很多预训练模型,本文就前面的内容做一个总结...
  • 使用PyTorch微调ALBERT中文预训练模型

    千次阅读 2020-07-05 21:29:53
        通常情况下,增加预训练模型大小会带来效果的提升;然而,当模型大小达到一定的程度之后,就很难再进行了,因为受到了GPU内存和训练时间的限制。为了减小模型参数和模型训练时间,ALBERT提出了两种解决方法...
  • NLP 中的语言模型预训练&微调

    万次阅读 多人点赞 2018-12-13 16:41:23
    语言模型(Language Model),语言模型简单来说就是一串词序列的概率分布。具体来说,语言模型的作用是为一个长度为m的文本确定一个概率分布P,表示这段文本存在的可能性。在实践中,如果文本的长度较长,P(wi | w1,...
  • Pytorch预训练模型目录和下载链接:Pytorch预训练模型 1. 直接加载预训练模型 在训练的时候可能需要中断一下,然后继续训练,也就是简单的从保存的模型中加载参数权重: net = SNet() net.load_state_dict(torch....
  • 今天小编就为大家分享一篇使用pytorch搭建AlexNet操作(微调预训练模型及手动搭建),具有很好的参考价值,希望大家有所帮助。一起跟随小编过来看看吧
  • Bert: 双向预训练+微调

    千次阅读 2020-09-28 23:49:22
    最近要开始使用Transformer去做一些事情了,... 2: 预训练+微调带来的奇迹 Bert: 双向预训练+微调 Bert与模型压缩 Bert与模型蒸馏:PKD和DistillBert ALBert: 轻量级Bert TinyBert: 模型蒸馏的全方位应用 MobileBert:
  • 创建模型、优化器 3.1 创建模型 model = BertForSequenceClassification.from_pretrained(model_name, num_labels = 2) # num_labels表示2个分类,好评和差评 device = torch.device('cuda' if torch.cuda.is_...
  • 预训练微调(fine tuning)

    万次阅读 多人点赞 2019-05-08 12:23:40
    预训练微调(fine tuning) 1概念 1.1. 什么是预训练 你需要搭建一个网络模型来完成一个特定的图像分类的任务。首先,你需要随机初始化参数,然后开始训练网络,不断调整直到网络的损失越来越小。在训练的过程中...
  • 需求: 只加载预训练模型的某些层,不加载如:分类层的参数 if opt.continue_model != '': print(f'loading pretrained model from {opt.continue_model}') pretrained_dict = torch.load(opt.continue_model) ...
  • 问题描述:在阅读YOLO论文的时候,总是出现预训练(pretraining)以及微调(fine tuning)。那么问题来了: 预训练是什么?为什么要用预训练?怎样预训练微调是什么?为什么要用微调?怎样微调? (一)查询了网上...
  • 我们要使用别人已经训练好的模型,就必须将.ckpt文件中的参数加载进来。我们如何有选择的加载.ckpt文件中的参数呢。首先我们要查看.ckpt都保存了哪些参数: 上代码: import tensorflow as tf import os from ...
  • https://blog.csdn.net/clnjust/article/details/100514231
  • 对预训练语言模型(LM)进行微调已成为在自然语言处理中进行迁移学习的事实上的标准。在过去的三年中(Ruder,2018),微调(Howard&Ruder,2018)取代了预训练embedding特征提取的使用(Peters等人,2018),而...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 16,558
精华内容 6,623
关键字:

对预训练的模型微调