Construindo uma rede neural convolucional

Conteúdo

Este artigo foi publicado como parte do Data Science Blogathon

Este artículo tiene como objetivo explicar la convolucional neuronal vermelho y cómo compilar CNN con la biblioteca TensorFlow Keras. Este artigo irá discutir os seguintes tópicos.

Primero analicemos la neuronal vermelho convolucional.

Convolucional neuronal vermelho (CNN)

o aprendizado profundo es un subconjunto muy importante del aprendizaje automático debido a su alto rendimiento en varios dominios. A rede neural convolucional (CNN) é um poderoso tipo de processamento de imagem de aprendizagem profunda que é frequentemente usado na visão computacional e compreende o reconhecimento de imagem e vídeo, juntamente com um sistema de processamento e recomendação de linguagem natural (PNL).

CNN utiliza un sistema multicapa que consta de la camada de entrada, a Camada de saída y una capa oculta que comprende múltiples capas convolucionales, camadas agrupadas, camadas totalmente conectadas. Discutiremos todas as camadas na próxima seção do artigo, como explicamos a construção da CNN.

Vamos olhar para a construção da CNN usando a biblioteca Keras, juntamente com uma explicação de como a CNN funciona.

Edifício CNN

Nós vamos usar o Conjunto de dados de imagem celular da malária. Este conjunto de dados consiste em 27,558 imagens de amostras de sangue microscópica. O conjunto de dados consiste em 2 pastas: pastas: parasitado e não infectado. Imagens de amostra

uma) amostra de sangue parasitada

b) Amostra de sangue não infectada

Discutiremos a construção da CNN juntamente com a CNN trabalhando no seguinte 6 Passos:

Paso 1: importar as bibliotecas necessárias

Paso 2: inicializar CNN y agregar una capa convolucional

Paso 3: operação de agrupamento

Paso 4: adicionar duas camadas convolucionais

Paso 5 – Operação de achatamento

Paso 6: camada e camada de saída totalmente conectadas

Estes 6 passos vai explicar como a CNN funciona, mostrado na imagem a seguir:

55796cnn-9342100

Agora, vamos analisar cada passo:

1. Importar bibliotecas necessárias

Por favor, veja link abaixo para explicações detalhadas dos módulos Keras.

https://keras.io/getting_started/

Código Python:

from tensorflow.keras.layers importação Entrada, Lambda, Denso, Achatar,Conv2D
de tensorflow.keras.models import Model
de tensorflow.keras.applications.vgg19 importação VGG19
de tensorflow.keras.applications.resnet50 preprocess_input de importação
de tensorflow.keras.preprocessando imagem de importação
de tensorflow.keras.preprocessing.image import ImageDataGenerator,load_img
de tensorflow.keras.models importar Sequencial
importar numpy como np
de glob importação glob
import matplotlib.pyplot as plt
de tensorflow.keras.layers importar MaxPooling2D

2. Inicialize a CNN e adicione uma camada convolucional

Código Python:

modelo=Sequencial()

model.add(Conv2D(filtros=16.kernel_size=2,estofamento="mesmo",ativação ="retomar",input_shape =(224,224,3)))

Primeiro temos que começar a classe sequencial, já que existem várias camadas para construir a CNN e todos devem estar em sequência. Em seguida, adicionamos a primeira camada convolucional onde precisamos especificar 5 argumentos. Então, vamos analisar cada argumento e seu propósito.

· Filtros

O principal objetivo da convolução é encontrar recursos na imagem usando um detector de recursos. Mais tarde, colocá-los em um mapa de características, que preserva as características distintas das imagens.

O detector de recursos, que é conhecido como um filtro, ele também é aleatoriamente inicializado e, em seguida,, depois de muitas iterações, o parâmetro de matriz de filtro que será melhor para separar imagens é selecionado. Por exemplo, o olho, o nariz, etc. dos animais devem ser considerados uma característica usada para classificar imagens por meio de filtros ou detectores característicos. Aqui estamos usando 16 funções.

· Kernel_size

Kernel_size refere-se ao tamanho da matriz do filtro. Aqui estamos usando um tamanho de filtro de 2 * 2.

