TensorFlow-bildklassificering: Allt du behöver veta om byggklassificatorer

Bildklassificering en uppgift som även en baby kan göra på några sekunder, men för en maskin har det varit en tuff uppgift fram till de senaste framstegen inom och Djup lärning . Självkörande bilar kan upptäcka föremål och vidta nödvändiga åtgärder i realtid och det mesta är möjligt på grund av Bildklassificering. I den här artikeln guidar jag dig genom följande ämnen:

• Vad är TensorFlow?
• Vad är bildklassificering?
• TensorFlow bildklassificering: Mode MNIST
• CIFAR 10: CNN

Vad är TensorFlow?

TensorFlow är Googles Open Source Machine Learning Framework för dataflödesprogrammering över en rad uppgifter. Noder i diagrammet representerar matematiska operationer, medan grafkanterna representerar de flerdimensionella dataarrisen som kommuniceras mellan dem.

Tensorer är bara flerdimensionella matriser, en förlängning av tvådimensionella tabeller till data med en högre dimension. Det finns många funktioner i Tensorflow som gör det lämpligt för Deep Learning och dess kärnkodsbibliotek hjälper dig att utveckla och träna ML-modeller.

Vad är bildklassificering?

Syftet med bildklassificering är att kategorisera alla pixlar i en digital bild i en av flera marktäckning klasser eller teman . Denna kategoriserade data kan sedan användas för att producera temakartor av landskyddet i en bild.

Nu, beroende på interaktionen mellan analytikern och datorn under klassificeringen, finns det två typer av klassificering:

• Övervakad &
• Oövervakad

Låt oss hoppa in i TensorFlow-bildklassificering utan att slösa bort tid. Jag har två exempel: lätt och svårt. Låt oss fortsätta med den enkla.

TensorFlow bildklassificering: Mode MNIST

Mode MNIST-dataset

Här ska vi använda Fashion MNIST Dataset, som innehåller 70 000 gråskalebilder i tio kategorier. Vi kommer att använda 60000 för träning och resten 10000 för teständamål. Du kan komma åt Fashion MNIST direkt från TensorFlow, bara importera och ladda in data.

• Låt oss importera biblioteken först

från __future__ importerar absolut_import, division, utskriftsfunktion # TensorFlow och tf.keras importerar tensorflow som tf från tensorflow import keras # Hjälpbibliotek importerar numpy som np importerar matplotlib.pyplot som plt

• Låt oss ladda in data

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

• Därefter ska vi kartlägga bilderna i klasser

class_names = ['T-shirt / topp', 'Byxa', 'Pullover', 'Klänning', 'Kappa', 'Sandal', 'Skjorta', 'Sneaker', 'Väska', 'Ankelkänga']

• Utforska data

train_images.form 
#Each Label är mellan 0-9

train_labels 
test_bilder.form 

• Nu är det dags att förbehandla data.

plt.figur() plt.imshow(train_images[0]) plt.färgfält() plt.rutnät(Falsk) plt.show() 
#Om du inspekterar den första bilden i träningsuppsättningen ser du att pixelvärdena ligger inom området 0 till 255. 

• Vi måste skala bilderna från 0-1 för att mata in dem i Neural Network

train_images = train_images / 255,0 test_bilder = test_bilder / 255,0

• Låt oss visa några bilder.

plt.figur(fikonstorlek=(10,10)) för i i räckvidd(25): plt.delplott(5,5,i+ett) plt.xticks([]) plt.yticks([]) plt.rutnät(Falsk) plt.imshow(train_images[i], cmap=plt.centimeter.binär) plt.xlabel(klassnamn[train_labels[i]]) plt.show()

• Ställ in lagren

modell = hård.Sekventiell([ hård.skikten.Platta(input_shape=(28, 28)), hård.skikten.Tät(128, aktivering=tf.nr.relu), hård.skikten.Tät(10, aktivering=tf.nr.softmax) ])

