Klasifikasi Imej TensorFlow: Yang perlu anda ketahui mengenai Building Classifiers

Klasifikasi Imej merupakan tugas yang boleh dilakukan oleh bayi dalam beberapa saat, tetapi untuk mesin, ia adalah tugas yang sukar sehingga kemajuan dalam dan Pembelajaran yang mendalam . Kereta yang memandu sendiri dapat mengesan objek dan melakukan tindakan yang diperlukan dalam masa nyata dan kebanyakan ini mungkin berlaku kerana Pengelasan Imej. Dalam artikel ini, saya akan membimbing anda melalui topik berikut:

• Apa itu TensorFlow?
• Apa itu Pengelasan Imej?
• Klasifikasi Imej TensorFlow: Fesyen MNIST
• CIFAR 10: CNN

Apa itu TensorFlow?

TensorFlow adalah Kerangka Pembelajaran Mesin Sumber Terbuka Google untuk pengaturcaraan aliran data dalam pelbagai tugas. Nod dalam grafik mewakili operasi matematik, sementara tepi grafik mewakili tatasusunan data pelbagai dimensi yang dikomunikasikan di antara mereka.

Tensor hanyalah tatasusunan multidimensi, perpanjangan jadual 2 dimensi ke data dengan dimensi yang lebih tinggi. Terdapat banyak ciri Tensorflow yang menjadikannya sesuai untuk Pembelajaran Dalam dan perpustakaan sumber terbuka utamanya membantu anda mengembangkan dan melatih model ML.

Apa itu Pengelasan Imej?

Tujuan Pengelasan Imej adalah untuk mengkategorikan semua piksel dalam gambar digital menjadi salah satu daripada beberapa penutup tanah kelas atau tema . Data yang dikategorikan ini kemudiannya dapat digunakan untuk menghasilkan peta tematik penutup tanah yang terdapat dalam gambar.

Sekarang Bergantung pada interaksi antara penganalisis dan komputer semasa klasifikasi, terdapat dua jenis klasifikasi:

• Diselia &
• Tidak diawasi

Jadi, tanpa membuang masa mari masuk ke TensorFlow Image Classification. Saya mempunyai 2 contoh: mudah dan sukar. Mari teruskan dengan yang mudah.

Klasifikasi Imej TensorFlow: Fesyen MNIST

Dataset Fesyen MNIST

Di sini kita akan menggunakan Set Data Fesyen MNIST, yang mengandungi 70,000 gambar skala kelabu dalam 10 kategori. Kami akan menggunakan 60000 untuk latihan dan selebihnya 10000 untuk tujuan ujian. Anda boleh mengakses Fashion MNIST terus dari TensorFlow, hanya mengimport dan memuatkan data.

• Mari kita mengimport perpustakaan terlebih dahulu

dari __future__ import absolut_import, Division, print_function # TensorFlow dan tf.keras import tensorflow sebagai tf dari tensorflow import keras # Perpustakaan pembantu mengimport numpy sebagai np import matplotlib.pyplot sebagai plt

• Mari memuatkan data

fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()

• Seterusnya, kami akan memetakan gambar ke dalam kelas

class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

• Meneroka data

gambar kereta api.bentuk 
#Setiap Label adalah antara 0-9

kereta api_label 
gambar_percayaan.bentuk 

• Sekarang, sudah tiba masanya untuk memproses data.

plt.angka() plt.menunjukkan(gambar kereta api[0]) plt.bar warna() plt.grid(Salah) plt.tunjuk() 
#Sekiranya anda memeriksa gambar pertama dalam set latihan, anda akan melihat bahawa nilai piksel jatuh dalam lingkungan 0 hingga 255. 

• Kita harus memperbesar gambar dari 0-1 untuk memasukkannya ke dalam Neural Network

gambar kereta api = gambar kereta api / 255.0 gambar_percayaan = gambar_percayaan / 255.0

