Python语言基于Tensorflow实现RNN（预测）

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import csv
from pylab import*
from sklearn import preprocessing
from sklearn.preprocessing import MinMaxScaler
from matplotlib import pyplot
import math
from random import random
from sklearn.model_selection import KFold
import random
n_inputs = 6 #输入一行，一行有6个数据
max_time = 24 #一共24行
lstm_size = 35 #隐层单元
n_classes = 24 # 预测24个值
batch_size = 32 #每批次50个样本
n_batch = 32 // batch_size #计算一共有多少个批次
i=0
j=[]
data = []
X = []
indicess = []
xback =24
with open(r'D:\晴天新.csv') as f:
reader = csv.reader(f)
for row in reader:
if i == 0:
i += 1
continue
            else:
data.append(row[:])#提取出每一行中的2:14列
data = np.array(data)
m,n = np.shape(data)
for i in range(m):
for j in range(n):
data[i][j] = data[i][j].astype('float64')#是从第三列开始的
data = data.astype('float64')
y = data[:,-1]
y1 = data[:,-1]
set1 = data[:,:-1]
set2 = data[:,-1]
def create_interval_dataset(dataset1, dataset2, xback):
dataX, dataY = [], []
for i in range(0, len(dataset1)-xback,24):
dataX.append(dataset1[i:i+xback])
dataY.append(dataset2[i:i + xback])
return np.asarray(dataX), np.asarray(dataY)

dataX, dataY = create_interval_dataset(set1, set2, 24)
dataY=np.reshape(dataY, [-1,24])
from sklearn.model_selection import KFold
MAPE2 = []
RMSE2 = []
MABE2 = []
kf =KFold(n_splits=10, random_state=None, shuffle=False)
for train_index, test_index in kf.split(dataX):
print("TRAIN:", train_index, "TEST:", test_index)
X_tr, X_te = dataX[train_index], dataX[test_index]
y_tr, y_te = dataY[train_index], dataY[test_index]
X_tr = np.reshape(X_tr, [-1,6])
X_te = np.reshape(X_te, [-1,6])
y_tr = np.reshape(y_tr, [-1, 24])
y_te = np.reshape(y_te, [-1, 24])
scaler = MinMaxScaler(feature_range=(0, 1))
scaler1 = MinMaxScaler(feature_range=(0, 1))
X_tr = scaler.fit_transform(X_tr)
X_te = scaler1.fit_transform(X_te)
scaler2 = MinMaxScaler(feature_range=(0, 1))
y_tr = scaler2.fit_transform(y_tr.reshape(-1, 24))
scaler3 = MinMaxScaler(feature_range=(0, 1))
y_te = scaler3.fit_transform(y_te.reshape(-1, 24))
y_tr = np.reshape(y_tr, [-1, 24])
y_te = np.reshape(y_te, [-1, 24])
y_te = y_te.astype('float64')
y_tr = y_tr.astype('float64')
x = tf.placeholder(tf.float32, [None, 6])
y = tf.placeholder(tf.float32, [None, 24])
weights = tf.Variable(tf.truncated_normal([lstm_size, n_classes], stddev=0.1))
biases = tf.Variable(tf.constant(0.1, shape=[n_classes]))
# 定义RNN网络
def RNN(X, weights, biases):
# inputs=[batch_size, max_time, n_inputs]
inputs = tf.reshape(X, [-1, max_time, n_inputs])
print("the shape of inputs",np.shape(inputs))
# 定义LSTM基本CELL
lstm_cell = tf.contrib.rnn.core_rnn_cell.BasicLSTMCell(lstm_size)
# final_state[0]是cell state
# final_state[1]是hidden_state
outputs, final_state = tf.nn.dynamic_rnn(lstm_cell, inputs, dtype=tf.float32)
print("the shape of outputs",np.shape(outputs))
print("the shape of weights",np.shape(weights))
results = tf.matmul(outputs[-1], weights) + biases
return results
# 计算RNN的返回结果
prediction = RNN(x, weights, biases)
# 损失函数
cross_entropy = tf.reduce_mean(tf.square(y - prediction))
# 使用AdamOptimizer进行优化
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
# 结果存放在一个布尔型列表中
# correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(prediction,1))#argmax返回一维张量中最大的值所在的位置
# 求准确率
# accuracy = tf.reduce_mean(tf.cast(correct_prediction,tf.float32))#把correct_prediction变为float32类型
# 初始化
init = tf.global_variables_initializer()
with tf.Session() as sess:
sess.run(init)
for _ in range(400):
sess.run(train_step, feed_dict={x: X_tr, y: y_tr})
pred_X1 = sess.run(prediction, feed_dict={x: X_te})
pred_X = sess.run(prediction, feed_dict={x: X_tr})
y_tr = scaler2.inverse_transform(y_tr.reshape(-1, 24))
y_te = scaler3.inverse_transform(y_te.reshape(-1, 24))
pred_X = scaler3.inverse_transform(pred_X.reshape(-1, 24))
prediction_train1 = scaler2.inverse_transform(pred_X1.reshape(-1, 24))
y_tr = y_tr.flatten()
y_te = y_te.flatten()
pred_X = pred_X.flatten()
pred_X1 = pred_X1.flatten()
fei01 = []
for i in range(len(y_te)):
if y_te[i] != 0:
fei01.append(i)
xina1 = []
xinb1 = []
for i in fei01:
xina1.append(y_te[i])
xinb1.append(pred_X[i])
v = list(map(lambda x: (abs((x[0] - x[1]) / x[0])), zip(xina1, xinb1)))
loss = sum(v) * 100 / len(y_te)
MAPE2.append(loss)

v = list(map(lambda x: ((pow((x[0] - x[1]), 2))), zip(xina1, xinb1)))
loss = math.sqrt(sum(v) / len(y_te))
RMSE2.append(loss)

v = list(map(lambda x: (abs((x[0] - x[1]))), zip(xina1, xinb1)))
loss = sum(v) / len(y_te)
MABE2.append(loss)