Classificação de imagem do TensorFlow: tudo o que você precisa saber sobre a construção de classificadores

Este artigo de classificação de imagens do TensorFlow fornecerá a você um conhecimento detalhado e abrangente da classificação de imagens.

Classificação de imagens uma tarefa que até um bebê pode fazer em segundos, mas para uma máquina, tem sido uma tarefa difícil até os recentes avanços em e Aprendizado Profundo . Os carros que dirigem sozinhos podem detectar objetos e tomar as medidas necessárias em tempo real e muito disso é possível devido a Classificação de imagens. Neste artigo, vou guiá-lo pelos seguintes tópicos:

O que é TensorFlow?

TensorFlow é a estrutura de aprendizado de máquina de código aberto do Google para programação de fluxo de dados em uma série de tarefas. Os nós no gráfico representam operações matemáticas, enquanto as bordas do gráfico representam as matrizes de dados multidimensionais comunicadas entre eles.



TensorFlow-Image-Recognition
Tensores são apenas matrizes multidimensionais, uma extensão de tabelas bidimensionais para dados com uma dimensão superior. Existem muitos recursos do Tensorflow que o tornam apropriado para Deep Learning e sua biblioteca de código aberto central ajuda a desenvolver e treinar modelos de ML.

O que é classificação de imagens?

O objetivo da Classificação de Imagens é categorizar todos os pixels de uma imagem digital em um de vários cobertura da terra Aulas ou temas . Esses dados categorizados podem então ser usados ​​para produzir mapas temáticos da cobertura do solo presente em uma imagem.

Agora, dependendo da interação entre o analista e o computador durante a classificação, existem dois tipos de classificação:

  • Supervisionado e
  • Sem supervisão

Então, sem perder tempo, vamos pular para a classificação de imagens do TensorFlow. Tenho 2 exemplos: fácil e difícil. Vamos prosseguir com o mais fácil.

Classificação de imagem do TensorFlow: Fashion MNIST

Conjunto de dados Fashion MNIST

Aqui, usaremos o conjunto de dados Fashion MNIST, que contém 70.000 imagens em tons de cinza em 10 categorias. Usaremos 60.000 para treinamento e o restante 10.000 para fins de teste. Você pode acessar o Fashion MNIST diretamente do TensorFlow, basta importar e carregar os dados.

  • Vamos importar as bibliotecas primeiro
from __future__ import absolute_import, division, print_function # TensorFlow e tf.keras importam tensorflow como tf de tensorflow import keras # Bibliotecas auxiliares import numpy as np import matplotlib.pyplot as plt
  • Vamos carregar os dados
