Classification d'image TensorFlow: tout ce que vous devez savoir sur les classificateurs de bâtiments

Cet article sur la classification des images TensorFlow vous fournira une connaissance détaillée et complète de la classification des images.

Classification des images une tâche que même un bébé peut faire en quelques secondes, mais pour une machine, cela a été une tâche difficile jusqu'aux récents progrès et L'apprentissage en profondeur . Les voitures autonomes peuvent détecter des objets et prendre les mesures nécessaires en temps réel, ce qui est en grande partie possible grâce à Classification des images. Dans cet article, je vais vous guider à travers les sujets suivants:



Qu'est-ce que TensorFlow?

TensorFlow est le cadre d'apprentissage automatique Open Source de Google pour la programmation de flux de données sur une gamme de tâches. Les nœuds du graphique représentent des opérations mathématiques, tandis que les bords du graphique représentent les tableaux de données multidimensionnels communiqués entre eux.



TensorFlow-Image-Recognition
Les tenseurs ne sont que des tableaux multidimensionnels, une extension des tables à 2 dimensions aux données de dimension supérieure. Il existe de nombreuses fonctionnalités de Tensorflow qui le rendent approprié pour le Deep Learning et sa bibliothèque open source principale vous aide à développer et à entraîner des modèles ML.

Qu'est-ce que la classification d'images?

Le but de la classification d'image est de classer tous les pixels d'une image numérique dans l'un de plusieurs couverture terrestre Des classes ou thèmes . Ces données catégorisées peuvent ensuite être utilisées pour produire cartes thématiques de la couverture terrestre présente dans une image.



Maintenant En fonction de l'interaction entre l'analyste et l'ordinateur lors de la classification, il existe deux types de classification:



  • Supervisé &
  • Non supervisé

Alors, sans perdre de temps, passons à la classification d'images TensorFlow. J'ai 2 exemples: facile et difficile. Continuons avec le plus facile.

Classification d'image TensorFlow: Mode MNIST

Ensemble de données Fashion MNIST

Ici, nous allons utiliser Fashion MNIST Dataset, qui contient 70 000 images en niveaux de gris dans 10 catégories. Nous utiliserons 60000 pour la formation et le reste 10000 à des fins de test. Vous pouvez accéder au Fashion MNIST directement à partir de TensorFlow, il suffit d'importer et de charger les données.

  • Importons d'abord les bibliothèques
from __future__ import absolute_import, division, print_function # TensorFlow et tf.keras importent tensorflow comme tf depuis tensorflow import keras # Les bibliothèques d'assistance importent numpy comme np import matplotlib.pyplot comme plt
  • Chargeons les données
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
  • Ensuite, nous allons mapper les images en classes
class_names = ['T-shirt / top', 'Pantalon', 'Pull-over', 'Robe', 'Manteau', 'Sandale', 'Chemise', 'Sneaker', 'Sac', 'Bottines']
  • Explorer les données
train_images.forme 
#Chaque étiquette est comprise entre 0 et 9
train_labels 
test_images.forme
  • Il est maintenant temps de prétraiter les données.
plt.figure() plt.imshow(train_images[0]) plt.barre de couleur() plt.la grille(Faux) plt.montrer() 
#Si vous inspectez la première image de l'ensemble d'apprentissage, vous verrez que les valeurs de pixel sont comprises entre 0 et 255.

  • Nous devons mettre les images à l'échelle de 0 à 1 pour les alimenter dans le réseau neuronal
train_images = train_images / 255,0 test_images = test_images / 255,0
  • Montrons quelques images.
plt.figure(figue=(dix,dix)) pour je dans gamme(25): plt.sous-tracé(5,5,je+un) plt.xticks([]) plt.yticks([]) plt.la grille(Faux) plt.imshow(train_images[je], cmap=plt.cm.binaire) plt.xlabel(noms_classe[train_labels[je]]) plt.montrer()
 

  • Configurer les couches
