怎么教孩子标自然段2020-01-10 13:17:02文/宋则贤
一篇文章,每个自然段前面空两个字,是自然段。几句话，不是表达一个完整的意思，没有题目，就是几句话。自然段由若干句子组成，每句话相互连贯，才能形成一个自然段，反则应分为两个自然段。
怎么教孩子标自然段
一篇文章,每个自然段前面空两个字,是自然段。几句话，不是表达一个完整的意思，没有题目，就是几句话。自然段由若干句子组成，每句话相互连贯，才能形成一个自然段，反则应分为两个自然段。若干自然段可以构成一个大段，以表达一件相关的事情的发展经过，也可以直接构成一篇文章，即文章只有一个问题，或者一件事，等等。
划分方法
1.按时间空间顺序划分。这类文章在行文上往往有明显的标志时间的词语，找出了有助于划分段落的标志。如《分马》写了“分马前”、“分马中”、“分马后”，共三段。
2.按地点的转换(空间位置变化)划分。如《故乡》，按“去故乡”、“在故乡”“离故乡”划分段落。
3.按文章结构特点划分。常见的如“总——分”或“分——总”可分两大段；有的是“总——分——总”，可分三部分。如《春》的主体部分“绘春”：春回大地，万物复苏，生机勃勃的景象(总)——春草如茵：春花争艳；春风送暖；春雨绵绵；人勤春早(分)。《谁是最可爱的人》：抒情议论(总)——三个典型事例(分)——抒情议论(总)(“总”赞美志愿军战士优秀品质)。
4.按思想情感变化划分。如《荔枝蜜》，作者以对蜜蜂的感情变化为线索，分“不大喜欢蜜蜂”、“想去看看蜜蜂”、“赞美蜜蜂”、“想变蜜蜂”四部分。
5.按故事情节的发展划分。如故事、小说，通常按情节划分：“开端、发展、高潮、结局”四部分，或“开始”、“经过”、“结束”三部分。如《我的叔叔于勒》：盼于勒、赞于勒、见于勒、躲于勒。

展开全部
看图写话技巧：
1、开头空两格。有几幅图就写几个自然段。
2、第一句要明确写e68a843231313335323631343130323136353331333433636234清：什么时间、谁、在哪儿、干什么。
3、通过仔细观察，展开想象，能够写出每幅图“最重要的情节”，必须详细写。所谓“详细写”，就是能写出人物间的对话，图中的人物具体是怎么做的，并能够用上恰当的动词。别人一看就知道这句话写得就是这幅图的内容，而不是其他图的内容。
4、能正确使用“，”“。”“？”“！”。能写通顺的句子，不丢字，不多字。学过的字必须写字，没有学过的字可以写拼音。
例文一
一个阳光明媚的早上，小白兔背着书包上学去。小猴子和它的妈妈也来到了小河边，它们要到小河的对岸摘桃子，对岸的桃子又红又大，像一个个小灯笼。在独木桥的另一边，小兔子正要过桥。小猴子和它妈妈也正好来到桥头边，小猴子看见小兔子在独木桥的另一边。
就对妈妈说：“小兔姐姐要上学去了，我们让它先过桥吧！”妈妈笑了笑直夸小猴子，她说：“小宝贝，你真懂事，我们让小兔子先过桥吧！”小兔子过了桥，对猴妈妈和小猴弟弟说：“谢谢你们了，再见！”
小兔子背着书包一蹦一跳的向学校跑去。小猴子和妈妈也高高兴兴的来到果园，摘了满满的两大筐桃子。
例文二
有一天，猴哥哥和猴弟弟到树林里玩。玩到吃晚饭的时候，天就黑了。他们俩的肚子饿得咕咕叫，这可把兄弟俩急得抓耳挠腮。
猴哥哥突然看见一片桃林，高兴得大叫：“弟弟，看！那里有一片桃林！”猴弟弟马上跑过来说：“真的吗？”“真的！”猴哥哥说。“可是有一条小河呀！”弟弟说。这时，猴哥哥看见一个大木盆，说：“我们找一根木棍划着木盆过去。”
就这样兄弟俩把木盆抬到小河上，猴哥哥找来了一根木棍，兄弟俩就高高兴兴地到了河对岸。把木盆抬上岸后，猴哥哥说：“弟弟，我爬到树上摘桃子，你在下面接住后放到盆子里。”说完，猴哥哥就爬上了树，他摘了个粉红粉红的大桃子，就尝了一口。
“哇！太好吃啦！弟弟你也尝一个吧！”猴哥说着就把一个桃子扔给了猴弟弟。猴弟弟尝了一口就说：“真的很好吃！哥哥多摘点桃子，分给大家吃！”于是他们摘了很多的桃子，都够吃到猴年马月了。
例文三
一个风和日丽的日子，猴子兄弟去小河边玩。忽然，猴弟弟发现对岸的几棵桃树上结了许多又大又红的桃子，他恨不得马上飞过河去吃桃。猴猴弟弟对猴哥哥说：“我们去河对岸吃桃吧！”猴哥哥说：“好啊！”
可是要想吃到又香又甜的大桃子就必须过河啊！猴弟弟挠了挠脑袋，可还是想不出办法来。猴哥哥眨了眨眼睛说：“我有个好办法。”“是什么办法呀？”猴弟弟问，“可以用妈妈洗衣服的大木盆当船来使用啊！”猴弟弟说：“哥哥你真聪明呀！”
猴哥哥就和猴弟弟一起回村子里搬来了妈妈的大木盆，小猴弟弟想：没有桨怎么划船呢？弟弟把这个想法告诉了哥哥，猴哥哥夸弟弟想得周到，猴弟弟就去找了一根竹竿，他俩把沉甸甸的木盆搬到了河边。
他们把大木盆放进了河里，然后小心翼翼地坐了进去，猴哥哥用竹竿当船桨，使劲地把大木盆划到了河对岸。他们迟到了又香又甜的桃子，心里美滋滋的。

