Relatorio - ML - PAVIC - Wallison - Ipynb - Colaboratory

14/12/2023, 21:48 Relatorio_ML_PAVIC_Wallison.
ipynb - Colaboratory
QUESTIONÁRIO DE MACHINE LEARNING - PARTE I
Nome: Wallison Santos Ferreira
Ano: 2023
Disciplina: Machine Learning
Professor: Salomão Machado Mafalda
Observações: Ao avaliar o impacto das técnicas é importante deixar a rede neural com a mesma
arquitetura, ou seja, com o mesmo tamanho, quantidade de neurônios e camadas. Assim, ficará
mais justo a observação do impacto das técnicas nas redes neurais. Também, para cada
questão utilize um problema diferente. E, em cada questão, deixe um bloco para o código da
arquitetura, outro com o gráfico dos resultados e por fim seu comentário sobre o
comportamento observado. Gere um PDF e envie no classroom.
Double-click (or enter) to edit
keyboard_arrow_down Importações
import os
os.makedirs('utils_ex', exist_ok=True)
!wget -q https://github.com/mafaldasalomao/pavic_treinamento_ml/raw/main/utils/plot.py -O
!wget -q https://github.com/mafaldasalomao/pavic_treinamento_ml/raw/main/utils/samples_ge
import numpy as np
import _pickle as pkl
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.datasets import make_blobs, make_circles, make_moons, make_classification
from sklearn.metrics import accuracy_score

from sklearn.preprocessing import MinMaxScaler, OneHotEncoder
from utils_ex import plot
from utils_ex.samples_generator import make_spiral, make_square, make_cubic, make_exp, ma
%matplotlib inline
keyboard_arrow_down Funções de Ativação
https://colab.research.google.com/drive/1o0CBMEn3IFfrskD1t4FTzz-JIPgIv7_l#scrollTo=wxqeRBU1WlVJ&printMode=true 1/35
14/12/2023, 21:48 Relatorio_ML_PAVIC_Wallison.ipynb - Colaboratory
def linear(x, derivative=False):

return np.ones_like(x) if derivative else x
def sigmoid(x, derivative=False):

if derivative:
y = sigmoid(x)
return y*(1 - y)
return 1.0/(1.0 + np.exp(-x))
def tanh(x, derivative=False):

if derivative:
y = tanh(x)
return 1 - y**2
return (np.exp(x) - np.exp(-x))/(np.exp(x) + np.exp(-x))
def relu(x, derivative=False):

if derivative:
return np.where(x <= 0, 0, 1)
return np.maximum(0, x)
def leaky_relu(x, derivative=False):

alpha = 0.1
if derivative:
return np.where(x <= 0, alpha, 1)
return np.where(x <= 0, alpha*x, x)
def elu(x, derivative=False):

alpha = 1.0
if derivative:
y = elu(x)
return np.where(x <= 0, y + alpha, 1)
return np.where(x <= 0, alpha*(np.exp(x) - 1), x)
# Auxiliar
def softmax(x, y_oh=None, derivative=False):
if derivative:
y_pred = softmax(x)
k = np.nonzero(y_pred * y_oh)
pk = y_pred[k]
y_pred[k] = pk * (1.0 - pk)
return y_pred
exp = np.exp(x)
return exp / np.sum(exp, axis=1, keepdims=True)
keyboard_arrow_down Funções de Custo
##### Regressão
def mae(y, y_pred, derivative=False):
if derivative:
return np.where(y_pred > y, 1, -1) / y.shape[0]
return np.mean(np.abs(y - y_pred))
def mse(y, y_pred, derivative=False):

if derivative:
return - (y - y_pred) / y.shape[0]
return 0.5 * np.mean((y - y_pred)**2)
##### Classificação binária

def binary_cross_entropy(y, y_pred, derivative=False):
if derivative:
return -(y - y_pred) / (y_pred * (1-y_pred) * y.shape[0])
return -np.mean(y*np.log(y_pred) + (1 - y)*np.log(1-y_pred))
def sigmoid_cross_entropy(y, y_pred, derivative=False):

y_sigmoid = sigmoid(y_pred)
if derivative:
return -(y - y_sigmoid) / y.shape[0]
return -np.mean(y * np.log(y_sigmoid) + (1 - y) * np.log(1-y_sigmoid))
##### Classificação multi-classe

def neg_log_likelihood(y_oh, y_pred, derivative=False):
k = np.nonzero(y_pred * y_oh)
pk = y_pred[k]
if derivative:
y_pred[k] = (-1.0 / pk)
return y_pred
return np.mean(-np.log(pk))
def softmax_neg_log_likelihood(y_oh, y_pred, derivative=False):

y_softmax = softmax(y_pred)
if derivative:
return -(y_oh - y_softmax) / y_oh.shape[0]
return neg_log_likelihood(y_oh, y_softmax)
keyboard_arrow_down Inicialização de pesos
#Inicialização de pesos
def zeros(rows, cols): #in, out
return np.zeros((rows, cols))
def ones(rows, cols):

return np.ones((rows, cols))
def random_normal(rows, cols):

return np.random.randn(rows, cols)
def random_uniform(rows, cols):

return np.random.randn(rows, cols)
def glorot_normal(rows, cols):

std_dev = np.sqrt(2.0 / (rows + cols))
return std_dev * np.random.randn(rows, cols)
def glorot_uniform(rows, cols):