fashion_mnist = keras.datasets.fashion_mnist (train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data ()
  • A seguir, mapearemos as imagens em classes
class_names = ['Camiseta / top', 'Calça', 'Pulôver', 'Vestido', 'Casaco', 'Sandália', 'Camiseta', 'Tênis', 'Bolsa', 'Botins']
  • Explorando os dados
train_images.forma 
#Each Label está entre 0-9
train_labels 
test_images.forma
  • Agora é hora de pré-processar os dados.
plt.figura() plt.imshow(train_images[0]) plt.Barra de cor() plt.rede(Falso) plt.mostrar() 
#Se você inspecionar a primeira imagem no conjunto de treinamento, verá que os valores de pixel ficam na faixa de 0 a 255.

  • Temos que dimensionar as imagens de 0-1 para alimentá-las na Rede Neural
train_images = train_images / 255,0 test_images = test_images / 255,0
  • Vamos mostrar algumas imagens.
plt.figura(figsize=(10,10)) para Eu dentro alcance(25): plt.subtrama(5,5,Eu+1) plt.xticks([]) plt.yticks([]) plt.rede(Falso) plt.imshow(train_images[Eu], cmap=plt.cm.binário) plt.xlabel(class_names[train_labels[Eu]]) plt.mostrar()
 

  • Configure as camadas
modelo = Difícil.Sequencial([ Difícil.camadas.Flatten(input_shape=(28, 28)), Difícil.camadas.Denso(128, ativação=tf.nos.relu), Difícil.camadas.Denso(10, ativação=tf.nos.softmax) ])
  • Compile o modelo
modelo.compilar(otimizador='Adão', perda='sparse_categorical_crossentropy', Métricas=['precisão'])
  • Treinamento de modelo
modelo.em forma(train_images, train_labels, épocas=10)

  • Avaliando a precisão
test_loss, test_acc = modelo.Avalie(test_images, test_labels) impressão('Teste de precisão:', test_acc)

  • Fazendo previsões
previsões = modelo.prever(test_images)
previsões[0]

Uma previsão é uma matriz de 10 números. Descrevem a “confiança” da modelo de que a imagem corresponde a cada uma das 10 diferentes peças de roupa. Podemos ver qual rótulo tem o maior valor de confiança.

por exemplo..argmax(previsões[0])#Model tem mais certeza de que é uma bota de tornozelo. Vamos ver se está correto

Produto: 9

test_labels[0]

Produto: 9

  • Agora é hora de olhar para o conjunto completo de 10 canais
def plot_image(Eu, predictions_array, true_label, img): predictions_array, true_label, img = predictions_array[Eu], true_label[Eu], img[Eu] plt.rede(Falso) plt.xticks([]) plt.yticks([]) plt.imshow(img, cmap=plt.cm.binário) predicted_label = por exemplo..argmax(predictions_array) E se predicted_label == true_label: cor = 'verde' outro: cor = 'internet' plt.xlabel('{} {: 2.0f}% ({}) '.formato(class_names[predicted_label], 100*por exemplo..max(predictions_array), class_names[true_label]), cor=cor) def plot_value_array(Eu, predictions_array, true_label): predictions_array, true_label = predictions_array[Eu], true_label[Eu] plt.rede(Falso) plt.xticks([]) plt.yticks([]) este enredo = plt.Barra(alcance(10), predictions_array, cor='# 777777') plt.Ylim([0, 1]) predicted_label = por exemplo..argmax(predictions_array) este enredo[predicted_label].set_color('internet') este enredo[true_label].set_color('verde')
  • Vamos dar uma olhada na 0ª e 10ª imagem primeiro
Eu = 0 plt.figura(figsize=(6,3)) plt.subtrama(1,2,1) plot_image(Eu, previsões, test_labels, test_images) plt.subtrama(1,2,2) plot_value_array(Eu, previsões, test_labels) plt.mostrar()

Eu = 10 plt.figura(figsize=(6,3)) plt.subtrama(1,2,1) plot_image(Eu, previsões, test_labels, test_images) plt.subtrama(1,2,2) plot_value_array(Eu, previsões, test_labels) plt.mostrar()

  • Agora, vamos traçar várias imagens e suas previsões. Os corretos são verdes, enquanto os incorretos são vermelhos.
num_rows = 5 num_cols = 3 num_images = num_rows*num_cols plt.figura(figsize=(2*2*num_cols, 2*num_rows)) para Eu dentro alcance(num_images): plt.subtrama(num_rows, 2*num_cols, 2*Eu+1) plot_image(Eu, previsões, test_labels, test_images) plt.subtrama(num_rows, 2*num_cols, 2*Eu+2) plot_value_array(Eu, previsões, test_labels) plt.mostrar()

  • Por fim, usaremos o modelo treinado para fazer uma previsão sobre uma única imagem.
# Pegue uma imagem do conjunto de dados de teste img = test_images[0] impressão(img.forma)
# Adicione a imagem a um lote onde é o único membro. img = (por exemplo..expand_dims(img,0)) impressão(img.forma)
predictions_single = modelo.prever(img) impressão(predictions_single)

plot_value_array(0, predictions_single, test_labels) plt.xticks(alcance(10), class_names, rotação=Quatro cinco) plt.mostrar()

  • Como você pode ver a previsão para nossa única imagem em lote.
prediction_result = por exemplo..argmax(predictions_single[0])

Produto: 9

CIFAR-10: CNN

O conjunto de dados CIFAR-10 consiste em aviões, cães, gatos e outros objetos. Você vai pré-processar as imagens e, em seguida, treinar uma rede neural convolucional em todas as amostras. As imagens precisam ser normalizadas e os rótulos precisam ter codificação one-hot. Este caso de uso certamente esclarecerá suas dúvidas sobre a classificação de imagens do TensorFlow.

  • Baixando os dados
a partir de urllib.request importar urlretrieve a partir de os.path importar isfile, é fuligem a partir de tqdm importar tqdm importar tarfile cifar10_dataset_folder_path = 'cifar-10-batches-py' classe DownloadProgress(tqdm): last_block = 0 def gancho(auto, block_num=1, tamanho do bloco=1, tamanho total=Nenhum): auto.total = tamanho total auto.atualizar((block_num - auto.last_block) * tamanho do bloco) auto.last_block = block_num '' ' verifique se o arquivo de dados (zip) já foi baixado caso contrário, baixe-o em 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz' e salve como cifar-10-python.tar.gz '' ' E se não isfile('cifar-10-python.tar.gz'): com DownloadProgress(unidade='B', escala_da_unidade=Verdade, minitros=1, desc='Conjunto de dados CIFAR-10') Como pbar: urlretrieve( 'https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz', 'cifar-10-python.tar.gz', pbar.gancho) E se não é fuligem(cifar10_dataset_folder_path): com tarfile.Aberto('cifar-10-python.tar.gz') Como alcatrão: alcatrão.extrair tudo() alcatrão.perto()
  • Importando Bibliotecas Necessárias
importar salmoura importar entorpecido Como por exemplo. importar matplotlib.pyplot Como plt
  • Compreendendo os dados

O lote original de dados é 10000 × 3072 tensor expresso em uma matriz numpy, onde 10000 é o número de dados de amostra. A imagem é colorida e tem o tamanho 32 × 32. A alimentação pode ser feita em um formato de (largura x altura x num_canal) ou (num_canal x largura x altura). Vamos definir os rótulos.

def load_label_names(): Retorna ['avião', 'automóvel', 'pássaro', 'gato', 'cervo', 'cachorro', 'rã', 'cavalo', 'navio', 'caminhão']
  • Remodelando os Dados

Vamos reformular os dados em duas etapas

Em primeiro lugar, divida o vetor linha (3072) em 3 partes. Cada peça corresponde a cada canal. Isso resulta na dimensão (3 x 1024) de um tensor. Em seguida, divida o tensor resultante da etapa anterior com 32. 32 aqui significa a largura de uma imagem. Isso resulta em (3x32x32).

python o que é __init__

Em segundo lugar, temos que transpor os dados de (num_channel, largura, altura) para (largura, altura, num_channel). Para isso, vamos usar a função transpor.

def load_cfar10_batch(cifar10_dataset_folder_path, batch_id): com Aberto(cifar10_dataset_folder_path + '/ data_batch_' + p(batch_id), modo='rb') Como Arquivo: # note que o tipo de codificação é 'latin1' lote = salmoura.carga(Arquivo, codificação='latin1') recursos = lote['dados'].remodelar((len(lote['dados']), 3, 32, 32)).transpor(0, 2, 3, 1) rótulos = lote['rótulos'] Retorna recursos, rótulo
  • Explorando os dados
def display_stats(cifar10_dataset_folder_path, batch_id, sample_id): recursos, rótulos = load_cfar10_batch(cifar10_dataset_folder_path, batch_id) E se não (0 <= sample_id < len(recursos)): impressão('{}amostras em lote{}.{}está fora do alcance. '.formato(len(recursos), batch_id, sample_id)) Retorna Nenhum impressão(' Estatísticas do lote nº{}: '.formato(batch_id)) impressão('# de Amostras:{} '.formato(len(recursos))) label_names = load_label_names() label_counts = dict(fecho eclair(*por exemplo..único(rótulos, return_counts=Verdade))) para chave, valor dentro label_counts.Itens(): impressão('Contagens de rótulos de [{}] ({}):{}'.formato(chave, label_names[chave].superior(), valor)) sample_image = recursos[sample_id] sample_label = rótulos[sample_id] impressão(' Exemplo de imagem{}: '.formato(sample_id)) impressão('Imagem - Valor mínimo:{}Valor máximo:{}'.formato(sample_image.min(), sample_image.max())) impressão('Imagem - Forma:{}'.formato(sample_image.forma)) impressão('Etiqueta - Id da etiqueta:{}Nome:{}'.formato(sample_label, label_names[sample_label])) plt.imshow(sample_image)
%matplotlib em linha %config InlineBackend.figure_format = 'retina' importar entorpecido Como por exemplo. # Explore o conjunto de dados batch_id = 3 sample_id = 7000 display_stats(cifar10_dataset_folder_path, batch_id, sample_id)

  • Implementando funções de pré-processamento

Vamos normalizar os dados por meio da normalização Mín-Máx. Isso simplesmente faz com que todos os valores de x variem entre 0 e 1.
y = (x-min) / (max-min)

def normalizar(x): '' ' argumento - x: dados de entrada de imagem em matriz numpy [32, 32, 3] Retorna - normalizado x '' ' min_val = por exemplo..min(x) max_val = por exemplo..max(x) x = (x-min_val) / (max_val-min_val) Retorna x
  • One-Hot Encode
def one_hot_encode(x): '' ' argumento - x: uma lista de rótulos Retorna - uma matriz de codificação dinâmica (número de rótulos, número de classe) '' ' codificado = por exemplo..zeros((len(x), 10)) para idx, horas dentro enumerar(x): codificado[idx] [horas] = 1 Retorna codificado
  • Pré-processar e salvar os dados
def _preprocess_and_save(normalizar, one_hot_encode, recursos, rótulos, nome do arquivo): recursos = normalizar(recursos) rótulos = one_hot_encode(rótulos) salmoura.despejar((recursos, rótulos), Aberto(nome do arquivo, 'wb')) def preprocess_and_save_data(cifar10_dataset_folder_path, normalizar, one_hot_encode): n_batches = 5 valid_features = [] valid_labels = [] para batch_i dentro alcance(1, n_batches + 1): recursos, rótulos = load_cfar10_batch(cifar10_dataset_folder_path, batch_i) # encontrar o índice como o ponto de dados de validação em todo o conjunto de dados do lote (10%) index_of_validation = int(len(recursos) * 0,1) # pré-processar 90% de todo o conjunto de dados do lote # - normalizar os recursos # - one_hot_encode os rótulos # - salvar em um novo arquivo chamado, 'preprocess_batch_' + batch_number # - cada arquivo para cada lote _preprocess_and_save(normalizar, one_hot_encode, recursos[:-index_of_validation], rótulos[:-index_of_validation], 'preprocess_batch_' + p(batch_i) + '.p') # ao contrário do conjunto de dados de treinamento, o conjunto de dados de validação será adicionado a todos os conjuntos de dados em lote # - pega 10% do conjunto de dados inteiro do lote # - adicione-os a uma lista de # - valid_features # - valid_labels valid_features.ampliar(recursos[-index_of_validation:]) valid_labels.ampliar(rótulos[-index_of_validation:]) # pré-processar todo o conjunto de dados de validação empilhado _preprocess_and_save(normalizar, one_hot_encode, por exemplo..matriz(valid_features), por exemplo..matriz(valid_labels), 'preprocess_validation.p') # carregue o conjunto de dados de teste com Aberto(cifar10_dataset_folder_path + '/ test_batch', modo='rb') Como Arquivo: lote = salmoura.carga(Arquivo, codificação='latin1') # pré-processar os dados de teste test_features = lote['dados'].remodelar((len(lote['dados']), 3, 32, 32)).transpor(0, 2, 3, 1) test_labels = lote['rótulos'] # Pré-processar e salvar todos os dados de teste _preprocess_and_save(normalizar, one_hot_encode, por exemplo..matriz(test_features), por exemplo..matriz(test_labels), 'preprocess_training.p')
preprocess_and_save_data(cifar10_dataset_folder_path, normalizar, one_hot_encode)
  • Checkpoint
importar salmoura valid_features, valid_labels = salmoura.carga(Aberto('preprocess_validation.p', modo='rb'))
  • Construindo a Rede

Todo o modelo consiste em 14 camadas no total.

importar tensorflow Como tf def conv_net(x, keep_prob): conv1_filter = tf.Variável(tf.truncated_normal(forma=[3, 3, 3, 64], significar=0, stddev=0,08)) conv2_filter = tf.Variável(tf.truncated_normal(forma=[3, 3, 64, 128], significar=0, stddev=0,08)) conv3_filter = tf.Variável(tf.truncated_normal(forma=[5, 5, 128, 256], significar=0, stddev=0,08)) conv4_filter = tf.Variável(tf.truncated_normal(forma=[5, 5, 256, 512], significar=0, stddev=0,08)) # 1, 2 conv1 = tf.nos.conv2d(x, conv1_filter, passos largos=[1,1,1,1], preenchimento='MESMO') conv1 = tf.nos.relu(conv1) conv1_pool = tf.nos.max_pool(conv1, ksize=[1,2,2,1], passos largos=[1,2,2,1], preenchimento='MESMO') conv1_bn = tf.camadas.batch_normalization(conv1_pool) # 3. 4 conv2 = tf.nos.conv2d(conv1_bn, conv2_filter, passos largos=[1,1,1,1], preenchimento='MESMO') conv2 = tf.nos.relu(conv2) conv2_pool = tf.nos.max_pool(conv2, ksize=[1,2,2,1], passos largos=[1,2,2,1], preenchimento='MESMO') conv2_bn = tf.camadas.batch_normalization(conv2_pool) # 5, 6 conv3 = tf.nos.conv2d(conv2_bn, conv3_filter, passos largos=[1,1,1,1], preenchimento='MESMO') conv3 = tf.nos.relu(conv3) conv3_pool = tf.nos.max_pool(conv3, ksize=[1,2,2,1], passos largos=[1,2,2,1], preenchimento='MESMO') conv3_bn = tf.camadas.batch_normalization(conv3_pool) # 7, 8 conv4 = tf.nos.conv2d(conv3_bn, conv4_filter, passos largos=[1,1,1,1], preenchimento='MESMO') conv4 = tf.nos.relu(conv4) conv4_pool = tf.nos.max_pool(conv4, ksize=[1,2,2,1], passos largos=[1,2,2,1], preenchimento='MESMO') conv4_bn = tf.camadas.batch_normalization(conv4_pool) # 9 plano = tf.contrib.camadas.achatar(conv4_bn) # 10 full1 = tf.contrib.camadas.totalmente conectado(entradas=plano, num_outputs=128, ativação_fn=tf.nos.relu) full1 = tf.nos.cair fora(full1, keep_prob) full1 = tf.camadas.batch_normalization(full1) # onze full2 = tf.contrib.camadas.totalmente conectado(entradas=full1, num_outputs=256, ativação_fn=tf.nos.relu) full2 = tf.nos.cair fora(full2, keep_prob) full2 = tf.camadas.batch_normalization(full2) # 12 full3 = tf.contrib.camadas.totalmente conectado(entradas=full2, num_outputs=512, ativação_fn=tf.nos.relu) full3 = tf.nos.cair fora(full3, keep_prob) full3 = tf.camadas.batch_normalization(full3) # 13 full4 = tf.contrib.camadas.totalmente conectado(entradas=full3, num_outputs=1024, ativação_fn=tf.nos.relu) full4 = tf.nos.cair fora(full4, keep_prob) full4 = tf.camadas.batch_normalization(full4) # 14 Fora = tf.contrib.camadas.totalmente conectado(entradas=full3, num_outputs=10, ativação_fn=Nenhum) Retorna Fora
  • Hiperparâmetros
épocas = 10 tamanho do batch = 128 keep_probability = 0,7 taxa de Aprendizagem = 0,001
logits = conv_net(x, keep_prob) modelo = tf.identidade(logits, nome='logits') # Name Logits Tensor, para que possa ser carregado do disco após o treinamento # Perda e otimizador custo = tf.reduzir_média(tf.nos.softmax_cross_entropy_with_logits(logits=logits, rótulos=Y)) otimizador = tf.trem.AdamOptimizer(taxa de Aprendizagem=taxa de Aprendizagem).minimizar(custo) # Precisão correto_pred = tf.igual(tf.argmax(logits, 1), tf.argmax(Y, 1)) precisão = tf.reduzir_média(tf.fundida(correto_pred, tf.float32), nome='precisão')
  • Treine a rede neural
#Single Optimization 
def
train_neural_network(sessão, otimizador, keep_probability, feature_batch, label_batch): sessão.corre(otimizador, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: keep_probability })
#Showing Stats def print_stats(sessão, feature_batch, label_batch, custo, precisão): perda = sessão.corre(custo, feed_dict={ x: feature_batch, Y: label_batch, keep_prob: 1. }) valid_acc = sessão.corre(precisão, feed_dict={ x: valid_features, Y: valid_labels, keep_prob: 1. }) impressão('Perda:{:> 10.4f}Precisão de validação:{: .6f}'.formato(perda, valid_acc))
  • Treinando totalmente e salvando o modelo
