Criando uma só camada RNN
import tensorflow as tf
import numpy as np
cell = tf.nn.rnn_cell.BasicRNNCell(num_units=128) # state_size = 128
print(cell.state_size) # 128
inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size，100是input_size shape = (batch_size, input_size)
h0 = cell.zero_state(32, np.float32) # 通过zero_state得到一个全0的初始状态，形状为(batch_size, state_size)
output, h1 = cell.call(inputs, h0) #调用call函数
print(h1.shape) # (32, 128）
Criar um multi-camada RNN
import tensorflow as tf
import numpy as np
# 每调用一次这个函数就返回一个BasicRNNCell
def get_a_cell():
return tf.nn.rnn_cell.BasicRNNCell(num_units=128)
# 用tf.nn.rnn_cell MultiRNNCell创建3层RNN,每层神经元具有128个
cell = tf.nn.rnn_cell.MultiRNNCell([get_a_cell() for _ in range(3)]) # 3层RNN
# 得到的cell实际也是RNNCell的子类
# 它的state_size是(128, 128, 128)
# (128, 128, 128)并不是128x128x128的意思
# 而是表示共有3个隐层状态，每个隐层状态的大小为128
print(cell.state_size) # (128, 128, 128)
# 使用对应的call函数
inputs = tf.placeholder(np.float32, shape=(32, 100)) # 32 是 batch_size
h0 = cell.zero_state(32, np.float32) # 通过zero_state得到一个全0的初始状态,得到的输出为128
output, h1 = cell.call(inputs, h0)
print(h1) # tuple中含有3个32x128的向量
Aprenda a executar um multi-passo: tf.nn.dynamic_rnn
# inputs: shape = (batch_size, time_steps, input_size)
# cell: RNNCell
# initial_state: shape = (batch_size, cell.state_size)。初始状态。一般可以取零矩阵
# inputs: shape = (batch_size, time_steps, input_size)
# cell: RNNCell
# initial_state: shape = (batch_size, cell.state_size)。初始状态。一般可以取零矩阵
import tensorflow as tf
tf.reset_default_graph()
batch_size = 32 # batch大小
input_size = 100 # 输入向量xt维度
state_size = 128 # 隐藏状态ht维度
time_steps = 10 # 序列长度 训练的循环次数，即训练每个词的预示范围
inputs = tf.random_normal(shape=[batch_size, time_steps, input_size], dtype=tf.float32)
print("inputs.shape:",inputs.shape) #(32,10,100）
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units = state_size)
print(lstm_cell.state_size) #(c=128,h=128)
initial_state = lstm_cell.zero_state(batch_size, dtype = tf.float32)
print(initial_state.h, initial_state.c) #(32,128),(32,128)
outputs, state = tf.nn.dynamic_rnn(lstm_cell, inputs, initial_state = initial_state)
print(outputs) #(32,10,128)
print(state) #(32,128) state是最终(最后一个time_step）的状态
print(state.h, state.c) #(32,128),(32,128)
Melhor compreensão da resposta:
processamento de texto, uma palavra em nome de uma iteração, a inferência quando apenas uma palavra por saída de palavra, e quando o trem, temos uma frase inteira, para que possa alimentar um número de palavras, como o Google é melhor do que a Apple, timeStep 5, e formação de metas é melhor do que a Apple [FIM].
Autor: Você Yang
link: https: //www.zhihu.com/question/271774530/answer/364711129
Fonte: sabemos quase
Quase mais conhecido em questão:
Como entender o passo LSTM vez em? - A resposta de Você Yang - sei quase https://www.zhihu.com/question/271774530/answer/364711129 rever outros usuários melhor pergunta é a seguinte:
[1] com o som de pássaros vão todos (Pergunta): Se o trem quando o passo de tempo é 5, que o peso e as dimensões da latitude não deve passo de tempo consistente isso? Assim, no teste, apenas para o passo de tempo de entrada de dados 1, e o peso da latitude não corresponde ah?
HankGuo (resposta): Esta não é uma dimensão, uma vez que é uma rede neural recorrente, o número de ciclos é arbitrária, passo de tempo é o número de ciclos. Cada ciclo é uma palavra, a palavra é um vector de dimensão palavra. Também treinar e teste quando o passo de tempo não deve consistente. seq2seq código é maior do que 1, a descodificação é igual a 1.
Você Yang (resposta): Quando é que o treinamento como [batch_size, time_step, word_dim] dimensões dos dados, a última dimensão é a incorporação de vector de cada palavra, cada ciclo [batch_size, word_dim] entrou uma vez, para um time_step entrada total vezes.
[2] Xun Nisshin (perguntas): perguntar, time_step é a unidade número RNN fazer?
Você Yang (resposta): os dois não são uma coisa, o número de RNN está escondido camada e dimensão estado celular, passo de tempo é o número de ciclos.
[3] q boneca (Pergunta): Olá, perguntar, na sequência de tempo, time_step como entender? Aguardamos a sua resposta, muito obrigado!
Você Yang (Resposta): Você tem como [lote, t, w] de dados, a primeira dimensão é Batch, a segunda dimensão é o comprimento da frase, cada palavra na terceira incorporação dimensão que é, ele vai RNN tempos de ciclo t, cada tomar os últimos resultados do ciclo, e desta vez [lote, w] y como entrada.
[4] sonho de cavalos (pergunta): Olá, tenho uma pergunta a fazer ao lado, passo de tempo é 1, não deve ser entendido como um ex-dados com dados para prever? Mas este sentimento é muito complicado?
Você Yang (resposta): Por causa do estado oculto, antes dos dados é realmente um [estado escondido, x], que é a integração de informações antes.
LSTM exemplo simples
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('MINIST_data', one_hot=True)
#读出mnist数据
weight = {
# 128====>hidden cell num ;
'first': tf.Variable(tf.random_normal([28, 128])),#输入层权值矩阵，转化为128输出，输入到RNN层中
'last': tf.Variable(tf.random_normal([128, 10]))#输出层权值矩阵
}
#权重字典
bias = {
'first': tf.Variable(tf.constant(0.1, shape=[128, ])),
'last': tf.Variable(tf.constant(0.1, shape=[10, ]))
}
def RNN(X, weights, biases):#X是一个三维数据[batch_size, step , pixel]
X = tf.reshape(X, shape=[-1, 28]) #重构输入数据集，转化为2维输入，[批，输入尺寸]
X_in = tf.matmul(X, weight['first']) + bias['first'] #全连接层实现
X_in = tf.reshape(X_in, shape=[-1, 28, 128])#经过全连接层后X = [batch_size , step , output]，这里的step指图片的相关性，
# 用前28个数据预测该值，也可以说是句子的长度
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units=128)#创建一个LSTMCell层，隐层神经元有128个，即有128个输出
init_state = lstm_cell.zero_state(128, dtype=tf.float32)#创建初始状态矩阵
outputs, state = tf.nn.dynamic_rnn(lstm_cell, X_in, initial_state=init_state, time_major=False)#进行一次
'''
tf.nn.dynamic_rnn(
cell,
inputs,
sequence_length=None,
initial_state=None,
dtype=None,
parallel_iterations=None,
swap_memory=False,
time_major=False,
scope=None
tf.nn.dynamic_rnn的返回值有两个：outputs和state
为了描述输出的形状，先介绍几个变量，batch_size是输入的这批数据的数量，max_time就是这批数据中序列的最长长度，
如果输入的三个句子，那max_time对应的就是最长句子的单词数量，cell.output_size其实就是rnn cell中神经元的个数。
outputs是一个tensor
如果time_major==True，outputs形状为 [max_time, batch_size, cell.output_size ]（要求rnn输入与rnn输出形状保持一致）
如果time_major==False（默认），outputs形状为 [ batch_size, max_time, cell.output_size ]
state是一个tensor。state是最终的状态，也就是序列中最后一个cell输出的状态。一般情况下state的形状为 [batch_size, cell.output_size ]，
但当输入的cell为BasicLSTMCell时，state的形状为[2，batch_size, cell.output_size ]，其中2也对应着LSTM中的cell state和hidden state
)
'''
# results = tf.matmul(final_state[1], weight['last']) + bias['last']
results = tf.layers.dense(outputs[:, -1, :], 10)#全连接层实现，将RNN网络输出值转化为10个输出 全连接层执行操作 outputs = activation(inputs.kernel+bias)
"""
tf.layers.dense(
inputs,
units,
activation=None,
use_bias=True,
kernel_initializer=None, ##卷积核的初始化器
bias_initializer=tf.zeros_initializer(), ##偏置项的初始化器，默认初始化为0
kernel_regularizer=None, ##卷积核的正则化，可选
bias_regularizer=None, ##偏置项的正则化，可选
activity_regularizer=None, ##输出的正则化函数
kernel_constraint=None,
bias_constraint=None,
trainable=True,
name=None, ##层的名字
reuse=None ##是否重复使用参数
)
"""
return results
x = tf.placeholder(tf.float32, [None, 28, 28])#图片尺寸
y = tf.placeholder(tf.float32, [None, 10])#输出层尺寸
pred = RNN(x, weight, bias)
# loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(labels=pred, logits=y))
loss = tf.losses.softmax_cross_entropy(onehot_labels=y, logits=pred)#计算损失值，交叉熵
train = tf.train.AdamOptimizer(0.01).minimize(loss)#ADAM优化
correct_pred = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1))#对比测试矩阵中与标签矩阵中的相等数量
"""tf.equal(A, B)是对比这两个矩阵或者向量的相等的元素，如果是相等的那就返回True，反正返回False，返回的值的矩阵维度和A是一样的
import tensorflow as tf
import numpy as np
A = [[1,3,4,5,6]]
B = [[1,3,4,3,2]]
with tf.Session() as sess:
print(sess.run(tf.equal(A, B)))
输出：[[ True True True False False]]
2、tf.argmax(input, axis=None, name=None, dimension=None)
此函数是对矩阵按行或列计算最大值，输出最大值的下标
参数
input：输入Tensor
axis：0表示按列，1表示按行
name：名称
dimension：和axis功能一样，默认axis取值优先。新加的字段
返回：Tensor 一般是行或列的最大值下标向量
"""
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))#计算正确率
init = tf.global_variables_initializer()#初始化placeholder
with tf.Session() as sess:#执行会话
sess.run(init)
step = 0
for step in range(1200):
step += 1
batch_x, batch_y = mnist.train.next_batch(128)
batch_x = batch_x.reshape([128, 28, 28])
sess.run(train, feed_dict={x: batch_x, y: batch_y})
if step % 50 == 0:
print(sess.run(accuracy, feed_dict={x: batch_x, y: batch_y}))
https://blog.csdn.net/littlely_ll/article/details/79671393
RNN função analítica
