TensorFlow - Redes Neurais Convolucionais

Depois de entender os conceitos de aprendizado de máquina, agora podemos mudar nosso foco para os conceitos de aprendizado profundo. O aprendizado profundo é uma divisão do aprendizado de máquina e é considerado um passo crucial dado pelos pesquisadores nas últimas décadas. Os exemplos de implementação de aprendizado profundo incluem aplicativos como reconhecimento de imagem e reconhecimento de voz.

A seguir estão os dois tipos importantes de redes neurais profundas -

Redes Neurais Convolucionais
Redes Neurais Recorrentes

Neste capítulo, vamos nos concentrar na CNN, Redes Neurais Convolucionais.

Redes Neurais Convolucionais

As redes neurais convolucionais são projetadas para processar dados por meio de várias camadas de matrizes. Esse tipo de rede neural é usado em aplicativos como reconhecimento de imagem ou reconhecimento de rosto. A principal diferença entre a CNN e qualquer outra rede neural comum é que a CNN recebe a entrada como uma matriz bidimensional e opera diretamente nas imagens, em vez de focar na extração de recursos em que outras redes neurais se concentram.

A abordagem dominante da CNN inclui soluções para problemas de reconhecimento. Grandes empresas como Google e Facebook têm investido em pesquisa e desenvolvimento para projetos de reconhecimento para realizar atividades com maior agilidade.

Uma rede neural convolucional usa três idéias básicas -

Respectivos campos locais
Convolution
Pooling

Vamos entender essas idéias em detalhes.

A CNN utiliza correlações espaciais que existem nos dados de entrada. Cada camada simultânea de uma rede neural conecta alguns neurônios de entrada. Essa região específica é chamada de campo receptivo local. O campo receptivo local concentra-se nos neurônios ocultos. Os neurônios ocultos processam os dados de entrada dentro do campo mencionado, sem perceber as mudanças fora do limite específico.

A seguir está uma representação de diagrama de geração de respectivos campos locais -

Se observarmos a representação acima, cada conexão aprende um peso do neurônio oculto com uma conexão associada com o movimento de uma camada para outra. Aqui, os neurônios individuais realizam mudanças de tempos em tempos. Este processo é denominado “convolução”.

O mapeamento de conexões da camada de entrada para o mapa de feições ocultas é definido como “pesos compartilhados” e o viés incluído é chamado de “viés compartilhado”.

CNN ou redes neurais convolucionais usam camadas de pooling, que são as camadas, posicionadas imediatamente após a declaração da CNN. Ele recebe a entrada do usuário como um mapa de características que sai de redes convolucionais e prepara um mapa de características condensado. O agrupamento de camadas ajuda a criar camadas com neurônios de camadas anteriores.

Implementação do TensorFlow de CNN

Nesta seção, aprenderemos sobre a implementação do TensorFlow do CNN. As etapas, que exigem a execução e dimensionamento adequado de toda a rede, são as apresentadas a seguir -

Step 1 - Inclui os módulos necessários para o TensorFlow e os módulos do conjunto de dados, que são necessários para calcular o modelo CNN.

import tensorflow as tf
import numpy as np
from tensorflow.examples.tutorials.mnist import input_data

Step 2 - Declare uma função chamada run_cnn(), que inclui vários parâmetros e variáveis de otimização com declaração de marcadores de posição de dados. Essas variáveis de otimização irão declarar o padrão de treinamento.

def run_cnn():
   mnist = input_data.read_data_sets("MNIST_data/", one_hot = True)
   learning_rate = 0.0001
   epochs = 10
   batch_size = 50

Step 3 - Nesta etapa, declararemos os marcadores de posição de dados de treinamento com parâmetros de entrada - para 28 x 28 pixels = 784. Estes são os dados de imagem nivelada que são extraídos de mnist.train.nextbatch().

Podemos remodelar o tensor de acordo com nossos requisitos. O primeiro valor (-1) diz à função para moldar dinamicamente essa dimensão com base na quantidade de dados transmitidos a ela. As duas dimensões intermediárias são definidas para o tamanho da imagem (ou seja, 28 x 28).

x = tf.placeholder(tf.float32, [None, 784])
x_shaped = tf.reshape(x, [-1, 28, 28, 1])
y = tf.placeholder(tf.float32, [None, 10])

Step 4 - Agora é importante criar algumas camadas convolucionais -

layer1 = create_new_conv_layer(x_shaped, 1, 32, [5, 5], [2, 2], name = 'layer1')
layer2 = create_new_conv_layer(layer1, 32, 64, [5, 5], [2, 2], name = 'layer2')

