IA com Python - Deep Learning

Rede Neural Artificial (RNA) é um sistema de computação eficiente, cujo tema central é emprestado da analogia das redes neurais biológicas. As redes neurais são um tipo de modelo para aprendizado de máquina. Em meados da década de 1980 e no início da década de 1990, muitos avanços arquitetônicos importantes foram feitos em redes neurais. Neste capítulo, você aprenderá mais sobre Deep Learning, uma abordagem de IA.

O aprendizado profundo emergiu de um crescimento computacional explosivo de uma década como um sério competidor no campo. Assim, o aprendizado profundo é um tipo particular de aprendizado de máquina cujos algoritmos são inspirados na estrutura e função do cérebro humano.

Aprendizado de máquina x aprendizado profundo

O aprendizado profundo é a técnica de aprendizado de máquina mais poderosa atualmente. É tão poderoso porque eles aprendem a melhor maneira de representar o problema enquanto aprendem como resolvê-lo. Uma comparação entre aprendizado profundo e aprendizado de máquina é fornecida abaixo -

Dependência de Dados

O primeiro ponto de diferença é baseado no desempenho de DL e ML quando a escala de dados aumenta. Quando os dados são grandes, os algoritmos de aprendizado profundo funcionam muito bem.

Dependência de máquina

Algoritmos de aprendizado profundo precisam de máquinas de última geração para funcionarem perfeitamente. Por outro lado, os algoritmos de aprendizado de máquina também podem funcionar em máquinas de baixo custo.

Extração de característica

Algoritmos de aprendizado profundo podem extrair recursos de alto nível e tentar aprender com os mesmos também. Por outro lado, um especialista é necessário para identificar a maioria dos recursos extraídos pelo aprendizado de máquina.

Tempo de Execução

O tempo de execução depende dos vários parâmetros usados ​​em um algoritmo. O aprendizado profundo tem mais parâmetros do que algoritmos de aprendizado de máquina. Portanto, o tempo de execução de algoritmos DL, principalmente o tempo de treinamento, é muito mais do que algoritmos ML. Mas o tempo de teste dos algoritmos DL é menor do que os algoritmos ML.

Abordagem para resolução de problemas

O aprendizado profundo resolve o problema de ponta a ponta, enquanto o aprendizado de máquina usa a maneira tradicional de resolver o problema, ou seja, dividindo-o em partes.

Rede Neural Convolucional (CNN)

As redes neurais convolucionais são iguais às redes neurais comuns porque também são compostas de neurônios com pesos e tendências aprendíveis. As redes neurais comuns ignoram a estrutura dos dados de entrada e todos os dados são convertidos em uma matriz 1-D antes de alimentá-los na rede. Este processo se adapta aos dados regulares, no entanto, se os dados contiverem imagens, o processo pode ser complicado.

A CNN resolve esse problema facilmente. Leva em consideração a estrutura 2D das imagens ao processá-las, o que permite extrair as propriedades específicas das imagens. Dessa forma, o objetivo principal das CNNs é ir dos dados brutos da imagem na camada de entrada para a classe correta na camada de saída. A única diferença entre um NNs e CNNs comuns está no tratamento dos dados de entrada e no tipo de camadas.

Visão geral da arquitetura das CNNs

Arquitetonicamente, as redes neurais comuns recebem uma entrada e a transformam por meio de uma série de camadas ocultas. Cada camada é conectada à outra camada com a ajuda de neurônios. A principal desvantagem das redes neurais comuns é que elas não são bem dimensionadas para imagens completas.

A arquitetura das CNNs possui neurônios dispostos em 3 dimensões chamadas largura, altura e profundidade. Cada neurônio na camada atual é conectado a uma pequena porção da saída da camada anterior. É semelhante a sobrepor um×filtro na imagem de entrada. UsaMfiltros para ter certeza de como obter todos os detalhes. EstesM filtros são extratores de recursos que extraem recursos como bordas, cantos, etc.

Camadas usadas para construir CNNs

As seguintes camadas são usadas para construir CNNs -

  • Input Layer - Aceita os dados brutos da imagem como estão.

  • Convolutional Layer- Esta camada é o bloco de construção central das CNNs que faz a maioria dos cálculos. Esta camada calcula as convoluções entre os neurônios e os vários patches na entrada.

  • Rectified Linear Unit Layer- Aplica uma função de ativação à saída da camada anterior. Ele adiciona não linearidade à rede para que possa generalizar bem para qualquer tipo de função.

  • Pooling Layer- O pooling nos ajuda a manter apenas as partes importantes à medida que progredimos na rede. A camada de pooling opera independentemente em cada fatia de profundidade da entrada e a redimensiona espacialmente. Ele usa a função MAX.

  • Fully Connected layer/Output layer - Esta camada calcula as pontuações de saída na última camada. A saída resultante é do tamanho×× , onde L é o número de classes do conjunto de dados de treinamento.

Instalando pacotes úteis do Python

Você pode usar Keras, que é uma API de redes neurais de alto nível, escrita em Python e capaz de ser executada em TensorFlow, CNTK ou Theno. É compatível com Python 2.7-3.6. Você pode aprender mais sobre isso emhttps://keras.io/.

Use os seguintes comandos para instalar o keras -

pip install keras

Em conda ambiente, você pode usar o seguinte comando -

conda install –c conda-forge keras

Construindo um regressor linear usando ANN

Nesta seção, você aprenderá como construir um regressor linear usando redes neurais artificiais. Você pode usarKerasRegressorPara alcançar isto. Neste exemplo, estamos usando o conjunto de dados de preços de casas em Boston com 13 valores numéricos para propriedades em Boston. O código Python para o mesmo é mostrado aqui -

