DL学习笔记——NLP

0.python基础

https://www.codecademy.com/catalog

1.github

下载

2.AI

https://www.codecademy.com/catalog/subject/artificial-intelligence
————————————————

11.1 自然语言处理

一般来说，NLP任务希望能够做到以下三件事之一：

标记文本区域：例如，词性标注、情感分类或命名实体识别

链接两个以上的文本区域：例如共指，指的是识别表示同一个实体的名词短语或代词，并将其进行归类。

试着填补基于上下文的信息空缺：例如，用完形填空的方式补齐单词缺失的部分。

11.2 监督NLP学习

输入句子，输出结果

难点一：输入数据不仅从数字变成了文本，而且还是可变长度的文本。

难点二:  输入数据与输出有什么关系？具有相关性的关系是什么？

词袋模型：给定电影评论中的词汇，预测其情绪

创建一个矩阵，其中每一行（向量）对应于每个电影评论，每一列表示评论中是否包含词汇表中的特定单词。这种存储形式称为one-hot编码。

下载数据集

# Download reviews.txt and labels.txt from here: https://github.com/udacity/deep-learning/tree/master/sentiment-network

def pretty_print_review_and_label(i):
   print(labels[i] + "\t:\t" + reviews[i][:80] + "...")

g = open('reviews.txt','r') # What we know!
reviews = list(map(lambda x:x[:-1],g.readlines()))
g.close()

g = open('labels.txt','r') # What we WANT to know!
labels = list(map(lambda x:x[:-1].upper(),g.readlines()))
g.close()

Capturing Word Correlation in Input Data

import numpy as np

onehots = {}
onehots['cat'] = np.array([1,0,0,0])
onehots['the'] = np.array([0,1,0,0])
onehots['dog'] = np.array([0,0,1,0])
onehots['sat'] = np.array([0,0,0,1])

sentence = ['the','cat','sat']
x = onehots[sentence[0]] + \
    onehots[sentence[1]] + \
    onehots[sentence[2]]

print("Sent Encoding:" + str(x))

11.3 对影评进行预测

 基于编码策略和已掌握的神经网络，可以预测电影评论的情绪色彩。

预处理：

import sys

f = open('reviews.txt')
raw_reviews = f.readlines()
f.close()

f = open('labels.txt')
raw_labels = f.readlines()
f.close()

tokens = list(map(lambda x:set(x.split(" ")),raw_reviews))

vocab = set()
for sent in tokens:
    for word in sent:
        if(len(word)>0):
            vocab.add(word)
vocab = list(vocab)

word2index = {}
for i,word in enumerate(vocab):
    word2index[word]=i

input_dataset = list()
for sent in tokens:
    sent_indices = list()
    for word in sent:
        try:
            sent_indices.append(word2index[word])
        except:
            ""
    input_dataset.append(list(set(sent_indices)))

target_dataset = list()
for label in raw_labels:
    if label == 'positive\n':
        target_dataset.append(1)
    else:
        target_dataset.append(0)

权重的相似度表示单词的相似度。

用欧式距离来可视化权重的相似度。

from collections import Counter
import math 

def similar(target='beautiful'):
    target_index = word2index[target]
    scores = Counter()
    for word,index in word2index.items():
        raw_difference = weights_0_1[index] - (weights_0_1[target_index])
        squared_difference = raw_difference * raw_difference
        scores[word] = -math.sqrt(sum(squared_difference))

    return scores.most_common(10)

神经元在网络中的含义来自于预测目标的标签。神经网络对除了手头的任务之外的所有信息一无所知。

我们要找到一项能够让神经网络学到更有价值的权重的任务。

11.4 完形填空

通过更丰富的信号来学习单词更丰富的含义。

任务设置：我们将不再尝试为一整条电影评论预测出一个标签，而是将文本划分成5个单词一组的短语，删除一个单词（一个重点词汇），尝试训练一个网络，利用去掉单词剩余部分来预测去掉的那个词汇。此外，使用一项名为负抽样的技巧来让网络训练的更快一些。

负抽样：在每次正向传播中，随机忽略其中大多数标签（假设它们不存在）