def batch_features_labels(recursos, rótulos, tamanho do batch): '' ' Divida recursos e rótulos em lotes '' ' para começar dentro alcance(0, len(recursos), tamanho do batch): fim = min(começar + tamanho do batch, len(recursos)) Rendimento recursos[começar:fim], rótulos[começar:fim] def load_preprocess_training_batch(batch_id, tamanho do batch): '' ' Carregue os dados de treinamento pré-processado e retorne-os em lotes de ou menos '' ' nome do arquivo = 'preprocess_batch_' + p(batch_id) + '.p' recursos, rótulos = salmoura.carga(Aberto(nome do arquivo, modo='rb')) # Retorne os dados de treinamento em lotes de tamanho ou menos Retorna batch_features_labels(recursos, rótulos, tamanho do batch)
#Saving Model and Path 
save_model_path
= './image_classification' impressão('Treinamento...') com tf.Sessão() Como sessão: # Inicializando as variáveis sessão.corre(tf.global_variables_initializer()) # Ciclo de treinamento para época dentro alcance(épocas): # Loop em todos os lotes n_batches = 5 para batch_i dentro alcance(1, n_batches + 1): para batch_features, batch_labels dentro load_preprocess_training_batch(batch_i, tamanho do batch): train_neural_network(sessão, otimizador, keep_probability, batch_features, batch_labels) impressão('Época{:> 2}, Lote CIFAR-10{}: '.formato(época + 1, batch_i), fim='') print_stats(sessão, batch_features, batch_labels, custo, precisão) # Salvar modelo protetor = tf.trem.Saver() save_path = protetor.Salve (sessão, save_model_path)

