Flame Guardian: Système de détection d'incendie basé sur l'apprentissage en profondeur

Introduction

Imaginez vous réveiller à l'odeur de la fumée, de la course de cœur lorsque vous assurez la sécurité de votre famille. La détection précoce est cruciale et «Flame Guardian», un système de détection d'incendie alimentée par l'apprentissage en profondeur, vise à faire une différence vitale. Cet article vous guide à travers la création de cette technologie à l'aide de CNNS et Tensorflow, de la collecte de données et de l'augmentation à la construction du modèle et au réglage fin. Que vous soyez un passionné de technologie ou un professionnel, découvrez comment exploiter la technologie de pointe pour protéger les vies et les biens.

Résultats d'apprentissage

• Gagnez des compétences dans la préparation, l'organisation et l'augmentation des ensembles de données d'images pour optimiser les performances du modèle.
• Apprenez à construire et à affiner les réseaux de neurones convolutionnels pour des tâches de classification d'images efficaces.
• Développer la capacité d'évaluer et d'interpréter les performances du modèle à l'aide de mesures et de visualisations.
• Apprenez à déployer et à adapter les modèles DL (Deep Learning) pour des applications pratiques, démontrant leur utilité dans des problèmes du monde réel comme la détection des incendies.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Révolution de l'apprentissage en profondeur dans la détection des incendies
• Défis dans la détection des incendies
• Présentation de l'ensemble de données
• Configuration de l'environnement
• Préparation des données
• Visualiser la distribution des images
• Affichage des images de feu et de non-feu
• Améliorer les données de formation avec des techniques d'augmentation
• Construire le modèle de détection d'incendie
• Ajustement du modèle: formation du réseau neuronal convolutionnel
• Évaluer le modèle
• Exemple d'utilisation: prédire le feu dans de nouvelles images
• Questions fréquemment posées

Révolution de l'apprentissage en profondeur dans la détection des incendies

Ces derniers temps, l'apprentissage de Thedeep a révolutionné des domaines colorés, des soins de santé à la finance, et maintenant, il fait des progrès dans les opérations de sécurité et de catastrophe. Une opération particulièrement instigative de l'apprentissage en profondeur réside dans le domaine de la découverte du feu. Avec l'ajout de fréquence et d'inflexibilité des feux de retour dans le monde, le développement d'un système de découverte de feu efficace et fiable est plus essentiel que jamais. Dans ce compagnon complet, nous vous guiderons à travers le processus de création d'un important système de découverte de feu à l'aide de réseaux de neurones convolutionnels (CNNS) et de TensorFlow. Ce système, bien nommé «Flame Guardian», vise à identifier le feu à partir d'images avec une forte délicatesse, potentiellement encourageant la découverte précoce et la mise en place de dégâts de feu larges.

Les incendies, que ce soit des incendies de forêt ou des incendies structurels constituent une menace importante pour la vie, la propriété et l'environnement. La détection précoce est essentielle pour atténuer les effets dévastateurs des incendies. Les systèmes de détection d'incendie à base d'apprentissage en profondeur peuvent analyser de grandes quantités de données rapidement et avec précision, identifiant les incidents de feu avant de dégénérer.

Défis dans la détection des incendies

La détection du feu à l'aide d'un apprentissage en profondeur présente plusieurs défis:

• Variabilité des données: les images de feu peuvent varier considérablement en termes de couleur, d'intensité et de environnement environnant. Un système de détection robuste doit être capable de gérer cette variabilité.
• Faux positifs: il est crucial de minimiser les faux positifs (identifiant incorrectement les images non-feu comme un incendie) pour éviter le déploiement inutile de panique et de ressources.
• Traitement en temps réel: pour une utilisation pratique, le système devrait être en mesure de traiter les images en temps réel, fournissant des alertes opportunes.
• Évolutivité: le système doit être évolutif pour gérer de grands ensembles de données et fonctionner à travers différents.

Présentation de l'ensemble de données

L'ensemble de données utilisé pour le système de détection des incendies de Flame Guardian comprend des images classées en deux classes: «feu» et «non-feu». L'objectif principal de cet ensemble de données est de former un modèle de réseau neuronal convolutionnel (CNN) à distinguer avec précision entre les images qui contiennent du feu et celles qui ne le font pas.