• Mari kita paparkan beberapa gambar.

plt.angka(buah ara=(10,10)) untuk i dalam julat(25): plt.subplot(5,5,i+satu) plt.xticks([]) plt.yticks([]) plt.grid(Salah) plt.menunjukkan(gambar kereta api[i], cmap=plt.cm.binari) plt.xlabel(nama_ kelas[kereta api_label[i]]) plt.tunjuk()

• Sediakan lapisan

model = keras.Berurutan([ keras.lapisan.Ratakan(input_bentuk=(28, 28)), keras.lapisan.Padat(128, pengaktifan=tf.nos.relu), keras.lapisan.Padat(10, pengaktifan=tf.nos.softmax) ])

• Menyusun Model

model.menyusun(pengoptimum='adam', kerugian='sparse_categorical_crossentropy', sukatan=['ketepatan'])

• Latihan Model

model.sesuai(gambar kereta api, kereta api_label, zaman=10)

• Menilai Ketepatan

test_loss, ujian_acc = model.menilai(gambar_percayaan, label_pengujian) mencetak('Ketepatan ujian:', ujian_acc)

• Membuat Ramalan

ramalan = model.meramalkan(gambar_percayaan)

ramalan[0]

Ramalan ialah susunan 10 nombor. Ini menggambarkan 'keyakinan' model bahawa gambar sesuai dengan masing-masing dari 10 artikel pakaian yang berbeza. Kita dapat melihat label mana yang mempunyai nilai keyakinan tertinggi.

cth..argmax(ramalan[0])#Model sangat yakin bahawa ia adalah but buku lali. Mari lihat sama ada betul

Keluaran: 9

label_pengujian[0]

Keluaran: 9

• Sekarang, inilah masanya untuk melihat rangkaian penuh 10 saluran

def gambaran plot(i, ramalan_kumpulan, label_benar, img): ramalan_kumpulan, label_benar, img = ramalan_kumpulan[i], label_benar[i], img[i] plt.grid(Salah) plt.xticks([]) plt.yticks([]) plt.menunjukkan(img, cmap=plt.cm.binari) ramalan_label = cth..argmax(ramalan_kumpulan) sekiranya ramalan_label == label_benar: warna = 'hijau' yang lain: warna = 'bersih' plt.xlabel('{} {: 2.0f}% ({}) '.format(nama_ kelas[ramalan_label], 100*cth..maks(ramalan_kumpulan), nama_ kelas[label_benar]), warna=warna) def plot_value_array(i, ramalan_kumpulan, label_benar): ramalan_kumpulan, label_benar = ramalan_kumpulan[i], label_benar[i] plt.grid(Salah) plt.xticks([]) plt.yticks([]) petak ini = plt.bar(julat(10), ramalan_kumpulan, warna='# 777777') plt.ylim([0, satu]) ramalan_label = cth..argmax(ramalan_kumpulan) petak ini[ramalan_label].set_warna('bersih') petak ini[label_benar].set_warna('hijau')

• Mari lihat gambar ke-10 dan ke-10 terlebih dahulu

i = 0 plt.angka(buah ara=(6,3)) plt.subplot(satu,2,satu) gambaran plot(i, ramalan, label_pengujian, gambar_percayaan) plt.subplot(satu,2,2) plot_value_array(i, ramalan, label_pengujian) plt.tunjuk()

i = 10 plt.angka(buah ara=(6,3)) plt.subplot(satu,2,satu) gambaran plot(i, ramalan, label_pengujian, gambar_percayaan) plt.subplot(satu,2,2) plot_value_array(i, ramalan, label_pengujian) plt.tunjuk()

• Sekarang, mari kita plot beberapa gambar dan ramalannya. Yang betul berwarna hijau, sementara yang tidak betul berwarna merah.

