Séries temporelles

Fonctions :

• Séries temporelles (exemple)

  Les LSTM (Long Short-Term Memory) sont des réseaux de neurones récurrents conçus pour modéliser des séquences de données, comme les séries temporelles. Ils permettent de prédire les valeurs futures en tenant compte des dépendances passées à long terme.

  Importation :

  import numpy as np
  import tensorflow as tf
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import LSTM, Dense

  Attributs :

  Paramètre	Type	Description	Valeur par défaut
  texts	list[str]	Liste des textes à analyser ou à prédire.	—
  max_length	int	Longueur maximale des séquences de tokens après padding.	100
  model	tf.keras.Model	Modèle de deep learning entraîné pour la tâche NLP (ex : classification de texte).	—

  Exemple de code :

  📋 Copy

  import numpy as np
  import tensorflow as tf
  from tensorflow.keras.models import Sequential
  from tensorflow.keras.layers import LSTM, Dense
  
  # Génération d'une sinusoïde
  t = np.linspace(0, 10, 100)
  data = np.sin(t)
  
  # Création d'un dataset glissant
  def create_dataset(series, window_size=5):
      X, y = [], []
      for i in range(len(series) - window_size):
          X.append(series[i:i+window_size])
          y.append(series[i+window_size])
      return np.array(X), np.array(y)
  
  window_size = 5
  X, y = create_dataset(data, window_size)
  X = X.reshape((X.shape[0], X.shape[1], 1))
  
  # Construction du modèle
  model = Sequential()
  model.add(LSTM(units=50, input_shape=(window_size, 1)))
  model.add(Dense(1))
  
  model.compile(optimizer='adam', loss='mse')
  model.fit(X, y, epochs=50, verbose=0)
  
  # Prédiction d'une valeur
  last_sequence = data[-window_size:].reshape(1, window_size, 1)
  predicted = model.predict(last_sequence)
  
  print(f"Valeur prédite : {predicted[0][0]}")
  

  Explication du code :

  Importation des bibliothèques
  import numpy as np : Manipulation de tableaux numériques.
  import tensorflow as tf : Framework de deep learning.
  from tensorflow.keras.models import Sequential : Création d’un modèle séquentiel.
  from tensorflow.keras.layers import LSTM, Dense : Couches LSTM et entièrement connectées.
  
  Génération de données
  t = np.linspace(0, 10, 100) : Crée un vecteur temps.
  data = np.sin(t) : Génère une sinusoïde simulant une série cyclique.
  
  Préparation des données
  create_dataset() : Crée des paires (X, y) où X = séquence de 5 pas et y = valeur suivante.
  reshape() : Redimensionne X pour l’adapter au format (samples, time_steps, features) requis par LSTM.
  
  Création du modèle
  Sequential() : Empile les couches.
  LSTM(50) : 50 neurones mémoire pour apprendre la dynamique temporelle.
  Dense(1) : Neurone de sortie pour prédire une valeur unique.
  compile() : Spécifie l’optimiseur (Adam) et la fonction de perte (MSE).
  fit() : Entraîne le modèle pendant 50 époques.
  
  Prédiction
  last_sequence : Derniers points de la série pour prédiction.
  predict() : Calcule la valeur suivante attendue.