MobileNet et EfficientNet pour le déploiement en périphérie
Architectures légères, conversion vers TFLite, compromis entre taille du modèle et précision.
MobileNet et EfficientNet pour le déploiement en périphérie est une leçon Learn AI with Python gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn AI with Python, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn AI with Python comprend 4 leçons au total.
Pourquoi les modèles en périphérie sont différents
Sur les téléphones et les appareils embarqués, vous sacrifiez une partie de la précision au profit d’une taille minuscule, d’une faible latence et d’une faible consommation d’énergie. MobileNet et EfficientNet sont conçus exactement pour cela : ils utilisent des blocs de construction efficaces plutôt que de lourdes convolutions denses.
Convolutions en profondeur de MobileNet
MobileNet remplace les convolutions standard par des convolutions séparables en profondeur : un filtre spatial appliqué à chaque canal, suivi d’un mélange ponctuel 1x1. Cela réduit les calculs et le nombre de paramètres d’environ 8 à 9 fois, avec une faible perte de précision.
MobileNetV3Small
MobileNetV3Small est optimisé pour les appareils mobiles : environ 2,5 Mo de poids, ce qui le rend idéal lorsque l’espace de stockage et la RAM sont limités.
from tensorflow.keras.applications import MobileNetV3Small
base = MobileNetV3Small(
weights="imagenet",
include_top=False,
input_shape=(224, 224, 3)
)EfficientNetB0
EfficientNetB0 utilise une mise à l’échelle composée pour équilibrer la profondeur, la largeur et la résolution. Il offre une excellente précision compte tenu de sa taille et constitue un bon compromis entre les réseaux mobiles très compacts et les modèles lourds destinés aux serveurs.
from tensorflow.keras.applications import EfficientNetB0
base = EfficientNetB0(
weights="imagenet",
include_top=False,
input_shape=(224, 224, 3)
)Choisir entre ces modèles
- MobileNetV3Small (~2,5 Mo) : le plus petit et le plus rapide, mais aussi celui dont la précision est la plus faible. Idéal pour le mobile en temps réel.
- EfficientNetB0 : compromis équilibré entre précision et taille. Idéal lorsque vous pouvez consacrer un peu plus de puissance de calcul.
Choisissez selon le budget de latence de votre appareil et votre objectif de précision.
Construire la tête de transfert
La méthode d’apprentissage par transfert est identique : geler la base, effectuer une mise en commun, puis ajouter une tête Dense.
from tensorflow.keras import layers, Model
base.trainable = False
x = layers.GlobalAveragePooling2D()(base.output)
x = layers.Dropout(0.2)(x)
out = layers.Dense(num_classes, activation="softmax")(x)
model = Model(base.input, out)Qu’est-ce que TFLite ?
TensorFlow Lite est un environnement d’exécution pour l’inférence sur appareil. Vous convertissez un modèle Keras entraîné en un flatbuffer .tflite compact, qui s’exécute efficacement sur les processeurs, processeurs graphiques et NPU mobiles.
Conversion TFLite
Utilisez TFLiteConverter pour convertir le modèle enregistré.
import tensorflow as tf
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open("model.tflite", "wb") as f:
f.write(tflite_model)La quantification réduit encore la taille
La quantification après entraînement stocke les poids en int8 plutôt qu’en float32, ce qui réduit la taille d’environ 4 fois et accélère l’inférence sur le matériel mobile, avec une perte de précision minimale.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_quant = converter.convert()Tests de latence
Sur un matériel mobile courant, MobileNetV3Small s’exécute souvent en quelques millisecondes à une dizaine de millisecondes par image, ce qui convient largement au temps réel. EfficientNetB0 est plus lourd et plus lent, mais plus précis.
Effectuez toujours les mesures sur l’appareil réellement ciblé ; les temps mesurés dans un émulateur ne sont pas fiables. Utilisez l’outil de mesure TFLite ou mesurez le temps d’exécution de l’Interpreter avec invoke().
Exécuter une inférence avec TFLite
Chargez le modèle avec l’Interpreter, définissez le tenseur d’entrée, invoquez-le, puis lisez la sortie.
interpreter = tf.lite.Interpreter(model_path="model.tflite")
interpreter.allocate_tensors()
inp = interpreter.get_input_details()[0]
out = interpreter.get_output_details()[0]
interpreter.set_tensor(inp["index"], image)
interpreter.invoke()
print(interpreter.get_tensor(out["index"]))Vérification rapide
Testez vos connaissances sur le déploiement en périphérie.
Récapitulatif
Vous avez comparé MobileNetV3Small (~2,5 Mo, le plus rapide) et EfficientNetB0 (équilibré) pour une utilisation en périphérie, construit des têtes de transfert à partir de ces modèles, effectué la conversion vers TFLite, appliqué une quantification int8 et mesuré la latence sur du matériel réel. Le cours d’apprentissage par transfert est ainsi terminé. Cours suivant : analyse des séries temporelles.
Questions Fréquemment Posées
La leçon « MobileNet et EfficientNet pour le déploiement en périphérie » est-elle gratuite ?
Oui — le texte complet de « MobileNet et EfficientNet pour le déploiement en périphérie » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn AI with Python, passe à CoddyKit PRO. Le cours Learn AI with Python comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « MobileNet et EfficientNet pour le déploiement en périphérie » ?
Architectures légères, conversion vers TFLite, compromis entre taille du modèle et précision. Tu pratiques Learn AI with Python avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Learn AI with Python ?
Aucune expérience préalable n'est requise. Learn AI with Python sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.
Combien de temps prend la leçon « MobileNet et EfficientNet pour le déploiement en périphérie » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Learn AI with Python ?
Oui. Chaque leçon Learn AI with Python inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Concepts et stratégies de l’apprentissage par transfert
- Utiliser VGG16 et ResNet50 comme modèles de base
- Ajustement fin : dégel et réentraînement
- MobileNet et EfficientNet pour le déploiement en périphérie