[Aprenda TensorFlow] - Convolutional Neural Networks

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

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 o CNN e qualquer outra rede neural comum é que o 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 em projetos de reconhecimento para realizar atividades com maior agilidade.

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

• Respectivos campos locais
• Convolução
• Pooling

Vamos entender essas ideias 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 campos respectivos 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 uma mudança 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 requerem a execução e dimensionamento adequado de toda a rede, são as apresentadas a seguir:

Etapa 1 - Incluir 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

Etapa 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 declararão 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

Etapa 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])

Etapa 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')

Passo 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)

Passo 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()

Etapa 7 - Devemos configurar as 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()

O output do código é o seguinte:

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.

No próximo artigo falaremos sobre Recurrent neural networks.