Kuvaluokittelu tehtävä, jonka jopa vauva voi suorittaa sekunneissa, mutta koneelle se on ollut vaikea tehtävä viimeisimpiin ja Syvä oppiminen . Itse ajavat autot voivat havaita esineitä ja toteuttaa tarvittavat toimet reaaliajassa, ja suurin osa tästä on mahdollista Kuvien luokittelu. Tässä artikkelissa opastan sinua seuraavista aiheista:
Mikä on TensorFlow?
TensorFlow on Googlen avoimen lähdekoodin koneoppimisen kehys tiedonkulun ohjelmointiin useille tehtäville. Kaavion solmut edustavat matemaattisia operaatioita, kun taas kaavion reunat edustavat niiden välisiä moniulotteisia tietojoukkoja.
Tensorit ovat vain moniulotteisia matriiseja, 2-ulotteisten taulukoiden laajennus dataan, jolla on suurempi ulottuvuus. Tensorflow-palvelussa on monia ominaisuuksia, jotka tekevät siitä sopivan syvälle oppimiselle, ja se on avoimen lähdekoodin kirjasto, joka auttaa sinua kehittämään ja kouluttamaan ML-malleja.
Mikä on kuvaluokitus?
Kuvaluokituksen tarkoituksena on luokitella kaikki digitaalisen kuvan pikselit yhdeksi useista maanpeite luokat tai teemoja . Tätä luokiteltuja tietoja voidaan sitten käyttää tuottamiseen aihekartat kuvassa olevasta maanpeitteestä.
Nyt riippuen analyytikon ja tietokoneen välisestä vuorovaikutuksesta luokituksen aikana, luokitusta on kahdenlaisia:
- Valvottu ja
- Valvomaton
Joten, tuhlaamatta aikaa, siirrymme TensorFlow-kuvaluokitukseen. Minulla on 2 esimerkkiä: helppo ja vaikea. Jatketaan helpompaa.
TensorFlow-kuvaluokitus: Muoti MNIST
Muoti MNIST-tietojoukko
Tässä käytetään Fashion MNIST -tietojoukkoa, joka sisältää 70 000 harmaasävykuvaa 10 kategoriassa. Käytämme 60000 koulutukseen ja loput 10000 testaamiseen. Pääset Fashion MNIST -palveluun suoraan TensorFlow-palvelusta, vain tuo ja lataa tiedot.
- Tuo ensin kirjastot
mistä __future__ tuonti absoluuttinen_jako, jako, tulostusfunktio # TensorFlow ja tf.keras tuovat tensorflow: n tf: stä tensorflow-tuontikeraista # Apukirjastot tuovat numpy: np tuonti matplotlib.pyplot plt: ksi
- Ladataan tiedot
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = muoti_mnist.load_data ()
- Seuraavaksi aiomme kartoittaa kuvat luokkiin
class_names = ['T-paita / toppi', 'Housut', 'Pullover', 'Mekko', 'Takki', 'Sandaali', 'Paita', 'Sneaker', 'Laukku', 'Nilkkurit']
- Tietojen tutkiminen
juna_kuvia.muoto
#Jokainen tunniste on välillä 0–9
juna_tunnisteet
test_images.muoto
- Nyt on aika esikäsitellä tiedot.
plt.kuva() plt.näytä(juna_kuvia[0]) plt.väripalkki() plt.ruudukko(Väärä) plt.näytä()
#Jos tarkastat harjoitusjoukon ensimmäisen kuvan, huomaat, että pikseliarvot putoavat välillä 0-255.
- Meidän on skaalattava kuvat 0-1: stä syöttämään ne hermoverkkoon
juna_kuvia = juna_kuvia / 255,0 test_images = test_images / 255,0
- Näytetään joitain kuvia.
plt.kuva(figsize=(10,10)) varten i sisään alue(25): plt.sivujuoni(5,5,i+yksi) plt.xticks([]) plt.yticks([]) plt.ruudukko(Väärä) plt.näytä(juna_kuvia[i], cmap=plt.cm.binääri) plt.xlabel(luokan_nimet[juna_tunnisteet[i]]) plt.näytä()
- Määritä tasot
malli- = kovaa.Peräkkäinen([ kovaa.kerroksia.Litistä(input_shape=(28, 28)), kovaa.kerroksia.Tiheä(128, aktivointi=tf.Nro.relu), kovaa.kerroksia.Tiheä(10, aktivointi=tf.Nro.softmax) ])
- Kokoa malli
malli-.koota(optimoija='adam', menetys='harva_kategorinen_ristikopio', mittarit=['tarkkuus'])
- Mallikoulutus
malli-.sovi(juna_kuvia, juna_tunnisteet, aikakausia=10)
- Tarkkuuden arviointi
test_loss, test_acc = malli-.arvioida(test_images, test_labels) Tulosta('Testitarkkuus:', test_acc)
- Ennusteiden tekeminen
ennusteita = malli-.ennustaa(test_images)
ennusteita[0]
mitkä ovat rajoituksia sql: ssä
Ennuste on 10 numeron taulukko. Nämä kuvaavat mallin 'luottamusta' siihen, että kuva vastaa kutakin 10 erilaista vaatetuotetta. Voimme nähdä, millä etiketillä on korkein luotettavuusarvo.
esim..argmax(ennusteita[0])#Model on varma siitä, että se on nilkkurit. Katsotaanpa, onko se oikeinLähtö: 9
test_labels[0]
Lähtö: 9
- Nyt on aika tarkastella kaikkia 10 kanavan sarjaa
def plot_image(i, ennusteet_haarukka, true_label, img): ennusteet_haarukka, true_label, img = ennusteet_haarukka[i], true_label[i], img[i] plt.ruudukko(Väärä) plt.xticks([]) plt.yticks([]) plt.näytä(img, cmap=plt.cm.binääri) ennustettu_tunniste = esim..argmax(ennusteet_haarukka) jos ennustettu_tunniste == true_label: väri = 'vihreä' muu: väri = 'netto' plt.xlabel('{} {: 2.0f}% ({}) ''.muoto(luokan_nimet[ennustettu_tunniste], 100*esim..enint(ennusteet_haarukka), luokan_nimet[true_label]), väri=väri) def plot_value_array(i, ennusteet_haarukka, true_label): ennusteet_haarukka, true_label = ennusteet_haarukka[i], true_label[i] plt.ruudukko(Väärä) plt.xticks([]) plt.yticks([]) tämä juoni = plt.baari(alue(10), ennusteet_haarukka, väri='# 777777') plt.ylim([0, yksi]) ennustettu_tunniste = esim..argmax(ennusteet_haarukka) tämä juoni[ennustettu_tunniste].set_color('netto') tämä juoni[true_label].set_color('vihreä')
- Tarkastellaan ensin 0. ja 10. kuvaa
i = 0 plt.kuva(figsize=(6,3)) plt.sivujuoni(yksi,2,yksi) plot_image(i, ennusteita, test_labels, test_images) plt.sivujuoni(yksi,2,2) plot_value_array(i, ennusteita, test_labels) plt.näytä()
i = 10 plt.kuva(figsize=(6,3)) plt.sivujuoni(yksi,2,yksi) plot_image(i, ennusteita, test_labels, test_images) plt.sivujuoni(yksi,2,2) plot_value_array(i, ennusteita, test_labels) plt.näytä()
- Piirretään nyt useita kuvia ja niiden ennusteita. Oikeat ovat vihreitä, kun taas väärät ovat punaisia.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.kuva(figsize=(2*2*num_cols, 2*num_rows)) varten i sisään alue(num_images): plt.sivujuoni(num_rows, 2*num_cols, 2*i+yksi) plot_image(i, ennusteita, test_labels, test_images) plt.sivujuoni(num_rows, 2*num_cols, 2*i+2) plot_value_array(i, ennusteita, test_labels) plt.näytä()
- Lopuksi käytämme koulutettua mallia ennustamaan yksittäistä kuvaa.
# Tartu kuva testitiedostosta img = test_images[0] Tulosta(img.muoto)
# Lisää kuva erään, jossa se on ainoa jäsen. img = (esim..expand_dims(img,0)) Tulosta(img.muoto)
ennusteet_yhden = malli-.ennustaa(img) Tulosta(ennusteet_yhden)plot_value_array(0, ennusteet_yhden, test_labels) plt.xticks(alue(10), luokan_nimet, kierto=Neljä viisi) plt.näytä()
ennustus_tulos = esim..argmax(ennusteet_yhden[0])
Lähtö: 9
CIFAR-10: CNN
CIFAR-10-tietojoukko koostuu lentokoneista, koirista, kissoista ja muista esineistä. Esikäsittele kuvat ja kouluta sitten konvoluutiohermoverkko kaikille näytteille. Kuvat on normalisoitava ja tarrat on koodattava yksisuuntaisesti. Tämä käyttötapaus varmasti poistaa epäilyt TensorFlow-kuvaluokituksesta.
- Tietojen lataaminen
alkaen urllib.request tuonti urlretrieve alkaen os. polku tuonti isfile, on nokea alkaen tqdm tuonti tqdm tuonti tarfile cifar10_dataset_folder_path = 'cifar-10-erät-py' luokassa Lataa edistyminen(tqdm): last_block = 0 def koukku(itse, block_num=yksi, block_size=yksi, total_size=Ei mitään): itse.kaikki yhteensä = total_size itse.päivittää((block_num - itse.last_block) * block_size) itse.last_block = block_num '' Tarkista, onko data (zip) tiedosto jo ladattu jos ei, lataa se osoitteesta https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz ja tallenna nimellä cifar-10-python.tar.gz '' jos ei isfile('cifar-10-python.tar.gz'): kanssa Lataa edistyminen(yksikkö='B', unit_scale=Totta, miniters=yksi, kuva='CIFAR-10-tietojoukko') kuten pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.koukku) jos ei on nokea(cifar10_dataset_folder_path): kanssa tarfile.avata('cifar-10-python.tar.gz') kuten terva: terva.Pura kaikki() terva.kiinni()
- Tarvittavien kirjastojen tuominen
tuonti suolakurkku tuonti numpy kuten esim. tuonti matplotlib.pyplot kuten plt
- Tietojen ymmärtäminen
Alkuperäinen dataerä on 10000 × 3072 tensori ilmaistuna numpy-taulukossa, jossa 10000 on näytetietojen määrä. Kuva on värillinen ja kooltaan 32 × 32. Syöttö voidaan tehdä joko muodossa (leveys x korkeus x num_kanava) tai (num_kanava x leveys x korkeus). Määritellään tunnisteet.
def lataa_etiketin_nimet(): palata ['lentokone', 'auto', 'lintu', 'kissa', 'Peura', 'koira', 'sammakko', 'hevonen', 'laiva', 'kuorma']
- Tietojen muokkaaminen
Aiomme muuttaa tietoja kahdessa vaiheessa
Jaa ensin rivivektori (3072) 3 osaan. Jokainen kappale vastaa kutakin kanavaa. Tämä johtaa tensorin (3 x 1024) ulottuvuuteen. Jaa sitten tuloksena oleva tensori edellisestä vaiheesta luvulla 32. 32 tarkoittaa tässä kuvan leveyttä. Tuloksena on (3x32x32).
Toiseksi meidän on siirrettävä tiedot kohteesta (num_kanava, leveys, korkeus) kohtaan (leveys, korkeus, num_kanava). Tätä varten aiomme käyttää transponointitoimintoa.
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): kanssa avata(cifar10_dataset_folder_path + '/ data_batch_' + s(batch_id), -tilassa='rb') kuten tiedosto: # Huomaa, että koodaustyyppi on 'latin1' erä = suolakurkku.ladata(tiedosto, koodaus='latin1') ominaisuudet = erä['data'].muotoilla uudelleen((len(erä['data']), 3, 32, 32)).osaksi kansallista lainsäädäntöä(0, 2, 3, yksi) tarrat = erä['tarrat'] palata ominaisuudet, etiketti
- Tietojen tutkiminen
def display_stats(cifar10_dataset_folder_path, batch_id, näyte_id): ominaisuudet, tarrat = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) jos ei (0 <= näyte_id < len(ominaisuudet)): Tulosta('{}näytteet erässä{}.{}on kantaman ulkopuolella. '.muoto(len(ominaisuudet), batch_id, näyte_id)) palata Ei mitään Tulosta(' Erätilastot #{}: '.muoto(batch_id)) Tulosta('Näytteiden lukumäärä:{} '.muoto(len(ominaisuudet))) label_names = lataa_etiketin_nimet() label_counts = sanella(postinumero(*esim..ainutlaatuinen(tarrat, return_counts=Totta))) varten avain, arvo sisään label_counts.kohteita(): Tulosta('Etiketit [{}] ({}):{}'.muoto(avain, label_names[avain].ylempi(), arvo)) näyte_kuva = ominaisuudet[näyte_id] sample_label = tarrat[näyte_id] Tulosta(' Esimerkki kuvasta{}: '.muoto(näyte_id)) Tulosta('Kuva - Minimi arvo:{}Suurin arvo:{}'.muoto(näyte_kuva.min(), näyte_kuva.enint())) Tulosta('Kuva - muoto:{}'.muoto(näyte_kuva.muoto)) Tulosta('Label - Label Id:{}Nimi:{}'.muoto(sample_label, label_names[sample_label])) plt.näytä(näyte_kuva)
%matplotlib linjassa %kokoonpano InlineBackend.kuva_muoto = 'verkkokalvo' tuonti numpy kuten esim. # Tutki tietoaineistoa batch_id = 3 näyte_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, näyte_id)
- Esikäsittelytoimintojen toteuttaminen
Aiomme normalisoida tiedot Min-Max-normalisoinnin avulla. Tämä yksinkertaisesti saa kaikki x-arvot vaihtelemaan välillä 0 ja 1.
y = (x-min) / (max-min)
def normalisoitua(x): '' Perustelu - x: syötä kuvadata numpy-taulukossa [32, 32, 3] palata - normalisoitu x '' min_val = esim..min(x) max_val = esim..enint(x) x = (x-min_val) / (max_val-min_val) palata x
- Yksi kuuma koodaus
def one_hot_encode(x): '' Perustelu - x: luettelo tarroista palata - yksi kuumakoodausmatriisi (tarrojen lukumäärä, luokan numero) '' koodattu = esim..nollat((len(x), 10)) varten idx, tuntia sisään luetella(x): koodattu[idx] [tuntia] = yksi palata koodattu
- Esikäsittele ja tallenna tiedot
def _preprocess_and_save(normalisoitua, one_hot_encode, ominaisuudet, tarrat, Tiedoston nimi): ominaisuudet = normalisoitua(ominaisuudet) tarrat = one_hot_encode(tarrat) suolakurkku.kaataa((ominaisuudet, tarrat), avata(Tiedoston nimi, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalisoitua, one_hot_encode): n_erät = 5 kelvolliset_ominaisuudet = [] valid_labels = [] varten erä_i sisään alue(yksi, n_erät + yksi): ominaisuudet, tarrat = load_cfar10_batch(cifar10_dataset_folder_path, erä_i) # etsi hakemisto pisteeksi validointitiedoina koko erän tietojoukossa (10%) index_of_validation = int(len(ominaisuudet) * 0,1) # esikäsittele 90% koko erän tietojoukosta # - normalisoi ominaisuudet # - one_hot_encode lables # - tallenna uuteen tiedostoon nimeltä 'preprocess_batch_' + eränumero # - kukin tiedosto jokaiselle erälle _preprocess_and_save(normalisoitua, one_hot_encode, ominaisuudet[:-index_of_validation], tarrat[:-index_of_validation], 'preprocess_batch_' + s(erä_i) + '.p') # toisin kuin koulutustietojoukko, validointitiedosto lisätään kaikkien eräajojen kautta # - ota 10% erän kokonaismäärästä # - lisää ne luetteloon # - valid_features # - kelvolliset tunnisteet kelvolliset_ominaisuudet.pidentää(ominaisuudet[-index_of_validation:]) valid_labels.pidentää(tarrat[-index_of_validation:]) # esikäsittele kaikki pinotut validointitiedot _preprocess_and_save(normalisoitua, one_hot_encode, esim..taulukko(kelvolliset_ominaisuudet), esim..taulukko(valid_labels), 'preprocess_validation.p') # lataa testitietojoukko kanssa avata(cifar10_dataset_folder_path + '/ test_batch', -tilassa='rb') kuten tiedosto: erä = suolakurkku.ladata(tiedosto, koodaus='latin1') # esikäsittele testaustiedot test_ominaisuudet = erä['data'].muotoilla uudelleen((len(erä['data']), 3, 32, 32)).osaksi kansallista lainsäädäntöä(0, 2, 3, yksi) test_labels = erä['tarrat'] # Esikäsittele ja tallenna kaikki testaustiedot _preprocess_and_save(normalisoitua, one_hot_encode, esim..taulukko(test_ominaisuudet), esim..taulukko(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalisoitua, one_hot_encode)
- Tarkastuspiste
tuonti suolakurkku kelvolliset_ominaisuudet, valid_labels = suolakurkku.ladata(avata('preprocess_validation.p', -tilassa='rb'))
- Verkoston rakentaminen
Koko malli koostuu yhteensä 14 kerroksesta.
tuonti tensorflow kuten tf def conv_net(x, keep_prob): conv1_filter = tf.Vaihteleva(tf.katkaistu_normaali(muoto=[3, 3, 3, 64], tarkoittaa=0, keskihajonta=0,08)) conv2_filter = tf.Vaihteleva(tf.katkaistu_normaali(muoto=[3, 3, 64, 128], tarkoittaa=0, keskihajonta=0,08)) conv3_filter = tf.Vaihteleva(tf.katkaistu_normaali(muoto=[5, 5, 128, 256], tarkoittaa=0, keskihajonta=0,08)) conv4_filter = tf.Vaihteleva(tf.katkaistu_normaali(muoto=[5, 5, 256, 512], tarkoittaa=0, keskihajonta=0,08)) # 1, 2 conv1 = tf.Nro.conv2d(x, conv1_filter, harppauksia=[yksi,yksi,yksi,yksi], pehmuste='SAMA') conv1 = tf.Nro.relu(conv1) conv1_pool = tf.Nro.max_pool(conv1, ksize=[yksi,2,2,yksi], harppauksia=[yksi,2,2,yksi], pehmuste='SAMA') conv1_bn = tf.kerroksia.erän_normalisointi(conv1_pool) # 3. 4 conv2 = tf.Nro.conv2d(conv1_bn, conv2_filter, harppauksia=[yksi,yksi,yksi,yksi], pehmuste='SAMA') conv2 = tf.Nro.relu(conv2) conv2_pool = tf.Nro.max_pool(conv2, ksize=[yksi,2,2,yksi], harppauksia=[yksi,2,2,yksi], pehmuste='SAMA') conv2_bn = tf.kerroksia.erän_normalisointi(conv2_pool) # 5, 6 conv3 = tf.Nro.conv2d(conv2_bn, conv3_filter, harppauksia=[yksi,yksi,yksi,yksi], pehmuste='SAMA') conv3 = tf.Nro.relu(conv3) conv3_pool = tf.Nro.max_pool(conv3, ksize=[yksi,2,2,yksi], harppauksia=[yksi,2,2,yksi], pehmuste='SAMA') conv3_bn = tf.kerroksia.erän_normalisointi(conv3_pool) # 7, 8 conv4 = tf.Nro.conv2d(conv3_bn, conv4_filter, harppauksia=[yksi,yksi,yksi,yksi], pehmuste='SAMA') conv4 = tf.Nro.relu(conv4) conv4_pool = tf.Nro.max_pool(conv4, ksize=[yksi,2,2,yksi], harppauksia=[yksi,2,2,yksi], pehmuste='SAMA') conv4_bn = tf.kerroksia.erän_normalisointi(conv4_pool) # 9 tasainen = tf.avustaja.kerroksia.tasoittaa(conv4_bn) # 10 1 = tf.avustaja.kerroksia.täysin kytketty(tulot=tasainen, num_lähdöt=128, activation_fn=tf.Nro.relu) 1 = tf.Nro.lopettaa(1, keep_prob) 1 = tf.kerroksia.erän_normalisointi(1) # yksitoista täysi 2 = tf.avustaja.kerroksia.täysin kytketty(tulot=1, num_lähdöt=256, activation_fn=tf.Nro.relu) täysi 2 = tf.Nro.lopettaa(täysi 2, keep_prob) täysi 2 = tf.kerroksia.erän_normalisointi(täysi 2) # 12 täysi 3 = tf.avustaja.kerroksia.täysin kytketty(tulot=täysi 2, num_lähdöt=512, activation_fn=tf.Nro.relu) täysi 3 = tf.Nro.lopettaa(täysi 3, keep_prob) täysi 3 = tf.kerroksia.erän_normalisointi(täysi 3) # 13 4 = tf.avustaja.kerroksia.täysin kytketty(tulot=täysi 3, num_lähdöt=1024, activation_fn=tf.Nro.relu) 4 = tf.Nro.lopettaa(4, keep_prob) 4 = tf.kerroksia.erän_normalisointi(4) # 14 ulos = tf.avustaja.kerroksia.täysin kytketty(tulot=täysi 3, num_lähdöt=10, activation_fn=Ei mitään) palata ulos
- Hyperparametrit
aikakausia = 10 erä_koko = 128 pidä todennäköisyys = 0.7 oppimisnopeus = 0,001
logit = conv_net(x, keep_prob) malli- = tf.henkilöllisyys(logit, nimi='logit') # Nimi logit Tensor, jotta se voidaan ladata levyltä harjoituksen jälkeen # Tappio ja optimoija kustannus = tf.vähennä(tf.Nro.softmax_cross_entropy_with_logits(logit=logit, tarrat=Y)) optimoija = tf.kouluttaa.AdamOptimizer(oppimisnopeus=oppimisnopeus).minimoida(kustannus) # Tarkkuus correct_pred = tf.yhtä suuri(tf.argmax(logit, yksi), tf.argmax(Y, yksi)) tarkkuus = tf.vähennä(tf.heittää(correct_pred, tf.kellua32), nimi='tarkkuus')
- Harjoittele hermoverkkoa
#Yksi optimointi
def juna_hermoverkko(istunto, optimoija, pidä todennäköisyys, ominaisuus_erä, label_batch): istunto.juosta(optimoija, feed_dict={ x: ominaisuus_erä, Y: label_batch, keep_prob: pidä todennäköisyys })
#Showing Stats def print_stats(istunto, ominaisuus_erä, label_batch, kustannus, tarkkuus): menetys = sess.juosta(kustannus, feed_dict={ x: ominaisuus_erä, Y: label_batch, keep_prob: yksi. }) valid_acc = sess.juosta(tarkkuus, feed_dict={ x: kelvolliset_ominaisuudet, Y: valid_labels, keep_prob: yksi. }) Tulosta('Menetys:{:> 10.4f}Vahvistuksen tarkkuus:{: .6f}'.muoto(menetys, valid_acc))
- Täysi koulutus ja mallin tallentaminen
def erän_ominaisuudet_etiketit(ominaisuudet, tarrat, erä_koko): '' Jaa ominaisuudet ja tarrat eriin '' varten alkaa sisään alue(0, len(ominaisuudet), erä_koko): loppuun = min(alkaa + erä_koko, len(ominaisuudet)) saanto ominaisuudet[alkaa:loppuun], tarrat[alkaa:loppuun] def load_preprocess_training_batch(batch_id, erä_koko): '' Lataa esikäsitelty harjoittelutiedot ja palauta ne erissä tai vähemmän '' Tiedoston nimi = 'preprocess_batch_' + s(batch_id) + '.p' ominaisuudet, tarrat = suolakurkku.ladata(avata(Tiedoston nimi, -tilassa='rb')) # Palauta harjoitustiedot erissä, joiden koko on tai vähemmän palata erän_ominaisuudet_etiketit(ominaisuudet, tarrat, erä_koko)
#Tallennusmalli ja polku
save_model_path = './kuva_luokitus' Tulosta('Koulutus ...') kanssa tf.Istunto() kuten sess: # Muuttujien alustaminen sess.juosta(tf.global_variables_initializer()) # Harjoittelujakso varten aikakausi sisään alue(aikakausia): # Kierrä kaikki erät n_erät = 5 varten erä_i sisään alue(yksi, n_erät + yksi): varten eräominaisuudet, erän_etiketit sisään load_preprocess_training_batch(erä_i, erä_koko): juna_hermoverkko(sess, optimoija, pidä todennäköisyys, eräominaisuudet, erän_etiketit) Tulosta('Epoch{:> 2}, CIFAR-10-erä{}: '.muoto(aikakausi + yksi, erä_i), loppuun='') print_stats(sess, eräominaisuudet, erän_etiketit, kustannus, tarkkuus) # Tallenna malli säästäjä = tf.kouluttaa.Säästäjä() tallenna_polku = säästäjä.Tallentaa(sess, save_model_path)
Tensorflow-kuvaluokituksen tärkeä osa on nyt tehty. Nyt on aika testata mallia.
- Mallin testaaminen
tuonti suolakurkku tuonti numpy kuten esim. tuonti matplotlib.pyplot kuten plt alkaen sklearn.preprocinging tuonti LabelBinarizer def erän_ominaisuudet_etiketit(ominaisuudet, tarrat, erä_koko): '' Jaa ominaisuudet ja tarrat eriin '' varten alkaa sisään alue(0, len(ominaisuudet), erä_koko): loppuun = min(alkaa + erä_koko, len(ominaisuudet)) saanto ominaisuudet[alkaa:loppuun], tarrat[alkaa:loppuun] def display_image_predictions(ominaisuudet, tarrat, ennusteita, top_n_ennusteet): n_luokkia = 10 label_names = lataa_etiketin_nimet() label_binarizer = LabelBinarizer() label_binarizer.sovi(alue(n_luokkia)) label_ids = label_binarizer.käänteinen_muunnos(esim..taulukko(tarrat)) kuva, akselit = plt.osa-alueet(nrows=top_n_ennusteet, ncols=2, figsize=(kaksikymmentä, 10)) kuva.tiukka_asettelu() kuva.suptitle('Softmax-ennusteet', Fonttikoko=kaksikymmentä, Y=1.1) n_ennusteet = 3 marginaali = 0,05 ind = esim..outo(n_ennusteet) leveys = (yksi. - 2. * marginaali) / n_ennusteet varten kuva_i, (ominaisuus, label_id, ennakkotiedot, pred_values) sisään luetella(postinumero(ominaisuudet, label_ids, ennusteita.indeksit, ennusteita.arvot)): jos (kuva_i < top_n_ennusteet): etunimet = [label_names[pred_i] varten pred_i sisään ennakkotiedot] oikea_nimi = label_names[label_id] akselit[kuva_i] [0].näytä((ominaisuus*255).tyyppinen(esim..int32, kopio=Väärä)) akselit[kuva_i] [0].set_title(oikea_nimi) akselit[kuva_i] [0].set_axis_off() akselit[kuva_i] [yksi].barh(ind + marginaali, pred_values[:3], leveys) akselit[kuva_i] [yksi].set_yticks(ind + marginaali) akselit[kuva_i] [yksi].set_yticklabels(etunimet[::-yksi]) akselit[kuva_i] [yksi].set_xticks([0, 0.5, 1.0])
%matplotlib linjassa %kokoonpano InlineBackend.kuva_muoto = 'verkkokalvo' tuonti tensorflow kuten tf tuonti suolakurkku tuonti satunnainen save_model_path = './kuva_luokitus' erä_koko = 64 n_näytteet = 10 top_n_ennusteet = 5 def test_model(): test_ominaisuudet, test_labels = suolakurkku.ladata(avata('preprocess_training.p', -tilassa='rb')) ladattu_graafi = tf.Kaavio() kanssa tf.Istunto(kaavio=ladattu_graafi) kuten sess: # Lataa malli kuormaaja = tf.kouluttaa.import_meta_graph(save_model_path + '.meta') kuormaaja.palauttaa(sess, save_model_path) # Hanki tensorit ladatusta mallista ladattu_x = ladattu_graafi.get_tensor_by_name('input_x: 0') ladattu_y = ladattu_graafi.get_tensor_by_name('output_y: 0') loaded_keep_prob = ladattu_graafi.get_tensor_by_name('keep_prob: 0') ladattu_logit = ladattu_graafi.get_tensor_by_name('logits: 0') ladattu_acc = ladattu_graafi.get_tensor_by_name('tarkkuus: 0') # Hanki erien tarkkuus muistirajoituksia varten test_batch_acc_total = 0 test_batch_count = 0 varten juna_ominaisuus_erä, train_label_batch sisään erän_ominaisuudet_etiketit(test_ominaisuudet, test_labels, erä_koko): test_batch_acc_total + = sess.juosta( ladattu_acc, feed_dict={ladattu_x: juna_ominaisuus_erä, ladattu_y: train_label_batch, loaded_keep_prob: 1.0}) test_batch_count + = yksi Tulosta('Tarkkuuden testaaminen:{} '.muoto(test_batch_acc_total/test_batch_count)) # Tulosta satunnaisia näytteitä random_test_features, random_test_labels = kaksinkertainen(postinumero(*satunnainen.näyte(lista(postinumero(test_ominaisuudet, test_labels)), n_näytteet))) satunnainen_testiennusteet = sess.juosta( tf.Nro.top_k(tf.Nro.softmax(ladattu_logit), top_n_ennusteet), feed_dict={ladattu_x: random_test_features, ladattu_y: random_test_labels, loaded_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, satunnainen_testiennusteet, top_n_ennusteet) test_model()
Tuotos: Tarkkuuden testaus: 0.5882762738853503
Jos nyt koulutat hermoverkkoasi uusiin aikakausiin tai muutat aktivointitoimintoa, saatat saada toisen tuloksen, jolla voi olla parempi tarkkuus.
Joten tällä olemme päässeet tämän TensorFlow Image Classification -artikkelin loppuun. Olen varma, että voit nyt käyttää samaa luokittelemaan kaikenlaisia kuvia, etkä ole aloittelija kuvaluokituksessa.
Edurekan Python-sertifioinnin avulla alan ammattilaiset ovat kuratoineet alan vaatimukset ja vaatimukset. Opit käsitteet, kuten SoftMax-toiminto, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. Kurssin ovat erikoistuneet alan asiantuntijat reaaliaikaisilla tapaustutkimuksilla.