TensorFlow-bildeklassifisering: Alt du trenger å vite om byggeklassifiserere

Bildeklassifisering en oppgave som til og med en baby kan gjøre på få sekunder, men for en maskin har det vært en tøff oppgave til de siste fremskrittene innen og Dyp læring . Selvkjørende biler kan oppdage gjenstander og ta nødvendige tiltak i sanntid, og det meste av dette er mulig pga Bildeklassifisering. I denne artikkelen vil jeg veilede deg gjennom følgende emner:

• Hva er TensorFlow?
• Hva er bildeklassifisering?
• TensorFlow bildeklassifisering: Mote MNIST
• CIFAR 10: CNN

Hva er TensorFlow?

TensorFlow er Googles Open Source Machine Learning Framework for dataflytprogrammering på tvers av en rekke oppgaver. Noder i grafen representerer matematiske operasjoner, mens grafkantene representerer de flerdimensjonale dataarriser kommunisert mellom dem.

Tensorer er bare flerdimensjonale matriser, en utvidelse av todimensjonale tabeller til data med en høyere dimensjon. Det er mange funksjoner i Tensorflow som gjør det passende for Deep Learning, og det viktigste open source-biblioteket hjelper deg med å utvikle og trene ML-modeller.

Hva er bildeklassifisering?

Hensikten med Image Classification er å kategorisere alle piksler i et digitalt bilde i en av flere landdekning klasser eller temaer . Disse kategoriserte dataene kan deretter brukes til å produsere temakart av landdekket tilstede i et bilde.

Avhengig av samspillet mellom analytikeren og datamaskinen under klassifiseringen, er det to typer klassifisering:

• Overvåket og
• Uten tilsyn

Så uten å kaste bort tid, la oss hoppe inn i TensorFlow Image Classification. Jeg har to eksempler: lett og vanskelig. La oss fortsette med den enkle.

TensorFlow bildeklassifisering: Mote MNIST

Mote MNIST-datasett

Her skal vi bruke Fashion MNIST Dataset, som inneholder 70 000 gråtonebilder i 10 kategorier. Vi vil bruke 60000 til trening og resten 10000 til testformål. Du kan få tilgang til Fashion MNIST direkte fra TensorFlow, bare importer og last inn dataene.

• La oss importere bibliotekene først

fra __future__ importer absolutt_import, divisjon, utskriftsfunksjon # TensorFlow og tf.keras importerer tensorflow som tf fra tensorflow import keras # Hjelpebiblioteker importerer numpy som np importerer matplotlib.pyplot som plt

• La oss laste inn dataene

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

• Deretter skal vi kartlegge bildene i klasser

class_names = ['T-skjorte / topp', 'Bukse', 'Genser', 'Kjole', 'Frakk', 'Sandal', 'Skjorte', 'Joggesko', 'Veske', 'Ankelstøvle']

• Utforske dataene

togbilder.form 
#Each Label er mellom 0-9

tog_etiketter 
test_bilder.form 

• Nå er det på tide å forhåndsbehandle dataene.

plt.figur() plt.imshow(togbilder[0]) plt.fargelinje() plt.Nett(Falsk) plt.vise fram() 
#Hvis du inspiserer det første bildet i treningssettet, vil du se at pikselverdiene faller i området 0 til 255. 

• Vi måler bildene fra 0-1 for å mate dem inn i Neural Network

togbilder = togbilder / 255,0 test_bilder = test_bilder / 255,0

• La oss vise noen bilder.

plt.figur(figsize=(10,10)) til Jeg i område(25): plt.delplott(5,5,Jeg+en) plt.xticks([]) plt.yticks([]) plt.Nett(Falsk) plt.imshow(togbilder[Jeg], cmap=plt.cm.binær) plt.xlabel(klassenavn[tog_etiketter[Jeg]]) plt.vise fram()

• Sett opp lagene

modell = hard.Sekvensiell([ hard.lag.Flate ut(input_shape=(28, 28)), hard.lag.Tett(128, aktivering=tf.nr.relu), hard.lag.Tett(10, aktivering=tf.nr.softmax) ])

• Kompiler modellen

modell.kompilere(optimizer='adam', tap='sparsom_kategorisk_korsentropi', beregninger=['nøyaktighet'])

• Modellopplæring

modell.passe(togbilder, tog_etiketter, epoker=10)

• Evaluering av nøyaktighet

test_tap, test_acc = modell.evaluere(test_bilder, test_labels) skrive ut('Testnøyaktighet:', test_acc)

• Forutsi

spådommer = modell.forutsi(test_bilder)

spådommer[0]

En prediksjon er en matrise på 10 tall. Disse beskriver modellens “tillit” til at bildet tilsvarer hver av de 10 forskjellige klesplaggene. Vi kan se hvilken etikett som har den høyeste tillitsverdien.

f.eks..argmax(spådommer[0])#Model er mest trygg på at det er en ankelstøvel. La oss se om det er riktig

Utgang: 9

test_labels[0]

Utgang: 9

• Nå er det på tide å se på hele settet med 10 kanaler

def plot_image(Jeg, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[Jeg], true_label[Jeg], img[Jeg] plt.Nett(Falsk) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binær) predicted_label = f.eks..argmax(predictions_array) hvis predicted_label == true_label: farge = 'grønn' ellers: farge = 'nett' plt.xlabel('{} {: 2.0f}% ({}) '.format(klassenavn[predicted_label], 100*f.eks..maks(predictions_array), klassenavn[true_label]), farge=farge) def plot_value_array(Jeg, predictions_array, true_label): predictions_array, true_label = predictions_array[Jeg], true_label[Jeg] plt.Nett(Falsk) plt.xticks([]) plt.yticks([]) denne tomten = plt.bar(område(10), predictions_array, farge='# 777777') plt.ylim([0, en]) predicted_label = f.eks..argmax(predictions_array) denne tomten[predicted_label].settfarge('nett') denne tomten[true_label].settfarge('grønn')

• La oss se på det 10. og 10. bildet først

Jeg = 0 plt.figur(figsize=(6,3)) plt.delplott(en,2,en) plot_image(Jeg, spådommer, test_labels, test_bilder) plt.delplott(en,2,2) plot_value_array(Jeg, spådommer, test_labels) plt.vise fram()

Jeg = 10 plt.figur(figsize=(6,3)) plt.delplott(en,2,en) plot_image(Jeg, spådommer, test_labels, test_bilder) plt.delplott(en,2,2) plot_value_array(Jeg, spådommer, test_labels) plt.vise fram()

• La oss nå plotte flere bilder og deres spådommer. De riktige er grønne, mens de riktige er røde.

num_rows = 5 num_cols = 3 antall bilder = num_rows*num_cols plt.figur(figsize=(2*2*num_cols, 2*num_rows)) til Jeg i område(antall bilder): plt.delplott(num_rows, 2*num_cols, 2*Jeg+en) plot_image(Jeg, spådommer, test_labels, test_bilder) plt.delplott(num_rows, 2*num_cols, 2*Jeg+2) plot_value_array(Jeg, spådommer, test_labels) plt.vise fram()

• Til slutt vil vi bruke den trente modellen til å spå om et enkelt bilde.

# Ta et bilde fra testdatasettet img = test_bilder[0] skrive ut(img.form)

# Legg til bildet i en gruppe der det er det eneste medlemmet. img = (f.eks..utvide_dims(img,0)) skrive ut(img.form)

prediksjoner_single = modell.forutsi(img) skrive ut(prediksjoner_single)

plot_value_array(0, prediksjoner_single, test_labels) plt.xticks(område(10), klassenavn, rotasjon=Fire fem) plt.vise fram()

• Som du kan se spådommen for vårt eneste bilde i batch.

prediksjon_resultat = f.eks..argmax(prediksjoner_single[0])

Utgang: 9

CIFAR-10: CNN

CIFAR-10 datasettet består av fly, hunder, katter og andre gjenstander. Du behandler bildene på forhånd, og trener deretter et konvolusjonalt nevralt nettverk på alle prøvene. Bildene må normaliseres, og etikettene må være kodet med en het. Denne brukssaken vil helt sikkert fjerne din tvil om TensorFlow Image Classification.

python hva er __init__

• Laste ned dataene

fra urllib.forespørsel import urlretrieve fra os. sti import isfil, er sot fra tqdm import tqdm import tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klasse Last nedProgress(tqdm): siste_blokk = 0 def krok(selv-, blokk_nummer=en, blokkstørrelse=en, Total størrelse=Ingen): selv-.Total = Total størrelse selv-.Oppdater((blokk_nummer - selv-.siste_blokk) * blokkstørrelse) selv-.siste_blokk = blokk_nummer '' ' sjekk om datafilen (zip) allerede er lastet ned hvis ikke, last det ned fra 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' og lagre som cifar-10-python.tar.gz '' ' hvis ikke isfil('cifar-10-python.tar.gz'): med Last nedProgress(enhet='B', enhetsskala=ekte, miniters=en, avd='CIFAR-10 datasett') som pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.krok) hvis ikke er sot(cifar10_dataset_folder_path): med tarfile.åpen('cifar-10-python.tar.gz') som tjære: tjære.trekk ut alt() tjære.Lukk()

• Importerer nødvendige biblioteker

import sylteagurk import bedøvet som f.eks. import matplotlib.pyplot som plt

• Forstå dataene

Den opprinnelige batchen av data er 10000 × 3072 tensor uttrykt i en nummen matrise, hvor 10000 er antall eksempeldata. Bildet er farget og av størrelse 32 × 32. Mating kan gjøres enten i formatet (bredde x høyde x num_channel) eller (num_channel x bredde x høyde). La oss definere etikettene.

def load_label_names(): komme tilbake ['fly', 'bil', 'fugl', 'katt', 'hjort', 'hund', 'frosk', 'hest', 'skip', 'lastebil']

• Omforme dataene

Vi skal omforme dataene i to trinn

Del først radvektoren (3072) i 3 stykker. Hvert stykke tilsvarer hver kanal. Dette resulterer i (3 x 1024) dimensjon av en tensor. Del deretter den resulterende tensoren fra forrige trinn med 32. 32 betyr her bredden på et bilde. Dette resulterer i (3x32x32).

For det andre må vi transponere dataene fra (num_channel, width, height) til (width, height, num_channel). For det skal vi bruke transponeringsfunksjonen.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): med åpen(cifar10_dataset_folder_path + '/ data_batch_' + s(batch_id), modus='rb') som fil: # merk kodingstypen er 'latin1' parti = sylteagurk.laste(fil, koding='latin1') egenskaper = parti['data'].omforme((len(parti['data']), 3, 32, 32)).transponere(0, 2, 3, en) etiketter = parti['etiketter'] komme tilbake egenskaper, merkelapp

• Utforske dataene

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): egenskaper, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) hvis ikke (0 <= sample_id < len(egenskaper)): skrive ut('{}prøver i batch{}.{}er utenfor rekkevidde. '.format(len(egenskaper), batch_id, sample_id)) komme tilbake Ingen skrive ut(' Statistikk over batch #{}: '.format(batch_id)) skrive ut(Antall prøver:{} '.format(len(egenskaper))) etikettnavn = load_label_names() label_counts = diktere(glidelås(*f.eks..unik(etiketter, retur_teller=ekte))) til nøkkel, verdi i label_counts.gjenstander(): skrive ut('Merketelling av [{}] ({}):{}'.format(nøkkel, etikettnavn[nøkkel].øverste(), verdi)) sample_image = egenskaper[sample_id] sample_label = etiketter[sample_id] skrive ut(' Eksempel på bilde{}: '.format(sample_id)) skrive ut('Bilde - Min verdi:{}Maks verdi:{}'.format(sample_image.min(), sample_image.maks())) skrive ut('Bilde - Form:{}'.format(sample_image.form)) skrive ut(Etikett - etikett-ID:{}Navn:{}'.format(sample_label, etikettnavn[sample_label])) plt.imshow(sample_image)

