Модель продажи шампуня shampoo-sales близка. Обновил: Я так думал.Не нормализовавал данные

# %%
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler
import keras
from keras.models import Sequential
from keras.layers import LSTM
from keras.layers import Dense, Dropout
import pickle
 
# %%
n_past = 5
n_future = 1
 
# switch to google colab
flag_google_colab = False
# /switch to google colab
 
if flag_google_colab:
    # для google colab
    from google.colab import drive
    drive.mount('/content/gdrive')
    google_colab_prefix_data_folder = '/content/gdrive/MyDrive/Colab Notebooks/'  # csv ложим в папку data
    # /для google colab
else:
    google_colab_prefix_data_folder = ''
 
fold_csv = google_colab_prefix_data_folder + 'data/shampoo-sales.csv'
fpickle = google_colab_prefix_data_folder + 'learned.pkl'
 
df = pd.read_csv(fold_csv)
 
cols = list(df)[1:2]
 
df_for_training = df[cols].astype(float)
 
np_common_data_2Dmatr = df_for_training.to_numpy()
 
train, test = np_common_data_2Dmatr[0:-12], np_common_data_2Dmatr[
    -12:]  # train за 2 год берем, test - за год
 
scaler_train = StandardScaler()
scaler_train = scaler_train.fit(train)
np_train_common_data_2Dmatr_scaled = scaler_train.transform(train)
 
 
def save_model(model):
    """
       Сохранить только веса модели в pickle файл.Это карта
       key:int-номер слоя => value - значение матрицы весов.
    """
    len_layers = len(model.layers)
    weights = {}
    for i in range(len_layers):
        weights[i] = model.layers[i].get_weights()
 
    with open(fpickle, 'wb') as f:
        pickle.dump(weights, f)
        print(f'saved learned to {fpickle}')
 
 
def build_model_lstm(period_n_X, n_vars_X, n_out_Y, random_initializer):
    if random_initializer:
        seed = None
    else:
        seed = 1
    initializer = keras.initializers.RandomNormal(mean=0.0,
                                                  stddev=0.05,
                                                  seed=seed)
    model = Sequential()
 
    model.add(
        LSTM(64,
             activation='relu',
             input_shape=(period_n_X, n_vars_X),
             return_sequences=True,
             kernel_initializer=initializer))
    model.add(
        LSTM(32,
             activation='relu',
             return_sequences=False,
             kernel_initializer=initializer))
    model.add(Dropout(0.2))
    model.add(Dense(n_out_Y, kernel_initializer=initializer,
                    activation='relu'))
 
    model.compile(optimizer='adam', loss='mse')
    model.summary()
 
    return model
 
 
def make_lstm(period_n_X,
              n_vars_X,
              n_out_Y,
              fdump=None,
              random_initializer=False):
    """
      Загружаем из pickle веса в модель(из функции build_model_lstm()) как обученную,
      если указан параметр-имя файла fdump, если нет выдаем модель для compile/fit.
    """
    model = build_model_lstm(period_n_X, n_vars_X, n_out_Y, random_initializer)
    if fdump:
        params = {}
        with open(fdump, 'rb') as f:
            params = pickle.load(f)
        len_layers = len(model.layers)
 
        for i in range(len_layers):
            model.layers[i].set_weights(params[i])
 
        print('loaded learned model')
 
    return model
 
 
def pass_window_ver1(n_past, n_future, common_data_2D_matr: np.ndarray):
    """
     pass_window_ver1() и  pass_window_ver2()
     в основном смоделированы для одновариантого time-siries-forecasing.
     Persistant look back forward - непрерывный 
     анализ временного ряда
    """
    trainX = []
    trainY = []
    height_common_data = common_data_2D_matr.shape[0]
    width_common_data = common_data_2D_matr.shape[1]
 
    for i in range(n_past, height_common_data - n_future + 1):
        trainX.append(common_data_2D_matr[i - n_past:i, 0:width_common_data])
        trainY.append(
            common_data_2D_matr[i:i + n_future, 0]
        )  
 
    trainX, trainY = np.array(trainX), np.array(trainY)
 
    print('trainX shape == {}.'.format(trainX.shape))
    print('trainY shape == {}.'.format(trainY.shape))
 
    return trainX, trainY
 
 
# не используется
def pass_window_ver2(n_past, common_data_2D_matr: np.ndarray, lag=1):
    """
      pass_window_ver1() и  pass_window_ver2()
      в основном смоделированы для одновариантого time-siries-forecasing  
    """
 
    height_common_data = common_data_2D_matr.shape[0]
    width_common_data = common_data_2D_matr.shape[1]
 
    trainX = []
    trainY = []
 
    for i in range(n_past, height_common_data, lag):
        trainX.append(common_data_2D_matr[i - n_past:i, 0:width_common_data])
        trainY.append(common_data_2D_matr[i - n_past:i + 1, 0])
 
    trainX, trainY = np.array(trainX), np.array(trainY)
 
    print('trainX shape == {}.'.format(trainX.shape))
    print('trainY shape == {}.'.format(trainY.shape))
 
    return trainX, trainY
 
 
