TensorFlow ialah alat serba boleh untuk mencipta model pembelajaran mesin.
Dalam siaran ini, kita akan melihat cara mencipta sistem pengecaman muka dengan TensorFlow, rangka kerja pembelajaran mesin sumber terbuka. Kami akan membincangkan proses penting dalam mencipta sistem pengecaman wajah yang berjaya, daripada mengumpul dan menyediakan data untuk melatih dan menilai model.
Anda akan mendapat pengalaman langsung dengan TensorFlow untuk mencipta pengecaman muka dengan bantuan coretan kod dan contoh dunia sebenar. Anda dialu-alukan untuk mengikuti semasa kami meneruskan.
Pengenalan kepada TensorFlow
TensorFlow ialah perpustakaan percuma dan sumber terbuka. Ia ialah kotak alat matematik simbolik yang menggunakan aliran data dan pengaturcaraan boleh dibezakan. Anda boleh mengendalikan pelbagai tugas dengannya, termasuk dalam rangkaian neural latihan.
TensorFlow berkuasa dan boleh disesuaikan. Begitu juga, ia adalah alat yang hebat untuk membangunkan dan menggunakan model pembelajaran mesin. Anda boleh membina model rumit dengan beberapa lapisan dan operasi tensor. Selain itu, model pra-bina dalam perpustakaan boleh diperhalusi untuk keperluan tertentu.
Tambahan pula, TensorFlow mempunyai komuniti pengguna yang besar dan berkembang. Jadi, terdapat banyak maklumat dan bantuan untuk individu yang baru menggunakan platform.
TensorFlow popular untuk pembelajaran mesin sebahagiannya kerana ia menyediakan aliran kerja hujung ke hujung. Jadi, anda boleh membina, melatih dan menggunakan model dengan mudah. Ia menyediakan alat dan strategi untuk menambah baik dan menskalakan model agar sesuai dengan permintaan tertentu. Ia berbeza daripada pra-pemprosesan data kepada penggunaan model.
Apakah Pengecaman Wajah?
Pengecaman muka ialah a penglihatan komputer tugas yang mengenal pasti pengenalan seseorang berdasarkan wajah mereka. Teknik ini mengenali ciri-ciri wajah, seperti bentuk dan tekstur mata, hidung, dan mulut.
Dan, ia membandingkannya dengan pangkalan data wajah yang diketahui untuk mengenal pasti padanan. Pengecaman muka mempunyai beberapa kegunaan, termasuk sistem keselamatan, organisasi foto dan pengesahan biometrik.
Ketepatan algoritma pengecaman muka telah meningkat dengan ketara dalam beberapa tahun kebelakangan ini hasil daripada penemuan dalam pembelajaran mesin.
Mengimport Perpustakaan yang Diperlukan
Sebelum memulakan apa-apa, kami perlu mengimport perpustakaan yang diperlukan untuk model kami. Tensorflow (tf) diimport dan digunakan untuk mencipta dan melatih model. <(p>
"numpy" melakukan pengiraan matematik dan pemprosesan data.
“matplotlib.pyplot” diimport sebagai plt dan digunakan untuk carta data dan visualisasi.
Akhir sekali, "fetch lfw people" diimport daripada sklearn. set data dan digunakan untuk memuatkan set data pengecaman muka. Fungsi ini adalah sebahagian daripada scikit-learn toolkit. Terima kasih kepada fungsi ini, kami tidak perlu memuat naik set data lain. Ini sudah dibina dalam sckit-learn.
Dan, ia memberi anda akses kepada pelbagai jenis set data untuk pembelajaran mesin aplikasi. Dalam senario ini, kami menggunakan kaedah fetch lfw people untuk mendapatkan semula set data "Wajah Berlabel di Alam Liar" (LFW). Ia terdiri daripada foto wajah orang ramai serta label yang disertakan bersama mereka.
Perpustakaan ini penting dalam pelaksanaan dan penilaian model pengecaman muka kami.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Prapemprosesan dan Memuatkan Set Data Pengecaman Wajah
Dalam bahagian ini, kami menggunakan fungsi "ambil orang ramai" untuk pramemproses data pengecaman muka. Mula-mula, kami menggunakan ambil lfw orang dengan pilihan "muka min setiap orang=60". Ini menunjukkan bahawa kami hanya mahu memasukkan orang dalam set data yang mempunyai sekurang-kurangnya 60 foto. Oleh itu, kami memastikan model kami mempunyai data yang mencukupi untuk dipelajari. Selain itu, ini mengurangkan bahaya overfitting.
Data dan label daripada objek muka kemudiannya diekstrak dan diberikan kepada pembolehubah X dan y. X hol.
Kami kini bersedia untuk melatih model pengecaman muka kami menggunakan data dan label praproses.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Latihan Pemisahan dan Set Ujian
Dalam langkah ini, kami membahagikan set data pengecaman muka kami kepada dua bahagian menggunakan kaedah pemisahan ujian kereta api daripada pemilihan sklearn.model. Matlamat pemisahan ini adalah untuk menilai prestasi model kami selepas latihan
Fungsi pemisahan ujian kereta api menerima sebagai input data X dan label y. Dan, ia membahagikan mereka kepada set latihan dan ujian. Kami memilih saiz ujian=0.2 dalam contoh ini. Ini menunjukkan bahawa 20% daripada data akan digunakan sebagai set ujian dan 80% sebagai set latihan. Tambahan pula, kami menggunakan keadaan rawak=42 untuk memastikan data dibahagikan secara konsisten setiap kali kod dilakukan.
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
Menyediakan Data
Tujuan prapemprosesan data adalah untuk menyediakannya untuk kemasukan ke dalam model. Data dipraproses dalam kod ini dengan membahagikan setiap titik data dengan 255.
Apakah yang mendorong kami untuk mencapai ini? Normalisasi ialah prosedur prapemprosesan yang digunakan dalam pembelajaran mesin untuk menjamin bahawa semua ciri berada pada skala yang sama. Dalam senario ini, membahagikan dengan 255 menskalakan data kepada julat 0 hingga 1, yang merupakan langkah normalisasi data gambar biasa.
Ini mempercepatkan penumpuan model dan boleh meningkatkan prestasinya.
X_train = X_train / 255.0
X_test = X_test / 255.0
Mencipta Mod
Kami ingin mengenal pasti individu yang wajahnya muncul dalam gambar. Dalam kes ini, kami akan menggunakan rangkaian yang disambungkan sepenuhnya, selalunya dikenali sebagai rangkaian padat. Ia adalah rangkaian saraf tiruan yang digunakan untuk mencipta model.
Rangkaian saraf tiruan dimodelkan mengikut cara otak manusia beroperasi dan disusun. Ia terdiri daripada nod atau neuron pemprosesan maklumat yang dipautkan. Setiap neuron dalam lapisan dalam rangkaian padat dikaitkan dengan setiap neuron dalam lapisan di atasnya.
Model ini mempunyai empat lapisan dalam kod ini. Untuk dimasukkan ke lapisan seterusnya, data input diratakan dalam lapisan pertama ke dalam tatasusunan satu dimensi. 128 dan 64 neuron dalam dua lapisan berikut, dengan itu, dikaitkan sepenuhnya.
Fungsi pengaktifan ReLU ialah fungsi pengaktifan unik yang digunakan oleh lapisan ini. Dengan itu, kita boleh mendapatkan model untuk mempelajari korelasi bukan linear antara input dan output. Lapisan terakhir menggunakan fungsi pengaktifan softmax untuk membuat ramalan. Dan, ia adalah lapisan bersambung sepenuhnya dengan seberapa banyak neuron kerana terdapat kelas yang berpotensi.
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(62 * 47,)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dense(64, activation='relu'),
tf.keras.layers.Dense(len(target_names), activation='softmax')
])
Penyusunan Model
Model disusun menggunakan fungsi "kompilasi". Kita perlu menyediakan model untuk latihan. Jadi, kami akan menentukan pengoptimum, fungsi kehilangan dan metrik yang akan digunakan untuk menilai model.
Semasa latihan, pengoptimum bertanggungjawab menukar parameter model. Pengoptimum "adam" ialah teknik pengoptimuman pembelajaran mendalam yang popular.
Kami menggunakan fungsi kehilangan untuk menilai prestasi model pada data latihan. Oleh kerana label sasaran adalah integer yang mencerminkan kelas imej dan bukannya vektor dikodkan satu panas, fungsi kehilangan "silang kategori jarang" adalah baik.
Akhir sekali, kami mentakrifkan metrik untuk menilai model, dalam kes ini, "ketepatan".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Latihan Model
Kami akan menggunakan fungsi "sesuai" untuk melatih model.
Kami akan menyediakan data latihan (kereta api X) dan label berkaitan (kereta api y), serta menetapkan bilangan zaman (lelaran) untuk dijalankan sebagai 10. Prosedur latihan mengubah suai berat model untuk mengurangkan kerugian (perbezaan antara ramalan dan label sebenar) dan meningkatkan ketepatan data latihan.
model.fit(X_train, y_train, epochs=10)
Penilaian Model
Sekarang, kita perlu menilai model terlatih pada data ujian. Kami menggunakan kehilangan ujian dan ketepatan ujian digunakan untuk menilai prestasi model. Pada ujian data ujian X dan ujian label y ujian, kita perlu memanggil "fungsi model.evaluate"
Fungsi ini mengeluarkan ketepatan ujian dan kehilangan ujian. Pembolehubah menguji kehilangan dan ketepatan ujian, masing-masing mengandungi nilai ini. Akhir sekali, kami menggunakan fungsi "cetak" untuk mengeluarkan ketepatan ujian.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Meramal Kelas dan Mendapatkan Kelas Ramalan
Menggunakan model latihan dan data ujian, algoritma membuat ramalan. Apabila data ujian dihantar ke kaedah "model.predict", ia mengeluarkan tatasusunan ramalan untuk setiap gambar dalam set ujian.
Nama kelas sasaran untuk setiap gambar kemudiannya diambil daripada senarai "nama sasaran" menggunakan fungsi "np.argmax" untuk mengenal pasti indeks dengan kebarangkalian ramalan terbesar. Indeks ini kemudiannya digunakan untuk menentukan kelas ramalan bagi setiap imej.
Dengan menggunakan pemahaman senarai, semua ramalan dalam tatasusunan "ramalan" tertakluk kepada kaedah ini, menghasilkan senarai "kelas yang diramalkan".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Menggambarkan Ramalan
Kini kita boleh melihat bagaimana model kita kelihatan.
Untuk menilai prestasi model itu, 10 foto pertama dan ramalannya akan ditunjukkan. Ia akan memplot foto dalam skala kelabu dan memaparkan kedua-dua kelas sebenar imej dan kelas yang diramalkan oleh model menggunakan modul matplotlib.pyplot.
Fungsi "imshow" digunakan oleh gelung for untuk memplot setiap 10 foto set ujian pertama. Nama sasaran[y test[i]] dan kelas ramalan[i] digunakan untuk menentukan kelas sebenar imej dan kelas ramalan, masing-masing. Tajuk setiap plot kemudiannya ditunjukkan oleh klasifikasi ini.
Akhir sekali, plot dipaparkan menggunakan kaedah plt.show().
for i in range(10):
plt.imshow(X_test[i].reshape(62, 47), cmap='gray')
plt.title(f"True: {target_names[y_test[i]]}, Predicted:{predicted_classes[i]}")
plt.show()
Wrap Up
TensorFlow menawarkan persekitaran yang lengkap dan fleksibel untuk mencipta model pembelajaran mesin.
Dengan memperhalusi model untuk memenuhi keperluan tertentu atau dengan menambahkan perkembangan baharu dalam pembelajaran mesin, ketepatan model boleh ditingkatkan lagi.
TensorFlow dan pengecaman muka mungkin akan semakin digunakan dalam industri seperti sistem keselamatan, pengesahan biometrik dan penjagaan kesihatan pada masa hadapan. Kami akan melihat inovasi yang menarik tidak lama lagi.
Sila tinggalkan balasan anda