· O preenchimento

67425pad-3670102

Vamos discutir qual é o problema com a CNN e como a operação de preenchimento resolverá o problema.

uma. Para uma imagem em escala de cinza (nxn) e um filtro / núcleo (fxf), as dimensões da imagem resultante de uma operação de convolução é (n – f + 1) x (n – f + 1).

Então, por exemplo, uma imagem de 5 * 7 e um tamanho do núcleo do filtro de 3 * 3, o resultado de saída após a operação de convolução seria um tamanho de 3 * 5. Portanto, a imagem encolhe cada vez que a operação convolucional é realizada.

B. Pixels, localizado nos cantos, ter uma contribuição muito pequena em comparação com os pixels no meio.

Então, para mitigar esses problemas, a operação de preenchimento é realizada. Preenchimento é um processo simples de adicionar camadas com 0 o -1 para inserir imagens para evitar os problemas mencionados acima.

Aqui estamos usando Estofamento = Mesmos argumentos, que descreve que as imagens de saída têm as mesmas dimensões das imagens de entrada.

· Função de gatilhoRelu

94297reluuu-8785187

Uma vez que as imagens não são lineares, para fornecer não linearidade, a función de activación relu se aplica después de la operación convolucional.

Relu significa função de ativação linear retificada. a função relu vai gerar a entrada diretamente se for positiva; pelo contrário, vai gerar zero.

· Formulário de entrada

este argumento mostra o tamanho da imagem: 224 * 224 * 3. Uma vez que as imagens em formato RGB são assim, la tercera dimensão de la imagen es 3.

3. Operação de agrupamento

Código Python:

model.add(MaxPooling2D(pool_size=2))

Precisamos aplicar a operação do pool depois de inicializar a CNN. Agrupamento é uma operação de downsampling da imagem. A camada de agrupamento é usada para reduzir as dimensões dos mapas de recursos. Portanto, la capa Pooling reduce la cantidad de parametros a aprender y reduce el cálculo en la red neuronal.

68836ppppppppp-9351255

Operações futuras são realizadas em recursos de resumo criados pela camada de agrupamento. em vez de recursos precisamente localizados gerados pela camada de convolução. Isso leva ao modelo mais robusto a variações na orientação de recursos na imagem..

Existem principalmente 3 tipos de agrupamento: –

1. Agrupamento máximo

2. Agrupamento médio

3. Agrupamento global

4. Adicione duas camadas convolucionais

Para adicionar mais duas camadas convolucionais, precisamos repetir os passos 2 e 3 com uma pequena modificação no número de filtros.

Código Python:

model.add(Conv2D(filtros=32.kernel_size=2,estofamento="mesmo",ativação ="retomar"))
model.add(MaxPooling2D(pool_size=2))
model.add(Conv2D(filtros=64.kernel_size=2,estofamento="mesmo",ativação ="retomar"))
model.add(MaxPooling2D(pool_size=2))

Nós modificamos o 2Dakota do Norte e 3rd camadas convolucionais com número de filtro 32 e 64 respectivamente.

5. Operação de achatamento

Código Python:

model.add(Achatar())

A operação de achatamento é converter o conjunto de dados em uma matriz 1D para entrar na próxima camada, que é a camada totalmente conectada.

36841tttttt-6506254

Depois de terminar o 3 Passos, agora nós agrupamos o mapa de recursos. Estamos agora achatando nossa saída depois de dois passos em uma coluna. Porque precisamos inserir esses dados 1D em uma camada de rede neural artificial.

6. Camada e camada de saída totalmente conectadas

A saída da operação de achatamento funciona como entrada para a rede neural. O objetivo da rede neural artificial torna a rede neural convolucional mais avançada e suficientemente capaz de classificar imagens..

45580sssssss-7571933

Aqui estamos usando uma classe densa da biblioteca Keras para criar uma camada e camada de saída totalmente conectada.

Código Python:

model.add(Denso(500,ativação ="retomar"))

model.add(Denso(2,ativação ="softmax"))

A função de ativação SoftMax é usada para construir a camada de saída. Vamos analisar a função de ativação do softmax.

