2016-12-01 18:01:09 pirage 阅读数 10942
  • Python文本数据分析--实战视频教学

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程首先概述文本分析的基本概念,整个课程围绕案例进行:新闻分类任务。案例从零开始讲解如何使用Python库进行分析与建模的工作。案例中实例演示如何从杂乱的文本数据开始进行分词预处理到后应用贝叶斯算法进行分类预测。 专属会员卡更超值:http://edu.csdn.net/lecturer/1079

    4147 人正在学习 去看看 唐宇迪

分词原理

本小节内容参考待字闺中的两篇博文:

  1. 97.5%准确率的深度学习中文分词(字嵌入+Bi-LSTM+CRF)
  2. 如何深度理解Koth的深度分词?

简单的说,kcws的分词原理就是:

  1. 对语料进行处理,使用word2vec对语料的字进行嵌入,每个字特征为50维。
  2. 得到字嵌入后,用字嵌入特征喂给双向LSTM, 对输出的隐层加一个线性层,然后加一个CRF就得到本文实现的模型。
  3. 于最优化方法,文本语言模型类的貌似Adam效果更好, 对于分类之类的,貌似AdaDelta效果更好。

另外,字符嵌入的表示可以是纯预训练的,但也可以在训练模型的时候再fine-tune,一般而言后者效果更好。对于fine-tune的情形,可以在字符嵌入后,输入双向LSTM之前加入dropout进一步提升模型效果。

figure1

具体的解决方案,基于双向LSTM与CRF的神经网络结构

如上图所示,单层圆圈代表的word embedding输入层,菱形代表学习输入的决定性方程,双层圆圈代表随机变量。信息流将输入层的word embedding送到双向LSTM, l(i)代表word(i)和从左边传入的历史信号,r(i)代表word(i)以及从右边传入的未来的信号,用c(i)连接这两个向量的信息,代表词word(i)。

先说Bi-LSTM这个双向模型,LSTM的变种有很多,基本流程都是一样的,文献中同样采用上一节说明的三个门,控制送入memory cell的输入信息,以及遗忘之前阶段信息的比例,再对细胞状态进行更新,最后用tanh方程对更新后的细胞状态再做处理,与sigmoid叠加相乘作为最终输出。具体的模型公式见下图,经过上一节的解释,这些符号应该不太陌生了。

公式

双向LSTM说白了,就是先从左至右,顺序学习输入词序列的历史信息,再从右至左,学习输入词序列未来影响现在的信息,结合这两种方式的最终表示有效地描述了词的内容,在多种标注应用上取得了好效果。

如果说双向LSTM并不特殊,这个结构中另一个新的尝试,就是将深度神经网络最后学出来的结果,作为特征,用CRF模型连接起来,用P来表示双向LSTM神经网络学习出来的打分输出矩阵,它是一个 nxk 的矩阵,n是输入词序列个数,k是标记类型的数目, P(ij)指的是在一个输入句子中,第i个词在第j个tag标记上的可能性(打分)。另外一个特征函数是状态转移矩阵 A,A(ij) 代表从tag i转移到tag j的可能性(打分),但这个转移矩阵实际上有k+2维,其中包括句子的开始和结束两个状态,用公式表示如下图:

s(X,y)=i=0nAyi,yi+1+i=1nPi,yi

在给定输入序列X,最终定义的输出y序列的概率,则使用softmax函数表示如下:

p(y|X)=es(X,y)y˘YXes(X,y˘)

而在训练学习目标函数的时候,要优化的就是下面这个预测输出标记序列的log概率,其中 Y(X)代表的是所有可能的tag标记序列集合,那么最后学习得到的输出,就是概率最大的那个标记序列。如果只是模拟输出的bigram交互影响方式,采用动态规划即可求解下列方程。

log(p(y|X))=s(X,y)log(y˘YXes(X,y˘))

=s(X,y)logaddy˘YXs(X,y˘)

y=argmaxy˘YXs(X,y˘)

至此,基于双向LSTM与CRF的神经网络结构已经介绍完毕,文献中介绍的是在命名实体识别方面的一个实践应用,这个思路同样可以用在分词上。具体的实践和调参,也得应场景而异,Koth在上一篇博客中已经给出了自己的践行,读者们可以借鉴参考。

