TensorFlow adalah alat serbaguna untuk membuat model pembelajaran mesin.
Dalam postingan ini, kita akan melihat cara membuat sistem pengenalan wajah dengan TensorFlow, framework pembelajaran mesin sumber terbuka. Kami akan membahas proses penting dalam menciptakan sistem pengenalan wajah yang sukses, mulai dari mengumpulkan dan menyiapkan data hingga melatih dan menilai model.
Anda akan mendapatkan pengalaman langsung dengan TensorFlow untuk membuat pengenalan wajah dengan bantuan cuplikan kode dan contoh dunia nyata. Anda dipersilakan untuk mengikuti saat kami melanjutkan.
Pengantar TensorFlow
TensorFlow adalah library sumber terbuka dan gratis. Ini adalah kotak alat matematika simbolis yang menggunakan aliran data dan pemrograman yang dapat dibedakan. Anda dapat menangani berbagai tugas dengannya, termasuk deep saraf jaringan pelatihan.
TensorFlow kuat dan mudah beradaptasi. Demikian juga, ini adalah alat yang hebat untuk mengembangkan dan menerapkan model pembelajaran mesin. Anda dapat membuat model rumit dengan beberapa lapisan dan operasi tensor. Selain itu, model pra-bangun di perpustakaan dapat disesuaikan untuk kebutuhan khusus.
Selain itu, TensorFlow memiliki komunitas pengguna yang besar dan berkembang. Jadi, ada banyak informasi dan bantuan untuk individu yang baru mengenal platform ini.
TensorFlow populer untuk Mesin belajar sebagian karena menyediakan alur kerja end-to-end. Jadi, Anda dapat dengan mudah membuat, melatih, dan menerapkan model. Ini menyediakan alat dan strategi untuk meningkatkan dan menskalakan model agar sesuai dengan permintaan khusus. Ini bervariasi dari pra-pemrosesan data hingga penyebaran model.
Apa itu Pengenalan Wajah?
Pengenalan wajah adalah a visi komputer tugas yang mengidentifikasi identitas seseorang berdasarkan wajahnya. Teknik ini mengenali ciri-ciri wajah, seperti bentuk dan tekstur mata, hidung, dan mulut.
Dan, itu membandingkannya dengan database wajah yang dikenal untuk mengidentifikasi kecocokan. Pengenalan wajah memiliki beberapa kegunaan, termasuk sistem keamanan, organisasi foto, dan otentikasi biometrik.
Keakuratan algoritme pengenalan wajah telah meningkat secara substansial dalam beberapa tahun terakhir sebagai hasil terobosan dalam pembelajaran mesin.
Mengimpor Perpustakaan yang Diperlukan
Sebelum memulai apa pun, kita perlu mengimpor pustaka yang diperlukan untuk model kita. Tensorflow (tf) diimpor dan digunakan untuk membuat dan melatih model. <(p>
"numpy" melakukan perhitungan matematis dan pemrosesan data.
"matplotlib.pyplot" diimpor sebagai plt dan digunakan untuk pemetaan data dan visualisasi.
Terakhir, "fetch lfw people" diimpor dari sklearn. dataset dan digunakan untuk memuat dataset pengenalan wajah. Fungsi ini adalah bagian dari toolkit scikit-learn. Berkat fungsi ini, kami tidak perlu mengunggah kumpulan data lain. Ini sudah dibangun di sckit-learn.
Dan, itu memberi Anda akses ke berbagai kumpulan data untuk pembelajaran mesin aplikasi. Dalam skenario ini, kami menggunakan metode fetch lfw people untuk mengambil dataset “Labeled Faces in the Wild” (LFW). Ini terdiri dari foto wajah orang serta label yang menyertainya.
Pustaka ini sangat penting dalam penerapan dan evaluasi model pengenalan wajah kami.
import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt from sklearn.datasets
import fetch_lfw_people
Pra-pemrosesan dan Memuat Set Data Pengenalan Wajah
Pada bagian ini, kami menggunakan fungsi "ambil orang lfw" untuk memproses data pengenalan wajah. Pertama, kami menggunakan ambil lfw orang dengan opsi “min face per person=60”. Ini menunjukkan bahwa kami hanya ingin menyertakan orang dalam kumpulan data yang memiliki setidaknya 60 foto. Oleh karena itu, kami memastikan bahwa model kami memiliki data yang memadai untuk dipelajari. Juga, ini menurunkan risiko overfitting.
Data dan label dari objek face kemudian diekstraksi dan diberikan ke variabel X dan y. X hol.
Kami sekarang siap untuk melatih model pengenalan wajah kami menggunakan data dan label yang diproses sebelumnya.
faces = fetch_lfw_people(min_faces_per_person=60)
X = faces.data
y = faces.target
target_names = faces.target_names
Memisahkan Set Pelatihan dan Tes
Pada langkah ini, kami membagi dataset pengenalan wajah menjadi dua bagian menggunakan metode pemisahan uji latih dari pemilihan sklearn.model. Tujuan pemisahan ini adalah untuk menilai kinerja model kami setelah pelatihan
Fungsi pemisahan tes kereta menerima sebagai input data X dan label y. Dan, itu membaginya menjadi set pelatihan dan tes. Kami memilih ukuran uji = 0.2 dalam contoh ini. Ini menyiratkan bahwa 20% dari data akan digunakan sebagai set tes dan 80% sebagai set pelatihan. Selanjutnya, kami menggunakan status acak = 42 untuk memastikan bahwa data dibagi secara konsisten setiap kali kode 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)
Mempersiapkan Data
Tujuan preprocessing data adalah mempersiapkannya untuk masuk ke dalam model. Data diproses sebelumnya dalam kode ini dengan membagi setiap titik data dengan 255.
Apa yang memotivasi kami untuk mencapai ini? Normalisasi adalah prosedur preprocessing yang digunakan dalam pembelajaran mesin untuk menjamin bahwa semua fitur berada pada skala yang sama. Dalam skenario ini, membagi dengan 255 menskalakan data ke rentang 0 hingga 1, yang merupakan langkah normalisasi data gambar biasa.
Ini mempercepat konvergensi model dan dapat meningkatkan kinerjanya.
X_train = X_train / 255.0
X_test = X_test / 255.0
Membuat Modus
Kami ingin mengidentifikasi individu yang wajahnya muncul di gambar. Dalam hal ini, kami akan menggunakan jaringan yang terhubung sepenuhnya, yang sering dikenal sebagai jaringan padat. Ini adalah jaringan saraf tiruan yang digunakan untuk membuat model.
Jaringan saraf tiruan dimodelkan setelah bagaimana otak manusia beroperasi dan diatur. Mereka terdiri dari node pemrosesan informasi atau neuron yang terhubung. Setiap neuron di lapisan dalam jaringan padat terhubung ke setiap neuron di lapisan di atasnya.
Model memiliki empat lapisan dalam kode ini. Untuk dimasukkan ke lapisan berikutnya, data masukan diratakan di lapisan pertama menjadi larik satu dimensi. Neuron 128 dan 64 dalam dua lapisan berikut, karenanya, terhubung sepenuhnya.
Fungsi aktivasi ReLU adalah fungsi aktivasi unik yang digunakan oleh lapisan ini. Dengan itu, kita bisa mendapatkan model untuk mempelajari korelasi non-linear antara input dan output. Lapisan terakhir menggunakan fungsi aktivasi softmax untuk membuat prediksi. Dan, itu adalah lapisan yang sepenuhnya terhubung dengan neuron sebanyak kelas potensial.
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 dikompilasi menggunakan fungsi "kompilasi". Kita perlu menyiapkan model untuk pelatihan. Jadi, kami akan menentukan pengoptimal, fungsi kerugian, dan metrik yang akan digunakan untuk menilai model.
Selama pelatihan, pengoptimal bertugas mengubah parameter model. Pengoptimal "adam" adalah teknik pengoptimalan pembelajaran mendalam yang populer.
Kami menggunakan fungsi kerugian untuk menilai kinerja model pada data pelatihan. Karena label target adalah bilangan bulat yang mencerminkan kelas gambar daripada vektor enkode one-hot, fungsi kerugian "sparse categorical crossentropy" menguntungkan.
Terakhir, kami mendefinisikan metrik untuk menilai model, dalam hal ini, "akurasi".
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Pelatihan Model
Kami akan menggunakan fungsi "pas" untuk melatih model.
Kami akan menyediakan data pelatihan (kereta X) dan label terkait (kereta y), serta menyetel jumlah zaman (iterasi) untuk dijalankan sebagai 10. Prosedur pelatihan mengubah bobot model untuk mengurangi kerugian (perbedaan antara diprediksi dan label nyata) dan meningkatkan akurasi data pelatihan.
model.fit(X_train, y_train, epochs=10)
Evaluasi Model
Sekarang, kita perlu menilai model yang dilatih pada data uji. Kami menggunakan kerugian pengujian dan akurasi pengujian digunakan untuk menilai kinerja model. Pada test data X test dan test labels y test, kita perlu memanggil “the model.evaluate function”
Fungsi menampilkan akurasi pengujian dan kehilangan pengujian. Kerugian uji variabel dan akurasi uji, masing-masing, mengandung nilai-nilai ini. Terakhir, kami menggunakan fungsi "cetak" untuk menampilkan akurasi pengujian.
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print("Test accuracy:", test_accuracy)
Memprediksi Kelas dan Mendapatkan Kelas yang Diprediksi
Dengan menggunakan model pelatihan dan data uji, algoritme membuat prediksi. Saat data pengujian diteruskan ke metode "model.predict", ini menghasilkan serangkaian prediksi untuk setiap gambar dalam set pengujian.
Nama kelas target untuk setiap gambar kemudian diambil dari daftar "nama target" menggunakan fungsi "np.argmax" untuk mengidentifikasi indeks dengan probabilitas prediksi terbesar. Indeks ini kemudian digunakan untuk menentukan kelas prediksi untuk setiap citra.
Dengan menggunakan pemahaman daftar, semua prediksi dalam larik "prediksi" tunduk pada metode ini, menghasilkan daftar "kelas prediksi".
predictions = model.predict(X_test)
predicted_classes = [target_names[np.argmax(prediction)] for prediction in predictions]
Memvisualisasikan Prediksi
Kita sekarang dapat melihat bagaimana model kita terlihat.
Untuk mengevaluasi seberapa baik performa model, 10 foto pertama dan prediksinya akan ditampilkan. Ini akan memplot foto dalam skala abu-abu dan menampilkan kelas sebenarnya dari gambar dan kelas yang diprediksi oleh model menggunakan modul matplotlib.pyplot.
Fungsi "imshow" digunakan oleh for loop untuk memplot masing-masing dari 10 foto set pengujian pertama. Nama target[y test[i]] dan kelas prediksi[i] masing-masing digunakan untuk menentukan kelas aktual dan kelas prediksi gambar. Judul setiap plot kemudian ditunjukkan oleh klasifikasi ini.
Terakhir, plot ditampilkan menggunakan metode 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()
Bungkus
TensorFlow menawarkan lingkungan yang lengkap dan fleksibel untuk membuat model machine learning.
Dengan menyempurnakan model untuk memenuhi persyaratan tertentu atau dengan menambahkan perkembangan baru dalam pembelajaran mesin, keakuratan model dapat ditingkatkan lebih jauh lagi.
TensorFlow dan pengenalan wajah kemungkinan akan semakin banyak digunakan dalam industri seperti sistem keamanan, autentikasi biometrik, dan layanan kesehatan di masa mendatang. Kami akan segera melihat inovasi yang menarik.
Tinggalkan Balasan