Pengenalan

Bayangkan bangun dengan bau asap, perlumbaan jantung semasa anda memastikan keselamatan keluarga anda. Pengesanan awal adalah penting, dan "Flame Guardian," sistem pengesanan kebakaran berkuasa yang mendalam, bertujuan untuk membuat perbezaan menyelamatkan nyawa. Artikel ini membimbing anda melalui mewujudkan teknologi ini menggunakan CNN dan Tensorflow, dari pengumpulan data dan pembesaran untuk model pembinaan dan penalaan halus. Sama ada anda seorang peminat teknologi atau profesional, temukan cara memanfaatkan teknologi canggih untuk melindungi kehidupan dan harta benda.

Hasil pembelajaran

• Mendapatkan kemahiran dalam menyediakan, mengatur, dan menambah dataset imej untuk mengoptimumkan prestasi model.
• Ketahui cara membina dan menyempurnakan rangkaian saraf konvolusi untuk tugas klasifikasi imej yang berkesan.
• Membangunkan keupayaan untuk menilai dan mentafsir prestasi model menggunakan metrik dan visualisasi.
• Ketahui cara menggunakan dan menyesuaikan model DL (Deep Learning) untuk aplikasi praktikal, menunjukkan utiliti mereka dalam masalah dunia sebenar seperti pengesanan kebakaran.

Artikel ini diterbitkan sebagai sebahagian daripada Blogathon Sains Data.

Jadual Kandungan

• Revolusi pembelajaran mendalam dalam pengesanan kebakaran
• Cabaran dalam Pengesanan Kebakaran
• Gambaran Keseluruhan Dataset
• Menyediakan persekitaran
• Penyediaan data
• Menggambarkan pengagihan imej
• Memaparkan gambar api dan bukan api
• Meningkatkan data latihan dengan teknik pembesaran
• Membina Model Pengesanan Kebakaran
• Pemasangan Model: Latihan Rangkaian Neural Convolutional
• Menilai model
• Contoh Penggunaan: Meramalkan Kebakaran dalam Imej Baru
• Soalan yang sering ditanya

Revolusi pembelajaran mendalam dalam pengesanan kebakaran

Pada kebelakangan ini, pembelajaran Thedeep telah merevolusikan bidang yang berwarna -warni, dari penjagaan kesihatan untuk membiayai, dan sekarang, ia membuat kemajuan dalam operasi keselamatan dan bencana. Satu operasi pembelajaran yang mendalam adalah dalam bidang penemuan kebakaran. Dengan kekerapan menambah dan ketidakcekapan backfires di seluruh dunia, membangunkan sistem penemuan kebakaran yang berkesan dan boleh dipercayai lebih penting daripada sebelumnya. Dalam sahabat yang komprehensif ini, kami akan membimbing anda melalui proses mewujudkan sistem penemuan kebakaran yang penting menggunakan rangkaian saraf konvensional (CNNs) dan tensorflow. Sistem ini, dengan tepat bernama "Flame Guardian," bertujuan untuk mengenal pasti kebakaran dari imej dengan makanan istimewa yang tinggi, berpotensi bersubahat dalam penemuan awal dan hutan kerosakan kebakaran yang luas.

Kebakaran, sama ada kebakaran hutan atau kebakaran struktur menimbulkan ancaman yang signifikan terhadap kehidupan, harta benda, dan alam sekitar. Pengesanan awal adalah kritikal dalam mengurangkan kesan buruk kebakaran. Sistem pengesanan kebakaran berasaskan pembelajaran yang mendalam, boleh menganalisis sejumlah besar data dengan cepat dan tepat, mengenal pasti insiden kebakaran sebelum mereka meningkat.

Cabaran dalam Pengesanan Kebakaran

Mengesan Kebakaran Menggunakan Pembelajaran Deep memberikan beberapa cabaran:

• Variabiliti data: Imej kebakaran boleh berbeza -beza dari segi warna, intensiti, dan persekitaran sekitarnya. Sistem pengesanan yang mantap mesti dapat mengendalikan kebolehubahan ini.
• Positif palsu: Sangat penting untuk meminimumkan positif palsu (salah mengenal pasti imej bukan api sebagai api) untuk mengelakkan panik dan sumber yang tidak perlu.
• Pemprosesan masa nyata: Untuk kegunaan praktikal, sistem harus dapat memproses imej dalam masa nyata, memberikan makluman tepat pada masanya.
• Skalabiliti: Sistem ini harus berskala untuk mengendalikan dataset yang besar dan bekerja di seluruh yang berbeza.