limit = np.sqrt(6.0 / (rows + cols))
return 2 * limit * np.random.randn(rows, cols) - limit
keyboard_arrow_down Regularização
def l1_regularization(weights, derivative=False):
if derivative:
weights = [np.where(w < 0, -1, w) for w in weights]
return np.array([np.where(w > 0, 1, w) for w in weights])
return np.sum([np.sum(np.abs(w)) for w in weights])
def l2_regularization(weights, derivative=False):
if derivative:
return weights
return 0.5 * np.sum(weights**2)
keyboard_arrow_down Batch Generator

def batch_sequencial(x, y, batch_size=None):
batch_size = x.shape[0] if batch_size is None else batch_size
n_batches = x.shape[0] // batch_size
for batch in range(n_batches):

offset = batch_size * batch
x_batch, y_batch = x[offset:offset+batch_size], y[offset:offset+batch_size]
yield (x_batch, y_batch)
def batch_shuffle(x, y, batch_size=None):

shuffle_index = np.random.permutation(range(x.shape[0]))
return batch_sequencial(x[shuffle_index], y[shuffle_index], batch_size)
keyboard_arrow_down Learning Rate Decay

def time_based_decay(learning_rate, epoch, decay_rate, decay_steps=1):
return 1.0 / (1 + decay_rate * epoch)
def exponential_decay(learning_rate, epoch, decay_rate, decay_steps=1):
return learning_rate * decay_rate ** epoch
def stair_case_decay(learning_rate, epoch, decay_rate, decay_steps=1):
return learning_rate * decay_rate ** (epoch // decay_steps)
def none_decay(learning_rate, epoch, decay_rate, decay_steps=1):
return learning_rate
keyboard_arrow_down Batch Normalization

def batchnorm_forward(layer, x, is_training=True):
mu = np.mean(x, axis=0) if is_training else layer._pop_mean
var = np.var(x, axis=0) if is_training else layer._pop_var
x_norm = (x - mu) / np.sqrt(var + 1e-8)
out = layer.gamma * x_norm + layer.betta
if is_training:
layer._pop_mean = layer.bn_decay * layer._pop_mean + (1.0 - layer.bn_decay) * mu
layer._pop_var = layer.bn_decay * layer._pop_var + (1.0 - layer.bn_decay) * var
layer._bn_cache = (x, x_norm, mu, var)
return out
def batchnorm_backward(layer, dactivation):

x, x_norm, mu, var = layer._bn_cache
m = layer._activ_inp.shape[0]
x_mu = x - mu
std_inv = 1. / np.sqrt(var + 1e-8)
dx_norm = dactivation * layer.gamma

dvar = np.sum(dx_norm * x_mu, axis=0) * -0.5 * (std_inv **3)
dmu = np.sum(dx_norm * -std_inv, axis=0) + dvar * np.mean(-2.0 * x_mu, axis=0)
dx = (dx_norm * std_inv) + (dvar * 2.0 * x_mu / m) + (dmu / m)

layer._dgamma = np.sum(dactivation * x_norm, axis=0)
layer._dbetta = np.sum(dactivation, axis=0)
return dx
keyboard_arrow_down Implementação da Rede Neural
class Layer():
def __init__(self, input_dim, output_dim,
weights_initializer=random_normal,
bias_initializer=ones, dropout_prob=0,
reg_func=l2_regularization,
reg_strength=0.0,
batch_norm=False,
bn_decay=0.9,
is_trainable=True,
activation=linear):
self.input = None
self.weights = weights_initializer(output_dim, input_dim)
self.biases = bias_initializer(1, output_dim)
self.activation = activation
self.dropout_prob = dropout_prob
self.reg_func = reg_func
self.reg_strength = reg_strength
self._dropout_mask = None
self._activ_inp, self._activ_out = None, None
self._dweights, self._dbiases, self._prev_dweights = None, None, 0.0
self.is_trainable = is_trainable
self.batch_norm = batch_norm
self.bn_decay = bn_decay
self.gamma, self.betta = ones(1, output_dim), zeros(1, output_dim)
self._dgamma, self._dbetta = None, None

self._pop_mean, self._pop_var = zeros(1, output_dim), zeros(1, output_dim)
self._bn_cache = None
class NeuralNetwork():
def __init__(self, cost_func=mse, learning_rate=1e-3,
lr_decay_method=none_decay,
lr_decay_rate=0.0,
lr_decay_steps=1,
patience=np.inf,
momentum=0.0):
self.layers = []
self.cost_func = cost_func
self.momentum = momentum
self.learning_rate = self.lr_initial = learning_rate
self.lr_decay_method = lr_decay_method
self.lr_decay_rate = lr_decay_rate
self.lr_decay_steps = lr_decay_steps
self.patience, self.waiting = patience, 0

self._best_model, self._best_loss = self.layers, np.inf
def fit(self, x_train, y_train, x_val=None, y_val=None, epochs=100, verbose=10, batch_g

x_val, y_val = (x_train, y_train) if (x_val is None or y_val is None) else (x_val, y_
for epoch in range(epochs+1):

self.learning_rate = self.lr_decay_method(self.lr_initial, epoch, self.lr_decay_rat
for x_batch, y_batch in batch_gen(x_train, y_train, batch_size):

y_pred = self.__feedforward(x_batch)
y_pred = self.__backprop(y_batch, y_pred)
loss_val = self.cost_func(y_val, self.predict(x_val))

if loss_val < self._best_loss:
self._best_model, self._best_loss = self.layers, loss_val
self.waiting = 0
else:
self.waiting += 1
if self.waiting > self.patience:
self.layers = self._best_model
print(f'Early Stopping at {epoch} epoch')
return
if epoch % verbose == 0:
loss_train = self.cost_func(y_train, self.predict(x_train))
loss_reg = (1.0 / y_train.shape[0]) * np.sum([layer.reg_strength * layer.reg_func
print("Epoch: {0:=4}/{1} loss_train: {2:.8f}+{3:.8f} = {4:.8f} loss_val= {5:.8f}"
def predict(self, x):

return self.__feedforward(x, is_training=False)
#Save model
def save(self, filepath):
pkl.dump(self, open(filepath, 'wb'), -1)
#Load model
def load(filepath):
return pkl.load(open(filepath, 'rb'))
def __feedforward(self, x, is_training=True):

self.layers[0].input = x
for current_layer, next_layer in zip(self.layers, self.layers[1:] + [Layer(0,0)]):

y = np.dot(current_layer.input, current_layer.weights.T) + current_layer.biases
y = batchnorm_forward(current_layer, y, is_training) if current_layer.batch_norm el
current_layer._dropout_mask = np.random.binomial(1, 1.0 - current_layer.dropout_pro
current_layer._activ_inp = y
current_layer._activ_out = next_layer.input = current_layer.activation(y) * (curren
return self.layers[-1]._activ_out
def __backprop(self, y, y_pred):

last_delta = self.cost_func(y, y_pred, derivative=True)
#calcular a derivada para as camadas
for layer in reversed(self.layers):
dactivation = layer.activation(layer._activ_inp, derivative=True) * last_delta * la
dactivation = batchnorm_backward(layer, dactivation) if layer.batch_norm else dacti
last_delta = np.dot(dactivation, layer.weights)

layer._dweights = np.dot(dactivation.T, layer.input)

layer._dbiases = 1.0 * dactivation.sum(axis=0, keepdims=True)
for layer in reversed(self.layers):

if layer.is_trainable:
layer._dweights = layer._dweights + (1.0 / y.shape[0]) * layer.reg_strength * lay
layer._prev_dweights = - self.learning_rate * layer._dweights + self.momentum * l
layer.weights = layer.weights + layer._prev_dweights
layer.biases = layer.biases - self.learning_rate * layer._dbiases
if layer.batch_norm:
layer.gamma = layer.gamma - self.learning_rate * layer._dgamma
layer.betta = layer.betta - self.learning_rate * layer._dbetta
keyboard_arrow_down Questões
Questão 01 - Com suas palavras defina: Overfitting, underfitting, vetor gradiente, taxa de
aprendizado, épocas, camadas, neurônio, função de custo e função de ativação.
Resp. 1:
Overfitting: é quando o modelo é maior e os dados são menores. O modelo se ajusta acima do
necessário, não sendo capaz portanto de generalizar o problema para quando houver novos
exemplos de entrada. Portanto o acerto tende a ser exageradamente grande no treino, mas
tende a falhar para novos dados.
Underfitting: é quando o modelo é menor e os dados são maiores. Neste sentido, o modelo
tende a modelar o problema de forma muito errônea, por que o seu ajuste não é capaz de
satisfazer a complexidade do problema. Tende a errar muito no treino, e o acerto no teste tende
a ser maior, por que a liberdade para os dados satisfezerem o modelo é maior (o que não é
conveniente para o aprendizado da máquina).
Vetor gradiente: é um vetor que nos dá a direção para que o ponto na curva da função de custo
deve ser deslocada, no sentido de achar o menor nível. O vetor gradiente é normal em relação ao
ponto na curva, e o seu valor negativo nos diz a direção para onde o erro da máquina aprendiz é
minimizado.
Taxa de aprendizado: é o tamanho da passada que o algoritmo deve dar repetidamente até
chegar no resultado ideal. Quando o tamanho da passada é pequeno, muitas iterações
(passadas) são necessárias pra chegar ao resultado. Quando a passada é muito grande chega-
se ao resultado mais rápido, mas perde-se na precisão do modelo, devido ao risco do tamanho
do passo incidir na extrapolação do valor ideal.
Épocas: O momento do recebimento de um conjunto de indivíduos, as operações da rede

(multiplicação, soma e função de ativação) e o resultado da função de custo, e a atualização de
pesos (se houver), configura uma época. A época configura uma iteração por um conjunto de
indivíduos OU pacotes OU mini-pacotes, obtidos pela rede até a devolução de um resultado ou
atualizações de pesos. Geralmente itera-se sucessivas vezes suas operações até que uma
pausa definida seja alcançada ou até que um valor satisfaça o pretendido.
Camadas: estão presentes na rede neural e representa um conjunto de neurônios. A camada de

entrada e saída é a mais comum, mas uma rede neural pode ter camadas intermediárias (hidden
layers) que são usadas para lidar com problemas não-lineares ou de maiores complexidades.
Neurônio: é uma estrutura em uma rede neural usado para armazenar indíviduos ou resultados
de operações entre pesos e indivíduos na rede.
Função de custo: é a função que ajuda o aprendizado do algoritmo, calculando o quanto que o
resultado se afasta do valor real.
Função de ativação: A função de ativação transmite o aprendizado obtido entre as camadas da

rede e decide se ou quanto um neurônio irá contribuir na sua saída.
Questão 02 - Construa uma rede neural totalmente conectada, treine-a e teste-a com pelo
menos dois métodos de inicialização de pesos diferentes. Em seguida, comente o que foi
possível observar de diferente entre os métodos escolhidos.
x, y = make_cubic(n_samples=100, x_min=-4, x_max=4, a=1, b=0, c=-10, d=0, noise=3)

print(x.shape, y.shape)
plt.figure(figsize=(12, 6))
plt.subplot(1, 3, 1)
plt.scatter(x, y)
minmax = MinMaxScaler(feature_range=(-1, 1))

x = minmax.fit_transform(x.astype(np.float64))
input_dim, output_dim = x.shape[1], y.shape[1]
##### RANDOM NORMAL

nn = NeuralNetwork(cost_func=mse, learning_rate=0.1)
nn.layers.append(Layer(input_dim=input_dim, output_dim=10, weights_initializer=random_nor
nn.layers.append(Layer(10, 10, weights_initializer=random_normal, activation=sigmoid))
nn.layers.append(Layer(10, output_dim, weights_initializer=random_normal, activation=line
# train
nn.fit(x, y, epochs=5000, verbose=500)
# plot
plt.scatter(x, y)
plt.title('RANDOM NORMAL')
plt.plot(x, nn.predict(x), c='purple');
print('#'*20)
##### ONES
nn = NeuralNetwork(cost_func=mse, learning_rate=0.1)
nn.layers.append(Layer(input_dim=input_dim, output_dim=10, weights_initializer=ones, acti
nn.layers.append(Layer(10, 10, weights_initializer=ones, activation=sigmoid))
nn.layers.append(Layer(10, output_dim, weights_initializer=ones, activation=linear))
# train
# plot
plt.scatter(x, y)
plt.title('ONES')
(100, 1) (100, 1)
Epoch: 0/5000 loss_train: 52.02215732+0.00000000 = 52.02215732 loss_val= 52.022157
####################
Acima pode-se ver exemplos de treinamento de duas redes semelhantes com uma inicializando
pesos de forma aleatória e a outra rede iniciando pesos com 1's. A inicialização aleatória trouxe
melhor resultado devido a capacidade dos pesos fornecerem mais liberdade para o modelo
realizar os ajustes nos dados.
Random Normal: 5000 - loss_train 1.49754506
Ones: 5000 - loss_train 51.26945633
Questão 03 - Construa uma rede neural totalmente conectada, treine-a e teste-a com
diferentes camadas de ativação. Em seguida, comente o que foi possível observar de diferente
no comportamento de uma rede neural ao alterar as camadas de ativação (mantenha a mesma

quantidade de camadas).
# Gerando dados
x, y = make_log10(n_samples=100, x_min=1, x_max=100, noise=0.3)
plt.subplot(1,3,1)
plt.title('LOG-10')
plt.scatter(x, y);
# SIGMOID
nn = NeuralNetwork(cost_func=mae, learning_rate=1e-1)
nn.layers.append(Layer(input_dim=input_dim, output_dim=10, activation=linear))

nn.layers.append(Layer(input_dim=10, output_dim=20, activation=sigmoid))
nn.layers.append(Layer(input_dim=10, output_dim=output_dim, activation=linear))
# train
# plot
plt.scatter(x, y)
plt.title('SIGMOID')
print('#'*20)
nn.layers.append(Layer(input_dim=input_dim, output_dim=10, activation=linear))

nn.layers.append(Layer(input_dim=10, output_dim=20, activation=tanh))
nn.layers.append(Layer(input_dim=20, output_dim=10, activation=tanh))
# train
# plot
plt.scatter(x, y)
plt.title('TANH')
Epoch: 0 / 5000 loss_train 2.42138316

Epoch: 500 / 5000 loss_train 0.26303659
Epoch: 1000 / 5000 loss_train 0.24027691
Epoch: 1500 / 5000 loss_train 0.23261892
Epoch: 2000 / 5000 loss_train 0.21618289
Epoch: 2500 / 5000 loss_train 0.21992310
Epoch: 3000 / 5000 loss_train 0.22892049
Epoch: 3500 / 5000 loss_train 0.21861949
Epoch: 4000 / 5000 loss_train 0.15180707
Epoch: 4500 / 5000 loss_train 0.18418501
Epoch: 5000 / 5000 loss_train 0.15056345
####################
Epoch: 0 / 5000 loss_train 2.56018430
Epoch: 500 / 5000 loss_train 0.26898435
Epoch: 1000 / 5000 loss_train 0.23744392
Epoch: 1500 / 5000 loss_train 0.18477465
Epoch: 2000 / 5000 loss_train 0.21922092
Epoch: 2500 / 5000 loss_train 0.20938884
Epoch: 3000 / 5000 loss_train 0.19934186
Epoch: 3500 / 5000 loss_train 0.20878215
Epoch: 4000 / 5000 loss_train 0.20377527
Epoch: 4500 / 5000 loss_train 0.21859780
Epoch: 5000 / 5000 loss_train 0.20820884
A implementação da arquitetura com funções de ativação sigmoidal performou melhor do que a

RELU. A sigmoid foi capaz de dar a capacidade ao algoritmo de aprender mais rápido e
generalizar melhor o conjunto de dados, iniciando em (1.04 - 0.17). Já a Tanh demorou bastante
para aprender, iniciando em boa posição (0.68 - 0.20).
Sigmoid: 5000 - loss_train 0.17920404
Tanh: 5000 - loss_train 0.20055233
Double-click (or enter) to edit
Questão 04 - Construa uma rede neural totalmente conectada, treine-a e teste-a sem/com pelo
menos um dos métodos de regularização (L1, L2). Em seguida, comente o que foi possível
observar de diferente entre uma rede com método de regularização e outra sem (mantenha a
mesma quantidade de camadas).
x, y = make_circles(n_samples=1000, noise=0.1, factor=0.4, random_state=616)

y = y.reshape(-1, 1)
(1000, 2) (1000, 1)
plt.subplot(1,2,1)
plt.scatter(x[:, 0], x[:,1])
plt.subplot(1,2,2)
plt.scatter(x[:, 0], x[:,1], c=list(np.array(y).ravel()), s=15, cmap='bwr')
<matplotlib.collections.PathCollection at 0x7efc5bd8db10>
import numpy as np
import matplotlib.pyplot as plt
def __softmax(x):
exp = np.exp(x)
return exp / np.sum(exp, axis=1, keepdims=True)
def __compute_meshgrid(x, y):

x_min, x_max, y_min, y_max = x[:, 0].min(), x[:, 0].max(), x[:, 1].min(), x[:, 1].max
x1, x2 = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
x_mesh = np.array([x1.ravel(), x2.ravel()]).T
return x1, x2, x_mesh
def classification_predictions_custom(x, y, is_binary, nn=None, threshold=0.0, figsize=(1

ax = plt.subplot(1, size, order)
if nn is not None:
x1, x2, x_mesh = __compute_meshgrid(x, y)
y_mesh = nn.predict(x_mesh)
y_mesh = np.where(y_mesh <= threshold, 0, 1) if is_binary else np.argmax(__softma
plt.scatter(x[:, 0], x[:, 1], c=list(np.array(y).ravel()), s=s, cmap=cmap)

title = title + " = " + str(acc)
plt.title(title)
plt.contourf(x1, x2, y_mesh.reshape(x1.shape), cmap=cmap, alpha=0.5)
plt.figure(figsize=(12,6))
########################## NO REG
print("No regularization")
nn = NeuralNetwork(cost_func=binary_cross_entropy, learning_rate=0.1)
nn.layers.append(Layer(input_dim, 4, activation=tanh))
nn.layers.append(Layer(4, output_dim, activation=sigmoid))
y_pred = nn.predict(x)
print("")
acc = 100*accuracy_score(y, y_pred >= 0.5)
print("Acc: {:.2f}%".format(acc))
# plt.subplot(1,3,1)
classification_predictions_custom(x, y, is_binary=True, nn=nn, threshold=0.5, cmap='bwr',
########################## REG L1
print("Reg. L1")
nn.layers.append(Layer(input_dim, 4, reg_strength=1, reg_func=l1_regularization, activati
nn.layers.append(Layer(4, output_dim, reg_strength=1, reg_func=l1_regularization, activat
print("")
classification_predictions_custom(x, y, is_binary=True, nn=nn, threshold=0.5, title="L1",
########################## REG L2
print("Reg. L2")
nn.layers.append(Layer(input_dim, 4, reg_strength=1, reg_func=l1_regularization, activati
nn.layers.append(Layer(4, output_dim, reg_strength=1, reg_func=l1_regularization, activat
print("")
classification_predictions_custom(x, y, is_binary=True, nn=nn, threshold=0.5, title="L2",
## TODO: Ajeitar este plot
No regularization
Acc: 99.20%
Reg. L1
Acc: 99.30%
Reg. L2
Comentário: Podemos perceber
Epoch: 4200/5000 nos resultados
loss_train: acima, para separação
0.41909523+0.02243179 de círculos,
= 0.44152702 loss_val=a 0.41909523
Epoch: 4500/5000
regularização loss_train:
L1 performando 0.41354388+0.02283853
melhor em relação às técnicas= com
0.43638241
ausêncialoss_val= 0.41354388
de regularização e
regularização L2. Obtendo uma acurácia de 99.3% (L2). Porém, devido ao crescimento da
Acc: 85.20%
acurácia não ter sido tão significativa, custando em desempenho para o algoritmo, a técnica
sem regularização se mostra mais viável para este caso, com 99.2% de acurácia (NO REG).
Questão 05 - Construa uma rede neural totalmente conectada, treine-a e teste-a com
tamanhos de batchs diferentes. Em seguida, comente o comportamento da rede com
diferentes batchs sizes.
x, y = make_log10(n_samples=1000, x_min=1, x_max=100, noise=0.5)
plt.scatter(x, y)
(1000, 1) (1000, 1)
<matplotlib.collections.PathCollection at 0x7efc4c0cac50>
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)

plt.subplot(1,5,1)
plt.title('LOG-10')
plt.scatter(x, y);
# SIGMOID
nn.layers.append(Layer(input_dim=input_dim, output_dim=10, activation=tanh))

# train
# plot
plt.scatter(x, y)
plt.title('LOG-10')
# SIGMOID BATCH SIZE-10


# train
nn.fit(x, y, epochs=5000, verbose=500, batch_size=10)
# plot
plt.scatter(x, y)
plt.title('LOG-10 BATCHSIZE-10')


# train
# plot
plt.scatter(x, y)


# train
# plot
plt.scatter(x, y)

Epoch: Temos
Comentário: 4000/5000 loss_train:
acima 0.25705919+0.00000000
implementações = 0.25705919
de um modelo sobre os dados loss_val= 0.25705919
com comportamento
logaritmico
Epoch: em ordem 10
5000/5000 (Log-10). Para
loss_train: estes dados, batchsizes
0.25715778+0.00000000 maiores ajudam
= 0.25715778 o algoritmo
loss_val= a
0.25715778
se ajustar melhor,
Epoch: pois são
0/5000 capazes de
loss_train: armazenar em memória
1.58840494+0.00000000 uma quantidade
= 1.58840494 maior1.58840494
loss_val= de dados
e. NaEpoch:
ausência de batches (todo o conjunto de dados), o algoritmo performa melhor, com
1000/5000 loss_train: 0.25679710+0.00000000 = 0.25679710 loss_val= 0.25679710
loss_val em 0.25413410,
Epoch:
Questão 06 -3000/5000 loss_train:
Construa uma 0.25552504+0.00000000
rede neural = 0.25552504
totalmente conectada, loss_val=
treine-a e teste-a 0.25552504
sem/com
learning_rate decay (selecione
Epoch: 4000/5000 um dos
loss_train: métodos implementados).
0.25753295+0.00000000 Em seguida,
= 0.25753295 comente
loss_val= o que
0.25753295
Epoch: observar
foi possível 4500/5000deloss_train: 0.25636169+0.00000000
diferente entre = 0.25636169
uma rede com learning_rate decayloss_val= 0.25636169
e outra sem
(mantenha
Epoch:a mesma quantidade
0/5000 de camadas).
loss_train: 1.01518110+0.00000000 = 1.01518110 loss_val= 1.01518110
x, y = make_moons(200,
Epoch: noise=0.20) 0.25146399+0.00000000 = 0.25146399 loss_val= 0.25146399
1500/5000 loss_train:
Epoch: 3000/5000
print(x.shape, y.shape)loss_train: 0.25033656+0.00000000 = 0.25033656 loss_val= 0.25033656
Epoch: 3500/5000 loss_train:
plt.scatter(x[:,0], x[:,1], 0.25004117+0.00000000 =s=15,
c=list(np.array(y).ravel()), 0.25004117 loss_val= 0.25004117
cmap='bwr')
(200, 2) (200, 1)
<matplotlib.collections.PathCollection at 0x7efc4b92e350>
### SEM LEARNING RATE DECAY

nn.layers.append(Layer(input_dim, 40, reg_strength=1, reg_func=l2_regularization, activat
nn.layers.append(Layer(40, 30, reg_strength=1, reg_func=l2_regularization, activation=rel
nn.layers.append(Layer(30, output_dim, reg_strength=1, reg_func=l2_regularization, activa
print("Acc: {:.2f}%".format(100*accuracy_score(y, y_pred >= 0.5)))
#plt.subplot(1, 2, 1)
### COM LEARNING RATE DECAY

nn = NeuralNetwork(cost_func=binary_cross_entropy, learning_rate=0.0001, lr_decay_method=
nn.layers.append(Layer(input_dim, 40, reg_strength=1, batch_norm=True, reg_func=l2_regula
nn.layers.append(Layer(40, 30, reg_strength=1, batch_norm=True, reg_func=l2_regularizatio
nn.layers.append(Layer(30, output_dim, reg_strength=1, batch_norm=True, reg_func=l2_regul

Acc: 97.00%
Comentário: Acima vemos
Epoch: 5100/8000 os resultados
loss_train: do algoritmo sem learning
0.71832257+3.06609333 rate decay
= 3.78441589 e com 0.71832257
loss_val= learning
Epoch:(lr_decay_method=exponential_decay,
rate decay 5400/8000 loss_train: 0.71832257+3.06609333 = 3.78441589
lr_decay_rate=0.8, loss_val= 0.71832257
lr_decay_steps=100), onde a
rede sem lr_decay
Epoch: performou
6000/8000 melhor,0.71832257+3.06609333
loss_train: atingindo 97% de acurácia. Enquantoloss_val=
= 3.78441589 que, para o0.71832257
learning
Epoch:o 6300/8000
rate decay, decaimentoloss_train: 0.71832257+3.06609333
da taxa de aprendizado, = 3.78441589
usando a abordagem loss_val=fez
logaritmica, 0.71832257
com que
os passos
Epoch:de6900/8000
aprendizado fossem cada
loss_train: vez menores a cada =100
0.71832257+3.06609333 iterações,loss_val=
3.78441589 atingindo dessa
0.71832257
Epoch: 7200/8000 loss_train: 0.71832257+3.06609333
forma uma acurácia relativamente baixa (52.0%). = 3.78441589 loss_val= 0.71832257
Acc: 52.00%
Questão 07 - Construa uma rede neural totalmente conectada, treine-a e teste-a sem/com
batch normalization. Em seguida, comente o que foi possível observar de diferente entre uma
rede com batch normalization e outra sem (mantenha a mesma quantidade de camadas).
x, y = make_moons(1000, noise=0.20)
plt.scatter(x[:,0], x[:,1], c=list(np.array(y).ravel()), s=15, cmap='bwr')
(1000, 2) (1000, 1)
<matplotlib.collections.PathCollection at 0x7efc4c2efd60>
### SEM NORMALIZAÇÃO

nn.layers.append(Layer(input_dim, 40, reg_strength=1, reg_func=l2_regularization, activat
nn.layers.append(Layer(40, 30, reg_strength=1, reg_func=l2_regularization, activation=rel
nn.layers.append(Layer(30, output_dim, reg_strength=1, reg_func=l2_regularization, activa
### COM NORMALIZAÇÃO

nn.layers.append(Layer(input_dim, 40, reg_strength=1, batch_norm=True, reg_func=l2_regula
nn.layers.append(Layer(40, 30, reg_strength=1, batch_norm=True, reg_func=l2_regularizatio
nn.layers.append(Layer(30, output_dim, reg_strength=1, batch_norm=True, reg_func=l2_regul

Acc: 96.30%
Comentário: implementamos
Epoch: 2100/8000 acima uma
loss_train: classificação binária
0.29356214+0.58462136 = sobre os dados
0.87818350 de padrão
loss_val= 0.29356214
"moons", no intuito de separar as classes azul e vermelha. Para implementação sem batch
norm,Epoch:
durante3000/8000
o treinamento a descida
loss_train: do loss foi bem rápida= e0.79743083
0.25342263+0.54400820 se ajustou conseguindo uma
loss_val= 0.25342263
acurácia de 96.3%. Para implementação com batch normalization, a descida do loss aconteceu
mais Epoch:
devagar,3900/8000
tendo umloss_train:
esforço muito grande para atignir acurácia
0.22384225+0.50621641 de 96%.loss_val= 0.22384225
= 0.73005866
Questão 08 -4800/8000
Epoch: Construa uma rede neural
loss_train: totalmente conectada,
0.20143964+0.47104997 treine-a e teste-a
= 0.67248961 sem/com
loss_val= 0.20143964
dropout. Em seguida, comente o que foi possível observar de diferente entre uma rede com
dropout e outra
Epoch: sem (mantenha
5700/8000 a mesma
loss_train: quantidade de camadas).
0.18441441+0.43832653 = 0.62274094 loss_val= 0.18441441
Acc: 96.00%
x, y = make_blobs(n_samples=400, n_features=2, centers=[(-3, 0), (3, 0), (0, 3), (0, -3)]
plt.scatter(x[:,0], x[:,1], c=list(np.array(y).ravel()), s=15, cmap=plt.cm.viridis)
onehot = OneHotEncoder(sparse=False)
y_onehot = onehot.fit_transform(y)
print(y_onehot[::70])
(400, 2) (400, 1)
[[0. 0. 1. 0.]
[1. 0. 0. 0.]
[0. 0. 1. 0.]
[1. 0. 0. 0.]
[0. 0. 0. 1.]
[1. 0. 0. 0.]]
/usr/local/lib/python3.10/dist-packages/sklearn/preprocessing/_encoders.py:868: Futur
warnings.warn(
input_dim, output_dim = x.shape[1], y_onehot.shape[1]
### SEM DROPOUT

nn = NeuralNetwork(cost_func=softmax_neg_log_likelihood, learning_rate=1e-2)
nn.layers.append(Layer(input_dim, 2, activation=relu))
nn.layers.append(Layer(2, output_dim, activation=linear))
nn.fit(x, y_onehot, epochs=1000, verbose=100)
y_pred = np.argmax(nn.predict(x), axis=1)

acc = 100*accuracy_score(y, y_pred)
print('ACC: {:.2f}%'.format(acc))
classification_predictions_custom(x, y, is_binary=False, nn=nn, title="Sem dropout", size
### COM DROPOUT

nn.layers.append(Layer(input_dim, 2, activation=relu, dropout_prob=0.5))

classification_predictions_custom(x, y, is_binary=False, nn=nn, title="Com dropout", size

ACC: 74.00%
ACC: 96.50%
Comentário: Na implementação acima, podemos ver que o dropout (dropout_prob=0.5) ajudou

no aprendizado da nossa rede através da inativação de neurônios, reduzindo o modelo e
ajudando a encontrar um ajuste mais conciso, com 96.5% de acurácia. Enquanto isso, o modelo
sem dropout demorou menos para ajustar seus passos, no entanto na hora de fazer a predição,
performou pior do que o dropout, com 74% de acurácia.
momentum. Em seguida, comente o que foi possível observar de diferente entre uma rede com
momentum e outra sem (mantenha a mesma quantidade de camadas).
x, y = make_classification(n_samples=100, n_classes=4, n_features=2, n_clusters_per_class

(100, 2) (100, 1)
warnings.warn(
#BUILD
nn.layers.append(Layer(input_dim, 30,dropout_prob=0.7, activation=relu))
nn.layers.append(Layer(30, 20,dropout_prob=0.7, activation=relu))
#TRAIN
#EVALUATION

classification_predictions_custom(x, y, is_binary=False, nn=nn, title="Sem momentum", siz
#BUILD
nn = NeuralNetwork(cost_func=softmax_neg_log_likelihood, learning_rate=1e-2, momentum=0.4
nn.layers.append(Layer(input_dim, 30,dropout_prob=0.7, activation=relu))
#TRAIN
#EVALUATION

classification_predictions_custom(x, y, is_binary=False, nn=nn, title="Com momentum", siz

ACC: 88.00%
ACC: 92.00%
Comentário: acima pode-se observar o resultado da implementação dos modelos de

classificação multi-classe com momento e sem momentum, onde o modelo com momentum
(0.4) performou melhor, atingindo uma acurácia de 92%, enquanto o modelo sem momentum
atingiu uma acurácia de 88%. O momentum aplica uma "força" na direção da curva de erro
durante o processo de aprendizado, ajudando o aprendiz a se ajustar mais rápido.
early stopping. Em seguida, comente o impacto causado por early stopping e sua utilidade.
x, y = make_classification(n_samples=1000, n_classes=4, n_features=2, n_clusters_per_clas

(1000, 2) (1000, 1)
<matplotlib.collections.PathCollection at 0x7fbcc84d2ce0>
warnings.warn(
keyboard_arrow_down Rede Neural sem Early Stop
#BUILD
nn.layers.append(Layer(input_dim, 30,dropout_prob=0.7, activation=tanh))
#TRAIN
#EVALUATION
print('ACC: {:.2f}%'.format(100*accuracy_score(y, y_pred)))

plot.classification_predictions(x, y, is_binary=False, nn=nn)

ACC: 85.80%
keyboard_arrow_down Rede Neural com Early Stop
#BUILD
nn.layers.append(Layer(input_dim, 30,dropout_prob=0.7, activation=tanh))
#TRAIN
#EVALUATION
print('ACC: {:.2f}%'.format(100*accuracy_score(y, y_pred)))

plot.classification_predictions(x, y, is_binary=False, nn=nn)

Early Stopping at 2151 epoch
ACC: 85.60%

Relatorio - ML - PAVIC - Wallison - Ipynb - Colaboratory

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Relatorio - ML - PAVIC - Wallison - Ipynb - Colaboratory

Enviado por

Direitos autorais:

Formatos disponíveis

14/12/2023, 21:48 Relatorio_ML_PAVIC_Wallison.

QUESTIONÁRIO DE MACHINE LEARNING - PARTE I

Nome: Wallison Santos Ferreira

Disciplina: Machine Learning

Professor: Salomão Machado Mafalda

Double-click (or enter) to edit

from sklearn.metrics import accuracy_score

keyboard_arrow_down Funções de Ativação

def linear(x, derivative=False):

def sigmoid(x, derivative=False):

def tanh(x, derivative=False):

def relu(x, derivative=False):

def leaky_relu(x, derivative=False):

def elu(x, derivative=False):

keyboard_arrow_down Funções de Custo

def mse(y, y_pred, derivative=False):

##### Classificação binária

def sigmoid_cross_entropy(y, y_pred, derivative=False):

##### Classificação multi-classe

def softmax_neg_log_likelihood(y_oh, y_pred, derivative=False):

keyboard_arrow_down Inicialização de pesos

def ones(rows, cols):

def random_normal(rows, cols):

def random_uniform(rows, cols):

def glorot_normal(rows, cols):

def glorot_uniform(rows, cols):

keyboard_arrow_down Batch Generator

for batch in range(n_batches):

def batch_shuffle(x, y, batch_size=None):

keyboard_arrow_down Learning Rate Decay

keyboard_arrow_down Batch Normalization

def batchnorm_backward(layer, dactivation):

dx_norm = dactivation * layer.gamma

dx = (dx_norm * std_inv) + (dvar * 2.0 * x_mu / m) + (dmu / m)

keyboard_arrow_down Implementação da Rede Neural

self._dgamma, self._dbetta = None, None

self.patience, self.waiting = patience, 0

def fit(self, x_train, y_train, x_val=None, y_val=None, epochs=100, verbose=10, batch_g

for epoch in range(epochs+1):

for x_batch, y_batch in batch_gen(x_train, y_train, batch_size):

loss_val = self.cost_func(y_val, self.predict(x_val))

def predict(self, x):

def __feedforward(self, x, is_training=True):

for current_layer, next_layer in zip(self.layers, self.layers[1:] + [Layer(0,0)]):

def __backprop(self, y, y_pred):

dactivation = batchnorm_backward(layer, dactivation) if layer.batch_norm else dacti

last_delta = np.dot(dactivation, layer.weights)

layer._dweights = np.dot(dactivation.T, layer.input)

for layer in reversed(self.layers):

Épocas: O momento do recebimento de um conjunto de indivíduos, as operações da rede

Camadas: estão presentes na rede neural e representa um conjunto de neurônios. A camada de

Função de ativação: A função de ativação transmite o aprendizado obtido entre as camadas da

x, y = make_cubic(n_samples=100, x_min=-4, x_max=4, a=1, b=0, c=-10, d=0, noise=3)

minmax = MinMaxScaler(feature_range=(-1, 1))

input_dim, output_dim = x.shape[1], y.shape[1]

##### RANDOM NORMAL

Random Normal: 5000 - loss_train 1.49754506

Ones: 5000 - loss_train 51.26945633

no comportamento de uma rede neural ao alterar as camadas de ativação (mantenha a mesma

nn.layers.append(Layer(input_dim=input_dim, output_dim=10, activation=linear))

nn.layers.append(Layer(input_dim=input_dim, output_dim=10, activation=linear))

Epoch: 0 / 5000 loss_train 2.42138316

A implementação da arquitetura com funções de ativação sigmoidal performou melhor do que a