import numpy as np
import tensorflow as tf
from sklearn.preprocessing import OneHotEncoder
import random
import os
from tensorflow.contrib import rnn
data_num=np.array([0,1,2,3,4,5,6,7,8,9])
data_num=data_num.reshape([-1,1])
data_num=OneHotEncoder().fit_transform(data_num).todense()
batch_size=100
#print(data)
def get_data(batch_size=100):
batch_in_data=[]
batch_out_data=[]
for i in range(batch_size):
a=random.randint(0,10000000)
b=random.randint(0,10000000)
c=[a,b]
d=a+b
d1=d
data=[]
label=[]
out_data=[]
for j in c:
for i in range(8):
data.insert(i,j%10)
j=j//10
data=np.array(data)
data=data.reshape([2,8]).T
data=data.reshape([8,2])
for i in range(8):
out_data.insert(i,d%10)
d=d//10
for x in out_data:
label.append(data_num[x])
#print(out_data)
label=np.array(label)
label=label.reshape([8,10])
batch_out_data.append(label)
batch_in_data.append(data)
batch_in_data=np.array(batch_in_data)
batch_out_data=np.array(batch_out_data)
batch_in_data=batch_in_data.astype("float32")
batch_out_data=batch_out_data.astype("float32")
batch_in_data=batch_in_data.reshape([-1,8,2])
batch_out_data=batch_out_data.reshape([-1,8,10])
return batch_in_data,batch_out_data,d1
#输入:
x=tf.placeholder(tf.float32,[None,8,2])
y=tf.placeholder(tf.float32,[None,8,10])
#y=tf.placeholder(tf.int64,[8])
weights = {
'out' : tf.Variable(tf.random_normal([8, 10])) #128*10
}
biases = {
'out' : tf.Variable(tf.random_normal([10])) #1*10
}
weights = {'in':tf.Variable(tf.random_normal([2, 16])),
'out':tf.Variable(tf.random_normal([8, 10]))}
biases = {'in':tf.Variable(tf.constant(0.1, shape=[16, ])),
'out':tf.Variable(tf.constant(0.1, shape=[10, ]))}
'''
def RNN(X, weights, biases):
#print(X)
X=tf.reshape(X,[-1,2])
X_in = tf.matmul(X, weights['in']) + biases['in']
#print(X_in)
X_in = tf.reshape(X_in, [8, -1,16])
#print(X_in)
# 使用基本的LSTM循环网络单元
#lstm_cell = tf.contrib.rnn.BasicLSTMCell(16, forget_bias=1.0, state_is_tuple=True)
lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(8, forget_bias=1.0, state_is_tuple=True)
# 初始化为0,LSTM单元由两部分构成(c_state, h_state)
init_state = lstm_cell.zero_state(8, dtype=tf.float32)
# dynamic_rnn接收张量要么为(batch, steps, inputs)或者(steps, batch, inputs)作为X_in
outputs, final_state = tf.nn.dynamic_rnn(lstm_cell, X_in, initial_state=init_state, time_major=False)
print("output:",outputs)
print("final_state:",final_state)
results = tf.matmul(final_state[1], weights['out']) + biases['out']
#outputs = tf.reshape(outputs, [-1, 8])
#results = tf.matmul(outputs, weights['out']) + biases['out']
#results = tf.reshape(results, [8, -1, 10])
print("results:",results)
#results = tf.transpose(results, [1, 0,2])
#results = tf.reshape(results, [-1, 10])
return results
'''
def RNN(X, weights, biases):
x=tf.transpose(X,[1,0,2])
x=tf.reshape(x,[-1,2])
x = tf.split(x, 8,0)
print("x:",x)
rnn_cell = tf.nn.rnn_cell.BasicRNNCell(8)
outputs, states = rnn.static_rnn(rnn_cell, x, dtype=tf.float32)
with tf.variable_scope('hidden_to_output_layer'):
w2out = tf.get_variable('w2out', shape=[8, 10], dtype=tf.float32, initializer=tf.truncated_normal_initializer(0.0, 1.0))
bias2out = tf.get_variable('bias2oput', shape=[10], dtype=tf.float32, initializer=tf.constant_initializer(0.0))
print("outputs:",outputs)
outputs = tf.reshape(outputs, [-1, 8])
print("outputs:",outputs)
#result = tf.nn.sigmoid(tf.matmul(outputs, w2out)+bias2out)
result = tf.matmul(outputs, w2out)+bias2out
print(result)
result = tf.reshape(result, [8, -1, 10])
print(result)
result = tf.transpose(result, [1, 0,2])
print(result)
return result
'''
def RNN(x, weights, biase):
#print(1)
x = tf.unstack(x, 8, 1) #分解维数
#print(len(x))
lstm_cell = rnn.BasicLSTMCell(8, forget_bias=1.0) #LSTM最简单的神经元 128
outputs, states = rnn.static_rnn(lstm_cell, x, dtype=tf.float32) #
print("ouyputs:",outputs)
return tf.nn.softmax(tf.matmul(outputs[-1], weights['out']) + biases['out'])#矩阵相乘
'''
pred = RNN(x, weights, biases)
pre = tf.argmax(pred,2)
#pre = tf.argmax(pred,1)
#cost = tf.reduce_mean(tf.square(pred-y))
#print(pre)
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits_v2(logits=pred, labels=y))
#optimizer = tf.train.AdagradOptimizer(1).minimize(cost)
optimizer = tf.train.AdamOptimizer(0.01).minimize(cost)
correct_pred = tf.equal(tf.argmax(pred, 2), tf.argmax(y, 2))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
def train():
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
for i in range(2000000):
batch_xs,batch_ys,d=get_data()
#print(batch_xs.shape,batch_ys.shape)
sess.run(optimizer, feed_dict={x: batch_xs, y: batch_ys})
if i%100 ==0:
cc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys})
loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})
print("cc:",cc," loss:",loss)
if i % 1000==0:
batch_xs,batch_ys,d=get_data(1)
#print(d)
#print(batch_xs)
#print(batch_ys)
#os.system("pause")
pree = sess.run(pre,feed_dict={x:batch_xs})
cc = sess.run(accuracy, feed_dict={x: batch_xs, y: batch_ys})
loss = sess.run(cost, feed_dict={x: batch_xs, y: batch_ys})
print("true:",d)
print("pree:",pree[0][::-1][0:8])
#print("pree1:",pree)
print("ac:",cc)
print("loss:",loss)
print("________________")
sess.close()
train()
最后的运行图: