Pag-uuri ng TensorFlow Image: Ang kailangan mo lamang malaman tungkol sa Pag-uuri ng Mga Classifier

Ang artikulong TensorFlow Image Classification na ito ay magbibigay sa iyo ng isang detalyado at komprehensibong kaalaman ng pag-uuri ng imahe.

Ang Pag-uuri ng Imahe ng isang gawain na kahit na maaaring gawin ng isang sanggol sa segundo, ngunit para sa isang makina, ito ay naging isang matigas na gawain hanggang sa kamakailang pag-unlad sa at Malalim na Pag-aaral . Ang mga kotse na nagmamaneho ng sarili ay maaaring makakita ng mga bagay at gumawa ng kinakailangang aksyon sa real-time at karamihan sa mga ito ay posible dahil sa Pag-uuri ng Larawan. Sa artikulong ito, gabayan ka namin sa mga sumusunod na paksa:

Ano ang TensorFlow?

TensorFlow ang Framework ng Pag-aaral ng Open Source Machine ng Google para sa programflow ng dataflow sa iba't ibang mga gawain. Ang mga node sa grap ay kumakatawan sa mga pagpapatakbo ng matematika, habang ang mga gilid ng grap ay kumakatawan sa mga multi-dimensional na data array na naihatid sa pagitan nila.





kung paano ihinto ang programa sa java

TensorFlow-Image-Recognition
Ang mga sensor ay mga multidimensional na array lamang, isang extension ng mga 2-dimensional na talahanayan sa data na may mas mataas na sukat. Maraming mga tampok ng Tensorflow na ginagawang naaangkop para sa Deep Learning at ang pangunahing open source library ay tumutulong sa iyo na bumuo at sanayin ang mga modelo ng ML.

Ano ang Pag-uuri ng Larawan?

Ang layunin ng Pag-uuri ng Imahe ay upang ikategorya ang lahat ng mga pixel sa isang digital na imahe sa isa sa marami takip ng lupa mga klase o mga tema . Ang kategorya ng data na ito ay maaaring magamit upang makabuo mga mapang pampakay ng lupain na naroon sa isang imahe.



Nakasalalay ngayon sa pakikipag-ugnayan sa pagitan ng analista at computer sa panahon ng pag-uuri, mayroong dalawang uri ng pag-uuri:



  • Pinangangasiwaan &
  • Hindi sinusuportahan

Kaya, nang hindi nag-aaksaya ng anumang oras tumalon tayo sa Pag-uuri ng Larawan ng TensorFlow. Mayroon akong 2 mga halimbawa: madali at mahirap. Ituloy natin ang madali.

Pag-uuri ng TensorFlow Image: Fashion MNIST

Fashion MNIST Dataset

Dito ay gagamitin namin ang Fashion MNIST Dataset, na naglalaman ng 70,000 mga grayscale na imahe sa 10 kategorya. Gagamitin namin ang 60000 para sa pagsasanay at ang natitirang 10000 para sa mga layuning pagsubok. Maaari mong ma-access ang Fashion MNIST nang direkta mula sa TensorFlow, i-import at i-load lamang ang data.

  • I-import muna natin ang mga aklatan
mula sa __future__ import absolute_import, dibisyon, print_unction # TensorFlow at tf.keras i-import ang tensorflow bilang tf mula sa tensorflow import keras # Helper libraries import numpy as np import matplotlib.pyplot as plt
  • I-load natin ang data
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
  • Susunod, ilalagay namin sa mapa ang mga imahe sa mga klase