Gambaran Keseluruhan Dataset

Dataset yang digunakan untuk sistem pengesanan api Guardian Flame terdiri daripada imej yang dikategorikan kepada dua kelas: "api" dan "bukan api." Tujuan utama dataset ini adalah untuk melatih model rangkaian saraf konvensional (CNN) untuk membezakan dengan tepat antara imej yang mengandungi kebakaran dan yang tidak.

Komposisi imej api dan bukan api

• Imej Kebakaran: Imej -imej ini mengandungi pelbagai senario di mana api hadir. Dataset termasuk imej kebakaran hutan, kebakaran struktur, dan luka bakar terkawal. Kebakaran dalam imej -imej ini mungkin berbeza -beza mengikut saiz, keamatan, dan persekitaran di mana ia hadir. Kepelbagaian ini membantu model mempelajari ciri -ciri visual kebakaran yang berbeza.
• Imej bukan api: Imej-imej ini tidak mengandungi sebarang api. Mereka termasuk pelbagai senario seperti landskap, bangunan, hutan, dan persekitaran semula jadi dan bandar yang lain tanpa api. Kemasukan imej bukan kebakaran yang pelbagai memastikan bahawa model itu tidak mengenal pasti kebakaran dalam situasi bukan api.

Anda boleh memuat turun dataset dari sini.

Menyediakan persekitaran

Pertama, kita perlu menubuhkan medan kita dengan perpustakaan dan alat yang diperlukan. Kami akan menggunakan Google Collab untuk reka bentuk ini, kerana ia menyediakan platform yang boleh diakses dengan sokongan GPU. Kami pernah memuat turun dataset dan memuat naiknya pada pemacu.

 #Mount Drive
dari Google.Colab Import Drive
drive.mount ('/kandungan/drive')

#Mengata perpustakaan yang diperlukan
import numpy sebagai np
Import Pandas sebagai PD
import matplotlib.pyplot sebagai PLT
Import Seaborn sebagai SNS
import plotly.express sebagai px
import plotly.graph_objects sebagai pergi
dari plotly.subplots import make_subplots
Import OS
Import Tensorflow sebagai TF
dari TensorFlow.keras.Preprocessing Impor Import
dari tensorflow.keras.preprocessing.Image Import Imagedatagenerator


#Setting Style Grid 
sns.set_style ('DarkGrid')

Penyediaan data

Kami memerlukan dataset dengan gambar skrip api dan bukan api untuk melatih algoritma kami. DataFrame kosong dan fungsi untuk menambah imej dari Google Drive kami kepadanya akan dibuat.

 # Buat nama data kosong
df = pd.dataFrame (lajur = ['path', 'label'])

# Berfungsi untuk menambahkan imej ke dalam data data
def add_images_to_df (direktori, label):
    Untuk Dirname, _, Filenames dalam OS.Walk (direktori):
        Untuk nama fail dalam nama fail:
            df.loc [len (df)] = [os.path.join (dirname, nama fail), label]

# Tambahkan gambar api
add_images_to_df ('/kandungan/drive/mydrive/fire/fire_dataset/fire_images', 'api')

# Tambah gambar bukan api
add_images_to_df ('/kandungan/drive/mydrive/fire/fire_dataset/non_fire_images', 'non_fire')

# Shuffle dataset
df = df.sample (frac = 1) .reset_index (drop = true)

Menggambarkan pengagihan imej

Menggambarkan pengedaran imej api dan bukan kebakaran membantu kita memahami dataset kita dengan lebih baik. Kami akan menggunakan plot untuk plot interaktif.

Membuat carta pai untuk pengedaran gambar

Marilah kita buat carta pai untuk pengedaran imej.

 # Buat plot penyebaran
Rajah = px.scatter (
    data_frame = df,
    x = df.index,
    y = 'label',
    warna = 'label',
    Tajuk = 'Pengedaran Imej Kebakaran dan Bukan Kebakaran'
)

# Kemas kini saiz penanda
fig.update_traces (marker_size = 2)