%matplotlib på linje %config InlineBackend.figur_format = 'netthinnen' import bedøvet som f.eks. # Utforsk datasettet batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Implementering av forhåndsbehandlingsfunksjoner

Vi skal normalisere dataene via Min-Max Normalization. Dette gjør ganske enkelt at alle x-verdier varierer mellom 0 og 1.
y = (x-min) / (max-min)

def normalisere(x): '' ' argument - x: legg inn bildedata i nummen matrise [32, 32, 3] komme tilbake - normalisert x '' ' min_val = f.eks..min(x) max_val = f.eks..maks(x) x = (x-min_val) / (max_val-min_val) komme tilbake x

• One-Hot Encode

def one_hot_encode(x): '' ' argument - x: en liste over etiketter komme tilbake - en varm kodingsmatrise (antall etiketter, antall klasser) '' ' kodet = f.eks..nuller((len(x), 10)) til idx, timer i oppregne(x): kodet[idx] [timer] = en komme tilbake kodet

• Forbehandle og lagre dataene

def _forarbeid_og_lagre(normalisere, one_hot_encode, egenskaper, etiketter, filnavn): egenskaper = normalisere(egenskaper) etiketter = one_hot_encode(etiketter) sylteagurk.dump((egenskaper, etiketter), åpen(filnavn, 'wb')) def preprosess_og_save_data(cifar10_dataset_folder_path, normalisere, one_hot_encode): n_batcher = 5 valid_features = [] gyldige_etiketter = [] til batch_i i område(en, n_batcher + en): egenskaper, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # finn indeks for å være poenget som valideringsdata i hele datasettet til batchen (10%) indeks_av_validering = int(len(egenskaper) * 0,1) # forbehandler 90% av hele datasettet til batchen # - normaliser funksjonene # - one_hot_encode etikettene # - lagre i en ny fil med navnet 'preprocess_batch_' + batchnummer # - hver fil for hver batch _forarbeid_og_lagre(normalisere, one_hot_encode, egenskaper[:-indeks_av_validering], etiketter[:-indeks_av_validering], 'preprocess_batch_' + s(batch_i) + '.p') # i motsetning til opplæringsdatasettet, blir valideringsdatasettet lagt til gjennom hele batchdatasettet # - ta 10% av hele datasettet til batchen # - legg dem til i en liste over # - valid_features # - valid_labels valid_features.forlenge(egenskaper[-indeks_av_validering:]) gyldige_etiketter.forlenge(etiketter[-indeks_av_validering:]) # forbehandle alt stablet valideringsdatasett _forarbeid_og_lagre(normalisere, one_hot_encode, f.eks..array(valid_features), f.eks..array(gyldige_etiketter), 'preprocess_validation.p') # last testdatasettet med åpen(cifar10_dataset_folder_path + '/ test_batch', modus='rb') som fil: parti = sylteagurk.laste(fil, koding='latin1') # behandle testdata på forhånd test_funksjoner = parti['data'].omforme((len(parti['data']), 3, 32, 32)).transponere(0, 2, 3, en) test_labels = parti['etiketter'] # Forbehandling og lagre alle testdata _forarbeid_og_lagre(normalisere, one_hot_encode, f.eks..array(test_funksjoner), f.eks..array(test_labels), 'preprocess_training.p')

preprosess_og_save_data(cifar10_dataset_folder_path, normalisere, one_hot_encode)

• Kontrollpunkt

import sylteagurk valid_features, gyldige_etiketter = sylteagurk.laste(åpen('preprocess_validation.p', modus='rb'))

• Å bygge nettverket

Hele modellen består av totalt 14 lag.