modèle = dur.Séquentiel([ dur.couches.Aplatir(input_shape=(28, 28)), dur.couches.Dense(128, Activation=tf.nos.relu), dur.couches.Dense(dix, Activation=tf.nos.softmax) ])
  • Compilez le modèle
modèle.compiler(optimiseur='Adam', perte='sparse_categorical_crossentropy', métrique=['précision'])
  • Formation modèle
modèle.en forme(train_images, train_labels, époques=dix)

  • Évaluation de la précision
test_loss, test_acc = modèle.évaluer(test_images, test_labels) impression(«Exactitude du test:», test_acc)

  • Faire des prédictions
prédictions = modèle.prédire(test_images)
prédictions[0]

Une prédiction est un tableau de 10 nombres. Celles-ci décrivent la «confiance» du modèle que l'image correspond à chacun des 10 vêtements différents. Nous pouvons voir quelle étiquette a la valeur de confiance la plus élevée.

par exemple..argmax(prédictions[0])#Model est le plus convaincu qu'il s'agit d'une bottine. Voyons si c'est correct

Sortie: 9

test_labels[0]

Sortie: 9

  • Maintenant, il est temps de regarder l'ensemble complet des 10 chaînes
def plot_image(je, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[je], true_label[je], img[je] plt.la grille(Faux) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binaire) prédite_label = par exemple..argmax(predictions_array) si prédite_label == true_label: Couleur = 'vert' autre: Couleur = 'net' plt.xlabel('{} {: 2.0f}% ({}) '.format(noms_classe[prédite_label], 100*par exemple..max(predictions_array), noms_classe[true_label]), Couleur=Couleur) def plot_value_array(je, predictions_array, true_label): predictions_array, true_label = predictions_array[je], true_label[je] plt.la grille(Faux) plt.xticks([]) plt.yticks([]) cette intrigue = plt.bar(gamme(dix), predictions_array, Couleur=«# 777777») plt.ylim([0, un]) prédite_label = par exemple..argmax(predictions_array) cette intrigue[prédite_label].set_color('net') cette intrigue[true_label].set_color('vert')
  • Examinons d'abord la 0e et la 10e image
je = 0 plt.figure(figue=(6,3)) plt.sous-tracé(un,2,un) plot_image(je, prédictions, test_labels, test_images) plt.sous-tracé(un,2,2) plot_value_array(je, prédictions, test_labels) plt.montrer()

je = dix plt.figure(figue=(6,3)) plt.sous-tracé(un,2,un) plot_image(je, prédictions, test_labels, test_images) plt.sous-tracé(un,2,2) plot_value_array(je, prédictions, test_labels) plt.montrer()

  • Maintenant, traçons plusieurs images et leurs prédictions. Les bons sont verts, tandis que les incorrects sont rouges.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figure(figue=(2*2*num_cols, 2*num_rows)) pour je dans gamme(num_images): plt.sous-tracé(num_rows, 2*num_cols, 2*je+un) plot_image(je, prédictions, test_labels, test_images) plt.sous-tracé(num_rows, 2*num_cols, 2*je+2) plot_value_array(je, prédictions, test_labels) plt.montrer()

  • Enfin, nous utiliserons le modèle entraîné pour faire une prédiction sur une seule image.
# Récupérer une image de l'ensemble de données de test img = test_images[0] impression(img.forme)
# Ajouter l'image à un lot dont c'est le seul membre. img = (par exemple..expand_dims(img,0)) impression(img.forme)
predictions_single = modèle.prédire(img) impression(predictions_single)

plot_value_array(0, predictions_single, test_labels) plt.xticks(gamme(dix), noms_classe, rotation=Quatre cinq) plt.montrer()

  • Comme vous pouvez le voir la prédiction pour notre seule image en lot.
prediction_result = par exemple..argmax(predictions_single[0])

Sortie: 9

CIFAR-10: CNN

Le jeu de données CIFAR-10 comprend des avions, des chiens, des chats et d'autres objets. Vous prétraitez les images, puis entraînez un réseau neuronal convolutif sur tous les échantillons. Les images doivent être normalisées et les étiquettes doivent être encodées à chaud. Ce cas d'utilisation dissipera sûrement vos doutes sur la classification d'image TensorFlow.

  • Téléchargement des données
de urllib.request importer urlretrieve de os.path importer isfile, est de la suie de tqdm importer tqdm importer tarfile cifar10_dataset_folder_path = 'cifar-10-lots-py' classe Téléchargement(tqdm): dernier_bloc = 0 def crochet(soi, block_num=un, taille de bloc=un, taille totale=Aucun): soi.total = taille totale soi.mise à jour((block_num - soi.dernier_bloc) * taille de bloc) soi.dernier_bloc = block_num '' ' vérifier si le fichier de données (zip) est déjà téléchargé sinon, téléchargez-le sur 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' et enregistrez-le sous cifar-10-python.tar.gz '' ' si ne pas isfile(«cifar-10-python.tar.gz»): avec Téléchargement(unité=«B», unit_scale=Vrai, mineurs=un, desc=«Ensemble de données CIFAR-10») comme pbar: urlretrieve( «https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz», «cifar-10-python.tar.gz», pbar.crochet) si ne pas est de la suie(cifar10_dataset_folder_path): avec tarfile.ouvert(«cifar-10-python.tar.gz») comme le goudron: le goudron.extraire tout() le goudron.proche()
  • Importation des bibliothèques nécessaires
importer cornichon importer engourdi comme par exemple. importer matplotlib.pyplot comme plt
  • Comprendre les données

Le lot original de données est un tenseur de 10000 × 3072 exprimé dans un tableau numpy, où 10000 est le nombre d'échantillons de données. L'image est colorée et de taille 32 × 32. L'alimentation peut être effectuée soit dans un format de (largeur x hauteur x num_channel) ou (num_channel x largeur x hauteur). Définissons les étiquettes.

def load_label_names(): revenir ['avion', 'voiture', 'oiseau', 'chat', 'cerf', 'chien', 'grenouille', 'cheval', 'navire', 'un camion']
  • Remodeler les données

Nous allons remodeler les données en deux étapes

Commencez par diviser le vecteur de ligne (3072) en 3 morceaux. Chaque morceau correspond à chaque canal. Il en résulte une dimension (3 x 1024) d'un tenseur. Divisez ensuite le tenseur résultant de l'étape précédente par 32. 32 signifie ici la largeur d'une image. Cela donne (3x32x32).

Deuxièmement, nous devons transposer les données de (num_channel, width, height) à (width, height, num_channel). Pour cela, nous allons utiliser la fonction de transposition.

comment installer hadoop sur linux

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): avec ouvert(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), mode=«rb») comme fichier: # notez que le type d'encodage est 'latin1' lot = cornichon.charge(fichier, codage=«latin1») Caractéristiques = lot['Les données'].remodeler((len(lot['Les données']), 3, 32, 32)).transposer(0, 2, 3, un) Étiquettes = lot['Étiquettes'] revenir Caractéristiques, étiquette
  • Explorer les données
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): Caractéristiques, Étiquettes = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) si ne pas (0 <= sample_id < len(Caractéristiques)): impression('{}échantillons en lot{}.{}est hors de portée..format(len(Caractéristiques), batch_id, sample_id)) revenir Aucun impression(' Statistiques du lot #{}: '.format(batch_id)) impression('# d'échantillons:{} '.format(len(Caractéristiques))) label_names = load_label_names() label_counts = dict(Zip *: français(*par exemple..unique(Étiquettes, return_counts=Vrai))) pour clé, valeur dans label_counts.articles(): impression('Nombre d'étiquettes de [{}] ({}):{}'.format(clé, label_names[clé].plus haut(), valeur)) sample_image = Caractéristiques[sample_id] sample_label = Étiquettes[sample_id] impression(' Exemple d'image{}: '.format(sample_id)) impression('Image - Valeur minimale:{}Valeur max:{}'.format(sample_image.min(), sample_image.max())) impression('Image - Forme:{}'.format(sample_image.forme)) impression('Label - Identifiant d'étiquette:{}Nom:{}'.format(sample_label, label_names[sample_label])) plt.imshow(sample_image)
%matplotlib en ligne %config InlineBackend.figure_format = 'rétine' importer engourdi comme par exemple. # Explorer le jeu de données batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

  • Implémentation des fonctions de prétraitement

Nous allons normaliser les données via la normalisation Min-Max. Cela rend simplement toutes les valeurs x comprises entre 0 et 1.
y = (x-min) / (max-min)

def normaliser(X): '' ' argument - x: données d'image d'entrée dans le tableau numpy [32, 32, 3] revenir - normalisé x '' ' min_val = par exemple..min(X) max_val = par exemple..max(X) X = (X-min_val) / (max_val-min_val) revenir X
  • Encodage à chaud
def one_hot_encode(X): '' ' argument - x: une liste d'étiquettes revenir - une matrice d'encodage à chaud (nombre d'étiquettes, nombre de classe) '' ' encodé = par exemple..zéros((len(X), dix)) pour idx, heures dans énumérer(X): encodé[idx] [heures] = un revenir encodé
  • Prétraitez et enregistrez les données
