Flame Guardian: Deep Learning Based Fire Detection System

Einführung

Stellen Sie sich vor, Sie wachen mit dem Geruch von Rauch und dem Herzrennen auf, während Sie die Sicherheit Ihrer Familie gewährleisten. Die frühzeitige Erkennung ist entscheidend, und „Flame Guardian“, ein tiefes Lernfeuererkennungssystem, zielt darauf ab, einen lebensrettenden Unterschied zu machen. Dieser Artikel führt Sie durch die Erstellung dieser Technologie mit CNNs und Tensorflow, von der Datenerfassung und Erweiterung bis hin zu Modellkonstruktion und Feinabstimmung. Egal, ob Sie ein Technologieenthusiast oder ein Fachmann sind, herausfinden, wie Sie modernste Technologie zum Schutz von Leben und Eigentum nutzen können.

Lernergebnisse

• Erhalten Sie Fähigkeiten bei der Vorbereitung, Organisation und Erweiterung von Bilddatensätzen, um die Modellleistung zu optimieren.
• Erfahren Sie, wie Sie Faltungsnetzwerke für effektive Bildklassifizierungsaufgaben konstruieren und feinstimmen.
• Entwickeln Sie die Fähigkeit, die Modellleistung mithilfe von Metriken und Visualisierungen zu bewerten und zu interpretieren.
• Erfahren Sie, wie Sie DL-Modelle (Deep Learning) für praktische Anwendungen bereitstellen und anpassen, und demonstrieren Sie deren Nützlichkeit bei realen Problemen wie der Feuererkennung.

Dieser Artikel wurde als Teil des Data Science -Blogathons veröffentlicht.

Inhaltsverzeichnis

• Revolution des tiefen Lernens bei der Branderkennung
• Herausforderungen bei der Branderkennung
• Datensatzübersicht
• Einrichten der Umgebung
• Datenvorbereitung
• Visualisierung der Verteilung von Bildern
• Anzeigen von Feuer- und Nichtfeuerbildern
• Verbesserung der Trainingsdaten mit Augmentationstechniken
• Bau des Branderkennungsmodells
• Modellanpassung: Training des neuronalen Netzwerks mit Faltungsstücken
• Bewertung des Modells
• Beispiel Verwendung: Vorhersage von Feuer in neuen Bildern
• Häufig gestellte Fragen

Revolution des tiefen Lernens bei der Branderkennung

In jüngster Zeit hat das Lernen von Theeep farbenfrohe Felder von der Gesundheitsversorgung bis zur Finanzierung revolutioniert, und jetzt macht es Fortschritte in den Bereichen Sicherheits- und Katastrophenoperationen. Eine besonders anstiftigende Operation von Deep Learning liegt im Bereich der Brandentdeckung. Mit der Hinzufügen von Häufigkeit und Inflexibilität von Backfirs weltweit ist die Entwicklung eines effektiven und zuverlässigen Brandentdeckungssystems zentraler denn je. In diesem umfassenden Begleiter führen wir Sie durch den Prozess der Erstellung eines wichtigen Brandentdeckungssystems mithilfe von Faltungsnetzwerken (CNNs) und Tensorflow. Dieses System, das treffend als "Flame Guardian" bezeichnet wird, zielt darauf ab, Feuer aus Bildern mit hoher Delikatesse zu identifizieren, die möglicherweise in der frühen Entdeckung und der Vorbehalt von breiten Brandschäden begünstigt.

Brände, ob Waldbrände oder strukturelle Brände, stellen eine erhebliche Bedrohung für Leben, Eigentum und Umwelt dar. Frühe Erkennung ist von entscheidender Bedeutung, um die verheerenden Wirkungen von Bränden zu mildern. Deep-Learning-basierte Branderkennungssysteme können große Datenmengen schnell und genau analysieren und Brandvorfälle identifizieren, bevor sie eskalieren.

Herausforderungen bei der Branderkennung

Das Erkennen von Feuer mit Deep Learning stellt mehrere Herausforderungen dar:

