Experiência Prática - Redes Neurais

As redes neurais artificiais são um modelo de aprendizagem de máquina inspirado nas redes
neurais biológicas.
Na década de 1980 houve um ressurgimento na pesquisa de redes neurais. Uma rede
perceptron em múltiplas camadas (MLP) é uma classe de redes sem ciclos ou direta (feed forward).
É composta de pelo menos 3 camadas de perceptrons: uma de entrada, uma escondida (ou oculta) e
uma de saída. Exceto os nós de entrada, cada nó é um neurônio que usa uma função de ativação
não-linear.
MLP usa uma técnica para treinamento chamada backpropagation; ela consegue distinguir
dados não linearmente separáveis.
As redes MLP são formadas por:
◦ Camadas (layers), que possuem:
▪ Quantidade k>0 de neurônios
▪ Uma função de ativação θ, a qual é aplicada para cada neurônio da camada.
◦ Cada conexão entre 2 neurônios tem um valor chamado peso (weight) (W). Cada
conexão é ilustrada por uma aresta.

As redes neurais promovem transformações matemáticas nos dados que recebem para
processar. Em cada neurônio de cada camada, elas multiplicam o valor de entrada pelo peso do
neurônio correspondente, somam com o bias associado ao neurônio (valor que não depende da
entrada), e passam esse valor adiante.
Essas operações são lineares, de forma que, por mais complexa que seja a rede neural, ela só
pode captar relações lineares entre as variáveis de entrada e a variável de saída.
Para torná-las capazes de modelar também relações não-lineares, os resultados de saída de
cada camada passaram a ser processados pelas chamadas funções de ativação.

Isso é

especialmente importante nas camadas escondidas da rede neural. Nas camadas de saída, as funções
de ativação podem ter finalidades específicas, dependendo do problema que a rede neural está
tentando resolver.
Mas, qual função de ativação usar? Pelo seu desempenho, a função de ativação mais
utilizada nas camadas escondidas é a ReLU, tendo a preferência na abordagem inicial do problema.
Quando ela não é eficiente, pode-se recorrer às outras funções, considerando-se caso a caso.
Para as camadas de saída, podemos usar a função adequada à natureza do problema a ser
resolvido:
 classificação binária, podemos recorrer à função sigmóide, com a tangente hiperbólica
também sendo uma possível solução;
 classificação não-binária, podemos aplicar a função softmax;
 regressão, usamos a ativação linear.

Treinamento

Cada conexão entre neurônios representa um peso. O treinamento de redes neurais envolve
descobrir valores de pesos que minimizam o erro.
 Mesmo para um modelo com poucos neurônios, há infinitas permutações possíveis.
Os algoritmos mais eficientes para ajustar os pesos de um modelo de rede neural utilizam a
ideia do gradiente descendente. A função que calcula o erro do modelo calcula a diferença entre a
saída esperada e a saída atual. A derivada de uma função de custo permite calcular o gradiente para
cada peso W, o que permite ajustá-los para um valor que minimiza o erro.

Experimentos:
1) Código de um único Perceptron em python puro:

# Código de Milo Spencer-Harper

# https://gist.github.com/miloharper/62fe5dcc581131c96276

# Treino (função booleana OU):

# a b saída
# 0 0 0
# 0 1 1
# 1 0 1
# Teste:
# 1 1 1

from numpy import exp, array, random, dot

import numpy as np
entradas_treinamento = array([[0, 0], [0, 1], [1, 0]])
saidas_treinamento = array([[0, 1, 1]]).T
random.seed(1)
pesos_sinapticos = 2 * random.random((2, 1)) - 1 #pesos aleatórios entre -1 e 1
for epoca in range(100):
saida = 1 / (1 + exp(-(dot(entradas_treinamento, pesos_sinapticos)))) #saídas do neurônio
mudanca_pesos = dot(entradas_treinamento.T, (saidas_treinamento - saida) * saida * (1 - saida))
pesos_sinapticos += mudanca_pesos
print('Mudança nos pesos:', np.linalg.norm(mudanca_pesos))
#Testando com 1 e 1, esperando que dê 1 na saída
print (1 / (1 + exp(-(dot(array([1, 1]), pesos_sinapticos)))))

Atividades:
a) Imagine que o código acima esteja treinando um perceptron para replicar a função booleana AND
(E), fornecendo 3 pontos apenas. A previsão relacionada ao ponto (1,1) está correta?
b) Alterem o programa de modo a treinar o perceptron com a função booleana XOR (OU-
EXCLUSIVO):

A B A XOR B
0 0 0
0 1 1
1 0 1
1 1 0

O perceptron consegue fazer previsões sobre esta função? Por que é assim?
Sugestão: faça um plano cartesiano onde A e B são abscissa e ordenada; pinte a região do plano
correspondente ao 0 de uma cor e a correspondente ao 1 de outra; você consegue separar os zeros
dos uns com apenas uma reta?

2) Exemplo básico de MLP (Multi-layer Perceptron) usando a biblioteca Sklearn :

from sklearn.neural_network import MLPClassifier

