Halo, Habr! Saya hadir untuk Anda terjemahan artikel "Latih jaringan saraf pertama Anda: klasifikasi dasar" .
Ini adalah panduan pelatihan model jaringan saraf untuk mengklasifikasikan gambar pakaian seperti sepatu kets dan kemeja. Untuk membuat jaringan saraf, kami menggunakan python dan perpustakaan TensorFlow.
Instal TensorFlow
Untuk bekerja, kita membutuhkan perpustakaan berikut:
- numpy (pada baris perintah kita menulis: pip install numpy)
- matplotlib (pada baris perintah kita menulis: pip install matplotlib)
- keras (pada baris perintah kita menulis: pip install keras)
- jupyter (pada baris perintah kita menulis: pip install jupyter)
Menggunakan pip: pada baris perintah, tulis pip install tensorflow
Jika Anda mendapatkan kesalahan, Anda dapat mengunduh file .whl dan menginstalnya menggunakan pip: pip install file_path \ file_name.whl
Panduan Instalasi Resmi TensorFlow
Luncurkan Jupyter. Untuk memulai di baris perintah, tulis jupyter notebook.
Memulai
Panduan ini menggunakan dataset Fashion MNIST, yang berisi 70.000 gambar skala abu-abu dalam 10 kategori. Gambar menunjukkan masing-masing item pakaian dengan resolusi rendah (28 x 28 piksel):
Kami akan menggunakan 60.000 gambar untuk melatih jaringan dan 10.000 gambar untuk mengevaluasi seberapa akurat jaringan telah belajar untuk mengklasifikasikan gambar. Anda dapat mengakses Fashion MNIST langsung dari TensorFlow hanya dengan mengimpor dan mengunduh data:
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()
Memuat dataset mengembalikan empat array NumPy:
- Array train_images dan train_labels adalah data yang digunakan model untuk pelatihan
- Array test_images dan test_labels digunakan untuk menguji model.
Gambar adalah array NumPy 28x28 yang nilai pikselnya berkisar dari 0 hingga 255. Labelnya adalah array bilangan bulat dari 0 hingga 9. Mereka sesuai dengan kelas pakaian:
| Label | Kelas |
| 0 | T-shirt (T-shirt) |
| 1 | Celana (Celana) |
| 2 | Pullover (Sweater) |
| 3 | Pakaian |
| 4 | Mantel (Coat) |
| 5 | Sandal |
| 6 | Baju |
| 7 | Sneaker (Sepatu Sneaker) |
| 8 | Tas |
| 9 | Boot pergelangan kaki (Ankle Boots) |
Nama kelas tidak termasuk dalam kumpulan data, jadi kami meresepkannya sendiri:
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
Eksplorasi data
Pertimbangkan format kumpulan data sebelum melatih model.
train_images.shape
Pra-pemrosesan data
Sebelum menyiapkan model, data harus diproses terlebih dahulu. Jika Anda memeriksa gambar pertama dalam set pelatihan, Anda akan melihat bahwa nilai piksel berada dalam kisaran dari 0 hingga 255:
plt.figure() plt.imshow(train_images[0]) plt.colorbar() plt.grid(False)
Kami skala nilai-nilai ini ke rentang dari 0 hingga 1:
train_images = train_images / 255.0 test_images = test_images / 255.0
Kami menampilkan 25 gambar pertama dari set pelatihan dan menunjukkan nama kelas di bawah setiap gambar. Pastikan data dalam format yang benar.
plt.figure(figsize=(10,10)) for i in range(25): plt.subplot(5,5,i+1) plt.xticks([]) plt.yticks([]) plt.grid(False) plt.imshow(train_images[i], cmap=plt.cm.binary) plt.xlabel(class_names[train_labels[i]])
Bangunan model
Membangun jaringan saraf membutuhkan lapisan tuning model.
Blok bangunan utama dari jaringan saraf adalah lapisan. Sebagian besar pembelajaran mendalam terdiri dari menggabungkan lapisan sederhana. Sebagian besar layer, seperti tf.keras.layers.Dense, memiliki parameter yang dipelajari selama pelatihan.
model = keras.Sequential([ keras.layers.Flatten(input_shape=(28, 28)), keras.layers.Dense(128, activation=tf.nn.relu), keras.layers.Dense(10, activation=tf.nn.softmax) ])
Lapisan pertama dalam jaringan tf.keras.layers.Flatten mengubah format gambar dari array 2d (28 kali 28 piksel) menjadi array 1d dari 28 * 28 = 784 piksel. Lapisan ini tidak memiliki parameter untuk dipelajari, hanya memformat ulang data.
Dua lapisan berikutnya adalah tf.keras.layers.Dense. Ini adalah lapisan saraf yang terhubung erat atau sepenuhnya terhubung. Lapisan padat pertama berisi 128 node (atau neuron). Level kedua (dan terakhir) adalah sebuah layer dengan 10 node tf.nn.softmax, yang mengembalikan array dari sepuluh estimasi probabilitas, jumlah di antaranya adalah 1. Setiap node berisi estimasi yang menunjukkan kemungkinan bahwa gambar saat ini milik salah satu dari 10 kelas.
Menyusun model
Sebelum model siap untuk pelatihan, perlu beberapa pengaturan lagi. Mereka ditambahkan selama fase kompilasi model:
- Fungsi kerugian - mengukur seberapa akurat model selama pelatihan
- Pengoptimal adalah bagaimana model diperbarui berdasarkan data yang dilihatnya dan fungsi kerugian.
- Metrik (metrik) - digunakan untuk mengontrol tahapan pelatihan dan pengujian
model.compile(optimizer=tf.train.AdamOptimizer(), loss='sparse_categorical_crossentropy', metrics=['accuracy'])
Pelatihan model
Mempelajari model jaringan saraf membutuhkan langkah-langkah berikut:
- Pengajuan data pelatihan model (dalam contoh ini, array train_images dan train_labels)
- Model belajar mengaitkan gambar dan tag.
- Kami meminta model untuk membuat prediksi tentang test suite (dalam contoh ini, array test_images). Kami memeriksa kesesuaian perkiraan label dari array label (dalam contoh ini, array test_labels)
Untuk memulai pelatihan, hubungi metode model.fit:
model.fit(train_images, train_labels, epochs=5)
Saat memodelkan model, indikator kehilangan (loss) dan akurasi (acc) ditampilkan. Model ini mencapai akurasi sekitar 0,88 (atau 88%) menurut data pelatihan.
Peringkat akurasi
Bandingkan cara kerja model dalam dataset uji:
test_loss, test_acc = model.evaluate(test_images, test_labels) print('Test accuracy:', test_acc)
Ternyata keakuratan dalam dataset uji sedikit kurang dari akurasi dalam dataset pelatihan. Kesenjangan antara akurasi pelatihan dan akurasi pengujian adalah contoh pelatihan ulang. Pelatihan ulang adalah ketika model pembelajaran mesin bekerja lebih buruk dengan data baru dibandingkan dengan data pelatihan.
Peramalan
Kami menggunakan model untuk memprediksi beberapa gambar.
predictions = model.predict(test_images)
Di sini, model memprediksi label untuk setiap gambar dalam test case. Mari kita lihat prediksi pertama:
predictions[0]
Prediksi ini adalah array dari 10 angka. Mereka menggambarkan "kepercayaan diri" model yang sesuai dengan gambar masing-masing dari 10 item pakaian yang berbeda. Kita dapat melihat label mana yang memiliki nilai kepercayaan tertinggi:
np.argmax(predictions[0])
Dengan demikian, model ini paling yakin bahwa gambar ini adalah Boot kaki (Ankle boots), atau class_names [9]. Dan kita dapat memeriksa label tes untuk memastikan ini benar:
test_labels[0]
Kami akan menulis fungsi untuk memvisualisasikan prediksi ini.
def plot_image(i, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[i], true_label[i], img[i] plt.grid(False) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binary) predicted_label = np.argmax(predictions_array) if predicted_label == true_label: color = 'blue' else: color = 'red' plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label], 100*np.max(predictions_array), class_names[true_label]), color=color) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.grid(False) plt.xticks([]) plt.yticks([]) thisplot = plt.bar(range(10), predictions_array, color="#777777") plt.ylim([0, 1]) predicted_label = np.argmax(predictions_array) thisplot[predicted_label].set_color('red') thisplot[true_label].set_color('blue')
Mari kita lihat gambar ke-0, prediksi, dan berbagai prediksi.
i = 0 plt.figure(figsize=(6,3)) plt.subplot(1,2,1) plot_image(i, predictions, test_labels, test_images) plt.subplot(1,2,2) plot_value_array(i, predictions, test_labels)
Mari kita buat beberapa gambar dengan ramalan mereka. Label perkiraan yang benar berwarna biru, dan label perkiraan yang salah berwarna merah. Harap dicatat bahwa ini mungkin salah bahkan ketika dia sangat percaya diri.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figure(figsize=(2*2*num_cols, 2*num_rows)) for i in range(num_images): plt.subplot(num_rows, 2*num_cols, 2*i+1) plot_image(i, predictions, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, predictions, test_labels)
Akhirnya, kami menggunakan model yang terlatih untuk membuat prediksi tentang satu gambar.
Model Tf.keras dioptimalkan untuk membuat prediksi untuk paket (kumpulan) atau koleksi (koleksi). Karena itu, walaupun kami menggunakan satu gambar, kami perlu menambahkannya ke daftar:
Ramalan untuk gambar:
predictions_single = model.predict(img) print(predictions_single)
plot_value_array(0, predictions_single, test_labels) _ = plt.xticks(range(10), class_names, rotation=45)
np.argmax(predictions_single[0])
Seperti sebelumnya, model memprediksi label 9.
Jika Anda memiliki pertanyaan, tulis di komentar atau di pesan pribadi.