对于自然语言处理的话，预处理其实就是有那么几个固定的步骤：

分词，英文的话全部转换为小写，去除标点符号，提取词干，出去不是英文的单词，出去特殊的符号，修正错别字。

1.分词 （Tokenization）

Token 是符号，包括了单词还有标点符号两种。 Tokenization 就是把一句话或者一段话分解成单个的单词和标点。比如 I like your cat. 这句话分词之后就变成了 ['I','like','your','cat','.'] 这样的一个五元组，注意最后的标点符号也是算的。

2.提取词干（stemming）

在英文中，常常可能会有一些英文单词的各种变化，比如第三人称的单数，时态等等的变化。比如 run 可以变成runnIng，ran,runs 等等，但是我们只要他们的基本态就是run. 这个就叫做提取词干。这么做的主要目的是用统一的特征形式，特征降维以减少计算量。抽取词的词干或词根形式不一定能够表达完整语义。

在NLTK中提供了三种最常用的词干提取器接口：Porter stemmer, Lancaster Stemmer 和 Snowball Stemmer。

各有优劣，看具体文本情况。对于分类、聚类这样对于特征词语的具体形态没有要求的情况下，进行词干抽取虽然抽取后的词干可能无实际意义但是却会大大减少计算时间，提高效率。

>>> from nltk.stem.porter import PorterStemmer  
>>> porter_stemmer = PorterStemmer()  

>>> from nltk.stem.lancaster import LancasterStemmer  
>>> lancaster_stemmer = LancasterStemmer()  

>>> from nltk.stem import SnowballStemmer  
>>> snowball_stemmer = SnowballStemmer(“english”)  


>>> porter_stemmer.stem(‘maximum’)  
u’maximum’  
>>> lancaster_stemmer.stem(‘maximum’)  
‘maxim’  
>>> snowball_stemmer.stem(‘maximum’)  
u’maximum’  

>>> porter_stemmer.stem(‘presumably’)  
u’presum’  
>>> snowball_stemmer.stem(‘presumably’)  
u’presum’  
>>> lancaster_stemmer.stem(‘presumably’)  
‘presum’  



3.词形还原（Lemmatization）

词形还原是把任何形式的词汇还原为一般形式，能表达完整的语义。相对而言，词干提取是简单的轻量级的词形归并方式，最后获得的结果为词干，但是可能没有实际的意义。词形还原处理相对来说比较复杂，获得结果为词的原形，能够承载一定的意义，与词干的提取相比，更具有研究和应用的价值。