import tensorflow som tf def conv_net(x, keep_prob): konv1_filter = tf.Variabel(tf.avkortet_normalt(form=[3, 3, 3, 64], mener=0, stddev=0,08)) conv2_filter = tf.Variabel(tf.avkortet_normalt(form=[3, 3, 64, 128], mener=0, stddev=0,08)) conv3_filter = tf.Variabel(tf.avkortet_normalt(form=[5, 5, 128, 256], mener=0, stddev=0,08)) conv4_filter = tf.Variabel(tf.avkortet_normalt(form=[5, 5, 256, 512], mener=0, stddev=0,08)) # 1, 2 conv1 = tf.nr.konv2d(x, konv1_filter, skritt=[en,en,en,en], polstring='SAMME') conv1 = tf.nr.relu(conv1) conv1_pool = tf.nr.max_pool(conv1, ksize=[en,2,2,en], skritt=[en,2,2,en], polstring='SAMME') conv1_bn = tf.lag.batch_normalisering(conv1_pool) # 3. 4 conv2 = tf.nr.konv2d(conv1_bn, conv2_filter, skritt=[en,en,en,en], polstring='SAMME') conv2 = tf.nr.relu(conv2) conv2_pool = tf.nr.max_pool(conv2, ksize=[en,2,2,en], skritt=[en,2,2,en], polstring='SAMME') conv2_bn = tf.lag.batch_normalisering(conv2_pool) # 5, 6 conv3 = tf.nr.konv2d(conv2_bn, conv3_filter, skritt=[en,en,en,en], polstring='SAMME') conv3 = tf.nr.relu(conv3) conv3_pool = tf.nr.max_pool(conv3, ksize=[en,2,2,en], skritt=[en,2,2,en], polstring='SAMME') conv3_bn = tf.lag.batch_normalisering(conv3_pool) # 7, 8 konv4 = tf.nr.konv2d(conv3_bn, conv4_filter, skritt=[en,en,en,en], polstring='SAMME') konv4 = tf.nr.relu(konv4) conv4_pool = tf.nr.max_pool(konv4, ksize=[en,2,2,en], skritt=[en,2,2,en], polstring='SAMME') conv4_bn = tf.lag.batch_normalisering(conv4_pool) # 9 flat = tf.bidrag.lag.flate ut(conv4_bn) # 10 full1 = tf.bidrag.lag.fullt_koblet(innganger=flat, antall utganger=128, aktivering_fn=tf.nr.relu) full1 = tf.nr.frafall(full1, keep_prob) full1 = tf.lag.batch_normalisering(full1) # elleve full2 = tf.bidrag.lag.fullt_koblet(innganger=full1, antall utganger=256, aktivering_fn=tf.nr.relu) full2 = tf.nr.frafall(full2, keep_prob) full2 = tf.lag.batch_normalisering(full2) # 12 full3 = tf.bidrag.lag.fullt_koblet(innganger=full2, antall utganger=512, aktivering_fn=tf.nr.relu) full3 = tf.nr.frafall(full3, keep_prob) full3 = tf.lag.batch_normalisering(full3) # 1. 3 full4 = tf.bidrag.lag.fullt_koblet(innganger=full3, antall utganger=1024, aktivering_fn=tf.nr.relu) full4 = tf.nr.frafall(full4, keep_prob) full4 = tf.lag.batch_normalisering(full4) # 14 ute = tf.bidrag.lag.fullt_koblet(innganger=full3, antall utganger=10, aktivering_fn=Ingen) komme tilbake ute

• Hyperparametere

epoker = 10 Partistørrelse, Gruppestørrelse = 128 keep_probability = 0,7 learning_rate = 0,001

logitter = conv_net(x, keep_prob) modell = tf.identitet(logitter, Navn='logitter') # Navn logger Tensor, slik at det kan lastes fra disk etter trening # Tap og Optimizer koste = tf.redusere middel(tf.nr.softmax_cross_entropy_with_logits(logitter=logitter, etiketter=Y)) optimizer = tf.tog.AdamOptimizer(learning_rate=learning_rate).minimere(koste) # Nøyaktighet correct_pred = tf.lik(tf.argmax(logitter, en), tf.argmax(Y, en)) nøyaktighet = tf.redusere middel(tf.rollebesetning(correct_pred, tf.flyte32), Navn='nøyaktighet')