• Datenvariabilität: Brandbilder können in Bezug auf Farbe, Intensität und Umgebung stark variieren. Ein robustes Erkennungssystem muss in der Lage sein, diese Variabilität zu bewältigen.
• Fehlalarme Aspekte: Es ist entscheidend, falsch positive Aspekte (fälschlicherweise identifizieren Nicht-Feuerbilder als Feuer) zu minimieren, um unnötige Panik- und Ressourcenbereitstellung zu vermeiden.
• Echtzeitverarbeitung: Für den praktischen Gebrauch sollte das System in der Lage sein, Bilder in Echtzeit zu verarbeiten und zeitnahe Benachrichtigungen bereitzustellen.
• Skalierbarkeit: Das System sollte skalierbar sein, um große Datensätze zu verarbeiten und unterschiedlich zu arbeiten.

Datensatzübersicht

Der für das Flame Guardian Fire Detection System verwendete Datensatz umfasst Bilder, die in zwei Klassen eingeteilt wurden: „Feuer“ und „Nicht-Fire“. Der Hauptzweck dieses Datensatzes besteht darin, ein CNN -Modell (Faltungsunternehmen "(CNN) zu schulen, um zwischen Bildern, die Feuer enthalten, genau zu unterscheiden, und solche, die dies nicht tun.

Zusammensetzung von Feuer- und Nichtfeuerbildern

• Feuerbilder: Diese Bilder enthalten verschiedene Szenarien, in denen Feuer vorhanden ist. Der Datensatz enthält Bilder von Waldbränden, strukturellen Bränden und kontrollierten Verbrennungen. Das Feuer in diesen Bildern kann in Größe, Intensität und der Umgebung, in der es vorhanden ist, variieren. Diese Vielfalt hilft dem Modell, die unterschiedlichen visuellen Eigenschaften des Feuers zu lernen.
• Nicht-Fire-Bilder: Diese Bilder enthalten kein Feuer. Dazu gehören eine breite Palette von Szenarien wie Landschaften, Gebäuden, Wäldern und andere natürliche und städtische Umgebungen ohne Feuer. Die Einbeziehung verschiedener Nichtfeuerbilder stellt sicher, dass das Modell das Feuer in nicht-Feuer-Situationen fälschlicherweise fälschlicherweise fälschlicherweise identifiziert.

Sie können den Datensatz von hier herunterladen.

Einrichten der Umgebung

Zunächst müssen wir unser Gelände mit den erforderlichen Bibliotheken und Tools einrichten. Wir werden Google Collaboc für dieses Design nutzen, da es eine zugängliche Plattform mit GPU -Unterstützung bietet. Wir haben früher den Datensatz heruntergeladen und auf Drive hochgeladen.

 #Mount Drive
von Google.Colab Import Laufwerk
Drive.mount ('/content/Drive')

#Notwendige Bibliotheken
Numph als NP importieren
Pandas als PD importieren
matplotlib.pyplot als pLT importieren
Importieren Sie Seeborn als SNS
plotly.express als px importieren
plotly.graph_objects as Go importieren
von Plotly.Subplots importieren make_subplots
OS importieren
Tensorflow als TF importieren
Aus TensorFlow.keras.Processing Import Image
aus Tensorflow.keras.preprozessing.image Import Imagedatagenerator


#Setting Style Grid 
snsset_style ('darkgrid')

Datenvorbereitung

Wir benötigen einen Datensatz mit Bildern von Feuer- und Nichtfeuer-Skripten, um unseren Algorithmus zu trainieren. Ein leerer Datenrahmen und eine Funktion zum Hinzufügen von Bildern aus unserem Google -Laufwerk werden erstellt.

 # Erstellen Sie einen leeren Datenrahmen
df = pd.dataframe (columns = ['path', 'label'])

# Funktion zum Hinzufügen von Bildern zum DataFrame
Def add_images_to_df (Verzeichnis, Etikett):
    Für DirName, _, Dateinamen in os.walk (Verzeichnis):
        Für Dateinamen in Dateinamen:
            df.loc [len (df)] = [os.path.join (DirName, Dateiname), Etikett]

# Feuerbilder hinzufügen
add_images_to_df ('/content/drive/mydrive/fire/fire_dataset/fire_images', 'fire'))

