„TensorFlow“ vaizdų klasifikacija: viskas, ką reikia žinoti apie pastatų klasifikatorius

Vaizdų klasifikavimas - užduotis, kurią net kūdikis gali atlikti per kelias sekundes, tačiau mašinai tai buvo nelengva užduotis iki naujausių ir Gilus mokymasis . Savarankiškai važiuojantys automobiliai gali aptikti daiktus ir atlikti reikiamus veiksmus realiuoju laiku, ir tai yra įmanoma dėl to Vaizdų klasifikacija. Šiame straipsnyje aprašysiu šias temas:

• Kas yra „TensorFlow“?
• Kas yra vaizdų klasifikacija?
• „TensorFlow“ vaizdų klasifikacija: Mada MNIST
• CIFAR 10: CNN

Kas yra „TensorFlow“?

„TensorFlow“ yra „Google“ atvirojo kodo mašininio mokymosi sistema, skirta duomenų srautams programuoti įvairiose užduotyse. Grafike esantys mazgai rodo matematines operacijas, o grafiko kraštai - daugialypius duomenų masyvus, perduodamus tarp jų.

Tensoriai yra tik daugiamatės masyvai, 2 dimensijų lentelių išplėtimas į aukštesnio matmens duomenis. Yra daug „Tensorflow“ funkcijų, dėl kurių ji tinka giliam mokymuisi, o pagrindinė atvirojo kodo biblioteka padeda jums kurti ir mokyti ML modelius.

Kas yra vaizdų klasifikacija?

Vaizdų klasifikavimo tikslas yra suskirstyti visus skaitmeninio vaizdo taškus į vieną iš kelių žemės danga klasės arba temomis . Šie suskirstyti duomenys gali būti naudojami rengiant teminiai žemėlapiai žemės dangos, esančios atvaizde.

Dabar, atsižvelgiant į analitiko ir kompiuterio sąveiką klasifikavimo metu, yra du klasifikavimo tipai:

• Prižiūrimas ir
• Neprižiūrimas

Taigi, negaišdami laiko, pereikime prie „TensorFlow“ vaizdų klasifikavimo. Turiu 2 pavyzdžius: lengva ir sunku. Tęskime lengvą.

„TensorFlow“ vaizdų klasifikacija: Mada MNIST

Mados MNIST duomenų rinkinys

Čia mes naudosime „Fashion MNIST“ duomenų rinkinį, kuriame yra 70 000 pilkų spalvų vaizdų 10 kategorijų. Treniruotėms panaudosime 60000, o testavimui - 10000. „Fashion MNIST“ galite pasiekti tiesiai iš „TensorFlow“, tiesiog importuokite ir įkelkite duomenis.

• Pirmiausia importuokime bibliotekas

iš __future__ importo absoliutus_importas, dalijimas, spausdinimo_funkcija # TensorFlow ir tf.keras importuoja tensorflow kaip tf iš tensorflow importo kerų # Pagalbinės bibliotekos importuoja numerį kaip np importo matplotlib.pyplot kaip plt

• Įkelkime duomenis

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

• Toliau vaizdus suskirstysime į klases

class_names = ['marškinėliai / viršus', 'kelnės', 'megztiniai', 'suknelės', 'paltai', 'sandalai', 'marškiniai', 'sportbačiai', 'krepšys', kulkšnies batai]

• Tyrinėdami duomenis

traukinio vaizdai.figūra 
#Kiekviena etiketė yra tarp 0–9

traukinio_etiketės 
test_images.figūra 

• Dabar atėjo laikas iš anksto apdoroti duomenis.

plt.figūra() plt.imshow(traukinio vaizdai[0]) plt.spalvų juosta() plt.tinklelis(Klaidinga) plt.Rodyti() 
#Apžiūrėję pirmąjį treniruočių rinkinio vaizdą, pamatysite, kad pikselių vertės patenka į 0–255 intervalą. 

• Mes turime mastelį atvaizduoti nuo 0 iki 1, kad galėtume juos perduoti į neuronų tinklą

traukinio vaizdai = traukinio vaizdai / 255,0 test_images = test_images / 255,0

• Parodykime keletą vaizdų.