代码结构与实践

koth大神开源的项目地址为:https://github.com/koth/kcws

主要的代码在目录kcws/kcws/train路径下。(写这篇文章的时候发现K大神做了更新,我主要还是分析之前的代码)

  • process_anno_file.py 将人民网2014训练语料进行单字切割,包括标点符号
  • generate_training.py 生成单字的vector之后,处理每篇训练语料,以“。”划分为句子,对每个句子,如果长度大于MAX_LEN(默认设置为80,在代码里改),不处理,Long lines加一,如果长度小于MAX_LEN,则生成长度为160的vector,前80为单字在字典中的index,不足80的补0,后80为每个字对应的SBME标记(S表示单字,B表示开始,M表示中间,E表示结尾)。
  • filter_sentence.py 将语料切分为训练集和测试集,作者将含有两个字以下的句子过滤掉,剩下的按照二八分,测试集最多8000篇。
  • train_cws_lstm.py 主要训练代码。

作者在项目主页上很详细的写了构建和训练的步骤,按照这些步骤来实践一下不算难,我主要遇到了以下几个问题:

  1. 之前安装tensorflow的时候没有用bazel,不了解bazel的工作方式和原理,但是这个项目必须要用,因为需要用到third_party中word2vec的类。(可以将word2vec的某些类构建为python可以import的类?)
  2. 已安装的0.8.0版本的tensorflow没有实现crf,需要升级。
  3. 安装tensorflow 0.11.0版本后运行,出现PyUnicodeUCS4_AsUTF8String的错误,查找后发现是当前安装的python默认是unicode=ucs2,需要重新编译安装python。编译的时候设置./configure –enable-unicode=ucs4 。
  4. numpy,scipy都需要重新build,setup。

主要代码分析

def main(unused_argv):
    curdir = os.path.dirname(os.path.realpath(__file__))
    trainDataPath = tf.app.flags.FLAGS.train_data_path
    if not trainDataPath.startswith("/"):
        trainDataPath = curdir + "/" + trainDataPath
    graph = tf.Graph()
    with graph.as_default():
        model = Model(FLAGS.embedding_size, FLAGS.num_tags,
                  FLAGS.word2vec_path, FLAGS.num_hidden)
        print("train data path:", trainDataPath)
        # 读取训练集batch大小的feature和label,各为80大小的数组
        X, Y = inputs(trainDataPath)  
        # 读取测试集所有数据的feature和label,各为80大小的数组
        tX, tY = do_load_data(tf.app.flags.FLAGS.test_data_path) 
        # 计算训练集的损失
        total_loss = model.loss(X, Y)  
        # 使用AdamOptimizer优化方法
        train_op = train(total_loss)  
        # 在测试集上做评测
        test_unary_score, test_sequence_length = model.test_unary_score() 
        # 创建Supervisor管理模型的分布式训练
        sv = tf.train.Supervisor(graph=graph, logdir=FLAGS.log_dir) 
        with sv.managed_session(master='') as sess:
            # actual training loop
            training_steps = FLAGS.train_steps
            for step in range(training_steps):
                if sv.should_stop():
                    break
                try:
                    _, trainsMatrix = sess.run(
                    [train_op, model.transition_params])
                    # for debugging and learning purposes, see how the loss gets decremented thru training steps
                    if step % 100 == 0:
                        print("[%d] loss: [%r]" % (step, sess.run(total_loss)))
                    if step % 1000 == 0:
                        test_evaluate(sess, test_unary_score,
                                  test_sequence_length, trainsMatrix,
                                  model.inp, tX, tY)
                except KeyboardInterrupt, e:
                    sv.saver.save(sess,
                              FLAGS.log_dir + '/model',
                              global_step=step + 1)
                    raise e
            sv.saver.save(sess, FLAGS.log_dir + '/finnal-model')
            sess.close()

Class Model:

