序列预测sin函数-RNN/LSTM

问题描述

咱们就使用预测个sin函数吧

NN

     def test_sin_predict_by_ann(self):

        # build data
        series_len = 20
        x_train = np.linspace(-10, 10, 1000)
        y_train = np.sin(x_train)
        y_train2 = np.sin(x_train)
        data = {'x': [], 'y': []}
        for i in range(len(x_train) - series_len):
            data['x'].append([y_train[i + j] for j in range(series_len)])
            data['y'].append(y_train2[i + series_len])

        # build model
        input = Input(shape=(series_len,))
        x = input
        x = Dense(series_len, activation='sigmoid')(x)
        x = Dense(series_len, activation='sigmoid')(x)
        y = Dense(1, activation='tanh')(x)
        model = Model(inputs=input, outputs=y)
        model.compile(optimizer=RMSprop(learning_rate=0.1), loss=MeanSquaredError())
        X, Y = np.array(data['x']), np.array(data['y'])
        model.fit(X, Y, epochs=500, batch_size=50)
        model.evaluate(X, Y)
        res = model.predict(X)
        plt.plot(x_train[series_len:], y_train[series_len:])
        plt.plot(x_train[series_len:], Y)
        plt.plot(x_train[series_len:], res)
        plt.legend(labels=('origin', 'y_train', 'y_pred'))
        plt.show()

使用ann全连接预测结果，可以看到，预测的曲线有很多突变点，不够光滑。

LSTM

    def test_sin_predict_by_lstm(self):
        series_len = 20
        out_len = 1
        input = Input(shape=(series_len, 1))
        x = input
        x = LSTM(1)(x)
        model = Model(inputs=input, outputs=x)
        optimizer = RMSprop(learning_rate=0.1)
        loss = MeanSquaredError()
        model.compile(optimizer=optimizer, loss=loss, metrics=[])

        x = np.linspace(-10, 10, 1000)
        y = np.sin(x)
        y2 = np.cos(x)
        data = {'x': [], 'y': []}
        for i in range(len(x) - series_len):
            data['x'].append([[y[i + j]] for j in range(series_len)])
            # data['y'].append([y2[i + series_len + j] for j in range(out_len)])
            data['y'].append([y[i + series_len]])
        model.fit(data['x'], data['y'], batch_size=40, epochs=100)
        model.evaluate(data['x'], data['y'])
        x_test = data['x']
        res = model.predict(x_test)
        print(f"x {x_test}\n")
        print(f"y {res[:20]}")
        print(f"y_true {data['y'][:20]}")
        plt.plot(x, y.ravel()[:len(x)], color='green')
        plt.plot(x[series_len:], res.ravel()[:len(x) - series_len], color='red')
        plt.legend(labels=('y_train','y_pred'))
        plt.show()

LSTM的预测就平滑多了