Optimisation du modèle IA

Fonctions :

• Optimisation du modèle IA (exemple)

  Exemple de code :

  📋 Copy

  from flask import Flask, jsonify
  import tensorflow as tf
  import numpy as np
  
  app = Flask(__name__)
  
  # Chargement d'un modèle simple (exemple)
  model = tf.keras.Sequential([
      tf.keras.layers.Dense(16, activation='relu', input_shape=(4,)),
      tf.keras.layers.Dense(3, activation='softmax')
  ])
  
  # Compilation du modèle pour l'inférence rapide
  model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
  
  # Simulation d'entraînement rapide pour l'exemple
  X_train = np.random.random((10, 4))
  y_train = np.random.randint(0, 3, 10)
  model.fit(X_train, y_train, epochs=1, verbose=0)
  
  # Route pour faire une prédiction optimisée
  @app.route('/predict')
  def predict():
      sample_input = np.random.random((1, 4))
      prediction = model.predict(sample_input)
      return jsonify(prediction.tolist())
  
  if __name__ == "__main__":
      app.run(debug=True)

  Explication du code :

  from flask import Flask, jsonify importe la classe Flask pour créer l’application web et jsonify pour renvoyer des données au format JSON.
   
  import tensorflow as tf importe la bibliothèque TensorFlow pour créer et manipuler le modèle IA.
   
  import numpy as np importe NumPy pour gérer les données sous forme de tableaux (arrays) nécessaires à l’entraînement et aux prédictions.
  Créer l’application Flask
   
  app = Flask(__name__) crée une instance de l’application Flask.
   
  Créer un modèle IA simple
   
  model = tf.keras.Sequential([...]) crée un modèle séquentiel avec :
   
   
  Une première couche Dense de 16 neurones avec activation relu et input_shape=(4,).
   
  Une deuxième couche Dense de 3 neurones avec activation softmax, adaptée pour classification à 3 classes.
   
   
  Compiler le modèle pour l’optimisation
   
  model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) configure le modèle pour l’inférence rapide :
   
   
  optimizer='adam' : algorithme pour optimiser les poids.
   
  loss='sparse_categorical_crossentropy' : fonction de perte adaptée à la classification multi-classes.
   
  metrics=['accuracy'] : permet de suivre la précision du modèle.
   
   
  Simulation d’entraînement rapide
   
  X_train = np.random.random((10, 4)) crée un tableau de 10 échantillons avec 4 caractéristiques aléatoires.
   
  y_train = np.random.randint(0, 3, 10) crée 10 labels aléatoires pour 3 classes.
   
  model.fit(X_train, y_train, epochs=1, verbose=0) entraîne le modèle sur ces données pour 1 époque, sans afficher de détails.
   
  Définir la route de prédiction
   
  @app.route('/predict') crée une route accessible à /predict.
   
  sample_input = np.random.random((1, 4)) génère un nouvel exemple aléatoire pour la prédiction.
   
  prediction = model.predict(sample_input) calcule la prédiction du modèle sur cet exemple.
   
  return jsonify(prediction.tolist()) renvoie la prédiction au format JSON.
   
  Lancer l’application Flask
   
  if __name__ == "__main__": vérifie que le fichier est exécuté directement et non importé comme module.
   
  app.run(debug=True) démarre le serveur Flask en mode debug, permettant le rechargement automatique du code et l’affichage des erreurs détaillées.