Composition des images de feu et de non-feu

• Images de feu: Ces images contiennent divers scénarios où le feu est présent. L'ensemble de données comprend des images d'incendies de forêt, des incendies structurels et des brûlures contrôlées. Le feu de ces images peut varier en taille, en intensité et à l'environnement dans lequel il est présent. Cette diversité aide le modèle à apprendre les différentes caractéristiques visuelles du feu.
• Images non-feu: ces images ne contiennent aucun feu. Ils comprennent un large éventail de scénarios tels que des paysages, des bâtiments, des forêts et d'autres environnements naturels et urbains sans aucun feu. L'inclusion de diverses images non-feu garantit que le modèle n'identifie pas faussement le feu dans des situations non-feu.

Vous pouvez télécharger l'ensemble de données à partir d'ici.

Configuration de l'environnement

Tout d'abord, nous devons configurer notre terrain avec les bibliothèques et outils nécessaires. Nous utiliserons Google Collab pour cette conception, car il fournit une plate-forme accessible avec le support GPU. Nous avons auparavant téléchargé l'ensemble de données et l'avons téléchargé sur le lecteur.

 #Mount lecteur
à partir du lecteur d'importation google.colab
Drive.mount ('/ Content / Drive')

# Importation des bibliothèques nécessaires
Importer Numpy comme NP
Importer des pandas en tant que PD
Importer Matplotlib.pyplot en tant que plt
Importer Seaborn comme SNS
Importer Plotly.express as px
importer tracé.graph_objects comme Go
à partir de tracé.SubPlots import make_subplots
Importer un système d'exploitation
Importer TensorFlow comme TF
de Tensorflow.keras.preprocessement Image d'importation
de Tensorflow.keras.preprocessing.image Import ImageDatagenerator


Grille de style #setting 
sns.set_style ('darkgrid')

Préparation des données

Nous avons besoin d'un ensemble de données avec des photos de scénaristes de feu et de non-feu afin de former notre algorithme. Un dataframe vierge et une fonction pour ajouter des images de notre lecteur Google à celle-ci seront créées.

 # Créer un dataframe vide
df = pd.dataframe (colonnes = ['path', 'label'])

# Fonction pour ajouter des images au dataframe
def add_images_to_df (répertoire, étiquette):
    pour dirname, _, noms de fichiers dans os.walk (répertoire):
        pour le nom de fichier dans les noms de fichiers:
            df.loc [len (df)] = [os.path.join (dirname, nom de fichier), étiquette]

# Ajouter des images de feu
add_images_to_df ('/ content / drive / mydrive / fire / fire_dataset / fire_images', 'fire')

# Ajouter des images sans tir
add_images_to_df ('/ content / drive / mydrive / fire / fire_dataset / non_fire_images', 'non_fire')

# Mélanger l'ensemble de données
df = df.sample (frac = 1) .reset_index (drop = true)

Visualiser la distribution des images

La visualisation de la distribution des images de feu et de non-feu nous aide à mieux comprendre notre ensemble de données. Nous utiliserons Plotly pour les parcelles interactives.

Création d'un graphique à secteurs pour la distribution d'images

Créons maintenant un graphique à secteurs pour la distribution d'images.

 # Créer le tracé de dispersion
Fig = px.scatter (
    data_frame = df,
    x = df.index,
    y = 'label',
    color = 'label',
    Titre = 'Distribution des images de feu et de non-feu'
)

# Mise à jour de la taille du marqueur
Fig.update_traces (Marker_Size = 2)