Função de ativação Softmax

59812ssssssssss-1488041

É usado como a função de ativação final de uma rede neural para levar a saída da rede neural a uma distribuição de probabilidades sobre as classes de predição.. A saída do Softmax está em probabilidades de cada resultado possível para prever a classe. A soma das probabilidades deve ser uma para todas as classes de previsão possíveis.

Agora, analicemos el Treinamento y la evaluación de la red neuronal convolucional. Vamos discutir esta seção em 3 Passos; –

Paso 1: compila o modelo CNN

Paso 2: ajustar o modelo no conjunto de treinamento

Paso 3: avaliar o resultado

Paso 1: compilar o modelo CNN

Linha de código

model.compile (perda = 'categorical_crossentropy', otimizador = 'adam', metrics =['precisão'])

Aqui estamos usando 3 argumentos: –

· Função de perda

Estamos usando o categorical_crossentropy função de perda que é usada na tarefa de classificação. Esta pérdida es una muy buena medir de cuán distinguibles son dos distribuciones de probabilidad discretas entre sí.

Por favor, veja o link abaixo para uma descrição detalhada dos diferentes tipos de função de perda:

https://machinelearningmastery.com/how-to-choose-loss-functions-when-training-deep-learning-neural-networks/

· Otimizador

Estamos usando Adam Optimizer que é usado para atualizar pesos de rede neural e taxa de aprendizado. Otimizadores são usados para resolver problemas de otimização minimizando a função.

Por favor, veja o link abaixo para uma explicação detalhada dos diferentes tipos de otimizador:

https://medium.datadriveninvestor.com/overview-of-different-optimizers-for-neural-networks-e0ed119440c3

· Argumentos métricos

Aqui, estamos usando a precisão como uma métrica para avaliar o desempenho do algoritmo de rede neural convolucional.

Paso 2: ajuste modelo no conjunto de treinamento

Linha de código:

model.fit_generator(training_set,validation_data=test_set,épocas=50, steps_per_epoch=len(training_set), validation_steps=len(test_set) )

Estamos ajustando o modelo cnn no conjunto de dados de treinamento com 50 iterações e cada iteração tem passos diferentes para treinar e avaliar etapas dependendo da duração do teste e conjunto de treinamento.

Paso 3: – Avalie o resultado

Comparamos a função de precisão e perda para o conjunto de dados de treinamento e teste.

Código: Conspiração de perdas

plt.plot(r.history['perda'], rótulo ="perda de trem")
plt.plot(r.history['val_loss'], rótulo ="val perda")
plt.legend()
plt.show()
plt.savefig('LossVal_loss')

Produção

84637llllll-3357681

Perda é a punição para uma previsão ruim. O objetivo é tornar a perda de validação o mais baixa possível. Um pouco de overfit é quase sempre uma coisa boa. Tudo o que importa, ao final, isto é: é a menor perda possível de validação.

Código: Gráfico de precisão do gráfico

plt.plot(r.history['precisão'], rótulo ="acc trem")
plt.plot(r.history['val_accuracy'], rótulo ="val acc")
plt.legend()
plt.show()
plt.savefig('AccVal_acc')

Produção

28356aaaaaaa-7616326

A precisão é uma métrica para avaliar modelos de classificação. Informalmente, precisão é a fração de previsões nosso modelo tem direito. Aqui, podemos observar que a precisão está perto do 90% no teste de validação mostrando que um modelo CNN está tendo um bom desempenho em métricas de precisão.

Obrigado pela leitura! Feliz aprendizado profundo!

Referências:

1. https://www.superdatascience.com/

2. https://www.youtube.com/watch?v=H-bcnHE6Mes

Sobre mim :

Sou Jitendra Sharma., estagiário de ciência de dados em Nabler, e me dedico ao PGDM-Big Data Analytics do Goa Institute of Management. Você pode entrar em contato comigo através LinkedIn e Github.

A mídia mostrada neste artigo não é propriedade da DataPeaker e é usada a critério do autor.

Assine a nossa newsletter

Nós não enviaremos SPAM para você. Nós odiamos isso tanto quanto você.