Képosztályozás olyan feladat, amelyet még egy csecsemő is képes másodpercek alatt elvégezni, de egy gép számára ez nehéz feladat volt a és Mély tanulás . Az önvezető autók valós időben képesek észlelni a tárgyakat és megtenni a szükséges intézkedéseket, és ennek nagy része lehetséges Képosztályozás. Ebben a cikkben a következő témaköröket ismertetem:
Mi az a TensorFlow?
TensorFlow a Google nyílt forráskódú gépi tanulási keretrendszere az adatfolyamok programozásához számos feladaton keresztül. A grafikon csomópontjai matematikai műveleteket, míg a grafikon élei a köztük kommunikált többdimenziós adattömböket képviselik.
A tenzorok csak többdimenziós tömbök, a 2-dimenziós táblák kiterjesztése a magasabb dimenziós adatokra. A Tensorflow számos olyan funkcióval rendelkezik, amelyek alkalmassá teszik a mély tanulásra, és ez a központi nyílt forráskódú könyvtár segít az ML modellek fejlesztésében és képzésében.
Mi a képosztályozás?
A Képosztályozás célja, hogy a digitális kép összes pixelét a több kategóriába sorolja talajtakaró osztályok vagy témák . Ezeket a kategorizált adatokat felhasználhatja az előállításhoz tematikus térképek képen megjelenő talajtakaró.
Most az elemző és a számítógép osztályozás közbeni kölcsönhatásától függően kétféle osztályozás létezik:
- Felügyelt és
- Felügyelet nélkül
Tehát időveszteség nélkül ugorjunk át a TensorFlow képosztályozásra. 2 példám van: könnyű és nehéz. Folytassuk a könnyebbel.
TensorFlow képosztályozás: Divat MNIST
Divat MNIST adatkészlet
Itt a Fashion MNIST adatkészletet fogjuk használni, amely 70 000 szürkeárnyalatos képet tartalmaz 10 kategóriában. A 60000-at edzésre, a többit 10000-ot tesztelési célokra fogjuk felhasználni. A Fashion MNIST-hez közvetlenül hozzáférhet a TensorFlow alkalmazásból, csak importálja és töltse be az adatokat.
- Először importáljuk a könyvtárakat
from __future__ import absolut_import, osztás, print_function # TensorFlow és tf.keras importálja a tensorflow-t tf-ként a tensorflow import kerákból # Segítő könyvtárak importálják a számot np import matplotlib.pyplot plt-ként
- Töltsük be az adatokat
divat_mnist = keras.datasets.fashion_mnist (vonat_képek, vonat_címkék), (teszt_képek, teszt_címkék) = fashion_mnist.load_data ()
- Ezután osztályokba osztjuk a képeket
class_names = ['póló / felső', 'nadrág', 'pulóver', 'ruha', 'kabát', 'szandál', 'ing', 'tornacipő', 'táska', 'bokacsizma']
- Az adatok feltárása
vonat_képek.alak
#Minden címke 0-9 között van
vonat_címkék
teszt_képek.alak
- Itt az ideje az adatok előzetes feldolgozásának.
plt.ábra() plt.imshow(vonat_képek[0]) plt.színsáv() plt.rács(Hamis) plt.előadás()
#Ha megvizsgálja az edzéskészlet első képét, látni fogja, hogy a pixelértékek 0 és 255 közé esnek.
- 0-1-re kell méreteznünk a képeket, hogy betáplálhassuk azokat a Neural Network-be
vonat_képek = vonat_képek / 255.0 teszt_képek = teszt_képek / 255,0
- Nézzünk meg néhány képet.
plt.ábra(figsize=(10.,10.)) mert én ban ben hatótávolság(25): plt.mellékcselekmény(5.,5.,én+egy) plt.xticks([]) plt.yticks([]) plt.rács(Hamis) plt.imshow(vonat_képek[én], cmap=plt.cm.bináris) plt.xlabel(osztály_nevek[vonat_címkék[én]]) plt.előadás()
- Állítsa be a rétegeket
modell = kemény.Egymás utáni([ kemény.rétegek.Lelapul(input_shape=(28., 28.)), kemény.rétegek.Sűrű(128, aktiválás=tf.sz.relu), kemény.rétegek.Sűrű(10., aktiválás=tf.sz.softmax) ])
- Állítsa össze a modellt
modell.összeállítani(optimalizáló='Ádám', veszteség='sparse_categorical_crossentropy', metrikák=['pontosság'])
- Modellképzés
modell.elfér(vonat_képek, vonat_címkék, korszakok=10.)
- A pontosság értékelése
teszt_veszteség, teszt_acc = modell.értékelni(teszt_képek, teszt_címkék) nyomtatás('Tesztpontosság:', teszt_acc)
- Jóslatok készítése
jóslatok = modell.megjósolni(teszt_képek)
jóslatok[0]
Az előrejelzés 10 szám tömbje. Ezek leírják a modell „magabiztosságát”, miszerint a kép megfelel a 10 különböző ruházati cikk mindegyikének. Láthatjuk, melyik címke rendelkezik a legmagasabb megbízhatósági értékkel.
például..argmax(jóslatok[0])A #Model abban bízik, hogy bokacsizma. Lássuk, helyes-eKimenet: 9
teszt_címkék[0]
Kimenet: 9
- Itt az ideje, hogy megvizsgáljuk a teljes 10 csatornás készletet
def telek_kép(én, jóslatok_array, true_label, img): jóslatok_array, true_label, img = jóslatok_array[én], true_label[én], img[én] plt.rács(Hamis) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.bináris) megjósolt_címke = például..argmax(jóslatok_array) ha megjósolt_címke == true_label: szín = 'zöld' más: szín = 'háló' plt.xlabel('{} {: 2.0f}% ({}) ”.formátum(osztály_nevek[megjósolt_címke], 100*például..max(jóslatok_array), osztály_nevek[true_label]), szín=szín) def plot_value_array(én, jóslatok_array, true_label): jóslatok_array, true_label = jóslatok_array[én], true_label[én] plt.rács(Hamis) plt.xticks([]) plt.yticks([]) ez a telek = plt.rúd(hatótávolság(10.), jóslatok_array, szín='# 777777') plt.ylim([0, egy]) megjósolt_címke = például..argmax(jóslatok_array) ez a telek[megjósolt_címke].set_color('háló') ez a telek[true_label].set_color('zöld')
- Először nézzük meg a 0. és a 10. képet
én = 0 plt.ábra(figsize=(6.,3)) plt.mellékcselekmény(egy,2,egy) telek_kép(én, jóslatok, teszt_címkék, teszt_képek) plt.mellékcselekmény(egy,2,2) plot_value_array(én, jóslatok, teszt_címkék) plt.előadás()
én = 10. plt.ábra(figsize=(6.,3)) plt.mellékcselekmény(egy,2,egy) telek_kép(én, jóslatok, teszt_címkék, teszt_képek) plt.mellékcselekmény(egy,2,2) plot_value_array(én, jóslatok, teszt_címkék) plt.előadás()
- Most ábrázoljunk több képet és azok jóslatait. A helyes zöld, míg a helytelen piros.
szám_sorok = 5. num_cols = 3 szám_képek = szám_sorok*num_cols plt.ábra(figsize=(2*2*num_cols, 2*szám_sorok)) mert én ban ben hatótávolság(szám_képek): plt.mellékcselekmény(szám_sorok, 2*num_cols, 2*én+egy) telek_kép(én, jóslatok, teszt_címkék, teszt_képek) plt.mellékcselekmény(szám_sorok, 2*num_cols, 2*én+2) plot_value_array(én, jóslatok, teszt_címkék) plt.előadás()
- Végül a képzett modell segítségével jósolhatunk egyetlen képet.
# Fogjon egy képet a tesztadatkészletből img = teszt_képek[0] nyomtatás(img.alak)
# Adja hozzá a képet egy köteghez, ahol ez az egyetlen tag. img = (például..expand_dims(img,0)) nyomtatás(img.alak)
jóslatok_egyetlen = modell.megjósolni(img) nyomtatás(jóslatok_egyetlen)plot_value_array(0, jóslatok_egyetlen, teszt_címkék) plt.xticks(hatótávolság(10.), osztály_nevek, forgás=Négy öt) plt.előadás()
jóslat_eredmény = például..argmax(jóslatok_egyetlen[0])
Kimenet: 9
CIFAR-10: CNN
A CIFAR-10 adatkészlet repülőgépekből, kutyákból, macskákból és egyéb tárgyakból áll. Előkészíti a képeket, majd az összes mintán konvolúciós ideghálózatot képez. A képeket normalizálni kell, és a címkéket egyszerre kell kódolni. Ez a felhasználási eset biztosan tisztázza a TensorFlow képminősítéssel kapcsolatos kétségeit.
- Az adatok letöltése
tól től urllib.request import urlretrieve tól től os.path import isfile, korom tól től tqdm import tqdm import tarfile cifar10_dataset_folder_path = „cifar-10-batches-py” osztály DownloadProgress(tqdm): utolsó_blokk = 0 def horog(maga, block_num=egy, block_size=egy, teljes méret=Egyik sem): maga.teljes = teljes méret maga.frissítés((block_num - maga.utolsó_blokk) * block_size) maga.utolsó_blokk = block_num '' ' ellenőrizze, hogy az adat (zip) fájl már le van-e töltve ha nem, töltse le a következő webhelyről: https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz és mentse el cifar-10-python.tar.gz néven '' ' ha nem isfile(„cifar-10-python.tar.gz”): val vel DownloadProgress(Mértékegység=„B”, unit_scale=Igaz, miniterek=egy, desc=„CIFAR-10 adatkészlet”) mint pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz”, „cifar-10-python.tar.gz”, pbar.horog) ha nem korom(cifar10_dataset_folder_path): val vel tarfile.nyisd ki(„cifar-10-python.tar.gz”) mint kátrány: kátrány.extractall() kátrány.Bezárás()
- A szükséges könyvtárak importálása
import savanyú uborka import számtalan mint például. import matplotlib.pyplot mint plt
- Az adatok megértése
Az eredeti adatcsomag 10000 × 3072 tenzor, amelyet numpy tömbben fejezünk ki, ahol 10000 a mintaadatok száma. A kép színes és 32 × 32 méretű. Az adagolás történhet (szélesség x magasság x szám_csatorna) vagy (szám_csatorna x szélesség x magasság) formátumban. Határozzuk meg a címkéket.
def load_label_names(): Visszatérés ['repülőgép', 'autó', 'madár', 'macska', 'szarvas', 'kutya', 'béka', 'ló', 'hajó', 'kamion']
- Az adatok átformálása
Az adatokat két szakaszban fogjuk átalakítani
Először ossza fel a sorvektort (3072) 3 részre. Minden darab megfelel az egyes csatornáknak. Ez egy (3 x 1024) tenzor méretet eredményez. Ezután ossza el a kapott tenzort az előző lépéstől 32-gyel. 32 itt a kép szélességét jelenti. Ennek eredménye (3x32x32).
Másodsorban át kell ültetnünk az adatokat a (szám_csatorna, szélesség, magasság) és a (szélesség, magasság, szám_csatorna) értékre. Ehhez az átültetés funkciót fogjuk használni.
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): val vel nyisd ki(cifar10_dataset_folder_path + '/ data_batch_' + o(batch_id), mód=„rb”) mint fájl: # note a kódolási típus 'latin1' tétel = savanyú uborka.Betöltés(fájl, kódolás=„latin1”) jellemzők = tétel['adat'].alakítsd át((len(tétel['adat']), 3, 32, 32)).átültetni(0, 2, 3, egy) címkék = tétel[„címkék”] Visszatérés jellemzők, címke
- Az adatok feltárása
def display_stats(cifar10_dataset_folder_path, batch_id, minta_id): jellemzők, címkék = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) ha nem (0 <= minta_id < len(jellemzők)): nyomtatás('{}minták tételesen{}.{}hatótávolságon kívül van. '.formátum(len(jellemzők), batch_id, minta_id)) Visszatérés Egyik sem nyomtatás(' Tételszám #{}: '.formátum(batch_id)) nyomtatás(A minták száma:{} '.formátum(len(jellemzők))) label_names = load_label_names() label_counts = diktálja(postai irányítószám(*például..egyedi(címkék, return_counts=Igaz))) mert kulcs, érték ban ben label_counts.elemeket(): nyomtatás('Címkeszámok{}] ({}):{}'.formátum(kulcs, label_names[kulcs].felső(), érték)) minta_kép = jellemzők[minta_id] minta_címke = címkék[minta_id] nyomtatás(' Példa a képre{}: '.formátum(minta_id)) nyomtatás(Kép - Min. Érték:{}Maximális érték:{}'.formátum(minta_kép.min(), minta_kép.max())) nyomtatás(Kép - Alak:{}'.formátum(minta_kép.alak)) nyomtatás('Címke - címke azonosító:{}Név:{}'.formátum(minta_címke, label_names[minta_címke])) plt.imshow(minta_kép)
%matplotlib Sorban %konfig InlineBackend.ábra_formátum = 'retina' import számtalan mint például. # Fedezze fel az adatkészletet batch_id = 3 minta_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, minta_id)
- Előkészítő funkciók megvalósítása
Az adatokat normalizálni fogjuk a Min-Max Normalization segítségével. Ezzel egyszerűen az összes x érték 0 és 1 közé esik.
y = (x-min) / (max-min)
def normalizálni(x): '' ' érv - x: bemeneti képadatok a numerikus tömbben [32, 32, 3] Visszatérés - normalizált x '' ' min_val = például..min(x) max_val = például..max(x) x = (x-min_val) / (max_val-min_val) Visszatérés x
- One-Hot Encode
def one_hot_encode(x): '' ' érv - x: a címkék listája Visszatérés - egy forró kódolási mátrix (címkék száma, osztályok száma) '' ' kódolt = például..nullák((len(x), 10.)) mert idx, óra ban ben felsorolja(x): kódolt[idx] [óra] = egy Visszatérés kódolt
- Az adatok előkészítése és mentése
def _preprocess_and_save(normalizálni, one_hot_encode, jellemzők, címkék, fájl név): jellemzők = normalizálni(jellemzők) címkék = one_hot_encode(címkék) savanyú uborka.lerak((jellemzők, címkék), nyisd ki(fájl név, „wb”)) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizálni, one_hot_encode): n_batches = 5. érvényes_jellemzők = [] érvényes_címkék = [] mert kötegelt_i ban ben hatótávolság(egy, n_batches + egy): jellemzők, címkék = load_cfar10_batch(cifar10_dataset_folder_path, kötegelt_i) # a keresési index lesz a pont validációs adatokként a köteg teljes adatkészletében (10%) index_of_validation = int(len(jellemzők) * 0.1) # feldolgozza a köteg teljes adatkészletének 90% -át # - normalizálja a funkciókat # - one_hot_encode a címkéket # - mentse egy új fájlba, amelynek neve: „preprocess_batch_” + batch_number # - minden fájl minden köteghez _preprocess_and_save(normalizálni, one_hot_encode, jellemzők[:-index_of_validation], címkék[:-index_of_validation], 'preprocess_batch_' + o(kötegelt_i) + '.p') # a képzési adatkészlettel ellentétben, az ellenőrzési adatkészlet az összes kötegelt adatkészleten keresztül kerül hozzáadásra # - vegye fel a köteg összesített adatkészletének 10% -át # - adja hozzá őket a listához # - valid_features # - érvényes_címkék érvényes_jellemzők.kiterjeszt(jellemzők[-index_of_validation:]) érvényes_címkék.kiterjeszt(címkék[-index_of_validation:]) # az összes halmozott érvényesítési adatkészlet feldolgozása _preprocess_and_save(normalizálni, one_hot_encode, például..sor(érvényes_jellemzők), például..sor(érvényes_címkék), 'preprocess_validation.p') # töltse be a tesztadatkészletet val vel nyisd ki(cifar10_dataset_folder_path + '/ test_batch', mód=„rb”) mint fájl: tétel = savanyú uborka.Betöltés(fájl, kódolás=„latin1”) # a feldolgozási adatok előfeldolgozása teszt_jellemzők = tétel['adat'].alakítsd át((len(tétel['adat']), 3, 32, 32)).átültetni(0, 2, 3, egy) teszt_címkék = tétel[„címkék”] # Az összes tesztadat előkészítése és mentése _preprocess_and_save(normalizálni, one_hot_encode, például..sor(teszt_jellemzők), például..sor(teszt_címkék), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalizálni, one_hot_encode)
- Ellenőrző pont
import savanyú uborka érvényes_jellemzők, érvényes_címkék = savanyú uborka.Betöltés(nyisd ki('preprocess_validation.p', mód=„rb”))
- A hálózat kiépítése
A teljes modell összesen 14 rétegből áll.
hogyan kell használni a pitont anakondában
import tensorflow mint tf def conv_net(x, keep_prob): conv1_filter = tf.Változó(tf.csonka_normális(alak=[3, 3, 3, 64.], átlagos=0, stddev=0,08)) conv2_filter = tf.Változó(tf.csonka_normális(alak=[3, 3, 64., 128], átlagos=0, stddev=0,08)) conv3_filter = tf.Változó(tf.csonka_normális(alak=[5., 5., 128, 256], átlagos=0, stddev=0,08)) conv4_filter = tf.Változó(tf.csonka_normális(alak=[5., 5., 256, 512], átlagos=0, stddev=0,08)) # 1, 2 konv = tf.sz.conv2d(x, conv1_filter, lépéseket=[egy,egy,egy,egy], párnázás='AZONOS') konv = tf.sz.relu(konv) conv1_pool = tf.sz.max_pool(konv, ksize=[egy,2,2,egy], lépéseket=[egy,2,2,egy], párnázás='AZONOS') conv1_bn = tf.rétegek.köteg_normalizáció(conv1_pool) # 3. 4 konv = tf.sz.conv2d(conv1_bn, conv2_filter, lépéseket=[egy,egy,egy,egy], párnázás='AZONOS') konv = tf.sz.relu(konv) conv2_pool = tf.sz.max_pool(konv, ksize=[egy,2,2,egy], lépéseket=[egy,2,2,egy], párnázás='AZONOS') conv2_bn = tf.rétegek.köteg_normalizáció(conv2_pool) # 5, 6 conv3 = tf.sz.conv2d(conv2_bn, conv3_filter, lépéseket=[egy,egy,egy,egy], párnázás='AZONOS') conv3 = tf.sz.relu(conv3) conv3_pool = tf.sz.max_pool(conv3, ksize=[egy,2,2,egy], lépéseket=[egy,2,2,egy], párnázás='AZONOS') conv3_bn = tf.rétegek.köteg_normalizáció(conv3_pool) # 7, 8 conv4 = tf.sz.conv2d(conv3_bn, conv4_filter, lépéseket=[egy,egy,egy,egy], párnázás='AZONOS') conv4 = tf.sz.relu(conv4) conv4_pool = tf.sz.max_pool(conv4, ksize=[egy,2,2,egy], lépéseket=[egy,2,2,egy], párnázás='AZONOS') conv4_bn = tf.rétegek.köteg_normalizáció(conv4_pool) # 9 lakás = tf.közreműködés.rétegek.lelapul(conv4_bn) # 10 teljes1 = tf.közreműködés.rétegek.teljesen_kapcsolva(bemenetek=lakás, kimenetek száma=128, activation_fn=tf.sz.relu) teljes1 = tf.sz.kidobni(teljes1, keep_prob) teljes1 = tf.rétegek.köteg_normalizáció(teljes1) # tizenegy teljes2 = tf.közreműködés.rétegek.teljesen_kapcsolva(bemenetek=teljes1, kimenetek száma=256, activation_fn=tf.sz.relu) teljes2 = tf.sz.kidobni(teljes2, keep_prob) teljes2 = tf.rétegek.köteg_normalizáció(teljes2) # 12 teljes3 = tf.közreműködés.rétegek.teljesen_kapcsolva(bemenetek=teljes2, kimenetek száma=512, activation_fn=tf.sz.relu) teljes3 = tf.sz.kidobni(teljes3, keep_prob) teljes3 = tf.rétegek.köteg_normalizáció(teljes3) # 13 teljes4 = tf.közreműködés.rétegek.teljesen_kapcsolva(bemenetek=teljes3, kimenetek száma=1024, activation_fn=tf.sz.relu) teljes4 = tf.sz.kidobni(teljes4, keep_prob) teljes4 = tf.rétegek.köteg_normalizáció(teljes4) # 14 ki = tf.közreműködés.rétegek.teljesen_csatlakozik(bemenetek=teljes3, kimenetek száma=10., activation_fn=Egyik sem) Visszatérés ki
- Hiperparaméterek
korszakok = 10. csomó méret = 128 valószínûség = 0.7 learning_rate = 0,001
logitok = conv_net(x, keep_prob) modell = tf.identitás(logitok, név=„logit”) # A név naplózza a Tensort, így edzés után lemezről tölthető be # Veszteség és optimalizáló költség = tf.red_mean(tf.sz.softmax_cross_entropy_with_logits(logitok=logitok, címkék=Y)) optimalizáló = tf.vonat.AdamOptimizer(learning_rate=learning_rate).minimalizálni(költség) # Pontosság helyes_pred = tf.egyenlő(tf.argmax(logitok, egy), tf.argmax(Y, egy)) pontosság = tf.red_mean(tf.öntvény(helyes_pred, tf.úszó32), név='pontosság')
- A vonat a Neural Network
# Egyetlen optimalizálás
def vonat_neurális_hálózat(ülés, optimalizáló, valószínûség, feature_batch, label_batch): ülés.fuss(optimalizáló, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: valószínûség })
# Statisztikák megjelenítése def print_stats(ülés, feature_batch, label_batch, költség, pontosság): veszteség = sess.fuss(költség, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: egy. }) érvényes_acc = sess.fuss(pontosság, feed_dict={ x: érvényes_jellemzők, Y: érvényes_címkék, keep_prob: egy. }) nyomtatás('Veszteség:{:> 10.4f}Ellenőrzési pontosság:{: .6f}'.formátum(veszteség, érvényes_acc))
- Teljes képzés és a modell mentése
def batch_features_labels(jellemzők, címkék, csomó méret): '' ' A funkciókat és a címkéket szakaszokra bontsa '' ' mert Rajt ban ben hatótávolság(0, len(jellemzők), csomó méret): vége = min(Rajt + csomó méret, len(jellemzők)) hozam jellemzők[Rajt:vége], címkék[Rajt:vége] def load_preprocess_training_batch(batch_id, csomó méret): '' ' Töltse be az előfeldolgozott edzés adatait, és küldje el azokat legfeljebb vagy kevesebb tételben '' ' fájl név = 'preprocess_batch_' + o(batch_id) + '.p' jellemzők, címkék = savanyú uborka.Betöltés(nyisd ki(fájl név, mód=„rb”)) # Adja vissza az edzés adatait kisebb méretű kötegekben Visszatérés batch_features_labels(jellemzők, címkék, csomó méret)
# Modell és útvonal mentése
save_model_path = './image_classification' nyomtatás('Kiképzés...') val vel tf.Ülés() mint sess: # A változók inicializálása sess.fuss(tf.global_variables_initializer()) # Képzési ciklus mert korszak ban ben hatótávolság(korszakok): # Hurkolja az összes adagot n_batches = 5. mert kötegelt_i ban ben hatótávolság(egy, n_batches + egy): mert kötegelt_jellemzők, köteg_címkék ban ben load_preprocess_training_batch(kötegelt_i, csomó méret): vonat_neurális_hálózat(sess, optimalizáló, valószínûség, kötegelt_jellemzők, köteg_címkék) nyomtatás('Korszak{:> 2}, CIFAR-10 köteg{}: '.formátum(korszak + egy, kötegelt_i), vége=') print_stats(sess, kötegelt_jellemzők, köteg_címkék, költség, pontosság) # Modell mentése megmentő = tf.vonat.Megmentő() save_path = megmentő.mentés(sess, save_model_path)
Most elkészült a Tensorflow képosztályozás fontos része. Itt az ideje kipróbálni a modellt.
- A modell tesztelése
import savanyú uborka import számtalan mint például. import matplotlib.pyplot mint plt tól től sklearn.előfeldolgozás import LabelBinarizer def batch_features_labels(jellemzők, címkék, csomó méret): '' ' A funkciókat és a címkéket szakaszokra bontsa '' ' mert Rajt ban ben hatótávolság(0, len(jellemzők), csomó méret): vége = min(Rajt + csomó méret, len(jellemzők)) hozam jellemzők[Rajt:vége], címkék[Rajt:vége] def display_image_predictions(jellemzők, címkék, jóslatok, top_n_predictions): n_osztályok = 10. label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.elfér(hatótávolság(n_osztályok)) label_ids = label_binarizer.invers_transform(például..sor(címkék)) ábra, tengelyek = plt.részterületek(nrows=top_n_predictions, ncols=2, figsize=(húsz, 10.)) ábra.tight_layout() ábra.suptitle('Softmax Predictions', betűméret=húsz, Y=1.1) n_jóslatok = 3 árrés = 0,05 ind = például..arange(n_jóslatok) szélesség = (egy. - 2. * árrés) / n_jóslatok mert image_i, (funkció, label_id, pred_indicies, pred_values) ban ben felsorolja(postai irányítószám(jellemzők, label_ids, jóslatok.indexek, jóslatok.értékek)): ha (image_i < top_n_predictions): pred_names = [label_names[pred_i] mert pred_i ban ben pred_indicies] helyes_név = label_names[label_id] tengelyek[image_i] [0].imshow((funkció*255).típusú(például..int32, másolat=Hamis)) tengelyek[image_i] [0].set_title(helyes_név) tengelyek[image_i] [0].set_axis_off() tengelyek[image_i] [egy].barh(ind + árrés, pred_values[:3], szélesség) tengelyek[image_i] [egy].set_yticks(ind + árrés) tengelyek[image_i] [egy].set_yticklabels(pred_names[::-egy]) tengelyek[image_i] [egy].set_xticks([0, 0.5, 1.0])
%matplotlib Sorban %konfig InlineBackend.ábra_formátum = 'retina' import tensorflow mint tf import savanyú uborka import véletlen save_model_path = './image_classification' csomó méret = 64. n_minták = 10. top_n_predictions = 5. def teszt_modell(): teszt_jellemzők, teszt_címkék = savanyú uborka.Betöltés(nyisd ki('preprocess_training.p', mód=„rb”)) loading_graph = tf.Grafikon() val vel tf.Ülés(grafikon=loading_graph) mint sess: # Modell betöltése rakodó = tf.vonat.import_meta_graph(save_model_path + '.meta') rakodó.visszaállítás(sess, save_model_path) # Tenzorok beszerzése a megrakott modellből betöltve_x = loading_graph.get_tensor_by_name('input_x: 0') betöltve_y = loading_graph.get_tensor_by_name('output_y: 0') loading_keep_prob = loading_graph.get_tensor_by_name('keep_prob: 0') loading_logits = loading_graph.get_tensor_by_name('logits: 0') betöltése_acc = loading_graph.get_tensor_by_name('pontosság: 0') # Pontosság elérése kötegekben a memória korlátai miatt test_batch_acc_total = 0 teszt_batch_count = 0 mert train_feature_batch, vonat_címke_ köteg ban ben batch_features_labels(teszt_jellemzők, teszt_címkék, csomó méret): test_batch_acc_total + = sess.fuss( betöltése_acc, feed_dict={betöltve_x: train_feature_batch, betöltve_y: vonat_címke_ köteg, loading_keep_prob: 1.0}) teszt_batch_count + = egy nyomtatás(„A pontosság tesztelése:{} '.formátum(test_batch_acc_total/teszt_batch_count)) # Véletlen minták nyomtatása random_test_features, random_test_labels = tuple(postai irányítószám(*véletlen.minta(lista(postai irányítószám(teszt_jellemzők, teszt_címkék)), n_minták))) random_test_predictions = sess.fuss( tf.sz.top_k(tf.sz.softmax(loading_logits), top_n_predictions), feed_dict={betöltve_x: random_test_features, betöltve_y: random_test_labels, loading_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) teszt_modell()
Kimenet: Pontosság tesztelése: 0.5882762738853503
Most, ha ideghálózatát újabb korszakokra képzi, vagy megváltoztatja az aktiválási funkciót, akkor más eredményt kaphat, amelynek pontossága jobb lehet.
Tehát ezzel a TensorFlow Image Classification cikknek a végére értünk. Biztos vagyok benne, hogy mostantól ugyanezt használhatja bármilyen kép osztályozásához, és nem kezdi a képek besorolását.
Edureka's A Python tanúsítással az ipari szakemberek kurálják az ipar követelményeinek és igényeinek megfelelően. Elsajátítja az olyan fogalmakat, mint a SoftMax funkció, az Autoencoder Neural Networks, a Restricted Boltzmann Machine (RBM), a Keras és a TFLearn. A tanfolyamot ipari szakemberek készítették, valós idejű esettanulmányokkal.