TensorFlow attēlu klasifikācija: viss, kas jums jāzina par ēku klasifikatoriem

Attēlu klasifikācija - uzdevums, kuru pat zīdainis var paveikt dažu sekunžu laikā, taču mašīnai tas ir bijis grūts uzdevums līdz pēdējiem sasniegumiem un Dziļa mācīšanās . Pašpiedziņas automašīnas var noteikt objektus un veikt nepieciešamās darbības reāllaikā, un lielākoties tas ir iespējams tāpēc Attēlu klasifikācija. Šajā rakstā es iepazīstināšu jūs ar šādām tēmām:

kas ir hašmaps java

• Kas ir TensorFlow?
• Kas ir attēlu klasifikācija?
• TensorFlow attēlu klasifikācija: Modes MNIST
• CIFAR 10: CNN

Kas ir TensorFlow?

TensorFlow ir Google atvērtā pirmkoda mašīnmācīšanās ietvars datu plūsmas programmēšanai dažādiem uzdevumiem. Mezgli diagrammā attēlo matemātiskās darbības, savukārt diagrammas malas attēlo daudzdimensiju datu masīvus, kas tiek savstarpēji paziņoti.

Tensori ir tikai daudzdimensionāli masīvi, divdimensiju tabulu paplašinājums datiem ar augstāku dimensiju. Ir daudz Tensorflow iezīmju, kas padara to piemērotu dziļai apmācībai, un tā galvenā atvērtā pirmkoda bibliotēka palīdz jums izstrādāt un apmācīt ML modeļus.

Kas ir attēlu klasifikācija?

Attēlu klasifikācijas nolūks ir kategorizēt visus digitālā attēla pikseļus vienā no vairākiem zemes segums klases vai tēmas . Pēc tam šos klasificētos datus var izmantot, lai iegūtu tematiskās kartes zemes seguma, kas atrodas attēlā.

Tagad atkarībā no analītiķa un datora mijiedarbības klasifikācijas laikā ir divi klasifikācijas veidi:

• Uzraudzīts un
• Nepieskatīts

Tātad, netērējot laiku, pārejam uz TensorFlow attēlu klasifikāciju. Man ir 2 piemēri: viegli un grūti. Turpināsim vieglāko.

TensorFlow attēlu klasifikācija: Modes MNIST

Modes MNIST datu kopa

Šeit mēs izmantosim Fashion MNIST datu kopu, kas satur 70 000 pelēktoņu attēlus 10 kategorijās. Apmācībai izmantosim 60000, bet pārējos 10000 testēšanas vajadzībām. Jūs varat piekļūt Fashion MNIST tieši no TensorFlow, vienkārši importējiet un ielādējiet datus.

• Vispirms importēsim bibliotēkas

no __future__ importa absolūts_imports, dalīšana, drukas_funkcija # TensorFlow un tf.keras importē tensorflow kā tf no tensorflow importa keras # Palīdzības bibliotēkas importē numpy kā np import matplotlib.pyplot kā plt

• Ielādēsim datus

fashion_mnist = keras.datasets.fashion_mnist (vilciena_attēli, vilciena_apzīmējumi), (testa_attēli, testa_zīmējumi) = fashion_mnist.load_data ()

• Tālāk mēs attēlosim attēlus klasēs

class_names = ['T-krekls / augšdaļa', 'Bikses', 'Pulovers', 'Kleita', 'Mētelis', 'Sandale', 'Krekls', 'Sneakers', 'Soma', 'Potītes zābaks']

• Datu izpēte

vilciena attēli.forma 
# Katra iezīme ir starp 0–9

vilciena_ etiķetes 
test_images.forma 

• Ir pienācis laiks iepriekš apstrādāt datus.

plt.skaitlis() plt.imshow(vilciena attēli[0]) plt.krāsu josla() plt.režģis(Nepatiesa) plt.šovs() 
#Pārbaudot pirmo attēlu apmācības komplektā, redzēsiet, ka pikseļu vērtības ir diapazonā no 0 līdz 255. 