def __init__(self, embeddingSize, distinctTagNum, c2vPath, numHidden):
    self.embeddingSize = embeddingSize
    self.distinctTagNum = distinctTagNum
    self.numHidden = numHidden
    self.c2v = self.load_w2v(c2vPath)
    self.words = tf.Variable(self.c2v, name="words")
    with tf.variable_scope('Softmax') as scope:
        self.W = tf.get_variable(
            shape=[numHidden * 2, distinctTagNum],
            initializer=tf.truncated_normal_initializer(stddev=0.01),
            name="weights",
            regularizer=tf.contrib.layers.l2_regularizer(0.001))
        self.b = tf.Variable(tf.zeros([distinctTagNum], name="bias"))
    self.trains_params = None
    self.inp = tf.placeholder(tf.int32,
                              shape=[None, FLAGS.max_sentence_len],
                              name="input_placeholder")
    pass

def length(self, data):
    used = tf.sign(tf.reduce_max(tf.abs(data), reduction_indices=2))
    length = tf.reduce_sum(used, reduction_indices=1)
    length = tf.cast(length, tf.int32)
    return length

def inference(self, X, reuse=None, trainMode=True):
    word_vectors = tf.nn.embedding_lookup(self.words, X) # 按照X顺序返回self.words中的第X行,返回的结果组成tensor。
    length = self.length(word_vectors)
    # length是shape为[batch_size]大小值为句子长度的vector
    length_64 = tf.cast(length, tf.int64)
    if trainMode:  # 训练的时候启用dropout,测试的时候关键dropout
        word_vectors = tf.nn.dropout(word_vectors, 0.5)  # 将word_vectors按照50%的概率丢弃某些词,tf增加的一个处理是将其余的词scale 1/0.5
    with tf.variable_scope("rnn_fwbw", reuse=reuse) as scope:
        forward_output, _ = tf.nn.dynamic_rnn(
            tf.nn.rnn_cell.LSTMCell(self.numHidden),
            word_vectors,
            dtype=tf.float32,
            sequence_length=length,
            scope="RNN_forward")
        backward_output_, _ = tf.nn.dynamic_rnn(
            tf.nn.rnn_cell.LSTMCell(self.numHidden),
            inputs=tf.reverse_sequence(word_vectors,
                                       length_64,
                                       seq_dim=1),
            # 训练和测试的时候,inputs的格式不同。训练时,tensor shape是[batch_size, max_time,input_size]
            # 测试时,tensor shape是[max_time,batch_size,input_size].
            # tf.reverse_sequence作用就是指定在列上操作(batch_dim表示按行操作)
            dtype=tf.float32,
            sequence_length=length,
            scope="RNN_backword")
    # tf.nn.dynamic_rnn(cell, inputs, sequence_length,time_major,...)主要参数:
    # cell:搭建好的网络,这里用LSTMCell(num_cell),num_cell表示一个lstm单元输出的维数(100)
    # inputs:word_vectors,它的shape由time_major决定,默认是false,即[batch_size,max_time,input_size],如果是测试
    #           过程,time_major设置为True,shape为[max_time,batch_size,input_size],这里直接做了reverse,省去了time_major设置。
    #         其中,batch_size=100, max_time=80句子最大长度,input_size字的向量的长度。
    # sequence_length:shape[batch_size]大小的值为句子最大长度的tensor。
    # 输出:
    #   outputs:[batch_size, max_time, cell.output_size]
    #   state: shape取决于LSTMCell中state_size的设置,返回Tensor或者tuple。

    backward_output = tf.reverse_sequence(backward_output_,
                                          length_64,
                                          seq_dim=1)
    # 这里的reverse_sequence同上。
    output = tf.concat(2, [forward_output, backward_output])
    # 连接两个三维tensor,2表示按照列连接(0表示纵向,1表示行)
    # 连接后,output的shape:[batch_size, max_time, 2*cell.output_size],即[100, 80, 2*50]
    output = tf.reshape(output, [-1, self.numHidden * 2])
    # reshape后,output的shape:[batch_size, self.numHidden * 2],即[100, 200]
    matricized_unary_scores = tf.batch_matmul(output, self.W)
    # 得到未归一化的CRF输出
    # 点乘W的shape[ 100*2, 4],生成[batch_size, 4]大小的matricized_unary_scores
    unary_scores = tf.reshape(
        matricized_unary_scores,
        [-1, FLAGS.max_sentence_len, self.distinctTagNum])
    # reshape后,unary_scores大小为[batch_size,80, 4]
    return unary_scores, length