Agora, a parte importante da classificação de imagens do Tensorflow está concluída. Agora é hora de testar o modelo.

  • Testando o modelo
importar salmoura importar entorpecido Como por exemplo. importar matplotlib.pyplot Como plt a partir de sklearn.preprocessing importar LabelBinarizer def batch_features_labels(recursos, rótulos, tamanho do batch): '' ' Divida recursos e rótulos em lotes '' ' para começar dentro alcance(0, len(recursos), tamanho do batch): fim = min(começar + tamanho do batch, len(recursos)) Rendimento recursos[começar:fim], rótulos[começar:fim] def display_image_predictions(recursos, rótulos, previsões, top_n_predictions): n_classes = 10 label_names = load_label_names() label_binarizer = LabelBinarizer() label_binarizer.em forma(alcance(n_classes)) label_ids = label_binarizer.inverse_transform(por exemplo..matriz(rótulos)) FIG, axies = plt.subtramas(nrows=top_n_predictions, ncols=2, figsize=(vinte, 10)) FIG.tight_layout() FIG.Suptitle('Predições Softmax', tamanho da fonte=vinte, Y=1,1) n_predições = 3 margem = 0,05 ind = por exemplo..arange(n_predições) largura = (1. - 2 * margem) / n_predições para imagem_i, (característica, label_id, pred_indicies, pred_values) dentro enumerar(fecho eclair(recursos, label_ids, previsões.índices, previsões.valores)): E se (imagem_i < top_n_predictions): pred_names = [label_names[pred_i] para pred_i dentro pred_indicies] nome correto = label_names[label_id] axies[imagem_i] [0].imshow((característica*255).astype(por exemplo..int32, cópia de=Falso)) axies[imagem_i] [0].set_title(nome correto) axies[imagem_i] [0].set_axis_off() axies[imagem_i] [1].barh(ind + margem, pred_values[:3], largura) axies[imagem_i] [1].set_yticks(ind + margem) axies[imagem_i] [1].set_yticklabels(pred_names[::-1]) axies[imagem_i] [1].set_xticks([0, 0,5, 1.0])
%matplotlib em linha %config InlineBackend.figure_format = 'retina' importar tensorflow Como tf importar salmoura importar aleatória save_model_path = './image_classification' tamanho do batch = 64 n_samples = 10 top_n_predictions = 5 def test_model(): test_features, test_labels = salmoura.carga(Aberto('preprocess_training.p', modo='rb')) load_graph = tf.Gráfico() com tf.Sessão(gráfico=load_graph) Como sessão: # Carregar modelo carregador = tf.trem.import_meta_graph(save_model_path + '.meta') carregador.restaurar(sessão, save_model_path) # Obtenha tensores do modelo carregado carregado_x = load_graph.get_tensor_by_name('input_x: 0') carregado_y = load_graph.get_tensor_by_name('output_y: 0') load_keep_prob = load_graph.get_tensor_by_name('keep_prob: 0') carregado_logits = load_graph.get_tensor_by_name('logits: 0') carregado_acc = load_graph.get_tensor_by_name('precisão: 0') # Obtenha precisão em lotes para limitações de memória test_batch_acc_total = 0 test_batch_count = 0 para train_feature_batch, train_label_batch dentro batch_features_labels(test_features, test_labels, tamanho do batch): test_batch_acc_total + = sessão.corre( carregado_acc, feed_dict={carregado_x: train_feature_batch, carregado_y: train_label_batch, load_keep_prob: 1.0}) test_batch_count + = 1 impressão('Teste de precisão:{} '.formato(test_batch_acc_total/test_batch_count)) # Imprimir amostras aleatórias random_test_features, random_test_labels = tupla(fecho eclair(*aleatória.amostra(Lista(fecho eclair(test_features, test_labels)), n_samples))) random_test_predictions = sessão.corre( tf.nos.top_k(tf.nos.softmax(carregado_logits), top_n_predictions), feed_dict={carregado_x: random_test_features, carregado_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()

Resultado: Precisão de teste: 0,5882762738853503

Agora, se você treinar sua rede neural por mais épocas ou alterar a função de ativação, poderá obter um resultado diferente que pode ter uma precisão melhor.

Então, com isso, chegamos ao fim deste artigo de classificação de imagens do TensorFlow. Tenho certeza que agora você pode usar o mesmo para classificar qualquer tipo de imagem e você não é um iniciante na classificação de imagens.

Edureka's com Python Certification Training é organizado por profissionais da indústria de acordo com os requisitos e demandas da indústria. Você vai dominar conceitos como função SoftMax, Redes Neurais Autoencoder, Máquina Boltzmann Restrita (RBM), Keras & TFLearn. O curso foi especialmente curado por especialistas do setor com estudos de caso em tempo real.