import sys,random,math
from collections import Counter
import numpy as np

np.random.seed(1)
random.seed(1)
f = open('reviews.txt')
raw_reviews = f.readlines()
f.close()

tokens = list(map(lambda x:(x.split(" ")),raw_reviews))
wordcnt = Counter()
for sent in tokens:
    for word in sent:
        wordcnt[word] -= 1
vocab = list(set(map(lambda x:x[0],wordcnt.most_common())))

word2index = {}
for i,word in enumerate(vocab):
    word2index[word]=i

concatenated = list()
input_dataset = list()
for sent in tokens:
    sent_indices = list()
    for word in sent:
        try:
            sent_indices.append(word2index[word])
            concatenated.append(word2index[word])
        except:
            ""
    input_dataset.append(sent_indices)
concatenated = np.array(concatenated)
random.shuffle(input_dataset)

alpha, iterations = (0.05, 2)
hidden_size,window,negative = (50,2,5)

weights_0_1 = (np.random.rand(len(vocab),hidden_size) - 0.5) * 0.2
weights_1_2 = np.random.rand(len(vocab),hidden_size)*0

layer_2_target = np.zeros(negative+1)
layer_2_target[0] = 1

def similar(target='beautiful'):
  target_index = word2index[target]

  scores = Counter()
  for word,index in word2index.items():
    raw_difference = weights_0_1[index] - (weights_0_1[target_index])
    squared_difference = raw_difference * raw_difference
    scores[word] = -math.sqrt(sum(squared_difference))
  return scores.most_common(10)

def sigmoid(x):
    return 1/(1 + np.exp(-x))

for rev_i,review in enumerate(input_dataset * iterations):
  for target_i in range(len(review)):
        
    # since it's really expensive to predict every vocabulary
    # we're only going to predict a random subset
    target_samples = [review[target_i]]+list(concatenated\
    [(np.random.rand(negative)*len(concatenated)).astype('int').tolist()]) #每次只预测一个随机子集，因为对每个词汇都进行预测的代价过于高昂。

    left_context = review[max(0,target_i-window):target_i]
    right_context = review[target_i+1:min(len(review),target_i+window)]

    layer_1 = np.mean(weights_0_1[left_context+right_context],axis=0)
    layer_2 = sigmoid(layer_1.dot(weights_1_2[target_samples].T))
    layer_2_delta = layer_2 - layer_2_target
    layer_1_delta = layer_2_delta.dot(weights_1_2[target_samples])

    weights_0_1[left_context+right_context] -= layer_1_delta * alpha
    weights_1_2[target_samples] -= np.outer(layer_2_delta,layer_1)*alpha

  if(rev_i % 250 == 0):
    sys.stdout.write('\rProgress:'+str(rev_i/float(len(input_dataset)
        *iterations)) + "   " + str(similar('terrible')))
  sys.stdout.write('\rProgress:'+str(rev_i/float(len(input_dataset)
        *iterations)))
print(similar('terrible'))

11.5 损失函数的意义

即使神经网络基于相同的统计信息进行训练，你也可以根据对输入和预测目标的选择，对神经网络所学习的内容进行定位。这个过程是“智能定位”。

控制输入和预测目标的值并不是进行“智能定位”的唯一方法。你还可以通过调整网络测量误差的方式、网络层的参数数量和类型，以及应用的正则化类型来改变网络的学习过程。在深度学习中，所有这些技术都属于构建所谓损失函数的范畴。

神经网络并不能真正从数据中学习，它们只是使损失函数最小化。

损失函数的选择决定了神经网络学到的知识。

不同种类的网络架构、算子设计、正则化技巧、数据集合非线性数据，这些都是我们可以用来构造损失函数的“一揽子”方法。

例如，如果网络过拟合、可以通过选择更简单的非线性关系、更少的网络层参数、更浅的网络架构、更大的数据集或者更激进的正则化技术，来增强损失函数。

如果测试结果出了问题，不妨去损失函数中找寻改进的方法。

11.6 单词类比（完形填空）

如果将词向量看成一个二维向量，可能有助于我们理解单词类比是如何逐步发挥作用的。