• Tren det nevrale nettverket

# Enkel optimalisering 
def train_neural_network(økt, optimizer, keep_probability, funksjon_batch, label_batch): økt.løpe(optimizer, feed_dict={ x: funksjon_batch, Y: label_batch, keep_prob: keep_probability })

#Showing Stats def utskriftsstatistikker(økt, funksjon_batch, label_batch, koste, nøyaktighet): tap = sess.løpe(koste, feed_dict={ x: funksjon_batch, Y: label_batch, keep_prob: en. }) valid_acc = sess.løpe(nøyaktighet, feed_dict={ x: valid_features, Y: gyldige_etiketter, keep_prob: en. }) skrive ut('Tap:{:> 10.4f}Valideringsnøyaktighet:{: .6f}'.format(tap, valid_acc))

• Fulltrening og lagring av modellen

def batch_features_labels(egenskaper, etiketter, Partistørrelse, Gruppestørrelse): '' ' Del funksjoner og etiketter i grupper '' ' til start i område(0, len(egenskaper), Partistørrelse, Gruppestørrelse): slutt = min(start + Partistørrelse, Gruppestørrelse, len(egenskaper)) utbytte egenskaper[start:slutt], etiketter[start:slutt] def load_preprocess_training_batch(batch_id, Partistørrelse, Gruppestørrelse): '' ' Last inn forhåndsbehandlede treningsdata og returner dem i grupper på eller mindre '' ' filnavn = 'preprocess_batch_' + s(batch_id) + '.p' egenskaper, etiketter = sylteagurk.laste(åpen(filnavn, modus='rb')) # Returner treningsdataene i grupper av størrelse eller mindre komme tilbake batch_features_labels(egenskaper, etiketter, Partistørrelse, Gruppestørrelse)

#Sparing Model and Path 
save_model_path = './image_classification' skrive ut('Opplæring...') med tf.Økt() som sess: # Initialisere variablene sess.løpe(tf.global_variables_initializer()) # Treningssyklus til epoke i område(epoker): # Sløyfe over alle partiene n_batcher = 5 til batch_i i område(en, n_batcher + en): til batch_features, batch_labels i load_preprocess_training_batch(batch_i, Partistørrelse, Gruppestørrelse): train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels) skrive ut('Epoke{:> 2}, CIFAR-10 Batch{}: '.format(epoke + en, batch_i), slutt='') utskriftsstatistikker(sess, batch_features, batch_labels, koste, nøyaktighet) # Lagre modell sparer = tf.tog.Sparer() save_path = sparer.lagre(sess, save_model_path)

Nå er den viktige delen av Tensorflow Image Classification ferdig. Nå er det på tide å teste modellen.

• Testing av modellen

import sylteagurk import bedøvet som f.eks. import matplotlib.pyplot som plt fra sklearn.preprocessing import LabelBinarizer def batch_features_labels(egenskaper, etiketter, Partistørrelse, Gruppestørrelse): '' ' Del funksjoner og etiketter i grupper '' ' til start i område(0, len(egenskaper), Partistørrelse, Gruppestørrelse): slutt = min(start + Partistørrelse, Gruppestørrelse, len(egenskaper)) utbytte egenskaper[start:slutt], etiketter[start:slutt] def display_image_predictions(egenskaper, etiketter, spådommer, topp_n_spådommer): n_klasser = 10 etikettnavn = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.passe(område(n_klasser)) label_ids = label_binarizer.inverse_transform(f.eks..array(etiketter)) Fig, akser = plt.delplott(nrows=topp_n_spådommer, ncols=2, figsize=(tjue, 10)) Fig.tight_layout() Fig.suptitle('Softmax-spådommer', skriftstørrelse=tjue, Y=1.1) n_spådommer = 3 margin = 0,05 ind = f.eks..arange(n_spådommer) bredde = (en. - 2. * margin) / n_spådommer til image_i, (trekk, label_id, pred_indicies, pred_values) i oppregne(glidelås(egenskaper, label_ids, spådommer.indekser, spådommer.verdier)): hvis (image_i < topp_n_spådommer): fornavn = [etikettnavn[pred_i] til pred_i i pred_indicies] riktig_navn = etikettnavn[label_id] akser[image_i] [0].imshow((trekk*255).astype(f.eks..int32, kopiere=Falsk)) akser[image_i] [0].set_title(riktig_navn) akser[image_i] [0].set_axis_off() akser[image_i] [en].barh(ind + margin, pred_values[:3], bredde) akser[image_i] [en].set_yticks(ind + margin) akser[image_i] [en].set_yticklabels(fornavn[::-en]) akser[image_i] [en].set_xticks([0, 0,5, 1.0])