# Nicht-Feuerbilder hinzufügen
add_images_to_df ('/content/drive/mydrive/fire/fire_dataset/non_fire_images', 'non_fire'))

# Mischen Sie den Datensatz
df = df.sample (frac = 1) .reset_index (Drop = true)

Visualisierung der Verteilung von Bildern

Die Visualisierung der Verteilung von Feuer- und Nichtfeuerbildern hilft uns, unseren Datensatz besser zu verstehen. Wir werden Plotly für interaktive Diagramme verwenden.

Erstellen eines Kreisdiagramms für die Bildverteilung

Lassen Sie uns nun ein Kreisdiagramm für die Bildverteilung erstellen.

 # Erstellen Sie das Streudiagramm
Fig = px.catter (
    data_frame = df,
    x = df.index,
    y = 'label',
    color = 'label',
    Titel = 'Verteilung von Feuer- und Nichtfeuerbildern'
)

# Markierungsgröße aktualisieren
Abb.Update_traces (marker_size = 2)

Abb.ADD_TRACE (go.pie (values ​​= df ['label']. value_counts (). to_numpy (), labels = df ['label']. value_counts (). Index, marker = dict (farben = ['leichte', 'pink']), row = 1, col = 2)

Anzeigen von Feuer- und Nichtfeuerbildern

Lassen Sie uns nun den Code zum Anzeigen von Feuer- und Nichtfeuerbildern schreiben.

 Def visualisierung_images (Etikett, Titel):
    Data = df [df ['label'] == label]
    Bilder = 6 # Legen Sie die Anzahl der Bilder fest
    Abb, ax = plt.subplots (int (pics // 2), 2, figsize = (15, 15))
    Plt.Suptitle (Titel)
    ax = ax.ravel ()
    für i im Bereich ((Bilder // 2) * 2):
        path = data.sample (1) .loc [: 'path']. to_numpy () [0]
        img = image.load_img (Pfad)
        img = image.img_to_array (img) / 255
        AX [i] .imshow (IMG)
        AX [i] .AXES.xaxis.set_visible (Falsch)
        AX [i] .AXES.YAXIS.SET_VISIBLE (FALSE)
visualisieren_images ('feuer', 'bilder mit feuer')
visualisieren_images ('non_fire', 'bilder ohne feuer') 

Durch die Anzeige einiger Beispielbilder aus Feuer- und Nichtfeuerkategorien würden wir ein Gefühl dafür bekommen, was unser Modell zusammenarbeiten wird.

Verbesserung der Trainingsdaten mit Augmentationstechniken

Wir werden Bildzusatzmöglichkeiten anwenden, um unsere Trainingsdaten zu verbessern. Die Anwendung willkürlicher Bildanpassungen, ähnlich wie Gyration, Drohne und Schere, wird als Addition bezeichnet. Durch die Generierung eines robusteren und unterschiedlicheren Datensatzes verbessert dieses Verfahren die Fähigkeit des Modells, auf neue Bilder zu verallgemeinern.

 von TensorFlow.keras.models sequentiell importieren
aus Tensorflow.keras.layers importieren conv2d, maxpool2d, flach, dichter

Generator = Imagedatagenerator (
    rotation_range = 20,
    width_shift_range = 0.1,
    HIGH_SHIFT_RANGE = 0.1,
    SHEAR_RANGE = 2,
    Zoom_range = 0,2,
    scALE = 1/255,
    validation_split = 0,2,
)
train_gen = generator.flow_from_dataframe (df, x_col = 'path', y_col = 'Label', Bilder_Size = (256,256), class_mode = 'Binary', subset = 'Training')
val_gen = generator.flow_from_dataframe (df, x_col = 'path', y_col = 'Label', Bilder_Size = (256,256), class_mode = 'Binary', subset = 'Validation')
class_indices = {}
Für Schlüssel in Train_gen.class_indices.keys ():
    class_indices [train_gen.class_indices [key]] = key
    
print (class_indices)

Visualisierung erweiterter Bilder

Wir können einige der erweiterten Bilder visualisieren, die von unserem Trainingssatz generiert werden.

 snsset_style ('dark')
Bilder = 6 # Legen Sie die Anzahl der Bilder fest
Abb, ax = plt.subplots (int (pics // 2), 2, figsize = (15, 15))
PLT.SUPTITLE ('Erzeugte Bilder im Trainingssatz')
ax = ax.ravel ()
für i im Bereich ((Bilder // 2) * 2):
    ax [i] .imshow (train_gen [0] [0] [i])
    AX [i] .AXES.xaxis.set_visible (Falsch)
    AX [i] .AXES.YAXIS.SET_VISIBLE (FALSE)

Bau des Branderkennungsmodells

Unser Modell entspricht mehreren Faltungsschichten, die jeweils von einer maximalen Billard-Unterkaste gefolgt werden. Faltungsschichten sind die Kernstrukturblöcke von CNNs, sodass das Modell räumliche Skalen von Merkmalen aus den Bildern erlernen kann. Maxpooling-Schichten helfen dazu, die Dimensionalität der Punktkarten zu verringern und das Modell effektiver zu machen. Wir werden auch vollständig verbundene (dicke) Schichten gegen Ende des Modells hinzufügen. Diese Schichten helfen dabei, die von den Faltungsschichten gelernten Merkmale zu kombinieren und die endgültige Entscheidung zu treffen. Die Affair -Subcaste verfügt über ein einzelnes Neuron mit einer Sigmoidaktivierungsfunktion, die einen Wahrscheinlichkeitsbewertung fordert, der angibt, ob das Bild Feuer enthält. Nachdem wir die Modellanrichtung definiert haben, veröffentlichen wir eine Zusammenfassung, um die Struktur und die Anzahl der Parameter in jeder Subcaste zu überprüfen. Dieser Schritt ist wichtig, um sicherzustellen, dass das Modell zu Recht konfiguriert ist.

 von TensorFlow.keras.models sequentiell importieren
aus Tensorflow.keras.layers importieren conv2d, maxpool2d, flach, dichter

Modell = sequentiell ()
model.Add (conv2d (filters = 32, kernel_size = (2,2), active = 'relu', input_shape = (256,256,3)))
model.add (maxpool2d ())
model.add (conv2d (filters = 64, kernel_size = (2,2), actionation = 'relu'))
model.add (maxpool2d ())
model.Add (conv2d (filters = 128, kernel_size = (2,2), actionation = 'relu'))
model.add (maxpool2d ())
model.add (flacher ())
model.add (dichter (64, activation = 'relu'))
model.add (dichter (32, activation = 'relu'))
model.add (dichter (1, activation = 'sigmoid'))
Modell.Summary ()

Kompilieren des Modells mit Optimierern und Verlustfunktionen

Als nächstes werden wir das Modell mit dem Adam Optimizer und der Binary Cross-Entropy-Verlustfunktion kompilieren. Der Adam -Optimierer wird für seine Effizienz und die adaptive Lernrate häufig im Deep -Lernen eingesetzt. Binärer Kreuzentropie ist für unser Binärklassifizierungsproblem (Feuer vs. Nicht-Fire) geeignet.

Wir werden auch zusätzliche Metriken wie Genauigkeit, Rückruf und Bereich unter der Kurve (AUC) angeben, um die Leistung des Modells während des Trainings und der Validierung zu bewerten.

Hinzufügen von Rückrufen für ein optimales Training

Rückrufe sind eine leistungsstarke Funktion in TensorFlow, mit der wir den Trainingsprozess überwachen und steuern können. Wir werden zwei wichtige Rückrufe verwenden:

• Frühstop: Stört das Training zu, wenn sich der Validierungsverlust nicht mehr verbessert und eine Überanpassung verhindern.
• ReducelronPlateau: Reduziert die Lernrate, wenn die Validierungsverlust -Plateaus und das Modell zu einer besseren Lösung konvergieren.

 #Modell
von TensorFlow.keras.Metrics Import Recall, AUC
von TensorFlow.keras.utils import Plot_Model

model.comPile (optimizer = 'adam', Loss = 'Binary_crossentropy', Metrics = ['Genauigkeit', Rückruf (), AUC ()])

#Definierende Rückrufe
aus Tensorflow.keras.Callbacks frühstört, reducelronPlateau
Early_Stoppping = EarlyStoping (Monitor = 'val_loss', Patience = 5, restore_best_weights = true)
ReducelronPlateau (monitor = 'val_loss', faktor = 0,1, pidence = 5)

Modellanpassung: Training des neuronalen Netzwerks mit Faltungsstücken

Modellanpassung bezieht sich auf den Prozess des Trainings eines maschinellen Lernmodells in einem Datensatz. Während dieses Prozesses lernt das Modell die zugrunde liegenden Muster in den Daten, indem es seine Parameter (Gewichte und Verzerrungen) anpasst, um die Verlustfunktion zu minimieren. Im Kontext des tiefen Lernens beinhaltet dies mehrere Epochen von Vorwärts- und Rückwärtspässen über die Trainingsdaten.

 model.fit (x = train_gen, batch_size = 32, epochs = 15, validation_data = val_gen, callbacks = [Early_Stoppping, record_lr_on_plateau]))

Bewertung des Modells

Nach dem Training bewerten wir die Leistung des Modells im Validierungssatz. Dieser Schritt hilft uns zu verstehen, wie gut das Modell auf neue Daten verallgemeinert wird. Wir werden auch die Trainingsgeschichte visualisieren, um zu sehen, wie sich der Verlust und die Metriken im Laufe der Zeit entwickelt haben.

 eval_list = model.evaluate (val_gen, return_dict = true)
für metric in eval_list.keys ():
    print (metric f ": {eval_list [metric] :. 2f}")
   
eval_list = model.evaluate (val_gen, return_dict = true)
für metric in eval_list.keys ():
    print (metric f ": {eval_list [metric] :. 2f}")

Beispiel Verwendung: Vorhersage von Feuer in neuen Bildern

Schließlich werden wir demonstrieren, wie das trainierte Modell verwendet wird, um vorherzusagen, ob ein neues Bild Feuer enthält. Dieser Schritt beinhaltet das Laden eines Bildes, das Vorverarbeitung auf die Eingabeanforderungen des Modells und die Verwendung des Modells, um eine Vorhersage zu machen.

Herunterladen und Laden des Bildes

Wir werden ein Beispielbild aus dem Internet herunterladen und es mit den Bildverarbeitungsfunktionen von TensorFlow laden. Dieser Schritt beinhaltet die Größe des Bildes und die Normalisierung seiner Pixelwerte.

Die Vorhersage machen

Mit dem trainierten Modell machen wir eine Vorhersage auf dem geladenen Bild. Das Modell gibt eine Wahrscheinlichkeitsbewertung aus, die wir um eine binäre Klassifizierung (Feuer oder Nichtfeuer) abrufen werden. Wir werden die Vorhersage auch mit den Klassenindizes auf seine entsprechende Etikett zuordnen.

 # Das Bild herunterladen
! curl https://static01.nyt.com/images/2021/02/19/world/19storm-briefing-texas-fire/19storm-briefing-texas-fire-articlelarge.jpg--ausgleichen Predict.jpggg
#Laden des Bildes
img = image.load_img ('predict.jpg'))
img

img = image.img_to_array (img)/255
img = tf.image.Resize (IMG, (256,256))
img = tf.expand_dims (img, axis = 0)

print ("Bildform", img.shape)

Vorhersage = int (tf.round (model.Predict (x = img)). numpy () [0] [0])
print ("Der vorhergesagte Wert ist:", Vorhersage "und die vorhergesagte Etikett ist:", class_indices [Vorhersage]) 

Abschluss

Die Entwicklung eines tief lernbasierten Branderkennungssystems wie „Flame Guardian“ veranschaulicht das transformative Potenzial des Deep-Lernens bei der Bewältigung der realen Herausforderungen. Durch die akribische Verfolgung jedes Schritts von Datenvorbereitung und Visualisierung bis hin zu Modellbildung, Schulung und Bewertung haben wir einen robusten Rahmen für das Erkennen von Feuer in Bildern erstellt. Dieses Projekt unterstreicht nicht nur die technischen Feinheiten, die Deep Learning betreffen, sondern unterstreicht auch die Bedeutung der Nutzung von Technologie für Sicherheit und Katastrophenprävention.

Wie wir schließen, ist es offensichtlich, dass das DL -Modell die Branderkennungssysteme erheblich verbessern und sie effizienter, zuverlässiger und skalierbarer machen kann. Während traditionelle Methoden ihre Vorzüge haben, führt die Einbeziehung von Deep Learning ein neues Maß an Raffinesse und Genauigkeit vor. Die Reise der Entwicklung von „Flame Guardian“ war sowohl aufschlussreich als auch lohnend und zeigt die immensen Fähigkeiten moderner Technologien.

Key Takeaways

• Verstandene Datenhandhabungs- und Visualisierungstechniken.
• Die richtige Datenerfassung und -vergrößerung verstanden, gewährleisten eine effektive Modellschulung und -verallgemeinerung.
• Implementierte Modellbildung und Modellbewertung.
• Verstandene Rückrufe wie frühstopping und reducelronPlateau, um das Training zu optimieren und Überanpassung zu verhindern.
• Gelerntes Gebäude mit dem neuronalen Netzwerk für Brandbekämpfung mit CNN.

Häufig gestellte Fragen

Q1. Was ist "Flame Guardian"?

A. „Flame Guardian“ ist ein Branderkennungssystem, das Faltungsnetzwerke (CNNs) und Tensorflow verwendet, um Feuer in Bildern mit hoher Genauigkeit zu identifizieren.

Q2. Warum ist die frühe Branderkennung wichtig?

A. Eine frühzeitige Branderkennung ist entscheidend, um umfangreiche Schäden zu verhindern, Leben zu retten und die Umweltauswirkungen von Bränden zu verringern. Eine schnelle Reaktion kann die verheerenden Wirkungen sowohl von Waldbränden als auch von Strukturbränden erheblich mildern.

Q3. Welche Herausforderungen sind mit dem Aufbau eines Branderkennungssystems mit Deep Learning verbunden?

A. Die Herausforderungen umfassen den Umgang mit Datenvariabilität (Unterschiede in Farbe, Intensität und Umgebung), die Minimierung falscher Positives, die Gewährleistung der Echtzeitverarbeitungsfunktionen und die Skalierbarkeit für große Datensätze.

Q4. Wie hilft die Bildvergrößerung beim Training des Modells?

A. Die Bildvergrößerung verbessert den Trainingsdatensatz, indem zufällige Transformationen wie Rotation, Zoom und Schere angewendet werden. Dies hilft dem Modell besser, indem es eine Vielzahl von Szenarien ausgesetzt und seine Robustheit verbessert.

Q5. Welche Metriken werden verwendet, um die Leistung des Modells zu bewerten?

A. Das Modell wird unter Verwendung von Metriken wie Genauigkeit, Rückruf und der Fläche unter der Kurve (AUC) bewertet. Diese Metriken beurteilen, wie gut das Modell zwischen Feuer- und Nichtfeuerbildern und seiner allgemeinen Zuverlässigkeit unterscheidet.

Die in diesem Artikel gezeigten Medien sind nicht im Besitz von Analytics Vidhya und werden nach Ermessen des Autors verwendet.

Das obige ist der detaillierte Inhalt vonFlame Guardian: Deep Learning Based Fire Detection System. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!