fig.add_trace (go.pie (nilai = df ['label']. value_counts (). to_numpy (), label = df ['label']. value_counts ().

Memaparkan gambar api dan bukan api

Marilah kita menulis kod untuk memaparkan imej api dan bukan api.

 def visualise_images (label, tajuk):
    data = df [df ['label'] == label]
    gambar = 6 # Tetapkan bilangan gambar
    Rajah, kapak = plt.subplots (int (pics // 2), 2, figsize = (15, 15))
    PLT.SUPTITLE (tajuk)
    kapak = ax.ravel ()
    untuk i dalam julat ((pics // 2) * 2):
        path = data.sample (1) .loc [:, 'path']. to_numpy () [0]
        img = image.load_img (jalan)
        img = image.img_to_array (img) / 255
        Ax [i] .Imshow (IMG)
        kapak [i] .axes.xaxis.set_visible (palsu)
        kapak [i] .axes.yaxis.set_visible (palsu)
Visualise_images ('api', 'imej dengan api')
Visualising_images ('non_fire', 'imej tanpa api') 

Dengan memaparkan beberapa gambar sampel dari kedua-dua kategori kebakaran dan bukan api, kita akan mendapat gambaran tentang model kami.

Meningkatkan data latihan dengan teknik pembesaran

Kami akan menggunakan cara tambahan imej untuk memperbaiki data latihan kami. Memohon penyesuaian imej sewenang -wenang, sama seperti gyration, drone, dan ricih, dikenali sebagai tambahan. Dengan menghasilkan dataset yang lebih mantap dan berbeza, prosedur ini meningkatkan keupayaan model untuk umum kepada imej baru.

 dari tensorflow.keras.Models Import Sequential
dari tensorflow.keras.layers import conv2d, maxpool2d, flatten, padat

penjana = ImageDatagenerator (
    putaran_range = 20,
    width_shift_range = 0.1,
    ketinggian_shift_range = 0.1,
    shear_range = 2,
    zoom_range = 0.2,
    Rescale = 1/255,
    pengesahan_split = 0.2,
)
train_gen = generator.flow_from_dataframe (df, x_col = 'path', y_col = 'label', images_size = (256,256), class_mode = 'binari', subset = 'latihan')
val_gen = generator.flow_from_dataframe (df, x_col = 'path', y_col = 'label', images_size = (256,256), class_mode = 'binari', subset = 'pengesahan')
class_indices = {}
Untuk kunci dalam train_gen.class_indices.keys ():
    class_indices [train_gen.class_indices [key]] = key
    
cetak (class_indices)

Menggambarkan imej tambahan

Kami boleh memvisualisasikan beberapa imej tambahan yang dihasilkan oleh set latihan kami.

 sns.set_style ('gelap')
gambar = 6 # Tetapkan bilangan gambar
Rajah, kapak = plt.subplots (int (pics // 2), 2, figsize = (15, 15))
PLT.SUPTITLE ('Imej yang dihasilkan dalam set latihan')
kapak = ax.ravel ()
untuk i dalam julat ((pics // 2) * 2):
    kapak [i] .imshow (train_gen [0] [0] [i])
    kapak [i] .axes.xaxis.set_visible (palsu)
    kapak [i] .axes.yaxis.set_visible (palsu)

Membina Model Pengesanan Kebakaran

Model kami akan sesuai dengan beberapa lapisan konvolusi, masing-masing diikuti dengan subcaste maksimum. Lapisan konvolusi adalah blok struktur teras CNNs, yang membolehkan model untuk mempelajari skala spatial ciri dari imej. Lapisan max-couling membantu mengurangkan dimensi peta titik, menjadikan model lebih berkesan. Kami juga akan menambah lapisan yang disambungkan sepenuhnya (tebal) ke arah akhir model. Lapisan ini membantu menggabungkan ciri -ciri yang dipelajari oleh lapisan konvolusi dan membuat keputusan pendirian akhir. Subcaste Affair akan mempunyai neuron tunggal dengan fungsi pengaktifan sigmoid, yang membiayai skor kebarangkalian yang menunjukkan sama ada imej itu mengandungi api. Selepas menentukan model Armature, kami akan menerbitkan ringkasan untuk mengkaji struktur dan bilangan parameter dalam setiap subcaste. Langkah ini penting untuk memastikan model itu dikonfigurasi dengan betul.

 dari tensorflow.keras.Models Import Sequential
dari tensorflow.keras.layers import conv2d, maxpool2d, flatten, padat

model = berurutan ()
model.add (conv2d (penapis = 32, kernel_size = (2,2), pengaktifan = 'relu', input_shape = (256,256,3)))
Model.Add (MaxPool2D ())
model.add (conv2d (penapis = 64, kernel_size = (2,2), pengaktifan = 'relu'))
Model.Add (MaxPool2D ())
Model.Add (conv2d (penapis = 128, kernel_size = (2,2), pengaktifan = 'relu'))
Model.Add (MaxPool2D ())
Model.Add (flatten ())
Model.Add (padat (64, pengaktifan = 'relu'))
model.add (padat (32, pengaktifan = 'relu'))
model.add (padat (1, pengaktifan = 'sigmoid'))
model.summary ()

Menyusun model dengan pengoptimuman dan fungsi kerugian

Seterusnya, kami akan menyusun model menggunakan pengoptimuman Adam dan fungsi kehilangan silang entropi binari. Pengoptimuman Adam digunakan secara meluas dalam pembelajaran mendalam untuk kecekapan dan kadar pembelajaran adaptifnya. Entropi silang binari sesuai untuk masalah klasifikasi binari kami (kebakaran vs bukan api).

Kami juga akan menentukan metrik tambahan, seperti ketepatan, ingat, dan kawasan di bawah lengkung (AUC), untuk menilai prestasi model semasa latihan dan pengesahan.

Menambah panggilan balik untuk latihan yang optimum

Callbacks adalah ciri yang kuat dalam Tensorflow yang membolehkan kita memantau dan mengawal proses latihan. Kami akan menggunakan dua panggilan balik penting:

• Awalnya: Menghentikan latihan apabila kehilangan pengesahan berhenti bertambah baik, menghalang overfitting.
• ReducelronPlateau: Mengurangkan kadar pembelajaran apabila dataran kehilangan pengesahan, membantu model menumpu kepada penyelesaian yang lebih baik.

 Model #compiling
dari tensorflow.keras.Metrics Import Recall, AUC
dari tensorflow.keras.utils import plot_model

Model

#Deksi panggilan balik
dari tensorflow.keras.Callbacks Import Earlystopping, ReducelronPlateau
Early_stoppping = EarlyStopping (monitor = 'val_loss', kesabaran = 5, restore_best_weights = true)
mengurangkan_lr_on_plateau = reducelronplateau (monitor = 'val_loss', faktor = 0.1, kesabaran = 5)

Pemasangan Model: Latihan Rangkaian Neural Convolutional

Model pemasangan merujuk kepada proses latihan model pembelajaran mesin pada dataset. Semasa proses ini, model mempelajari corak asas dalam data dengan menyesuaikan parameternya (berat dan bias) untuk meminimumkan fungsi kerugian. Dalam konteks pembelajaran yang mendalam, ini melibatkan beberapa zaman ke hadapan dan ke belakang melalui data latihan.

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

Menilai model

Selepas latihan, kami akan menilai prestasi model pada set pengesahan. Langkah ini membantu kita memahami bagaimana model umum kepada data baru. Kami juga akan memvisualisasikan sejarah latihan untuk melihat bagaimana kehilangan dan metrik berkembang dari masa ke masa.

 eval_list = model.evaluuate (val_gen, return_dict = true)
untuk metrik dalam eval_list.keys ():
    cetak (metrik f ": {eval_list [metric] :. 2f}")
   
eval_list = model.evaluuate (val_gen, return_dict = true)
untuk metrik dalam eval_list.keys ():
    cetak (metrik f ": {eval_list [metric] :. 2f}")

Contoh Penggunaan: Meramalkan Kebakaran dalam Imej Baru

Akhirnya, kami akan menunjukkan cara menggunakan model terlatih untuk meramalkan sama ada imej baru mengandungi kebakaran. Langkah ini melibatkan memuatkan imej, memprosesnya untuk memadankan keperluan input model, dan menggunakan model untuk membuat ramalan.

Memuat turun dan memuatkan gambar

Kami akan memuat turun gambar sampel dari internet dan memuatkannya menggunakan fungsi pemprosesan imej TensorFlow. Langkah ini melibatkan mengubah saiz imej dan menormalkan nilai pikselnya.

Membuat ramalan

Menggunakan model terlatih, kami akan membuat ramalan pada imej yang dimuatkan. Model ini akan mengeluarkan skor kebarangkalian, yang akan kami bulat untuk mendapatkan klasifikasi binari (kebakaran atau bukan api). Kami juga akan memetakan ramalan ke labelnya yang sama menggunakan indeks kelas.

 # Memuat turun gambar
! curl https://static01.nyt.com/images/2021/02/19/world/19storm-briefing-texas-fire/19storm-briefing-texas-fire-articlelarge.jpg --Output Predict.jpg
#Mengerahkan imej
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, paksi = 0)

Cetak ("Bentuk Imej", IMG.Shape)

ramalan = int (tf.round (model.predict (x = img)). numpy () [0] [0])
Cetak ("Nilai yang diramalkan ialah:", Ramalan, "dan label yang diramalkan ialah:", Class_indices [Ramalan]) 

Kesimpulan

Membangunkan sistem pengesanan kebakaran berasaskan pembelajaran yang mendalam seperti "Flame Guardian" mencontohkan potensi transformasi pembelajaran mendalam dalam menangani cabaran dunia nyata. Dengan teliti mengikuti setiap langkah, dari penyediaan data dan visualisasi untuk membina model, latihan, dan penilaian, kami telah membuat rangka kerja yang mantap untuk mengesan kebakaran dalam imej. Projek ini bukan sahaja menyoroti kerumitan teknikal yang melibatkan pembelajaran mendalam tetapi juga menekankan pentingnya memanfaatkan teknologi untuk pencegahan keselamatan dan bencana.

Seperti yang kita buat, jelas bahawa model DL dapat meningkatkan sistem pengesanan kebakaran dengan ketara, menjadikannya lebih cekap, boleh dipercayai, dan berskala. Walaupun kaedah tradisional mempunyai merit mereka, penggabungan pembelajaran mendalam memperkenalkan tahap kecanggihan dan ketepatan baru. Perjalanan membangunkan "Flame Guardian" telah mencerahkan dan memberi ganjaran, mempamerkan keupayaan teknologi moden yang besar.

Takeaways utama

• Memahami pengendalian data dan teknik visualisasi.
• Memahami pengumpulan dan pembesaran data yang betul memastikan latihan model dan penyebaran model yang berkesan.
• Bangunan model dan penilaian model yang dilaksanakan.
• Memahami panggilan balik seperti Earlystopping dan ReducelronPlateau untuk mengoptimumkan latihan dan mencegah overfitting.
• Bangunan Rangkaian Neural Convolutional untuk Pengesanan Kebakaran Menggunakan CNN.

Soalan yang sering ditanya

A. "Flame Guardian" adalah sistem pengesanan kebakaran yang menggunakan rangkaian saraf konvensional (CNNs) dan Tensorflow untuk mengenal pasti kebakaran dalam imej dengan ketepatan yang tinggi.

A. Pengesanan api awal adalah penting untuk mencegah kerosakan yang meluas, menyelamatkan nyawa, dan mengurangkan kesan alam sekitar kebakaran. Tanggapan yang cepat dapat mengurangkan kesan buruk dari kebakaran hutan dan kebakaran struktur.

A. Cabaran termasuk mengendalikan kebolehubahan data (perbezaan warna, intensiti, dan persekitaran), meminimumkan positif palsu, memastikan keupayaan pemprosesan masa nyata, dan skalabiliti untuk mengendalikan dataset yang besar.

A. Peningkatan imej meningkatkan dataset latihan dengan menggunakan transformasi rawak seperti putaran, zum, dan ricih. Ini membantu model umum dengan lebih baik dengan mendedahkannya kepada pelbagai senario, meningkatkan keteguhannya.

A. Model ini dinilai menggunakan metrik seperti ketepatan, ingat, dan kawasan di bawah lengkung (AUC). Metrik ini membantu menilai sejauh mana model membezakan antara imej kebakaran dan bukan kebakaran dan kebolehpercayaan keseluruhannya.

Media yang ditunjukkan dalam artikel ini tidak dimiliki oleh Analytics Vidhya dan digunakan atas budi bicara penulis.

Atas ialah kandungan terperinci Flame Guardian: Sistem Pengesanan Kebakaran Berasaskan Pembelajaran Deep. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!