Discussion :

[mim2284]

Bonjour tout le monde

J'ai suivi l'exemple de: https://machinelearningmastery.com/m...g-lstms-keras/ L'exemple prédit la pollution à l'instant t et prédit également les observations (à l'instant t TEMP, PRESS,etc..) en mon cas je veux prendre en considération les observations à l'instant t je veux juste prévoir la pollution Que dois-je modifier dans mon exemple.?

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
dataset = read_csv('tt.csv',  parse_dates = ['date'], index_col=0)
#dataset.drop('No', axis=1, inplace=True)
# manually specify column names
#dataset.columns = ['pollution', 'dew', 'temp', 'press', 'wnd_dir', 'wnd_spd', 'snow', 'rain']
dataset.index.name = 'date'
print(dataset.head(5))
# save to file
dataset.to_csv('((ttt.csv')))
# load dataset
dataset = read_csv('tt', header=0, index_col=0)
values = dataset.values
 
# convert series to supervised learning
def series_to_supervised(data, n_in=1, n_out=1, dropnan=True):
    n_vars = 1 if type(data) is list else data.shape[1]
    df = DataFrame(data)
    cols, names = list(), list()
    # input sequence (t-n, ... t-1)
    for i in range(n_in, 0, -1):
        cols.append(df.shift(i))
        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]
    # forecast sequence (t, t+1, ... t+n)
    for i in range(0, n_out):
        cols.append(df.shift(-i))
        if i == 0:
            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]
        else:
            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]
    # put it all together
    agg = concat(cols, axis=1)
    agg.columns = names
    # drop rows with NaN values
    if dropnan:
        agg.dropna(inplace=True)
    return agg
# ensure all data is float
values = values.astype('float32')
# normalize features
scaler = MinMaxScaler(feature_range=(0, 1))
scaled = scaler.fit_transform(values)
# frame as supervised learning
reframed = series_to_supervised(scaled, 1, 1)
# drop columns we don't want to predict
#reframed.drop(reframed.columns[[9,10,11,12,13,14,15]], axis=1, inplace=True)
print(reframed.head())
values = reframed.values
n_train_hours =160
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
test_X = test_X.reshape((test_X.shape[0],1, test_X.shape[1]))
print(train_X.shape, train_y.shape, test_X.shape, test_y.shape)
print(train_X.shape[1], train_X.shape[2]) 
model = Sequential()
model.add(LSTM(units=15,return_sequences=True, input_shape=(train_X.shape[1], train_X.shape[2])))
model.add(Dropout(rate=0.2))
model.add(LSTM(units=15,return_sequences=True))
model.add(Dropout(rate=0.2))
model.add(LSTM(units=15,return_sequences=False))
model.add(Dropout(rate=0.2))
model.add(Dense(1,activation="sigmoid"))
model.compile( loss="binary_crossentropy", optimizer="adam", metrics=["accuracy"])
# fit network
history = model.fit(train_X, train_y, epochs=100, batch_size=20, validation_split=0.1, verbose=1, shuffle=False)

[dev_ggy]

Bonjour,

Nous aurions besoin d'information sur les messages d'erreurs si c'est le cas lors de la compilation.

Pour ce qui est de la fonction Dropout, je suis surpris qu'elle s'applique aussi aux réseaux LSTM, je pensais peut-être à tort que c'était un des éléments uniquement des réseaux de convolution.

Cordialement,

[mim2284]

Bonjour, Merci d'avance pour votre aide j'ai été bloquée quant j'ai vu votre message vous n'imaginez pas ma joie.Aidez moi svp
en fait j'ai changé mon programme posté par ceux-ci.
Mon probléme est ainsi:monfichier excel contient 7 variables var1, var2,...,var7,valeur sortie(qui vaut 0/1) je veux prédire la valeur de sortie à l'instant t mais en prenant en considération les valeurs de (var1,...,var7) à l'instant t, même si mon programme me donne une accuracy de 99.98% je ne sais pas si il est correct j'ai l'impression qu'il ressemble à un ANN.

Mes question si vous le permettez
1-est ce que les entrées de mon modèles sont correctes et le timestemp je ne sais pas dans mon cas , c'est quoi?
2-j'ai utilisé le dropout pour ne pas avoir de overfitting( vu que j'ai eu 99.89% en faisant une prédictiion sur les valeurs test)