%matplotlib på linje %config InlineBackend.figur_format = 'netthinnen' import tensorflow som tf import sylteagurk import tilfeldig save_model_path = './image_classification' Partistørrelse, Gruppestørrelse = 64 n_samples = 10 topp_n_spådommer = 5 def test_modell(): test_funksjoner, test_labels = sylteagurk.laste(åpen('preprocess_training.p', modus='rb')) lastet_graf = tf.Kurve() med tf.Økt(kurve=lastet_graf) som sess: # Lastemodell laster = tf.tog.import_meta_graph(save_model_path + '.meta') laster.restaurere(sess, save_model_path) # Få tensorer fra lastet modell lastet_x = lastet_graf.get_tensor_by_name('input_x: 0') lastet_y = lastet_graf.get_tensor_by_name('output_y: 0') loaded_keep_prob = lastet_graf.get_tensor_by_name('keep_prob: 0') lastet_logger = lastet_graf.get_tensor_by_name('logger: 0') loaded_acc = lastet_graf.get_tensor_by_name('nøyaktighet: 0') # Få nøyaktighet i grupper for minnebegrensninger test_batch_acc_total = 0 test_batch_count = 0 til train_feature_batch, train_label_batch i batch_features_labels(test_funksjoner, test_labels, Partistørrelse, Gruppestørrelse): test_batch_acc_total + = sess.løpe( loaded_acc, feed_dict={lastet_x: train_feature_batch, lastet_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = en skrive ut(Testing av nøyaktighet:{} '.format(test_batch_acc_total/test_batch_count)) # Skriv ut tilfeldige prøver tilfeldige_testfunksjoner, tilfeldig_test_etiketter = tuple(glidelås(*tilfeldig.prøve(liste(glidelås(test_funksjoner, test_labels)), n_samples))) tilfeldige_test_forutsigelser = sess.løpe( tf.nr.topp_k(tf.nr.softmax(lastet_logger), topp_n_spådommer), feed_dict={lastet_x: tilfeldige_testfunksjoner, lastet_y: tilfeldig_test_etiketter, loaded_keep_prob: 1.0}) display_image_predictions(tilfeldige_testfunksjoner, tilfeldig_test_etiketter, tilfeldige_test_forutsigelser, topp_n_spådommer) test_modell()

Produksjon: Testnøyaktighet: 0.5882762738853503

Nå, hvis du trener nevrale nettverk for flere epoker eller endrer aktiveringsfunksjonen, kan du få et annet resultat som kan ha bedre nøyaktighet.

Så med dette kommer vi til en slutt på denne TensorFlow Image Classification-artikkelen. Jeg er sikker på at du nå kan bruke det samme for å klassifisere alle slags bilder, og du er ikke en nybegynner for bildeklassifisering.

Edureka’s med Python Certification Training er kuratert av fagpersoner i bransjen i henhold til bransjens krav og krav. Du vil mestre konseptene som SoftMax-funksjon, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kurset er spesielt kuratert av bransjeeksperter med sanntidsstudier.