class_names = ['T-shirt / top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
  • Paggalugad sa data
train_images.Hugis 
Ang bawat label ay nasa pagitan ng 0-9
mga train_labels 
test_images.Hugis
  • Ngayon, oras na upang paunang iproseso ang data.
plt.pigura() plt.imshow(train_images[0]) plt.colorbar() plt.parilya(Mali) plt.ipakita() 
#Kung susuriin mo ang unang imahe sa hanay ng pagsasanay, makikita mo na ang mga halaga ng pixel ay nahuhulog sa saklaw na 0 hanggang 255.

  • Kailangan nating sukatin ang mga imahe mula 0-1 upang pakainin ito sa Neural Network
train_images = train_images / 255.0 test_images = test_images / 255.0
  • Ipakita ang ilang mga imahe.
plt.pigura(figsize=(10,10)) para sa ako sa saklaw(25): plt.subplot(5,5,ako+isa) plt.xticks([]) plt.yticks([]) plt.parilya(Mali) plt.imshow(train_images[ako], cmap=plt.cm.binary) plt.xlabel(class_names[mga train_labels[ako]]) plt.ipakita()
 

  • I-setup ang mga layer
modelo = mahirap.Sunud-sunod([ mahirap.mga patong.Patagin(input_shape=(28, 28)), mahirap.mga patong.Siksik(128, pagpapagana=tf.butas ng ilong.relu), mahirap.mga patong.Siksik(10, pagpapagana=tf.butas ng ilong.softmax) ])
  • Compile ang Model
modelo.magtipon(optimizer='adam', pagkawala='sparse_categorical_crossentropy', sukatan=['kawastuhan'])
  • Pagsasanay sa Modelo
modelo.magkasya(train_images, mga train_labels, mga kapanahunan=10)

  • Nasusuri ang Kawastuhan
test_loss, test_acc = modelo.suriin(test_images, test_labels) mag-print('Katumpakan sa pagsubok:', test_acc)

  • Paggawa ng Mga Hula
mga hula = modelo.hulaan(test_images)
mga hula[0]

Ang hula ay isang hanay ng 10 mga numero. Inilalarawan nito ang 'kumpiyansa' ng modelo na ang imahe ay tumutugma sa bawat isa sa 10 magkakaibang mga artikulo ng pananamit. Maaari naming makita kung aling label ang may pinakamataas na halaga ng kumpiyansa.

hal..argmax(mga hula[0])Tiwala ang #Model na ito ay isang ankle boot. Tingnan natin kung tama ito

Output: 9

test_labels[0]

Output: 9

  • Ngayon, oras na upang tingnan ang buong hanay ng 10 mga channel
def balangkas_image(ako, prediksiyon_array, true_label, img): prediksiyon_array, true_label, img = prediksiyon_array[ako], true_label[ako], img[ako] plt.parilya(Mali) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binary) hinulaang_label = hal..argmax(prediksiyon_array) kung hinulaang_label == true_label: kulay = 'berde' iba pa: kulay = 'net' plt.xlabel('{} {: 2.0f}% ({}) '.format(class_names[hinulaang_label], 100*hal..max(prediksiyon_array), class_names[true_label]), kulay=kulay) def plot_value_array(ako, prediksiyon_array, true_label): prediksiyon_array, true_label = prediksiyon_array[ako], true_label[ako] plt.parilya(Mali) plt.xticks([]) plt.yticks([]) angplot na ito = plt.bar(saklaw(10), prediksiyon_array, kulay='# 777777') plt.ylim([0, isa]) predicted_label = hal..argmax(prediksiyon_array) angplot na ito[hinulaang_label].set_color('net') angplot na ito[true_label].set_color('berde')
  • hitsura natin ang mga 0TH at ika-10 image unang
ako = 0 plt.pigura(figsize=(6,3)) plt.subplot(isa,2,isa) balangkas_image(ako, mga hula, test_labels, test_images) plt.subplot(isa,2,2) plot_value_array(ako, mga hula, test_labels) plt.ipakita()