def loss(self, X, Y):
    P, sequence_length = self.inference(X)
    # CRF损失计算,训练的时候使用,测试的时候用viterbi解码
    log_likelihood, self.transition_params = tf.contrib.crf.crf_log_likelihood(
        P, Y, sequence_length)
    # crf_log_likelihood参数(inputs,tag_indices, sequence_lengths)
    #   inputs:大小为[100, 80, 4]的tensor,CRF层的输入
    #   tag_indices:大小为[100, 80]的矩阵
    #   sequence_length:大小 [100]值为80的向量。
    # 输出:
    #   log_likelihood:[batch_size]大小的vector,log-likelihood值
    #   transition_params:[4,4]大小的矩阵
    loss = tf.reduce_mean(-log_likelihood)
    return loss

def load_w2v(self, path): #返回(num+2)*50大小的二维矩阵,其中第一行全是0,最后一行是每个词向量维度的平均值。
    fp = open(path, "r")
    print("load data from:", path)
    line = fp.readline().strip()
    ss = line.split(" ")
    total = int(ss[0])
    dim = int(ss[1])
    assert (dim == (FLAGS.embedding_size))
    ws = []
    mv = [0 for i in range(dim)]
    # The first for 0
    ws.append([0 for i in range(dim)])
    for t in range(total):
        line = fp.readline().strip()
        ss = line.split(" ")
        assert (len(ss) == (dim + 1))
        vals = []
        for i in range(1, dim + 1):
            fv = float(ss[i])
            mv[i - 1] += fv
            vals.append(fv)
        ws.append(vals)
    for i in range(dim):
        mv[i] = mv[i] / total
    ws.append(mv)
    fp.close()
    return np.asarray(ws, dtype=np.float32)

def test_unary_score(self):
    P, sequence_length = self.inference(self.inp,
                                        reuse=True,
                                        trainMode=False)
    return P, sequence_length

其他的代码比较简单,个人觉得不必要做深入分析。

总结

近一两个月开始学习TensorFlow,代码看了一些,但是总感觉临门差那么一脚。革命尚未完成,同志们仍需努力!

2019-09-10 17:20:31 isxixi 阅读数 209
  • Python文本数据分析--实战视频教学

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程首先概述文本分析的基本概念,整个课程围绕案例进行:新闻分类任务。案例从零开始讲解如何使用Python库进行分析与建模的工作。案例中实例演示如何从杂乱的文本数据开始进行分词预处理到后应用贝叶斯算法进行分类预测。 专属会员卡更超值:http://edu.csdn.net/lecturer/1079

    4147 人正在学习 去看看 唐宇迪

一、中文分词方法

  1. 基于字典的分词方法
  2. 基础规则的分词方法
  3. 基于统计的分词方法(统计在一段话中出现频率最的那个分词字段)
  4. 基于深度学的的方法(通过大量的数据的学习)

二、词向量化

  1. one-hot
  2. word2vec 将词映射到多维空间里

三、神经网络

  1. RNN(循环神经网络)
    特点:记忆是短期,梯度消失以及梯度爆炸‘’
  2. LSTM(长短期记忆网络) 是 RNN 的进一步优化
    特点:克服 RNN 梯度消失的问题,而且能学习到长距离的信息
  3. BILSTM (双向长短期神经网络)

四、统计模型

CRF:条件随机场是标记、分割结构化数据的统计模型。CRF 优于隐马尔可夫模型在于放松了 HMM 所需的独立性假设。另外避免了标签偏差问题。CRF 训练的损失函数是凸函数,全局收敛,具有非常好的实用性。
特点:隐马尔可夫是有向图,每个状态依赖于上个状态,而线性链条件随机场是无向
图,当前状态依赖于周围结点的状态,可以捕捉全局信息,所以效果更好