Fig.Add_Trace (go.pie (valeurs = df ['label']. Value_Countts (). TO_NUMPY (), Labels = DF ['Label']. Value_Counts ().

Affichage des images de feu et de non-feu

Écrivons maintenant le code pour afficher des images de feu et de non-feu.

 Def Visualize_images (étiquette, titre):
    data = df [df ['label'] == label]
    pics = 6 # définir le nombre de photos
    Fig, ax = plt.subplots (int (pics // 2), 2, FigSize = (15, 15))
    plt.suptitle (titre)
    ax = ax.ravel ()
    pour i dans la gamme ((photos // 2) * 2):
        path = data.sample (1) .loc [:, 'path']. to_numpy () [0]
        img = image.load_img (chemin)
        img = image.img_to_array (img) / 255
        hache [i] .imshow (img)
        ax [i] .axes.xaxis.set_visible (false)
        ax [i] .axes.yaxis.set_visible (false)
Visualize_images («feu», «images avec feu»)
Visualize_images ('non_fire', 'images sans feu') 

En affichant quelques exemples d'images à partir de catégories de feu et de non-feu, nous aurions une idée de ce avec quoi notre modèle fonctionnera.

Améliorer les données de formation avec des techniques d'augmentation

Nous allons appliquer des moyens d'addition d'image pour améliorer nos données de formation. L'application d'adaptations d'images arbitraires, similaires à la giration, au drone et au cisaillement, est connue sous le nom d'addition. En générant un ensemble de données plus robuste et différent, cette procédure améliore la capacité du modèle à se généraliser aux nouvelles images.

 à partir de Tensorflow.keras.Models Import Sequential
de Tensorflow.keras.layers Importer Conv2D, Maxpool2d, aplati, dense

générateur = imagedatagenerator (
    rotation_range = 20,
    width_shift_range = 0,1,
    height_shift_range = 0,1,
    shear_range = 2,
    zoom_range = 0,2,
    RESCALE = 1/255,
    validation_split = 0,2,
)
Train_gen = générateur.flow_from_dataframe (df, x_col = 'path', y_col = 'label', images_size = (256 256), class_mode = 'binary', sous-ensemble = 'formation')
val_gen = générateur.flow_from_dataframe (df, x_col = 'path', y_col = 'label', images_size = (256 256), class_mode = 'binary', sous-ensemble = 'validation')
classe_indices = {}
pour la clé dans Train_gen.class_indices.keys ():
    class_indices [Train_gen.class_Indices [Key]] = Key
    
print (class_indices)

Visualiser des images augmentées

Nous pouvons visualiser certaines des images augmentées générées par notre ensemble de formation.

 sns.set_style ('sombre')
pics = 6 # définir le nombre de photos
Fig, ax = plt.subplots (int (pics // 2), 2, FigSize = (15, 15))
Plt.Suptitle («Images générées dans l'ensemble de formation»)
ax = ax.ravel ()
pour i dans la gamme ((photos // 2) * 2):
    ax [i] .imshow (Train_gen [0] [0] [i])
    ax [i] .axes.xaxis.set_visible (false)
    ax [i] .axes.yaxis.set_visible (false)

Construire le modèle de détection d'incendie

Notre modèle correspondra à plusieurs couches convolutionnelles, chacune suivies d'un sous-casse maximal. Les couches convolutionnelles sont les blocs de structure centrale des CNN, permettant au modèle d'apprendre les échelles spatiales des caractéristiques des images. Les couches maximales de regroupement aident à réduire la dimensionnalité des cartes ponctuelles, ce qui rend le modèle plus efficace. Nous ajouterons également des couches complètement connectées (épaisses) vers la fin du modèle. Ces couches aident à combiner les caractéristiques apprises par les couches convolutionnelles et à prendre la décision finale du support. La sous-casse d'affaire aura un seul neurone avec une fonction d'activation sigmoïde, qui travaille un score de probabilité indiquant si l'image contient du feu. Après avoir défini l'armature du modèle, nous publierons un résumé pour examiner la structure et le nombre de paramètres dans chaque sous-casse. Cette étape est importante pour s'assurer que le modèle est à juste titre configuré.

 à partir de Tensorflow.keras.Models Import Sequential
de Tensorflow.keras.layers Importer Conv2D, Maxpool2d, aplati, dense

modèle = séquentiel ()
modèle.add (conv2d (filtres = 32, kernel_size = (2,2), activation = 'relu', input_shape = (256,256,3))))
modèle.add (maxpool2d ())
Model.Add (conv2D (filtres = 64, Kernel_Size = (2,2), activation = 'relu'))
modèle.add (maxpool2d ())
Model.Add (conv2D (filtres = 128, Kernel_Size = (2,2), activation = 'relu'))
modèle.add (maxpool2d ())
modèle.add (aplate ())
modèle.add (dense (64, activation = 'relu'))
modèle.add (dense (32, activation = 'relu'))
modèle.add (dense (1, activation = 'sigmoïde')))
Model.Summary ()

Compilation du modèle avec des optimisateurs et des fonctions de perte

Ensuite, nous allons compiler le modèle à l'aide de l'optimiseur ADAM et de la fonction binaire de perte d'entrée croisée. L'optimiseur ADAM est largement utilisé dans l'apprentissage en profondeur pour son taux d'efficacité et d'apprentissage adaptatif. L'entropie croisée binaire est appropriée pour notre problème de classification binaire (incendie vs non-feu).

Nous spécifierons également des mesures supplémentaires, telles que la précision, le rappel et la zone sous la courbe (AUC), pour évaluer les performances du modèle pendant la formation et la validation.

Ajout de rappels pour une formation optimale

Les rappels sont une fonctionnalité puissante de TensorFlow qui nous permet de surveiller et de contrôler le processus de formation. Nous utiliserons deux rappels importants:

• Early stopping: arrête la formation lorsque la perte de validation cesse de s'améliorer, empêchant le sur-ajustement.
• Reducelronplateau: réduit le taux d'apprentissage lorsque les plateaux de perte de validation, aidant le modèle à converger vers une meilleure solution.

 #Compiling modèle
De Tensorflow.keras.Metrics Import Rappel, AUC
de Tensorflow.keras.utils Import Plot_model

Model.Compile (Optimizer = 'Adam', Loss = 'Binary_Crossentropy', Metrics = ['Précision', rappel (), Auc ()])

#Defining Rappels
De Tensorflow.keras.Callbacks Importer tôt, réducelronplateau
Early_Stoppping = Earlystopping (monitor = 'Val_loss', patience = 5, restore_best_weights = true)
réduction_lr_on_plateau = reducelronplateau (monitor = 'val_loss', facteur = 0,1, patience = 5)

Ajustement du modèle: formation du réseau neuronal convolutionnel

L'ajustement du modèle fait référence au processus de formation d'un modèle d'apprentissage automatique sur un ensemble de données. Au cours de ce processus, le modèle apprend les modèles sous-jacents dans les données en ajustant ses paramètres (poids et biais) pour minimiser la fonction de perte. Dans le contexte de l'apprentissage en profondeur, cela implique plusieurs époques de passage vers l'avant et en arrière sur les données de formation.

 Model.Fit (x = Train_gen, Batch_Size = 32, Epochs = 15, Validation_Data = Val_gen, Callbacks = [Early_Stoppping, Reduce_LR_ON_PLATEAU])

Évaluer le modèle

Après la formation, nous évaluerons les performances du modèle sur l'ensemble de validation. Cette étape nous aide à comprendre à quel point le modèle se généralise aux nouvelles données. Nous allons également visualiser l'histoire de la formation pour voir comment les pertes et les mesures ont évolué au fil du temps.

 EVAL_LIST = Model.Evaluate (Val_gen, return_dict = true)
pour la métrique dans ev_list.keys ():
    print (métrique f ": {eval_list [métrique]:. 2f}")
   
EVAL_LIST = Model.Evaluate (Val_gen, return_dict = true)
pour la métrique dans ev_list.keys ():
    print (métrique f ": {eval_list [métrique]:. 2f}")

Exemple d'utilisation: prédire le feu dans de nouvelles images

Enfin, nous allons montrer comment utiliser le modèle formé pour prédire si une nouvelle image contient du feu. Cette étape consiste à charger une image, à le prétraiter pour répondre aux exigences d'entrée du modèle et à utiliser le modèle pour faire une prédiction.

Télécharger et charger l'image

Nous allons télécharger un exemple d'image à partir d'Internet et le charger à l'aide des fonctions de traitement d'image de TensorFlow. Cette étape consiste à redimensionner l'image et à normaliser ses valeurs de pixels.

Faire la prédiction

En utilisant le modèle formé, nous ferons une prédiction sur l'image chargée. Le modèle publiera un score de probabilité, que nous allons compléter pour obtenir une classification binaire (incendie ou non-feu). Nous mapperons également la prédiction à son étiquette correspondante en utilisant les indices de classe.

 # Télécharger l'image
! Curl https://static01.nyt.com/images/2021/02/19/world/19storm-briefing-texas-fire/19storm-briefing-texas-fire-articlelarge.jpg --toutput prédict.jpg
#charge de l'image
img = image.load_img ('prédite.jpg')
IMG

img = image.img_to_array (img) / 255
img = tf.image.resize (img, (256 256))
img = tf.expand_dims (img, axe = 0)

print ("Forme d'image", img.shape)

prédiction = int (tf.round (modèle.predict (x = img)). Numpy () [0] [0])
print ("La valeur prévue est:", prédiction ", et l'étiquette prévue est:", class_indices [prédiction]) 

Conclusion

Le développement d'un système de détection d'incendie basé sur l'apprentissage en profondeur comme «Flame Guardian» illustre le potentiel transformateur de l'apprentissage en profondeur pour relever les défis du monde réel. En suivant méticuleusement chaque étape, de la préparation et de la visualisation des données à la construction, à la formation et à l'évaluation des modèles, nous avons créé un cadre robuste pour détecter le feu dans les images. Ce projet met non seulement les subtilités techniques impliquées en profondeur, mais souligne également l'importance de tirer parti de la technologie pour la sécurité et la prévention des catastrophes.

Comme nous le concluons, il est évident que le modèle DL peut améliorer considérablement les systèmes de détection des incendies, les rendant plus efficaces, fiables et évolutifs. Alors que les méthodes traditionnelles ont leurs mérites, l'incorporation de l'apprentissage en profondeur introduit un nouveau niveau de sophistication et de précision. Le voyage du développement de «Flame Guardian» a été à la fois éclairant et enrichissant, présentant les immenses capacités des technologies modernes.

Principaux à retenir

• Comprendre les techniques de gestion des données et de visualisation.
• Comprendre la collecte et l'augmentation des données appropriées assurent une formation et une généralisation efficaces du modèle.
• Implémentation de la construction de modèles et de l'évaluation du modèle.
• Comprend des rappels comme les premiers stopping et Reducelronplateau pour optimiser la formation et empêcher le sur-ajustement.
• Apprenu réseau de neurones convolutionnels pour la détection des incendies à l'aide de CNN.

Questions fréquemment posées

Q1. Qu'est-ce que «Flame Guardian»?

A. «Flame Guardian» est un système de détection d'incendie qui utilise des réseaux de neurones convolutionnels (CNN) et Tensorflow pour identifier le feu dans des images à haute précision.

Q2. Pourquoi la détection précoce des incendies est-elle importante?

A. La détection précoce des incendies est cruciale pour prévenir les dommages importants, sauver des vies et réduire l'impact environnemental des incendies. La réponse rapide peut atténuer considérablement les effets dévastateurs des incendies de forêt et des incendies structurels.

Q3. Quels défis sont impliqués dans la construction d'un système de détection d'incendie en utilisant l'apprentissage en profondeur?

A. Les défis incluent la gestion de la variabilité des données (différences de couleur, d'intensité et d'environnement), de minimiser les faux positifs, d'assurer les capacités de traitement en temps réel et d'évolutivité pour gérer de grands ensembles de données.

Q4. Comment l'augmentation de l'image aide-t-elle à former le modèle?

A. L'augmentation de l'image améliore l'ensemble de données de formation en appliquant des transformations aléatoires telles que la rotation, le zoom et le cisaillement. Cela aide le modèle à mieux généraliser en l'exposant à une variété de scénarios, améliorant sa robustesse.

Q5. Quelles mesures sont utilisées pour évaluer les performances du modèle?

A. Le modèle est évalué à l'aide de mesures comme la précision, le rappel et la zone sous la courbe (AUC). Ces mesures aident à évaluer dans quelle mesure le modèle distingue bien le feu et les images non-feu et sa fiabilité globale.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!