Nesta parte do trabalho, será implementada a Regressão Logística Regularizada para prever se os microchips de uma usina de fabricação passam na garantia de qualidade (QA). Durante a QA, cada microchip passa por vários testes para garantir se está funcionando corretamente. Dessa forma, a Gestão de Produto da fábrica terá o resultados de teste para alguns microchips em dois testes diferentes.
A partir desses dois testes, será determinado se os microchips deveriam ser aceitos ou rejeitados. Para auxiliar a tomar a decisão, há um conjunto de dados com resultados de testes anteriores sobre microchips, a partir do qual é possível construir um modelo de Regressão Logística.
O arquivo {ex2data2.txt} contém os dados a serem usados nessa parte do trabalho. A primeira coluna corresponde aos resultados do primeiro teste, enquanto que a segunda coluna corresponde aos resultados do segundo teste. A terceira coluna contém os valores da classe (y = 0 significa rejeitado no teste, e y = 1 significa aceito no teste).
Para a maioria dos conjuntos de dados do mundo real, não é possível criar um gráfico para visualizar seus pontos. Mas, para o conjunto de dados fornecido, isso é possível. Implemente um script em Python que produza um gráfico de dispersão (scatter plot) dos dados fornecidos. Após finalizado, seu script deve produzir um resultado similar ao apresentado na Figura abaixo.
In [39]:
#import os
import pandas as pd
import numpy as np
import matplotlib as plt
from numpy import loadtxt, where, append, zeros, ones, array, linspace, logspace
from pylab import scatter, show, legend, xlabel, ylabel
#%matplotlib inline
# Carregando o arquivo gerado pelo MATLAB
#import scipy.io
#mat = scipy.io.loadmat('file.mat')
In [40]:
# Construindo um dataset com base num Dataframe, já identificando colunas e exibindo seus primeiros 20 registros.
df = pd.read_csv('am-T2-dados/ex2data2.txt', names=['QATest1', 'QATest2', 'QAcceptance'])
df.head()
Out[40]:
In [41]:
# Visualização da Distribuição dos Dados conforme Histograma
df.hist()
plt.pyplot.show()
df.QATest1.hist(), df.QATest2.hist(), df.QAcceptance.hist()
plt.pyplot.show()
In [42]:
df.describe()
Out[42]:
In [43]:
df.QATest1.describe().round(2)
Out[43]:
In [44]:
df.QATest2.describe().round(2)
Out[44]:
In [45]:
df.QAcceptance.describe().round(2)
Out[45]:
In [46]:
#df.drop(labels='QATest1', axis=1)
#df.drop(labels='QATest2', axis=1)
#df.drop(labels='QAcceptance', axis=1)
#load the dataset
data = np.loadtxt('am-T2-dados/ex2data2.txt', delimiter=',')
In [ ]:
In [48]:
X = data[:, 0:2]
y = data[:, 2]
pos = where(y == 1)
neg = where(y == 0)
scatter(X[pos, 0], X[pos, 1], marker='+', c='xkcd:black', label='Not Admitted')
scatter(X[neg, 0], X[neg, 1], marker='o', c='xkcd:yellow', label='Admitted')
legend(['Admitted', 'Not Admitted'])
xlabel('Exam 1 score')
ylabel('Exam 2 score')
show()
Uma maneira de tornar os dados mais apropriados para a classificação é criar
mais características a partir das já existentes. Para isso, você deve criar uma
função mapFeature. Essa função deve ser implementada em um arquivo de
nome mapFeature.py, que irá mapear as características para todos os termos
polinomiais de x1 e x2, até a sexta potência. Como resultado desse mapeamento, nosso
vetor de duas características (os escores nos dois testes de QA) será transformado
em um vetor de 28 dimensões.
Um classificador que usa regressão logística treinado nesse vetor de características de maior dimensão terá uma fronteira de decisão mais complexa e parecerá não-linear quando desenhado em um gráfico bidimensional.
Embora o mapeamento de características nos permita construir um classificador mais expressivo, também é mais suscetível a sobreajuste (overfitting). Desse modo, será implementada a Regressão Logística Regularizada sobre os dados fornecidos e também verá como a regularização pode ajudar a combater o problema do sobreajuste.
In [ ]:
In [49]:
def map_feature(X1, X2):
'''
Função que mapeia características p/ os termos polinomiais X1 e X2 até a 6ª potência.
Retorna um novo conjunto com mais características, através do algoritmo de mapping
X1, X2, X1 ** 2, X2 ** 2, X1*X2, X1*X2 ** 2, etc...
Os parâmetros X1, X2 devem ser do mesmo tamanho
'''
# Potência padrão para o mapeamento
potencia = 6
X1.shape = (X1.size, 1)
X2.shape = (X2.size, 1)
features = np.ones(shape=(X1.size, 1))
for i in range(1, potencia + 1):
for j in range(i + 1):
r = (X1 ** (i - j)) * (X2 ** j)
features = append(features, r, axis=1)
return features
In [50]:
X = data[:, 0:2]
y = data[:, 2]
pos = where(y == 1)
neg = where(y == 0)
scatter(X[pos, 0], X[pos, 1], marker='o', c='b')
scatter(X[neg, 0], X[neg, 1], marker='x', c='r')
xlabel('Microchip Test 1')
ylabel('Microchip Test 2')
legend(['y = 1', 'y = 0'])
m, n = X.shape
y.shape = (m, 1)
it = map_feature(X[:, 0], X[:, 1])
In [51]:
it.shape
Out[51]:
In [52]:
print(pd.DataFrame(it))
Agora, você deverá implementar o código para calcular a função de custo e o gradiente para a regressão logística regularizada. Crie um arquivo de nome costFunctionReg.py que contém uma função de nome costFunctionReg.py e que computa o custo e o gradiente. Lembre-se de que a função de custo regularizada na regressão logística é dada por:
$$J_{regularizado} = \small \underbrace{-\frac{1}{m} \sum\limits_{i = 1}^{m} \large{(}\small y^{(i)}\log\left(x^{(i)}\right) + (1-y^{(i)})\log\left(1- x^{(i)}\right) \large{)} }_\text{Função de Custo} + \underbrace{\frac{\lambda}{2m} \sum\limits_{j = 1}^{n}\ {\theta}_{j}^{2} }_\text{Fator Regularização} $$Depois de concluir a implementação da função costFunctionReg, você deve
testar a corretude dela usando o valor inicial de ${\theta}$ (inicializado todo com zeros).
Você deve ver que o custo é de cerca de 0.693.
Porém, usando a função costFunctionReg, você agora deve computar os valores ótimos para ${\theta}$.
In [53]:
from numpy import loadtxt, where, zeros, e, array, log, ones, append, linspace
from pylab import scatter, show, legend, xlabel, ylabel, contour, title
from scipy.optimize import fmin_bfgs
def sigmoid(X):
'''Compute the sigmoid function '''
den = 1.0 + e ** (-1.0 * X)
d = 1.0 / den
return d
def cost_function_reg(theta, X, y, l):
'''Compute the cost and partial derivatives as grads
'''
h = sigmoid(X.dot(theta))
thetaR = theta[1:, 0]
J = (1.0 / m) * ((-y.T.dot(log(h))) - ((1 - y.T).dot(log(1.0 - h)))) + (l / (2.0 * m)) * (thetaR.T.dot(thetaR))
delta = h - y
sumdelta = delta.T.dot(X[:, 1])
grad1 = (1.0 / m) * sumdelta
XR = X[:, 1:X.shape[1]]
sumdelta = delta.T.dot(XR)
grad = (1.0 / m) * (sumdelta + l * thetaR)
out = zeros(shape=(grad.shape[0], grad.shape[1] + 1))
out[:, 0] = grad1
out[:, 1:] = grad
return J.flatten(), out.T.flatten()
In [54]:
from scipy.optimize import fmin_bfgs
m, n = X.shape
y.shape = (m, 1)
it = map_feature(X[:, 0], X[:, 1])
#Initialize theta parameters
initial_theta = zeros(shape=(it.shape[1], 1))
#Set regularization parameter lambda to 1
regularizacao = 1
# Compute and display initial cost and gradient for regularized logistic regression
cost, grad = cost_function_reg(initial_theta, it, y, regularizacao)
#def decorated_cost(theta):
# return cost_function_reg(theta, it, y, l)
#cost_function_reg(theta, it, y, l)
#print fmin_bfgs(decorated_cost, initial_theta, args=(it, y, l), maxfun=400)
cost, grad
Out[54]:
Nessa parte, você deve esboçar (plotar) a fronteira de decisão que foi aprendida
para separar os exemplos positivos dos negativos. Crie uma arquivo de nome
plotDecisionBoundary.py, para criar esse gráfico que traça o limite da decisão
não-linear. Seu gráfico deve ser semelhante ao apresentado na Figura abaixo.
In [60]:
#Plot Boundary
l = 1
m, n = X.shape
y.shape = (m, 1)
it = map_feature(X[:, 0], X[:, 1])
theta = ones(shape=(it.shape[1], 1))
u = linspace(-1, 1.5, 50)
v = linspace(-1, 1.5, 50)
z = zeros(shape=(len(u), len(v)))
for i in range(len(u)):
for j in range(len(v)):
z[i, j] = (map_feature(array(u[i]), array(v[j])).dot(array(theta)))
z = z.T
contour(u, v, z)
title('lambda = %f' % l)
xlabel('Microchip Test 1')
ylabel('Microchip Test 2')
legend(['y = 1', 'y = 0', 'Decision boundary'])
show()
In [61]:
#load the dataset
data2 = np.loadtxt('am-T2-dados/ex2data2.txt', delimiter=',')
In [82]:
#y = np.c_[data2[:,2]]
y = data2[:,2]
y.shape = (y.size, 1)
X = data2[:,0:2]
In [89]:
print(y.shape)
In [84]:
#it = map_feature(X[:, 0], X[:, 1])
X_feature = map_feature(X[:, 0], X[:, 1])
X_feature.shape
Out[84]:
In [85]:
def costFunctionReg(theta, reg, X, y):
m = y.size
h = sigmoid(X.dot(theta))
J = -1*(1/m)*(np.log(h).T.dot(y)+np.log(1-h).T.dot(1-y)) + (reg/(2*m))*np.sum(np.square(theta[1:]))
if np.isnan(J[0]):
return(np.inf)
return(J[0])
In [86]:
def gradientReg(theta, reg, X, y):
m = y.size
h = sigmoid(X.dot(theta.reshape(-1,1)))
grad = (1/m)*X.T.dot(h-y) + (reg/m)*np.r_[[[0]],theta[1:].reshape(-1,1)]
return(grad.flatten())
In [87]:
initial_theta = np.zeros(X_feature.shape[1])
costFunctionReg(initial_theta, 1, X_feature, y)
Out[87]:
In [100]:
initial_theta
Out[100]:
Para melhor entender a função de custo, você irá nessa parte do trabalho plotar o custo sobre uma grade bidimensional de valores de 0 e de 1. Para isso, você deve usar sua implementação da função computarCusto.
O código que você deve implementar deve gerar um array bidimensional de valores de J(ø). Os valores gerados pelo seu código devem estar na faixa a seguir: -10;0;+10 e -1;+4. Utilize incremento de 0.01 para gerar os valores de 0 e de 1.
A seguir, usando a função matplotlib.pyplot.contour da biblioteca matplotlib, produza um gráfico de curvas de contorno (contour plot). Também utilizando a biblioteca matplotlib, crie um gráfico da superfície correspondente a J(ø).
In [92]:
import pandas as pd
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from sklearn.preprocessing import PolynomialFeatures
pd.set_option('display.notebook_repr_html', False)
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', 150)
pd.set_option('display.max_seq_items', None)
#%config InlineBackend.figure_formats = {'pdf',}
%matplotlib inline
import seaborn as sns
sns.set_context('notebook')
sns.set_style('white')
In [95]:
def predict(theta, X, threshold=0.5):
p = sigmoid(X.dot(theta.T)) >= threshold
return(p.astype('int'))
def loaddata(file, delimeter):
data = np.loadtxt(file, delimiter=delimeter)
print('Dimensions: ',data.shape)
print(data[1:6,:])
return(data)
def plotData(data, label_x, label_y, label_pos, label_neg, axes=None):
# Get indexes for class 0 and class 1
neg = data[:,2] == 0
pos = data[:,2] == 1
# If no specific axes object has been passed, get the current axes.
if axes == None:
axes = plt.gca()
axes.scatter(data[pos][:,0], data[pos][:,1], marker='+', c='k', s=60, linewidth=2, label=label_pos)
axes.scatter(data[neg][:,0], data[neg][:,1], c='y', s=60, label=label_neg)
axes.set_xlabel(label_x)
axes.set_ylabel(label_y)
axes.legend(frameon= True, fancybox = True);
In [99]:
fig, axes = plt.subplots(1,3, sharey = True, figsize=(17,5))
# Decision boundaries
# Lambda = 0 : No regularization --> too flexible, overfitting the training data
# Lambda = 1 : Looks about right
# Lambda = 100 : Too much regularization --> high bias
for i, C in enumerate([0, 1, 100]):
# Optimize costFunctionReg
res2 = minimize(costFunctionReg, initial_theta, args=(C, X_feature, y), method=None, jac=gradientReg, options={'maxiter':3000})
# Accuracy
accuracy = 100*sum(predict(res2.x, X_feature) == y.ravel())/y.size
# Scatter plot of X,y
plotData(data2, 'Microchip Test 1', 'Microchip Test 2', 'y = 1', 'y = 0', axes.flatten()[i])
# Plot decisionboundary
x1_min, x1_max = X[:,0].min(), X[:,0].max(),
x2_min, x2_max = X[:,1].min(), X[:,1].max(),
xx1, xx2 = np.meshgrid(np.linspace(x1_min, x1_max), np.linspace(x2_min, x2_max))
h = sigmoid(X_feature.fit_transform(np.c_[xx1.ravel(), xx2.ravel()]).dot(res2.x))
h = h.reshape(xx1.shape)
axes.flatten()[i].contour(xx1, xx2, h, [0.5], linewidths=1, colors='g');
axes.flatten()[i].set_title('Train accuracy {}% with Lambda = {}'.format(np.round(accuracy, decimals=2), C))
Nessa parte do trabalho, você irá implementar a regressão linear com múltiplas variáveis para predizer o preço de venda de imóveis. O arquivo ex1data2.txt contém informações acerca de preços de imóveis. A primeira coluna corersponde ao tamanho do imóvel (em pés quadrados). A segunda coluna corresponde à quantidade de dormitórios no imóvel em questão. A terceira coluna corresponde ao preço do imóvel.
In [ ]:
# Carregando o dataset na forma de txt, porque tem melhor desempenho p/ representação gráfica e
# principalmente na vertorização, se comparado ao Dataframe, utilizado na primeira seção deste trabalho.
data = np.loadtxt('am-T1-dados/ex1data2.txt', delimiter=',')
In [ ]:
data
In [ ]:
# Inicializando visualização gráfica
plano = plt.figure()
plano = plano.add_subplot(111, projection='3d')
# Criação dos pontos ('x' vermelhos) para o gráfico
for c, m in [('red', 'x')]:
tamanho = data[:, 0]
quartos = data[:, 1]
valor = data[:, 2]
plano.scatter(tamanho, quartos, valor, c=c, marker=m)
# Plotando o Gráfico
plano.set_xlabel('Tamanho')
plano.set_ylabel('Nº de Quartos')
plano.set_zlabel('Valor do Imóvel')
show()
Se você inspecionar os valores do conjunto de dados fornecido, irá notar que os tamanhos dos imóveis são aproximadamente 1000 vezes maiores que as quantidades encontradas na coluna de quantidade de dormitórios. Sua tarefa nessa parte é implementar uma função denominada normalizarCaracteristica em um arquivo denominado normalizarCaracteristica.py. Essa função deve:
A sua função normalizarCaracteristica deve a matriz de dados X de dados como parâmetro (na forma de um numpy array). Além disso, essa função deve funcionar com conjuntos de dados de variados tamanhos (qualquer quantidade de características / exemplos). Repare que cada coluna da matriz de dados X passada para a função normalizarCaracteristica deve corresponder a um característica.
Nota de Implementação: Ao normalizar as características, é importante armazenar os valores utilizados para a normalização - o valor médio e o desvio padrão utilizados para a normalização. Depois de aprender os parâmetros do modelo, muitas vezes queremos prever os preços das casas que não temos visto antes. Dado um novo valor x (área da sala de estar e número de quartos), devemos normalizar x usando a média e o desvio padrão que nós previamente calculamos a partir do conjunto de treinamento.
In [ ]:
def normalizarCaracteristica(X):
'''
Retorna uma versão normalizada de X onde o valor médio de cada característica é 0
e o desvio padrão é 1. Este é frequentemente um bom passo de pré-processamento
a ser feito ao trabalhar com algoritmos de aprendizado.
'''
valormedio = []
desviopadrao = []
X_Normalizado = X
for i in range(X.shape[1]):
m = np.mean(X[:, i])
s = np.std(X[:, i])
valormedio.append(m)
desviopadrao.append(s)
X_Normalizado[:, i] = (X_Normalizado[:, i] - m) / s
return X_Normalizado, valormedio, desviopadrao
Anteriormente, você implementou o GD em uma regressão linear univariada. A única diferença agora é que há mais uma característica na matriz de dados X. A função de hipótese h(x) e a atualização dos gradientes em lote permanecem inalteradas. Você deve implementar código nos arquivos denominados computarCustoMulti.py e gdmulti.py para implementar a função de custo e o algoritmo GD para regressão linear com múltiplas variáveis, respectivamente. Se o seu código na parte anterior (variável única) já provê suporte a múltiplas variáveis, você também pode reusá-lo aqui. Se assegure de que o seu código dá suporte a qualquer número de características e está bem vetorizado.
In [ ]:
def computarCustoMulti(X, y, theta):
'''
Função que computa o custo para Regressão Linear com múltiplas variáveis.
'''
# Número do conjunto de treinamento
m = y.size
J = (1 / (2 * m)) * (X.dot(theta) - y).T.dot(X.dot(theta) - y)
return J
In [ ]:
def gradienteDescendenteMulti(X, y, theta, alpha, iteracoes):
'''
Essa função calcula o gradiente descendente conforme o Theta, e com
etapas de iteracoes gradiente mediante a taxa de aprendizado em Alpha.
'''
m = y.size
J = np.zeros(shape=(iteracoes, 1))
for i in range(iteracoes):
hipotese = X.dot(theta)
for it in range(theta.size):
temp = X[:, it]
temp.shape = (m, 1)
errors_x1 = (hipotese - y) * temp
theta[it][0] = theta[it][0] - alpha * (1.0 / m) * errors_x1.sum()
J[i, 0] = computarCustoMulti(X, y, theta)
return J
In [ ]:
X = data[:, :2]
y = data[:, 2]
# Tamanho do conjunto de treinamento
m = y.size
y.shape = (m,1)
# Normalizando X, obtendo Média e Desvio-padrão
x, media, desviopadrao = normalizarCaracteristica(X)
# Adicionando uma coluna de 1's ao novo X
Xnovo = np.ones(shape=(m, 3))
Xnovo[:, 1:3] = x
# Atributos para a função GradienteDescendenteMulti
iteracao = 100 # Número de repeticões p/ o algoritmo
alpha = 0.01 # Taxa de aprendizado
# Inicializando o Theta p/ execução da função GradienteDescendenteMulti
theta = np.zeros(shape=(3, 1))
J = gradienteDescendenteMulti(Xnovo, y, theta, alpha, iteracao)
plot(np.arange(iteracao), J)
xlabel('Iteracões')
ylabel('Função de Custo')
show()
Nessa parte do trabalho, você irá implementar a regressão logística. Em particular, você irá criar uma classificador para predizer se um estudante será admitido em uma universidade, com base nos resultados de duas avaliações. Suponha que estão disponíveis dados históricos acerca de realizações passadas dessas avaliações, e que esses dados históricos podem ser usados como conjunto de treinamento. Para cada exemplo desse conjunto de treinamento, temos as notas das duas avaliações e a decisão acerca do candidato (aprovado ou reprovado).
Sua tarefa é construir um modelo de classificação que provê uma estimativa da probabilidade de admissão de um candidato, com base na notas que ele obteve nas duas avaliações.
O arquivo ex2data1.txt contém os dados a serem usados nessa parte do trabalho.
Antes de começar a implementar qualquer algoritmo de aprendizado, é adequado visualizar os dados, quando possível. Nessa parte do trabalho, você deve carregar o arquivo com o conjunto de treinamento e plotar (i.e., produzir um gráfico) os pontos de dados. O resultado dessa tarefa deve ser um gráfico similar ao apresentado na Figura abaixo.
In [ ]:
# carregando os dados
data = np.loadtxt('am-T1-dados/ex2data1.txt', delimiter=',', usecols=(0,1,2), unpack=True)
In [ ]:
# Transportando matriz
X = np.transpose(np.array(data[:2]))
y = np.transpose(np.array(data[2:]))
# Tamanho do conjunto de treinamento
m = y.size
# Adicionando uma coluna de 1's ao novo X
X = np.insert(X,0,1,axis=1)
# Classificando a amostra em Positiva (data[:, 2]=1) e Negativa(data[:, 2]=0)
X_Admitted = np.array([X[i] for i in range(X.shape[0]) if y[i] == 1])
X_Nadmitted = np.array([X[i] for i in range(X.shape[0]) if y[i] == 0])
plt.figure(figsize=(16,8))
plt.plot(X_Admitted[:, 1], X_Admitted[:, 2],'k+',label='Admitted')
plt.plot(X_Nadmitted[:, 1], X_Nadmitted[:, 2],'yo',label='Not admitted')
plt.title('Gráfico Decision Boundary p/ admissão de candidato', fontsize=18, fontweight='bold')
plt.xlabel('Exam 1 Score', fontweight='bold')
plt.ylabel('Exam 2 Score', fontweight='bold')
plt.legend()
plt.grid(False)
plt.show()
Como primeiro passo nessa parte, implemente a função em Python que calcula o valor da função sigmoide. Defina essa função em um arquivo denominado sigmoide.py, de tal forma que ela possa ser chamada de outras parte do seu código. Após finalizar sua implementação, você pode verificar sua corretude:
O seu código também deve funcionar com vetores (i.e., o seu código deve estar vetorizado). Em particular, se uma matriz for passada, o seu código deve aplicar a função sigmoide a cada componente.
In [ ]:
def sigmoid(x):
'''
A função sigmoid
'''
g = np.array([x]).flatten()
s = 1 / (1 + np.exp(-g))
return s
In [ ]:
print('\t ########################### Teste para função sigmoid(0) ###########################\n')
print('\t O Valor da Sigmoid(0) é', sigmoid(0))
print('\t O Valor da Sigmoid([0,1,2,3000]) é', sigmoid(np.array([0,1,2,3000])))
print('\t ######################################################################################\n')
In [ ]:
# Exibindo o gráfico da função Sigmoid
X_teste = np.arange(-6,6,.5)
plt.plot(X_teste, sigmoid(X_teste))
plt.title("Função Sigmoid", fontsize=18, fontweight='bold')
plt.grid(True)
plt.show()
Agora, você deverá implementar a função de custo para a regressão logística. Essa função deve retornar o valor de função de custo e o gradiente. Implemente esse código em um arquivo denominado funcaoCustoRegressaoLogistica.py. Lembre-se de que o gradiente é um vetor com o mesmo número de elementos que ø.
Uma vez que tenha implementado essa função, realize uma chamada usando o valor inicial de ø. Você deve confirmar que o valor produzido é aproximadamente 0.693.
In [ ]:
def custoJ(theta, X, y):
'''
A função custoJ retorna o valor de função de custo:
X é uma matrix com n-colunas e m-linhas
y é um vetor com m-linhas
theta é um vetor n-dimensional
Obs.: Será utilizada para facilitar o cálculo de minimização.
'''
m = len(y)
H = sigmoid(X.dot(theta).T)
J = -np.sum( y* np.log(H) + (1-y) * np.log(1-H))/m
return J
In [ ]:
def custoRegressaoLogistica(theta, X, y):
'''
A função funcaoCustoRegressaoLogistica retorna o valor de função de custo e o gradiente.
Returna J, gradiente:
X é uma matrix com n-colunas e m-linhas
y é um vetor com m-linhas
theta é um vetor n-dimensional
'''
# Calcula o Custo
m = len(y)
H = sigmoid(X.dot(theta).T)
J = -np.sum( y* np.log(H) + (1-y) * np.log(1-H))/m
# Calcula o Gradiente
erro = H-y
gradiente = []
for i in range(len(X.columns)):
gradiente.append(np.sum(erro*(X.iloc[:,i]))/m)
return J, gradiente
Para a regressão logística, o objetivo é minimizar J(ø) com relação ao vetor de parâmetros ø. Sendo assim, nessa parte você deve implementar uma função em Python para encontrar o vetor ø que minimiza a função de custo. Utilize a função funcaoCustoRegressaoLogistica que você implementou previamente.
In [ ]:
from scipy import optimize
def minimizar(theta, X, y):
'''
A função minimizar J(ø) com relação ao vetor de parâmetros ø
'''
minimo = optimize.fmin(func=custoJ, x0=theta, args=(X, y), maxiter=1000, full_output=True)
return minimo[0], minimo[1]
In [12]:
# Utilizando uma segunda estrutura de dados
import pandas as pd
dfQA = pd.read_csv('am-T2-dados/ex2data2.txt', names=['Exame1', 'Exame2', 'Admissao'])
X = dfQA.iloc[:, :2]
y = dfQA.iloc[:, 2]
X.head()
Out[12]:
In [13]:
#add a column of ones to the feature matrix X to account for theta 0
m = len(y)
X.insert(0, "theta0",value=pd.Series(np.ones([m])))
X.head()
Out[13]:
In [18]:
# Apresentando uma visualização gráfica com base na classificação
from seaborn import lmplot
import matplotlib.pyplot as plt
g = lmplot("Exame1", "Exame2", hue="Admissao", data=dfQA, fit_reg=True, palette = "dark", markers = ["o","x"], legend = True)
plt.xlabel("Exame 1 Score")
plt.ylabel("Exame 2 Score")
plot_x = np.array([min(X.iloc[:,2])-2, max(X.iloc[:,2])+2])
plt.ylim(30,100)
plt.show()
In [19]:
theta0 = np.zeros([X.shape[1], 1])
hypothesis = sigmoid(X.dot(theta0).T)
print(hypothesis)
In [ ]:
print(custoRegressaoLogistica(theta0, X, y))
In [ ]:
#
print(custoJ(theta0, X, y))
In [ ]:
# Avaliando a minimização
X_min, theta_min = minimizar(theta0, X, y)
print(X_min, theta_min)
Após o aprendizado dos parâmetros, você pode usar o modelo correspondente para predizer se um candidato qualquer será aprovado. Para um candidato com notas 45 e 85 na primeira e segunda avaliações, respectivamente, você deve esperar que ele seja aprovado com probabilidade de 77.6%.
Outro modo de avaliar a qualidade dos parâmetros é verificar o quão bem o modelo aprendido prediz os pontos de dados do conjunto de treinamento. Nessa parte, você deve implementar uma função denominada predizer. Essa função deve produzir os valores 0 ou 1, dados um exemplo do conjunto de treinamento o vetor de parâmetros ø. Use essa função para produzir a porcentagem de acertos do seu classificador sobre o conjunto de treinamento.
In [ ]:
def predizer(theta, X):
P = sigmoid(X.dot(theta))
return (P >= 0.5).astype(int)
In [ ]:
# Predição de Admissão do candidato
A = np.array([1,45,85])
H = sigmoid(A.dot(X_min))
# Efetuando predição p/ Admissão de um candidato com notas 45 e 85 na primeira e segunda avaliações
print('\t ###################################### ALUNO TESTE #################################\n')
print('\t Para as notas 45 e 85 no 1º e 2º Exame prevê a probabilidade de admissão de %f' % H)
print('\t ######################################################################################\n')
The standard way to avoid overfitting is called L2 regularization. It consists of appropriately modifying your cost function, from: $$J = -\frac{1}{m} \sum\limits_{i = 1}^{m} \large{(}\small y^{(i)}\log\left(a^{[L](i)}\right) + (1-y^{(i)})\log\left(1- a^{[L](i)}\right) \large{)} \tag{1}$$ To: $$J_{regularized} = \small \underbrace{-\frac{1}{m} \sum\limits_{i = 1}^{m} \large{(}\small y^{(i)}\log\left(a^{[L](i)}\right) + (1-y^{(i)})\log\left(1- a^{[L](i)}\right) \large{)} }_\text{cross-entropy cost} + \underbrace{\frac{1}{m} \frac{\lambda}{2} \sum\limits_l\sum\limits_k\sum\limits_j W_{k,j}^{[l]2} }_\text{L2 regularization cost} \tag{2}$$
Let's modify your cost and observe the consequences.
Exercise: Implement compute_cost_with_regularization() which computes the cost given by formula (2). To calculate $\sum\limits_k\sum\limits_j W_{k,j}^{[l]2}$ , use :
np.sum(np.square(Wl))
Note that you have to do this for $W^{[1]}$, $W^{[2]}$ and $W^{[3]}$, then sum the three terms and multiply by $ \frac{1}{m} \frac{\lambda}{2} $.
In [ ]:
In [6]:
import numpy as np
# função de custo
def loss_function(theta, X, y, Lambda):
m = y.size
H = np.subtract(X,y)
J = 1/(2*m) * np.sum(H**2)
custo = J + (1/(2*m) * np.multiply(Lambda,np.sum(theta**2)))
return custo
def prints(self, epoch):
print("--epoca %s: " % epoch)
print("loss: ", self.loss[epoch])
print("theta: ", self.theta_0.reshape(theta[0].shape[0]), self.theta_n.reshape(theta[1].shape[0]))
def gradient_descent(self, epochs, X, Y, learning_rate, Lambda, m, print_results):
for i in xrange(epochs):
# calcula H
H = np.dot(self.theta_n.T, X) + self.theta_0
# calcula gradientes
gH = H - Y
gTheta_n = np.dot(X, gH.T)/m
gTheta_0 = np.sum(gH)/m
# calcula função de custo
loss = self.loss_function(Y, gH, Lambda, m)
self.loss.append(loss)
# atualiza pesos
self.theta_0 -= learning_rate*gTheta_0
self.theta_n = self.theta_n*(1-(learning_rate*Lambda/m)) - learning_rate*gTheta_n
if print_results:
self.prints(i)
# calcula função de custo final
# calcula H
H = np.dot(self.theta_n.T, X) + self.theta_0
# calcula gradientes
gH = H - Y
loss = self.loss_function(Y, gH, Lambda, m)
self.loss.append(loss)
In [ ]: