Pour modéliser un phénomène dans le domaine de l’edge AI, nous pouvons utiliser un réseau de neurones convolutifs (CNN) pour une tâche de classification d’images. L’edge AI implique l’exécution de modèles d’IA directement sur des appareils à la périphérie du réseau, tels que des smartphones ou des capteurs, afin de réduire la latence et d’améliorer la confidentialité des données.
Voici un exemple de code Python pour entraîner un modèle CNN sur un dataset d’images à l’aide de TensorFlow et Keras. Ce code est conçu pour être exécuté sur un appareil edge.
« `python
import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
# Paramètres du modèle
input_shape = (64, 64, 3)
num_classes = 10
# Charger les données
datagen = ImageDataGenerator(
rescale=1.0255.0,
validation_split=0.2
)
train_generator = datagen.flow_from_directory(
‘pathtotrain_data’,
target_size=input_shape[:2],
batch_size=32,
class_mode=’categorical’,
subset=’training’
)
validation_generator = datagen.flow_from_directory(
‘pathtotrain_data’,
target_size=input_shape[:2],
batch_size=32,
class_mode=’categorical’,
subset=’validation’
)
# Définir le modèle CNN
model = Sequential([
Conv2D(32, (3, 3), activation=’relu’, input_shape=input_shape),
MaxPooling2D((2, 2)),
Conv2D(64, (3, 3), activation=’relu’),
MaxPooling2D((2, 2)),
Conv2D(128, (3, 3), activation=’relu’),
MaxPooling2D((2, 2)),
Flatten(),
Dense(128, activation=’relu’),
Dense(num_classes, activation=’softmax’)
])
# Compiler le modèle
model.compile(
optimizer=’adam’,
loss=’categorical_crossentropy’,
metrics=[‘accuracy’]
)
# Entraîner le modèle
history = model.fit(
train_generator,
steps_per_epoch=train_generator.samples train_generator.batch_size,
epochs=10,
validation_data=validation_generator,
validation_steps=validation_generator.samples validation_generator.batch_size
)
# Enregistrer le modèle pour le déploiement sur l’edge
model.save(‘edge_model.h5’)
# Afficher les résultats de l’entraînement
import matplotlib.pyplot as plt
plt.plot(history.history[‘accuracy’], label=’accuracy’)
plt.plot(history.history[‘val_accuracy’], label=’val_accuracy’)
plt.xlabel(‘Epoch’)
plt.ylabel(‘Accuracy’)
plt.legend()
plt.show()
plt.plot(history.history[‘loss’], label=’loss’)
plt.plot(history.history[‘val_loss’], label=’val_loss’)
plt.xlabel(‘Epoch’)
plt.ylabel(‘Loss’)
plt.legend()
plt.show()
« `
### Explications du Code
1. Importations : Nous importons les bibliothèques nécessaires, notamment TensorFlow et Keras.
2. Paramètres du Modèle : Nous définissons la taille de l’entrée (64x64x3) et le nombre de classes (10).
3. Chargement des Données : Nous utilisons `ImageDataGenerator` pour charger et prétraiter les images. Les données sont divisées en ensembles d’entraînement et de validation.
4. Définition du Modèle : Nous définissons un modèle CNN séquentiel avec plusieurs couches de convolution et de pooling, suivies de couches de dense.
5. Compilation du Modèle : Nous compilons le modèle avec l’optimiseur Adam et la fonction de perte `categorical_crossentropy`.
6. Entraînement du Modèle : Nous entraînons le modèle sur les données d’entraînement et validons sur les données de validation.
7. Enregistrement du Modèle : Nous enregistrons le modèle entraîné pour un déploiement ultérieur sur un appareil edge.
8. Visualisation des Résultats : Nous affichons les courbes d’accuracy et de loss pour visualiser la performance du modèle.
Ce code est un point de départ pour modéliser un phénomène dans le domaine de l’edge AI. Vous pouvez ajuster les paramètres et les couches du modèle en fonction de vos besoins spécifiques.