Keras + LSTM 做回归demo

学习神经网络

想拿lstm 做回归, 网上找demo 基本三种: sin拟合cos 那个, 比特币价格预测(我用相同的代码和数据没有跑成功, 我太菜了)和keras 的一个例子

我基于keras 那个实现了一个, 这里贴一下我的代码.

import numpy as np
np.random.seed(1337)
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import keras
from keras.models import Sequential
from keras.layers import Activation
from keras.layers import LSTM
from keras.layers import Dropout
from keras.layers import Dense

　　

# 数据的数量
datan = 400
X = np.linspace(-1, 2, datan)
np.random.shuffle(X)
# 构造y  y=3*x + 2 并加上一个0-0.5 的随机数
Y = 3.3 * X + 2 + np.random.normal(0, 0.5, (datan, ))
# 展示一下数据
plt.scatter(X, Y)
plt.show()

　　

# 训练集测试集划分 2:1
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.33, random_state=42)

　　

# 一些参数
neurons = 128 
activation_function = 'tanh'   # 激活函数
loss = 'mse'  # 损失函数
optimizer="adam"  # 优化函数      
dropout = 0.01 

　　

model = Sequential()

model.add(LSTM(neurons, return_sequences=True, input_shape=(1, 1), activation=activation_function))
model.add(Dropout(dropout))
model.add(LSTM(neurons, return_sequences=True, activation=activation_function))
model.add(Dropout(dropout))
model.add(LSTM(neurons, activation=activation_function))
model.add(Dropout(dropout))
model.add(Dense(output_dim=1, input_dim=1))
#
model.compile(loss=loss, optimizer=optimizer)

　　

# training 训练
print('Training -----------')
epochs = 2001
for step in range(epochs):
    cost = model.train_on_batch(X_train[:, np.newaxis, np.newaxis], Y_train)
    if step % 30 == 0:
        print(f'{step} train cost: ', cost)

　　

# 测试
print('Testing ------------')
cost = model.evaluate(X_test[:, np.newaxis, np.newaxis], Y_test, batch_size=40)
print('test cost:', cost)

　　

# 打印预测结果
Y_pred = model.predict(X_test[:, np.newaxis, np.newaxis])
plt.scatter(X_test, Y_test)
plt.plot(X_test, Y_pred, 'ro')
plt.show()

　　

---

loss_history = {}
def run(X_train, Y_train, X_test, Y_test, epochs, activation_func='tanh', loss_func='mse', opt_func='sgd'):
    """
　　这里是对上面代码的封装, 我测试了一下各种优化函数的效率
    可用的目标函数
        mean_squared_error或mse
        mean_absolute_error或mae
        mean_absolute_percentage_error或mape
        mean_squared_logarithmic_error或msle
        squared_hinge
        hinge
        categorical_hinge
        binary_crossentropy（亦称作对数损失，logloss）
        logcosh
        categorical_crossentropy：亦称作多类的对数损失，注意使用该目标函数时，需要将标签转化为形如(nb_samples, nb_classes)的二值序列
        sparse_categorical_crossentrop：如上，但接受稀疏标签。注意，使用该函数时仍然需要你的标签与输出值的维度相同，你可能需要在标签数据上增加一个维度：np.expand_dims(y,-1)
        kullback_leibler_divergence:从预测值概率分布Q到真值概率分布P的信息增益,用以度量两个分布的差异.
        poisson：即(predictions - targets * log(predictions))的均值
        cosine_proximity：即预测值与真实标签的余弦距离平均值的相反数
    优化函数
        sgd
        RMSprop
        Adagrad
        Adadelta
        Adam
        Adamax
        Nadam
    """
    mdl = Sequential()
    mdl.add(LSTM(neurons, return_sequences=True, input_shape=(1, 1), activation=activation_func))
    mdl.add(Dropout(dropout))
    mdl.add(LSTM(neurons, return_sequences=True, activation=activation_func))
    mdl.add(Dropout(dropout))
    mdl.add(LSTM(neurons, activation=activation_func))
    mdl.add(Dropout(dropout))
    mdl.add(Dense(output_dim=1, input_dim=1))
    #
    mdl.compile(optimizer=opt_func, loss=loss_func)
    #
    print('Training -----------')
    loss_history[opt_func] = []
    for step in range(epochs):
        cost = mdl.train_on_batch(X_train[:, np.newaxis, np.newaxis], Y_train)
        if step % 30 == 0:
            print(f'{step} train cost: ', cost)
            loss_history[opt_func].append(cost)
    # test
    print('Testing ------------')
    cost = mdl.evaluate(X_test[:, np.newaxis, np.newaxis], Y_test, batch_size=40)
    print('test cost:', cost)
    #
    Y_pred = mdl.predict(X_test[:, np.newaxis, np.newaxis])
    plt.scatter(X_test, Y_test)
    plt.plot(X_test, Y_pred, 'ro')
    return plt

　　

run(X_train, Y_train, X_test, Y_test, 2000)
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='Adagrad')
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='Nadam')
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='Adadelta')
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='RMSprop')
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='Adam')
run(X_train, Y_train, X_test, Y_test, 2000, opt_func='Adamax')

#
arr = [i*30 for i in range(len(loss_history['sgd']))]
plt.plot(arr, loss_history['sgd'], 'b--')
plt.plot(arr, loss_history['RMSprop'], 'r--')
plt.plot(arr, loss_history['Adagrad'], color='orange', linestyle='--')
plt.plot(arr, loss_history['Adadelta'], 'g--')
plt.plot(arr, loss_history['Adam'], color='coral', linestyle='--')
plt.plot(arr, loss_history['Adamax'], color='tomato', linestyle='--')
plt.plot(arr, loss_history['Nadam'], color='darkkhaki', linestyle='--')
plt

最快的是 adadelta, 最慢的sgd. 其他差不多.