X = [[0., 0.], [0., 1.], [1., 0.]]
y = [0., 1., 1.]
clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(2), random_state=1)
clf.fit(X, y) #treino
clf.predict([[1.,1.]]) #aplicação/teste

Atividades:
a) O código acima tenta aprender a função booleana AND (E), fornecendo 3 pontos apenas. A
previsão relacionada ao ponto (1,1) está correta?
b) Alterem o programa de modo a treinar a rede MLP com a função booleana XOR (OU-
EXCLUSIVO). A rede MLP consegue fazer previsões sobre esta função?

3) MLP usando Sklearn com a base IRIS:

import numpy as np

import pandas as pd
import seaborn as sns # visualization
from sklearn.neural_network import MLPClassifier # neural network
from sklearn.datasets import load_iris
iris = load_iris()

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.25)

#transformando a base em um dataframe def sklearn_to_df(sklearn_dataset):

df_iris = pd.DataFrame(iris.data, columns=iris.feature_names)
df_iris['target'] = pd.Series([iris['target_names'][iris['target'][i]] for i in range(150)])

sns.pairplot( data=df_iris, vars=('sepal length (cm)','sepal width (cm)','petal length (cm)','petal

width (cm)'), hue='target' )
df_iris.describe()

clf = MLPClassifier(solver='lbfgs', alpha=1e-5, hidden_layer_sizes=(3, 3), random_state=1)

clf.fit(X_train, y_train)
prediction = clf.predict(X_test)

from sklearn.metrics import classification_report

print('Relatório:\n',classification_report(y_test,prediction))
print("\nMatriz de confusão detalhada:\n",
pd.crosstab(y_test, prediction, rownames=['Real'], colnames=['Predito'],
margins=True, margins_name='Todos'))
Atividades:
a) Analise o relatório de avaliação. A rede trabalhou adequadamente?
b) Teste a rede MLP com uma outra base disponível (faça uma busca no site www.kaggle.com; lá
encontrará bases de muitas áreas e finalidades, como a CENSUS, que é um extrato de um censo
norte-americano).

4) Reconhecimento de imagens (base MNIST) usando a API Keras:

Usaremos a base MNIST, constituída por imagens digitalizadas de dígitos escritos à mão:

Primeiro código:

from __future__ import print_function

import numpy as np
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.optimizers import SGD, Adam, RMSprop
from keras.utils import np_utils

# Carregamos os dados do conjunto de dados MNIST do pacote Keras

(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_test_copy = X_test
y_test_copy = y_test

# Redimensionamos os dados e fazemos cast para float32

X_train = X_train.reshape(60000, 784).astype('float32')
X_test = X_test.reshape(10000, 784).astype('float32')

# Normalizamos os dados entre 0 e 1 (Dividimos pelo maximo)

X_train /= 255
X_test /= 255

# Convertemos de vetores de classes para matrizes binárias de classes.

Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)

model = Sequential()
model.add(Dense(units=512, input_shape=(784,)))
model.add(Activation('relu'))

model.add(Dense(units=512))
model.add(Activation('relu'))

model.add(Dense(units=10))
model.add(Activation('softmax'))

#Imprimimos o modelo no console

model.summary()

#Compilamos/Criamos o modelo
model.compile(loss='categorical_crossentropy', optimizer=RMSprop(), metrics=['accuracy'])

#Executamos o treinamento
history = model.fit(X_train, Y_train, batch_size=128, verbose=1, validation_data=(X_test, Y_test))

#Testamos o modelo e imprimimos o resultado

score = model.evaluate(X_test, Y_test, verbose=0)
print('Score:', score[0])
print('Accuracy:', score[1])

# salve o modelo treinado e a arquitetura da rede para um único arquivo

model.save("model.h5")
print('Modelo salvo no disco')

Segundo código:
Podemos testar o recurso de salvamento de modelos treinados e arquitetura de uma rede em
um único arquivo. Após rodar o código acima, rode o próximo, o qual usará a rede treinada:

from numpy import loadtxt

from keras.models import load_model

# carregue o modelo
model = load_model('model.h5')
# summarize model
model.summary()
predicao = model.predict_classes(X_test)

# example of loading the mnist dataset

from matplotlib import pyplot
erros = 0
errosSumario=''
print('Previsões:')
# plot first few images
for i in range(100):
# define subplot
pyplot.subplot(10, 10, 1 + i)
# plot raw pixel data
pyplot.imshow(X_test_copy[i], cmap=pyplot.get_cmap('gray'))
if(i%10 == 0): print('')
print(predicao[i], end=' ')
if predicao[i] != y_test[i]:
erros += 1
errosSumario += ('Errei na linha ' + str(i//10 + 1) + ' e coluna ' + str(i%10 + 1) +
': Real = ' + str(y_test[i]) + ', Predito = ' + str(predicao[i]) + '\n')
# show the figure
print('\n\nImagens:\n')
pyplot.show()
print('\nErros =', erros)
print(errosSumario)

Atividades:
a) Ocorreram erros de classificação? Fazem sentido os erros? Você teria reconhecido corretamente
estes dígitos?
b) Teste uma rede feita com Keras aplicada a uma outra base, como a CENSUS ou a IRIS.