Python 多次迭代后，LSTM损失保持不变

谢谢你研究这个问题！：）

我试图训练一个LSTM网络，根据过去30天的股价预测谷歌未来10天的股价。我训练了LSTM，但即使经过200次迭代，损失也几乎没有减少。我怀疑这个问题可能是由于tf会话中的提要命令引起的。然而，我没有发现任何问题（可能是由于我的肤浅知识）。优化器似乎会刷新tf会话中的每个迭代

如果我对优化器使用的理解是错误的，如果我能就代码中可能出现的错误寻求建议，我将不胜感激

谢谢你的帮助

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import sys
import csv
import random
import tensorflow as tf
from tensorflow.contrib import rnn

# Define data reader
def read_data(fname):
    with open(fname) as f:
        data = list(csv.reader(f))
        d_mat = np.array(data)
        d_trsp = np.transpose(d_mat)

        date = np.transpose(d_trsp[0])
        p_open = d_trsp[1]
        vol = d_trsp[6]
        chg = d_trsp[7]
        chg = [float(i) for i in chg]

        return vol, chg

vol, training_data = read_data('GOOGL.csv')

training_data = training_data[0:300]
print("Loading training data..")

#Split data for learning
ratio_train = 0.70
ratio_valid = 0.90-ratio_train
ratio_test = 0.10 #fixed at 10% of dataset

# Parameters
learning_rate = 0.005
training_iters = 100
display_step = 1
x_size = 30
y_size = 5
n_hidden = 256

# Variables
x = tf.placeholder("float", [265, x_size])
y = tf.placeholder("float", [265, y_size])

weights = {
    'out': tf.Variable(tf.random_normal([n_hidden, y_size]))
    }

biases = {
    'out': tf.Variable(tf.random_normal([y_size]))
    }

# Preprocess Data
def prod_data(data):
    x = []
    y = []

    iter = len(data)-x_size-y_size
    for i in range(0, iter):
        x.append(data[i:i+x_size])
        y.append(data[i+x_size+1: i+x_size+1+y_size])

    return x, y

a,b = prod_data(training_data)

# Define RNN architecture
def RNN(x, weights, biases):
    # Reshape x to [1, n_input]
    x = tf.reshape(x, [-1, x_size])
    x = tf.split(x, x_size, 1)

    rnn_cell = rnn.MultiRNNCell([rnn.BasicLSTMCell(n_hidden), rnn.BasicLSTMCell(n_hidden)])
    outputs, states = rnn.static_rnn(rnn_cell, x, dtype = tf.float32)

    return tf.matmul(outputs[-1], weights['out'] + biases['out'])

pred = RNN(x, weights, biases)

# Loss and Optimizer
cost = tf.reduce_mean((pred-y)**2)
optimizer = tf.train.RMSPropOptimizer(learning_rate = learning_rate).minimize(cost)

# Initialization
init = tf.global_variables_initializer()

# Launch Tensor graph
with tf.Session() as sess:
    sess.run(init)
    step = 0
    loss_total = 0
    loss_coll = []
    end_offset = len(training_data)-y_size-x_size-1  

    while step < training_iters:

        _, loss, model_pred = sess.run([optimizer, cost, pred], \
                                                feed_dict={x: a, y: b})

        # Update total loss and accuracy
        loss_total += loss
        loss_coll.append(loss)


        if (step+1) % display_step == 0:
            print("Loss at step " + str(step) + " = " + str(loss))
            loss_total = 0

        step += 1

    print("Optimization Finished!")

将熊猫作为pd导入
将matplotlib.pyplot作为plt导入
将numpy作为np导入
导入系统
导入csv
随机输入
导入tensorflow作为tf
从tensorflow.contrib导入rnn
#定义数据读取器
def读取数据（fname）：
将open（fname）作为f：
数据=列表（csv.reader（f））
d_mat=np.数组（数据）
d_trsp=np.转置（d_mat）
日期=np.转置（d_trsp[0]）
p_open=d_trsp[1]
vol=d_trsp[6]
chg=d_trsp[7]
chg=[chg中i的浮点数（i）]
返回卷，chg
vol，training\u data=读取数据（'GOOGL.csv'）
训练数据=训练数据[0:300]
打印（“加载培训数据…”）
#分割数据进行学习
传动比=0.70
传动比有效=0.90-传动比
比率_测试=0.10#固定在数据集的10%
#参数
学习率=0.005
培训费用=100
显示步骤=1
x_尺寸=30
y_尺寸=5
n_hidden=256
#变数
x=tf.placeholder（“float”[265，x_size]）
y=tf.占位符（“浮动”[265，y_大小]）
权重={
'out'：tf.Variable（tf.random\u normal（[n\u hidden，y\u size]））
}
偏差={
'out'：tf.Variable（tf.random\u normal（[y\u size]））
}
#预处理数据
def产品数据（数据）：
x=[]
y=[]
iter=透镜（数据）-x_尺寸-y_尺寸
对于范围内的i（0，iter）：
x、 追加（数据[i:i+x_大小]）
y、 追加（数据[i+x\u大小+1:i+x\u大小+1+y\u大小]）
返回x，y
a、 b=生产数据（培训数据）
#定义RNN体系结构
def RNN（x、重量、偏差）：
#将x整形为[1，n_输入]
x=tf.重塑（x，[-1，x_大小]）
x=tf.分割（x，x_大小，1）
rnn\u单元=rnn.MultiRNNCell（[rnn.BasicLSTMCell（n\u隐藏），rnn.BasicLSTMCell（n\u隐藏）]）
输出，状态=rnn.static\u rnn（rnn\u单元格，x，dtype=tf.float32）
返回tf.matmul（输出[-1]，权重['out']+偏差['out']）
pred=RNN（x，权重，偏差）
#损失与优化
成本=tf.减少平均值（（预测年）**2）
优化器=tf.train.RMSPropOptimizer（学习率=学习率）。最小化（成本）
#初始化
init=tf.global_variables_initializer（）
#发射张量图
使用tf.Session（）作为sess：
sess.run（初始化）
步长=0
总损失=0
损耗系数=[]
结束偏移=长度（训练数据）-y\U尺寸-x\U尺寸-1
当步骤<培训\u iters:
_，损失，模型_pred=sess.run（[optimizer，cost，pred]\
feed_dict={x:a，y:b}）
#更新总损失和准确度
损失总额+=损失
损失附加（损失）
如果（步骤+1）%display\u step==0：
打印（“在步骤中丢失”+str（步骤）+“=”+str（丢失））
总损失=0
步骤+=1
打印（“优化完成！”）

100步算不了什么。尝试数千次，看看问题是否仍然存在。此外，您可能还想指定“勉强”减少的损失是什么意思。感谢@xdurch0，事实证明这是学习率和使用的迭代次数的混合。找到了两者的平衡，损失也如预期的那样减少了：）