Importe todos os pacotes necessários conforme mostrado -

import numpy
import pandas
from keras.models import Sequential
from keras.layers import Dense
from keras.wrappers.scikit_learn import KerasRegressor
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold

Agora, carregue nosso conjunto de dados que é salvo no diretório local.

dataframe = pandas.read_csv("/Usrrs/admin/data.csv", delim_whitespace = True, header = None)
dataset = dataframe.values

Agora, divida os dados em variáveis ​​de entrada e saída, ou seja, X e Y -

X = dataset[:,0:13]
Y = dataset[:,13]

Uma vez que usamos redes neurais de linha de base, defina o modelo -

def baseline_model():

Agora, crie o modelo da seguinte maneira -

model_regressor = Sequential()
model_regressor.add(Dense(13, input_dim = 13, kernel_initializer = 'normal', 
   activation = 'relu'))
model_regressor.add(Dense(1, kernel_initializer = 'normal'))

Em seguida, compile o modelo -

model_regressor.compile(loss='mean_squared_error', optimizer='adam')
return model_regressor

Agora, fixe a semente aleatória para reprodutibilidade da seguinte forma -

seed = 7
numpy.random.seed(seed)

O objeto wrapper Keras para uso em scikit-learn como um estimador de regressão é chamado KerasRegressor. Nesta seção, avaliaremos este modelo com um conjunto de dados padronizado.

estimator = KerasRegressor(build_fn = baseline_model, nb_epoch = 100, batch_size = 5, verbose = 0)
kfold = KFold(n_splits = 10, random_state = seed)
baseline_result = cross_val_score(estimator, X, Y, cv = kfold)
print("Baseline: %.2f (%.2f) MSE" % (Baseline_result.mean(),Baseline_result.std()))

A saída do código mostrado acima seria a estimativa do desempenho do modelo no problema de dados não vistos. Será o erro quadrático médio, incluindo a média e o desvio padrão em todas as 10 dobras da avaliação de validação cruzada.

Classificador de imagens: um aplicativo de aprendizado profundo

Redes Neurais Convolucionais (CNNs) resolvem um problema de classificação de imagens, isto é, a qual classe a imagem de entrada pertence. Você pode usar a biblioteca de aprendizado profundo Keras. Observe que estamos usando o conjunto de dados de treinamento e teste de imagens de cães e gatos do seguinte linkhttps://www.kaggle.com/c/dogs-vs-cats/data.

Importe as bibliotecas e pacotes keras importantes conforme mostrado -

O seguinte pacote denominado sequencial inicializará as redes neurais como rede sequencial.

from keras.models import Sequential

O seguinte pacote chamado Conv2D é usado para realizar a operação de convolução, a primeira etapa da CNN.

from keras.layers import Conv2D

O seguinte pacote chamado MaxPoling2D é usado para realizar a operação de agrupamento, a segunda etapa do CNN.

from keras.layers import MaxPooling2D

O seguinte pacote chamado Flatten é o processo de conversão de todas as matrizes 2D resultantes em um único vetor linear longo e contínuo.

from keras.layers import Flatten

O seguinte pacote chamado Dense é usado para realizar a conexão completa da rede neural, a quarta etapa da CNN.

from keras.layers import Dense

Agora, crie um objeto da classe sequencial.

S_classifier = Sequential()

Agora, a próxima etapa é codificar a parte da convolução.

S_classifier.add(Conv2D(32, (3, 3), input_shape = (64, 64, 3), activation = 'relu'))

Aqui relu é a função do retificador.

Agora, a próxima etapa da CNN é a operação de agrupamento nos mapas de recursos resultantes após a parte da convolução.

S-classifier.add(MaxPooling2D(pool_size = (2, 2)))

Agora, converta todas as imagens agrupadas em um vetor contínuo usando lisonjeiro -

S_classifier.add(Flatten())

Em seguida, crie uma camada totalmente conectada.

S_classifier.add(Dense(units = 128, activation = 'relu'))

Aqui, 128 é o número de unidades ocultas. É uma prática comum definir o número de unidades ocultas como a potência de 2.

Agora, inicialize a camada de saída da seguinte maneira -

S_classifier.add(Dense(units = 1, activation = 'sigmoid'))

Agora, compile a CNN, nós construímos -

S_classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])

Aqui, o parâmetro do otimizador é escolher o algoritmo de descida gradiente estocástico, o parâmetro de perda é escolher a função de perda e o parâmetro de métrica é escolher a métrica de desempenho.

Agora, execute aumentos de imagem e, em seguida, ajuste as imagens às redes neurais -

train_datagen = ImageDataGenerator(rescale = 1./255,shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True)
test_datagen = ImageDataGenerator(rescale = 1./255)

training_set = 
   train_datagen.flow_from_directory(”/Users/admin/training_set”,target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

test_set = 
   test_datagen.flow_from_directory('test_set',target_size = 
      (64, 64),batch_size = 32,class_mode = 'binary')

Agora, ajuste os dados ao modelo que criamos -

classifier.fit_generator(training_set,steps_per_epoch = 8000,epochs = 
25,validation_data = test_set,validation_steps = 2000)

Aqui, steps_per_epoch, tem o número de imagens de treinamento.

Agora que o modelo foi treinado, podemos usá-lo para a previsão da seguinte forma -

from keras.preprocessing import image

test_image = image.load_img('dataset/single_prediction/cat_or_dog_1.jpg', 
target_size = (64, 64))

test_image = image.img_to_array(test_image)

test_image = np.expand_dims(test_image, axis = 0)

result = classifier.predict(test_image)

training_set.class_indices

if result[0][0] == 1:
prediction = 'dog'

else:
   prediction = 'cat'