五、jieba 分词
jieba 是结合基于规则和基于统计的分词工具。
jieba 有三种分词模式,分别是精确模式,全模式和搜索引擎模式
六、词向量

  1. 输入层
    使用one-hot编码。
  2. 隐藏层
    隐藏层的神经单元数量代表着每一个词用向量表示的维度。
  3. 输出层
    七、分词的评估标准
    精确率:正确的分词个数/总分词的个数
    召回率:正确的个数/标准分词的个数
    F值:正确率召回率2/(正确率+召回率)
    错误率:错误分词的个数/标准分词的个数
2019-08-27 09:53:03 emdsh 阅读数 121
  • Python文本数据分析--实战视频教学

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程首先概述文本分析的基本概念,整个课程围绕案例进行:新闻分类任务。案例从零开始讲解如何使用Python库进行分析与建模的工作。案例中实例演示如何从杂乱的文本数据开始进行分词预处理到后应用贝叶斯算法进行分类预测。 专属会员卡更超值:http://edu.csdn.net/lecturer/1079

    4147 人正在学习 去看看 唐宇迪

第六章,深度学习用于文本和序列

 

深度学习不会接收原始文本作为输入,只能处理数值张量,文本向量化是指将文本转换为数值张量的过程。(文本可分割为标记:单词,字符,n-gram,分解为标记的过程叫做分词,然后将其转换为张量)

one-hot将每个单词与一个唯一的整数索引相关联,将整数索引i转换为长度为N的二进制向量。One-hot编码是标记转化为向量最基本最常用的方法,得到的是二进制的,稀疏的维度很高的向量。

 

词向量(词嵌入):是从数据中学习到的,得到低维的浮点型向量。

学习方式一:在完成主任务的同时学习词嵌入,对随机的词向量进行学习。

学习方式二:预训练词嵌入,计算好词嵌入加载到模型上。

利用Embedding层学习词嵌入:对每个新的任务都学习一个新的嵌入空间,利用Embedding层学习一个层的权重,将Embedding层理解为一个字典,将帧数索引映射为密集向量。Embedding层是一个二维整数张量(samples,sequence_length),返回形状为(samples,sequence_length,embedding_dimensionality)的三维浮点数张量。

       使用预训练的词嵌入:原理同图像分类中使用的预训练的卷积神经网络一样,这种词嵌入利用词频统计计算得出。

 

处理IMDB数据的原始文本
import os
imdb_dir='D:\\jupyter_code\\GloVe\\aclImdb'
train_dir=os.path.join(imdb_dir,'train')

labels=[]
texts=[]

for label_type in ['neg','pos']:
    dir_name=os.path.join(train_dir,label_type)
    for fname in os.listdir(dir_name):
        if fname[-4:]=='.txt':
            f=open(os.path.join(dir_name,fname),encoding='UTF-8')
            texts.append(f.read())
            f.close()
            if label_type=='neg':
                labels.append(0)
            else:
                labels.append(1)
                
#对imdb原始数据的文本进行分词
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
import numpy as np
#在100个单词后截断评论
maxlen=100
#200个样本上训练
training_samples=200
#在10000个样本上验证
validation_samples=10000
#只考虑前10000个最常见的单词
max_words=10000

tokenizer=Tokenizer(num_words=max_words)
#根据文本列表更新词汇表
tokenizer.fit_on_texts(texts)
sequences=tokenizer.texts_to_sequences(texts)

word_index=tokenizer.word_index
print('Found %s unique tokens.'%len(word_index))

data=pad_sequences(sequences,maxlen=maxlen)

labels=np.asarray(labels)
print(data.shape)
print(labels.shape)

#打乱数据在划分数据
indices=np.arange(data.shape[0])
np.random.shuffle(indices)
data=data[indices]
labels=labels[indices]

x_train=data[:training_samples]
y_train=labels[:training_samples]
x_val=data[training_samples:training_samples+validation_samples]
y_val=labels[training_samples:training_samples+validation_samples]

#解析GloVe嵌入文件
glove_dir='D:\\jupyter_code\\GloVe\\glove.6B'