def _preprocess_and_save(normaliser, one_hot_encode, Caractéristiques, Étiquettes, nom de fichier): Caractéristiques = normaliser(Caractéristiques) Étiquettes = one_hot_encode(Étiquettes) cornichon.déverser((Caractéristiques, Étiquettes), ouvert(nom de fichier, «wb»)) def preprocess_and_save_data(cifar10_dataset_folder_path, normaliser, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] pour batch_i dans gamme(un, n_batches + un): Caractéristiques, Étiquettes = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # find index pour être le point comme données de validation dans l'ensemble de données du lot (10%) index_of_validation = int(len(Caractéristiques) * 0,1) # prétraiter les 90% de l'ensemble de données du lot # - normaliser les fonctionnalités # - one_hot_encode les étiquettes # - enregistrer dans un nouveau fichier nommé, 'preprocess_batch_' + batch_number # - chaque fichier pour chaque lot _preprocess_and_save(normaliser, one_hot_encode, Caractéristiques[:-index_of_validation], Étiquettes[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + «.p») # contrairement à l'ensemble de données d'entraînement, l'ensemble de données de validation sera ajouté à l'ensemble de l'ensemble de données batch # - prendre 10% de l'ensemble de données whold du lot # - ajoutez-les dans une liste de # - valid_features # - valid_labels valid_features.étendre(Caractéristiques[-index_of_validation:]) valid_labels.étendre(Étiquettes[-index_of_validation:]) # prétraiter l'ensemble de données de validation empilé _preprocess_and_save(normaliser, one_hot_encode, par exemple..tableau(valid_features), par exemple..tableau(valid_labels), 'preprocess_validation.p') # charger le jeu de données de test avec ouvert(cifar10_dataset_folder_path + '/ test_batch', mode=«rb») comme fichier: lot = cornichon.charge(fichier, codage=«latin1») # prétraiter les données de test test_features = lot['Les données'].remodeler((len(lot['Les données']), 3, 32, 32)).transposer(0, 2, 3, un) test_labels = lot['Étiquettes'] # Prétraitez et enregistrez toutes les données de test _preprocess_and_save(normaliser, one_hot_encode, par exemple..tableau(test_features), par exemple..tableau(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normaliser, one_hot_encode)
  • Point de contrôle
