TensorFlow-billedklassifikation: Alt hvad du behøver at vide om bygningsklassifikatorer

Billedklassificering en opgave, som selv en baby kan udføre på få sekunder, men for en maskine har det været en hård opgave indtil de nylige fremskridt inden for og Dyb læring . Selvkørende biler kan registrere genstande og tage de nødvendige handlinger i realtid, og det meste af dette er muligt på grund af Billedklassificering. I denne artikel vil jeg guide dig gennem følgende emner:

• Hvad er TensorFlow?
• Hvad er billedklassificering?
• TensorFlow-billedklassifikation: Mode MNIST
• CIFAR 10: CNN

Hvad er TensorFlow?

TensorFlow er Googles Open Source Machine Learning Framework til dataflowsprogrammering på tværs af en række opgaver. Knudepunkter i grafen repræsenterer matematiske operationer, mens grafkanterne repræsenterer de flerdimensionale datarays, der er kommunikeret mellem dem.

Tensorer er bare flerdimensionelle arrays, en udvidelse af 2-dimensionelle tabeller til data med en højere dimension. Der er mange funktioner i Tensorflow, som gør det passende til Deep Learning, og det centrale open source-bibliotek hjælper dig med at udvikle og træne ML-modeller.

hvordan man kontrollerer for palindrom i java

Hvad er billedklassificering?

Hensigten med Image Classification er at kategorisere alle pixels i et digitalt billede i et af flere landdækning klasser eller temaer . Disse kategoriserede data kan derefter bruges til at producere temakort af landdækningen til stede i et billede.

Afhængigt af interaktionen mellem analytikeren og computeren under klassificering er der nu to typer klassifikation:

• Overvåget &
• Uden opsyn

Så lad os hoppe ind i TensorFlow Image Classification uden at spilde nogen tid. Jeg har 2 eksempler: let og vanskeligt. Lad os fortsætte med den nemme.

TensorFlow-billedklassifikation: Mode MNIST

Mode MNIST-datasæt

Her skal vi bruge Fashion MNIST Dataset, som indeholder 70.000 gråtonebilleder i 10 kategorier. Vi bruger 60000 til træning og resten 10000 til testformål. Du kan få adgang til Fashion MNIST direkte fra TensorFlow, bare importer og indlæs dataene.

• Lad os først importere bibliotekerne

fra __future__ importerer absolut_import, division, udskrivningsfunktion # TensorFlow og tf.keras importerer tensorflow som tf fra tensorflow import keras # Hjælpebiblioteker importerer numpy som np import matplotlib.pyplot som plt

• Lad os indlæse dataene

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

• Dernæst skal vi kortlægge billederne i klasser

class_names = ['T-shirt / top', 'Bukser', 'Pullover', 'Kjole', 'Frakke', 'Sandal', 'Skjorte', 'Sneaker', 'Taske', 'Ankelstøvle']

• Udforskning af data

tog_billeder.form 
#Each Label er mellem 0-9

togmærker 
test_billeder.form 

• Nu er det tid til at forbehandle dataene.

plt.figur() plt.imshow(tog_billeder[0]) plt.farvebjælke() plt.gitter(Falsk) plt.at vise() 
#Hvis du inspicerer det første billede i træningssættet, vil du se, at pixelværdierne falder i området 0 til 255. 

• Vi er nødt til at skalere billederne fra 0-1 for at føre dem ind i det neurale netværk

tog_billeder = tog_billeder / 255,0 test_billeder = test_billeder / 255,0

• Lad os vise nogle billeder.

plt.figur(figenstørrelse=(10,10)) til jeg i rækkevidde(25): plt.delplot(5,5,jeg+en) plt.xticks([]) plt.yticks([]) plt.gitter(Falsk) plt.imshow(tog_billeder[jeg], cmap=plt.cm.binær) plt.xlabel(klassenavne[togmærker[jeg]]) plt.at vise()

• Opsæt lagene