embeddings_index={}
f=open(os.path.join(glove_dir,'glove.6B.100d.txt'),encoding='UTF-8')
for line in f:
    values=line.split()
    word=values[0]
    coefs=np.asarray(values[1:],dtype='float32')
    embeddings_index[word]=coefs
f.close()

print('Found %s word vectors'%len(embeddings_index))

#准备GloVe词嵌入词库
embedding_dim=100
embedding_matrix=np.zeros((max_words,embedding_dim))
for word, i in word_index.items():
    if i<max_words:
        embedding_vector=embeddings_index.get(word)
        if embedding_vector is not None:
            embedding_matrix[i]=embedding_vector

#定义模型
from keras.models import Sequential
from keras.layers import Embedding,Flatten,Dense

model=Sequential()
model.add(Embedding(max_words,embedding_dim,input_length=maxlen))
model.add(Flatten())
model.add(Dense(32,activation='relu'))
model.add(Dense(1,activation='sigmoid'))
model.summary()

#预训练的词嵌入加载到Embedding层,冻结Embedding
model.layers[0].set_weights([embedding_matrix])
model.layers[0].trainable=False


#模型训练与评估
model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['acc'])
history=model.fit(x_train,y_train,epochs=10,batch_size=32,validation_data=(x_val,y_val))
model.save_weights('pre_trained_glove_model.h5')

#在不使用预训练词嵌入的情况下,训练相同的模型
from keras.models import Sequential
from keras.layers import Embedding,Flatten,Dense

model=Sequential()
model.add(Embedding(max_words,embedding_dim,input_length=maxlen))
model.add(Flatten())
model.add(Dense(32,activation='relu'))
model.add(Dense(1,activation='sigmoid'))
model.summary()

model.compile(optimizer='rmsprop',loss='binary_crossentropy',metrics=['acc'])
history=model.fit(x_train,y_train,epochs=10,batch_size=32,validation_data=(x_val,y_val))

#对测试集数据进行分词
test_dir=os.path.join(imdb_dir,'test')
labels=[]
texts=[]

for label_type in ['neg','pos']:
    dir_name=os.path.join(test_dir,label_type)
    for fname in sorted(os.listdir(dir_name)):
        if fname[-4:]=='.txt':
            f=open(os.path.join(dir_name,fname),encoding='UTF-8')
            texts.append(f.read())
            f.close()
            if label_type=='neg':
                labels.append(0)
            else:
                labels.append(1)

sequences=tokenizer.texts_to_sequences(texts)
x_test=pad_sequences(sequences,maxlen=maxlen)
y_test=np.asarray(labels)

model.load_weights('pre_trained_glove_model.h5')
model.evaluate(x_test,y_test)

 

2020-02-14 17:51:44 qq_30205387 阅读数 30
  • Python文本数据分析--实战视频教学

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 课程首先概述文本分析的基本概念,整个课程围绕案例进行:新闻分类任务。案例从零开始讲解如何使用Python库进行分析与建模的工作。案例中实例演示如何从杂乱的文本数据开始进行分词预处理到后应用贝叶斯算法进行分类预测。 专属会员卡更超值:http://edu.csdn.net/lecturer/1079

    4147 人正在学习 去看看 唐宇迪

Task 01

线性回归
线性回归的基本要素:模型、数据集、损失函数和优化函数
Softmax与分类模型
在这里插入图片描述
多层感知机
在这里插入图片描述

Task 02

文本预处理

文本是一类序列数据,一篇文章可以看作是字符或单词的序列,本节将介绍文本数据的常见预处理步骤,预处理通常包括四个步骤:

1. 读入文本
2. 分词
3. 建立字典,将每个词映射到一个唯一的索引(index)
4. 将文本从词的序列转换为索引的序列,方便输入模型