importer cornichon valid_features, valid_labels = cornichon.charge(ouvert('preprocess_validation.p', mode=«rb»))
  • Construire le réseau

Le modèle entier se compose de 14 couches au total.

importer tensorflow comme tf def conv_net(X, keep_prob): conv1_filter = tf.Variable(tf.truncated_normal(forme=[3, 3, 3, 64], signifier=0, stddev=0,08)) conv2_filter = tf.Variable(tf.truncated_normal(forme=[3, 3, 64, 128], signifier=0, stddev=0,08)) conv3_filter = tf.Variable(tf.truncated_normal(forme=[5, 5, 128, 256], signifier=0, stddev=0,08)) conv4_filter = tf.Variable(tf.truncated_normal(forme=[5, 5, 256, 512], signifier=0, stddev=0,08)) # 1, 2 conv1 = tf.nos.conv2d(X, conv1_filter, enjambées=[un,un,un,un], rembourrage='MÊME') conv1 = tf.nos.relu(conv1) conv1_pool = tf.nos.max_pool(conv1, ksize=[un,2,2,un], enjambées=[un,2,2,un], rembourrage='MÊME') conv1_bn = tf.couches.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.nos.conv2d(conv1_bn, conv2_filter, enjambées=[un,un,un,un], rembourrage='MÊME') conv2 = tf.nos.relu(conv2) conv2_pool = tf.nos.max_pool(conv2, ksize=[un,2,2,un], enjambées=[un,2,2,un], rembourrage='MÊME') conv2_bn = tf.couches.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.nos.conv2d(conv2_bn, conv3_filter, enjambées=[un,un,un,un], rembourrage='MÊME') conv3 = tf.nos.relu(conv3) conv3_pool = tf.nos.max_pool(conv3, ksize=[un,2,2,un], enjambées=[un,2,2,un], rembourrage='MÊME') conv3_bn = tf.couches.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.nos.conv2d(conv3_bn, conv4_filter, enjambées=[un,un,un,un], rembourrage='MÊME') conv4 = tf.nos.relu(conv4) conv4_pool = tf.nos.max_pool(conv4, ksize=[un,2,2,un], enjambées=[un,2,2,un], rembourrage='MÊME') conv4_bn = tf.couches.batch_normalization(conv4_pool) # 9 plat = tf.contrib.couches.aplatir(conv4_bn) # dix plein1 = tf.contrib.couches.entièrement_connecté(contributions=plat, num_outputs=128, activation_fn=tf.nos.relu) plein1 = tf.nos.abandonner(plein1, keep_prob) plein1 = tf.couches.batch_normalization(plein1) # Onze plein2 = tf.contrib.couches.entièrement_connecté(contributions=plein1, num_outputs=256, activation_fn=tf.nos.relu) plein2 = tf.nos.abandonner(plein2, keep_prob) plein2 = tf.couches.batch_normalization(plein2) # 12 plein3 = tf.contrib.couches.entièrement_connecté(contributions=plein2, num_outputs=512, activation_fn=tf.nos.relu) plein3 = tf.nos.abandonner(plein3, keep_prob) plein3 = tf.couches.batch_normalization(plein3) # 13 plein4 = tf.contrib.couches.entièrement_connecté(contributions=plein3, num_outputs=1024, activation_fn=tf.nos.relu) plein4 = tf.nos.abandonner(plein4, keep_prob) plein4 = tf.couches.batch_normalization(plein4) # 14 en dehors = tf.contrib.couches.entièrement_connecté(contributions=plein3, num_outputs=dix, activation_fn=Aucun) revenir en dehors
  • Hyperparamètres