比如说词干提取，假设这个词是provision得到的是provis这个没有什么实际的意义。

不过在nltk 中的Lemmatization 算法很鸡肋，基本可以理解为只有复述还原为单数的形式，一些其他的非常态的复数形式转换为单数的形式也是可以实现的。但是形容词变成名词可能会失效。

>>> from nltk.stem import WordNetLemmatizer  
>>> wordnet_lemmatizer = WordNetLemmatizer()  
>>> word = wordnet_lemmatizer.lemmatize('birds')  

bird

4.修正拼写错误

修改一些英文文本的拼写错误的话，可以用textblob 这个包

整体预处理代码：

import nltk 
from nltk.corpus import stopwords
from nltk.stem.porter import PorterStemmer
from nltk.stem import WordNetLemmatizer 


def Preprocessing(text):

    text = text.lower() # 将所有的单词转换成小写字母

    for c in string.punctuation:  # string.punctuation 所有的标点字符
        text = text.replace(c," ")  # 将标点符号转换成空格

    wordList = nltk.word_tokenize(text)  # 分词

    filtered = [w for w in wordList if w not in stopwords.words('english')] # 删除停用词

    # stem 
    ps = PorterStemmer()
    filtered = [ps.stem(w) for w in filtered]  # 提取词干
    wl = WordNetLemmatizer()   
    filtered = [wl.lemmatize(w) for w  in filtered]  # 词形还原

    return " ".join(filtered)




英文预处理整体流程代码：

