Jaringan saraf adalah konsep penting di bidang kecerdasan buatan dan pembelajaran mesin. Mereka terdiri dari simpul yang saling berhubungan, disusun berlapis-lapis, dan meniru cara kerja otak manusia. Node mewakili neuron otak manusia.
Anda dapat membuat jaringan saraf klasifikasi multi-kelas feed-forward sederhana Anda sendiri. Latih untuk mengklasifikasikan digit tulisan tangan menggunakan dataset MNIST. Anda kemudian dapat menggunakan computer vision untuk mengklasifikasikan digit tulisan tangan Anda sendiri.
Apa itu Klasifikasi Multi-Kelas?
Klasifikasi multi-kelas adalah jenis pembelajaran mesin yang dapat mengklasifikasikan data ke dalam lebih dari dua kategori. Jaringan saraf menggunakan pengklasifikasi softmax untuk mendistribusikan probabilitas atas kelas yang mungkin.
Anda dapat menggunakan klasifikasi multi-kelas untuk mengklasifikasikan gambar tulisan tangan dari kumpulan data MNIST ke dalam 10 kategori. Kategori ini akan sesuai dengan angka 0 sampai 9.
Memahami Kumpulan Data MNIST
Kumpulan data MNIST adalah kumpulan data tolok ukur yang populer untuk pembelajaran mesin dan algoritme visi komputer. Ini berisi 70.000 gambar tulisan tangan skala abu-abu yang berukuran 28 kali 28 piksel. Digit tulisan tangan berada dalam kisaran 0 hingga 9.
Sebelum membuat model pembelajaran mesin apa pun, penting untuk memahami isi kumpulan data Anda. Memahami dataset akan memungkinkan Anda untuk melakukan preprocessing data yang lebih baik.
Mempersiapkan Lingkungan Anda
Untuk mengikuti tutorial ini, Anda harus terbiasa dengan dasar-dasar Python. Anda juga harus memiliki pengetahuan dasar tentang pembelajaran mesin. Terakhir, Anda harus merasa nyaman menggunakan Jupyter Notebook atau Google Colab.
Kode sumber lengkap tersedia di a repositori GitHub.
Buat Notebook Jupyter baru atau masuk ke Google Colab. Jalankan perintah ini untuk menginstal paket yang diperlukan:
!pip instal numpy matplotlib tensorflow opencv-python
Anda akan menggunakan:
- Matplotlib untuk visualisasi data.
- NumPy untuk memanipulasi array.
- TensorFlow untuk membuat dan melatih model Anda.
- OpenCV untuk memberi makan model dengan digit tulisan tangan Anda sendiri.
Mengimpor Modul yang Diperlukan
Impor paket yang Anda instal di lingkungan Anda. Ini akan memungkinkan Anda untuk memanggil dan menggunakan fungsi dan modulnya nanti dalam kode Anda.
impor tensorflow sebagai tf
dari tensorflow impor keras
impor matplotlib.pyplot sebagai plt
%matplotlib sebaris
impor numpy sebagai np
impor cv2Baris kode kedua mengimpor modul Keras dari Pustaka Google TensorFlow. Anda akan menggunakan Keras untuk melatih jaringan saraf dalam dengan TensorFlow sebagai backend.
Memuat dan Melihat Kumpulan Data
Dataset MNIST dibangun ke dalam Keras. Muat dataset MNIST dan pisahkan menjadi set pelatihan dan pengujian. Anda akan menggunakan set pelatihan untuk melatih model Anda dan set pengujian untuk mengevaluasi keakuratan model Anda dalam mengklasifikasikan gambar baru yang tidak terlihat.
(X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
Periksa panjang set pelatihan dan tes. Dataset MNIST memiliki 60.000 gambar untuk pelatihan dan 10.000 gambar untuk pengujian.
len (X_train)
len (X_tes)Periksa bentuk gambar pertama dalam kumpulan data MNIST yang seharusnya berukuran 28 kali 28 piksel. Kemudian cetak nilai pikselnya dan visualisasikan menggunakan Matplotlib.
X_train[0].membentuk
X_train[0]
plt.matshow (X_train[0])
y_train[0]Output visualisasi adalah sebagai berikut:
Gambar yang divisualisasikan menunjukkan bahwa gambar pertama dalam dataset berisi angka lima.
Pra-pemrosesan Data
Sebelum menggunakan data dalam kumpulan data untuk melatih dan menguji model Anda, Anda perlu memprosesnya terlebih dahulu. Preprocessing meningkatkan akurasi model dengan standarisasi data.
Normalisasi Nilai Piksel
Normalisasikan nilai piksel gambar dalam kumpulan data dengan membagi setiap nilai dengan 255. Nilai piksel dari kumpulan data yang tidak dinormalisasi berkisar dari 0 hingga 255 dengan nol berwarna hitam dan 255 berwarna putih. Membagi setiap nilai piksel dengan 255 memastikan setiap piksel berada dalam kisaran antara 0 dan 1. Ini memudahkan model untuk mempelajari fitur dan pola yang relevan dalam data.
X_kereta = X_kereta / 255
X_tes = X_tes / 255Kemudian cetak nilai piksel dari gambar pertama.
X_train[0]Perhatikan mereka sekarang berada dalam kisaran antara 0 dan 1.
Mengubah Matriks Gambar Menjadi Array 1D
Lapisan masukan jaringan saraf biasanya mengharapkan masukan 1D, jadi buatlah larik 1D dari nilai piksel gambar. Untuk melakukannya, gunakan fungsi reshape() dengan jumlah raw yang diatur ke jumlah gambar dalam kumpulan data.
X_train_flattened = X_train.reshape (len (X_train), 28 * 28)
X_test_flattened = X_test.reshape (len (X_test), 28 * 28)
X_train_flattened.shape
X_train_diratakan[0]
Gambar Anda sekarang siap untuk melatih dan menguji model.
Membuat Model Deep Neural Network
Buat model berurutan dengan modul Keras Tensorflow menggunakan lapisan masukan, dua lapisan tersembunyi, dan lapisan keluaran. Atur bentuk masukan menjadi 28 kali 28 karena ini adalah bentuk gambar asli dalam kumpulan data. Gunakan 128 node untuk lapisan tersembunyi. Lapisan keluaran harus memiliki 10 neuron saja karena Anda hanya mengklasifikasikan angka 0 hingga 9.
model = keras. Sekuensial([
keras.layers. Ratakan (input_shape=(28, 28)),keras.layers. Padat(128, aktivasi='relu'),
keras.layers. Padat(128, aktivasi='relu'),
keras.layers. Padat(10, aktivasi='softmax')
])
Mengkompilasi model menggunakan adam pengoptimal, sparse_categorical_crossentropy sebagai fungsi kerugian, dan metrik untuk mengevaluasi kinerja model sebagai ketepatan. Kemudian paskan data pelatihan ke dalam model dan atur jumlah epoch menjadi lima.
model.kompilasi (pengoptimal='adam',
kerugian='sparse_categorical_crossentropy',
metrik=['ketepatan'])
model.fit (X_train, y_train, epochs=5)
Model akan memakan waktu beberapa menit untuk berlatih. Setelah pelatihan model selesai, evaluasi kinerjanya pada set pengujian.
model.evaluasi (X_test, y_test)
Fungsi evaluasi akan mengembalikan kehilangan dan akurasi model. Model tersebut menghasilkan akurasi sebesar 98%.
Menggunakan Model untuk Mengklasifikasikan Digit Tulisan Tangan Anda Sendiri
Untuk mengklasifikasikan digit tulisan tangan Anda sendiri, Anda perlu menyiapkan gambar agar sesuai dengan dataset MNIST. Gagal melakukannya akan menyebabkan model Anda berkinerja buruk.
Untuk melakukan praproses gambar:
- Muat gambar yang berisi digit menggunakan OpenCV.
- Konversikan ke skala abu-abu dan ubah ukurannya menjadi 28 kali 28 piksel.
- Balik dan normalkan nilai piksel.
- Terakhir, ratakan gambar menjadi larik 1D.
Lewati gambar yang diproses sebelumnya ke dalam model untuk prediksi dan cetak nilai prediksi di layar.
img = cv2.imread('digit/digit1.png', cv2.IMREAD_GRAYSCALE)
img_resize = cv2.ubah ukuran (img, (28, 28))
img_flip = cv2.bitwise_not (img_resize)
img_normalisasi = img_flip.astype('float32') / 255.0# Ratakan gambar menjadi larik 1D
input_data = img_normalized.flatten().reshape( 1,28,28)
# Membuat prediksi menggunakan model
prediksi = model.prediksi (input_data)
mencetak (f'Prediksi: {np.argmax (prediksi)}')
Meneruskan gambar yang telah diproses sebelumnya yang berisi nomor ke model.
Output dari model adalah sebagai berikut:
Model mampu mengklasifikasikan angka tujuh dengan benar.
Jaringan Neural di Chatbots
Penggunaan jaringan Neural telah meledak dalam beberapa tahun terakhir. Mereka sebagian besar digunakan dalam pemrosesan bahasa alami untuk terjemahan bahasa dan AI generatif.
Baru-baru ini, telah terjadi peningkatan jumlah chatbot yang dapat berkomunikasi dengan cara yang mirip manusia. Mereka menggunakan jenis jaringan saraf yang dikenal sebagai jaringan saraf transformator. Berinteraksi dengan beberapa dari mereka dan rasakan kekuatan jaringan saraf.