époques = dix taille du lot = 128 keep_probability = 0,7 taux d'apprentissage = 0,001
logits = conv_net(X, keep_prob) modèle = tf.identité(logits, Nom='logits') # Name logits Tensor, afin qu'il puisse être chargé à partir du disque après l'entraînement # Perte et optimiseur Coût = tf.réduire_moyenne(tf.nos.softmax_cross_entropy_with_logits(logits=logits, Étiquettes=Oui)) optimiseur = tf.train.AdamOptimizer(taux d'apprentissage=taux d'apprentissage).minimiser(Coût) # Précision correct_pred = tf.égal(tf.argmax(logits, un), tf.argmax(Oui, un)) précision = tf.réduire_moyenne(tf.jeter(correct_pred, tf.float32), Nom='précision')
  • Former le réseau neuronal
# Optimisation unique 
def
train_neural_network(session, optimiseur, keep_probability, feature_batch, label_batch): session.courir(optimiseur, feed_dict={ X: feature_batch, Oui: label_batch, keep_prob: keep_probability })
#Affichage des statistiques def print_stats(session, feature_batch, label_batch, Coût, précision): perte = sess.courir(Coût, feed_dict={ X: feature_batch, Oui: label_batch, keep_prob: un. }) valid_acc = sess.courir(précision, feed_dict={ X: valid_features, Oui: valid_labels, keep_prob: un. }) impression('Perte:{:> 10.4f}Précision de validation:{: .6f}'.format(perte, valid_acc))
  • Entraînement complet et enregistrement du modèle