• Attēli ir jāmaina no 0 līdz 1, lai tos ievadītu neironu tīklā

vilciena attēli = vilciena attēli / 255.0 test_images = test_images / 255.0

• Parādīsim dažus attēlus.

plt.skaitlis(figsize=(10,10)) priekš i iekšā diapazons(25): plt.apakšlaukums(5,5,i+viens) plt.xticks([]) plt.yticks([]) plt.režģis(Nepatiesa) plt.imshow(vilciena attēli[i], cmap=plt.cm.binārs) plt.xlabel(klases_nosaukumi[vilciena_ etiķetes[i]]) plt.šovs()

• Iestatiet slāņus

modeli = grūti.Secīga([ grūti.slāņi.Saplacināt(ievades forma=(28, 28)), grūti.slāņi.Blīvs(128., aktivizēšana=tf.nr.relu), grūti.slāņi.Blīvs(10, aktivizēšana=tf.nr.softmax) ])

• Sastādiet modeli

modeli.sastādīt(optimizētājs='adam', zaudējums='sparse_categorical_crossentropy', metrika=['precizitāte'])

• Modeļu apmācība

modeli.der(vilciena attēli, vilciena_ etiķetes, laikmetiem=10)

• Precizitātes novērtēšana

test_loss, test_acc = modeli.novērtēt(test_images, test_labels) izdrukāt('Testa precizitāte:', test_acc)

• Prognozēšana

prognozes = modeli.paredzēt(test_images)

prognozes[0]

Prognoze ir 10 skaitļu masīvs. Tie raksturo modeļa “pārliecību”, ka attēls atbilst katram no 10 dažādiem apģērba izstrādājumiem. Mēs varam redzēt, kurai etiķetei ir visaugstākā ticamības vērtība.

kā dziļi kopēt java

piem..argmax(prognozes[0])#Model ir visvairāk pārliecināts, ka tas ir potītes zābaks. Apskatīsim, vai tas ir pareizi

Rezultāts: 9

test_labels[0]

Rezultāts: 9

• Ir pienācis laiks apskatīt visu 10 kanālu komplektu

def plot_image(i, pareģojumi_lainojums, true_label, img): pareģojumi_lainojums, true_label, img = pareģojumi_lainojums[i], true_label[i], img[i] plt.režģis(Nepatiesa) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binārs) pareģotā_label = piem..argmax(pareģojumi_lainojums) ja pareģotā_label == true_label: krāsa = 'zaļš' cits: krāsa = 'tīkls' plt.xlabel('{} {: 2.0f}% ({}) '.formātā(klases_nosaukumi[pareģotā_label], 100*piem..maks(pareģojumi_lainojums), klases_nosaukumi[true_label]), krāsa=krāsa) def plot_value_array(i, pareģojumi_lainojums, true_label): pareģojumi_lainojums, true_label = pareģojumi_lainojums[i], true_label[i] plt.režģis(Nepatiesa) plt.xticks([]) plt.yticks([]) šo sižetu = plt.bārs(diapazons(10), pareģojumi_lainojums, krāsa='# 777777') plt.ylim([0, viens]) pareģotā_label = piem..argmax(pareģojumi_lainojums) šo sižetu[pareģotā_label].set_color('tīkls') šo sižetu[true_label].set_color('zaļš')

• Vispirms apskatīsim 0. un 10. attēlu

i = 0 plt.skaitlis(figsize=(6,3)) plt.apakšlaukums(viens,2,viens) plot_image(i, prognozes, test_labels, test_images) plt.apakšlaukums(viens,2,2) plot_value_array(i, prognozes, test_labels) plt.šovs()

i = 10 plt.skaitlis(figsize=(6,3)) plt.apakšlaukums(viens,2,viens) plot_image(i, prognozes, test_labels, test_images) plt.apakšlaukums(viens,2,2) plot_value_array(i, prognozes, test_labels) plt.šovs()

• Uzzīmēsim vairākus attēlus un to prognozes. Pareizie ir zaļi, bet nepareizie - sarkanie.