ako = 10 plt.pigura(figsize=(6,3)) plt.subplot(isa,2,isa) balangkas_image(ako, mga hula, test_labels, test_images) plt.subplot(isa,2,2) plot_value_array(ako, mga hula, test_labels) plt.ipakita()

  • Ngayon, magbalak tayo ng maraming mga imahe at kanilang mga hula. Ang mga wasto ay berde, habang ang mga hindi wasto ay pula.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.pigura(figsize=(2*2*num_cols, 2*num_rows)) para sa ako sa saklaw(num_images): plt.subplot(num_rows, 2*num_cols, 2*ako+isa) balangkas_image(ako, mga hula, test_labels, test_images) plt.subplot(num_rows, 2*num_cols, 2*ako+2) plot_value_array(ako, mga hula, test_labels) plt.ipakita()

binary na programa sa paghahanap sa java
  • Sa wakas, gagamitin namin ang mga sinanay na mga modelo upang gumawa ng isang hula tungkol sa isang nag-iisang larawan.
# Grab ng isang imahe mula sa test dataset img = test_images[0] mag-print(img.Hugis)
# Idagdag ang imahe sa isang batch kung saan ito ay ang tanging miyembro. img = (hal..palawakin_dims(img,0)) mag-print(img.Hugis)
mga hula_single = modelo.hulaan(img) mag-print(mga hula_single)

plot_value_array(0, mga hula_single, test_labels) plt.xticks(saklaw(10), class_names, pag-ikot=Apat lima) plt.ipakita()

  • Tulad ng nakikita mo ang hula para sa aming nag-iisang imahe sa batch.
hula_resulta = hal..argmax(mga hula_single[0])

Output: 9

CIFAR-10: CNN

Ang CIFAR-10 dataset ay binubuo ng mga eroplano, aso, pusa, at iba pang mga bagay. Ihahanda mo ang mga imahe, pagkatapos ay sanayin ang isang convolutional neural network sa lahat ng mga sample. Kailangang gawing normal ang mga imahe at ang mga label ay kailangang maging isang-mainit na naka-encode. Ang case-use na ito ay tiyak na malilinaw ang iyong mga pagdududa tungkol sa Pag-uuri ng TensorFlow Image.

  • Pagda-download ng Data
mula sa urllib.request angkat urlrieveve mula sa os.path angkat isfile, ay uling mula sa tqdm angkat tqdm angkat tarfile cifar10_dataset_folder_path = 'cifar-10-batch-py' klase I-downloadProgress(tqdm): huling_block = 0 def kawit(sarili, block_num=isa, block_size=isa, Kabuuang sukat=Wala): sarili.kabuuan = Kabuuang sukat sarili.pag-update((block_num - sarili.huling_block) * block_size) sarili.huling_block = block_num '' ' suriin kung na-download na ang file ng data (zip) kung hindi, i-download ito mula sa 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' at i-save bilang cifar-10-python.tar.gz '' ' kung hindi isfile('cifar-10-python.tar.gz'): kasama si I-downloadProgress(yunit='B', unit_scale=Totoo, miniters=isa, pababa='CIFAR-10 Dataset') bilang pbar: urlrieveve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'Cifar-10-python.tar.gz', pbar.kawit) kung hindi ay uling(cifar10_dataset_folder_path): kasama si tarfile.buksan('cifar-10-python.tar.gz') bilang alkitran: alkitran.extractall() alkitran.malapit na()
  • Pag-import Kinakailangang Aklatan
angkat atsara angkat numpy bilang hal. angkat matplotlib.pyplot bilang plt
  • Pag-unawa sa Data

Ang orihinal na batch ng Data ay 10000 × 3072 tensor na ipinahayag sa isang numpy array, kung saan ang 10000 ay ang bilang ng sample na data. Ang imahe ay may kulay at may sukat na 32 × 32. Ang pagpapakain ay maaaring gawin alinman sa isang format ng (lapad x taas x num_channel) o (num_channel x lapad x taas). Tukuyin natin ang mga label.

