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

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

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.

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.

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.

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!