plt.figūra(figsize=(10,10)) dėl i į diapazonas(25): plt.subplot(5,5,i+vienas) plt.xticks([]) plt.yticks([]) plt.tinklelis(Klaidinga) plt.imshow(traukinio vaizdai[i], cmap=plt.cm.dvejetainis) plt.xlabel(klasės_pavadinimai[traukinio_etiketės[i]]) plt.Rodyti()

• Nustatykite sluoksnius

modelis = sunku.Nuoseklus([ sunku.sluoksniai.Išlyginti(input_shape=(28, 28)), sunku.sluoksniai.Tankus(128, aktyvinimas=tf.Nr.relu), sunku.sluoksniai.Tankus(10, aktyvinimas=tf.Nr.softmax) ])

• Sudarykite modelį

modelis.sudaryti(optimizatorius=„Adam“, nuostoliai=„sparse_categorical_crossentropy“, metriką=[„tikslumas“])

• Modelio mokymai

modelis.tinka(traukinio vaizdai, traukinio_etiketės, epochos=10)

kaip naudotis „tableau public“

• Tikslumo įvertinimas

test_loss, test_acc = modelis.įvertinti(test_images, test_labels) spausdinti(„Bandymo tikslumas:“, test_acc)

• Spėti

prognozės = modelis.numatyti(test_images)

prognozės[0]

Spėjimas yra 10 skaičių masyvas. Tai apibūdina modelio „pasitikėjimą“, kad vaizdas atitinka kiekvieną iš 10 skirtingų drabužių. Galime pamatyti, kuri etiketė turi didžiausią patikimumo vertę.

pvz..argmax(prognozės[0])#Modelis labiausiai įsitikinęs, kad tai kulkšnies batas. Pažiūrėkime, ar tai teisinga

Rezultatas: 9

test_labels[0]

Rezultatas: 9

• Dabar atėjo laikas pažvelgti į visą 10 kanalų rinkinį

