独家 | 菜鸟必备的循环神经网络指南(附链接)
作者:Victor Zhou
翻译:王雨桐
校对:吴金迪
本文将介绍最基础的循环神经网络(Vanilla RNNs)的概况,工作原理,以及如何在Python中实现。
https://victorzhou.com/blog/intro-to-neural-networks/
红色为输入,绿色为RNN本身,蓝色为输出。来源:Andrej Karpathy
机器翻译(例如Google翻译)使用“多对多”RNN。原始文本序列被送入RNN,随后RNN将翻译的文本作为输出。
情感分析(例如,这是一个积极的还是负面的评论?)通常是使用“多对一”RNN。将要分析的文本送入RNN,然后RNN产生单个输出分类(例如,这是一个积极的评论)。
基于之前的隐藏状态和下一个输入,我们可以得到下一个隐藏状态。
通过计算, 我们可以得到下一个输出 。
多对多 RNN
https://github.com/vzhou842/rnn-from-scratch/blob/master/data.py
Text
|
Positive?
|
i am good
|
✓
|
i am bad
|
❌
|
this is very good
|
✓
|
this is not bad
|
✓
|
i am bad not good
|
❌
|
i am not at all happy
|
❌
|
this was good earlier
|
✓
|
i am not at all bad or sad right now
|
✓
|
多对一 RNN
data.py
train_data = {
'good': True,
'bad': False,
# ... more data
}
test_data = {
'this is happy': True,
'i am good': True,
# ... more data
}
True=积极,False=消极
main.py
from data import train_data, test_data
# Create the vocabulary.
vocab = list(set([w for text in train_data.keys() for w in text.split(' ')]))
vocab_size = len(vocab)
print('%d unique words found' % vocab_size) # 18 unique words found
main.py
# Assign indices to each word.
word_to_idx = { w: i for i, w in enumerate(vocab) }
idx_to_word = { i: w for i, w in enumerate(vocab) }
print(word_to_idx['good']) # 16 (this may change)
print(idx_to_word[0]) # sad (this may change)
main.py
import numpy as np
def createInputs(text):
'''
Returns an array of one-hot vectors representing the words
in the input text string.
- text is a string
- Each one-hot vector has shape (vocab_size, 1)
'''
inputs = []
for w in text.split(' '):
v = np.zeros((vocab_size, 1))
v[word_to_idx[w]] = 1
inputs.append(v)
return inputs
rnn.py
import numpy as np
from numpy.random import randn
class RNN:
# A Vanilla Recurrent Neural Network.
def __init__(self, input_size, output_size, hidden_size=64):
# Weights
self.Whh = randn(hidden_size, hidden_size) / 1000
self.Wxh = randn(hidden_size, input_size) / 1000
self.Why = randn(output_size, hidden_size) / 1000
# Biases
self.bh = np.zeros((hidden_size, 1))
self.by = np.zeros((output_size, 1))
rnn.py
class RNN:
# ...
def forward(self, inputs):
'''
Perform a forward pass of the RNN using the given inputs.
Returns the final output and hidden state.
- inputs is an array of one hot vectors with shape (input_size, 1).
'''
h = np.zeros((self.Whh.shape[0], 1))
# Perform each step of the RNN
for i, x in enumerate(inputs):
h = np.tanh(self.Wxh @ x + self.Whh @ h + self.bh)
# Compute the output
y = self.Why @ h + self.by
return y, h
main.py
# ...
def softmax(xs):
# Applies the Softmax Function to the input array.
return np.exp(xs) / sum(np.exp(xs))
# Initialize our RNN!
rnn = RNN(vocab_size, 2)
inputs = createInputs('i am very good')
out, h = rnn.forward(inputs)
probs = softmax(out)
print(probs) # [[0.50000095], [0.49999905]]
附链接:
https://victorzhou.com/blog/softmax/
https://github.com/vzhou842/rnn-from-scratch
rnn.py
main.py
# Loop over each training example
for x, y in train_data.items():
inputs = createInputs(x)
target = int(y)
# Forward
out, _ = rnn.forward(inputs)
probs = softmax(out)
# Build dL/dy
d_L_d_y = probs d_L_d_y[target] -= 1
# Backward
rnn.backprop(d_L_d_y)
rnn.py
class RNN:
# ...
def backprop(self, d_y, learn_rate=2e-2):
'''
Perform a backward pass of the RNN.
- d_y (dL/dy) has shape (output_size, 1).
- learn_rate is a float.
'''
n = len(self.last_inputs)
# Calculate dL/dWhy and dL/dby.
d_Why = d_y @ self.last_hs[n].T
d_by = d_y
rnn.py
class RNN:
# …
def backprop(self, d_y, learn_rate=2e-2):
‘’’
Perform a backward pass of the RNN.
- d_y (dL/dy) has shape (output_size, 1).
- learn_rate is a float.
‘’’
n = len(self.last_inputs)
# Calculate dL/dWhy and dL/dby.
D_Why = d_y @ self.last_hs[n].T
d_by = d_y
# Initialize dL/dWhh, dL/dWxh, and dL/dbh to zero.
D_Whh = np.zeros(self.Whh.shape)
d_Wxh = np.zeros(self.Wxh.shape)
d_bh = np.zeros(self.bh.shape)
# Calculate dL/dh for the last h.
d_h = self.Why.T @ d_y
# Backpropagate through time.
For t in reversed(range(n)):
# An intermediate value: dL/dh * (1 – h^2)
temp = ((1 – self.last_hs[t + 1] ** 2) * d_h)
# dL/db = dL/dh * (1 – h^2)
d_bh += temp
# dL/dWhh = dL/dh * (1 – h^2) * h_{t-1}
d_Whh += temp @ self.last_hs[t].T
# dL/dWxh = dL/dh * (1 – h^2) * x
d_Wxh += temp @ self.last_inputs[t].T
# Next dL/dh = dL/dh * (1 – h^2) * Whh
d_h = self.Whh @ temp
# Clip to prevent exploding gradients.
For d in [d_Wxh, d_Whh, d_Why, d_bh, d_by]:
np.clip(d, -1, 1, out=d)
# Update weights and biases using gradient descent.
Self.Whh -= learn_rate * d_Whh
self.Wxh -= learn_rate * d_Wxh
self.Why -= learn_rate * d_Why
self.bh -= learn_rate * d_bh
self.by -= learn_rate * d_by
main.py
import random
def processData(data, backprop=True):
'''
Returns the RNN's loss and accuracy for the given data.
- data is a dictionary mapping text to True or False.
- backprop determines if the backward phase should be run.
'''
items = list(data.items())
random.shuffle(items)
loss = 0
num_correct = 0
for x, y in items:
inputs = createInputs(x)
target = int(y)
# Forward
out, _ = rnn.forward(inputs)
probs = softmax(out)
# Calculate loss / accuracy
loss -= np.log(probs[target])
num_correct += int(np.argmax(probs) == target)
if backprop:
# Build dL/dy
d_L_d_y = probs
d_L_d_y[target] -= 1
# Backward
rnn.backprop(d_L_d_y)
return loss / len(data), num_correct / len(data)
main.py
# Training loop
for epoch in range(1000):
train_loss, train_acc = processData(train_data)
if epoch % 100 == 99:
print('--- Epoch %d' % (epoch + 1))
print('Train:\tLoss %.3f | Accuracy: %.3f' % (train_loss, train_acc))
test_loss, test_acc = processData(test_data, backprop=False)
print('Test:\tLoss %.3f | Accuracy: %.3f' % (test_loss, test_acc))
--- Epoch 100
Train: Loss 0.688 | Accuracy: 0.517
Test: Loss 0.700 | Accuracy: 0.500
--- Epoch 200
Train: Loss 0.680 | Accuracy: 0.552
Test: Loss 0.717 | Accuracy: 0.450
--- Epoch 300
Train: Loss 0.593 | Accuracy: 0.655
Test: Loss 0.657 | Accuracy: 0.650
--- Epoch 400
Train: Loss 0.401 | Accuracy: 0.810
Test: Loss 0.689 | Accuracy: 0.650
--- Epoch 500
Train: Loss 0.312 | Accuracy: 0.862
Test: Loss 0.693 | Accuracy: 0.550
--- Epoch 600
Train: Loss 0.148 | Accuracy: 0.914
Test: Loss 0.404 | Accuracy: 0.800
--- Epoch 700
Train: Loss 0.008 | Accuracy: 1.000
Test: Loss 0.016 | Accuracy: 1.000
--- Epoch 800
Train: Loss 0.004 | Accuracy: 1.000
Test: Loss 0.007 | Accuracy: 1.000
--- Epoch 900
Train: Loss 0.002 | Accuracy: 1.000
Test: Loss 0.004 | Accuracy: 1.000
--- Epoch 1000
Train: Loss 0.002 | Accuracy: 1.000
Test: Loss 0.003 | Accuracy: 1.000
https://github.com/vzhou842/rnn-from-scratch
了解长短期记忆网络(LSTM),这是一个更强大和更受欢迎的RNN架构,或关于LSTM的著名的变体--门控循环单元(GRU)。
通过恰当的ML库(如Tensorflow,Keras或PyTorch),你可以尝试更大/更好的RNN。
了解双向RNN,它可以处理前向和后向序列,因此输出层可以获得更多信息。
尝试像GloVe或Word2Vec这样的Word嵌入,可用于将单词转换为更有用的矢量表示。
查看自然语言工具包(NLTK),这是一个用于处理人类语言数据的Python库
编辑:于腾凯
校对:杨学俊
译者简介
王雨桐,UIUC统计学在读硕士,本科统计专业,目前专注于Coding技能的提升。理论到应用的转换中,敬畏数据,持续进化。
翻译组招募信息
工作内容:需要一颗细致的心,将选取好的外文文章翻译成流畅的中文。如果你是数据科学/统计学/计算机类的留学生,或在海外从事相关工作,或对自己外语水平有信心的朋友欢迎加入翻译小组。
你能得到:定期的翻译培训提高志愿者的翻译水平,提高对于数据科学前沿的认知,海外的朋友可以和国内技术应用发展保持联系,THU数据派产学研的背景为志愿者带来好的发展机遇。
其他福利:来自于名企的数据科学工作者,北大清华以及海外等名校学生他们都将成为你在翻译小组的伙伴。
点击文末“阅读原文”加入数据派团队~
点击“阅读原文”拥抱组织
独家 | 菜鸟必备的循环神经网络指南(附链接)相关推荐
- 独家 | 数据科学家的必备读物:从零开始用 Python 构建循环神经网络(附代码)...
作者:Faizan Shaikh 翻译:李文婧 校对:张一豪 本文约4300字,建议阅读10+分钟. 本文带你快速浏览典型NN模型核心部分,并教你构建RNN解决相关问题. 引言 人类不会每听到一个句子 ...
- 独家 | 在PyTorch中用图像混合(Mixup)增强神经网络(附链接)
作者:Ta-Ying Cheng翻译:陈之炎校对:车前子本文约2000字,建议阅读5分钟随机混合图像,效果是不是会更好? 标签:神经网络.图像混合 一直以来,在深度学习领域,图像分类是呈指数级增长的课 ...
- 独家 | 基于癌症生存数据建立神经网络(附链接)
作者:Jason Brownlee 翻译:wwl校对:车前子本文约4000字,建议阅读3分钟本文介绍了haberman乳腺癌生存二分类数据集,进行神经网络模型拟合.包含数据准备.MLP模型学习机制.模 ...
- 独家 | 一文读懂神经网络(附解读案例)
作者:Matthew Stewart 翻译:车前子 校对:陈丹 本文约5500字,建议阅读12分钟. 本文的知识将提供一个强有力的基础,带你入门神经网络的性能,应用于深度学习应用. "你的大 ...
- 独家 | 贝叶斯信念网络初探(附链接)
作者:Jason Brownlee 翻译:陈超 校对:欧阳锦 本文约3500字,建议阅读8分钟 本文共分为5部分,从概率模型的挑战.概率模型--贝叶斯信念网络.如何建立和使用贝叶斯网络.贝叶斯网络范例 ...
- 独家 | 如何手动优化神经网络模型(附链接)
翻译:陈丹 校对:车前子 本文约5400字,建议阅读15分钟 本文是一个教授如何优化神经网络模型的基础教程,提供了具体的实战代码供读者学习和实践. 标签:神经网络优化 深度学习的神经网络是采用随机梯度 ...
- 独家 | Python中的SOLID原则(附链接)
作者:Mattia Cinelli翻译:朱启轩校对:欧阳锦本文约3500字,建议阅读15分钟本文通过一些Python示例代码介绍了可以提高代码可靠性的SOLID编码准则. 标签:数据结构,编程,数据科 ...
- 《Scikit-Learn与TensorFlow机器学习实用指南》第14章 循环神经网络
第14章 循环神经网络 来源:ApacheCN<Sklearn 与 TensorFlow 机器学习实用指南>翻译项目 译者:@akonwang @alexcheen @飞龙 校对:@飞龙 ...
- 循环神经网络RNN 2—— attention注意力机制(附代码)
attention方法是一种注意力机制,很明显,是为了模仿人的观察和思维方式,将注意力集中到关键信息上,虽然还没有像人一样,完全忽略到不重要的信息,但是其效果毋庸置疑,本篇我们来总结注意力机制的不同方 ...
最新文章
- 996.icu 不加班的程序员有前途吗?
- 软件架构之美在于简单、好用、稳定、功能定位明确、代码简洁、通俗易懂
- mvc的视图中显示DataTable的方法
- 2月7日 SVM线性回归逻辑回归
- dqpsk的matlab,基于MATLAB的理想_4_DQPSK系统仿真.pdf
- 机器学习数学基础 - 导数和偏导数
- Java项目:医院挂号预约管理系统(java+SSM+HTML+JavaScript+jsp+mysql)
- c语言三阶素数魔方阵,C语言 三阶魔方阵
- 2021ICPC网络预选赛 M题
- 台式计算机多少g的显卡怎么看,怎样看电脑配置|怎样看电脑显卡配置?
- IDEA+MySQL+JavaFX之通讯录系统
- tcpdump命令解析
- 深度学习:神经络的向播和反传播算法导
- spotify文件下载路径_从计算机的音乐文件夹中自动执行Spotify上的播放列表
- 决定教你们如何看别人的 QQ密码
- 用模板创建Maven显示No archetype found in remote catalog. Defaulting to internal catalog
- 解决跨网段远程调试的问题
- 使用cat命令创建文件并写入数据
- 用C语言实现介于两个数字中间的数之和
- Matlab 基础01 - 多维数组的排列转换和Permute 函数
热门文章
- jQuery 淡入淡出
- Storm(一)集群搭建
- Ubuntu14.04 x64 zabbix 3.0 安装
- NopCommerce 增加 Customer Attributes
- 多线程断点下载开发总结(二)- 多线程写文件
- 大学毕业后,我将何去何从?
- linux与windows下开发,Linux 与 Windows下开发感受
- mysql当前时间减1小时_最佳睡眠时间:晚上睡眠不超8小时,午睡不超1小时
- python数据科学手册_小白入门Python数据科学
- 职称计算机和职称英语期限,专业技术职称考试,职称英语和职称计算机有效期多长时间,每年什么时候报名啊?上海的...