def load_label_names(): bumalik ka ['eroplano', 'sasakyan', 'ibon', 'pusa', 'usa', 'aso', 'Palaka', 'kabayo', 'barko', 'trak']
  • Muling pagbabago ng Data

Susubukan naming ibahin ang anyo ang data sa dalawang yugto

Una, hatiin ang hilera na vector (3072) sa 3 piraso. Ang bawat piraso ay tumutugma sa bawat channel. Nagreresulta ito sa (3 x 1024) sukat ng isang tenor. Pagkatapos Hatiin ang nagresultang tenor mula sa nakaraang hakbang sa 32. 32 dito ay nangangahulugang ang lapad ng isang imahe. Nagreresulta ito sa (3x32x32).

Pangalawa, kailangan nating ibahin ang data mula sa (num_channel, lapad, taas) hanggang (lapad, taas, num_channel). Para doon, gagamitin namin ang transpose function.

pagpapaandar ng kuryente sa java para sa mga integer

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): kasama si buksan(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), mode='rb') bilang file: # tandaan ang uri ng pag-encode ay 'latin1' batch = atsara.karga(file, pag-encode='latin1') mga tampok = batch['data'].ibalik ang anyo((len(batch['data']), 3, 32, 32)).magbago(0, 2, 3, isa) mga label = batch['mga label'] bumalik ka mga tampok, tatak
  • Paggalugad sa Data
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): mga tampok, mga label = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) kung hindi (0 <= sample_id < len(mga tampok)): mag-print('{}mga sample sa batch{}.{}wala sa saklaw. '.format(len(mga tampok), batch_id, sample_id)) bumalik ka Wala mag-print(' Stats ng batch #{}: '.format(batch_id)) mag-print('# ng Mga Sampol:{} '.format(len(mga tampok))) label_names = load_label_names() mga label_count = dikta(zip(*hal..natatangi(mga label, mga return_count=Totoo))) para sa susi, halaga sa mga label_count.mga item(): mag-print('Mga Bilang ng Label ng [{}] ({}):{}'.format(susi, label_names[susi].itaas(), halaga)) sample_image = mga tampok[sample_id] sample_label = mga label[sample_id] mag-print(' Halimbawa ng Larawan{}: '.format(sample_id)) mag-print('Imahe - Min Halaga:{}Max na Halaga:{}'.format(sample_image.min(), sample_image.max())) mag-print('Larawan - Hugis:{}'.format(sample_image.Hugis)) mag-print('Label - Label Id:{}Pangalan:{}'.format(sample_label, label_names[sample_label])) plt.imshow(sample_image)
%matplotlib nasa linya %config InlineBackend.figure_format = 'retina' angkat numpy bilang hal. # Tuklasin ang dataset batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

  • Implementing Preprocessing Pag-andar

Pupuntahan Normal namin ang data sa pamamagitan ng Min-Max Normalization. Ginagawa lamang nito ang lahat ng x mga halaga upang saklaw sa pagitan ng 0 at 1.
y = (x-min) / (max-min)

def gawing normal(x): '' ' pagtatalo - x: input data ng imahe sa numpy array [32, 32, 3] bumalik ka - gawing normal x '' ' min_val = hal..min(x) max_val = hal..max(x) x = (x-min_val) / (max_val-min_val) bumalik ka x
  • One-Hot Encode
def one_hot_encode(x): '' ' pagtatalo - x: isang listahan ng mga label bumalik ka - isang mainit na encoding matrix (bilang ng mga label, bilang ng klase) '' ' naka-encode = hal..mga zero((len(x), 10)) para sa idx, oras sa bilangin(x): naka-encode[idx] [oras] = isa bumalik ka naka-encode
  • Pauna sa proseso at I-save ang Data