• Kompilera modellen

modell.sammanställa(optimizer='Adam', förlust='gles_kategorisk_korsentropi', metrik=['noggrannhet'])

• Modellutbildning

modell.passa(train_images, train_labels, epoker=10)

• Utvärdera noggrannhet

testförlust, test_acc = modell.utvärdera(test_bilder, test_etiketter) skriva ut('Testnoggrannhet:', test_acc)

längden på en matris i javascript

• Förutsäga

förutsägelser = modell.förutspå(test_bilder)

förutsägelser[0]

En förutsägelse är en matris med 10 nummer. Dessa beskriver modellens 'självförtroende' att bilden motsvarar var och en av de tio olika kläderna. Vi kan se vilken etikett som har högst konfidensvärde.

t.ex..argmax(förutsägelser[0])#Model är mest säker på att det är en fotkänga. Låt oss se om det är korrekt

Utgång: 9

test_etiketter[0]

Utgång: 9

• Nu är det dags att titta på hela uppsättningen av tio kanaler

def plot_image(i, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[i], true_label[i], img[i] plt.rutnät(Falsk) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.centimeter.binär) förutsagt_etikett = t.ex..argmax(predictions_array) om förutsagt_etikett == true_label: Färg = 'grön' annan: Färg = 'netto' plt.xlabel(''{} {: 2.0f}% ({}) '.formatera(klassnamn[förutsagt_etikett], 100*t.ex..max(predictions_array), klassnamn[true_label]), Färg=Färg) def plot_value_array(i, predictions_array, true_label): predictions_array, true_label = predictions_array[i], true_label[i] plt.rutnät(Falsk) plt.xticks([]) plt.yticks([]) denna tomt = plt.bar(räckvidd(10), predictions_array, Färg='# 777777') plt.ylim([0, ett]) förutsagt_etikett = t.ex..argmax(predictions_array) denna tomt[förutsagt_etikett].set_color('netto') denna tomt[true_label].set_color('grön')

• Låt oss titta på den 0: e och 10: e bilden först

i = 0 plt.figur(fikonstorlek=(6,3)) plt.delplott(ett,2,ett) plot_image(i, förutsägelser, test_etiketter, test_bilder) plt.delplott(ett,2,2) plot_value_array(i, förutsägelser, test_etiketter) plt.show()

i = 10 plt.figur(fikonstorlek=(6,3)) plt.delplott(ett,2,ett) plot_image(i, förutsägelser, test_etiketter, test_bilder) plt.delplott(ett,2,2) plot_value_array(i, förutsägelser, test_etiketter) plt.show()

• Låt oss nu plotta flera bilder och deras förutsägelser. De korrekta är gröna, medan de felaktiga är röda.

num_rows = 5 num_cols = 3 antal_bilder = num_rows*num_cols plt.figur(fikonstorlek=(2*2*num_cols, 2*num_rows)) för i i räckvidd(antal_bilder): plt.delplott(num_rows, 2*num_cols, 2*i+ett) plot_image(i, förutsägelser, test_etiketter, test_bilder) plt.delplott(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, förutsägelser, test_etiketter) plt.show()

• Slutligen kommer vi att använda den utbildade modellen för att förutsäga en enda bild.

# Ta en bild från testdataset img = test_bilder[0] skriva ut(img.form)

# Lägg till bilden i en grupp där den är den enda medlemmen. img = (t.ex..expand_dims(img,0)) skriva ut(img.form)

predictions_single = modell.förutspå(img) skriva ut(predictions_single)

plot_value_array(0, predictions_single, test_etiketter) plt.xticks(räckvidd(10), klassnamn, rotation=Fyra fem) plt.show()

• Som du kan se förutsägelsen för vår enda bild i batch.

prediction_result = t.ex..argmax(predictions_single[0])

Utgång: 9

CIFAR-10: CNN

CIFAR-10-datasetet består av flygplan, hundar, katter och andra föremål. Du förbehandlar bilderna och tränar sedan ett favsivt neuralt nätverk på alla proverna. Bilderna måste normaliseras och etiketterna måste kodas hett. Detta användningsfall kommer säkert att rensa dina tvivel om TensorFlow Image Classification.

• Ladda ner data

från urllib.request importera urlretrieve från os.bana importera isfil, är sot från tqdm importera tqdm importera tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klass Ladda nerProgress(tqdm): last_block = 0 def krok(själv, block_num=ett, block storlek=ett, total storlek=Ingen): själv.total = total storlek själv.uppdatering((block_num - själv.last_block) * block storlek) själv.last_block = block_num '' ' kontrollera om datafilen (zip) redan har laddats ner om inte, ladda ner den från 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' och spara som cifar-10-python.tar.gz '' ' om inte isfil('cifar-10-python.tar.gz'): med Ladda nerProgress(enhet='B', enhetsskala=Sann, miniters=ett, beskrivning='CIFAR-10 Dataset') som pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.krok) om inte är sot(cifar10_dataset_folder_path): med tarfile.öppet('cifar-10-python.tar.gz') som tar: tar.extrahera() tar.stänga()

• Importera nödvändiga bibliotek

importera ättikslag importera bedövad som t.ex. importera matplotlib.pyplot som plt

• Förstå data

Den ursprungliga batchen av data är 10000 × 3072 tensor uttryckt i en bedövad array, där 10000 är antalet samplingsdata. Bilden är färgad och har storlek 32 × 32. Matning kan göras antingen i formatet (bredd x höjd x num_channel) eller (num_channel x bredd x höjd). Låt oss definiera etiketterna.

def load_label_names(): lämna tillbaka ['flygplan', 'bil', 'fågel', 'katt', 'rådjur', 'hund', 'groda', 'häst', 'fartyg', 'lastbil']

• Omforma data

Vi ska omforma data i två steg

Dela först radvektorn (3072) i tre delar. Varje bit motsvarar varje kanal. Detta resulterar i (3 x 1024) dimension av en tensor. Dela sedan den resulterande tensorn från föregående steg med 32. 32 betyder här bredden på en bild. Detta resulterar i (3x32x32).

För det andra måste vi transponera data från (num_channel, width, height) till (width, height, num_channel). För det ska vi använda transponeringsfunktionen.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): med öppet(cifar10_dataset_folder_path + '/ data_batch_' + sid(batch_id), läge='rb') som fil: # Observera att kodningstypen är 'latin1' omgång = ättikslag.ladda(fil, kodning='latin1') funktioner = omgång['data'].omforma((len(omgång['data']), 3, 32, 32)).transponera(0, 2, 3, ett) etiketter = omgång['etiketter'] lämna tillbaka funktioner, märka