# /не используется
 
 
def learn(epochs, batch_size=3, validation_split=0.10):
    trainX, trainY = pass_window_ver1(n_past, n_future,
                                      np_train_common_data_2Dmatr_scaled)
    vars_n_X = trainX.shape[2]
    model = make_lstm(n_past, vars_n_X, n_past + 1)
 
    model.compile(optimizer='adam', loss='mse')
    model.summary()
 
    history = model.fit(
        trainX,
        trainY,
        epochs=epochs,
        batch_size=batch_size,
        validation_split=validation_split,
        verbose=1,
    )
    plt.plot(history.history['loss'], label='Training loss')
    plt.plot(history.history['val_loss'], label='Validation loss')
    plt.legend()
    plt.show()
    save_model(model)
 
# не используется
def predict_long_period_ver1(
        model,
        first_test_period,  # 3D matrix
        n_periods):
    """
       Должна работать на своих же предсказаниях
       Для модели сети которая выдает не меньше выходов чем приняла входов.
    """
    scaler_test = StandardScaler()
    scaler_test.fit(first_test_period[0])
    first_test_period_scaled = scaler_test.transform(first_test_period[0])
    scales = []
 
    n_past = first_test_period.shape[1]
    y_pred = [None] * n_periods
    for i in range(n_periods):
        if i == 0:
            scaler_test.fit(first_test_period[0])
            first_test_period_scaled = scaler_test.transform(
                first_test_period[0])
            scales.append(
                np.mean(scaler_train.scale_) + np.mean(scaler_test.scale_)
            )  # накапливаем масштабы + задействуем скэляры train периода
            scales.append(
                np.mean(scaler_train.mean_) + np.mean(scaler_test.mean_))
            answer = model.predict(np.array([first_test_period_scaled]))
            answer = answer * scales[-2] + scales[-1]
            y_pred[i] = answer
 
        else:
            last_answer = y_pred[i - 1]
            np_last_answer = np.array([last_answer])
            scaler_test.fit(np_last_answer[0])
            scales.append(scales[-2] +
                          np.mean(scaler_test.scale_))  # накапливаем масштабы
            scales.append(scales[-1] + np.mean(scaler_test.mean_))
            np_last_answer = scaler_test.transform(np_last_answer[0])
            np_last_answer_reshaped = np_last_answer.reshape(1, n_past + 1, 1)
            np_last_answer_slice = np_last_answer_reshaped[:, -n_past:, :]
            answer = model.predict(np_last_answer_slice)
            answer = answer * scales[-2] + scales[-1]
            y_pred[i] = answer
# /не используется            
 
 
 
# %%
# для Рис.1  gr_predict_2_tochki.png
# Модель обучалась с сигмойдой на конце, данные стандартно нормализировались
 
model = make_lstm(n_past, 1, 1, fdump='learned.pkl')
np_for_testing = test
np_X_for_forecast = np_for_testing
np_real_all_periods = np_for_testing
y_pred = []
scaler_test = StandardScaler()
scaler_test.fit(np_X_for_forecast)
np_X_for_forecast_scaled = scaler_test.transform(np_X_for_forecast)
testX, _ = pass_window_ver1(n_past, n_future, np_X_for_forecast_scaled, lag=5) # получаем окна из нормализированных данных 
 
Y = test
Y_flatten = Y.flatten()
test_X_height = testX.shape[0]
for i in range(test_X_height):
    prediction = model.predict(np.array([testX[i]]))
    prediction_amount = prediction[0][0] *\
    scaler_train.scale_[0] +\
    scaler_train.mean_[0]
    y_pred.append(prediction_amount)
 
fig = plt.figure(figsize=(10.0, 10.0))
ax = fig.add_subplot()
fig.suptitle('''Насколько точна ИНС модель для шампуня''')
ax.set_xlabel('месяца')
ax.set_ylabel('количество бутылок')
 
ax.plot(Y_flatten, 'r-', label='real sales')
 
x_predicted_months = (n_past + 1, 2 * n_past + 1)
ax.plot(x_predicted_months, y_pred, 'g<', label='predicted sales by 5 months')
ax.legend()
plt.show()
 
# %%
# learn(150)
# для Рис.2 gr_predict_2_tochki_relu_na_konce.png
# Модель обучалась с relu на конце, данные стандартно не нормализировались
# Для Рис. gr_learn_relu_na_konce
    #     Epoch 150/150
    # 9/9 [==============================] - 0s 21ms/step - loss: 4137.4956 - val_loss: 8881.5879
model = make_lstm(n_past, 1, 1, fdump='learned.pkl')
np_for_testing = test
np_X_for_forecast = np_for_testing
np_real_all_periods = np_for_testing
y_pred = []
testX, _ = pass_window_ver1(n_past, n_future, np_X_for_forecast, lag=5) # получаем окна из не нормализированных данных 
 
Y = test
Y_flatten = Y.flatten()
test_X_height = testX.shape[0]
for i in range(test_X_height):
    prediction = model.predict(np.array([testX[i]]))
    prediction_amount = prediction[0][0] 
    y_pred.append(prediction_amount)
 
fig = plt.figure(figsize=(10.0, 10.0))
ax = fig.add_subplot()
fig.suptitle('''Насколько точна ИНС модель для продажи шампуня по месяцам''')
ax.set_xlabel('месяца')
ax.set_ylabel('количество бутылок')
 
ax.plot(Y_flatten, 'r-', label='real sales')
 
x_predicted_months = (n_past + 1, 2 * n_past + 1)
ax.plot(x_predicted_months, y_pred, 'g<', label='predicted sales by 5 months')
ax.legend()
plt.show()
 
 
# %%