num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.skaitlis(figsize=(2*2*num_cols, 2*num_rows)) priekš i iekšā diapazons(num_images): plt.apakšlaukums(num_rows, 2*num_cols, 2*i+viens) plot_image(i, prognozes, test_labels, test_images) plt.apakšlaukums(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, prognozes, test_labels) plt.šovs()

• Visbeidzot, mēs izmantosim apmācīto modeli, lai prognozētu vienu attēlu.

# Paņemiet attēlu no testa datu kopas img = test_images[0] izdrukāt(img.forma)

# Pievienojiet attēlu sērijai, kur tas ir vienīgais dalībnieks. img = (piem..expand_dims(img,0)) izdrukāt(img.forma)

pareģojumi_viens = modeli.paredzēt(img) izdrukāt(pareģojumi_viens)

plot_value_array(0, pareģojumi_viens, test_labels) plt.xticks(diapazons(10), klases_nosaukumi, rotācija=Četri, pieci) plt.šovs()

• Kā redzat prognozi par mūsu vienīgo attēlu sērijveidā.

prognozes_rezultāts = piem..argmax(pareģojumi_viens[0])

Rezultāts: 9

CIFAR-10: CNN

CIFAR-10 datu kopu veido lidmašīnas, suņi, kaķi un citi priekšmeti. Jūs iepriekš apstrādāsit attēlus, pēc tam visiem paraugiem apmācīsit konvolucionālo neironu tīklu. Attēli ir jā normalizē, un etiķetēm jābūt kodētām vienā karstumā. Šis lietošanas gadījums noteikti novērsīs jūsu šaubas par TensorFlow attēlu klasifikāciju.

• Datu lejupielāde

no urllib.request importēt urlretrieve no os.ceļš importēt isfile, ir kvēpi no tqdm importēt tqdm importēt tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klasē DownloadProgress(tqdm): pēdējais_bloks = 0 def āķis(pats, bloķēt_numuru=viens, block_size=viens, total_size=Nav): pats.Kopā = total_size pats.Atjaunināt((bloķēt_numuru - pats.pēdējais_bloks) * block_size) pats.pēdējais_bloks = bloķēt_numuru '' ' pārbaudiet, vai datu (zip) fails jau ir lejupielādēts ja nē, lejupielādējiet to vietnē https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz un saglabājiet kā cifar-10-python.tar.gz '' ' ja nē isfile('cifar-10-python.tar.gz'): ar DownloadProgress(vienība='B', vienības_ mērogs=Patiesi, miniters=viens, apraksts=“CIFAR-10 datu kopa”) kā pbar: urlretrieve( “https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz”, 'cifar-10-python.tar.gz', pbar.āķis) ja nē ir kvēpi(cifar10_dataset_folder_path): ar tarfile.atvērts('cifar-10-python.tar.gz') kā darva: darva.extractall() darva.tuvu()

• Nepieciešamo bibliotēku importēšana

importēt marinēti gurķi importēt numpy kā piem. importēt matplotlib.pyplot kā plt

• Datu izpratne

Sākotnējā datu partija ir 10000 × 3072 tenzors, izteikts numpy masīvā, kur 10000 ir datu paraugu skaits. Attēls ir krāsains un izmērs 32 × 32. Padevēju var veikt vai nu formātā (platums x augstums x ciparu kanāls), vai (num_kanāls x platums x augstums). Definēsim etiķetes.

def load_label_names(): atgriešanās ['lidmašīna', 'automobilis', 'putns', 'kaķis', 'briedis', 'suns', 'varde', 'zirgs', 'kuģis', 'smagā mašīna']

• Datu pārveidošana

Datus pārveidosim divos posmos

Pirmkārt, sadaliet rindas vektoru (3072) 3 daļās. Katrs gabals atbilst katram kanālam. Rezultātā tiek iegūts tenzora izmērs (3 x 1024). Tad sadaliet iegūto tenzoru no iepriekšējā soļa ar 32. 32 šeit nozīmē attēla platumu. Tā rezultātā (3x32x32).