model = hårdt.Sekventiel([ hårdt.lag.Flad(input_form=(28, 28)), hårdt.lag.Tæt(128, aktivering=tf.nr.relu), hårdt.lag.Tæt(10, aktivering=tf.nr.softmax) ])

• Kompilér modellen

model.udarbejde(optimering='adam', tab='sparse_categorical_crossentropy', målinger=['nøjagtighed'])

• Modeluddannelse

model.passe(tog_billeder, togmærker, epoker=10)

• Evaluering af nøjagtighed

test_tab, test_acc = model.vurdere(test_billeder, test_mærkater) Print('Testnøjagtighed:', test_acc)

• Forudsigelser

forudsigelser = model.forudsige(test_billeder)

forudsigelser[0]

En forudsigelse er en matrix på 10 tal. Disse beskriver modelens “tillid” til, at billedet svarer til hver af de 10 forskellige beklædningsgenstande. Vi kan se, hvilken etiket der har den højeste tillidsværdi.

for eksempel..argmax(forudsigelser[0])#Model er mest sikker på, at det er en ankelstøvle. Lad os se om det er korrekt

Output: 9

test_mærkater[0]

Output: 9

• Nu er det tid til at se på det fulde sæt med 10 kanaler

def plot_billede(jeg, forudsigelser_array, sand_mærke, img): forudsigelser_array, sand_mærke, img = forudsigelser_array[jeg], sand_mærke[jeg], img[jeg] plt.gitter(Falsk) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binær) forudsagt_mærke = for eksempel..argmax(forudsigelser_array) hvis forudsagt_mærke == sand_mærke: farve = 'grøn' andet: farve = 'net' plt.xlabel(''{} {: 2.0f}% ({}) '.format(klassenavne[forudsagt_mærke], 100*for eksempel..maks(forudsigelser_array), klassenavne[sand_mærke]), farve=farve) def plot_value_array(jeg, forudsigelser_array, sand_mærke): forudsigelser_array, sand_mærke = forudsigelser_array[jeg], sand_mærke[jeg] plt.gitter(Falsk) plt.xticks([]) plt.yticks([]) dette plot = plt.bar(rækkevidde(10), forudsigelser_array, farve='# 777777') plt.ylim([0, en]) forudsagt_mærke = for eksempel..argmax(forudsigelser_array) dette plot[forudsagt_mærke].sæt_farve('net') dette plot[sand_mærke].sæt_farve('grøn')

• Lad os først se på det 10. og 10. billede

jeg = 0 plt.figur(figenstørrelse=(6,3)) plt.delplot(en,2,en) plot_billede(jeg, forudsigelser, test_mærkater, test_billeder) plt.delplot(en,2,2) plot_value_array(jeg, forudsigelser, test_mærkater) plt.at vise()

jeg = 10 plt.figur(figenstørrelse=(6,3)) plt.delplot(en,2,en) plot_billede(jeg, forudsigelser, test_mærkater, test_billeder) plt.delplot(en,2,2) plot_value_array(jeg, forudsigelser, test_mærkater) plt.at vise()

• Lad os nu plotte flere billeder og deres forudsigelser. Korrekte er grønne, mens de forkerte er røde.

num_rows = 5 num_cols = 3 antal_billeder = num_rows*num_cols plt.figur(figenstørrelse=(2*2*num_cols, 2*num_rows)) til jeg i rækkevidde(antal_billeder): plt.delplot(num_rows, 2*num_cols, 2*jeg+en) plot_billede(jeg, forudsigelser, test_mærkater, test_billeder) plt.delplot(num_rows, 2*num_cols, 2*jeg+2) plot_value_array(jeg, forudsigelser, test_mærkater) plt.at vise()

• Endelig vil vi bruge den uddannede model til at forudsige et enkelt billede.

# Tag et billede fra testdatasættet img = test_billeder[0] Print(img.form)

# Føj billedet til et parti, hvor det er det eneste medlem. img = (for eksempel..expand_dims(img,0)) Print(img.form)

forudsigelser_single = model.forudsige(img) Print(forudsigelser_single)

plot_value_array(0, forudsigelser_single, test_mærkater) plt.xticks(rækkevidde(10), klassenavne, rotation=Fire. Fem) plt.at vise()

• Som du kan se forudsigelsen for vores eneste billede i batch.

prediction_result = for eksempel..argmax(forudsigelser_single[0])

Output: 9

CIFAR-10: CNN

CIFAR-10 datasættet består af fly, hunde, katte og andre objekter. Du forbehandler billederne og træner derefter et nedviklet neuralt netværk på alle prøverne. Billederne skal normaliseres, og etiketterne skal være kodet en-hot. Denne brugssag vil helt sikkert fjerne din tvivl om TensorFlow Image Classification.

hvordan man installerer php windows 10

• Download af dataene

fra urllib.anmodning importere urlretrieve fra os.sti importere isfil, er sod fra tqdm importere tqdm importere tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klasse DownloadProgress(tqdm): sidste blok = 0 def krog(selv, bloknummer=en, blokstørrelse=en, totalstørrelse=Ingen): selv.Total = totalstørrelse selv.opdatering((bloknummer - selv.sidste blok) * blokstørrelse) selv.sidste blok = bloknummer '' ' Kontroller, om datafilen (zip) allerede er downloadet hvis ikke, skal du downloade det fra 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' og gemme som cifar-10-python.tar.gz '' ' hvis ikke isfil('cifar-10-python.tar.gz'): med DownloadProgress(enhed='B', enhedsskala=Sand, miniters=en, beskrivelse='CIFAR-10 datasæt') som pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.krog) hvis ikke er sod(cifar10_dataset_folder_path): med tarfile.åben('cifar-10-python.tar.gz') som tjære: tjære.udtræk Alle() tjære.tæt()

• Import af nødvendige biblioteker

importere pickle importere bedøvet som for eksempel. importere matplotlib.pyplot som plt

• Forståelse af dataene

Den oprindelige batch af data er 10000 × 3072 tensor udtrykt i et følelsesløst array, hvor 10000 er antallet af eksempeldata. Billedet er farvet og af størrelse 32 × 32. Fodring kan udføres enten i formatet (bredde x højde x num_channel) eller (num_channel x bredde x højde). Lad os definere etiketterne.

def load_label_names(): Vend tilbage ['fly', 'automobil', 'fugl', 'kat', 'hjort', 'hund', 'frø', 'hest', 'skib', 'lastbil']

• Omformning af data

Vi vil omforme dataene i to faser

Del først rækkevektoren (3072) i 3 stykker. Hvert stykke svarer til hver kanal. Dette resulterer i (3 x 1024) dimension af en tensor. Del derefter den resulterende tensor fra det foregående trin med 32. 32 betyder her bredden på et billede. Dette resulterer i (3x32x32).

For det andet skal vi transponere dataene fra (num_channel, width, height) til (width, height, num_channel). Til det skal vi bruge transponeringsfunktionen.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): med åben(cifar10_dataset_folder_path + '/ data_batch_' + s(batch_id), mode='rb') som fil: # bemærk kodningstypen er 'latin1' parti = pickle.belastning(fil, indkodning='latin1') funktioner = parti['data'].omforme((len(parti['data']), 3, 32, 32)).transponere(0, 2, 3, en) etiketter = parti['etiketter'] Vend tilbage funktioner, etiket