def _preprocess_and_save(gawing normal, one_hot_encode, mga tampok, mga label, filename): mga tampok = gawing normal(mga tampok) mga label = one_hot_encode(mga label) atsara.magtapon((mga tampok, mga label), buksan(filename, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, gawing normal, one_hot_encode): n_batches = 5 wastong mga tampok = [] valid_labels = [] para sa batch_i sa saklaw(isa, n_batches + isa): mga tampok, mga label = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # find index na maging punto bilang data ng pagpapatunay sa buong dataset ng batch (10%) index_of_validation = int(len(mga tampok) * 0.1) # preprocess ang 90% ng buong dataset ng batch # - gawing normal ang mga tampok # - one_hot_encode ang mga label # - i-save sa isang bagong file na pinangalanang, 'preprocess_batch_' + batch_number # - bawat file para sa bawat batch _preprocess_and_save(gawing normal, one_hot_encode, mga tampok[:-index_of_validation], mga label[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # Hindi katulad ng pagsasanay dataset, pagpapatunay dataset ay idadagdag sa lahat ng batch dataset # - kumuha ng 10% ng whold dataset ng batch # - idagdag ang mga ito sa isang listahan ng # - wastong_feature # - valid_labels wastong mga tampok.magpahaba(mga tampok[-index_of_validation:]) valid_labels.magpahaba(mga label[-index_of_validation:]) # Preprocess ang lahat ng stacked pagpapatunay dataset _preprocess_and_save(gawing normal, one_hot_encode, hal..array(wastong mga tampok), hal..array(valid_labels), 'preprocess_validation.p') # load ang test dataset kasama si buksan(cifar10_dataset_folder_path + '/ Test_batch', mode='rb') bilang file: batch = atsara.karga(file, pag-encode='latin1') # preprocess ang data ng pagsubok pagsubok_feature = batch['data'].ibalik ang anyo((len(batch['data']), 3, 32, 32)).magbago(0, 2, 3, isa) test_labels = batch['mga label'] # Preprocess at I-save ang lahat ng data ng pagsubok _preprocess_and_save(gawing normal, one_hot_encode, hal..array(pagsubok_feature), hal..array(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, gawing normal, one_hot_encode)
  • Checkpoint
angkat atsara wastong mga tampok, valid_labels = atsara.karga(buksan('preprocess_validation.p', mode='rb'))
  • Pagbuo ng Network

Ang buong modelo ay binubuo ng 14 na mga layer sa kabuuan.

angkat tenorflow bilang tf def conv_net(x, panatilihin_prob): conv1_filter = tf.Variable(tf.pinutol na_normal(Hugis=[3, 3, 3, 64], ibig sabihin=0, stddev=0.08)) conv2_filter = tf.Variable(tf.pinutol na_normal(Hugis=[3, 3, 64, 128], ibig sabihin=0, stddev=0.08)) conv3_filter = tf.Variable(tf.pinutol na_normal(Hugis=[5, 5, 128, 256], ibig sabihin=0, stddev=0.08)) conv4_filter = tf.Variable(tf.pinutol na_normal(Hugis=[5, 5, 256, 512], ibig sabihin=0, stddev=0.08)) # 1, 2 conv1 = tf.butas ng ilong.conv2d(x, conv1_filter, hakbang=[isa,isa,isa,isa], padding='SAME') conv1 = tf.butas ng ilong.relu(conv1) conv1_pool = tf.butas ng ilong.max_pool(conv1, ksize=[isa,2,2,isa], hakbang=[isa,2,2,isa], padding='SAME') conv1_bn = tf.mga patong.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.butas ng ilong.conv2d(conv1_bn, conv2_filter, hakbang=[isa,isa,isa,isa], padding='SAME') conv2 = tf.butas ng ilong.relu(conv2) conv2_pool = tf.butas ng ilong.max_pool(conv2, ksize=[isa,2,2,isa], hakbang=[isa,2,2,isa], padding='SAME') conv2_bn = tf.mga patong.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.butas ng ilong.conv2d(conv2_bn, conv3_filter, hakbang=[isa,isa,isa,isa], padding='SAME') conv3 = tf.butas ng ilong.relu(conv3) conv3_pool = tf.butas ng ilong.max_pool(conv3, ksize=[isa,2,2,isa], hakbang=[isa,2,2,isa], padding='SAME') conv3_bn = tf.mga patong.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.butas ng ilong.conv2d(conv3_bn, conv4_filter, hakbang=[isa,isa,isa,isa], padding='SAME') conv4 = tf.butas ng ilong.relu(conv4) conv4_pool = tf.butas ng ilong.max_pool(conv4, ksize=[isa,2,2,isa], hakbang=[isa,2,2,isa], padding='SAME') conv4_bn = tf.mga patong.batch_normalization(conv4_pool) # 9 patag = tf.kontribusyon.mga patong.patagin(conv4_bn) # 10 buong1 = tf.kontribusyon.mga patong.ganap na nakakonekta(mga input=patag, num_outputs=128, activation_fn=tf.butas ng ilong.relu) buong1 = tf.butas ng ilong.pag-dropout(buong1, panatilihin_prob) buong1 = tf.mga patong.batch_normalization(buong1) # labing-isang buong2 = tf.kontribusyon.mga patong.ganap na nakakonekta(mga input=buong1, num_outputs=256, activation_fn=tf.butas ng ilong.relu) buong2 = tf.butas ng ilong.pag-dropout(buong2, panatilihin_prob) buong2 = tf.mga patong.batch_normalization(buong2) # 12 puno3 = tf.kontribusyon.mga patong.ganap na nakakonekta(mga input=buong2, num_outputs=512, activation_fn=tf.butas ng ilong.relu) puno3 = tf.butas ng ilong.pag-dropout(puno3, panatilihin_prob) puno3 = tf.mga patong.batch_normalization(puno3) # 13 puno4 = tf.kontribusyon.mga patong.ganap na nakakonekta(mga input=puno3, num_outputs=1024, activation_fn=tf.butas ng ilong.relu) puno4 = tf.butas ng ilong.pag-dropout(puno4, panatilihin_prob) puno4 = tf.mga patong.batch_normalization(puno4) # 14 palabas = tf.kontribusyon.mga patong.ganap na nakakonekta(mga input=puno3, num_outputs=10, activation_fn=Wala) bumalik ka palabas
  • Hyperparameter
mga kapanahunan = 10 batch_size = 128 keep_probability = 0.7 natututo_rate = 0.001
mga pag-log = conv_net(x, panatilihin_prob) modelo = tf.pagkakakilanlan(mga pag-log, pangalan='mga pag-log') # Mga pag-log ng pangalan ng Tensor, upang mai-load mula sa disk pagkatapos ng pagsasanay # Pagkawala at Optimizer gastos = tf.bawasan(tf.butas ng ilong.softmax_cross_entropy_with_logits(mga pag-log=mga pag-log, mga label=Y)) optimizer = tf.sanayin.AdamOptimizer(natututo_rate=natututo_rate).i-minimize(gastos) # Kawastuhan tama_pred = tf.pantay(tf.argmax(mga pag-log, isa), tf.argmax(Y, isa)) kawastuhan = tf.bawasan(tf.cast(tama_pred, tf.lumutang32), pangalan='kawastuhan')
  • Sanayin ang Neural Network
#Single Optimization 
def
train_neural_network(sesyon, optimizer, panatilihin ang_probability, tampok_batch, label_batch): sesyon.tumakbo(optimizer, feed_dict={ x: tampok_batch, Y: label_batch, panatilihin_prob: panatilihin ang_probability })
# Pagpapakita ng Stats def print_stats(sesyon, tampok_batch, label_batch, gastos, kawastuhan): pagkawala = sess.tumakbo(gastos, feed_dict={ x: feature_batch, Y: label_batch, panatilihin_prob: isa }) valid_acc = sess.tumakbo(kawastuhan, feed_dict={ x: wastong mga tampok, Y: valid_labels, panatilihin_prob: isa }) mag-print('Pagkawala:{:> 10.4f}Pagpapatunay Kawastuhan:{: .6f}'.format(pagkawala, wastong_acc))
  • Ganap na Pagsasanay at Pag-save ng Modelo
def batch_feature_labels(mga tampok, mga label, batch_size): '' ' Hatiin ang mga tampok at label sa mga batch '' ' para sa umpisahan sa saklaw(0, len(mga tampok), batch_size): tapusin = min(umpisahan + batch_size, len(mga tampok)) ani mga tampok[umpisahan:tapusin], mga label[umpisahan:tapusin] def load_preprocess_training_batch(batch_id, batch_size): '' ' Mag-load ng data preprocessed Pagsasanay at ibalik ang mga ito sa mga batch ng o mas mababa '' ' filename = 'Preprocess_batch_' + p(batch_id) + '.p' mga tampok, mga label = atsara.karga(buksan(filename, mode='rb')) # Ibalik ang data ng pagsasanay sa mga pangkat ng laki o mas kaunti bumalik ka batch_feature_labels(mga tampok, mga label, batch_size)
#Nag-iimbak ng Modelo at Landas 
save_model_path
= './image_classification' mag-print('Pagsasanay ...') kasama si tf.Session() bilang sess: # Pinasimulan ang mga variable sess.tumakbo(tf.global_variables_initializer()) # Siklo ng pagsasanay para sa kapanahunan sa saklaw(mga kapanahunan): # Umikot sa lahat ng mga batch n_batches = 5 para sa batch_i sa saklaw(isa, n_batches + isa): para sa batch_feature, batch_labels sa load_preprocess_training_batch(batch_i, batch_size): train_neural_network(sess, optimizer, panatilihin ang_probability, batch_feature, batch_labels) mag-print('Epoch{:> 2}, CIFAR-10 Batch{}: '.format(kapanahunan + isa, batch_i), tapusin=') print_stats(sess, batch_feature, batch_labels, gastos, kawastuhan) # I-save ang Model nagtitipid = tf.sanayin.Nagtipid() save_path = nagtitipid.magtipid(sess, save_model_path)

Ngayon, ang mga mahalagang bahagi ng Tensorflow Image Pag-uuri ay tapos na. Ngayon, oras na upang subukan ang mga modelo.

  • Pagsubok sa Model
angkat atsara angkat numpy bilang hal. angkat matplotlib.pyplot bilang plt mula sa sklearn.preprocessing angkat LabelBinarizer def batch_features_labels(mga tampok, mga label, batch_size): '' ' Split mga tampok at mga label sa mga batch '' ' para sa umpisahan sa saklaw(0, len(mga tampok), batch_size): tapusin = min(umpisahan + batch_size, len(mga tampok)) ani mga tampok[umpisahan:tapusin], mga label[umpisahan:tapusin] def display_image_predictions(mga tampok, mga label, mga hula, top_n_prediksiyon): n_class = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.magkasya(saklaw(n_class)) label_ids = label_binarizer.kabaligtaran_transform(hal..array(mga label)) igos, mga palakol = plt.mga subplot(nrows=top_n_prediksiyon, ncols=2, figsize=(dalawampu, 10)) igos.masikip_layout() igos.suptitle('Mga Prediksiyong Softmax', fonttsize=dalawampu, Y=1.1) n_prediksiyon = 3 margin = 0.05 ind = hal..ayusin(n_prediksiyon) lapad = (isa - 2. * margin) / n_prediksiyon para sa image_i, (tampok, label_id, pred_indicies, pred_values) sa bilangin(zip(mga tampok, label_ids, mga hula.mga indeks, mga hula.halaga)): kung (image_i < top_n_prediksiyon): pred_names = [label_names[pred_i] para sa pred_i sa pred_indicies] tamang_pangalan = label_names[label_id] mga palakol[image_i] [0].imshow((tampok*255).astype(hal..int32, kopya=Mali)) mga palakol[image_i] [0].set_title(tamang_pangalan) mga palakol[image_i] [0].set_axis_off() mga palakol[image_i] [isa].barh(ind + margin, pred_values[:3], lapad) mga palakol[image_i] [isa].set_yticks(ind + margin) mga palakol[image_i] [isa].set_yticklabels(pred_names[::-isa]) mga palakol[image_i] [isa].set_xticks([0, 0.5, 1.0])
%matplotlib nasa linya %config InlineBackend.figure_format = 'retina' angkat tenorflow bilang tf angkat atsara angkat sapalaran save_model_path = './image_classification' batch_size = 64 n_samples = 10 top_n_prediksiyon = 5 def test_model(): pagsubok_feature, test_labels = atsara.karga(buksan('Preprocess_training.p', mode='rb')) na-load_graph = tf.Grap() kasama si tf.Session(grapiko=na-load_graph) bilang sess: # Load na modelo loader = tf.sanayin.import_meta_graph(save_model_path + '.meta') loader.ibalik(sess, save_model_path) # Kumuha ng mga Tensor mula sa na-load na modelo na-load_x = na-load_graph.get_tensor_by_name('input_x: 0') na-load_y = na-load_graph.makakuha ng_tensor_by_name('Output_y: 0') na-load_keep_prob = na-load_graph.get_tensor_by_name('keep_prob: 0') load_logits = na-load_graph.makakuha ng_tensor_by_name('mga pag-log: 0') na-load_acc = na-load_graph.makakuha ng_tensor_by_name('kawastuhan: 0') # Kumuha ng kawastuhan sa mga batch para sa mga limitasyon sa memorya test_batch_acc_total = 0 test_batch_count = 0 para sa train_feature_batch, train_label_batch sa batch_feature_labels(pagsubok_feature, test_labels, batch_size): test_batch_acc_total + = sess.tumakbo( na-load_acc, feed_dict={na-load_x: train_feature_batch, na-load_y: train_label_batch, na-load_keep_prob: 1.0}) test_batch_count + = isa mag-print('Katumpakan sa Pagsubok:{} '.format(test_batch_acc_total/test_batch_count)) # I-print ang Mga Sample na Sample mga random_test_feature, random_test_labels = tuple(zip(*sapalaran.sample(listahan(zip(pagsubok_feature, test_labels)), n_samples))) mga random_test_prediksiyon = sess.tumakbo( tf.butas ng ilong.top_k(tf.butas ng ilong.softmax(load_logits), top_n_prediksiyon), feed_dict={na-load_x: mga random_test_feature, na-load_y: mga random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, mga random_test_labels, mga random_test_prediksiyon, top_n_prediksiyon) test_model()

Output: Katumpakan sa Pagsubok: 0.5882762738853503

Ngayon, kung sanayin mo ang iyong neural network para sa higit pang mga panahon o baguhin ang pagpapaandar ng pag-aktibo, maaari kang makakuha ng ibang resulta na maaaring magkaroon ng mas mahusay na kawastuhan.

Kaya, na ito, kami dumating sa isang dulo ng TensorFlow Image Classification artikulo. Sigurado akong magagamit mo na rin ang pareho upang maiuri ang anumang uri ng mga imahe at hindi ka isang nagsisimula sa pag-uuri ng imahe.

Edureka’s may sawa Certification Pagsasanay ay na-curate ng mga propesyonal sa industriya bawat sa mga pangangailangan ng industriya at mga pangangailangan. Mapagtutuunan mo ang mga konsepto tulad ng pag-andar ng SoftMax, Autoencoder Neural Networks, Pinaghihigpitang Boltzmann Machine (RBM), Keras at TFLearn. Siyempre ay espesyal na-curate ng mga eksperto sa industriya na may real-time na pag-aaral kaso.