#按空格进行分词，同时针对推文一些特性，去除@用户名，保留表情等一些特殊符号
tokenizer = TweetTokenizer()
for counter,rev in enumerate(reviews):
    # 去除HTML网页格式
    temp = BeautifulSoup(rev)
    text = temp.get_text()
    # 去除空格
    text = re.sub(' +',' ',text)
    test = re.sub(r'[()\[\]{}.,;:!?\<=>？@_^#$%"&*-],' ',text)
    # strip leading and trailing white space
    text = text.strip()
    # tokenize 
    tokens = tokenizer.tokenize(text)
    cleaned_reviews.append(tokens)
    if counter % round(len(reviews)/10) == 0:
        print(counter, '/', len(reviews), 'reviews cleaned')
# get list of tokens from all reviews
# 两个list变成一个list
all_tokens = [token for sublist in cleaned_reviews for token in sublist]
# 根据词频做index， 把单词转成index
counts = dict(Counter(all_tokens))
sorted_counts = sorted(counts.items(), key=operator.itemgetter(1), reverse=True)
# assign to each word an index based on its frequency in the corpus
# the most frequent word will get index equal to 1
word_to_index = dict([(tuple[0],idx+1) for idx, tuple in enumerate(sorted_counts)])
with open(path_to_IMDB + 'word_to_index_new.json', 'w') as my_file:
     json.dump(word_to_index, my_file, sort_keys=True, indent=4)

中文预处理代码：

#jieba分词和去停用词
#jieba 分词可以将我们的自定义词典导入，格式 “词” “词性” “词频”
jieba.load_userdict('data/userdict.txt')
#定义一个keyword类
class keyword(object):
    def Chinese_Stopwords(self):          #导入停用词库
        stopword=[]
        cfp=open('data/stopWord.txt','r+','utf-8')   #停用词的txt文件
        for line in cfp:
            for word in line.split():
                stopword.append(word)
        cfp.close()
        return stopword
def Word_cut_list(self,word_str):
        #利用正则表达式去掉一些一些标点符号之类的符号。
        word_str = re.sub(r'\s+', ' ', word_str)  # trans 多空格 to空格
        word_str = re.sub(r'\n+', ' ', word_str)  # trans 换行 to空格
        word_str = re.sub(r'\t+', ' ', word_str)  # trans Tab to空格
        word_str = re.sub("[\s+\.\!\/_,$%^*(+\"\']+|[+——；！，”。《》，。：“？、~@#￥%……&*（）1234567①②③④)]+".decode("utf8"), "".decode("utf8"), word_str)
        wordlist = list(jieba.cut(word_str))#jieba分词
        wordlist_N = []
        chinese_stopwords=self.Chinese_Stopwords()
        for word in wordlist:
            if word not in chinese_stopwords:#词语的清洗：去停用词
                if word != '\r\n'  and word!=' ' and word != '\u3000'.decode('unicode_escape') \
                        and word!='\xa0'.decode('unicode_escape'):#词语的清洗：去全角空格
                    wordlist_N.append(word)
        return wordlist_N


#名词提取
def Word_pseg(self,word_str):  # 名词提取函数
        words = pseg.cut(word_str)
        word_list = []
        for wds in words:
            # 筛选自定义词典中的词，和各类名词，自定义词库的词在没设置词性的情况下默认为x词性，即词的flag词性为x
            if wds.flag == 'x' and wds.word != ' ' and wds.word != 'ns' \
                    or re.match(r'^n', wds.flag) != None \
                            and re.match(r'^nr', wds.flag) == None:
                word_list.append(wds.word)
        return word_list


import tensorflow.contrib.keras as kr
 
def read_file(filename):
    """读取文件数据"""
    contents, labels = [], []
    with open_file(filename) as f:
        for line in f:
            try:
                label, content = line.strip().split('\t')
                if content:
                    contents.append(list(content))#通过list把一句话分成一个个字
                    labels.append(native_content(label))
            except:
                pass
    return contents, labels
 
 
def build_vocab(train_dir, vocab_dir, vocab_size=5000):
    """根据训练集构建词汇表，存储"""
    data_train, _ = read_file(train_dir)
    all_data = []
    for content in data_train:
        all_data.extend(content)
 
    counter = Counter(all_data)
    count_pairs = counter.most_common(vocab_size - 1) #输出几个出现次数最多的元素
    words, _ = list(zip(*count_pairs)) #通过zip只取出其中的单词
    # 添加一个 <PAD> 来将所有文本pad为同一长度
    words = ['<PAD>'] + list(words)
    open_file(vocab_dir, mode='w').write('\n'.join(words) + '\n')
 
def read_vocab(vocab_dir):
    """读取词汇表"""
    # words = open_file(vocab_dir).read().strip().split('\n')
    with open_file(vocab_dir) as fp:
        # 如果是py2 则每个值都转化为unicode
        words = [native_content(_.strip()) for _ in fp.readlines()]
    word_to_id = dict(zip(words, range(len(words))))
    return words, word_to_id
 
def process_file(filename, word_to_id, cat_to_id, max_length=600):
    """将文件转换为id表示"""
    contents, labels = read_file(filename)
    data_id, label_id = [], []
    for i in range(len(contents)):
        data_id.append([word_to_id[x] for x in contents[i] if x in word_to_id])
        label_id.append(cat_to_id[labels[i]])
    # 使用keras提供的pad_sequences来将文本pad为固定长度
    x_pad = kr.preprocessing.sequence.pad_sequences(data_id, max_length)
    y_pad = kr.utils.to_categorical(label_id, num_classes=len(cat_to_id))  # 将标签转换为one-hot表示
    return x_pad, y_pad

#建立词表
text = open(path,encoding='utf-8').read().lower()
chars = set(text)
print ('total chars:', len(chars))
char_indices = dict((c, i) for i, c in enumerate(chars))
indices_char = dict((i, c) for i, c in enumerate(chars))
#kreas下运行LSTM的Input生成，在建立词表的基础上，数据向量化
print('Vectorization...')
X = np.zeros((len(sentences), maxlen, len(chars)), dtype=np.bool)
print(X)
y = np.zeros((len(sentences), len(chars)), dtype=np.bool)
for i, sentence in enumerate(sentences):
    for t, char in enumerate(sentence):
        X[i, t, char_indices[char]] = 1
    y[i, char_indices[next_chars[i]]] = 1


# 过滤词长，过滤停用词，只保留中文
def is_fine_word(word, min_length=2):
    rule = re.compile(r"^[\u4e00-\u9fa5]+$")
    if len(word) >= min_length and word not in STOP_WORDS and re.search(rule, word):
        return True
    else:
        return False

#逐字切分的处理方式，同时去掉一些常见的虚词，如“之”、“乎”、“者”、“也”。
def singCut(text):
     tex = [i.strip('\n').strip('\r').strip('。').strip('，|）|：|{|}|“|” |（|\n') for i in text]
     return list(filter(None, tex)) #去掉空字符
text = '云横秦岭家何在，雪拥蓝关马不前'
 
#虚词通用词库
stopwords = '而|何|乎|乃|且|其|若|所|为'
#去掉标点
poem = [[i.strip(') |: |?|{|}| “|” （| \n\n\r|。') for i in tex if i not in stopwords]for tex in text]
poem = list(filter(None, poem ))

预处理（去特殊符号、去停用词、分词），把词转成index（word to index）, 把原文都变成数值，去掉topN词频的以及小于topM词频的，对每篇进行 truncation and padding，word2vec训练 得到 w2v_model[word] 的embedding，加入CNN作为初始值（kreas里面训练需要把每个词转成embedding这种）

训练CNN模型

https://github.com/Tixierae/deep_learning_NLP

构建词汇表

categories转成id, 读取词汇表，构建word_to_id字典（字符级别）

读入训练数据，预处理，将文本pad到固定长度

批次训练CNN（tensorflow内部会自动初始化embedding）

预测

 https://github.com/gaussic/text-classification-cnn-rnn

 

 

 

 

 

 

 

随深度学习技术的发展，使用循环神经网络（Recurrent Neural Network，RNN）建立的各种序列模型，使语音识别、机器翻译及自然语言理解等应用成为可能。



表示与类型

自然语言、音频等数据都是前后相互关联的数据，比如理解一句话要通过一整句而不是其中的几个词，分析一段音频要通过连续的片段而不是其中的几帧。前面所学的DNN以及CNN处理的都是前后毫无关联的一个个单独数据，对于这些序列数据则需要采用RNN进行处理。



用循环神经网络处理时间序列时，首先要对时间序列进行标记化。对一个序列数据$x$，用符号$x^{\langle t\rangle}$来表示这个序列数据中的第$t$个元素。这个元素的类型因数据类型而异，对一段音频，它可能其中的几帧，对一句话，它可能是一个或几个单词，如下图所示。



第$i$个序列数据的第$t$个元素用符号$x^{(i)\langle t\rangle}$表示，其标签用符号$y^{(i)\langle t\rangle}$表示。

序列中的每个元素有相应的标签，一般需要先建立一个包含序列中所有类型的元素的字典（Dictionary）。例如对上图中的句子，建立一个含有10000个单词的列向量词典，单词顺序以A~Z排列，然后根据单词在列向量中的位置，用one-hot向量来表示该单词的标签，部分表示如下图：



标记化完成后，将训练数据输入网络中。一种循环神经网络的结构如下图： 



左边的网络可简单表示为右图的结构，其中元素$x^{\langle t\rangle}$输入对应时间步（TIme Step）的隐藏层的同时，该隐藏层也会接收上一时间步的隐藏层激活$a^{\langle t-1\rangle}$，其中$a^{\langle 0\rangle}$一般直接初始化为零向量。一个时间步输出一个对应的预测结果${\hat y}^{\langle t\rangle}$，输入、激活、输出有对应的参数$W_{ax}$、$W_{aa}$、$W_{y}$。

以上结构的前向传播过程，有：
 $$a^{\langle 0\rangle} = \vec 0$$   $$a^{\langle t\rangle} = g_1(W_{aa} a^{\langle t-1\rangle} + W_{ax} x^{\langle t\rangle} + b_a)$$   $${\hat y}^{\langle t\rangle} = g_2(W_{y} a^{\langle t\rangle} + b_y)$$ 


其中$b_a$、$b_y$是两个偏差参数，激活函数$g_1$通常选择tanh，有时也用ReLU，$g_2$的选择取决于需要的输出类型，可选sigmoid或Softmax。

具体计算中以上的式子还可以进一步简化，以方便运算。将$W_{ax}$和$W_{aa}$堆叠成一个矩阵$W_a$，$a^{\langle t-1\rangle}$和$x^{\langle t\rangle}$也堆叠成一个矩阵，有：
 $$W_a = [W_{ax}, W_{aa}]$$   $$a^{\langle t\rangle} = g_1(W_{a}[a^{\langle t-1\rangle},x^{\langle t\rangle}] + b_a)$$ 


反向传播的过程类似于深度神经网络，如下图所示： 



这种结构的一个缺陷是，某一时刻的预测结果仅使用了该时刻之前输入的序列信息。根据所需的输入及输出数量，循环神经网络可分为“一对一”、“多对一”、“多对多”等结构：



这些网络结构可在不同的领域中得到应用。

RNN应用：语言模型

语言模型（Language Model）是根据语言客观事实而进行的语言抽象数学建模。例如对一个语音识别系统，输入的一段语音可能表示下面两句话： 



其中的“pair”和“pear”读音相近，但是在日常表达及语法上显然这段语音是第二句的可能性要大，要使这个语音识别系统能够准确判断出第二句话为正确结果，就需要语言模型的支持。这个语言模型能够分别计算出语音表示以上两句话的概率，以此为依据做出判断。

建立语言模型所采用的训练集是一个大型的语料库（Corpus）。建立过程中，如之前所述，需要先建立一个字典，之后将语料库中每个词表示为对应的one-hot向量。此外需要额外定义一个标记EOS（End Of Sentence）表示一个句子的结尾，也可以将其中的标点符号加入字典后也用one=hot向量表示。对于语料库中部分（英语）人名、地名等特殊的不包含在字典中的词汇，可在词典中加入再用一个UNK（Unique Token）标记来表示。

将标志化后的训练集输入网络中的训练过程，如下例所示：



第一个时间步中输入的$a^{\langle 0\rangle}$和$x^{\langle 1\rangle}$都是零向量，${\hat y}^{\langle 1\rangle}$是通过softmax预测出的字典中每一个词作为第一个词出现的概率；第二个时间步中输入的$x^{\langle 2\rangle}$是下面的训练数据中第一个单词“cats”的标签$y^{\langle 1\rangle}$和上一层的激活$a^{\langle 1\rangle}$,输出的$y^{\langle 2\rangle}$表示的是单词“cats”后面出现字典中的其他词，特别是“average”的条件概率。后面的时间步与第二步类似，到最后就可以得到整个句子出现的概率。

这样，损失函数将表示为：
 $$\mathcal{L}({\hat y}^{\langle t\rangle},y^{\langle t\rangle})=-\sum_t y^{\langle t\rangle}_i log\ {\hat y}^{\langle t\rangle}$$ 


成本函数表示为：
 $$\mathcal{J} = \sum_t \mathcal{L}^{\langle t\rangle}({\hat y}^{\langle t\rangle},y^{\langle t\rangle})$$ 


训练好一个这个语言模型后，可通过采样（Sample）新的序列，来了解这个模型中都学习到了一些什么。从模型中采样出新序列的过程如下： 



第一个时间步中输入的$a^{\langle 0\rangle}$和$x^{\langle 1\rangle}$还是零向量，依据softmax预测出的字典中每一个词作为第一个词出现的概率，选取一个词${\hat y}^{\langle 1\rangle}$作为第二个时间步的输入。后面与此类似，模型将自动生成一些句子，从这些句子中可发现模型通过语料库学习到的知识。

以上是基于词汇构建的语言模型，也就是所用的字典中包含的是一个个单词。实际应用中，还可以构建基于字符的语言模型，不过这种方法的结果中将得到过多过长的序列，计算成本也较大，在当今的NLP领域也用得较少。

GRU与LSTM

如下图中的句子时，后面的动词用“was”还是“were”取决于前面的名词“cat”是单数还是复数。 

 

一般的循环神经网络不擅于捕捉这种序列中存在的长期依赖关系，其中的原因是，一般的循环神经网络也会出现类似于深度神经网络中的梯度消失问题，而使后面输入的序列难以受到早先输入序列的影响。梯度爆炸的问题也会出现，不过可以采用梯度修剪（Gradient Clipping）应对，相比之下梯度消失问题更难以解决。



GRU

GRU（Gated Recurrent Units, 门控循环单元）网络改进了循环神经网络的隐藏层，从而使梯度消失的问题得到改善。GRU的结构如下图： 



其中的$c$代表记忆细胞（Memory Cell），用它来“记住”类似前面例子中“cat”的单复数形式，且这里的记忆细胞$c^{\langle t\rangle}$直接等于输出的激活$a^{\langle t\rangle}$；$\tilde{c}$代表下一个$c$的候选值；$\Gamma_u$代表更新门（Update Gate），用它来控制记忆细胞的更新与否。上述结构的具体表达式有：
 $$\tilde{c}^{\langle t \rangle} = \tanh(W_c[c^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b\_c)$$   $$\Gamma_u = \sigma(W_u[c^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b\_u)$$   $$c^{\langle t \rangle} = \Gamma_u \times \tilde{c}^{\langle t \rangle} + (1 - \Gamma_u) \times c^{\langle t-1 \rangle}$$   $$a^{\langle t\rangle} = c^{\langle t\rangle}$$  

$\tilde{c}$的计算中以tanh作为激活函数，使用simgoid作为激活函数得到的$\Gamma_u$值将在0到1的范围内。当$\Gamma_u=1$时，输出的$c$值被更新为$\tilde{c}$，否者保持为输入的$c$值。


上面所述的是简化后的GRU，完整的GRU结构如下： 

 

其中相关门（Relevance Gate）$\Gamma_r$表示上一个$c$值与下一个$c$的候选值的相关性。与简化的GRU相比，表达式发生如下变化：
 $$\Gamma_r = \sigma(W_r[c^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_r)$$   $$\tilde{c}^{\langle t \rangle} = \tanh(W_c[\Gamma_r \times c^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_c)$$  

GRU其实只是一种LSTM的流行变体，其相关概念来自于2014年Cho等人发表的论文[On the properties of neural machine translation: Encoder-decoder approaches]以及Chung等人的[Empirical Evaluation of Gated Recurrent Neural Networks on Sequence Modeling]。


LSTM

1997年Hochreiter和Schmidhuber共同在论文[Long short-term memory ]中提出的LSTM（Long Short Term Memory，长短期记忆）网络比GRU更加通用及强大，其结构如下： 



相比之前的简化版GRU，LSTM中多了遗忘门（Forget Gate）$\Gamma_f$和输出门（Output Gate）$\Gamma_o$，具体表达式如下：
 $$\tilde{c}^{\langle t \rangle} = \tanh(W_c[a^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_c)$$   $$\Gamma_u = \sigma(W_u[a^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_u)$$   $$\Gamma_f = \sigma(W_f[a^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_f)$$   $$\Gamma_o=  \sigma(W_o[a^{\langle t-1 \rangle}, x^{\langle t \rangle}] + b_o)$$   $$c^{\langle t \rangle} = \Gamma_f^{\langle t \rangle} \times c^{\langle t-1 \rangle} + \Gamma_u^{\langle t \rangle} \times \tilde{c}^{\langle t \rangle}$$   $$a^{\langle t \rangle} = \Gamma_o^{\langle t \rangle}\times \tanh(c^{\langle t \rangle})$$ 


更为常用的LSTM版本中，几个门值的计算不只取决于输入$x$和$a$值，有时也可以偷窥上一个细胞输入的$c$值，这叫窥视孔连接（Peephole Connection)。

多个LSTM单元连接在一起，形成一个LSTM网络： 



BRNN与DRNN

前面介绍的循环神经网络在结构上都是单向的，也提到过它们具有某一时刻的预测结果仅使用了该时刻之前输入的序列信息的缺陷，而双向循环神经网络（Bidirectional RNN）弥补了这一缺陷。BRNN的结构图如下所示： 



此外，循环神经网络的每个时间步上也可以包含多个隐藏层，形成深度循环神经网络（Deep RNN)，如下图： 





参考资料


吴恩达-序列模型-网易云课堂
Andrew Ng-Sequence Model-Coursera
deeplearning.ai
零基础入门深度学习-循环神经网络
课程代码与资料-GitHub


注：本文涉及的图片及资料均整理翻译自Andrew Ng的Deep Learning系列课程，版权归其所有。翻译整理水平有限，如有不妥的地方欢迎指出。



更新历史： 

* 2018.02.27 完成初稿 

原文链接