Afbeeldingsclassificatie, een taak die zelfs een baby in seconden kan uitvoeren, maar voor een machine was het een zware taak tot de recente vorderingen in en Diep leren . Zelfrijdende auto's kunnen objecten detecteren en de vereiste actie in realtime ondernemen en het meeste hiervan is mogelijk dankzij Afbeelding classificatie. In dit artikel zal ik u door de volgende onderwerpen leiden:
- Wat is TensorFlow?
- Wat is beeldclassificatie?
- TensorFlow-beeldclassificatie: Fashion MNIST
- CIFAR 10: CNN
Wat is TensorFlow?
TensorFlow is het Open Source Machine Learning Framework van Google voor het programmeren van gegevensstromen voor een reeks taken. Knooppunten in de grafiek vertegenwoordigen wiskundige bewerkingen, terwijl de grafiekranden de multidimensionale gegevensarrays vertegenwoordigen die daartussen worden gecommuniceerd.
Tensoren zijn slechts multidimensionale arrays, een uitbreiding van tweedimensionale tabellen naar gegevens met een hogere dimensie. Er zijn veel functies van Tensorflow die het geschikt maken voor Deep Learning en de kernbibliotheek van open source helpt u bij het ontwikkelen en trainen van ML-modellen.
Wat is beeldclassificatie?
De bedoeling van afbeeldingsclassificatie is om alle pixels in een digitale afbeelding in een van meerdere te categoriseren landbedekking klassen of thema's . Deze gecategoriseerde gegevens kunnen vervolgens worden gebruikt om te produceren thematische kaarten van de landbedekking aanwezig in een afbeelding.
Nu Afhankelijk van de interactie tussen de analist en de computer tijdens de classificatie, zijn er twee soorten classificatie:
- Begeleid &
- Ongecontroleerd
Dus, zonder tijd te verspillen, gaan we naar TensorFlow Image Classification. Ik heb 2 voorbeelden: gemakkelijk en moeilijk. Laten we doorgaan met de gemakkelijke.
TensorFlow-beeldclassificatie: Fashion MNIST
Mode MNIST-gegevensset
Hier gaan we Fashion MNIST Dataset gebruiken, die 70.000 grijswaardenafbeeldingen in 10 categorieën bevat. We zullen 60000 gebruiken voor training en de rest 10000 voor testdoeleinden. U hebt rechtstreeks vanuit TensorFlow toegang tot de Fashion MNIST, u hoeft alleen maar de gegevens te importeren en te laden.
- Laten we eerst de bibliotheken importeren
uit __future__ import absolute_import, divisie, print_function # TensorFlow en tf.keras import tensorflow als tf uit tensorflow import keras # Helper bibliotheken import numpy als np import matplotlib.pyplot als plt
- Laten we de gegevens laden
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
- Vervolgens gaan we de afbeeldingen in klassen indelen
class_names = ['T-shirt / top', 'Broek', 'Trui', 'Jurk', 'Jas', 'Sandaal', 'Shirt', 'Sneaker', 'Tas', 'Enkellaarsje']
- Verkennen van de gegevens
treinbeelden.vorm
#Elk label is tussen 0-9
train_labels
test_afbeeldingen.vorm
- Nu is het tijd om de gegevens voor te verwerken.
plt.figuur() plt.imshow(treinbeelden[0]) plt.kleuren balk() plt.rooster(Vals) plt.tonen()
#Als je de eerste afbeelding in de trainingsset bekijkt, zie je dat de pixelwaarden in het bereik van 0 tot 255 vallen.
- We moeten de afbeeldingen schalen van 0-1 om ze in het neurale netwerk te brengen
treinbeelden = treinbeelden / 255,0 test_afbeeldingen = test_afbeeldingen / 255,0
- Laten we wat afbeeldingen laten zien.
plt.figuur(vijgenmaat=(10,10)) voor ik in bereik(25): plt.subplot(5,5,ik+een) plt.xticks([]) plt.yticks([]) plt.rooster(Vals) plt.imshow(treinbeelden[ik], cmap=plt.cm.binair) plt.xlabel(class_names[train_labels[ik]]) plt.tonen()
- Stel de lagen in
model- = moeilijk.Sequentieel([ moeilijk.lagen.Afvlakken(input_shape=(28, 28)), moeilijk.lagen.Dicht(128, activering=tf.nrs.relu), moeilijk.lagen.Dicht(10, activering=tf.nrs.softmax) ])
- Compileer het model
model-.compileren(optimizer='Adam', verlies='sparse_categorical_crossentropy', statistieken=['nauwkeurigheid'])
- Model opleiding
model-.passen(treinbeelden, train_labels, tijdperken=10)
wat is methode-overbelasting en methode-overschrijving
- Nauwkeurigheid evalueren
test_loss, test_acc = model-.evalueren(test_afbeeldingen, test_labels) afdrukken('Test nauwkeurigheid:', test_acc)
- Voorspellingen doen
voorspellingen = model-.voorspellen(test_afbeeldingen)
voorspellingen[0]
Een voorspelling is een reeks van 10 getallen. Deze beschrijven het 'vertrouwen' van het model dat de afbeelding overeenkomt met elk van de 10 verschillende kledingstukken. We kunnen zien welk label de hoogste betrouwbaarheidswaarde heeft.
bijv..argmax(voorspellingen[0])#Model is er het meest zeker van dat het een enkellaars is. Eens kijken of het kloptUitgang: 9
test_labels[0]
Uitgang: 9
- Nu is het tijd om de volledige set van 10 kanalen te bekijken
def plot_image(ik, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[ik], true_label[ik], img[ik] plt.rooster(Vals) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binair) voorspelde_label = bijv..argmax(predictions_array) als voorspelde_label == true_label: kleur = 'groen' anders: kleur = 'netto' plt.xlabel('{} {: 2.0f}% ({}) '.formaat(class_names[voorspelde_label], 100*bijv..max. hoogte(predictions_array), class_names[true_label]), kleur=kleur) def plot_value_array(ik, predictions_array, true_label): predictions_array, true_label = predictions_array[ik], true_label[ik] plt.rooster(Vals) plt.xticks([]) plt.yticks([]) dit plot = plt.bar(bereik(10), predictions_array, kleur='# 777777') plt.ylim([0, een]) voorspelde_label = bijv..argmax(predictions_array) dit plot[voorspelde_label].set_color('netto') dit plot[true_label].set_color('groen')
- Laten we eerst naar de 0e en 10e afbeelding kijken
ik = 0 plt.figuur(vijgenmaat=(6,3)) plt.subplot(een,2,een) plot_image(ik, voorspellingen, test_labels, test_afbeeldingen) plt.subplot(een,2,2) plot_value_array(ik, voorspellingen, test_labels) plt.tonen()
ik = 10 plt.figuur(vijgenmaat=(6,3)) plt.subplot(een,2,een) plot_image(ik, voorspellingen, test_labels, test_afbeeldingen) plt.subplot(een,2,2) plot_value_array(ik, voorspellingen, test_labels) plt.tonen()
- Laten we nu verschillende afbeeldingen en hun voorspellingen uitzetten. De juiste zijn groen, terwijl de verkeerde rood zijn.
num_rows = 5 aantal_cols = 3 aantal_afbeeldingen = num_rows*aantal_cols plt.figuur(vijgenmaat=(2*2*aantal_cols, 2*num_rows)) voor ik in bereik(aantal_afbeeldingen): plt.subplot(num_rows, 2*aantal_cols, 2*ik+een) plot_image(ik, voorspellingen, test_labels, test_afbeeldingen) plt.subplot(num_rows, 2*aantal_cols, 2*ik+2) plot_value_array(ik, voorspellingen, test_labels) plt.tonen()
- Ten slotte zullen we het getrainde model gebruiken om een voorspelling te doen over een enkele afbeelding.
# Pak een afbeelding uit de testdataset img = test_afbeeldingen[0] afdrukken(img.vorm)
# Voeg de afbeelding toe aan een batch waar het het enige lid is. img = (bijv..expand_dims(img,0)) afdrukken(img.vorm)
predictions_single = model-.voorspellen(img) afdrukken(predictions_single)plot_value_array(0, predictions_single, test_labels) plt.xticks(bereik(10), class_names, rotatie=Vier vijf) plt.tonen()
prediction_result = bijv..argmax(predictions_single[0])
Uitgang: 9
CIFAR-10: CNN
hoe je een parameter maakt in tableau
De CIFAR-10-dataset bestaat uit vliegtuigen, honden, katten en andere objecten. Je gaat de beelden voorbewerken en vervolgens een convolutioneel neuraal netwerk trainen op alle monsters. De afbeeldingen moeten worden genormaliseerd en de labels moeten one-hot-gecodeerd worden. Deze use-case zal uw twijfels over TensorFlow Image Classification zeker wegnemen.
- De gegevens downloaden
van urllib.request importeren urlretrieve van os.path importeren isfile, is roet van tqdm importeren tqdm importeren tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' klasse DownloadVoortgang(tqdm): last_block = 0 def haak(zelf, blok_getal=een, block_size=een, totale grootte=Geen): zelf.totaal = totale grootte zelf.bijwerken((blok_getal - zelf.last_block) * block_size) zelf.last_block = blok_getal '' ' controleer of het data (zip) bestand al is gedownload zo niet, download het dan van 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' en sla het op als cifar-10-python.tar.gz '' ' als niet isfile('cifar-10-python.tar.gz'): met DownloadVoortgang(eenheid='B', unit_scale=Klopt, miniters=een, aflop='CIFAR-10-gegevensset') net zo pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.haak) als niet is roet(cifar10_dataset_folder_path): met tarfile.Open('cifar-10-python.tar.gz') net zo teer: teer.extraheren() teer.dichtbij()
- Noodzakelijke bibliotheken importeren
importeren augurk importeren numpy net zo bijv. importeren matplotlib.pyplot net zo plt
- Inzicht in de gegevens
De oorspronkelijke batch met gegevens is een tensor van 10.000 × 3072 uitgedrukt in een numpy-array, waarbij 10000 het aantal voorbeeldgegevens is. De afbeelding is gekleurd en heeft een afmeting van 32 × 32. Het voeren kan worden gedaan in de indeling (breedte x hoogte x aantal_kanaal) of (aantal_kanaal x breedte x hoogte). Laten we de labels definiëren.
def load_label_names(): terugkeer ['vliegtuig', 'auto', 'vogel', 'kat', 'hert', 'hond', 'kikker', 'paard', 'schip', 'vrachtwagen']
- De gegevens opnieuw vormgeven
We gaan de gegevens in twee fasen hervormen
Verdeel eerst de rijvector (3072) in 3 stukken. Elk stuk komt overeen met elk kanaal. Dit resulteert in (3 x 1024) afmeting van een tensor. Verdeel vervolgens de resulterende tensor uit de vorige stap met 32. 32 betekent hier de breedte van een afbeelding. Dit resulteert in (3x32x32).
Ten tweede moeten we de gegevens transponeren van (aantal_kanaal, breedte, hoogte) naar (breedte, hoogte, aantal_kanaal). Daarvoor gaan we de transponeerfunctie gebruiken.
def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): met Open(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), modus='rb') net zo het dossier: # let op het coderingstype is 'latin1' partij = augurk.laden(het dossier, codering='latijn1') Kenmerken = partij['gegevens'].hervormen((len(partij['gegevens']), 3, 32, 32)).transponeren(0, 2, 3, een) etiketten = partij['labels'] terugkeer Kenmerken, label
- De gegevens onderzoeken
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Kenmerken, etiketten = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) als niet (0 <= sample_id < len(Kenmerken)): afdrukken('{}monsters in batch{}.{}is buiten bereik. '.formaat(len(Kenmerken), batch_id, sample_id)) terugkeer Geen afdrukken(' Statistieken van batch #{}: '.formaat(batch_id)) afdrukken('Aantal voorbeelden:{} '.formaat(len(Kenmerken))) labelnamen = load_label_names() label_counts = dict(zip(*bijv..uniek(etiketten, return_counts=Klopt))) voor sleutel, waarde in label_counts.artikelen(): afdrukken('Labeltellingen van [{}] ({}):{}'.formaat(sleutel, labelnamen[sleutel].bovenste(), waarde)) sample_image = Kenmerken[sample_id] sample_label = etiketten[sample_id] afdrukken(' Voorbeeld van afbeelding{}: '.formaat(sample_id)) afdrukken('Afbeelding - Min. Waarde:{}Maximum waarde:{}'.formaat(sample_image.min(), sample_image.max. hoogte())) afdrukken('Afbeelding - Vorm:{}'.formaat(sample_image.vorm)) afdrukken('Label - Label-ID:{}Naam:{}'.formaat(sample_label, labelnamen[sample_label])) plt.imshow(sample_image)
%matplotlib in lijn %config InlineBackend.figure_format = 'netvlies' importeren numpy net zo bijv. # Verken de dataset batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)
js krijgen de lengte van de array
- Implementeren van voorverwerkingsfuncties
We gaan de gegevens normaliseren via Min-Max-normalisatie. Dit zorgt ervoor dat alle x-waarden tussen 0 en 1 liggen.
y = (x-min) / (max-min)
def normaliseren(X): '' ' argument - x: invoer afbeeldingsgegevens in numpy array [32, 32, 3] terugkeer - genormaliseerd x '' ' min_val = bijv..min(X) max_val = bijv..max. hoogte(X) X = (X-min_val) / (max_val-min_val) terugkeer X
- One-Hot Encode
def one_hot_encode(X): '' ' argument - x: een lijst met labels terugkeer - één hot-coderingsmatrix (aantal labels, aantal klassen) '' ' gecodeerd = bijv..nullen((len(X), 10)) voor idx, uur in opsommen(X): gecodeerd[idx] [uur] = een terugkeer gecodeerd
- Verwerk de gegevens voor en sla ze op
def _preprocess_and_save(normaliseren, one_hot_encode, Kenmerken, etiketten, bestandsnaam): Kenmerken = normaliseren(Kenmerken) etiketten = one_hot_encode(etiketten) augurk.dump((Kenmerken, etiketten), Open(bestandsnaam, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normaliseren, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] voor batch_i in bereik(een, n_batches + een): Kenmerken, etiketten = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # vind index als punt als validatiegegevens in de hele dataset van de batch (10%) index_of_validation = int(len(Kenmerken) * 0.1) # verwerk de 90% van de hele dataset van de batch voor # - normaliseer de functies # - one_hot_encode de labels # - opslaan in een nieuw bestand genaamd 'preprocess_batch_' + batch_number # - elk bestand voor elke batch _preprocess_and_save(normaliseren, one_hot_encode, Kenmerken[:-index_of_validation], etiketten[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # in tegenstelling tot de trainingsdataset, wordt validatiedataset toegevoegd via alle batchdatasets # - neem 10% van de volledige dataset van de batch # - voeg ze toe aan een lijst met # - valid_features # - valid_labels valid_features.uitbreiden(Kenmerken[-index_of_validation:]) valid_labels.uitbreiden(etiketten[-index_of_validation:]) # Verwerk de volledig gestapelde validatiedataset voor _preprocess_and_save(normaliseren, one_hot_encode, bijv..array(valid_features), bijv..array(valid_labels), 'preprocess_validation.p') # laad de testdataset met Open(cifar10_dataset_folder_path + '/ test_batch', modus='rb') net zo het dossier: partij = augurk.laden(het dossier, codering='latijn1') # Verwerk de testgegevens voor test_features = partij['gegevens'].hervormen((len(partij['gegevens']), 3, 32, 32)).transponeren(0, 2, 3, een) test_labels = partij['labels'] # Verwerk en bewaar alle testgegevens _preprocess_and_save(normaliseren, one_hot_encode, bijv..array(test_features), bijv..array(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normaliseren, one_hot_encode)
- IJkpunt
importeren augurk valid_features, valid_labels = augurk.laden(Open('preprocess_validation.p', modus='rb'))
- Het netwerk opbouwen
Het gehele model bestaat in totaal uit 14 lagen.
importeren tensorflow net zo tf def conv_net(X, keep_prob): conv1_filter = tf.Variabel(tf.truncated_normal(vorm=[3, 3, 3, 64], gemeen=0, stddev=0,08)) conv2_filter = tf.Variabel(tf.truncated_normal(vorm=[3, 3, 64, 128], gemeen=0, stddev=0,08)) conv3_filter = tf.Variabel(tf.truncated_normal(vorm=[5, 5, 128, 256], gemeen=0, stddev=0,08)) conv4_filter = tf.Variabel(tf.truncated_normal(vorm=[5, 5, 256, 512], gemeen=0, stddev=0,08)) # 1, 2 conv1 = tf.nrs.conv2d(X, conv1_filter, stappen=[een,een,een,een], opvulling='DEZELFDE') conv1 = tf.nrs.relu(conv1) conv1_pool = tf.nrs.max_pool(conv1, ksize=[een,2,2,een], stappen=[een,2,2,een], opvulling='DEZELFDE') conv1_bn = tf.lagen.batch_normalisatie(conv1_pool) # 3. 4 conv2 = tf.nrs.conv2d(conv1_bn, conv2_filter, stappen=[een,een,een,een], opvulling='DEZELFDE') conv2 = tf.nrs.relu(conv2) conv2_pool = tf.nrs.max_pool(conv2, ksize=[een,2,2,een], stappen=[een,2,2,een], opvulling='DEZELFDE') conv2_bn = tf.lagen.batch_normalisatie(conv2_pool) # 5, 6 conv3 = tf.nrs.conv2d(conv2_bn, conv3_filter, stappen=[een,een,een,een], opvulling='DEZELFDE') conv3 = tf.nrs.relu(conv3) conv3_pool = tf.nrs.max_pool(conv3, ksize=[een,2,2,een], stappen=[een,2,2,een], opvulling='DEZELFDE') conv3_bn = tf.lagen.batch_normalisatie(conv3_pool) # 7, 8 conv4 = tf.nrs.conv2d(conv3_bn, conv4_filter, stappen=[een,een,een,een], opvulling='DEZELFDE') conv4 = tf.nrs.relu(conv4) conv4_pool = tf.nrs.max_pool(conv4, ksize=[een,2,2,een], stappen=[een,2,2,een], opvulling='DEZELFDE') conv4_bn = tf.lagen.batch_normalisatie(conv4_pool) # 9 vlak = tf.bijdragen.lagen.afvlakken(conv4_bn) # 10 vol1 = tf.bijdragen.lagen.volledig_verbonden(ingangen=vlak, aantal_outputs=128, activatie_fn=tf.nrs.relu) vol1 = tf.nrs.afvaller(vol1, keep_prob) vol1 = tf.lagen.batch_normalisatie(vol1) # elf vol2 = tf.bijdragen.lagen.volledig_verbonden(ingangen=vol1, aantal_outputs=256, activatie_fn=tf.nrs.relu) vol2 = tf.nrs.afvaller(vol2, keep_prob) vol2 = tf.lagen.batch_normalisatie(vol2) # 12 vol3 = tf.bijdragen.lagen.volledig_verbonden(ingangen=vol2, aantal_outputs=512, activatie_fn=tf.nrs.relu) vol3 = tf.nrs.afvaller(vol3, keep_prob) vol3 = tf.lagen.batch_normalisatie(vol3) # 13 volledig4 = tf.bijdragen.lagen.volledig_verbonden(ingangen=vol3, aantal_outputs=1024, activatie_fn=tf.nrs.relu) volledig4 = tf.nrs.afvaller(volledig4, keep_prob) volledig4 = tf.lagen.batch_normalisatie(volledig4) # 14 uit = tf.bijdragen.lagen.volledig_verbonden(ingangen=vol3, aantal_outputs=10, activatie_fn=Geen) terugkeer uit
- Hyperparameters
tijdperken = 10 seriegrootte = 128 keep_probability = 0,7 learning_rate = 0,001
logits = conv_net(X, keep_prob) model- = tf.identiteit(logits, naam='logits') # Naam logt Tensor, zodat die na de training van schijf kan worden geladen # Verlies en optimalisatie kosten = tf.reduce_mean(tf.nrs.softmax_cross_entropy_with_logits(logits=logits, etiketten=Y)) optimizer = tf.trein.AdamOptimizer(learning_rate=learning_rate).minimaliseren(kosten) # Nauwkeurigheid correct_pred = tf.Gelijk(tf.argmax(logits, een), tf.argmax(Y, een)) nauwkeurigheid = tf.reduce_mean(tf.gips(correct_pred, tf.float32), naam='nauwkeurigheid')
- Train het neurale netwerk
# Enkele optimalisatie
def train_neural_network(sessie, optimizer, keep_probability, feature_batch, label_batch): sessie.rennen(optimizer, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: keep_probability })
# Statistieken weergeven def print_stats(sessie, feature_batch, label_batch, kosten, nauwkeurigheid): verlies = sess.rennen(kosten, feed_dict={ X: feature_batch, Y: label_batch, keep_prob: een. }) valid_acc = sess.rennen(nauwkeurigheid, feed_dict={ X: valid_features, Y: valid_labels, keep_prob: een. }) afdrukken('Verlies:{:> 10.4f}Validatie nauwkeurigheid:{: .6f}'.formaat(verlies, valid_acc))
- Het model volledig trainen en opslaan
def batch_features_labels(Kenmerken, etiketten, seriegrootte): '' ' Splits functies en labels in batches '' ' voor begin in bereik(0, len(Kenmerken), seriegrootte): einde = min(begin + seriegrootte, len(Kenmerken)) opbrengst Kenmerken[begin:einde], etiketten[begin:einde] def load_preprocess_training_batch(batch_id, seriegrootte): '' ' Laad de voorverwerkte trainingsgegevens en retourneer ze in batches van of minder '' ' bestandsnaam = 'preprocess_batch_' + p(batch_id) + '.p' Kenmerken, etiketten = augurk.laden(Open(bestandsnaam, modus='rb')) # Retourneer de trainingsgegevens in batches van grootte of minder terugkeer batch_features_labels(Kenmerken, etiketten, seriegrootte)
#Saving model en pad
save_model_path = './image_classification' afdrukken('Opleiding...') met tf.Sessie() net zo sess: # Initialiseren van de variabelen sess.rennen(tf.global_variables_initializer()) # Trainingscyclus voor tijdperk in bereik(tijdperken): # Loop door alle batches n_batches = 5 voor batch_i in bereik(een, n_batches + een): voor batch_features, batch_labels in load_preprocess_training_batch(batch_i, seriegrootte): train_neural_network(sess, optimizer, keep_probability, batch_features, batch_labels) afdrukken('Tijdperk{:> 2}, CIFAR-10 Batch{}: '.formaat(tijdperk + een, batch_i), einde='') print_stats(sess, batch_features, batch_labels, kosten, nauwkeurigheid) # Model opslaan spaarder = tf.trein.Saver() save_path = spaarder.sparen(sess, save_model_path)
Nu is het belangrijke deel van Tensorflow Image Classification voltooid. Nu is het tijd om het model te testen.
- Het model testen
importeren augurk importeren numpy net zo bijv. importeren matplotlib.pyplot net zo plt van sklearn.preprocessing importeren LabelBinarizer def batch_features_labels(Kenmerken, etiketten, seriegrootte): '' ' Splits functies en labels in batches '' ' voor begin in bereik(0, len(Kenmerken), seriegrootte): einde = min(begin + seriegrootte, len(Kenmerken)) opbrengst Kenmerken[begin:einde], etiketten[begin:einde] def display_image_predictions(Kenmerken, etiketten, voorspellingen, top_n_predictions): n_classes = 10 labelnamen = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.passen(bereik(n_classes)) label_ids = label_binarizer.inverse_transform(bijv..array(etiketten)) fig, assen = plt.subplots(nrows=top_n_predictions, ncols=2, vijgenmaat=(twintig, 10)) fig.tight_layout() fig.suptitle('Softmax-voorspellingen', lettertypegrootte=twintig, Y=1.1) n_voorspellingen = 3 marge = 0,05 ind = bijv..regelen(n_voorspellingen) breedte = (een. - 2. * marge) / n_voorspellingen voor image_i, (voorzien zijn van, label_id, pred_indicies, pred_values) in opsommen(zip(Kenmerken, label_ids, voorspellingen.indices, voorspellingen.waarden)): als (image_i < top_n_predictions): pred_names = [labelnamen[pred_i] voor pred_i in pred_indicies] correcte naam = labelnamen[label_id] assen[image_i] [0].imshow((voorzien zijn van*255).astype(bijv..int32, kopiëren=Vals)) assen[image_i] [0].set_title(correcte naam) assen[image_i] [0].set_axis_off() assen[image_i] [een].barh(ind + marge, pred_values[:3], breedte) assen[image_i] [een].set_yticks(ind + marge) assen[image_i] [een].set_yticklabels(pred_names[::-een]) assen[image_i] [een].set_xticks([0, 0,5, 1.0])
%matplotlib in lijn %config InlineBackend.figure_format = 'netvlies' importeren tensorflow net zo tf importeren augurk importeren willekeurig save_model_path = './image_classification' seriegrootte = 64 n_samples = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = augurk.laden(Open('preprocess_training.p', modus='rb')) geladen_grafiek = tf.Grafiek() met tf.Sessie(grafiek=geladen_grafiek) net zo sess: # Model laden lader = tf.trein.import_meta_graph(save_model_path + '.meta') lader.herstellen(sess, save_model_path) # Haal tensoren uit het geladen model geladen_x = geladen_grafiek.get_tensor_by_name('input_x: 0') geladen_y = geladen_grafiek.get_tensor_by_name('output_y: 0') geladen_keep_prob = geladen_grafiek.get_tensor_by_name('keep_prob: 0') geladen_logits = geladen_grafiek.get_tensor_by_name('logits: 0') geladen_acc = geladen_grafiek.get_tensor_by_name('nauwkeurigheid: 0') # Verkrijg nauwkeurigheid in batches voor geheugenbeperkingen test_batch_acc_total = 0 test_batch_count = 0 voor train_feature_batch, train_label_batch in batch_features_labels(test_features, test_labels, seriegrootte): test_batch_acc_total + = sess.rennen( geladen_acc, feed_dict={geladen_x: train_feature_batch, geladen_y: train_label_batch, geladen_keep_prob: 1.0}) test_batch_count + = een afdrukken(Nauwkeurigheid testen:{} '.formaat(test_batch_acc_total/test_batch_count)) # Willekeurige voorbeelden afdrukken random_test_features, random_test_labels = tupel(zip(*willekeurig.monster(lijst(zip(test_features, test_labels)), n_samples))) random_test_predictions = sess.rennen( tf.nrs.top_k(tf.nrs.softmax(geladen_logits), top_n_predictions), feed_dict={geladen_x: random_test_features, geladen_y: random_test_labels, geladen_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()
Uitgang: Nauwkeurigheid testen: 0,5882762738853503
Als u nu uw neurale netwerk voor meer tijdvakken traint of de activeringsfunctie wijzigt, krijgt u mogelijk een ander resultaat met mogelijk een betere nauwkeurigheid.
Hiermee komen we dus aan het einde van dit TensorFlow Image Classification-artikel. Ik weet zeker dat je hetzelfde nu kunt gebruiken om elk soort afbeeldingen te classificeren en dat je geen beginner bent in het classificeren van afbeeldingen.
Edureka's met Python Certification Training wordt samengesteld door professionals uit de industrie volgens de vereisten en eisen van de branche. Je beheerst de concepten zoals SoftMax-functie, Autoencoder Neural Networks, Restricted Boltzmann Machine (RBM), Keras & TFLearn. De cursus is speciaal samengesteld door experts uit de industrie met real-time casestudy's.