La radiologie est un domaine qui dépend largement de l'expertise de professionnels hautement qualifiés. Les radiologues analysent les images médicales pour diagnostiquer et surveiller toute une gamme de pathologies, depuis les simples fractures jusqu'aux maladies complexes telles que le cancer. Pourtant, avec l’essor de l’imagerie médicale et le besoin urgent de diagnostics rapides et précis, les radiologues subissent une pression énorme. C’est là qu’intervient l’intelligence artificielle (IA), qui transforme le domaine en améliorant les capacités humaines. À la fin de cet article, vous aurez créé votre propre modèle de classificateur d’images pour vous aider à détecter la pneumonie dans les images médicales.  Étape 1 : configuration de votre environnement  Avant de nous lancer dans le codage, nous devons nous assurer que notre environnement est prêt. Nous allons commencer par installer les bibliothèques nécessaires :   %pip install --upgrade tensorflow keras numpy pandas sklearn pillow  Ces bibliothèques sont essentielles pour construire et entraîner notre modèle :    et   pour créer et entraîner des réseaux de neurones. tensorflow keras    pour les opérations numériques. numpy    pour la manipulation de données. pandas    pour le prétraitement des données. sklearn    pour le traitement de l'image. pillow  Étape 2 : Importer des bibliothèques  Une fois les bibliothèques installées, importons-les :   import os from tensorflow import keras from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Flatten from tensorflow.keras.preprocessing.image import ImageDataGenerator import numpy as np  Nous commençons par importer plusieurs bibliothèques et modules essentiels nécessaires à la création et à la formation d'un modèle de réseau neuronal pour les tâches de traitement d'image. Nous utiliserons TensorFlow et ses sous-modules pour créer et gérer nos modèles d'apprentissage en profondeur. Plus précisément, nous importerons Keras pour l'utiliser comme API de haut niveau, Sequential pour construire une pile linéaire de couches, et des modules tels que Dense, Conv2D, MaxPool2D et Flatten pour créer et configurer diverses couches de réseau neuronal. De plus, ImageDataGenerator nous aidera à augmenter nos données d'image, améliorant ainsi la capacité de généralisation du modèle. Enfin, nous importerons numpy pour sa prise en charge des opérations numériques, particulièrement utile pour gérer les tableaux et exécuter des fonctions mathématiques.  Étape 3 : préparation des données  Notre radiologue IA a besoin de données pour apprendre. Nous utiliserons ImageDataGenerator pour charger et augmenter nos données de formation et de validation : pour télécharger les données, nous utiliserons notre ami de données open source Kaggle, allez télécharger l'ensemble de données étiqueté à partir du   ici. lien  Dans le contexte de l’apprentissage supervisé ici, l’ensemble de données étiqueté sera la vérité terrain que le modèle d’apprentissage automatique est censé prédire.   trdata = ImageDataGenerator() traindata = trdata.flow_from_directory(directory="data-task1/train", target_size=(224, 224)) tsdata = ImageDataGenerator() testdata = tsdata.flow_from_directory(directory="data-task1/val", target_size=(224, 224))  Cet extrait de code configure des générateurs de données pour nos ensembles de données de formation et de validation. Les images sont redimensionnées à 224 x 224 pixels, la taille d'entrée standard pour le modèle VGG16.   Étape 4 : Création du modèle VGG16  Vient maintenant la partie amusante : construire le modèle VGG16. VGG16 est une architecture de réseau neuronal convolutif (CNN) populaire connue pour sa simplicité et son efficacité grâce à son architecture unique construite principalement sur 13 couches convolutives et 3 couches entièrement connectées. Ce qui distingue VGG16, c'est son utilisation de petits filtres convolutifs 3x3 au sein d'un réseau profond. Cette conception capture des motifs complexes dans les images tout en garantissant l’efficacité informatique. Voici comment nous le créons :   model = Sequential() model.add(Conv2D(input_shape=(224,224,3), filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=64, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=128, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=256, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(Conv2D(filters=512, kernel_size=(3,3), padding="same", activation="relu")) model.add(MaxPool2D(pool_size=(2,2), strides=(2,2))) model.add(Flatten()) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=4096, activation="relu")) model.add(Dense(units=2, activation="softmax")) model.summary()  Décomposons-le :    ce sont des couches convolutives qui apprennent à détecter des caractéristiques telles que les bords et les textures. Couches Conv2D :    celles-ci réduisent les dimensions spatiales, conservant les fonctionnalités importantes. Couches MaxPool2D :    cela convertit les cartes de caractéristiques 2D en un vecteur 1D. Aplatir le calque :    ce sont des couches entièrement connectées pour la classification. Couches denses :  Étape 5 : Compilation du modèle  Une fois notre architecture de modèle définie, nous devons la compiler :   opt = keras.optimizers.Adam(learning_rate=0.001) model.compile(optimizer=opt, loss=keras.losses.binary_crossentropy, metrics=['accuracy'])  Ici, nous utilisons l'optimiseur Adam avec un taux d'apprentissage de 0,001 et une entropie croisée binaire comme fonction de perte, adaptée aux tâches de classification binaire. Décomposons les avantages et les inconvénients de ces choix :   Composant   Avantages   Désavantages   Adam Optimiseur  1. Taux d'apprentissage adaptatifs 2. fonctionne bien avec les paramètres par défaut.  Potentiel de surajustement avec des modèles complexes.   Perte d'entropie croisée binaire  Idéal pour la classification binaire  pas très compatible avec ma fonction d'activation de couche de sortie, pourquoi ? (Laissez-le dans les commentaires!)  N'hésitez pas à expérimenter différents optimiseurs, taux d'apprentissage et fonctions de perte, car c'est un excellent moyen d'acquérir de l'expérience.  Étape 6 : Former le modèle  Il est temps de former notre radiologue IA ! Nous mettons en place des rappels pour enregistrer le meilleur modèle et nous arrêtons plus tôt si la précision de la validation cesse de s'améliorer :   from keras.callbacks import ModelCheckpoint, EarlyStopping checkpoint = ModelCheckpoint("vgg16_1.h5", monitor='val_accuracy', verbose=1, save_best_only=True, save_weights_only=False, mode='auto', period=1) early = EarlyStopping(monitor='val_accuracy', min_delta=0, patience=20, verbose=1, mode='auto') hist = model.fit_generator(steps_per_epoch=20, generator=traindata, validation_data=testdata, validation_steps=10, epochs=10, callbacks=[checkpoint, early])    enregistre le meilleur modèle en fonction de la précision de la validation. ModelCheckpoint :    arrête l'entraînement si les performances du modèle ne s'améliorent pas pendant un nombre spécifié d'époques.  EarlyStopping :  Étape 7 : Visualiser les progrès de la formation  Pour voir comment fonctionne notre modèle, nous pouvons tracer la perte et la précision de la formation et de la validation :   import matplotlib.pyplot as plt # Training loss plt.plot(hist.history['loss']) plt.legend(['Training']) plt.title('Training loss') plt.ylabel('loss') plt.xlabel('epoch') plt.show() # Validation loss plt.plot(hist.history['val_loss']) plt.legend(['Validation']) plt.title('Validation loss') plt.ylabel('validation loss') plt.xlabel('epoch') plt.show() # Training and validation accuracy plt.plot(hist.history['accuracy']) plt.plot(hist.history['val_accuracy']) plt.legend(['Training', 'Validation']) plt.title('Training & Validation accuracy') plt.xlabel('epoch') plt.show()  Ces graphiques nous aideront à comprendre dans quelle mesure notre modèle apprend et s'il est surajusté ou sous-ajusté.  Étape 8 : Faire des prédictions  Après la formation, notre radiologue IA est prêt à faire des prédictions. Voici comment charger une image et obtenir la prédiction du modèle :   from tensorflow.keras.preprocessing import image # Load and preprocess image img_path = 'path_to_your_image.jpg' img = image.load_img(img_path, target_size=(224, 224)) img_array = image.img_to_array(img) img_array = np.expand_dims(img_array, axis=0) # Create batch axis # Make prediction prediction = model.predict(img_array) print('Prediction:', prediction)  Étape 9 : mise au point et expérimentation  Construire un radiologue IA n’est que le début. Voici quelques conseils pour affiner et améliorer votre modèle :    augmentez la variété de vos données d'entraînement grâce à des techniques telles que la rotation, le retournement et le zoom. Augmentation des données :    utilisez des modèles pré-entraînés comme VGG16 comme point de départ et affinez-les sur votre ensemble de données spécifique. Transfert d'apprentissage :    expérimentez différents taux d'apprentissage, tailles de lots et optimiseurs pour trouver la meilleure combinaison.  Réglage des hyperparamètres :  Conclusion  Waouh, travail incroyable ! 🎉 Vous avez créé un modèle capable d'analyser des images médicales et de faire des prédictions : quelle belle réussite médicale ! :) En plongeant en profondeur dans les complexités des architectures de réseaux neuronaux, vous avez vu à quel point un modèle d'IA finement réglé peut avoir l'impact. Continuez à repousser les limites, continuez à expérimenter et, plus important encore, profitez de chaque instant de travail sur vos projets d'IA !

The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Cet audio est produit dans la langue originale de l'histoire !

Trop long; Pour lire

Make resilience your competitive advantage

Construire votre radiologue IA : un guide amusant pour créer un détecteur de pneumonie avec VGG16

About Author

COMMENTAIRES

ÉTIQUETTES

CET ARTICLE A ÉTÉ PARU DANS

Related Stories

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

Télégramme : le pont de Crypto Island vers le continent

Les couches invisibles : pourquoi les entretiens avec les utilisateurs sont un atout irremplaçable

Croissance des crypto-monnaies : créer des profils d'utilisateurs efficaces

Guide de l'architecte pour créer une architecture de référence pour un datalake IA/ML

Télégramme : le pont de Crypto Island vers le continent

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps