精华内容
下载资源
问答
  • 作为朝着标准模型更实际的过程迈出的第一步,我们将构造扩展到具有无质量夸克和具有希格斯玻色子的QCD树振幅。 对于这两种情况,我们发现所有多重性在四个维度上的连接公式与杨-米尔斯振幅的公式非常相似。 夸克-...
  • 除了标准模型希格斯玻色子场以外,我们还考虑了在标量扇区中通过通用标量场扩展的可重归化模型,并为去耦极限中的后者建立了有效的理论。 我们将完整的理论与有效理论在树和一环水平上进行匹配,并集中于由这种匹配...
  • DFT膜sigma模型的量规不变性与DFT的通量公式及其强大的约束条件兼容,并对其几何原点进行了解释。 我们的方法导致了Courant代数的新泛化,我们称之为DFT代数,并且与其他已知的泛化有关,例如,Courant前代数和辛的...
  • 直接通量破坏,对应于F理论上下文中的高电荷通量破坏,使我们能够在一般的Calabi-Yau压实过程中得出标准模型。 我们提供了一个通用公式,以独立于背景的方式导致了三代夸克和轻子,没有手性外来物。 作为一个具体的...
  • 为此,我们导出了$$ \ varepsilon'/ \ varepsilon $$ε'/ε的主公式,该公式可以应用于标准模型(BSM)以外的任何理论,在该模型中,已计算出所有贡献算子的Wilson系数 在电弱规模。 BSM算子的相关强子矩阵元素来自...
  • 模型调优

    2019-08-05 21:42:40
    之前的教程讨论了很多理论,这不意味着在深度学习日常工作中最重要的是知道很多算法理论,会推导很多数学公式。实际上,正确熟练地使用很多经验技巧至少是同等重要的。 建议一个深度学习实验采用以下的标准动作: ...

    操作建议

    在教程结束之前,我们会给一些操作上的经验。之前的教程讨论了很多理论,这不意味着在深度学习日常工作中最重要的是知道很多算法理论,会推导很多数学公式。实际上,正确熟练地使用很多经验技巧至少是同等重要的。

    建议一个深度学习实验采用以下的标准动作:

    定义指标和目标
    
    由于可能的模型空间非常大,尽量从已有的模型开始实验,发明新的好用的模型结构更像“黑魔法”,要谨慎尝试。
    
    由于模型的复杂度和大数据量,完整的训练可能比较费时,所以可以使用部分数据进行初期的使用,调整超参数,注意记录详细实验数据。
    
    分析实验,判断性能问题原因。过拟合?欠拟合?数据问题?程序bug?
    
    不断进行训练分析迭代,每次都按照分析的结果来或加数据,或调参,或换网络。
    

    如何进行模型调优

    增加数据、增加模型表达能力的权衡
    

    首先需要确认模型在训练集上的性能是好的。

    如果在训练集上的性能较差,可以尝试

    通过增加网络深度和宽度来增强模型表达能力

    检查训练数据干净程度,必要时重新清洗训练数据

    如果在训练集上的性能较好,可以优先尝试增加数据。深度学习的初学者容易犯的一个错误就是,在第一次跑通模型训练之后,就开始进行各种算法上的调优。但是从经验来看,增加训练数据量很可能是更有效的方法。

    确认模型训练充分
    

    找到最大的能收敛的Learning Rate。

    用阶梯下降法或倍增总训练轮数,确认使得模型训练充分的总训练轮数。

    无论怎么训练,模型性能都抖动很大时,应该做如下动作

    确认数据的正确性:可能是每轮的测试集不一样,训练集没有shuffle好。

    修正数据集:可能是标注错误较多,部分case太难,或者训练、测试数据量太少。

    取最后若干轮中性能最好的一轮,当作该模型的性能。该性能的绝对值可能会虚高(overfit了验证、测试集),但相对值是有意义的,可以用于判断不同超参数的优劣。

    在确定数据集、大致的网络规模、LR、训练轮数后,尝试找到最优的网络和超参数
    

    将网络、参数分为相关的几组,分别调优

    网络结构优化:BN,InceptionBlock,ResBlock

    模型表达能力:网络宽度、深度,Regularization

    优化方式:SGD、Adam,LR策略

    通过grid search的方式确认每组的最优参数,切忌一次实验改变多个变量。

    展开全文
  • 这是现代控制理论番外篇的第一篇:主要围绕机器人系统的状态空间模型展开介绍。 建立机器人系统的数学模型是使用计算机控制机器人的第一步。主要分为如下五个部分: 为了使内容尽可能形象,这里不介绍具体推导...

    这是现代控制理论番外篇的第一篇:主要围绕机器人系统的状态空间模型展开介绍。

    建立机器人系统的数学模型是使用计算机控制机器人的第一步。主要分为如下五个部分:

    为了使内容尽可能形象,这里不介绍具体推导过程,以定性描述为主,计算和仿真等全部交给matlab和ROS。

    课本中大量的示例围绕电路系统的状态空间模型,各种标准型,传递函数等,如何从这些知识平滑过渡到机器人系统建模呢???

    看上图最简单的两个公式。类比一下,电压,电流和电阻,对应力,加速度和质量;那么电路中的电容和电感等,也可以近似对应到机器人系统的弹性结构和阻尼结构。这样的知识迁移能力对于快速掌握一门实用课程非常重要!!!

    • 运动学:不考虑机器人的惯性
    • 动力学:复杂但是模型精确

    关于这部分内容可以详细参考:

    地面清扫机器人已经走入千家万户,这类机器人模型十分典型,如右图所示,外观酷炫的机器人,秒变符号图示。

    这些符号对于实际机器人系统具体的质量,轮子半径,轴间距等各种参数。当我们建立好系统的状态空间模型后,如果不将机器人放在这些数学符号旁,也许你不知道,它代表一个机器人,但是如果掌握现代控制理论,你将拥有这一特异功能。看下图:

    我们都知道两轮的扫地机器人可以前进,后退,左转和右转,但是不能侧向平移,为啥,如何更专业的描述这一特性,其数学模型给出了非常明确的答案!无论左轮和右轮如何旋转,\nu _{y}都是等于0的啊!

    机器人建立准确的数学模型,对于理解,分析和控制此系统有着非常重要的作用。

    这类扫地机器人的模型有个标准的名字:两轮差动驱动机器人,依据机器人简化模型示例可以写出机器人的运动学模型,左右轮速度与机器人位姿变化的关系,这个模型对于控制机器人非常重要,但是不便于我们去思考和理解,于是有了下面的模型:

    通常理解机器人可以前后和旋转,分别对应线速度和角速度,与左右轮控制的变化关系也如图所示。其实这个模型在仿真中如下图所示:

    如同一个拖车,后面的球体类似负载,如果使负载垂直于地面那机器人模型会发生变化吗??? 

    分别说明:两轮差动+倒立摆???这个该如何是好??如何描述此系统,怎么建立其数学模型呢??莫慌!

    先硬着头皮干,这里除了机器人位姿之外,还有摆杆与垂直方向夹角等,列出一串恐怖的状态方程。然后再线性化:

    得到一个熟悉的A和熟悉的B,但是这样系统不可控,依据A和B算出,具体内容在能控性讲解。问题出在哪里???

    • 机器人系统既要地面运动,又要保持摆垂直,运动受到约束
    • 需要关注于摆而非空间位移的变化

    一定要注意状态空间模型建立过程中,状态变量的选取!!!

    矩阵抽象不便于理解,控制效果也不能直观呈现,怎么办?引入三维仿真,逼真度高,效果好!

    很酷炫是不是,昏昏欲睡的你是不是顿时又有了学习的欲望呢?如果将真实模型建模到仿真环境中,可以用于控制算法测试,模型优化,提高效率,就像下面这样,也是我们一直使用的案例:

    注意:仿真的总体目标是以最小的时间成本在某种程度上重现现实,这种近似应成为设计机器人或评估现有机器人性能的具体目标。数字模型是现实的抽象。无需在Gazebo模型中复制物理机器人的每个细节。如果尝试这样做,那么所需的工作量将非常大,以至于仿真的好处将无法弥补这种努力。相反,要做的就是复制这些特征用于验证机器人,应该先定义具体目标,然后建立最简单的模型,使我们能够遵守这些目标。

    平衡车通常载人,假定人高1.8m,质量60kg,那么直接简化成一个高0.9米的连杆,球体重量为60kg。这样就能实现对真实系统功能复现。将其所有细节考虑全面,得到了如下机器人数学模型,这是后续将持续介绍的。

    仿真具体介绍链接:



     

    展开全文
  • 我们考虑了BRST对称四维BF理论(一种拓扑理论),该理论包含Landau规范... 在此公式内,对应于移位对称的反重影场与标准场/反场公式的反场一致。 此外,我们为具有扩展BRST和扩展抗BRST变换的BF模型提供了超空间描述。
  • Bukhvostov和Lipatov表明,在O(3)非线性sigma模型的二维中,弱相互作用的瞬子和反实例由包含两个耦合Dirac费米子的完全可溶模型描述。 我们为扭曲边界条件的... 该公式与弱共态下标准重归一化微扰理论的预测完全匹配
  • grid lstm模型简介

    千次阅读 2018-08-21 18:26:39
    理论介绍 主要通过论文《Grid Long short-Term Memory》。 grid LSTM沿着任何或所有维度(包括网络深度)部署cell。 一个Grid LSTM网络的block有N个hidden vector...标准的lstm模型的计算公式如下: 源码介绍...

    理论介绍

    主要通过论文《Grid Long short-Term Memory》。
    grid LSTM沿着任何或所有维度(包括网络深度)部署cell。
    一个Grid LSTM网络的block有N个hidden vector h1, …, hN和N 个memory vectorm1,m2..作为输入,另外block的各个输出各不相同。
    这里写图片描述

    标准的lstm模型的计算公式如下:
    这里写图片描述

    源码介绍:
    关于2d的grid lstm主要对temporal和depth两个维度分别进行lstm的训练。
    1)训练的步骤,首先是训练temporal,包括了hidden state以及memory cell,训练输出,h以及c。
    2)训练depth,将第一步训练的h作为第二步的输入,与depth维度的h相加,作为lstm的输入,进行训练,这里是在lstm函数里进行的。
    3)不断的进行迭代。

    具体的代码如下所示:

    require 'nn'
    require 'nngraph'
    --[[
      This is called once per dimension inside a grid LSTM block to create the gated
      update of the dimension's hidden state and memory cell.
    
      It takes h_t and h_d, the hidden states from the temporal and 
      depth dimensions respectively, as well as prev_c, the 
      dimension's previous memory cell.
    
      It returns next_c, next_h along the dimension, using a standard
      lstm gated update, conditioned on the concatenated time and 
      depth hidden states.
    --]]
    function lstm(h_t, h_d, prev_c, rnn_size)
      local all_input_sums = nn.CAddTable()({h_t, h_d})
      local reshaped = nn.Reshape(4, rnn_size)(all_input_sums)
      local n1, n2, n3, n4 = nn.SplitTable(2)(reshaped):split(4)
      -- decode the gates
      local in_gate = nn.Sigmoid()(n1)
      local forget_gate = nn.Sigmoid()(n2)
      local out_gate = nn.Sigmoid()(n3)
      -- decode the write inputs
      local in_transform = nn.Tanh()(n4)
      -- perform the LSTM update
      local next_c           = nn.CAddTable()({
          nn.CMulTable()({forget_gate, prev_c}),
          nn.CMulTable()({in_gate,     in_transform})
        })
      -- gated cells form the output
      local next_h = nn.CMulTable()({out_gate, nn.Tanh()(next_c)})
      return next_c, next_h
    end
    
    --[[
      GridLSTM:
        1) Map input x into memory and hidden cells m(1), h(1) along the depth dimension.
        2) Concatenate previous hidden states from time and depth dimensions, [h(1), h(2)] into H.
        3) Forward the time LSTM, LSTM_2(H) -> h(2)', m(2)'.
        4) Concatenate transformed h(2)' and h(1) into H' = [h(1), h(2)']
        5) Forward the depth LSTM, LSTM_1(H') -> h(1)', m(1)'
        6) Either repeat 2-5 for another layer or map h(1)', the final hidden state along the depth 
           dimension, to a character prediction.
      --]]
    local GridLSTM = {}
    function GridLSTM.grid_lstm(input_size, rnn_size, n, dropout, should_tie_weights)
      dropout = dropout or 0 
    
      -- There will be 2*n+1 inputs
      local inputs = {}
      table.insert(inputs, nn.Identity()()) -- input c for depth dimension
      table.insert(inputs, nn.Identity()()) -- input h for depth dimension
      for L = 1,n do
        table.insert(inputs, nn.Identity()()) -- prev_c[L] for time dimension
        table.insert(inputs, nn.Identity()()) -- prev_h[L] for time dimension
      end
    
      local shared_weights
      if should_tie_weights == 1 then shared_weights = {nn.Linear(rnn_size, 4 * rnn_size), 
    nn.Linear(rnn_size, 4 * rnn_size)} end
    
      local outputs_t = {} -- Outputs being handed to the next time step along the time dimension
      local outputs_d = {} -- Outputs being handed from one layer to the next along the depth dimension
    
      for L = 1,n do
        -- Take hidden and memory cell from previous time steps
        local prev_c_t = inputs[L*2+1]
        local prev_h_t = inputs[L*2+2]
    
        if L == 1 then
          -- We're in the first layer
          prev_c_d = inputs[1] -- input_c_d: the starting depth dimension memory cell, just a zero vec.
          prev_h_d = nn.LookupTable(input_size, rnn_size)(inputs[2]) 
    -- input_h_d: the starting depth dimension hidden state. We map a char into hidden space via a lookup table
        else 
          -- We're in the higher layers 2...N
          -- Take hidden and memory cell from layers below
          prev_c_d = outputs_d[((L-1)*2)-1]
          prev_h_d = outputs_d[((L-1)*2)]
          if dropout > 0 then prev_h_d = nn.Dropout(dropout)(prev_h_d):annotate{name='drop_' .. L} end 
    -- apply dropout, if any
        end
    
        -- Evaluate the input sums at once for efficiency
        local t2h_t = nn.Linear(rnn_size, 4 * rnn_size)(prev_h_t):annotate{name='i2h_'..L}
        local d2h_t = nn.Linear(rnn_size, 4 * rnn_size)(prev_h_d):annotate{name='h2h_'..L}
    
        -- Get transformed memory and hidden states pointing in the time direction first
        local next_c_t, next_h_t = lstm(t2h_t, d2h_t, prev_c_t, rnn_size)
    
        -- Pass memory cell and hidden state to next timestep
        table.insert(outputs_t, next_c_t)
        table.insert(outputs_t, next_h_t)
    
        -- Evaluate the input sums at once for efficiency
        local t2h_d = nn.Linear(rnn_size, 4 * rnn_size)(next_h_t):annotate{name='i2h_'..L}
        local d2h_d = nn.Linear(rnn_size, 4 * rnn_size)(prev_h_d):annotate{name='h2h_'..L}
    
        -- See section 3.5, "Weight Sharing" of http://arxiv.org/pdf/1507.01526.pdf
        -- The weights along the temporal dimension are already tied (cloned many times in train.lua)
        -- Here we can tie the weights along the depth dimension. Having invariance in computation
        -- along the depth appears to be critical to solving the 15 digit addition problem w/ high accy.
        -- See fig 4. to compare tied vs untied grid lstms on this task.
        if should_tie_weights == 1 then
          print("tying weights along the depth dimension")
          t2h_d.data.module:share(shared_weights[1], 'weight', 'bias', 'gradWeight', 'gradBias')
          d2h_d.data.module:share(shared_weights[2], 'weight', 'bias', 'gradWeight', 'gradBias')
        end
    
        -- Create the lstm gated update pointing in the depth direction.
        -- We 'prioritize' the depth dimension by using the updated temporal hidden state as input
        -- instead of the previous temporal hidden state. This implements Section 3.2, "Priority Dimensions"
        local next_c_d, next_h_d = lstm(t2h_d, d2h_d, prev_c_d, rnn_size)
    
        -- Pass the depth dimension memory cell and hidden state to layer above
        table.insert(outputs_d, next_c_d)
        table.insert(outputs_d, next_h_d)
      end
    
      -- set up the decoder
      local top_h = outputs_d[#outputs_d]
      if dropout > 0 then top_h = nn.Dropout(dropout)(top_h) end
      local proj = nn.Linear(rnn_size, input_size)(top_h):annotate{name='decoder'}
      local logsoft = nn.LogSoftMax()(proj)
      table.insert(outputs_t, logsoft)
    
      return nn.gModule(inputs, outputs_t)
    end
    
    return GridLSTM

    模型示例图如下所示:

    这里写图片描述

    tensorflow代码实现如下所示:

    展开全文
  • 而经计算,采用桁架拱理论公式的计算结果与试验结果比值的均值更接近于1,标准偏差和变异系数均较规范公式计算结果小,与试验结果吻合较好。采用美国规范ACI 318-08中构件受剪承载力公式对所收集试验数据进行计算,...
  • 语言模型的目标是计算一句话出现的概率有多高?最好的应用即生成类模型,根据一个主题完成一...评价语义模型标准 困惑度(Perplexity),一句话的困惑度越高证明生成效果越差。公式如下: 实战 本次训练方式采用二.

    语言模型的目标是计算一句话出现的概率有多高?最好的应用即生成类模型,根据一个主题完成一篇描述性文章。最近精彩的项目狗屁不通文章生成器就是典型代表。在线版本请尝试.

    理论

    一句话出现的概率:
    一句话出现的概率
    根据条件概率定义,可以推导出
    在这里插入图片描述
    因此Markov提出假设:每个单词只跟它之前的n个单词有关。进而推广二元模型(每个单词由它前面一个单词决定)、N元模型(每个单词由它前面N-1个单词决定)。

    评价语义模型的标准

    困惑度(Perplexity),一句话的困惑度越高证明生成效果越差。公式如下:
    在这里插入图片描述

    实战

    本次训练方式采用二元模型理论。

    学习目标

    • 学习语言模型,以及如何训练一个语言模型
    • 学习torchtext的基本使用方法
      • 构建 vocabulary
      • word to index 和 index to word
    • 学习torch.nn的一些基本模型
      • Linear
      • RNN
      • LSTM
      • GRU
    • RNN的训练技巧
      • Gradient Clipping
    • 如何保存和读取模型

    1. 构建训练语料

    我们会使用 torchtext 来创建vocabulary, 然后把数据读成batch的格式。请大家自行阅读README来学习torchtext。

    import torchtext
    from torchtext.vocab import Vectors
    import torch
    import numpy as np
    import random
    
    USE_CUDA = torch.cuda.is_available()
    
    # 固定随机数
    sed = 53113
    random.seed(sed)
    np.random.seed(sed)
    torch.manual_seed(sed)
    if USE_CUDA:
        torch.cuda.manual_seed(sed)
    device = torch.device('cuda')
    BATCH_SIZE = 32
    EMBEDDING_SIZE = 100
    # 循环网络中隐藏层单元
    HIDDEN_SIZE = 100
    MAX_VOCAB_SIZE = 50000
    
    • 我们会继续使用上次的text8作为我们的训练,验证和测试数据
    • torchtext提供了LanguageModelingDataset这个class来帮助我们处理语言模型数据集
      • TEXT = torchtext.data.Field(lower=True) 定义一个Field类型的对象,包含Vocab对象
      • torchtext.datasets.LanguageModelingDataset.splits() 为同一个数据集下的训练集、验证集和测试集创建数据对象。splits() 是父类的方法
      • TEXT.build_vocab() 构建词表,Construct the Vocab object for this field from one or more datasets.
      • 构建完成之后通过TEXT.vocab 查看Vocab对象
        • Vocab下有三个属性,分别是~Vocab.freqs -A collections.Counter object holding the frequencies of tokens in the data used to build the Vocab.
        • ~Vocab.stoi-A collections.defaultdict instance mapping token strings to numerical identifiers.
        • ~Vocab.itos-A list of token strings indexed by their numerical identifiers.
    • BPTTIterator可以连续地得到连贯的句子
    • 访问网页TORCHTEXT.VOCAB了解更多
      (vocab.jpg)]

    在这里插入图片描述

    # https://pytorch.org/text/data.html?highlight=field#torchtext.data.Field
    #  定义一个Field类型的对象,包含Vocab对象
    TEXT = torchtext.data.Field(lower=True)
    # 为同一个数据集下的训练集、验证集和测试集创建数据对象
    train, val, test = torchtext.datasets.LanguageModelingDataset.splits(text_field=TEXT,path=r"[换成自己的路径]text8\text8", train="text8.train.txt", validation="text8.dev.txt", test="text8.test.txt")
    # 构建词表,Construct the Vocab object for this field from one or more datasets.
    # 从一个或多个数据集中,构建Field对象下的Vocab对象
    # Vocab下有三个属性,分别是~Vocab.freqs -A collections.Counter object holding the frequencies of tokens in the data used to build the Vocab.
    # ~Vocab.stoi-A collections.defaultdict instance mapping token strings to numerical identifiers.
    # ~Vocab.itos-A list of token strings indexed by their numerical identifiers.
    TEXT.build_vocab(train, max_size=MAX_VOCAB_SIZE)
    print(f"vocabulary size:{len(TEXT.vocab)}")
    VOCAB_SIZE = len(TEXT.vocab)
    # backpropagation through time (BPTT)
    train_iter, val_iter, test_iter = torchtext.data.BPTTIterator.splits((train, val, test), batch_size=BATCH_SIZE, device=device, bptt_len=50, repeat=False, shuffle=True)
    

    1.1查看模型的输入和输出

    模型的输入是一串文字,模型的输出也是一串文字,他们之间相差一个位置,因为语言模型的目标是根据之前的单词预测下一个单词。

    it = iter(train_iter)
    for i in range(5):
        batch = next(it)
        print(f"{i} text")
        print(" ".join([TEXT.vocab.itos[i] for i in batch.text[:,0].data]))
        print(f"{i} target")
        print(" ".join([TEXT.vocab.itos[i] for i in batch.target[:,0].data]))
       
    
    # 结果
    0 text
    anarchism originated as a term of abuse first used against early working class radicals including the diggers of the english revolution and the sans <unk> of the french revolution whilst the term is still used in a pejorative way to describe any act that used violent means to destroy the
    0 target
    originated as a term of abuse first used against early working class radicals including the diggers of the english revolution and the sans <unk> of the french revolution whilst the term is still used in a pejorative way to describe any act that used violent means to destroy the organization
    1 text
    organization of society it has also been taken up as a positive label by self defined anarchists the word anarchism is derived from the greek without archons ruler chief king anarchism as a political philosophy is the belief that rulers are unnecessary and should be abolished although there are differing
    1 target
    of society it has also been taken up as a positive label by self defined anarchists the word anarchism is derived from the greek without archons ruler chief king anarchism as a political philosophy is the belief that rulers are unnecessary and should be abolished although there are differing interpretations
    2 text
    interpretations of what this means anarchism also refers to related social movements that advocate the elimination of authoritarian institutions particularly the state the word anarchy as most anarchists use it does not imply chaos nihilism or <unk> but rather a harmonious anti authoritarian society in place of what are regarded
    2 target
    of what this means anarchism also refers to related social movements that advocate the elimination of authoritarian institutions particularly the state the word anarchy as most anarchists use it does not imply chaos nihilism or <unk> but rather a harmonious anti authoritarian society in place of what are regarded as
    3 text
    as authoritarian political structures and coercive economic institutions anarchists advocate social relations based upon voluntary association of autonomous individuals mutual aid and self governance while anarchism is most easily defined by what it is against anarchists also offer positive visions of what they believe to be a truly free society
    3 target
    authoritarian political structures and coercive economic institutions anarchists advocate social relations based upon voluntary association of autonomous individuals mutual aid and self governance while anarchism is most easily defined by what it is against anarchists also offer positive visions of what they believe to be a truly free society however
    4 text
    however ideas about how an anarchist society might work vary considerably especially with respect to economics there is also disagreement about how a free society might be brought about origins and predecessors kropotkin and others argue that before recorded history human society was organized on anarchist principles most anthropologists follow
    4 target
    ideas about how an anarchist society might work vary considerably especially with respect to economics there is also disagreement about how a free society might be brought about origins and predecessors kropotkin and others argue that before recorded history human society was organized on anarchist principles most anthropologists follow kropotkin
    

    2. 定义模型

    • 继承nn.Module
    • 初始化函数
    • forward函数
    • 其余可以根据模型需要定义相关的函数
    import torch
    import torch.nn as nn
    
    class RNNModel(nn.Module):
        # 模型类型, 单词表长度,词向量长度,隐藏层单元数,循环层数目(一层还是多层),dropout
        def __init__(self, rnn_type, ntoken, ninp, nhid, nlayers, dropout=0.5):
            ''' 模型参数
                - rnn_type 模型类型,LSTM、GRU、RNN_TANH、RNN_RELU
                - ntoken 单词表长度,本例为5002
                - ninp 词向量长度(Embedding size)100
                - nhid 隐藏层单元数
                - nlayers 循环层数目
                - dropout dropout率
                该模型包含以下几层:
                - 词嵌入层
                - 一个循环神经网络层(RNN, LSTM, GRU)
                - 一个线性层,从hidden state到输出单词表
                - 一个dropout层,用来做regularization
            '''
            super(RNNModel, self).__init__()
            self.drop = nn.Dropout(dropout)
            # 编码层
            self.encoder = nn.Embedding(ntoken, ninp) # [VOCAB_SIZE, EMBEDDING_SIZE]
            if rnn_type in ['LSTM', 'GRU']: # 创建 LSTM 或 GRU 模型 对象
                self.rnn = getattr(nn, rnn_type)(ninp, nhid, nlayers, dropout=dropout)
            else:
                # 选择基础RNN模型的激活函数 
                try:
                    nonlinearity = {'RNN_TANH': 'tanh', 'RNN_RELU': 'relu'}[rnn_type]
                except KeyError:
                    raise ValueError( """An invalid option for `--model` was supplied,
                                     options are ['LSTM', 'GRU', 'RNN_TANH' or 'RNN_RELU']""")
                # 基础的RNN模型
                self.rnn = nn.RNN(ninp, nhid, nlayers, nonlinearity=nonlinearity, dropout=dropout)
            # 解码层
            self.decoder = nn.Linear(nhid, ntoken)
            
            self.init_weights()
            self.rnn_type = rnn_type
            self.nhid = nhid
            self.nlayers = nlayers
        def init_weights(self):
            initrange = 0.1
            self.encoder.weight.data.uniform_(-initrange, initrange)
            self.decoder.bias.data.zero_()
            self.decoder.weight.data.uniform_(-initrange, initrange)
        
        def forward(self, input_text, hidden):
            # emb [seq_len, batch, ninp]
            emb = self.drop(self.encoder(input_text))
            # output [seq_len, batch, num_directions * hidden_size]
            # hidden ([nlayers, batch, nhid], [nlayers, batch, nhid]) (h_t, c_t) (隐藏层状态, 细胞状态)
            output, hidden = self.rnn(emb, hidden)
            output = self.drop(output)
            # deocded [seq_len*batch, ntoken]
            decoded = self.decoder(output.view(output.size(0)*output.size(1), output.size(2)))
            # [seq_len, batch, ntoken]
            return decoded.view(output.size(0), output.size(1), decoded.size(1)), hidden
        def init_hidden(self, batch_size, requires_grad=True):
            weight = next(self.parameters())
            if self.rnn_type == 'LSTM':
                return (weight.new_zeros((self.nlayers, batch_size, self.nhid), requires_grad=requires_grad),
                        weight.new_zeros((self.nlayers, batch_size, self.nhid), requires_grad=requires_grad))
            else:
                return weight.new_zeros((self.nlayers, batch_size, self.nhid), requires_grad=requires_grad)            
    

    2.1声明模型对象

    model = RNNModel("LSTM", VOCAB_SIZE, EMBEDDING_SIZE, HIDDEN_SIZE, 2, dropout=0.5)
    if USE_CUDA:
        model = model.to(device)
    

    查看模型结构

    model
    # 结果
    RNNModel(
      (drop): Dropout(p=0.5, inplace=False)
      (encoder): Embedding(50002, 100)
      (rnn): LSTM(100, 100, num_layers=2, dropout=0.5)
      (decoder): Linear(in_features=100, out_features=50002, bias=True)
    )
    

    3.训练与评估

    3.1 模型评估代码

    • 我们首先定义评估模型的代码。
    • 模型的评估和模型的训练逻辑基本相同,唯一的区别是我们只需要forward pass,不需要backward pass
    def evaluate(model, data):
        model.eval()
        total_loss = 0
        it = iter(data)
        total_count = 0
        with torch.no_grad():
            hidden = model.init_hidden(BATCH_SIZE, requires_grad=False)
            for i, batch in enumerate(it):
                data, target = batch.text, batch.target
                if USE_CUDA:
                    data, target = data.to(device), target.to(device)
                output, hidden = model(data, hidden)
                loss = loss_fn(output.view(-1, VOCAB_SIZE), target.view(-1))
                total_count += np.multiply(*data.size())
                total_loss += loss.item()*np.multiply(*data.size())
        loss = total_loss/total_count
        model.train()
        return loss
    

    定义下面的一个function,把一个hidden state和计算图之前的历史分离。

    def repackage_hidden(h):
        """Wraps hidden states in new Tensors, to detach them from their history."""
        if isinstance(h, torch.Tensor):
            return h.detach()
        else:
            return tuple(repackage_hidden(v) for v in h)
    

    3.2 定义loss function和optimizer

    loss_fn = nn.CrossEntropyLoss()
    learning_rate = 0.001
    optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
    scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, 0.5)
    

    3.3 训练模型:

    • 模型一般需要训练若干个epoch
    • 每个epoch我们都把所有的数据分成若干个batch
    • 把每个batch的输入和输出都包装成cuda tensor
    • forward pass,通过输入的句子预测每个单词的下一个单词
    • 用模型的预测和正确的下一个单词计算cross entropy loss
    • 清空模型当前gradient
    • backward pass
    • gradient clipping,防止梯度爆炸
    • 更新模型参数
    • 每隔一定的iteration输出模型在当前iteration的loss,以及在验证集上做模型的评估
    import copy
    GRAD_CLIP = 1.
    NUM_EPOCHS = 2
    
    val_losses = []
    for epoch in range(NUM_EPOCHS):
        model.train()
        it = iter(train_iter)
        hidden = model.init_hidden(BATCH_SIZE)
        for i, batch in enumerate(it):
            text, target = batch.text, batch.target
            hidden = repackage_hidden(hidden)
            # 
            optimizer.zero_grad()
            output, hidden = model(text, hidden)
            loss = loss_fn(output.view(-1, VOCAB_SIZE), target.view(-1))
            loss.backward()
            # 梯度裁剪
            torch.nn.utils.clip_grad_norm_(model.parameters(), GRAD_CLIP)
            optimizer.step()
            # 
            if i % 3 ==0:
                print(f"epoch {epoch} batch {i} loss: {loss.item()}")
            if i%5==0:
                val_loss = evaluate(model, val_iter)
                if len(val_losses)==0 or val_loss < min(val_losses):
                    print(f'save best model, val loss is {val_loss}')
                    torch.save(model.state_dict(), 'lm_best.pth')
                else:
                    print(f"parameters decay")
                    scheduler.step()
                val_losses.append(val_loss)
    

    训练结果展示

    epoch 0 batch 0 loss: 10.822463035583496
    save best model, val loss is 10.815159148365922
    epoch 0 batch 3 loss: 10.799246788024902
    save best model, val loss is 10.769979389708967
    epoch 0 batch 6 loss: 10.769998550415039
    epoch 0 batch 9 loss: 10.713444709777832
    save best model, val loss is 10.637265799769702
    epoch 0 batch 12 loss: 10.571533203125
    epoch 0 batch 15 loss: 10.1561279296875
    save best model, val loss is 9.966347007765822
    epoch 0 batch 18 loss: 9.652090072631836
    ....
    

    4. 加载模型参数

    在训练时,保存了最优的模型参数,在使用时通过下面代码加载

    model.load_state_dict(torch.load('lm_best.pth'))
    

    4.1 评估valid数据

    使用最好的模型在valid数据上计算perplexity

    val_loss = evaluate(best_model, val_iter)
    print("perplexity: ", np.exp(val_loss))
    

    4.2 评估test数据

    test_loss = evaluate(best_model, test_iter)
    print("perplexity: ", np.exp(test_loss))
    

    4.3 生成模型测试

    hidden = best_model.init_hidden(1)
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    input = torch.randint(VOCAB_SIZE, (1, 1), dtype=torch.long).to(device)
    words = []
    for i in range(100):
        output, hidden = best_model(input, hidden)
        word_weights = output.squeeze().exp().cpu()
        word_idx = torch.multinomial(word_weights, 1)[0]
        input.fill_(word_idx)
        word = TEXT.vocab.itos[word_idx]
        words.append(word)
    print(" ".join(words))
    # 结果 训练效果足够好的话,可以生成很棒的结果
    models and windward <unk> and labor listed significant monuments some generation from the ship process in two zero zero zero recommend in history of lorenz one six zero zero two malicious than varieties including <unk> and tea language <unk> of animals or printers in chr <unk> s minor and gods preferred order for vector parallel the twelfth gibbon bar is g the gr follows pv to fund it worshipped to store ceilings in europe the german <unk> greek bond hosea was only uncertain to warmed publicly severe rolfe up u s often a tissue from the peters divisions the bengals
    
    展开全文
  • Softmax和分类模型

    2020-02-13 11:33:17
    基本概念 神经网络图 softmax回归同线性回归一样,也是一个单层...首先假设样本与理论标准函数的误差(类似于线性回归那一章中生成数据时叠加上的高斯误差)服从正态分布(高斯分布),并且不同样本之间独立同分布,...
  • 迁移学习与大规模的transformers语言模型训练的结合正在成为现代NLP的一个标准。在这篇文章,我们对transformers体系结构和文本分类问题做一些必要的理论介绍。然后,我们将演示预训练BERT模型在文本分类任务的微调...
  • 以平均温度为检验标准,简化等效截面的温度场曲线,得出方便应用的梯形抛物弓叠合等效温度场模型。基于等效温度场模型确定平均温度计算方法,得出免于积分运算的平均温度简便计算公式。该公式计算精度满足工程要求,表明...
  • 对于标准的Hermitian和unit(三角)矩阵模型以及它们的各种变形(经典变形和量子变形),都是如此。 为分区函数建立明确的公式对于实际的计算机计算非常有效。 但是,要从理论上处理它们,需要将剩余的有限和驯服在...
  •  本文主要基于论文[1],[1]的主要讲述的webrtc采用的拥塞控制算法gcc的理论分析。我主要分析其中的公式推导部分。  假设一条链路的容量为C,目前只有一个session。根据基于Fluid Model[2]的分析,链路队列排队...
  • 首先建立先验信息标准模型,将先验信息转换成置信区间形式;然后根据D-S证据理论和Pignistic转换推导先验信息矩值,并解算先验分布超参数;最后基于Bayes定理给出后验分布和评估公式。实例证明该方法相比Bayes评估...
  • 从最近提出的关于辅助场的线性公式开始,我们研究Born和Born-Infeld理论的n场推广。 在此描述中,拉格朗日向量场强度是二次方的,并且相应的非线性理论的对称性(包括特征自对偶性)表现为壳对偶对称性,并取决于...
  • 针对普通高校体育课考试中存在的实际问题,经过调查研究认为:普通...在原始分数分布不合理的情况下,建议以70分为参照点,标准化评分的计分范围以士3S的转换数学模型较合理,其转换数学模型公式为: Z6=70+X--X/6S ×100
  • 同时克服了标准的脉冲耦合神经网络模型参数过多的缺点,识别率也有所改善。理论与实验结果表明,该方法与现有的基于子空间分解的人脸特征提取方法相比,对人脸图像在采集过程中的光照、旋转、位置等变化有较强的鲁棒...
  • 首先建立先验信息标准模型,将先验信息转换成置信区间形式;然后根据D-S证据理论和Pignistic转换推导先验信息矩值,并解算先验分布超参数;最后基于Bayes定理给出后验分布和评估公式。实例证明该方法相比Bayes评估...
  • Adaboost由于其分类效果好,算法简单,还有其可靠的理论基础,深受大家欢迎。... 其实这些模型难于理解在于看到公式表达就头晕,所以针对每个字符的意义,我做了详细的说明,这样一看就明白了。 提升方式基...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 129
精华内容 51
关键字:

标准模型理论公式