Code Python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
def create_dataset(dataset, look_back):
    dataX, dataY = [], []
    for i in range(len(dataset) - look_back - 1):
        a = dataset[i:(i + look_back), 0:7]
        dataX.append(a)
        dataY.append(dataset[i + look_back, 7])
    return numpy.array(dataX), numpy.array(dataY)
 
 
 
# fix random seed for reproducibility
 
# load the dataset
dataframe = pandas.read_csv('dataf.csv', engine='python') 
dataset = dataframe.values
# normalize the dataset
scaler = MinMaxScaler(feature_range=(0, 1))
dataset = scaler.fit_transform(dataset)
 
# split into train and test sets
train_size = int(len(dataset) * 0.67) 
test_size = len(dataset) - train_size
train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :]
 
# reshape into X=t and Y=t+1
look_back = 7
trainX, trainY = create_dataset(train, look_back)  
testX, testY = create_dataset(test, look_back)
 
# reshape input to be  [samples, time steps, features]
trainX = numpy.reshape(trainX, (trainX.shape[0], look_back, 7))
testX = numpy.reshape(testX, (testX.shape[0],look_back, 7))
 
# create and fit the LSTM network
from keras.layers import Dense
from keras.layers import Dropout
model1 = tf.keras.Sequential()
model1.add(tf.keras.layers.LSTM(units=50,return_sequences=True, input_shape=(look_back,7)))
model1.add(tf.keras.layers.Dropout(rate=0.2))
model1.add(tf.keras.layers.LSTM(units=50,return_sequences=False))
model1.add(tf.keras.layers.Dropout(rate=0.2))
model1.add(tf.keras.layers.Dense(1,activation="sigmoid"))
model1.compile(loss='binary_crossentropy', optimizer='adam',metrics=['accuracy'])
history1= model1.fit(trainX, trainY, epochs=50, batch_size=20,callbacks=[tf.keras.callbacks.TensorBoard(log_dir="logs\{}".format("LSTM"), histogram_freq=1, profile_batch = 100000000)])

voici un bout de mon fichier

[dev_ggy]

Bonjour,

Concernant le modèle en dehors du point que j'ai soulevé au sujet du Dropout, mais pour lequel je reste un peu ignorant, je trouve votre modèle correct.

Le TimeStamp c'est à vous de le construire et de connaitre vos données, il peut corresponde à une date, mais cela peut aussi être un Id. Dans votre cas on a l'impression que vous travaillez une fréquence 7 qui peut correspondre à une semaine de données.

Pour corriger l'Overfit, si vous avez peur d'être en surapprentissage qui peut être dû au peu de données, vous pouvez perturber celle-ci pour créer un nombre de données beaucoup plus grandes.

Bien cordialement,

[mim2284]

Bonjour,

je ne sais comment vous remercier, vous m'avez rassurer juste une serniére question si j'applique ce modéle sur un Simple RNN et un GRU et un LSTM ; lequel selon vous va me donner le bon resulat , lorque j'ai appliqué le même modèle GRU sur des données test il m'a donné plus de precision moins de fonction loss aprés le Simple RNN et a la fin le LSTM.
normalment le LSTM doit plus performé que le Simple RNN

Lorsque j'ai appliqué les autres modèles(j'ai juste remplacé le mot LSTM par GRU et par Simple RNN)

Merci encore une fois

[dev_ggy]

Bonsoir,

Concernant le choix du modèle, on peut comparer les différents modèles qui peuvent avoir des performances différentes selon les données.

Un algorithme qui parait meilleur peut avoir de moindre performance sur certains types de données.

Bien cordialement,

[mim2284]

merci beacoup

[deep_learning]

Bonjour à tous,

Je souhaite concaténer deux modèles biLstm, mais je trouve toujours des difficultés surtout au niveau model.summary():
model1 = Sequential()
model1.add(Embedding(vocab_size, 10, input_length=1))
model1.add(Bidirectional(LSTM(50)))
model1.add(Dense(vocab_size, activation='softmax'))
model1.add(Dense(vocab_size))

model2 = Sequential()
model2.add(Embedding(vocab_size, 10, input_length=1))
model2.add(Bidirectional(LSTM(50)))
model2.add(Dense(vocab_size, activation='softmax'))
model2.add(Dense(vocab_size))


model = Sequential()
model.add(Concatenate([model1,model2]))
model.add(Flatten())
model.add(Dense(vocab_size, activation='linear'))

model.summary()


Un erreur s'affiche:
This model has not yet been built. Build the model first by calling `build()` or by calling the model on a batch of data.

Merci d'avance!