[人工智能]RNN循环神经网络从零开始

# -*- coding: utf-8 -*-
# @Project: zc
# @Author: zc
# @File name: RNN-test
# @Create time: 2022/1/23 14:45

# 1. 导入相关数据库
import matplotlib.pyplot as plt
import math
import torch
from torch import nn
from torch.nn import functional as F
from d2l import torch as d2l

# 2.定义相关参数
# batch_size 批量大小；num_steps
batch_size, num_steps = 32, 35
# train_iter:训练迭代器，vocab 字符级词元表
train_iter, vocab = d2l.load_data_time_machine(batch_size, num_steps)


# 3.获取网络参数，因为输出和输出来自同一词汇表，所以num_inputs = num_outputs=vocab_size
def get_params(vocab_size, num_hiddens, device):
	num_inputs = num_outputs = vocab_size

	# 定义初始化，以正态分布采集数据
	def normal(shape):
		return torch.randn(size=shape, device=device) * 0.01

	# 根据公式 H_t = φ(X_t·W_xh+H_t-1·W_hh + b_h)
	# O_t = H_t·W_hq +b_q
	# X ∈ R^(n x d)
	W_xh = normal((num_inputs, num_hiddens))
	W_hh = normal((num_hiddens, num_hiddens))
	b_h = torch.zeros(num_hiddens, device=device)
	W_hq = normal((num_hiddens, num_outputs))
	b_q = torch.zeros(num_outputs, device=device)
	# 将RNN的所有参数集中到params中
	params = [W_xh, W_hh, b_h, W_hq, b_q]
	for param in params:
		# 确保每个参数：梯度返传时对该参数计算梯度，并存入tensor.grad中
		# 能够进行更新
		param.requires_grad_(True)
	return params  # 返回所有的参数


# 4. 初始化返回隐状态；返回值全为0的张量（(批量大小，隐藏单元数),）
def init_rnn_state(batch_size, num_hiddens, device):
	return (torch.zeros((batch_size, num_hiddens), device=device),)


# 5.定义了如何在一个时间步内计算隐状态和输出;
# RNN前向传播函数；
# 返回输出O_t和隐藏变量H_t
def rnn(inputs, state, params):
	# inputs的形状：(时间步数量，批量大小，词表大小)=(5,2,28)
	W_xh, W_hh, b_h, W_hq, b_q = params
	# W_xh=[512,512];W_hq=[512,28];W_xh=[28,512];b_h = [512,];b_q =[28,]
	H, = state  # state为元祖tuple ;tuple_0 = H = tensor(2,512)
	# outputs 输出层，相当于 O_t ; H 相当于隐藏层
	outputs = []
	# X 的大小为 [5,28]
	for X in inputs:
		# 隐藏层；激活函数为 torch.tanh
		H = torch.tanh(torch.mm(X, W_xh) + torch.mm(H, W_hh) + b_h)
		# 输出层
		Y = torch.mm(H, W_hq) + b_q
		outputs.append(Y)
	return torch.cat(outputs, dim=0), (H,)


class RNNModelScratch:
	"""
	vocab_size:词元大小；
	num_hiddens:隐藏单元个数
	device: GPU
	get_params:循环神经网络RNN需要的参数
	init_state:初始化状态
	forward_fn:前向传播函数

	"""

	def __init__(self, vocab_size, num_hiddens, device,
				 get_params, init_state, forward_fn):
		self.vocab_size, self.num_hiddens = vocab_size, num_hiddens
		self.params = get_params(vocab_size, num_hiddens, device)
		self.init_state, self.forward_fn = init_state, forward_fn

	# 当类的实例在传入(X,state)的时候，就调用此方法
	def __call__(self, X, state):
		# 1.将X独热编码；
		# 2.RNN前向传播计算
		X = F.one_hot(X.T, self.vocab_size).type(torch.float32)
		return self.forward_fn(X, state, self.params)

	# 初始化状态；值全为0，大小(批量大小，隐藏单元数)
	def begin_state(self, batch_size, device):
		return self.init_state(batch_size, self.num_hiddens, device)


num_hiddens = 512
X = torch.arange(10).reshape((2, 5))
net = RNNModelScratch(len(vocab), num_hiddens, d2l.try_gpu(), get_params, init_rnn_state, rnn)
state = net.begin_state(X.shape[0], d2l.try_gpu())
# Y.shape=[10,28];new_state=([2,512],)
# Y:输出状态；new_state隐藏状态，此调用RNNModelScratch 里面的__call__方法；
# 即前向传播函数，
Y, new_state = net(X.to(d2l.try_gpu()), state)
print(Y.shape, len(new_state), new_state[0].shape)


def predict_ch8(prefix, num_preds, net, vocab, device):
	# 初始化状态RNN神经网络
	# 在prefix后面生成新字符
	state = net.begin_state(batch_size=1, device=device)
	# prefix = time traveller;t->3;i->5;m->13;e->2;''->1;t->3;r->10;a->4;
	# v->22;e->2;l->12;l->12;e->2;r->10;18->g;16->f;24->x
	# 将字符词元化[3,5,13,2,1,3,10,4,22,2,12,12,2,10,18,16,24]
	outputs = [vocab[prefix[0]]]
	get_input = lambda: torch.tensor([outputs[-1]], device=device).reshape((1, 1))
	# 预热期
	for y in prefix[1:]:
		_, state = net(get_input(), state)
		outputs.append(vocab[y])
	# 预测num_preds步
	for _ in range(num_preds):
		y, state = net(get_input(), state)
		outputs.append(int(y.argmax(dim=1).reshape(1)))
	return ''.join([vocab.idx_to_token[i] for i in outputs])


print(predict_ch8('time traveller', 10, net, vocab, d2l.try_gpu()))