Voici mon code:

# Library Imports
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.preprocessing import MinMaxScaler
plt.style.use("ggplot")

from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout

# Loading/Reading in the Data
df = pd.read_csv("BTC-USD.csv")


# Data Preprocessing
### Setting the datetime index as the date, only selecting the 'Close' column, then only the last 1000 closing prices.
df = df.set_index("Date")[['Close']].tail(3000)
df = df.set_index(pd.to_datetime(df.index))

# Normalizing/Scaling the Data
scaler = MinMaxScaler()
df = pd.DataFrame(scaler.fit_transform(df), columns=df.columns, index=df.index)


def visualize_training_results(results):
    """
    Plots the loss and accuracy for the training and testing data
    """
    history = results.history
    plt.figure(figsize=(12,4))
    plt.plot(history['val_loss'])
    plt.plot(history['loss'])
    plt.legend(['val_loss', 'loss'])
    plt.title('Loss')
    plt.xlabel('Epochs')
    plt.ylabel('Loss')
    plt.show()
    
    plt.figure(figsize=(12,4))
    plt.plot(history['val_accuracy'])
    plt.plot(history['accuracy'])
    plt.legend(['val_accuracy', 'accuracy'])
    plt.title('Accuracy')
    plt.xlabel('Epochs')
    plt.ylabel('Accuracy')
    plt.show()
    
    
def split_sequence(seq, n_steps_in, n_steps_out):
    """
    Splits the univariate time sequence
    """
    X, y = [], []
    
    for i in range(len(seq)):
        end = i + n_steps_in
        out_end = end + n_steps_out
        
        if out_end > len(seq):
            break
        
        seq_x, seq_y = seq[i:end], seq[end:out_end]
        
        X.append(seq_x)
        y.append(seq_y)
    
    return np.array(X), np.array(y)


def layer_maker(n_layers, n_nodes, activation, drop=None, d_rate=.5):
    """
    Create a specified number of hidden layers for an RNN
    Optional: Adds regularization option, dropout layer to prevent potential overfitting if necessary
    """
    
    # Creating the specified number of hidden layers with the specified number of nodes
    for x in range(1,n_layers+1):
        model.add(LSTM(n_nodes, activation=activation, return_sequences=True))

        # Adds a Dropout layer after every Nth hidden layer (the 'drop' variable)
        try:
            if x % drop == 0:
                model.add(Dropout(d_rate))
        except:
            pass

# How many periods looking back to train
n_per_in  = 30

# How many periods ahead to predict
n_per_out = 10

# Features (in this case it's 1 because there is only one feature: price)
n_features = 1

# Splitting the data into appropriate sequences
X, y = split_sequence(list(df.Close), n_per_in, n_per_out)

# Reshaping the X variable from 2D to 3D
X = X.reshape((X.shape[0], X.shape[1], n_features))

# Instantiating the model
model = Sequential()

# Activation
activ = "softsign"

# Input layer
model.add(LSTM(30, activation=activ, return_sequences=True, input_shape=(n_per_in, n_features)))

# Hidden layers
layer_maker(n_layers=6, n_nodes=12, activation=activ)

# Final Hidden layer
model.add(LSTM(10, activation=activ))

# Output layer
model.add(Dense(n_per_out))

# Model summary
model.summary()

plt.figure(figsize=(12,5))


#Im compiling the code here before training
model.compile()
#visualize_training_results(res)
res = model.fit(X, y, epochs=800, batch_size=32, validation_split=0.1)
#visualize_training_results(res)

Que dois-je faire exactement ici pour pouvoir commencer à entraîner mon modèle?

J'ai également essayé ce code pour compiler:

model.compile(
    optimizer='adam',
    loss='mean_squared_error',
    metrics=[
        metrics.MeanSquaredError(),
        metrics.AUC(),
    ]
)

Mais quand j'exécute cela, j'obtiens une erreur de métrique non définie. Même si je le définis ici même dans la fonction de compilation?

Et j'ai aussi fait

model.compile(loss='categorical_crossentropy', optimizer='adam')