def batch_features_labels(Caractéristiques, Étiquettes, taille du lot): '' ' Diviser les fonctionnalités et les étiquettes en lots '' ' pour début dans gamme(0, len(Caractéristiques), taille du lot): fin = min(début + taille du lot, len(Caractéristiques)) rendement Caractéristiques[début:fin], Étiquettes[début:fin] def load_preprocess_training_batch(batch_id, taille du lot): '' ' Chargez les données d'entraînement prétraitées et renvoyez-les par lots de ou moins '' ' nom de fichier = 'preprocess_batch_' + p(batch_id) + «.p» Caractéristiques, Étiquettes = cornichon.charge(ouvert(nom de fichier, mode=«rb»)) # Renvoie les données d'entraînement par lots de taille ou moins revenir batch_features_labels(Caractéristiques, Étiquettes, taille du lot)
#Saving Model and Path 
save_model_path
= './classification_image' impression('Formation...') avec tf.Session() comme sess: # Initialisation des variables sess.courir(tf.global_variables_initializer()) # Cycle de formation pour époque dans gamme(époques): # Boucle sur tous les lots n_batches = 5 pour batch_i dans gamme(un, n_batches + un): pour batch_features, batch_labels dans load_preprocess_training_batch(batch_i, taille du lot): train_neural_network(sess, optimiseur, keep_probability, batch_features, batch_labels) impression('Époque{:> 2}, Lot CIFAR-10{}: '.format(époque + un, batch_i), fin='') print_stats(sess, batch_features, batch_labels, Coût, précision) # Enregistrer le modèle épargnant = tf.train.Épargnant() Enregistrer le chemin = épargnant.enregistrer(sess, save_model_path)

Maintenant, la partie importante de la classification d'images Tensorflow est terminée. Il est maintenant temps de tester le modèle.

  • Tester le modèle