Otrkārt, mums jātransponē dati no (num_channel, width, height) uz (width, height, num_channel). Tam mēs izmantosim transponēšanas funkciju.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): ar atvērts(cifar10_dataset_folder_path + '/ data_batch_' + lpp(batch_id), režīmā='rb') kā failu: # note, kodēšanas veids ir “latin1” partija = marinēti gurķi.slodze(failu, kodēšana='latin1') Iespējas = partija['dati'].pārveidot((len(partija['dati']), 3, 32, 32)).transponēt(0, 2, 3, viens) etiķetes = partija['etiķetes'] atgriešanās Iespējas, etiķete

• Datu izpēte

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Iespējas, etiķetes = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ja nē (0 <= sample_id < len(Iespējas)): izdrukāt('{}paraugi partijā{}.{}ir ārpus diapazona. '.formātā(len(Iespējas), batch_id, sample_id)) atgriešanās Nav izdrukāt(' Partijas statistika{}: '.formātā(batch_id)) izdrukāt('Paraugu skaits:{} '.formātā(len(Iespējas))) label_names = load_label_names() label_counts = diktēt(zip(*piem..unikāls(etiķetes, return_counts=Patiesi))) priekš taustiņu, vērtība iekšā label_counts.preces(): izdrukāt(“Etiķešu skaits [{}] ({}):{}'.formātā(taustiņu, label_names[taustiņu].augšējā(), vērtība)) parauga_attēls = Iespējas[sample_id] sample_label = etiķetes[sample_id] izdrukāt(' Attēla piemērs{}: '.formātā(sample_id)) izdrukāt('Attēls - minimālā vērtība:{}Maksimālā vērtība:{}'.formātā(parauga_attēls.min(), parauga_attēls.maks())) izdrukāt('Attēls - forma:{}'.formātā(parauga_attēls.forma)) izdrukāt('Etiķete - etiķetes ID:{}Nosaukums:{}'.formātā(sample_label, label_names[sample_label])) plt.imshow(parauga_attēls)

%matplotlib rindā %konfigurēt InlineBackend.attēls_formāts = 'tīklene' importēt numpy kā piem. # Izpētiet datu kopu batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Pirmsapstrādes funkciju ieviešana

Mēs normalizēsim datus, izmantojot Min-Max normalizāciju. Tādējādi visas x vērtības vienkārši svārstās no 0 līdz 1.
y = (x-min) / (max-min)

def normalizēt(x): '' ' arguments - x: ievades attēla dati numpy masīvā [32, 32, 3] atgriešanās - normalizēts x '' ' min_val = piem..min(x) max_val = piem..maks(x) x = (x-min_val) / (max_val-min_val) atgriešanās x

• Viena karstā kodēšana

def one_hot_encode(x): '' ' arguments - x: etiķešu saraksts atgriešanās - viena karstās kodēšanas matrica (etiķešu skaits, klases skaits) '' ' kodēts = piem..nulles((len(x), 10)) priekš idx, stundas iekšā uzskaitīt(x): kodēts[idx] [stundas] = viens atgriešanās kodēts

• Datu priekšapstrāde un saglabāšana

def _preprocess_and_save(normalizēt, one_hot_encode, Iespējas, etiķetes, faila nosaukums): Iespējas = normalizēt(Iespējas) etiķetes = one_hot_encode(etiķetes) marinēti gurķi.izgāzt((Iespējas, etiķetes), atvērts(faila nosaukums, 'wb')) def priekšapstrādes_un saglabāšanas_dati(cifar10_dataset_folder_path, normalizēt, one_hot_encode): n_partijas = 5 derīgas_funkcijas = [] derīgas iezīmes = [] priekš partija_i iekšā diapazons(viens, n_partijas + viens): Iespējas, etiķetes = load_cfar10_batch(cifar10_dataset_folder_path, partija_i) # atrast indeksu kā punktu kā validācijas datus visā partijas datu kopā (10%) index_of_validation = int(len(Iespējas) * 0.1) # pirmsapstrādāt 90% no visas partijas datu kopas # - normalizēt funkcijas # - one_hot_encode lables # - saglabāt jaunā failā ar nosaukumu “preprocess_batch_” + batch_number # - katrs fails katrai partijai _preprocess_and_save(normalizēt, one_hot_encode, Iespējas[:-index_of_validation], etiķetes[:-index_of_validation], 'preprocess_batch_' + lpp(partija_i) + '.p') # atšķirībā no apmācības datu kopas, validācijas datu kopa tiks pievienota caur visu sērijveida datu kopu # - ņem 10% no kopējās partijas datu kopas # - pievienojiet tos sarakstā # - derīgas_funkcijas # - derīgas iezīmes derīgas_funkcijas.pagarināt(Iespējas[-index_of_validation:]) derīgas iezīmes.pagarināt(etiķetes[-index_of_validation:]) # pirmsapstrādāt visu sakrauto validācijas datu kopu _preprocess_and_save(normalizēt, one_hot_encode, piem..masīvs(derīgas_funkcijas), piem..masīvs(derīgas iezīmes), 'preprocess_validation.p') # ielādējiet testa datu kopu ar atvērts(cifar10_dataset_folder_path + '/ test_batch', režīmā='rb') kā failu: partija = marinēti gurķi.slodze(failu, kodēšana='latin1') # pārstrādāt testēšanas datus test_features = partija['dati'].pārveidot((len(partija['dati']), 3, 32, 32)).transponēt(0, 2, 3, viens) test_labels = partija['etiķetes'] # Sagatavojiet un saglabājiet visus testēšanas datus _preprocess_and_save(normalizēt, one_hot_encode, piem..masīvs(test_features), piem..masīvs(test_labels), 'preprocess_training.p')

priekšapstrādes_un saglabāšanas_dati(cifar10_dataset_folder_path, normalizēt, one_hot_encode)

• Kontrolpunkts

importēt marinēti gurķi derīgas_funkcijas, derīgas iezīmes = marinēti gurķi.slodze(atvērts('preprocess_validation.p', režīmā='rb'))

• Tīkla veidošana

Viss modelis kopumā sastāv no 14 slāņiem.

importēt tensorflow kā tf def conv_net(x, saglabāt_problēmu): conv1_filter = tf.Mainīgs(tf.saīsināts_normāls(forma=[3, 3, 3, 64.], nozīmē=0, stddev=0,08)) conv2_filter = tf.Mainīgs(tf.saīsināts_normāls(forma=[3, 3, 64., 128.], nozīmē=0, stddev=0,08)) conv3_filter = tf.Mainīgs(tf.saīsināts_normāls(forma=[5, 5, 128., 256. lpp], nozīmē=0, stddev=0,08)) conv4_filter = tf.Mainīgs(tf.saīsināts_normāls(forma=[5, 5, 256. lpp, 512], nozīmē=0, stddev=0,08)) # 1, 2 1. konv = tf.nr.conv2d(x, conv1_filter, soļi=[viens,viens,viens,viens], polsterējums='SAME') 1. konv = tf.nr.relu(1. konv) conv1_pool = tf.nr.max_pool(1. konv, ksize=[viens,2,2,viens], soļi=[viens,2,2,viens], polsterējums='SAME') conv1_bn = tf.slāņi.partijas_normalizācija(conv1_pool) # 3. 4 conv2 = tf.nr.conv2d(conv1_bn, conv2_filter, soļi=[viens,viens,viens,viens], polsterējums='SAME') conv2 = tf.nr.relu(conv2) conv2_pool = tf.nr.max_pool(conv2, ksize=[viens,2,2,viens], soļi=[viens,2,2,viens], polsterējums='SAME') conv2_bn = tf.slāņi.partijas_normalizācija(conv2_pool) # 5, 6 conv3 = tf.nr.conv2d(conv2_bn, conv3_filter, soļi=[viens,viens,viens,viens], polsterējums='SAME') conv3 = tf.nr.relu(conv3) conv3_pool = tf.nr.max_pool(conv3, ksize=[viens,2,2,viens], soļi=[viens,2,2,viens], polsterējums='SAME') conv3_bn = tf.slāņi.partijas_normalizācija(conv3_pool) # 7, 8 conv4 = tf.nr.conv2d(conv3_bn, conv4_filter, soļi=[viens,viens,viens,viens], polsterējums='SAME') conv4 = tf.nr.relu(conv4) conv4_pool = tf.nr.max_pool(conv4, ksize=[viens,2,2,viens], soļi=[viens,2,2,viens], polsterējums='SAME') conv4_bn = tf.slāņi.partijas_normalizācija(conv4_pool) # 9 plakans = tf.ieguldījums.slāņi.saplacināt(conv4_bn) # 10 pilns1 = tf.ieguldījums.slāņi.pilnībā savienots(ieejas=plakans, num_outputs=128., activation_fn=tf.nr.relu) pilns1 = tf.nr.pamet(pilns1, saglabāt_problēmu) pilns1 = tf.slāņi.partijas_normalizācija(pilns1) # vienpadsmit pilna2 = tf.ieguldījums.slāņi.pilnībā savienots(ieejas=pilns1, num_outputs=256. lpp, activation_fn=tf.nr.relu) pilna2 = tf.nr.pamet(pilna2, saglabāt_problēmu) pilna2 = tf.slāņi.partijas_normalizācija(pilna2) # 12 pilns3 = tf.ieguldījums.slāņi.pilnībā savienots(ieejas=pilna2, num_outputs=512, activation_fn=tf.nr.relu) pilns3 = tf.nr.pamet(pilns3, saglabāt_problēmu) pilns3 = tf.slāņi.partijas_normalizācija(pilns3) # 13 pilna4 = tf.ieguldījums.slāņi.pilnībā savienots(ieejas=pilns3, num_outputs=1024, activation_fn=tf.nr.relu) pilna4 = tf.nr.pamet(pilna4, saglabāt_problēmu) pilna4 = tf.slāņi.partijas_normalizācija(pilna4) # 14 ārā = tf.ieguldījums.slāņi.pilnībā savienots(ieejas=pilns3, num_outputs=10, activation_fn=Nav) atgriešanās ārā

• Hiperparametri

laikmetiem = 10 partijas_izmērs = 128. saglabāt_probability = 0.7 mācību_noteikums = 0,001

logiti = conv_net(x, saglabāt_problēmu) modeli = tf.identitāte(logiti, nosaukums='logits') # Vārda logits Tensor, lai pēc treniņa to varētu ielādēt no diska # Zaudējums un optimizētājs izmaksas = tf.samazināt_nozīmē(tf.nr.softmax_cross_entropy_with_logits(logiti=logiti, etiķetes=Jā)) optimizētājs = tf.vilciens.AdamOptimizer(mācību_noteikums=mācību_noteikums).minimizēt(izmaksas) # Precizitāte pareizs_pred = tf.vienāds(tf.argmax(logiti, viens), tf.argmax(Jā, viens)) precizitāte = tf.samazināt_nozīmē(tf.cast(pareizs_pred, tf.pludiņš32), nosaukums='precizitāte')

• Apmāciet neironu tīklu

# Viena optimizācija 
def vilciena_neural_tīkls(sesija, optimizētājs, saglabāt_probability, iezīme_partija, label_batch): sesija.palaist(optimizētājs, feed_dict={ x: iezīme_partija, Jā: label_batch, saglabāt_problēmu: saglabāt_probability })

#Showing Stats def print_stats(sesija, iezīme_partija, label_batch, izmaksas, precizitāte): zaudējums = sēdēt.palaist(izmaksas, feed_dict={ x: iezīme_partija, Jā: label_batch, saglabāt_problēmu: viens. }) valid_acc = sēdēt.palaist(precizitāte, feed_dict={ x: derīgas_funkcijas, Jā: derīgas iezīmes, saglabāt_problēmu: viens. }) izdrukāt('Zaudējums:{:> 10,4f}Apstiprināšanas precizitāte:{: .6f}'.formātā(zaudējums, valid_acc))

• Pilnībā apmācīt un saglabāt modeli

def paketes_funkcijas_zīmes(Iespējas, etiķetes, partijas_izmērs): '' ' Sadaliet funkcijas un etiķetes partijās '' ' priekš sākt iekšā diapazons(0, len(Iespējas), partijas_izmērs): beigas = min(sākt + partijas_izmērs, len(Iespējas)) raža Iespējas[sākt:beigas], etiķetes[sākt:beigas] def load_preprocess_training_batch(batch_id, partijas_izmērs): '' ' Ielādējiet iepriekš apstrādātās apmācības datus un atgrieziet tos partijās, kas ir mazākas vai mazāk '' ' faila nosaukums = 'preprocess_batch_' + lpp(batch_id) + '.p' Iespējas, etiķetes = marinēti gurķi.slodze(atvērts(faila nosaukums, režīmā='rb')) # Atgrieziet apmācības datus lieluma vai mazākās partijās atgriešanās paketes_funkcijas_zīmes(Iespējas, etiķetes, partijas_izmērs)

# Modeļa un ceļa saglabāšana 
save_model_path = './image_classification' izdrukāt('Apmācība ...') ar tf.Sesija() kā sēdēt: # Mainīgo inicializēšana sēdēt.palaist(tf.global_variables_initializer()) # Treniņu cikls priekš laikmets iekšā diapazons(laikmetiem): # Pārliecinieties par visām partijām n_partijas = 5 priekš partija_i iekšā diapazons(viens, n_partijas + viens): priekš partijas_funkcijas, partijas_tietnes iekšā load_preprocess_training_batch(partija_i, partijas_izmērs): vilciena_neural_tīkls(sēdēt, optimizētājs, saglabāt_probability, partijas_funkcijas, partijas_tietnes) izdrukāt('Laikmets{:> 2}, CIFAR-10 sērija{}: '.formātā(laikmets + viens, partija_i), beigas=') print_stats(sēdēt, partijas_funkcijas, partijas_tietnes, izmaksas, precizitāte) # Saglabāt modeli taupītājs = tf.vilciens.Taupītājs() saglabāšanas_ceļš = taupītājs.saglabāt(sēdēt, save_model_path)

Tagad ir paveikta svarīgā Tensorflow attēlu klasifikācijas daļa. Ir pienācis laiks pārbaudīt modeli.

kā veikt datu bāzes testēšanu

• Modeļa pārbaude

importēt marinēti gurķi importēt numpy kā piem. importēt matplotlib.pyplot kā plt no sklearn.preprocessing importēt LabelBinarizer def paketes_funkcijas_zīmes(Iespējas, etiķetes, partijas_izmērs): '' ' Sadaliet funkcijas un etiķetes partijās '' ' priekš sākt iekšā diapazons(0, len(Iespējas), partijas_izmērs): beigas = min(sākt + partijas_izmērs, len(Iespējas)) raža Iespējas[sākt:beigas], etiķetes[sākt:beigas] def display_image_predictions(Iespējas, etiķetes, prognozes, top_n_prognozes): n_ klases = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.der(diapazons(n_ klases)) label_ids = label_binarizer.inverse_transform(piem..masīvs(etiķetes)) att, asis = plt.apakšlaukumi(nrows=top_n_prognozes, ncols=2, figsize=(divdesmit, 10)) att.tight_layout() att.suptitle('Softmax prognozes', fonta izmērs=divdesmit, Jā=1.1) n_prognozes = 3 starpība = 0,05 ind = piem..apbrīnojami(n_prognozes) platums = (viens. - 2. * starpība) / n_prognozes priekš attēls_i, (iezīme, label_id, pred_indicies, pred_values) iekšā uzskaitīt(zip(Iespējas, label_ids, prognozes.indeksi, prognozes.vērtības)): ja (attēls_i < top_n_prognozes): pred_names = [label_names[pred_i] priekš pred_i iekšā pred_indicies] pareizs_nosaukums = label_names[label_id] asis[attēls_i] [0].imshow((iezīme*255).astips(piem..int32, kopija=Nepatiesa)) asis[attēls_i] [0].set_title(pareizs_nosaukums) asis[attēls_i] [0].set_axis_off() asis[attēls_i] [viens].bārs(ind + starpība, pred_values[:3], platums) asis[attēls_i] [viens].set_yticks(ind + starpība) asis[attēls_i] [viens].set_yticklabels(pred_names[::-viens]) asis[attēls_i] [viens].set_xticks([0, 0.5, 1.0])

%matplotlib rindā %konfigurēt InlineBackend.attēls_formāts = 'tīklene' importēt tensorflow kā tf importēt marinēti gurķi importēt nejaušs save_model_path = './image_classification' partijas_izmērs = 64. n_paraugi = 10 top_n_prognozes = 5 def test_model(): test_features, test_labels = marinēti gurķi.slodze(atvērts('preprocess_training.p', režīmā='rb')) ielādēta_grāfs = tf.Grafiks() ar tf.Sesija(grafiks=ielādēta_grāfs) kā sēdēt: # Slodzes modelis iekrāvējs = tf.vilciens.import_meta_graph(save_model_path + '.meta') iekrāvējs.atjaunot(sēdēt, save_model_path) # Iegūstiet tenorus no ielādēta modeļa ielādēts_x = ielādēta_grāfs.get_tensor_by_name('input_x: 0') ielādēts_y = ielādēta_grāfs.get_tensor_by_name('output_y: 0') loading_keep_prob = ielādēta_grāfs.get_tensor_by_name('keep_prob: 0') ielādēti_logiti = ielādēta_grāfs.get_tensor_by_name('logits: 0') ielādēts_ak = ielādēta_grāfs.get_tensor_by_name('precizitāte: 0') # Iegūstiet precizitāti partijās par atmiņas ierobežojumiem test_batch_acc_total = 0 test_batch_count = 0 priekš train_feature_batch, vilciena_ etiķetes_partija iekšā paketes_funkcijas_zīmes(test_features, test_labels, partijas_izmērs): test_batch_acc_total + = sēdēt.palaist( ielādēts_ak, feed_dict={ielādēts_x: train_feature_batch, ielādēts_y: vilciena_ etiķetes_partija, loading_keep_prob: 1.0}) test_batch_count + = viens izdrukāt('Precizitātes pārbaude:{} '.formātā(test_batch_acc_total/test_batch_count)) # Drukāt izlases paraugus random_test_features, random_test_labels = dubultā(zip(*nejaušs.paraugs(sarakstā(zip(test_features, test_labels)), n_paraugi))) random_test_predictions = sēdēt.palaist( tf.nr.top_k(tf.nr.softmax(ielādēti_logiti), top_n_prognozes), feed_dict={ielādēts_x: random_test_features, ielādēts_y: random_test_labels, loading_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_prognozes) test_model()

Izeja: Pārbaudes precizitāte: 0.5882762738853503

Tagad, apmācot neironu tīklu vairāk laikmetu vai mainot aktivizācijas funkciju, jūs varētu iegūt citu rezultātu, kuram varētu būt lielāka precizitāte.

Tātad, līdz ar to mēs esam nonākuši pie šī TensorFlow attēlu klasifikācijas raksta beigām. Es esmu pārliecināts, ka tagad jūs varat to pašu izmantot jebkura veida attēlu klasificēšanai, un jūs neesat iesācējs attēlu klasifikācijā.

Edureka Ar Python sertifikāciju apmācību organizē nozares profesionāļi atbilstoši nozares prasībām un prasībām. Jūs apgūsiet tādus jēdzienus kā funkcija SoftMax, neironu tīkli Autoencoder, ierobežotā Boltzmann mašīna (RBM), Keras un TFLearn. Kursu ir īpaši kurējuši nozares eksperti ar reāllaika gadījumu izpēti.