bilangan_ baris = 5 num_cols = 3 angka_kata = bilangan_ baris*num_cols plt.angka(buah ara=(2*2*num_cols, 2*bilangan_ baris)) untuk i dalam julat(angka_kata): plt.subplot(bilangan_ baris, 2*num_cols, 2*i+satu) gambaran plot(i, ramalan, label_pengujian, gambar_percayaan) plt.subplot(bilangan_ baris, 2*num_cols, 2*i+2) plot_value_array(i, ramalan, label_pengujian) plt.tunjuk()

• Akhirnya, kami akan menggunakan model terlatih untuk membuat ramalan mengenai satu gambar.

# Ambil gambar dari set data ujian img = gambar_percayaan[0] mencetak(img.bentuk)

# Tambahkan gambar ke kumpulan yang satu-satunya ahli. img = (cth..kembangkan_dim(img,0)) mencetak(img.bentuk)

ramalan_sendiri = model.meramalkan(img) mencetak(ramalan_sendiri)

plot_value_array(0, ramalan_sendiri, label_pengujian) plt.xticks(julat(10), nama_ kelas, putaran=Empat lima) plt.tunjuk()

• Seperti yang anda lihat ramalan untuk satu-satunya gambar kami secara berkumpulan.

ramalan_hasil = cth..argmax(ramalan_sendiri[0])

Keluaran: 9

CIFAR-10: CNN

Set data CIFAR-10 terdiri daripada kapal terbang, anjing, kucing, dan objek lain. Anda akan memproses semula gambar, kemudian melatih rangkaian saraf konvensional pada semua sampel. Gambar perlu dinormalisasi dan label perlu dikodkan sekali panas. Kes penggunaan ini pasti akan menghilangkan keraguan anda mengenai TensorFlow Image Classification.

• Memuat turun Data

dari urllib.request mengimport urlretrieve dari os. jalan mengimport isfile, adalah jelaga dari tqdm mengimport tqdm mengimport tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' kelas Kemajuan Muat turun(tqdm): sekatan terakhir = 0 def cangkuk(diri, blok_num=satu, blok_saiz=satu, jumlah saiz=Tiada): diri.jumlah = jumlah saiz diri.kemas kini((blok_num - diri.sekatan terakhir) * blok_saiz) diri.sekatan terakhir = blok_num '' ' periksa sama ada fail data (zip) sudah dimuat turun jika tidak, muat turun dari 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' dan simpan sebagai cifar-10-python.tar.gz '' ' sekiranya tidak isfile('cifar-10-python.tar.gz'): dengan Kemajuan Muat turun(unit='B', skala unit=Betul, pemodal=satu, keturunan='Set Data CIFAR-10') sebagai pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.cangkuk) sekiranya tidak adalah jelaga(cifar10_dataset_folder_path): dengan tarfile.buka('cifar-10-python.tar.gz') sebagai tar: tar.ekstrak semua() tar.tutup()

• Mengimport Perpustakaan yang Diperlukan

mengimport acar mengimport kekenyangan sebagai cth. mengimport matplotlib.pyplot sebagai plt

• Memahami Data

Kumpulan data asal adalah 10000 × 3072 tensor dinyatakan dalam susunan numpy, di mana 10000 adalah bilangan data sampel. Gambar berwarna dan bersaiz 32 × 32. Pemberian makan boleh dilakukan sama ada dalam format (lebar x tinggi x saluran_num) atau (saluran_bilangan x lebar x tinggi). Mari tentukan label.

def load_label_nama(): kembali ['kapal terbang', 'kereta', 'burung', 'kucing', 'rusa', 'anjing', 'katak', 'kuda', 'kapal', 'trak']

• Membentuk semula Data

Kami akan membentuk semula data dalam dua tahap

Pertama, bahagikan vektor baris (3072) menjadi 3 keping. Setiap bahagian sesuai dengan setiap saluran. Ini menghasilkan dimensi tensor (3 x 1024). Kemudian bahagikan tensor yang dihasilkan dari langkah sebelumnya dengan 32. 32 di sini bermaksud lebar gambar. Ini menghasilkan (3x32x32).

