Recentemente, completei o exercício 3 do Machine Learning de Andrew Ng no Coursera usando Python .
Ao concluir inicialmente as partes 1.4 a 1.4.1 do exercício, tive dificuldades para garantir que meu modelo treinado tenha a precisão que corresponde aos 94,9% esperados. Mesmo após a depuração e a garantia de que minhas funções de custo e gradiente estavam livres de erros e que meu código de previsão estava funcionando corretamente, eu ainda estava obtendo apenas 90,3% de precisão. Eu estava usando o algoritmo de gradiente conjugado (CG) em scipy.optimize.minimize.
Por curiosidade, decidi tentar outro algoritmo e usei Broyden – Fletcher – Goldfarb – Shannon (BFGS). Para minha surpresa, a precisão melhorou drasticamente para 96,5% e, portanto, excedeu a expectativa. A comparação desses dois resultados diferentes entre CG e BFGS pode ser vista no meu notebook, sob o cabeçalho Diferença de precisão devido a diferentes algoritmos de otimização .
O motivo dessa diferença de precisão é devido à escolha diferente do algoritmo de otimização? Se sim, alguém poderia explicar o porquê?
Além disso, eu apreciaria muito qualquer revisão do meu código apenas para garantir que não haja um bug em nenhuma das minhas funções que está causando isso.
Obrigado.
EDIT: Aqui abaixo, adicionei o código envolvido na pergunta, a pedido dos comentários que faço nesta página, em vez de encaminhar os leitores para os links para meus cadernos Jupyter.
Funções de custo do modelo:
def sigmoid(z):
return 1 / (1 + np.exp(-z))
def compute_cost_regularized(theta, X, y, lda):
reg =lda/(2*len(y)) * np.sum(theta[1:]**2)
return 1/len(y) * np.sum(-y @ np.log(sigmoid(X@theta))
- (1-y) @ np.log(1-sigmoid(X@theta))) + reg
def compute_gradient_regularized(theta, X, y, lda):
gradient = np.zeros(len(theta))
XT = X.T
beta = sigmoid(X@theta) - y
regterm = lda/len(y) * theta
# theta_0 does not get regularized, so a 0 is substituted in its place
regterm[0] = 0
gradient = (1/len(y) * XT@beta).T + regterm
return gradientFunção que implementa o treinamento de classificação one-vs-all:
from scipy.optimize import minimize
def train_one_vs_all(X, y, opt_method):
theta_all = np.zeros((y.max()-y.min()+1, X.shape[1]))
for k in range(y.min(),y.max()+1):
grdtruth = np.where(y==k, 1,0)
results = minimize(compute_cost_regularized, theta_all[k-1,:],
args = (X,grdtruth,0.1),
method = opt_method,
jac = compute_gradient_regularized)
# optimized parameters are accessible through the x attribute
theta_optimized = results.x
# Assign thetheta_optimized vector to the appropriate row in the
# theta_all matrix
theta_all[k-1,:] = theta_optimized
return theta_allChamada de função para treinar o modelo com diferentes métodos de otimização:
theta_all_optimized_cg = train_one_vs_all(X_bias, y, 'CG') # Optimization performed using Conjugate Gradient
theta_all_optimized_bfgs = train_one_vs_all(X_bias, y, 'BFGS') # optimization performed using Broyden–Fletcher–Goldfarb–ShannoVemos que os resultados das previsões diferem com base no algoritmo usado:
def predict_one_vs_all(X, theta):
return np.mean(np.argmax(sigmoid(X@theta.T), axis=1)+1 == y)*100
In[16]: predict_one_vs_all(X_bias, theta_all_optimized_cg)
Out[16]: 90.319999999999993
In[17]: predict_one_vs_all(X_bias, theta_all_optimized_bfgs)
Out[17]: 96.480000000000004Para quem quiser obter dados para experimentar o código, eles podem ser encontrados no meu Github, conforme vinculado neste post.