Step 5- Vamos nivelar a saída pronta para o estágio de saída totalmente conectado - depois de duas camadas de passada 2 agrupando com as dimensões de 28 x 28, para a dimensão de 14 x 14 ou no mínimo 7 x 7 x, coordenadas y, mas com 64 canais de saída. Para criar a camada totalmente conectada com "densa", a nova forma precisa ser [-1, 7 x 7 x 64]. Podemos definir alguns pesos e valores de polarização para esta camada e, em seguida, ativar com ReLU.

flattened = tf.reshape(layer2, [-1, 7 * 7 * 64])

wd1 = tf.Variable(tf.truncated_normal([7 * 7 * 64, 1000], stddev = 0.03), name = 'wd1')
bd1 = tf.Variable(tf.truncated_normal([1000], stddev = 0.01), name = 'bd1')

dense_layer1 = tf.matmul(flattened, wd1) + bd1
dense_layer1 = tf.nn.relu(dense_layer1)

Step 6 - Outra camada com ativações específicas do softmax com o otimizador necessário define a avaliação da precisão, que faz a configuração do operador de inicialização.

wd2 = tf.Variable(tf.truncated_normal([1000, 10], stddev = 0.03), name = 'wd2')
bd2 = tf.Variable(tf.truncated_normal([10], stddev = 0.01), name = 'bd2')

dense_layer2 = tf.matmul(dense_layer1, wd2) + bd2
y_ = tf.nn.softmax(dense_layer2)

cross_entropy = tf.reduce_mean(
   tf.nn.softmax_cross_entropy_with_logits(logits = dense_layer2, labels = y))

optimiser = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cross_entropy)

correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

init_op = tf.global_variables_initializer()

Step 7- Devemos configurar variáveis de gravação. Isso adiciona um resumo para armazenar a precisão dos dados.

tf.summary.scalar('accuracy', accuracy)
   merged = tf.summary.merge_all()
   writer = tf.summary.FileWriter('E:\TensorFlowProject')
   
   with tf.Session() as sess:
      sess.run(init_op)
      total_batch = int(len(mnist.train.labels) / batch_size)
      
      for epoch in range(epochs):
         avg_cost = 0
      for i in range(total_batch):
         batch_x, batch_y = mnist.train.next_batch(batch_size = batch_size)
            _, c = sess.run([optimiser, cross_entropy], feed_dict = {
            x:batch_x, y: batch_y})
            avg_cost += c / total_batch
         test_acc = sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
            summary = sess.run(merged, feed_dict = {x: mnist.test.images, y:
            mnist.test.labels})
         writer.add_summary(summary, epoch)

   print("\nTraining complete!")
   writer.add_graph(sess.graph)
   print(sess.run(accuracy, feed_dict = {x: mnist.test.images, y:
      mnist.test.labels}))

def create_new_conv_layer(
   input_data, num_input_channels, num_filters,filter_shape, pool_shape, name):

   conv_filt_shape = [
      filter_shape[0], filter_shape[1], num_input_channels, num_filters]

   weights = tf.Variable(
      tf.truncated_normal(conv_filt_shape, stddev = 0.03), name = name+'_W')
   bias = tf.Variable(tf.truncated_normal([num_filters]), name = name+'_b')

#Out layer defines the output
   out_layer =
      tf.nn.conv2d(input_data, weights, [1, 1, 1, 1], padding = 'SAME')

   out_layer += bias
   out_layer = tf.nn.relu(out_layer)
   ksize = [1, pool_shape[0], pool_shape[1], 1]
   strides = [1, 2, 2, 1]
   out_layer = tf.nn.max_pool(
      out_layer, ksize = ksize, strides = strides, padding = 'SAME')

   return out_layer

if __name__ == "__main__":
run_cnn()

A seguir está a saída gerada pelo código acima -

See @{tf.nn.softmax_cross_entropy_with_logits_v2}.

2018-09-19 17:22:58.802268: I
T:\src\github\tensorflow\tensorflow\core\platform\cpu_feature_guard.cc:140]
Your CPU supports instructions that this TensorFlow binary was not compiled to
use: AVX2

2018-09-19 17:25:41.522845: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.

2018-09-19 17:25:44.630941: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 501760000 exceeds 10% of system memory.

Epoch: 1 cost = 0.676 test accuracy: 0.940

2018-09-19 17:26:51.987554: W
T:\src\github\tensorflow\tensorflow\core\framework\allocator.cc:101] Allocation
of 1003520000 exceeds 10% of system memory.