def plot_image(i, spėjimai_paveikslas, true_label, img): spėjimai_paveikslas, true_label, img = spėjimai_paveikslas[i], true_label[i], img[i] plt.tinklelis(Klaidinga) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.dvejetainis) numatomas_label = pvz..argmax(spėjimai_paveikslas) jei numatomas_label == true_label: spalva = 'žalias' Kitas: spalva = „neto“ plt.xlabel('{} {: 2.0f}% ({}) “.formatas(klasės_pavadinimai[numatomas_label], 100*pvz..maks(spėjimai_paveikslas), klasės_pavadinimai[true_label]), spalva=spalva) def plot_value_array(i, spėjimai_paveikslas, true_label): spėjimai_paveikslas, true_label = spėjimai_paveikslas[i], true_label[i] plt.tinklelis(Klaidinga) plt.xticks([]) plt.yticks([]) šį siužetą = plt.baras(diapazonas(10), spėjimai_paveikslas, spalva=„# 777777“) plt.ylim([0, vienas]) numatomas_label = pvz..argmax(spėjimai_paveikslas) šį siužetą[numatomas_label].set_color(„neto“) šį siužetą[true_label].set_color('žalias')

• Pirmiausia pažvelkime į 0 ir 10 vaizdą

i = 0 plt.figūra(figsize=(6,3)) plt.subplot(vienas,2,vienas) plot_image(i, prognozės, test_labels, test_images) plt.subplot(vienas,2,2) plot_value_array(i, prognozės, test_labels) plt.Rodyti()

i = 10 plt.figūra(figsize=(6,3)) plt.subplot(vienas,2,vienas) plot_image(i, prognozės, test_labels, test_images) plt.subplot(vienas,2,2) plot_value_array(i, prognozės, test_labels) plt.Rodyti()

• Dabar suskaičiuokime keletą vaizdų ir jų prognozes. Teisingi yra žali, o neteisingi - raudoni.

skaičių_ eilutės = 5 skaičiai_cols = 3 num_images = skaičių_ eilutės*skaičiai_cols plt.figūra(figsize=(2*2*skaičiai_cols, 2*skaičių_ eilutės)) dėl i į diapazonas(num_images): plt.subplot(skaičių_ eilutės, 2*skaičiai_cols, 2*i+vienas) plot_image(i, prognozės, test_labels, test_images) plt.subplot(skaičių_ eilutės, 2*skaičiai_cols, 2*i+2) plot_value_array(i, prognozės, test_labels) plt.Rodyti()

• Galiausiai naudosime apmokytą modelį, norėdami numatyti vieną vaizdą.

# Paimkite vaizdą iš bandomojo duomenų rinkinio img = test_images[0] spausdinti(img.figūra)

# Pridėkite vaizdą prie grupės, kur jis yra vienintelis narys. img = (pvz..išplėsti_dimpusius(img,0)) spausdinti(img.figūra)

numatymai_vienas = modelis.numatyti(img) spausdinti(numatymai_vienas)

plot_value_array(0, numatymai_vienas, test_labels) plt.xticks(diapazonas(10), klasės_pavadinimai, sukimasis=Keturi, penki) plt.Rodyti()

• Kaip matote prognozę apie mūsų vienintelį vaizdą paketais.

numatymas_rezultatas = pvz..argmax(numatymai_vienas[0])

Rezultatas: 9

CIFAR-10: CNN

CIFAR-10 duomenų rinkinį sudaro lėktuvai, šunys, katės ir kiti objektai. Iš anksto apdorosite vaizdus, ​​tada mokysite konvoliucinį neuronų tinklą iš visų pavyzdžių. Vaizdai turi būti normalizuoti, o etiketės - vienkartinės. Šis naudojimo atvejis tikrai pašalins jūsų abejones dėl „TensorFlow“ vaizdų klasifikavimo.

• Duomenų atsisiuntimas

nuo urllib.request importas urlretrieve nuo os. kelias importas isfile, yra suodžių nuo tqdm importas tqdm importas tarfile cifar10_dataset_folder_path = „cifar-10-batches-py“ klasė „DownloadProgress“(tqdm): paskutinis_blokuoti = 0 def kabliukas(savarankiškai, block_num=vienas, block_size=vienas, visas dydis=Nė vienas): savarankiškai.viso = visas dydis savarankiškai.atnaujinti((block_num - savarankiškai.paskutinis_blokuoti) * block_size) savarankiškai.paskutinis_blokuoti = block_num „“ patikrinkite, ar duomenų (zip) failas jau atsisiųstas jei ne, atsisiųskite jį iš „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“ ir išsaugokite kaip cifar-10-python.tar.gz „“ jei ne isfile(„cifar-10-python.tar.gz“): su „DownloadProgress“(vienetas=„B“, unit_scale=Tiesa, miniteriai=vienas, aprašymas=„CIFAR-10 duomenų rinkinys“) kaip pbar: urlretrieve( „https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz“, „cifar-10-python.tar.gz“, pbar.kabliukas) jei ne yra suodžių(cifar10_dataset_folder_path): su tarfile.atviras(„cifar-10-python.tar.gz“) kaip degutas: degutas.išarchyvuoti viską() degutas.Uždaryti()

• Būtinų bibliotekų importavimas

importas marinatas importas numpy kaip pvz. importas matplotlib.pyplot kaip plt

• Duomenų supratimas

Pradinė duomenų partija yra 10000 × 3072 tenzorius, išreikštas numpy masyvu, kur 10000 yra duomenų pavyzdžių skaičius. Vaizdas yra spalvotas ir 32 × 32 dydžio. Maitinimas gali būti atliekamas formatu (plotis x aukštis x skaičiaus kanalas) arba (skaičiaus kanalas x plotis x aukštis). Apibrėžkime etiketes.

def load_label_names(): grįžti [„lėktuvas“, „automobilis“, 'paukštis', 'katė', „elnias“, 'šuo', „varlė“, „arklys“, „laivas“, „sunkvežimis“]

• Duomenų pertvarkymas

Duomenis pertvarkysime dviem etapais

Pirmiausia eilutės vektorių (3072) padalykite į 3 dalis. Kiekvienas kūrinys atitinka kiekvieną kanalą. Dėl to gaunamas (3 x 1024) tenzoriaus matmuo. Tada padalykite gautą tensorių iš ankstesnio žingsnio naudodami 32. 32 čia reiškia vaizdo plotį. Dėl to gaunama (3x32x32).

Antra, duomenis turime perkelti iš (numerio_kanalas, plotis, aukštis) į (plotis, aukštis, numerio_kanalas). Tam mes naudosime transponavimo funkciją.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): su atviras(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), režimas=„rb“) kaip failą: # note kodavimo tipas yra „latin1“ partija = marinatas.apkrova(failą, kodavimas=„lotynų1“) funkcijos = partija[„duomenys“].pertvarkyti((len(partija[„duomenys“]), 3, 32, 32)).perkelti(0, 2, 3, vienas) etikečių = partija[„etiketės“] grįžti funkcijos, etiketė

