<jupyter_start><jupyter_text>Avaliaçao de Modelos - Métricas de Classificação - Parte 2<jupyter_code>import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn import linear_model
from sklearn import model_selection
from sklearn import metrics
from sklearn import preprocessing
import matplotlib.pyplot as plt
X, y = datasets.load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.3, stratify=y, random_state=42)

#model = linear_model.LogisticRegression(multi_class='auto', solver='lbfgs')
model = linear_model.LogisticRegression(multi_class='auto', solver='lbfgs', max_iter=130)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)<jupyter_output><empty_output><jupyter_text>Matriz de Confusão<jupyter_code>metrics.confusion_matrix(y_test, y_pred)<jupyter_output><empty_output><jupyter_text>Classification Report<jupyter_code>print(metrics.classification_report(y_test, y_pred))<jupyter_output>precision    recall  f1-score   support

           0       1.00      1.00      1.00        15
           1       0.88      0.93      0.90        15
           2       0.93      0.87      0.90        15

    accuracy                           0.93        45
   macro avg       0.93      0.93      0.93        45
weighted avg       0.93      0.93      0.93        45<jupyter_text>Estimativa de probabilidadeProbabilidade da amostra para cada classe do modelo.<jupyter_code>y_probs = model.predict_proba(X_test)
for i in range(5):
    linha = y_probs[i, :] 
    print(linha.round(4), linha.sum(), y_pred[i])<jupyter_output>[0.    0.033 0.967] 1.0 2
[0.0046 0.763  0.2324] 0.9999999999999999 1
[0.0009 0.506  0.4931] 1.0 1
[0.0052 0.661  0.3339] 1.0 1
[0.0017 0.4091 0.5892] 1.0 2<jupyter_text>Métrica Log LossLog Loss é o log da função de probabilidade condicional negativa dos rótulos verdadeiros, dadas as probabilidades das predições de um classificador.- Leva em conta a probabilidade da predição com base em quanto ela varia em relação ao rótulo real.- Usa log negativo para facilitar a comparação de resultados entre diferentes modelos.- É bastante usado para classificação multi-classe.- Penaliza classificações falsas.- Usa o valor negativo do log para facilitar a comparação entre o desempenho de diferentes modelos.- Valores próximos de zero, significam bom desempenho do modelo.![image.png](attachment:image.png)**Log Loss** e **Cross-Entropy** são ligeiramente diferentes dependendo do contexto, mas em aprendizado de máquina ao calcular as taxas de erro entre 0 e 1 elas são equivalentes (mesmos resultados). Regra MinMaxAo calcular o Log Loss, os valores de probabilidade previstos 0 e 1 são indefinidos. Para evitar esse problema, Log Loss ajusta as probabilidades previstas (p) usando um valor pequeno (eps / epsilon) de acordo com a fórmula a seguir:$$ max( min(p, 1−10^{−15}), 10^{-15}) $$ Log LossPara 2 classes (classificação binária):$$ - ( y \cdot \log{(p)} + (1 - y) \cdot \log{(1 - p)} ) $$Para mais de 2 classes:$$ - \sum_{c=1}^{M}{ y_{o,c} \log{(p_{o,c})} } $$<jupyter_code>metrics.log_loss([0, 1], [0.25, 0.75])
metrics.log_loss([1, 0], [0.75, 0.25])
metrics.log_loss([0, 1], [0.75, 0.25])
def logloss(y_true, y_prob, eps=1e-15):
    p = np.clip(y_prob, eps, 1 - eps)
    return -np.log(1 - p)
logloss(0, 0.25)
logloss(0, 0.75)<jupyter_output><empty_output><jupyter_text>Calculando para o conjunto de dados iris<jupyter_code>metrics.log_loss(y_test, y_probs)<jupyter_output><empty_output><jupyter_text>Métrica Curva ROC - Receiver Operating CharacteristicÉ uma forma de visualizar o desempenho de um classificador binário. ![image.png](attachment:image.png)   AUC - Area Under the Curve ![image.png](attachment:image.png)<jupyter_code>np.unique(y_test)
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_probs[:, 0], pos_label=0)
print('x', fpr.round(4))
print('y', tpr.round(4))
print('AUC', metrics.auc(fpr, tpr))
plt.plot([0, 1], [0, 1], '--')
plt.plot(fpr, tpr)
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.title('Curva ROC')
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_probs[:, 1], pos_label=1)
print('x', fpr.round(4))
print('y', tpr.round(4))
print('AUC', metrics.auc(fpr, tpr))
fpr, tpr, thresholds = metrics.roc_curve(y_test, y_probs[:, 2], pos_label=2)
print('x', fpr.round(4))
print('y', tpr.round(4))
print('AUC', metrics.auc(fpr, tpr))
plt.plot([0, 1], [0, 1], '--')
plt.plot(fpr, tpr)
plt.xlabel('FPR')
plt.ylabel('TPR')
plt.title('Curva ROC')<jupyter_output><empty_output><jupyter_text>Outra forma de calcular AUC<jupyter_code>y_test_binary_2 = np.where(y_test == 2, 1, 0)
metrics.roc_auc_score(y_test_binary_2, y_probs[:, 2])<jupyter_output><empty_output>
StarcoderdataJupyterStructuredCleanDedup