• Udforskning af dataene

def display_stats(cifar10_dataset_folder_path, batch_id, prøve_id): funktioner, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) hvis ikke (0 <= prøve_id < len(funktioner)): Print(''{}prøver i batch{}.{}er uden for rækkevidde. '.format(len(funktioner), batch_id, prøve_id)) Vend tilbage Ingen Print('' Statistik over batch #{}: '.format(batch_id)) Print(Antal prøver:{} ''.format(len(funktioner))) label_names = load_label_names() label_counts = diktere(lynlås(*for eksempel..enestående(etiketter, return_counts=Sand))) til nøgle, værdi i label_counts.genstande(): Print('Etikettællinger af [{}] ({}):{}''.format(nøgle, label_names[nøgle].øverst(), værdi)) prøve_billede = funktioner[prøve_id] prøve_mærke = etiketter[prøve_id] Print('' Eksempel på billede{}: '.format(prøve_id)) Print('Billede - Min værdi:{}Maks. Værdi:{}''.format(prøve_billede.min(), prøve_billede.maks())) Print('Billede - form:{}''.format(prøve_billede.form)) Print('Etiket - etiket-id:{}Navn:{}''.format(prøve_mærke, label_names[prøve_mærke])) plt.imshow(prøve_billede)

%matplotlib inline %config InlineBackend.figur_format = 'nethinden' importere bedøvet som for eksempel. # Udforsk datasættet batch_id = 3 prøve_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, prøve_id)

• Implementering af forbehandlingsfunktioner

Vi skal normalisere dataene via Min-Max Normalisering. Dette gør simpelthen alle x-værdier til at variere mellem 0 og 1.
y = (x-min) / (max-min)

def normalisere(x): '' ' argument - x: input billeddata i bedøvet matrix [32, 32, 3] Vend tilbage - normaliseret x '' ' min_val = for eksempel..min(x) max_val = for eksempel..maks(x) x = (x-min_val) / (max_val-min_val) Vend tilbage x

• En-hot-kode

def one_hot_encode(x): '' ' argument - x: en liste over etiketter Vend tilbage - en varm kodningsmatrix (antal etiketter, antal klasse) '' ' kodet = for eksempel..nuller((len(x), 10)) til idx, timer i tælle(x): kodet[idx] [timer] = en Vend tilbage kodet

• Forbehandling og gem data

def _forproces_og_save(normalisere, one_hot_encode, funktioner, etiketter, filnavn): funktioner = normalisere(funktioner) etiketter = one_hot_encode(etiketter) pickle.dump((funktioner, etiketter), åben(filnavn, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalisere, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] til batch_i i rækkevidde(en, n_batches + en): funktioner, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # find index for at være punktet som valideringsdata i hele datasættet i batchen (10%) index_of_validation = int(len(funktioner) * 0,1) # forbehandling af 90% af hele datasættet i batchen # - normaliser funktionerne # - one_hot_encode etiketterne # - gem i en ny fil med navnet 'preprocess_batch_' + batchnummer # - hver fil for hver batch _forproces_og_save(normalisere, one_hot_encode, funktioner[:-index_of_validation], etiketter[:-index_of_validation], 'preprocess_batch_' + s(batch_i) + '.p') # i modsætning til træningsdatasættet tilføjes valideringsdatasættet gennem hele batchdatasættet # - tag 10% af batchens samlede datasæt # - tilføj dem til en liste over # - valid_features # - valid_labels valid_features.forlænge(funktioner[-index_of_validation:]) valid_labels.forlænge(etiketter[-index_of_validation:]) # forbehandle alt stablet valideringsdatasæt _forproces_og_save(normalisere, one_hot_encode, for eksempel..array(valid_features), for eksempel..array(valid_labels), 'preprocess_validation.p') # indlæs testdatasættet med åben(cifar10_dataset_folder_path + '/ test_batch', mode='rb') som fil: parti = pickle.belastning(fil, indkodning='latin1') # forbehandle testdataene testfunktioner = parti['data'].omforme((len(parti['data']), 3, 32, 32)).transponere(0, 2, 3, en) test_mærkater = parti['etiketter'] # Forbehandling og gem alle testdata _forproces_og_save(normalisere, one_hot_encode, for eksempel..array(testfunktioner), for eksempel..array(test_mærkater), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normalisere, one_hot_encode)

• Kontrolpunkt

importere pickle valid_features, valid_labels = pickle.belastning(åben('preprocess_validation.p', mode='rb'))

• Opbygning af netværket

Hele modellen består af i alt 14 lag.

importere tensorflow som tf def conv_net(x, holde_prob): konv1_filter = tf.Variabel(tf.trunkeret_normalt(form=[3, 3, 3, 64], betyde=0, stddev=0,08)) konv2_filter = tf.Variabel(tf.trunkeret_normalt(form=[3, 3, 64, 128], betyde=0, stddev=0,08)) conv3_filter = tf.Variabel(tf.trunkeret_normalt(form=[5, 5, 128, 256], betyde=0, stddev=0,08)) conv4_filter = tf.Variabel(tf.trunkeret_normalt(form=[5, 5, 256, 512], betyde=0, stddev=0,08)) # 1, 2 konv1 = tf.nr.konv2d(x, konv1_filter, skridt=[en,en,en,en], polstring='SAMME') konv1 = tf.nr.relu(konv1) conv1_pool = tf.nr.max_pool(konv1, ksize=[en,2,2,en], skridt=[en,2,2,en], polstring='SAMME') conv1_bn = tf.lag.batch_normalisering(conv1_pool) # 3. 4 konv2 = tf.nr.konv2d(conv1_bn, konv2_filter, skridt=[en,en,en,en], polstring='SAMME') konv2 = tf.nr.relu(konv2) conv2_pool = tf.nr.max_pool(konv2, ksize=[en,2,2,en], skridt=[en,2,2,en], polstring='SAMME') conv2_bn = tf.lag.batch_normalisering(conv2_pool) # 5, 6 konv3 = tf.nr.konv2d(conv2_bn, conv3_filter, skridt=[en,en,en,en], polstring='SAMME') konv3 = tf.nr.relu(konv3) conv3_pool = tf.nr.max_pool(konv3, ksize=[en,2,2,en], skridt=[en,2,2,en], polstring='SAMME') conv3_bn = tf.lag.batch_normalisering(conv3_pool) # 7, 8 konv4 = tf.nr.konv2d(conv3_bn, conv4_filter, skridt=[en,en,en,en], polstring='SAMME') konv4 = tf.nr.relu(konv4) conv4_pool = tf.nr.max_pool(konv4, ksize=[en,2,2,en], skridt=[en,2,2,en], polstring='SAMME') conv4_bn = tf.lag.batch_normalisering(conv4_pool) # 9 flad = tf.bidrag.lag.flad(conv4_bn) # 10 fuld1 = tf.bidrag.lag.fuldt tilsluttet(indgange=flad, num_outputs=128, aktivering_fn=tf.nr.relu) fuld1 = tf.nr.droppe ud(fuld1, holde_prob) fuld1 = tf.lag.batch_normalisering(fuld1) # elleve fuld2 = tf.bidrag.lag.fuldt tilsluttet(indgange=fuld1, num_outputs=256, aktivering_fn=tf.nr.relu) fuld2 = tf.nr.droppe ud(fuld2, holde_prob) fuld2 = tf.lag.batch_normalisering(fuld2) # 12 fuld3 = tf.bidrag.lag.fuldt tilsluttet(indgange=fuld2, num_outputs=512, aktivering_fn=tf.nr.relu) fuld3 = tf.nr.droppe ud(fuld3, holde_prob) fuld3 = tf.lag.batch_normalisering(fuld3) # 13 fuld4 = tf.bidrag.lag.fuldt tilsluttet(indgange=fuld3, num_outputs=1024, aktivering_fn=tf.nr.relu) fuld4 = tf.nr.droppe ud(fuld4, holde_prob) fuld4 = tf.lag.batch_normalisering(fuld4) # 14 ud = tf.bidrag.lag.fuldt tilsluttet(indgange=fuld3, num_outputs=10, aktivering_fn=Ingen) Vend tilbage ud

• Hyperparametre

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

logitter = conv_net(x, holde_prob) model = tf.identitet(logitter, navn='logitter') # Navn logiterer Tensor, så det kan indlæses fra disken efter træning # Tab og optimering koste = tf.reducere-middel(tf.nr.softmax_cross_entropy_with_logits(logitter=logitter, etiketter=Y)) optimering = tf.tog.AdamOptimizer(learning_rate=learning_rate).minimere(koste) # Nøjagtighed korrekt_pred = tf.lige(tf.argmax(logitter, en), tf.argmax(Y, en)) nøjagtighed = tf.reducere-middel(tf.støbt(korrekt_pred, tf.flyde32), navn='nøjagtighed')

• Træn det neurale netværk

# Enkeltoptimering 
def train_neural_network(session, optimering, keep_probability, feature_batch, label_batch): session.løb(optimering, feed_dict={ x: feature_batch, Y: label_batch, holde_prob: keep_probability })

#Show Stats def print_stats(session, feature_batch, label_batch, koste, nøjagtighed): tab = sess.løb(koste, feed_dict={ x: feature_batch, Y: label_batch, holde_prob: en. }) valid_acc = sess.løb(nøjagtighed, feed_dict={ x: valid_features, Y: valid_labels, holde_prob: en. }) Print('Tab:{:> 10.4f}Valideringsnøjagtighed:{: .6f}''.format(tab, valid_acc))

• Fuld træning og lagring af modellen

def batch_features_labels(funktioner, etiketter, batch_størrelse): '' ' Opdel funktioner og etiketter i batches '' ' til Start i rækkevidde(0, len(funktioner), batch_størrelse): ende = min(Start + batch_størrelse, len(funktioner)) udbytte funktioner[Start:ende], etiketter[Start:ende] def load_preprocess_training_batch(batch_id, batch_størrelse): '' ' Indlæs de forforarbejdede træningsdata, og returner dem i batches på eller mindre '' ' filnavn = 'preprocess_batch_' + s(batch_id) + '.p' funktioner, etiketter = pickle.belastning(åben(filnavn, mode='rb')) # Returner træningsdataene i batches af størrelse eller mindre Vend tilbage batch_features_labels(funktioner, etiketter, batch_størrelse)

#Sparemodel og sti 
gemme_sti = './image_classification' Print('Uddannelse...') med tf.Session() som sess: # Initialisering af variablerne sess.løb(tf.global_variables_initializer()) # Træningscyklus til epoke i rækkevidde(epoker): # Loop over alle batcher n_batches = 5 til batch_i i rækkevidde(en, n_batches + en): til batch_features, batch_labels i load_preprocess_training_batch(batch_i, batch_størrelse): train_neural_network(sess, optimering, keep_probability, batch_features, batch_labels) Print('Epoke{:> 2}, CIFAR-10 Batch{}: '.format(epoke + en, batch_i), ende='') print_stats(sess, batch_features, batch_labels, koste, nøjagtighed) # Gem model opsparer = tf.tog.Saver() gemme sti = opsparer.Gemme(sess, gemme_sti)

php konvertere array til objekt

Nu er den vigtige del af Tensorflow Image Classification færdig. Nu er det tid til at teste modellen.

• Test af modellen

importere pickle importere bedøvet som for eksempel. importere matplotlib.pyplot som plt fra sklearn.forbehandling importere LabelBinarizer def batch_features_labels(funktioner, etiketter, batch_størrelse): '' ' Opdel funktioner og etiketter i batches '' ' til Start i rækkevidde(0, len(funktioner), batch_størrelse): ende = min(Start + batch_størrelse, len(funktioner)) udbytte funktioner[Start:ende], etiketter[Start:ende] def display_image_predictions(funktioner, etiketter, forudsigelser, top_n_forudsigelser): n_klasser = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.passe(rækkevidde(n_klasser)) label_ids = label_binarizer.inverse_transform(for eksempel..array(etiketter)) fig, akser = plt.delplots(nrows=top_n_forudsigelser, ncols=2, figenstørrelse=(tyve, 10)) fig.stram_layout() fig.suptitle('Softmax forudsigelser', skriftstørrelse=tyve, Y=1.1) n_forudsigelser = 3 margen = 0,05 ind = for eksempel..arange(n_forudsigelser) bredde = (en. - 2. * margen) / n_forudsigelser til image_i, (funktion, label_id, pred_indicies, pred_values) i tælle(lynlås(funktioner, label_ids, forudsigelser.indekser, forudsigelser.værdier)): hvis (image_i < top_n_forudsigelser): fornavn = [label_names[pred_i] til pred_i i pred_indicies] korrekt_navn = label_names[label_id] akser[image_i] [0].imshow((funktion*255).astype(for eksempel..int32, kopi=Falsk)) akser[image_i] [0].sæt_titel(korrekt_navn) akser[image_i] [0].set_axis_off() akser[image_i] [en].barh(ind + margen, pred_values[:3], bredde) akser[image_i] [en].sæt_ticks(ind + margen) akser[image_i] [en].sæt_yticklabels(fornavn[::-en]) akser[image_i] [en].sæt_xticks([0, 0,5, 1.0])

%matplotlib inline %config InlineBackend.figur_format = 'nethinden' importere tensorflow som tf importere pickle importere tilfældig gemme_sti = './image_classification' batch_størrelse = 64 n_ prøver = 10 top_n_forudsigelser = 5 def test_model(): testfunktioner, test_mærkater = pickle.belastning(åben('preprocess_training.p', mode='rb')) load_graph = tf.Kurve() med tf.Session(kurve=load_graph) som sess: # Indlæsningsmodel læsser = tf.tog.import_meta_graph(gemme_sti + '.meta') læsser.gendanne(sess, gemme_sti) # Få tonere fra indlæst model lastet_x = load_graph.get_tensor_by_name('input_x: 0') indlæst_y = load_graph.get_tensor_by_name('output_y: 0') loaded_keep_prob = load_graph.get_tensor_by_name('keep_prob: 0') loaded_logits = load_graph.get_tensor_by_name('logitter: 0') loaded_acc = load_graph.get_tensor_by_name('nøjagtighed: 0') # Få nøjagtighed i batches for hukommelsesbegrænsninger test_batch_acc_total = 0 test_batch_count = 0 til train_feature_batch, train_label_batch i batch_features_labels(testfunktioner, test_mærkater, batch_størrelse): test_batch_acc_total + = sess.løb( loaded_acc, feed_dict={lastet_x: train_feature_batch, indlæst_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = en Print('Testnøjagtighed:{} ''.format(test_batch_acc_total/test_batch_count)) # Udskriv tilfældige prøver tilfældige_testfunktioner, tilfældige_test_mærkater = tuple(lynlås(*tilfældig.prøve(liste(lynlås(testfunktioner, test_mærkater)), n_ prøver))) tilfældige_prøvningsforudsigelser = sess.løb( tf.nr.top_k(tf.nr.softmax(loaded_logits), top_n_forudsigelser), feed_dict={lastet_x: tilfældige_testfunktioner, indlæst_y: tilfældige_test_mærkater, loaded_keep_prob: 1.0}) display_image_predictions(tilfældige_testfunktioner, tilfældige_test_mærkater, tilfældige_prøvningsforudsigelser, top_n_forudsigelser) test_model()

Produktion: Testnøjagtighed: 0.5882762738853503

Hvis du træner dit neurale netværk i flere epoker eller ændrer aktiveringsfunktionen, får du muligvis et andet resultat, der måske har bedre nøjagtighed.

Så med dette kommer vi til en afslutning på denne TensorFlow Image Classification-artikel. Jeg er sikker på, at du nu kan bruge det samme til at klassificere enhver form for billeder, og du er ikke en begyndermand til billedklassificering.

Edureka's med Python certificering Uddannelse er kurateret af fagfolk i branchen i henhold til branchens krav og krav. Du mestrer begreberne som SoftMax-funktion, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kurset er specielt kurateret af brancheeksperter med realtids casestudier.