Qui démarre la formation mais j'obtiens cette sortie

Epoch 6/800
10/10 [==============================] - 1s 53ms/step - loss: nan - val_loss: nan
Epoch 7/800
10/10 [==============================] - 0s 43ms/step - loss: nan - val_loss: nan

Et quand je fais ça:

model.compile(loss='categorical_crossentropy',
              optimizer='sgd',
              metrics=['accuracy'])

Je reçois cette sortie

0/10 [==============================] - 0s 49ms/step - loss: nan - accuracy: 0.1128 - val_loss: nan - val_accuracy: 0.0606
Epoch 121/800
10/10 [==============================] - 0s 48ms/step - loss: nan - accuracy: 0.1086 - val_loss: nan - val_accuracy: 0.0606

Il s'entraîne et la précision fonctionne, mais je reçois toujours nan pour la perte et val_loss

Peu importe les paramètres de la fonction de compilation, j'utilise cette chose ne calcule pas la perte

Maintenant j'ai essayé ça

model.compile(
    optimizer='adam',
    loss='mean_squared_error',
    metrics=["accuracy"],
)

Et c'est ce que je reçois

10/10 [==============================] - 1s 74ms/step - loss: nan - accuracy: 0.0953 - val_loss: nan - val_accuracy: 0.0606
Epoch 5/800
10/10 [==============================] - 1s 74ms/step - loss: nan - accuracy: 0.1097 - val_loss: nan - val_accuracy: 0.0606
Epoch 6/800
10/10 [==============================] - 1s 72ms/step - loss: nan - accuracy: 0.0929 - val_loss: nan - val_accuracy: 0.0606
-1
joe blow 14 mars 2021 à 23:28

1 réponse

Meilleure réponse

Il existe de nombreuses raisons pour lesquelles vous pouvez obtenir des NaN lors de l'entraînement de votre modèle.

  • les données
  • fonction de perte renvoyant plus grand / plus petit que + infini / -infini

Essayez de prendre 20 lignes, assurez-vous de regarder chaque ligne vous-même avec vos yeux très hooman, puis exécutez le code pour voir si vous obtenez toujours des NAN. Si vous ne le faites pas, il peut y avoir 1 à 2 entrées corrompues. Sinon, regardez ce que split_sequence renvoie lorsque vous n'utilisez que ces 20 colonnes.

Ensuite, il y a le problème de l'infini, qui conduit aux NAN. Essayez d'utiliser des fonctions de perte qui sont bornées.

Voici une liste des fonctions de perte Keras

Alors que l'écart quadratique moyen renvoie une valeur qui "représente l'erreur de manière naturelle par rapport aux données d'entrée" i.e. RMSE 30'000 <=> error in estimating house price by 30'000$, il calcule toujours le carré, qui peut certainement aller trop vite à l'infini, donc ce n'est pas une solution si c'est le problème ici. Vous pouvez utiliser le MAE pour le maintenir bas.

MISE À JOUR:

Cela a fonctionné pour moi. J'ai utilisé ce qui suit, ainsi qu'un ensemble de données similaire pour une autre pièce cryptoboy aux États-Unis:

# The good old SGD and MAE. 
model.compile(optimizer="sgd", loss="mae") # optional: metrics=['accuracy']

Soyez prudent lorsque vous utilisez Adams / Huber ou d'autres fonctions d'optimisation / perte. Vous devez comprendre comment ils fonctionnent, au moins savoir comment et pourquoi nous les utilisons. Désormais, utiliser le SGD n'est pas le meilleur, mais à partir de là, vous disposez d'une base saine pour commencer.

Bonne chance dans votre entreprise! Ne sur-ajustez pas, créez un petit modèle avec de minuscules ensembles de données pour vous entraîner rapidement et prototyper avant d'exécuter 800 époques uniquement pour découvrir qu'un paramètre n'était pas viable! PROTO-TYPE ! L'avenir vous remerciera! :)

1
Florian Fasmeyer 14 mars 2021 à 23:59