读入文本
lines = [re.sub(’[^a-z]+’, ’ ', line.strip().lower()) for line in f]
%将文本中的大写替换成小写,并将由非英文字母构成的子串替换成空格

分词
在这里插入图片描述
分别以单词或者字符为单位进行分词

建立字典:为每个词映射一个唯一的索引
for idx, token in enumerate(self.idx_to_token)

用现有工具进行分词:spaCy:和NLTK:
在这里插入图片描述
在这里插入图片描述

## 语言模型

基于统计的语言模型,主要是nn元语法
N元语法的缺陷: 参数空间过大(v+v2+v3+…),数据稀疏(齐夫定律:大多数的单词的词频低)

时序数据的采样:随机采样和相邻采样
相邻采样:
在这里插入图片描述

循环神经网络基础

在这里插入图片描述

## 过拟合欠拟合

训练误差和泛化误差(常用测试数据集上的误差来近似)
欠拟合:模型无法得到较小的训练误差
过拟合:
在这里插入图片描述

正常情况
在这里插入图片描述
欠拟合情况
在这里插入图片描述
过拟合情况
在这里插入图片描述

降低过拟合的方法:

  1. 获得更多的训练样本。比如通过数据增强方式来扩充或者GAN来合成。
  2. 降低模型的复杂度。
  3. 正则化
  4. 集成学习方法
  5. dropout

降低欠拟合的方法:
6. 添加新的特征
7. 增加模型的复杂度,加强模型的拟合能力
8. 减小正则化系数

梯度消失、梯度爆炸

考虑环境因素:协变量偏移、标签偏移和概念偏移

循环神经网络进阶

裁剪梯度是一种应对梯度爆炸的方法

机器翻译及相关技术

问题:如何将输入序列映射为可能不等大小的输出序列(例如:I am Chinese -> 我是中国人)
在机器翻译模型的训练中,每个batch中的数据都要是相同长度的->pad

Encoder和decoder框架
Sequence to Sequence
在这里插入图片描述
维特比算法

注意力机制与seq2seq模型

Transform模型
要点在于:并行化和长序列的依赖
在这里插入图片描述

卷积神经网络基础

卷积可以由互相关引入,但是具体来说还存在一个核中心翻转的过程(从频率域滤波的角度来看)但由于在卷积层中参数是可学习的,故可直接等价 。

卷积神经网络进阶

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

之前题目中提到relu函数是否存在梯度消失问题:
https://www.zhihu.com/question/49230360

批量归一化和残差网络

BN处理
训练:以batch为单位,对每个batch计算均值和方差。
预测:用移动平均估算整个训练数据集的样本均值和方差。(滑动求均值和方差),或者说,一般到模型训练后期稳定后,后续批次的均值和方差可以直接作为测试的均值和方差

残差网络:residual block(恒等映射)->解决梯度消失问题

稠密连接网络(densenet):与resnet的区别在于使用相加和使用联结(concat)

凸优化

• 优化方法目标:训练集损失函数值
• 深度学习目标:测试集损失函数值(泛化性)
在深度学习中的挑战:1. 局部最小值 2. 鞍点 3. 梯度消失

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
凸性证明
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

梯度下降

证明:
在这里插入图片描述
(在一定程度上依赖于学习率)梯度下降的自适应方法

在这里插入图片描述
预处理 (Heissan阵辅助梯度下降)
梯度下降与线性搜索(共轭梯度法)
随机梯度下降
动态学习率

图像风格迁移

内容损失:平方误差
样式损失:格拉姆矩阵(Gram matrix)XX⊤∈Rc×c
总差分误差:抑制特别亮或者特别暗的像素

内容损失使合成图像与内容图像在内容特征上接近,样式损失令合成图像与样式图像在样式特征上接近,而总变差损失则有助于减少合成图像中的噪点。
在这里插入图片描述

图像分类案例1

目标检测基础

图像分类案例2

GAN

DCGAN

数据增强

Pytorch中的torchvision.transforms模块用于数据增强
RandomHorizontalFlip实例来实现一半概率的图像水平(左右)翻转
RandomVerticalFlip实例来实现一半概率的图像垂直(上下)翻转
RandomResizedCrop随机裁剪
ColorJitter变化颜色

多个增广方法的叠加 torchvision.transforms.Compose

模型微调

模型迁移
在这里插入图片描述
调参过程:先讲训练集划分为训练集和验证集,再放入模型训练调参过程,后续再讲完整训练集放入训练,最终在测试集上进行测试

NLP工作内容总结

阅读数 481

没有更多推荐了,返回首页