Kedua, kita harus memindahkan data dari (saluran_num, lebar, tinggi) ke (lebar, tinggi, saluran_num). Untuk itu, kita akan menggunakan fungsi transpose.

def muat_cfar10_batch(cifar10_dataset_folder_path, kumpulan_id): dengan buka(cifar10_dataset_folder_path + '/ data_batch_' + hlm(kumpulan_id), mod='rb') sebagai fail: # perhatikan jenis pengekodan adalah 'latin1' kumpulan = acar.memuatkan(fail, pengekodan='latin1') ciri-ciri = kumpulan['data'].membentuk semula((len(kumpulan['data']), 3, 32, 32)).menukar(0, 2, 3, satu) label = kumpulan['label'] kembali ciri-ciri, label

• Meneroka Data

def paparan_stats(cifar10_dataset_folder_path, kumpulan_id, contoh_id): ciri-ciri, label = muat_cfar10_batch(cifar10_dataset_folder_path, kumpulan_id) sekiranya tidak (0 <= contoh_id < len(ciri-ciri)): mencetak('{}sampel dalam kumpulan{}.{}berada di luar jangkauan. '.format(len(ciri-ciri), kumpulan_id, contoh_id)) kembali Tiada mencetak(' Statistik kumpulan #{}: '.format(kumpulan_id)) mencetak(# Contoh:{} '.format(len(ciri-ciri))) label_nama = load_label_nama() label_kira = imlak(zip(*cth..unik(label, pulangan_kira=Betul))) untuk kunci, nilai dalam label_kira.barang(): mencetak(Jumlah Label bagi [{}] ({}):{}'.format(kunci, label_nama[kunci].bahagian atas(), nilai)) gambar_contoh = ciri-ciri[contoh_id] label_contoh = label[contoh_id] mencetak(' Contoh Gambar{}: '.format(contoh_id)) mencetak('Imej - Nilai Min:{}Nilai Maks:{}'.format(gambar_contoh.min(), gambar_contoh.maks())) mencetak('Gambar - Bentuk:{}'.format(gambar_contoh.bentuk)) mencetak('Label - Id Label:{}Nama:{}'.format(label_contoh, label_nama[label_contoh])) plt.menunjukkan(gambar_contoh)

%matplotlib dalam barisan %konfigurasi InlineBackend.angka_format = 'retina' mengimport kekenyangan sebagai cth. # Terokai set data kumpulan_id = 3 contoh_id = 7000 paparan_stats(cifar10_dataset_folder_path, kumpulan_id, contoh_id)

• Melaksanakan Fungsi Pra-Pemprosesan

Kami akan Menormalkan data melalui Normalisasi Min-Max. Ini menjadikan semua nilai x berkisar antara 0 dan 1.
y = (x-min) / (min-min)

def menormalkan(x): '' ' hujah - x: masukan data gambar dalam susunan numpy [32, 32, 3] kembali - x dinormalisasi '' ' min_val = cth..min(x) max_val = cth..maks(x) x = (x-min_val) / (max_val-min_val) kembali x

• Pengekodan Satu Panas

def satu_hot_encode(x): '' ' hujah - x: senarai label kembali - satu matriks pengekodan panas (bilangan label, bilangan kelas) '' ' dikodkan = cth..sifar((len(x), 10)) untuk idx, jam dalam membilang(x): dikodkan[idx] [jam] = satu kembali dikodkan

• Memproses dan Menyimpan Data

def _percocess_and_save(menormalkan, satu_hot_encode, ciri-ciri, label, nama fail): ciri-ciri = menormalkan(ciri-ciri) label = satu_hot_encode(label) acar.pembuangan((ciri-ciri, label), buka(nama fail, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, menormalkan, satu_hot_encode): n_kumpulan = 5 ciri_ sah = [] label_ sah = [] untuk kumpulan_i dalam julat(satu, n_kumpulan + satu): ciri-ciri, label = muat_cfar10_batch(cifar10_dataset_folder_path, kumpulan_i) # cari indeks untuk menjadi titik sebagai data pengesahan dalam keseluruhan kumpulan data kumpulan (10%) index_of_validation = int(len(ciri-ciri) * 0.1) # memproses semula 90% daripada keseluruhan kumpulan data kumpulan # - menormalkan ciri # - one_hot_encode label # - simpan dalam fail baru bernama, 'preprocess_batch_' + batch_number # - setiap fail untuk setiap kumpulan _percocess_and_save(menormalkan, satu_hot_encode, ciri-ciri[:-index_of_validation], label[:-index_of_validation], 'preprocess_batch_' + hlm(kumpulan_i) + '.p') # tidak seperti set data latihan, set data pengesahan akan ditambahkan melalui semua kumpulan data kumpulan # - ambil 10% dari kumpulan data keseluruhan kumpulan # - tambahkan mereka ke dalam senarai # - ciri_ sah # - label_ sah ciri_ sah.memanjangkan(ciri-ciri[-index_of_validation:]) label_ sah.memanjangkan(label[-index_of_validation:]) # memproses semua set data pengesahan tersusun _percocess_and_save(menormalkan, satu_hot_encode, cth..susunan(ciri_ sah), cth..susunan(label_ sah), 'preprocess_validation.p') # muatkan set data ujian dengan buka(cifar10_dataset_folder_path + '/ test_batch', mod='rb') sebagai fail: kumpulan = acar.memuatkan(fail, pengekodan='latin1') # memproses data ujian ciri_ ujian = kumpulan['data'].membentuk semula((len(kumpulan['data']), 3, 32, 32)).menukar(0, 2, 3, satu) label_pengujian = kumpulan['label'] #Proses dan Simpan semua data ujian _percocess_and_save(menormalkan, satu_hot_encode, cth..susunan(ciri_ ujian), cth..susunan(label_pengujian), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, menormalkan, satu_hot_encode)

• Pusat Pemeriksaan

mengimport acar ciri_ sah, label_ sah = acar.memuatkan(buka('preprocess_validation.p', mod='rb'))

• Membina Rangkaian

Keseluruhan model terdiri daripada 14 lapisan secara keseluruhan.

mengimport aliran tensor sebagai tf def konvnet(x, jaga_prob): penapis1_filter = tf.Pembolehubah(tf.terpotong_ tidak normal(bentuk=[3, 3, 3, 64], bermaksud=0, stddev=0.08)) penapis2 = tf.Pembolehubah(tf.terpotong_ tidak normal(bentuk=[3, 3, 64, 128], bermaksud=0, stddev=0.08)) penapis3 = tf.Pembolehubah(tf.terpotong_ tidak normal(bentuk=[5, 5, 128, 256], bermaksud=0, stddev=0.08)) penapis4 = tf.Pembolehubah(tf.terpotong_ tidak normal(bentuk=[5, 5, 256, 512], bermaksud=0, stddev=0.08)) # 1, 2 konv1 = tf.nos.konvd(x, penapis1_filter, langkah=[satu,satu,satu,satu], pembalut='SAMA') konv1 = tf.nos.relu(konv1) conv1_pool = tf.nos.max_pool(konv1, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], pembalut='SAMA') konv1_bn = tf.lapisan.normalisasi kumpulan(conv1_pool) # 3. 4 konv2 = tf.nos.konvd(konv1_bn, penapis2, langkah=[satu,satu,satu,satu], pembalut='SAMA') konv2 = tf.nos.relu(konv2) conv2_pool = tf.nos.max_pool(konv2, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], pembalut='SAMA') konv2_bn = tf.lapisan.normalisasi kumpulan(conv2_pool) # 5, 6 konv3 = tf.nos.konvd(konv2_bn, penapis3, langkah=[satu,satu,satu,satu], pembalut='SAMA') konv3 = tf.nos.relu(konv3) conv3_pool = tf.nos.max_pool(konv3, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], pembalut='SAMA') konv3_bn = tf.lapisan.normalisasi kumpulan(conv3_pool) # 7, 8 konv4 = tf.nos.konvd(konv3_bn, penapis4, langkah=[satu,satu,satu,satu], pembalut='SAMA') konv4 = tf.nos.relu(konv4) conv4_pool = tf.nos.max_pool(konv4, ksize=[satu,2,2,satu], langkah=[satu,2,2,satu], pembalut='SAMA') konv4_bn = tf.lapisan.normalisasi kumpulan(conv4_pool) # 9 rata = tf.contrib.lapisan.ratakan(konv4_bn) # 10 penuh1 = tf.contrib.lapisan.sepenuhnya_berhubung(input=rata, num_keluaran=128, pengaktifan_fn=tf.nos.relu) penuh1 = tf.nos.tercicir(penuh1, jaga_prob) penuh1 = tf.lapisan.normalisasi kumpulan(penuh1) # sebelas penuh2 = tf.contrib.lapisan.sepenuhnya_berhubung(input=penuh1, num_keluaran=256, pengaktifan_fn=tf.nos.relu) penuh2 = tf.nos.tercicir(penuh2, jaga_prob) penuh2 = tf.lapisan.normalisasi kumpulan(penuh2) # 12 penuh3 = tf.contrib.lapisan.sepenuhnya_berhubung(input=penuh2, num_keluaran=512, pengaktifan_fn=tf.nos.relu) penuh3 = tf.nos.tercicir(penuh3, jaga_prob) penuh3 = tf.lapisan.normalisasi kumpulan(penuh3) # 13 penuh4 = tf.contrib.lapisan.sepenuhnya_berhubung(input=penuh3, num_keluaran=1024, pengaktifan_fn=tf.nos.relu) penuh4 = tf.nos.tercicir(penuh4, jaga_prob) penuh4 = tf.lapisan.normalisasi kumpulan(penuh4) # 14 keluar = tf.contrib.lapisan.sepenuhnya_berhubung(input=penuh3, num_keluaran=10, pengaktifan_fn=Tiada) kembali keluar

• Hiperparameter

zaman = 10 saiz kumpulan = 128 menjaga_probabiliti = 0.7 kadar_pelajar = 0.001

logit = konvnet(x, jaga_prob) model = tf.identiti(logit, nama='logit') # Nama log Tensor, supaya dapat dimuat dari cakera selepas latihan # Kerugian dan Pengoptimum kos = tf.kurangkan_berarti(tf.nos.softmax_cross_entropy_with_logits(logit=logit, label=Y)) pengoptimum = tf.kereta api.Pengoptimum Adam(kadar_pelajar=kadar_pelajar).kurangkan(kos) # Ketepatan betul_pred = tf.sama(tf.argmax(logit, satu), tf.argmax(Y, satu)) ketepatan = tf.kurangkan_berarti(tf.pelakon(betul_pred, tf.terapung32), nama='ketepatan')

• Latih Rangkaian Neural

# Pengoptimuman Tunggal 
def kereta api_neural_network(sesi, pengoptimum, menjaga_probabiliti, ciri_batch, label_batch): sesi.lari(pengoptimum, feed_dict={ x: ciri_batch, Y: label_batch, jaga_prob: menjaga_probabiliti })

#Menunjukkan Statistik def cetak_stats(sesi, ciri_batch, label_batch, kos, ketepatan): kerugian = sess.lari(kos, feed_dict={ x: ciri_batch, Y: label_batch, jaga_prob: satu. }) valid_acc = sess.lari(ketepatan, feed_dict={ x: ciri_ sah, Y: label_ sah, jaga_prob: satu. }) mencetak(Kerugian:{:> 10.4f}Ketepatan Pengesahan:{: .6f}'.format(kerugian, valid_acc))

• Melatih dan Menyimpan Model sepenuhnya

def batch_features_labels(ciri-ciri, label, saiz kumpulan): '' ' Pisahkan ciri dan label menjadi beberapa kumpulan '' ' untuk mulakan dalam julat(0, len(ciri-ciri), saiz kumpulan): akhir = min(mulakan + saiz kumpulan, len(ciri-ciri)) hasil ciri-ciri[mulakan:akhir], label[mulakan:akhir] def load_preprocess_training_batch(kumpulan_id, saiz kumpulan): '' ' Muatkan data Latihan yang Diproses dan kembalikan dalam kumpulan atau kurang '' ' nama fail = 'preprocess_batch_' + hlm(kumpulan_id) + '.p' ciri-ciri, label = acar.memuatkan(buka(nama fail, mod='rb')) # Kembalikan data latihan dalam beberapa ukuran atau kurang kembali batch_features_labels(ciri-ciri, label, saiz kumpulan)

#Menyimpan Model dan Laluan 
simpan_model_path = './image_classification' mencetak('Latihan...') dengan tf.Sesi() sebagai sess: # Memulakan pemboleh ubah sess.lari(tf.global_variables_initializer()) # Kitaran latihan untuk zaman dalam julat(zaman): # Gelung ke atas semua kumpulan n_kumpulan = 5 untuk kumpulan_i dalam julat(satu, n_kumpulan + satu): untuk ciri kumpulan, label_batch dalam load_preprocess_training_batch(kumpulan_i, saiz kumpulan): kereta api_neural_network(sess, pengoptimum, menjaga_probabiliti, ciri kumpulan, label_batch) mencetak('Epoch{:> 2}, Kumpulan CIFAR-10{}: '.format(zaman + satu, kumpulan_i), akhir='') cetak_stats(sess, ciri kumpulan, label_batch, kos, ketepatan) # Simpan Model penjimat = tf.kereta api.Penjimat() save_path = penjimat.berjimat(sess, simpan_model_path)

menggabungkan pelaksanaan c ++

Sekarang, bahagian penting dari Tensorflow Image Classification sudah selesai. Sekarang, sudah tiba masanya untuk menguji model.

• Menguji Model

mengimport acar mengimport kekenyangan sebagai cth. mengimport matplotlib.pyplot sebagai plt dari sklearn.preprocessing mengimport LabelBinarizer def batch_features_labels(ciri-ciri, label, saiz kumpulan): '' ' Pisahkan ciri dan label menjadi beberapa kumpulan '' ' untuk mulakan dalam julat(0, len(ciri-ciri), saiz kumpulan): akhir = min(mulakan + saiz kumpulan, len(ciri-ciri)) hasil ciri-ciri[mulakan:akhir], label[mulakan:akhir] def display_image_prediction(ciri-ciri, label, ramalan, top_n_prediksi): n_kelas = 10 label_nama = load_label_nama() label_binarizer = LabelBinarizer() label_binarizer.sesuai(julat(n_kelas)) label_id = label_binarizer.inverse_transform(cth..susunan(label)) rajah, paksi = plt.subplot(mengekang=top_n_prediksi, ncols=2, buah ara=(dua puluh, 10)) rajah.main ketat() rajah.suptitle('Ramalan Softmax', Saiz huruf=dua puluh, Y=1.1) n_prediksi = 3 margin = 0.05 ind = cth..berbaris(n_prediksi) lebar = (satu. - 2. * margin) / n_prediksi untuk gambar_i, (ciri, label_id, pred_indicies, pred_values) dalam membilang(zip(ciri-ciri, label_id, ramalan.Indeks, ramalan.nilai)): sekiranya (gambar_i < top_n_prediksi): pred_nama = [label_nama[pred_i] untuk pred_i dalam pred_indicies] betul_nama = label_nama[label_id] paksi[gambar_i] [0].menunjukkan((ciri*255).astip(cth..int32, salinan=Salah)) paksi[gambar_i] [0].set_title(betul_nama) paksi[gambar_i] [0].tetapkan_axis_off() paksi[gambar_i] [satu].barh(ind + margin, pred_values[:3], lebar) paksi[gambar_i] [satu].set_yticks(ind + margin) paksi[gambar_i] [satu].set_yticklabels(pred_nama[::-satu]) paksi[gambar_i] [satu].set_xticks([0, 0.5, 1.0])

%matplotlib dalam barisan %konfigurasi InlineBackend.angka_format = 'retina' mengimport aliran tensor sebagai tf mengimport acar mengimport rawak simpan_model_path = './image_classification' saiz kumpulan = 64 n_sampel = 10 top_n_prediksi = 5 def ujian_model(): ciri_ ujian, label_pengujian = acar.memuatkan(buka('preprocess_training.p', mod='rb')) dimuat_graf = tf.Grafik() dengan tf.Sesi(graf=dimuat_graf) sebagai sess: # Model muat pemuat = tf.kereta api.import_meta_graph(simpan_model_path + '.meta') pemuat.memulihkan(sess, simpan_model_path) # Dapatkan Tensor dari model yang dimuat dimuat_x = dimuat_graf.dapatkan_tensor_by_nama('input_x: 0') dimuat_y = dimuat_graf.dapatkan_tensor_by_nama('output_y: 0') dimuat_keep_prob = dimuat_graf.dapatkan_tensor_by_name('keep_prob: 0') dimuat_logits = dimuat_graf.dapatkan_tensor_by_nama('logit: 0') dimuat_acc = dimuat_graf.dapatkan_tensor_by_nama('ketepatan: 0') # Dapatkan ketepatan dalam kumpulan untuk had memori test_batch_acc_total = 0 test_batch_count = 0 untuk train_feature_batch, train_label_batch dalam batch_features_labels(ciri_ ujian, label_pengujian, saiz kumpulan): test_batch_acc_total + = sess.lari( dimuat_acc, feed_dict={dimuat_x: train_feature_batch, dimuat_y: train_label_batch, dimuat_keep_prob: 1.0}) test_batch_count + = satu mencetak('Menguji Ketepatan:{} '.format(test_batch_acc_total/test_batch_count)) # Cetak Sampel Rawak rawak_test_feature, label_tekstik_ rawak = tupel(zip(*rawak.contoh(senarai(zip(ciri_ ujian, label_pengujian)), n_sampel))) rawak_test_prediksi = sess.lari( tf.nos.atas_k(tf.nos.softmax(dimuat_logits), top_n_prediksi), feed_dict={dimuat_x: rawak_test_feature, dimuat_y: label_tekstik_ rawak, dimuat_keep_prob: 1.0}) display_image_prediction(rawak_test_feature, label_tekstik_ rawak, rawak_test_prediksi, top_n_prediksi) ujian_model()

Pengeluaran: Ketepatan Ujian: 0.5882762738853503

Sekarang, jika anda melatih rangkaian saraf anda untuk lebih banyak zaman atau mengubah fungsi pengaktifan, anda mungkin mendapat hasil yang berbeza yang mungkin mempunyai ketepatan yang lebih baik.

Jadi, dengan ini, kita akan mengakhiri artikel Pengelasan Imej TensorFlow ini. Saya yakin sekarang anda boleh menggunakan yang sama untuk mengklasifikasikan jenis gambar dan anda bukan pemula untuk klasifikasi gambar.

Edureka's dengan Python Certification Training dikuratori oleh profesional industri mengikut kehendak & permintaan industri. Anda akan menguasai konsep seperti fungsi SoftMax, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kursus ini telah dikuratori khas oleh pakar industri dengan kajian kes masa nyata.