• Duomenų tyrimas

def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): funkcijos, etikečių = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) jei ne (0 <= sample_id < len(funkcijos)): spausdinti('{}partijos mėginiai{}.{}yra už diapazono ribų. “.formatas(len(funkcijos), batch_id, sample_id)) grįžti Nė vienas spausdinti(' # Serijos statistika{}: '.formatas(batch_id)) spausdinti(„Pavyzdžių skaičius:{} '.formatas(len(funkcijos))) label_names = load_label_names() label_counts = diktuoti(užtrauktukas(*pvz..Unikalus(etikečių, grąžinimo_skaičiai=Tiesa))) dėl Raktas, vertė į label_counts.daiktų(): spausdinti(„Etikečių skaičius{}] ({}):{}'.formatas(Raktas, label_names[Raktas].viršutinė(), vertė)) imties_vaizdas = funkcijos[sample_id] pavyzdžio_etiketė = etikečių[sample_id] spausdinti(' Vaizdo pavyzdys{}: '.formatas(sample_id)) spausdinti(„Vaizdas - mažiausia vertė:{}Maksimali vertė:{}'.formatas(imties_vaizdas.min(), imties_vaizdas.maks())) spausdinti(„Vaizdas - forma:{}'.formatas(imties_vaizdas.figūra)) spausdinti('Etiketė - etiketės ID:{}Vardas:{}'.formatas(pavyzdžio_etiketė, label_names[pavyzdžio_etiketė])) plt.imshow(imties_vaizdas)

%matplotlib tiesiai %konfigūruoti „InlineBackend“.figūros_formatas = „tinklainė“ importas numpy kaip pvz. # Naršykite duomenų rinkinį batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

• Išankstinio apdorojimo funkcijų įgyvendinimas

Duomenis normalizuosime naudodami „Min-Max Normalization“. Tai paprasčiausiai priverčia visas x reikšmes svyruoti nuo 0 iki 1.
y = (x-min) / (max-min)

def normalizuoti(x): „“ argumentas - x: įvesties vaizdo duomenys numpy masyve [32, 32, 3] grįžti - normalizuotas x „“ min_val = pvz..min(x) max_val = pvz..maks(x) x = (x-min_val) / (max_val-min_val) grįžti x

• „Vienas karštas“ kodavimas

def one_hot_encode(x): „“ argumentas - x: etikečių sąrašas grįžti - viena karšto kodavimo matrica (etikečių skaičius, klasės skaičius) „“ užkoduota = pvz..nuliai((len(x), 10)) dėl idx, val į išvardinti(x): užkoduota[idx] [val] = vienas grįžti užkoduota

• Iš anksto apdorokite ir išsaugokite duomenis

def _preprocess_and_save(normalizuoti, one_hot_encode, funkcijos, etikečių, failo pavadinimas): funkcijos = normalizuoti(funkcijos) etikečių = one_hot_encode(etikečių) marinatas.išpilti((funkcijos, etikečių), atviras(failo pavadinimas, „wb“)) def išankstinio apdorojimo ir išsaugojimo duomenys(cifar10_dataset_folder_path, normalizuoti, one_hot_encode): n_partijos = 5 valid_features = [] valid_labels = [] dėl partija_i į diapazonas(vienas, n_partijos + vienas): funkcijos, etikečių = load_cfar10_batch(cifar10_dataset_folder_path, partija_i) # rasti indeksą kaip tašką kaip patvirtinimo duomenis visame paketo duomenų rinkinyje (10%) index_of_validation = tarpt(len(funkcijos) * 0.1) # iš anksto apdorokite 90% viso paketo duomenų rinkinio # - normalizuoti funkcijas # - one_hot_encode etiketės # - išsaugokite naujame faile pavadinimu „preprocess_batch_“ + batch_number # - kiekvienas failas kiekvienai partijai _preprocess_and_save(normalizuoti, one_hot_encode, funkcijos[:-index_of_validation], etikečių[:-index_of_validation], „preprocess_batch_“ + p(partija_i) + „.p“) # skirtingai nei mokymo duomenų rinkinys, patvirtinimo duomenų rinkinys bus pridėtas per visą paketinį duomenų rinkinį # - paimkite 10% visos partijos duomenų rinkinio # - įtraukite juos į sąrašą # - galiojančios funkcijos # - galiojančios etiketės valid_features.pratęsti(funkcijos[-index_of_validation:]) valid_labels.pratęsti(etikečių[-index_of_validation:]) # iš anksto apdorokite visą sukrautų patvirtinimo duomenų rinkinį _preprocess_and_save(normalizuoti, one_hot_encode, pvz..masyvas(valid_features), pvz..masyvas(valid_labels), „preprocess_validation.p“) # įkelkite bandomąjį duomenų rinkinį su atviras(cifar10_dataset_folder_path + „/ test_batch“, režimas=„rb“) kaip failą: partija = marinatas.apkrova(failą, kodavimas=„lotynų1“) # iš anksto apdorokite bandymo duomenis test_features = partija[„duomenys“].pertvarkyti((len(partija[„duomenys“]), 3, 32, 32)).perkelti(0, 2, 3, vienas) test_labels = partija[„etiketės“] # Paruoškite ir išsaugokite visus bandymų duomenis _preprocess_and_save(normalizuoti, one_hot_encode, pvz..masyvas(test_features), pvz..masyvas(test_labels), „preprocess_training.p“)

išankstinio apdorojimo ir išsaugojimo duomenys(cifar10_dataset_folder_path, normalizuoti, one_hot_encode)

• Patikrinimo punktas

importas marinatas valid_features, valid_labels = marinatas.apkrova(atviras(„preprocess_validation.p“, režimas=„rb“))

• Tinklo kūrimas

Visą modelį sudaro 14 sluoksnių.

importas tensorflow kaip tf def conv_net(x, išlaikyti_prob): conv1_filter = tf.Kintamas(tf.sutrumpintas_normalus(figūra=[3, 3, 3, 64], reiškia=0, stddev=0,08)) conv2_filter = tf.Kintamas(tf.sutrumpintas_normalus(figūra=[3, 3, 64, 128], reiškia=0, stddev=0,08)) conv3_filter = tf.Kintamas(tf.sutrumpintas_normalus(figūra=[5, 5, 128, 256], reiškia=0, stddev=0,08)) conv4_filter = tf.Kintamas(tf.sutrumpintas_normalus(figūra=[5, 5, 256, 512], reiškia=0, stddev=0,08)) # 1, 2 conv1 = tf.Nr.conv2d(x, conv1_filter, žingsniai=[vienas,vienas,vienas,vienas], paminkštinimas=„TAS pats“) conv1 = tf.Nr.relu(conv1) conv1_pool = tf.Nr.max_pool(conv1, ksize=[vienas,2,2,vienas], žingsniai=[vienas,2,2,vienas], paminkštinimas=„TAS pats“) conv1_bn = tf.sluoksniai.partijos_normalizavimas(conv1_pool) # 3. 4 konv = tf.Nr.conv2d(conv1_bn, conv2_filter, žingsniai=[vienas,vienas,vienas,vienas], paminkštinimas=„TAS pats“) konv = tf.Nr.relu(konv) conv2_pool = tf.Nr.max_pool(konv, ksize=[vienas,2,2,vienas], žingsniai=[vienas,2,2,vienas], paminkštinimas=„TAS pats“) conv2_bn = tf.sluoksniai.partijos_normalizavimas(conv2_pool) # 5, 6 conv3 = tf.Nr.conv2d(conv2_bn, conv3_filter, žingsniai=[vienas,vienas,vienas,vienas], paminkštinimas=„TAS pats“) conv3 = tf.Nr.relu(conv3) conv3_pool = tf.Nr.max_pool(conv3, ksize=[vienas,2,2,vienas], žingsniai=[vienas,2,2,vienas], paminkštinimas=„TAS pats“) conv3_bn = tf.sluoksniai.partijos_normalizavimas(conv3_pool) # 7, 8 conv4 = tf.Nr.conv2d(conv3_bn, conv4_filter, žingsniai=[vienas,vienas,vienas,vienas], paminkštinimas=„TAS pats“) conv4 = tf.Nr.relu(conv4) conv4_pool = tf.Nr.max_pool(conv4, ksize=[vienas,2,2,vienas], žingsniai=[vienas,2,2,vienas], paminkštinimas=„TAS pats“) conv4_bn = tf.sluoksniai.partijos_normalizavimas(conv4_pool) # 9 butas = tf.prisidėti.sluoksniai.išlyginti(conv4_bn) # 10 1 = tf.prisidėti.sluoksniai.visiškai_sujungtas(įvestys=butas, num_outputs=128, activation_fn=tf.Nr.relu) 1 = tf.Nr.iškristi(1, išlaikyti_prob) 1 = tf.sluoksniai.partijos_normalizavimas(1) # vienuolika 2 = tf.prisidėti.sluoksniai.visiškai_sujungtas(įvestys=1, num_outputs=256, activation_fn=tf.Nr.relu) 2 = tf.Nr.iškristi(2, išlaikyti_prob) 2 = tf.sluoksniai.partijos_normalizavimas(2) # 12 pilnas3 = tf.prisidėti.sluoksniai.visiškai_sujungtas(įvestys=2, num_outputs=512, activation_fn=tf.Nr.relu) pilnas3 = tf.Nr.iškristi(pilnas3, išlaikyti_prob) pilnas3 = tf.sluoksniai.partijos_normalizavimas(pilnas3) # 13 pilna4 = tf.prisidėti.sluoksniai.visiškai_sujungtas(įvestys=pilnas3, num_outputs=1024 m, activation_fn=tf.Nr.relu) pilna4 = tf.Nr.iškristi(pilna4, išlaikyti_prob) pilna4 = tf.sluoksniai.partijos_normalizavimas(pilna4) # 14 išėjo = tf.prisidėti.sluoksniai.visiškai_sujungtas(įvestys=pilnas3, num_outputs=10, activation_fn=Nė vienas) grįžti išėjo

• Hiperparametrai

epochos = 10 partijos_dydis = 128 išlaikyti_tikrinamumą = 0.7 mokymosi norma = 0,001

logitai = conv_net(x, išlaikyti_prob) modelis = tf.tapatybė(logitai, vardas=„logits“) # Vardų registrai „Tensor“, kad po treniruotės jį būtų galima atsisiųsti iš disko # Praradimas ir optimizatorius išlaidos = tf.mažinti_reiskia(tf.Nr.softmax_cross_entropy_with_logits(logitai=logitai, etikečių=Y)) optimizatorius = tf.traukinys.„AdamOptimizer“(mokymosi norma=mokymosi norma).sumažinti(išlaidos) # Tikslumas teisingas_prederis = tf.lygus(tf.argmax(logitai, vienas), tf.argmax(Y, vienas)) tikslumas = tf.mažinti_reiskia(tf.mesti(teisingas_prederis, tf.plūdė32), vardas=„tikslumas“)

• Treniruok neuronų tinklą

#Vienkartinis optimizavimas 
def traukinio_neuralinis_tinklas(sesija, optimizatorius, išlaikyti_tikrinamumą, feature_batch, label_batch): sesija.paleisti(optimizatorius, feed_dict={ x: feature_batch, Y: label_batch, išlaikyti_prob: išlaikyti_tikrinamumą })

# Rodoma statistika def print_stats(sesija, feature_batch, label_batch, išlaidos, tikslumas): nuostoliai = sess.paleisti(išlaidos, feed_dict={ x: feature_batch, Y: label_batch, išlaikyti_prob: vienas. }) valid_acc = sess.paleisti(tikslumas, feed_dict={ x: valid_features, Y: valid_labels, išlaikyti_prob: vienas. }) spausdinti('Praradimas:{:> 10.4f}Patvirtinimo tikslumas:{: .6f}'.formatas(nuostoliai, valid_acc))

• Visiškas mokymas ir modelio išsaugojimas

def batch_features_labels(funkcijos, etikečių, partijos_dydis): „“ Suskirstykite funkcijas ir etiketes į partijas „“ dėl pradžia į diapazonas(0, len(funkcijos), partijos_dydis): pabaiga = min(pradžia + partijos_dydis, len(funkcijos)) derlius funkcijos[pradžia:pabaiga], etikečių[pradžia:pabaiga] def load_preprocess_training_batch(batch_id, partijos_dydis): „“ Įdėkite paruošto apdorojimo duomenis ir grąžinkite juos po arba mažiau „“ failo pavadinimas = „preprocess_batch_“ + p(batch_id) + „.p“ funkcijos, etikečių = marinatas.apkrova(atviras(failo pavadinimas, režimas=„rb“)) # Grąžinkite treniruotės duomenis paketais, kurių dydis arba mažesnis grįžti batch_features_labels(funkcijos, etikečių, partijos_dydis)

# Modelio ir kelio išsaugojimas 
save_model_path = „./image_classification“ spausdinti(„Mokymai ...“) su tf.Sesija() kaip sess: # Kintamųjų inicijavimas sess.paleisti(tf.global_variables_initializer()) # Treniruočių ciklas dėl epocha į diapazonas(epochos): # Peržiūrėkite visas partijas n_partijos = 5 dėl partija_i į diapazonas(vienas, n_partijos + vienas): dėl partijos_ funkcijos, partijos_etiketės į load_preprocess_training_batch(partija_i, partijos_dydis): traukinio_neuralinis_tinklas(sess, optimizatorius, išlaikyti_tikrinamumą, partijos_ funkcijos, partijos_etiketės) spausdinti('Epocha{:> 2}, CIFAR-10 partija{}: '.formatas(epocha + vienas, partija_i), pabaiga=') print_stats(sess, partijos_ funkcijos, partijos_etiketės, išlaidos, tikslumas) # Išsaugoti modelį taupyklė = tf.traukinys.Taupytojas() save_path = taupyklė.sutaupyti(sess, save_model_path)

Dabar atlikta svarbi „Tensorflow“ vaizdų klasifikavimo dalis. Dabar atėjo laikas išbandyti modelį.

• Modelio testavimas

importas marinatas importas numpy kaip pvz. importas matplotlib.pyplot kaip plt nuo sklearn.paruošimas importas „LabelBinarizer“ def batch_features_labels(funkcijos, etikečių, partijos_dydis): „“ Suskirstykite funkcijas ir etiketes į partijas „“ dėl pradžia į diapazonas(0, len(funkcijos), partijos_dydis): pabaiga = min(pradžia + partijos_dydis, len(funkcijos)) derlius funkcijos[pradžia:pabaiga], etikečių[pradžia:pabaiga] def display_image_predictions(funkcijos, etikečių, prognozės, top_n_prognozės): n_klasės = 10 label_names = load_label_names() label_binarizer = „LabelBinarizer“() label_binarizer.tinka(diapazonas(n_klasės)) label_ids = label_binarizer.inversinis_transformuoti(pvz..masyvas(etikečių)) pav, ašys = plt.subplotai(nrows=top_n_prognozės, ncols=2, figsize=(dvidešimt, 10)) pav.storas išdėstymas() pav.suptitle(„Softmax prognozės“, šrifto dydis=dvidešimt, Y=1.1) n_prognozės = 3 marža = 0,05 ind = pvz..aranžinis(n_prognozės) pločio = (vienas. - 2. * marža) / n_prognozės dėl image_i, (funkcija, label_id, pred_indicies, pred_values) į išvardinti(užtrauktukas(funkcijos, label_ids, prognozės.indeksai, prognozės.vertybes)): jei (image_i < top_n_prognozės): pred_names = [label_names[pred_i] dėl pred_i į pred_indicies] teisingas_pavadinimas = label_names[label_id] ašys[image_i] [0].imshow((funkcija*255).astipas(pvz..int32, kopija=Klaidinga)) ašys[image_i] [0].set_title(teisingas_pavadinimas) ašys[image_i] [0].set_axis_off() ašys[image_i] [vienas].barhas(ind + marža, pred_values[:3], pločio) ašys[image_i] [vienas].set_yticks(ind + marža) ašys[image_i] [vienas].set_yticklabels(pred_names[::-vienas]) ašys[image_i] [vienas].set_xticks([0, 0.5, 1.0])

%matplotlib tiesiai %konfigūruoti „InlineBackend“.figūros_formatas = „tinklainė“ importas tensorflow kaip tf importas marinatas importas atsitiktinis save_model_path = „./image_classification“ partijos_dydis = 64 n_ mėginiai = 10 top_n_prognozės = 5 def test_model(): test_features, test_labels = marinatas.apkrova(atviras(„preprocess_training.p“, režimas=„rb“)) įkeltas_graafas = tf.Grafikas() su tf.Sesija(grafikas=įkeltas_graafas) kaip sess: # Apkrovos modelis krautuvas = tf.traukinys.import_meta_graph(save_model_path + „.meta“) krautuvas.atkurti(sess, save_model_path) # Gaukite „Tensors“ iš pakrauto modelio pakrautas_x = įkeltas_graafas.gauti_tensor_by_name('input_x: 0') pakrautas_y = įkeltas_graafas.gauti_tensor_by_name('output_y: 0') įkeltas_laikymo_prob = įkeltas_graafas.gauti_tensor_by_name(„keep_prob: 0“) loading_logits = įkeltas_graafas.gauti_tensor_by_name(„logits: 0“) įkeltas_ak = įkeltas_graafas.gauti_tensor_by_name(„tikslumas: 0“) # Gaukite tikslumą paketais dėl atminties apribojimų test_batch_acc_total = 0 test_batch_count = 0 dėl traukinio_funkcijos_partija, train_label_batch į batch_features_labels(test_features, test_labels, partijos_dydis): test_batch_acc_total + = sess.paleisti( įkeltas_ak, feed_dict={pakrautas_x: traukinio_funkcijos_partija, pakrautas_y: train_label_batch, įkeltas_laikymo_prob: 1.0}) test_batch_count + = vienas spausdinti(„Tikrumo tikrinimas:{} '.formatas(test_batch_acc_total/test_batch_count)) # Atspausdinti atsitiktinius pavyzdžius random_test_features, random_test_labels = dvipusis(užtrauktukas(*atsitiktinis.pavyzdys(sąrašą(užtrauktukas(test_features, test_labels)), n_ mėginiai))) atsitiktinių_testų_prognozės = sess.paleisti( tf.Nr.top_k(tf.Nr.softmax(loading_logits), top_n_prognozės), feed_dict={pakrautas_x: random_test_features, pakrautas_y: random_test_labels, įkeltas_laikymo_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, atsitiktinių_testų_prognozės, top_n_prognozės) test_model()

Išvestis: Tikrinimo tikslumas: 0.5882762738853503

Dabar, jei mokysite savo nervų tinklą daugiau epochų arba pakeisite aktyvinimo funkciją, galite gauti kitokį rezultatą, kurio tikslumas gali būti didesnis.

Taigi, mes baigėme šį „TensorFlow“ vaizdų klasifikavimo straipsnį. Esu įsitikinęs, kad dabar galite naudoti tą patį tipą bet kokiems vaizdams klasifikuoti, o jūs nesate pradinis klasifikuoti vaizdus.

„Edureka“ „Python“ sertifikavimo mokymus kuruoja pramonės specialistai pagal pramonės reikalavimus ir reikalavimus. Jūs įsisavinsite tokias sąvokas kaip „SoftMax“ funkcija, „Autoencoder“ neuroniniai tinklai, „Restricted Boltzmann Machine“ (RBM), „Keras“ ir „TFLearn“. Kursą specialiai kuravo pramonės ekspertai, atlikdami realaus laiko atvejų analizę.