Image Classification merupakan tugas yang bahkan dapat dilakukan oleh seorang bayi dalam hitungan detik, tetapi untuk mesin, ini merupakan tugas yang berat hingga kemajuan terkini dalam dan Pembelajaran Mendalam . Mobil self-driving dapat mendeteksi objek dan mengambil tindakan yang diperlukan secara real-time dan sebagian besar dimungkinkan karena Klasifikasi Gambar. Dalam artikel ini, saya akan memandu Anda melalui topik-topik berikut:
- Apa itu TensorFlow?
- Apa itu Klasifikasi Gambar?
- Klasifikasi Gambar TensorFlow: Fashion MNIST
- CIFAR 10: CNN
Apa itu TensorFlow?
TensorFlow adalah Kerangka Kerja Pembelajaran Mesin Sumber Terbuka Google untuk pemrograman aliran data di berbagai tugas. Node dalam grafik mewakili operasi matematika, sedangkan tepi grafik mewakili array data multi-dimensi yang dikomunikasikan di antara mereka.
Tensor hanyalah array multidimensi, perpanjangan dari tabel 2 dimensi ke data dengan dimensi yang lebih tinggi. Ada banyak fitur Tensorflow yang membuatnya sesuai untuk Deep Learning dan pustaka sumber terbuka intinya membantu Anda mengembangkan dan melatih model ML.
Apa itu Klasifikasi Gambar?
Tujuan dari Image Classification adalah untuk mengkategorikan semua piksel dalam gambar digital menjadi salah satu dari beberapa tutupan lahan kelas atau tema . Data yang dikategorikan ini kemudian dapat digunakan untuk menghasilkan peta tematik dari tutupan lahan yang ada dalam gambar.
Sekarang Bergantung pada interaksi antara analis dan komputer selama klasifikasi, ada dua jenis klasifikasi:
- Diawasi &
- Tidak diawasi
Jadi, tanpa membuang waktu, mari beralih ke Klasifikasi Gambar TensorFlow. Saya punya 2 contoh: mudah dan sulit. Mari kita lanjutkan dengan yang mudah.
Klasifikasi Gambar TensorFlow: Fashion MNIST
Fashion MNIST Dataset
Disini kita akan menggunakan Fashion MNIST Dataset yang berisi 70.000 gambar grayscale dalam 10 kategori. Kami akan menggunakan 60.000 untuk pelatihan dan 10.000 sisanya untuk tujuan pengujian. Anda dapat mengakses Fashion MNIST langsung dari TensorFlow, cukup impor dan muat datanya.
- Mari impor pustaka terlebih dahulu
dari __future__ import absolute_import, division, print_function # TensorFlow dan tf.keras import tensorflow sebagai tf dari tensorflow import keras # Helper libraries import numpy as np import matplotlib.pyplot as plt
- Mari kita muat datanya
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- Selanjutnya, kita akan memetakan gambar ke dalam kelas
class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
- Menjelajahi data
train_images.bentuk
#Setiap Label antara 0-9
train_labels
test_images.bentuk
- Sekarang, saatnya memproses data terlebih dahulu.
plt.angka() plt.imshow(train_images[0]) plt.colorbar() plt.jaringan(Salah) plt.menunjukkan()
#Jika Anda memeriksa gambar pertama di set pelatihan, Anda akan melihat bahwa nilai piksel berada dalam kisaran 0 hingga 255.
- Kami harus menskalakan gambar dari 0-1 untuk memasukkannya ke Jaringan Neural
train_images = train_images / 255.0 test_images = test_images / 255.0
- Mari kita tampilkan beberapa gambar.
plt.angka(figsize=(10,10)) untuk saya di jarak(25): plt.subplot(5,5,saya+satu) plt.xticks([]) plt.yticks([]) plt.jaringan(Salah) plt.imshow(train_images[saya], cmap=plt.cm.biner) plt.xlabel(class_names[train_labels[saya]]) plt.menunjukkan()
- Siapkan lapisan
model = keras.Sekuensial([ keras.lapisan.Meratakan(bentuk_input=(28, 28)), keras.lapisan.Padat(128, pengaktifan=tf.no.relu), keras.lapisan.Padat(10, pengaktifan=tf.no.softmax.dll) ])
- Kompilasi Model
model.menyusun(pengoptimal='adam', kerugian='sparse_categorical_crossentropy', metrik=['ketepatan'])
- Pelatihan Model
model.cocok(train_images, train_labels, zaman=10)
- Mengevaluasi Akurasi
test_loss, test_acc = model.evaluasi(test_images, test_labels) mencetak('Akurasi uji:', test_acc)
- Membuat Prediksi
prediksi = model.meramalkan(test_images)
prediksi[0]
Prediksi adalah larik 10 angka. Ini menjelaskan 'keyakinan' model bahwa gambar tersebut sesuai dengan masing-masing dari 10 artikel pakaian yang berbeda. Kita bisa melihat label mana yang memiliki nilai kepercayaan tertinggi.
misalnya.argmax.dll(prediksi[0])#Model sangat yakin bahwa ini adalah sepatu bot pergelangan kaki. Mari kita lihat apakah itu benarHasil: 9
test_labels[0]
Hasil: 9
- Sekarang, saatnya melihat 10 saluran lengkap
def plot_image(saya, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[saya], true_label[saya], img[saya] plt.jaringan(Salah) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.biner) predict_label = misalnya.argmax.dll(predictions_array) jika predict_label == true_label: warna = 'hijau' lain: warna = 'bersih' plt.xlabel('{} {: 2.0f}% ({}) '.format(class_names[predict_label], 100*misalnya.maks(predictions_array), class_names[true_label]), warna=warna) def plot_value_array(saya, predictions_array, true_label): predictions_array, true_label = predictions_array[saya], true_label[saya] plt.jaringan(Salah) plt.xticks([]) plt.yticks([]) plot ini = plt.batang(jarak(10), predictions_array, warna='# 777777') plt.ylim([0, satu]) predict_label = misalnya.argmax.dll(predictions_array) plot ini[predict_label].set_color('bersih') plot ini[true_label].set_color('hijau')
- Mari kita lihat gambar ke-0 dan ke-10 terlebih dahulu
saya = 0 plt.angka(figsize=(6,3)) plt.subplot(satu,2,satu) plot_image(saya, prediksi, test_labels, test_images) plt.subplot(satu,2,2) plot_value_array(saya, prediksi, test_labels) plt.menunjukkan()
saya = 10 plt.angka(figsize=(6,3)) plt.subplot(satu,2,satu) plot_image(saya, prediksi, test_labels, test_images) plt.subplot(satu,2,2) plot_value_array(saya, prediksi, test_labels) plt.menunjukkan()
- Sekarang, mari kita plot beberapa gambar dan prediksi mereka. Yang benar berwarna hijau, sedangkan yang salah berwarna merah.
num_rows = 5 jumlah_kol = 3 num_images = num_rows*jumlah_kol plt.angka(figsize=(2*2*jumlah_kol, 2*num_rows)) untuk saya di jarak(num_images): plt.subplot(num_rows, 2*jumlah_kol, 2*saya+satu) plot_image(saya, prediksi, test_labels, test_images) plt.subplot(num_rows, 2*jumlah_kol, 2*saya+2) plot_value_array(saya, prediksi, test_labels) plt.menunjukkan()
- Terakhir, kita akan menggunakan model terlatih untuk membuat prediksi tentang satu gambar.
# Ambil gambar dari dataset uji img = test_images[0] mencetak(img.bentuk)
# Tambahkan gambar ke kumpulan di mana itu satu-satunya anggota. img = (misalnya.expand_dims(img,0)) mencetak(img.bentuk)
predictions_single = model.meramalkan(img) mencetak(predictions_single)plot_value_array(0, predictions_single, test_labels) plt.xticks(jarak(10), class_names, rotasi=Empat Lima) plt.menunjukkan()
prediction_result = misalnya.argmax.dll(predictions_single[0])
Hasil: 9
CIFAR-10: CNN
Dataset CIFAR-10 terdiri dari pesawat terbang, anjing, kucing, dan objek lainnya. Anda akan memproses gambar sebelumnya, lalu melatih jaringan neural konvolusional pada semua sampel. Gambar perlu dinormalisasi dan label harus dienkode dengan one-hot. Kasus penggunaan ini pasti akan menghilangkan keraguan Anda tentang Klasifikasi Gambar TensorFlow.
- Mendownload Data
dari urllib.request impor urlretrieve dari os.path impor isfile, adalah jelaga dari tqdm impor tqdm impor tarfile.dll cifar10_dataset_folder_path = 'cifar-10-kelompok-py' kelas Kemajuan Unduhan(tqdm): last_block = 0 def menghubungkan(diri, block_num=satu, Ukuran blok=satu, total_size=Tidak ada): diri.total = total_size diri.memperbarui((block_num - diri.last_block) * Ukuran blok) diri.last_block = block_num '' ' periksa apakah file data (zip) sudah diunduh jika tidak, unduh dari 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' dan simpan sebagai cifar-10-python.tar.gz '' ' jika tidak isfile('cifar-10-python.tar.gz'): dengan Kemajuan Unduhan(satuan='B', unit_scale=Benar, miniters=satu, desc='CIFAR-10 Dataset') sebagai pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.menghubungkan) jika tidak adalah jelaga(cifar10_dataset_folder_path): dengan tarfile.dll.Buka('cifar-10-python.tar.gz') sebagai ter: ter.ekstrak semua() ter.Menutup()
- Mengimpor Perpustakaan yang Diperlukan
impor acar impor numpy sebagai misalnya impor matplotlib.pyplot sebagai plt
- Memahami Data
Kumpulan data asli adalah tensor 10000 × 3072 yang dinyatakan dalam larik numpy, di mana 10000 adalah jumlah data sampel. Gambar diwarnai dan berukuran 32 × 32. Pemberian makan dapat dilakukan dalam format (lebar x tinggi x num_channel) atau (num_channel x lebar x tinggi). Mari kita tentukan labelnya.
def load_label_names(): kembali ['pesawat terbang', 'mobil', 'burung', 'kucing', 'rusa', 'anjing', 'katak', 'kuda', 'kapal', 'truk']
- Membentuk Ulang Data
Kami akan membentuk kembali data dalam dua tahap
Pertama, bagi vektor baris (3072) menjadi 3 bagian. Setiap bagian sesuai dengan setiap saluran. Ini menghasilkan dimensi tensor (3 x 1024). Kemudian Bagilah tensor yang dihasilkan dari langkah sebelumnya dengan 32. 32 di sini berarti lebar sebuah gambar. Ini menghasilkan (3x32x32).
Kedua, kita harus mentranspos data dari (num_channel, width, height) menjadi (width, height, num_channel). Untuk itu, kita akan menggunakan fungsi transpose.
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): dengan Buka(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), mode='rb') sebagai mengajukan: # perhatikan jenis pengkodeannya adalah 'latin1' batch = acar.beban(mengajukan, pengkodean='latin1') fitur = batch['data'].membentuk kembali((len(batch['data']), 3, 32, 32)).mengubah urutan(0, 2, 3, satu) label = batch['label'] kembali fitur, label
- Menjelajahi Data
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): fitur, label = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) jika tidak (0 <= sample_id < len(fitur)): mencetak('{}sampel dalam batch{}.{}berada di luar jangkauan. '.format(len(fitur), batch_id, sample_id)) kembali Tidak ada mencetak(' Statistik kelompok #{}: '.format(batch_id)) mencetak('# Sampel:{} '.format(len(fitur))) label_names = load_label_names() label_counts = dikt(zip(*misalnya.unik(label, return_counts=Benar))) untuk kunci, nilai di label_counts.item(): mencetak('Jumlah Label dari [{}] ({}):{}'.format(kunci, label_names[kunci].atas(), nilai)) contoh gambar = fitur[sample_id] sample_label = label[sample_id] mencetak(' Contoh Gambar{}: '.format(sample_id)) mencetak('Gambar - Nilai Min:{}Nilai Maks:{}'.format(contoh gambar.min(), contoh gambar.maks())) mencetak('Gambar - Bentuk:{}'.format(contoh gambar.bentuk)) mencetak('Label - Id Label:{}Nama:{}'.format(sample_label, label_names[sample_label])) plt.imshow(contoh gambar)
%matplotlib.dll Di barisan %config InlineBackend.gambar_format = 'retina' impor numpy sebagai misalnya # Jelajahi kumpulan data batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
- Menerapkan Fungsi Preprocessing
Kami akan menormalkan data melalui Min-Max Normalization. Ini hanya membuat semua nilai x berkisar antara 0 dan 1.
y = (x-menit) / (maks-menit)
def menormalkan(x): '' ' argumen - x: masukan data gambar dalam larik numpy [32, 32, 3] kembali - x dinormalisasi '' ' min_val = misalnya.min(x) max_val = misalnya.maks(x) x = (x-min_val) / (max_val-min_val) kembali x
- Encode One-Hot
def one_hot_encode(x): '' ' argumen - x: daftar label kembali - satu matriks pengkodean panas (jumlah label, jumlah kelas) '' ' dikodekan = misalnya.nol((len(x), 10)) untuk idx, jam di menghitung(x): dikodekan[idx] [jam] = satu kembali dikodekan
- Proses awal dan Simpan Data
def _preprocess_and_save(menormalkan, one_hot_encode, fitur, label, nama file): fitur = menormalkan(fitur) label = one_hot_encode(label) acar.membuang((fitur, label), Buka(nama file, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, menormalkan, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] untuk batch_i di jarak(satu, n_batches + satu): fitur, label = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # temukan indeks sebagai poin sebagai data validasi di seluruh kumpulan data batch (10%) index_of_validation = int(len(fitur) * 0.1) # praproses 90% dari seluruh kumpulan data kelompok # - menormalkan fitur # - one_hot_encode labelnya # - simpan dalam file baru bernama, 'preprocess_batch_' + batch_number # - setiap file untuk setiap kelompok _preprocess_and_save(menormalkan, one_hot_encode, fitur[:-index_of_validation], label[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # tidak seperti kumpulan data pelatihan, kumpulan data validasi akan ditambahkan melalui semua kumpulan data # - ambil 10% dari kumpulan data kumpulan data # - menambahkannya ke dalam daftar # - valid_features # - valid_labels valid_features.memperpanjang(fitur[-index_of_validation:]) valid_labels.memperpanjang(label[-index_of_validation:]) # praproses semua set data validasi yang ditumpuk _preprocess_and_save(menormalkan, one_hot_encode, misalnya.Himpunan(valid_features), misalnya.Himpunan(valid_labels), 'preprocess_validation.p') # memuat set data pengujian dengan Buka(cifar10_dataset_folder_path + '/ test_batch', mode='rb') sebagai mengajukan: batch = acar.beban(mengajukan, pengkodean='latin1') # praproses data pengujian test_features = batch['data'].membentuk kembali((len(batch['data']), 3, 32, 32)).mengubah urutan(0, 2, 3, satu) test_labels = batch['label'] # Proses awal dan Simpan semua data pengujian _preprocess_and_save(menormalkan, one_hot_encode, misalnya.Himpunan(test_features), misalnya.Himpunan(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, menormalkan, one_hot_encode)
- Pos pemeriksaan
impor acar valid_features, valid_labels = acar.beban(Buka('preprocess_validation.p', mode='rb'))
- Membangun Jaringan
Seluruh model terdiri dari 14 lapisan.
menggabungkan implementasi sortir c ++
impor tensorflow sebagai tf def konv_net(x, keep_prob): konv1_filter = tf.Variabel(tf.truncated_normal(bentuk=[3, 3, 3, 64], berarti=0, stddev=0,08)) konv2_filter = tf.Variabel(tf.truncated_normal(bentuk=[3, 3, 64, 128], berarti=0, stddev=0,08)) konv3_filter = tf.Variabel(tf.truncated_normal(bentuk=[5, 5, 128, 256], berarti=0, stddev=0,08)) konv4_filter = tf.Variabel(tf.truncated_normal(bentuk=[5, 5, 256, 512], berarti=0, stddev=0,08)) # 1, 2 konv1 = tf.no.konv2d(x, konv1_filter, langkah=[satu,satu,satu,satu], lapisan='SAMA') konv1 = tf.no.relu(konv1) konv1_pool = tf.no.max_pool(konv1, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], lapisan='SAMA') konv1_bn = tf.lapisan.batch_normalization(konv1_pool) # 3. 4 konv2 = tf.no.konv2d(konv1_bn, konv2_filter, langkah=[satu,satu,satu,satu], lapisan='SAMA') konv2 = tf.no.relu(konv2) konv2_pool = tf.no.max_pool(konv2, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], lapisan='SAMA') konv2_bn = tf.lapisan.batch_normalization(konv2_pool) # 5, 6 konv3 = tf.no.konv2d(konv2_bn, konv3_filter, langkah=[satu,satu,satu,satu], lapisan='SAMA') konv3 = tf.no.relu(konv3) konv3_pool = tf.no.max_pool(konv3, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], lapisan='SAMA') konv3_bn = tf.lapisan.batch_normalization(konv3_pool) # 7, 8 konv4 = tf.no.konv2d(konv3_bn, konv4_filter, langkah=[satu,satu,satu,satu], lapisan='SAMA') konv4 = tf.no.relu(konv4) konv4_pool = tf.no.max_pool(konv4, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], lapisan='SAMA') konv4_bn = tf.lapisan.batch_normalization(konv4_pool) # 9 datar = tf.kontrib.lapisan.meratakan(konv4_bn) # 10 full1 = tf.kontrib.lapisan.fully_connected(masukan=datar, num_outputs=128, activation_fn=tf.no.relu) full1 = tf.no.keluar(full1, keep_prob) full1 = tf.lapisan.batch_normalization(full1) # sebelas full2 = tf.kontrib.lapisan.fully_connected(masukan=full1, num_outputs=256, activation_fn=tf.no.relu) full2 = tf.no.keluar(full2, keep_prob) full2 = tf.lapisan.batch_normalization(full2) # 12 full3 = tf.kontrib.lapisan.fully_connected(masukan=full2, num_outputs=512, activation_fn=tf.no.relu) full3 = tf.no.keluar(full3, keep_prob) full3 = tf.lapisan.batch_normalization(full3) # 13 full4 = tf.kontrib.lapisan.fully_connected(masukan=full3, num_outputs=1024, activation_fn=tf.no.relu) full4 = tf.no.keluar(full4, keep_prob) full4 = tf.lapisan.batch_normalization(full4) # 14 di luar = tf.kontrib.lapisan.fully_connected(masukan=full3, num_outputs=10, activation_fn=Tidak ada) kembali di luar
- Hyperparameter
zaman = 10 batch_size = 128 keep_probability = 0.7 learning_rate = 0,001
logits = konv_net(x, keep_prob) model = tf.identitas(logits, nama='logits') # Nama logits Tensor, sehingga dapat dimuat dari disk setelah pelatihan # Loss dan Optimizer biaya = tf.reduce_mean(tf.no.softmax_cross_entropy_with_logits(logits=logits, label=Y)) pengoptimal = tf.melatih.AdamOptimizer(learning_rate=learning_rate).memperkecil(biaya) # Akurasi correct_pred = tf.sama(tf.argmax.dll(logits, satu), tf.argmax.dll(Y, satu)) ketepatan = tf.reduce_mean(tf.Pemeran(correct_pred, tf.float32), nama='ketepatan')
- Latih Jaringan Neural
#Single Optimization
def train_neural_network(sidang, pengoptimal, keep_probability, feature_batch, label_batch): sidang.Lari(pengoptimal, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: keep_probability })
#Showing Stats def print_stats(sidang, feature_batch, label_batch, biaya, ketepatan): kerugian = sess.Lari(biaya, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: satu. }) valid_acc = sess.Lari(ketepatan, feed_dict={ x: valid_features, Y: valid_labels, keep_prob: satu. }) mencetak('Kerugian:{:> 10.4f}Akurasi Validasi:{: .6f}'.format(kerugian, valid_acc))
- Pelatihan Sepenuhnya dan Menyimpan Model
def batch_features_labels(fitur, label, batch_size): '' ' Pisahkan fitur dan label menjadi beberapa kelompok '' ' untuk Mulailah di jarak(0, len(fitur), batch_size): akhir = min(Mulailah + batch_size, len(fitur)) menghasilkan fitur[Mulailah:akhir], label[Mulailah:akhir] def load_preprocess_training_batch(batch_id, batch_size): '' ' Muat data Pelatihan yang Diproses Sebelumnya dan kembalikan dalam beberapa kelompok atau kurang '' ' nama file = 'preprocess_batch_' + p(batch_id) + '.p' fitur, label = acar.beban(Buka(nama file, mode='rb')) # Kembalikan data pelatihan dalam beberapa kelompok ukuran atau kurang kembali batch_features_labels(fitur, label, batch_size)
#Saving Model dan Path
save_model_path = './image_classification' mencetak('Latihan...') dengan tf.Sidang() sebagai sess: # Menginisialisasi variabel sess.Lari(tf.global_variables_initializer()) # Siklus pelatihan untuk masa di jarak(zaman): # Ulangi semua kelompok n_batches = 5 untuk batch_i di jarak(satu, n_batches + satu): untuk batch_features, batch_labels di load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, pengoptimal, keep_probability, batch_features, batch_labels) mencetak('Masa{:> 2}, CIFAR-10 Batch{}: '.format(masa + satu, batch_i), akhir='') print_stats(sess, batch_features, batch_labels, biaya, ketepatan) # Simpan Model penghemat = tf.melatih.Penghemat() save_path = penghemat.menyimpan(sess, save_model_path)
Sekarang, bagian penting dari Klasifikasi Gambar Tensorflow sudah selesai. Sekarang, saatnya menguji modelnya.
- Menguji Model
impor acar impor numpy sebagai misalnya impor matplotlib.pyplot sebagai plt dari sklearn.preprocessing impor LabelBinarizer def batch_features_labels(fitur, label, batch_size): '' ' Pisahkan fitur dan label menjadi beberapa kelompok '' ' untuk Mulailah di jarak(0, len(fitur), batch_size): akhir = min(Mulailah + batch_size, len(fitur)) menghasilkan fitur[Mulailah:akhir], label[Mulailah:akhir] def display_image_predictions(fitur, label, prediksi, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.cocok(jarak(n_classes)) label_ids = label_binarizer.inverse_transform(misalnya.Himpunan(label)) ara, sumbu = plt.subplot(nrows=top_n_predictions, ncols=2, figsize=(dua puluh, 10)) ara.tight_layout() ara.suptitle('Prediksi Softmax', ukuran huruf=dua puluh, Y=1.1) n_predictions = 3 batas = 0,05 ind = misalnya.timbul(n_predictions) lebar = (satu. - 2. * batas) / n_predictions untuk image_i, (fitur, label_id, pred_indicies, pred_values) di menghitung(zip(fitur, label_ids, prediksi.indeks, prediksi.nilai-nilai)): jika (image_i < top_n_predictions): pred_names = [label_names[pred_i] untuk pred_i di pred_indicies] nama_koreksi = label_names[label_id] sumbu[image_i] [0].imshow((fitur*255).astype(misalnya.int32, salinan=Salah)) sumbu[image_i] [0].set_title(nama_koreksi) sumbu[image_i] [0].set_axis_off() sumbu[image_i] [satu].barh(ind + batas, pred_values[:3], lebar) sumbu[image_i] [satu].set_yticks(ind + batas) sumbu[image_i] [satu].set_yticklabels(pred_names[::-satu]) sumbu[image_i] [satu].set_xticks([0, 0,5, 1.0])
%matplotlib.dll Di barisan %config InlineBackend.gambar_format = 'retina' impor tensorflow sebagai tf impor acar impor acak save_model_path = './image_classification' batch_size = 64 n_sampel = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = acar.beban(Buka('preprocess_training.p', mode='rb')) load_graph = tf.Grafik() dengan tf.Sidang(grafik=load_graph) sebagai sess: # Muat model pemuat = tf.melatih.import_meta_graph(save_model_path + '.meta') pemuat.mengembalikan(sess, save_model_path) # Dapatkan Tensor dari model yang dimuat dimuat_x = load_graph.get_tensor_by_name('input_x: 0') load_y = load_graph.get_tensor_by_name('output_y: 0') load_keep_prob = load_graph.get_tensor_by_name('keep_prob: 0') load_logits = load_graph.get_tensor_by_name('logits: 0') dimuat_acc = load_graph.get_tensor_by_name('akurasi: 0') # Dapatkan akurasi dalam batch untuk batasan memori test_batch_acc_total = 0 test_batch_count = 0 untuk train_feature_batch, train_label_batch di batch_features_labels(test_features, test_labels, batch_size): test_batch_acc_total + = sess.Lari( dimuat_acc, feed_dict={dimuat_x: train_feature_batch, load_y: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = satu mencetak(Akurasi Pengujian:{} '.format(test_batch_acc_total/test_batch_count)) # Cetak Sampel Acak random_test_features, random_test_labels = tupel(zip(*acak.Sampel(daftar(zip(test_features, test_labels)), n_sampel))) random_test_predictions = sess.Lari( tf.no.top_k(tf.no.softmax.dll(load_logits), top_n_predictions), feed_dict={dimuat_x: random_test_features, load_y: random_test_labels, load_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
Keluaran: Akurasi Pengujian: 0,5882762738853503
Sekarang, jika Anda melatih jaringan neural untuk lebih banyak waktu atau mengubah fungsi aktivasi, Anda mungkin mendapatkan hasil berbeda yang mungkin memiliki akurasi lebih baik.
Jadi, dengan ini, kita sampai pada akhir artikel Klasifikasi Gambar TensorFlow ini. Saya yakin Anda sekarang dapat menggunakan cara yang sama untuk mengklasifikasikan gambar apa pun dan Anda bukan pemula dalam klasifikasi gambar.
Edureka's dengan Python Sertifikasi Pelatihan dikurasi oleh para profesional industri sesuai dengan kebutuhan & tuntutan industri. Anda akan menguasai konsep-konsep seperti fungsi SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kursus ini telah dikurasi secara khusus oleh pakar industri dengan studi kasus waktu nyata.