自然语言处理入门学习笔记2：深度学习与NLP

深度学习与nlp

三种算法
文本分类：
Test->Lable
行业baseline：
用bow表示句子然后用lr或svm做回归，用你的模型对比
库：
深度学习keras
自然语言处理gensim

自编码器

主要作用是降维，压缩，降噪
在这里插入图片描述

已经学过了好像
玻尔兹曼机呗
1.聚类？
2.降维
历史进程
数据降噪，数据降维

会陷入局部最优解

在这里插入图片描述

卧槽keras真是神器，这样一个模型就构建好了

CNN卷积矩阵

卷积+Text
大部分用作分类
在这里插入图片描述
已经学过了，没啥好记的
不同的卷积核能提取出不同的特征，卷积核都是机器自己学出来的

左边进行了模糊，右边提取边缘特征
卷积池化（降低计算量）
迁移到自然语言处理

2维

在这里插入图片描述

1维

在这里插入图片描述
filter 是1维的卷积核？？？

边界处理：
1 边缘结束 2 原图外围添加0
步长
训练步骤

在这里插入图片描述

RNN & LSTM

带记忆
大部分用作文本生成
普通神经网络
在这里插入图片描述
rnn的目的是让语言的顺序关系得到考虑
rnn

记录下来
此刻的s=此刻的输入+上一个记忆的s

感觉有点类似像马尔科夫链
然而如果rnn的长度不能够记忆几天前的s的话还是没有用

lstm
把记忆长效的保存下来
LSTM和RNN的区别：
LSTM比RNN多了很多控制的门，通过这些门它能够学到哪些记忆需要被保留，哪些要遗忘；所以它能够一定程度防止梯度消失，记住比较长的之前的内容。
LSTM相对于RNN的优点：
普通RNN因为梯度消失的关系记不住很远的内容。
在这里插入图片描述
忘记门

记忆门

更新门

输出门

用RNN做文本生成

这边是提供的一个例子，用python写的，是以char级别生成文本的代码

import numpy
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import Dropout
from keras.layers import LSTM
from keras.callbacks import ModelCheckpoint
from keras.utils import np_utils

## 读取数据
raw_text = open('./input/Winston_Churchil.txt').read()
# .read() 读入整个文件为一个字符串
raw_text = raw_text.lower() # 小写
print(raw_text[:100]) #打印前100个字符
chars = sorted(list(set(raw_text))) 
# 这里去重不是单词去重，是字母去重，去重后只有英文字母和标点符号等字符
print(len(raw_text))
print(len(chars))
char_to_int = dict((c, i) for i, c in enumerate(chars)) 
# 去重后的字符排序好后，xi
int_to_char = dict((i, c) for i, c in enumerate(chars))
print(char_to_int)

## 构造训练集
seq_length = 100 
# 输入的字符的长度，一个字符对应一个神经元，总共100个神经元
# 输入是100个字符，输出是预测的一个字符

x = []
y = []
for i in range(0, len(raw_text) - seq_length): # 每次循环都滑动一个字符距离
    given = raw_text[i:i + seq_length] # 从零先取前100个字符作为输入
    predict = raw_text[i + seq_length] # y是后一个字符
    x.append([char_to_int[char] for char in given]) # 把字符转化为向量
    y.append(char_to_int[predict]) # # 把字符转化为向量
n_patterns = len(x) # 样本数量
n_vocab = len(chars) # 
# 把x变成LSTM需要的样子
x = numpy.reshape(x, (n_patterns, seq_length, 1))
# n_patterns 样本的数量
# seq_length 每个样本每次训练100个字符
# 1 代表我们的一个字符的维度是1维，这里1维是特殊情况，如果我们的输入不是一个字符，
#是一个单词的话，单词是可以embedding成100维向量，那这里就是100.
x = x / float(n_vocab) # 简单normal到0-1之间，归一化，防止梯度爆炸
y = np_utils.to_categorical(y) 
# y值总共取值61种，直接做个onehot编码
# 对类别进行onehot编码一个很重要的原因在于计算loss时的问题。loss一般用距离来表示，
# 如果用1~5来表示，那么1和2的距离是1，而1和5的距离是4，但是按道理1和2、1和5的距离应该一样。
# 如果用one hot编码表示，那么1和2的距离跟1和5的距离时一样的。
print(x[10][:10]) # 第10个样本的前10个字符向量
print(y[10])
print(y.shape) # 

##构建和训练模型
model = Sequential()
# Sequential()：序贯模型是多个网络层的线性堆叠，可以通过.add()一个一个添加层
model.add(LSTM(256, input_shape=(x.shape[1], x.shape[2])))
# 256是LSTM的隐藏层的维度。
# input_shape，不需要考虑样本数量，对模型本身结构没有意义
model.add(Dropout(0.2)) # 去掉20%的神经元
model.add(Dense(y.shape[1], activation='softmax')) 
# y.shape[1] = 60，'softmax'转化为概率，概率和为1
model.compile(loss='categorical_crossentropy', optimizer='adam')
# 多分类交叉熵损失，adam优化器
model.fit(x, y, nb_epoch=1, batch_size=1024)
# 这里本地跑的太慢了，nb_epoch设置为1了

##预测模型
def predict_next(input_array):
    x = numpy.reshape(input_array, (1, seq_length, 1))
    # 同上，只有一个样本，reshape成lstm需要的维度。
    x = x / float(n_vocab) # 归一化
    y = model.predict(x) # y是60维的向量
    return y

def string_to_index(raw_input):
    res = [] 
    for c in raw_input[(len(raw_input)-seq_length):]:
# 这步一个问题是len(raw_input)一定要大于seq_length：100,不然会报错
        res.append(char_to_int[c]) # 得到输入句子中后100个字符的向量表示
    return res

def y_to_char(y): 
    largest_index = y.argmax() # 取出概率最大的值对应的索引
    c = int_to_char[largest_index] # 根据索引得到对应的字符
    return c

def generate_article(init, rounds=200): 
    # rounds=200 代表预测生成200个新的字符
    # init是输入的字符串
    in_string = init.lower() # 跟上面一样的预处理步骤
    for i in range(rounds): # 每次模型预测一个字符
        n = y_to_char(predict_next(string_to_index(in_string)))
        # n是预测的新的字符
        in_string += n # 把新的字符拼接，重新作为新的输入
    return in_string

init = 'His object in coming to New York was to engage officers for that service. He came at an opportune moment'
article = generate_article(init)
print(article)

结尾

深度学习之前已经学过了，算是复习一下吧，所以note不多，基本上都是一些图片，就是没什么好记的
然后就是keras真是个好东西，赶紧装上，ok，这章结束