importer cornichon importer engourdi comme par exemple. importer matplotlib.pyplot comme plt de sklearn.preprocessing importer LabelBinarizer def batch_features_labels(Caractéristiques, Étiquettes, taille du lot): '' ' Diviser les fonctionnalités et les étiquettes en lots '' ' pour début dans gamme(0, len(Caractéristiques), taille du lot): fin = min(début + taille du lot, len(Caractéristiques)) rendement Caractéristiques[début:fin], Étiquettes[début:fin] def display_image_predictions(Caractéristiques, Étiquettes, prédictions, top_n_predictions): n_classes = dix label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.en forme(gamme(n_classes)) label_ids = label_binarizer.inverse_transform(par exemple..tableau(Étiquettes)) figure, axies = plt.sous-parcelles(nrows=top_n_predictions, ncols=2, figue=(vingt, dix)) figure.tight_layout() figure.sous-titre('Prédictions Softmax', taille de police=vingt, Oui=1.1) n_prédictions = 3 marge = 0,05 Indiana = par exemple..organiser(n_prédictions) largeur = (un. - 2. * marge) / n_prédictions pour image_i, (fonctionnalité, label_id, pred_indicies, pred_values) dans énumérer(Zip *: français(Caractéristiques, label_ids, prédictions.indices, prédictions.valeurs)): si (image_i < top_n_predictions): pred_names = [label_names[pred_i] pour pred_i dans pred_indicies] Nom correct = label_names[label_id] axies[image_i] [0].imshow((fonctionnalité*255).type(par exemple..int32, copie=Faux)) axies[image_i] [0].set_title(Nom correct) axies[image_i] [0].set_axis_off() axies[image_i] [un].barh(Indiana + marge, pred_values[:3], largeur) axies[image_i] [un].set_yticks(Indiana + marge) axies[image_i] [un].set_yticklabels(pred_names[::-un]) axies[image_i] [un].set_xticks([0, 0,5, 1.0])
%matplotlib en ligne %config InlineBackend.figure_format = 'rétine' importer tensorflow comme tf importer cornichon importer Aléatoire save_model_path = './classification_image' taille du lot = 64 n_samples = dix top_n_predictions = 5 def test_model(): test_features, test_labels = cornichon.charge(ouvert('preprocess_training.p', mode=«rb»)) chargé_graph = tf.Graphique() avec tf.Session(graphique=chargé_graph) comme sess: # Modèle de charge chargeur = tf.train.import_meta_graph(save_model_path + «.meta») chargeur.restaurer(sess, save_model_path) # Obtenir des tenseurs à partir du modèle chargé chargé_x = chargé_graph.get_tensor_by_name('input_x: 0') chargé_y = chargé_graph.get_tensor_by_name('output_y: 0') load_keep_prob = chargé_graph.get_tensor_by_name('keep_prob: 0') load_logits = chargé_graph.get_tensor_by_name('logits: 0') chargé_acc = chargé_graph.get_tensor_by_name('précision: 0') # Obtenez une précision dans les lots pour les limitations de mémoire test_batch_acc_total = 0 test_batch_count = 0 pour train_feature_batch, train_label_batch dans batch_features_labels(test_features, test_labels, taille du lot): test_batch_acc_total + = sess.courir( chargé_acc, feed_dict={chargé_x: train_feature_batch, chargé_y: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = un impression('Exactitude des tests:{} '.format(test_batch_acc_total/test_batch_count)) # Imprimer des échantillons aléatoires random_test_features, random_test_labels = tuple(Zip *: français(*Aléatoire.échantillon(liste(Zip *: français(test_features, test_labels)), n_samples))) random_test_predictions = sess.courir( tf.nos.top_k(tf.nos.softmax(load_logits), top_n_predictions), feed_dict={chargé_x: random_test_features, chargé_y: random_test_labels, load_keep_prob: 1.0}) display_image_predictions(random_test_features, random_test_labels, random_test_predictions, top_n_predictions) test_model()

Production: Exactitude des tests: 0,5882762738853503

Désormais, si vous entraînez votre réseau neuronal à plusieurs époques ou modifiez la fonction d'activation, vous pourriez obtenir un résultat différent qui pourrait avoir une meilleure précision.

Donc, avec cela, nous arrivons à la fin de cet article de classification d'image TensorFlow. Je suis sûr que vous pouvez maintenant utiliser la même chose pour classer n'importe quel type d'images et vous n'êtes pas un débutant dans la classification d'images.

Edureka avec Python Certification Training est organisée par des professionnels de l'industrie selon les exigences et les demandes de l'industrie. Vous maîtriserez les concepts tels que la fonction SoftMax, les réseaux de neurones Autoencoder, la machine Boltzmann restreinte (RBM), Keras et TFLearn. Le cours a été spécialement organisé par des experts de l'industrie avec des études de cas en temps réel.