• Utforska data

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): funktioner, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) om inte (0 <= sample_id < len(funktioner)): skriva ut(''{}prover i sats{}.{}är utom räckhåll. '.formatera(len(funktioner), batch_id, sample_id)) lämna tillbaka Ingen skriva ut('' Statistik över sats #{}: '.formatera(batch_id)) skriva ut(Antal prov:{} ''.formatera(len(funktioner))) etikettnamn = load_label_names() label_counts = diktera(blixtlås(*t.ex..unik(etiketter, return_counts=Sann))) för nyckel-, värde i label_counts.föremål(): skriva ut('Etiketträkning av [{}] ({}):{}''.formatera(nyckel-, etikettnamn[nyckel-].övre(), värde)) sample_image = funktioner[sample_id] exempel_etikett = etiketter[sample_id] skriva ut('' Exempel på bild{}: '.formatera(sample_id)) skriva ut('Bild - minvärde:{}Maxvärde:{}''.formatera(sample_image.min(), sample_image.max())) skriva ut('Bild - Form:{}''.formatera(sample_image.form)) skriva ut('Etikett - etikett-id:{}Namn:{}''.formatera(exempel_etikett, etikettnamn[exempel_etikett])) plt.imshow(sample_image)

%matplotlib i kö %konfigurera InlineBackend.figur_format = 'näthinnan' importera bedövad som t.ex. # Utforska datamängden batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Implementering av förbehandlingsfunktioner

Vi ska normalisera data via Min-Max Normalisering. Detta gör helt enkelt att alla x-värden ligger mellan 0 och 1.
y = (x-min) / (max-min)

def normalisera(x): '' ' argument - x: mata in bilddata i dumt array [32, 32, 3] lämna tillbaka - normaliserad x '' ' min_val = t.ex..min(x) max_val = t.ex..max(x) x = (x-min_val) / (max_val-min_val) lämna tillbaka x

• En-Hot-kodning

def one_hot_encode(x): '' ' argument - x: en lista med etiketter lämna tillbaka - en het kodningsmatris (antal etiketter, antal klasser) '' ' kodad = t.ex..nollor((len(x), 10)) för idx, timmar i räkna upp(x): kodad[idx] [timmar] = ett lämna tillbaka kodad

• Förbehandla och spara data

def _förprocess_och_spara(normalisera, one_hot_encode, funktioner, etiketter, filnamn): funktioner = normalisera(funktioner) etiketter = one_hot_encode(etiketter) ättikslag.dumpa((funktioner, etiketter), öppet(filnamn, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalisera, one_hot_encode): n_batcher = 5 valid_features = [] valid_labels = [] för batch_i i räckvidd(ett, n_batcher + ett): funktioner, etiketter = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # hitta index för att vara punkten som valideringsdata i hela datasetet för batchen (10%) index_of_validation = int(len(funktioner) * 0,1) # förbehandla 90% av hela batchen för batchen # - normalisera funktionerna # - one_hot_encode the lables # - spara i en ny fil med namnet 'preprocess_batch_' + batchnummer # - varje fil för varje batch _förprocess_och_spara(normalisera, one_hot_encode, funktioner[:-index_of_validation], etiketter[:-index_of_validation], 'preprocess_batch_' + sid(batch_i) + '.p') # till skillnad från träningsdataset kommer valideringsdataset att läggas till genom alla batchdataset # - ta 10% av hela datamängden för batchen # - lägg till dem i en lista över # - valid_features # - valid_labels valid_features.förlänga(funktioner[-index_of_validation:]) valid_labels.förlänga(etiketter[-index_of_validation:]) # förbehandla alla staplade valideringsdataset _förprocess_och_spara(normalisera, one_hot_encode, t.ex..array(valid_features), t.ex..array(valid_labels), 'preprocess_validation.p') # ladda testdataset med öppet(cifar10_dataset_folder_path + '/ test_batch', läge='rb') som fil: omgång = ättikslag.ladda(fil, kodning='latin1') # förbehandla testdata test_features = omgång['data'].omforma((len(omgång['data']), 3, 32, 32)).transponera(0, 2, 3, ett) test_etiketter = omgång['etiketter'] # Förbehandla och spara alla testdata _förprocess_och_spara(normalisera, one_hot_encode, t.ex..array(test_features), t.ex..array(test_etiketter), 'preprocess_training.p')

preprocess_and_save_data(cifar10_dataset_folder_path, normalisera, one_hot_encode)

• Kontrollstation

importera ättikslag valid_features, valid_labels = ättikslag.ladda(öppet('preprocess_validation.p', läge='rb'))

• Bygga nätverket

Hela modellen består av totalt 14 lager.

importera tensorflöde som tf def conv_net(x, keep_prob): conv1_filter = tf.Variabel(tf.trunkerad_normal(form=[3, 3, 3, 64], betyda=0, stddev=0,08)) conv2_filter = tf.Variabel(tf.trunkerad_normal(form=[3, 3, 64, 128], betyda=0, stddev=0,08)) conv3_filter = tf.Variabel(tf.trunkerad_normal(form=[5, 5, 128, 256], betyda=0, stddev=0,08)) conv4_filter = tf.Variabel(tf.trunkerad_normal(form=[5, 5, 256, 512], betyda=0, stddev=0,08)) # 1, 2 conv1 = tf.nr.conv2d(x, conv1_filter, steg=[ett,ett,ett,ett], stoppning='SAMMA') conv1 = tf.nr.relu(conv1) conv1_pool = tf.nr.max_pool(conv1, ksize=[ett,2,2,ett], steg=[ett,2,2,ett], stoppning='SAMMA') conv1_bn = tf.skikten.batch_normalisering(conv1_pool) # 3. 4 conv2 = tf.nr.conv2d(conv1_bn, conv2_filter, steg=[ett,ett,ett,ett], stoppning='SAMMA') conv2 = tf.nr.relu(conv2) conv2_pool = tf.nr.max_pool(conv2, ksize=[ett,2,2,ett], steg=[ett,2,2,ett], stoppning='SAMMA') conv2_bn = tf.skikten.batch_normalisering(conv2_pool) # 5, 6 conv3 = tf.nr.conv2d(conv2_bn, conv3_filter, steg=[ett,ett,ett,ett], stoppning='SAMMA') conv3 = tf.nr.relu(conv3) conv3_pool = tf.nr.max_pool(conv3, ksize=[ett,2,2,ett], steg=[ett,2,2,ett], stoppning='SAMMA') conv3_bn = tf.skikten.batch_normalisering(conv3_pool) # 7, 8 conv4 = tf.nr.conv2d(conv3_bn, conv4_filter, steg=[ett,ett,ett,ett], stoppning='SAMMA') conv4 = tf.nr.relu(conv4) conv4_pool = tf.nr.max_pool(conv4, ksize=[ett,2,2,ett], steg=[ett,2,2,ett], stoppning='SAMMA') conv4_bn = tf.skikten.batch_normalisering(conv4_pool) # 9 platt = tf.bidrag.skikten.platta(conv4_bn) # 10 full1 = tf.bidrag.skikten.helt ansluten(ingångar=platt, antal_utgångar=128, aktivering_fn=tf.nr.relu) full1 = tf.nr.hoppa av(full1, keep_prob) full1 = tf.skikten.batch_normalisering(full1) # elva full2 = tf.bidrag.skikten.helt ansluten(ingångar=full1, antal_utgångar=256, aktivering_fn=tf.nr.relu) full2 = tf.nr.hoppa av(full2, keep_prob) full2 = tf.skikten.batch_normalisering(full2) # 12 full3 = tf.bidrag.skikten.helt ansluten(ingångar=full2, antal_utgångar=512, aktivering_fn=tf.nr.relu) full3 = tf.nr.hoppa av(full3, keep_prob) full3 = tf.skikten.batch_normalisering(full3) # 13 full4 = tf.bidrag.skikten.helt ansluten(ingångar=full3, antal_utgångar=1024, aktivering_fn=tf.nr.relu) full4 = tf.nr.hoppa av(full4, keep_prob) full4 = tf.skikten.batch_normalisering(full4) # 14 ut = tf.bidrag.skikten.helt ansluten(ingångar=full3, antal_utgångar=10, aktivering_fn=Ingen) lämna tillbaka ut

• Hyperparametrar

epoker = 10 satsstorlek = 128 keep_probability = 0,7 learning_rate = 0,001

logiter = conv_net(x, keep_prob) modell = tf.identitet(logiter, namn='loggar') # Namn loggar Tensor, så att det kan laddas från disk efter träning # Förlust och optimering kosta = tf.minska_medlet(tf.nr.softmax_cross_entropy_with_logits(logiter=logiter, etiketter=Y)) optimizer = tf.tåg.AdamOptimizer(learning_rate=learning_rate).minimera(kosta) # Noggrannhet correct_pred = tf.likvärdig(tf.argmax(logiter, ett), tf.argmax(Y, ett)) noggrannhet = tf.minska_medlet(tf.kasta(correct_pred, tf.float32), namn='noggrannhet')

• Träna det neurala nätverket

# Enkel optimering 
def train_neural_network(session, optimizer, keep_probability, feature_batch, label_batch): session.springa(optimizer, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: keep_probability })

#Showing Stats def utskriftsstatistik(session, feature_batch, label_batch, kosta, noggrannhet): förlust = sess.springa(kosta, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: ett. }) valid_acc = sess.springa(noggrannhet, feed_dict={ x: valid_features, Y: valid_labels, keep_prob: ett. }) skriva ut('Förlust:{:> 10.4f}Valideringsnoggrannhet:{: .6f}''.formatera(förlust, valid_acc))

• Träna och spara modellen helt

def batch_features_labels(funktioner, etiketter, satsstorlek): '' ' Dela upp funktioner och etiketter i satser '' ' för Start i räckvidd(0, len(funktioner), satsstorlek): slutet = min(Start + satsstorlek, len(funktioner)) avkastning funktioner[Start:slutet], etiketter[Start:slutet] def load_preprocess_training_batch(batch_id, satsstorlek): '' ' Ladda de förbehandlade träningsdata och returnera dem i satser på eller mindre '' ' filnamn = 'preprocess_batch_' + sid(batch_id) + '.p' funktioner, etiketter = ättikslag.ladda(öppet(filnamn, läge='rb')) # Returnera träningsuppgifterna i partier av storlek eller mindre lämna tillbaka batch_features_labels(funktioner, etiketter, satsstorlek)

#Spara modell och sökväg 
save_model_path = './bild_klassificering' skriva ut('Träning...') med tf.Session() som sess: # Initiera variablerna sess.springa(tf.global_variables_initializer()) # Träningscykel för epok i räckvidd(epoker): # Loop över alla satser n_batcher = 5 för batch_i i räckvidd(ett, n_batcher + ett): för batch_features, batch_labels i load_preprocess_training_batch(batch_i, satsstorlek): train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels) skriva ut('Epok{:> 2}, CIFAR-10 Batch{}: '.formatera(epok + ett, batch_i), slutet='') utskriftsstatistik(sess, batch_features, batch_labels, kosta, noggrannhet) # Spara modell sparare = tf.tåg.Sparare() save_path = sparare.spara(sess, save_model_path)

Nu är den viktiga delen av Tensorflow Image Classification klar. Nu är det dags att testa modellen.

• Testa modellen

importera ättikslag importera bedövad som t.ex. importera matplotlib.pyplot som plt från sklearn.preprocessing importera LabelBinarizer def batch_features_labels(funktioner, etiketter, satsstorlek): '' ' Dela upp funktioner och etiketter i satser '' ' för Start i räckvidd(0, len(funktioner), satsstorlek): slutet = min(Start + satsstorlek, len(funktioner)) avkastning funktioner[Start:slutet], etiketter[Start:slutet] def display_image_predictions(funktioner, etiketter, förutsägelser, topp_n_förutsägelser): n_klasser = 10 etikettnamn = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.passa(räckvidd(n_klasser)) label_ids = label_binarizer.invers_transform(t.ex..array(etiketter)) fikon, axlar = plt.delplottar(nollor=topp_n_förutsägelser, ncols=2, fikonstorlek=(tjugo, 10)) fikon.tight_layout() fikon.suptitle('Softmax förutsägelser', textstorlek=tjugo, Y=1.1) n_förutsägelser = 3 marginal = 0,05 ind = t.ex..arange(n_förutsägelser) bredd = (ett. - 2. * marginal) / n_förutsägelser för image_i, (funktion, label_id, pred_indicies, pred_values) i räkna upp(blixtlås(funktioner, label_ids, förutsägelser.index, förutsägelser.värden)): om (image_i < topp_n_förutsägelser): förnamn = [etikettnamn[pred_i] för pred_i i pred_indicies] korrekt_namn = etikettnamn[label_id] axlar[image_i] [0].imshow((funktion*255).astype(t.ex..int32, kopiera=Falsk)) axlar[image_i] [0].set_title(korrekt_namn) axlar[image_i] [0].set_axis_off() axlar[image_i] [ett].barh(ind + marginal, pred_values[:3], bredd) axlar[image_i] [ett].set_yticks(ind + marginal) axlar[image_i] [ett].set_yticklabels(förnamn[::-ett]) axlar[image_i] [ett].set_xticks([0, 0,5, 1.0])

%matplotlib i kö %konfigurera InlineBackend.figur_format = 'näthinnan' importera tensorflöde som tf importera ättikslag importera slumpmässig save_model_path = './bild_klassificering' satsstorlek = 64 n_prover = 10 topp_n_förutsägelser = 5 def test_modell(): test_features, test_etiketter = ättikslag.ladda(öppet('preprocess_training.p', läge='rb')) laddad_graf = tf.Graf() med tf.Session(Graf=laddad_graf) som sess: # Lastmodell lastare = tf.tåg.import_meta_graph(save_model_path + '.meta') lastare.Återställ(sess, save_model_path) # Få tensorer från laddad modell laddad_x = laddad_graf.get_tensor_by_name('input_x: 0') laddad_y = laddad_graf.get_tensor_by_name('output_y: 0') laddad_hållande_prob = laddad_graf.get_tensor_by_name('keep_prob: 0') laddade_loggar = laddad_graf.get_tensor_by_name('logiter: 0') laddad_acc = laddad_graf.get_tensor_by_name('noggrannhet: 0') # Få noggrannhet i satser för minnesbegränsningar test_batch_acc_total = 0 test_batch_count = 0 för train_feature_batch, train_label_batch i batch_features_labels(test_features, test_etiketter, satsstorlek): test_batch_acc_total + = sess.springa( laddad_acc, feed_dict={laddad_x: train_feature_batch, laddad_y: train_label_batch, laddad_hållande_prob: 1.0}) test_batch_count + = ett skriva ut('Testning noggrannhet:{} ''.formatera(test_batch_acc_total/test_batch_count)) # Skriv ut slumpmässiga prover slumpmässiga_testfunktioner, slumpmässiga_testmärken = tupel(blixtlås(*slumpmässig.prov(lista(blixtlås(test_features, test_etiketter)), n_prover))) slumpmässiga_test_förutsägelser = sess.springa( tf.nr.top_k(tf.nr.softmax(laddade_loggar), topp_n_förutsägelser), feed_dict={laddad_x: slumpmässiga_testfunktioner, laddad_y: slumpmässiga_testmärken, laddad_hållande_prob: 1.0}) display_image_predictions(slumpmässiga_testfunktioner, slumpmässiga_testmärken, slumpmässiga_test_förutsägelser, topp_n_förutsägelser) test_modell()

Produktion: Testnoggrannhet: 0.5882762738853503

Nu, om du tränar ditt neurala nätverk för fler epoker eller ändrar aktiveringsfunktionen, kan du få ett annat resultat som kan ha bättre noggrannhet.

Så med detta kommer vi till ett slut på den här TensorFlow-bildklassificeringsartikeln. Jag är säker på att du nu kan använda samma för att klassificera alla typer av bilder och du är inte nybörjare för bildklassificering.

länkad lista i c tutorial

Edureka's med Python-certifiering utbildas curated av branschpersonal enligt branschens krav och krav. Du kommer att behärska koncepten som SoftMax-funktion, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kursen har specialiserats av branschexperter med fallstudier i realtid.