Entrenamiento y evaluación de regresión logística multiclase

Una forma más sencilla de optimizar los hipeparámetros del modelo de Regresión Lineal es usando GridSearchCV

Esto también se usa para otros modelos de regresión y clasificación, lo que hizo el profesor es basicamente lo que hace este modelo por dentro, un loop de varios ciclos for

En la figura de abajo se puede observar el mejor acuracy obtenido , nótese que debería de ser 0.93 y no 0.99 como se muestra en el video por un ligero error al darle una columna extra al set de X el cual explique en la clase anterior.

El modelo clf ya se encuentra entrenado con los mejores hiperparámetros por lo que yase encuentra listo para hacer predicciones

Con este código podemos hacer que se muestre el scoring en la grafica de barras, para ver mejor el accuracy:

fig, ax1 = plt.subplots(figsize=(10,5))

ax = sns.barplot(
        ax=ax1,
        x  = params,
        y = scores
        )
ax.set_title('Beans Accuracy')
ax.set_xticklabels(labels = ax.get_xticklabels(), rotation=66)
ax.bar_label(ax.containers[0])
plt.show()

pensando que habia overfiting use cross validation para verificar:

from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score

kfold = KFold(n_splits=5)

results = cross_val_score(model, X_test, y_test, cv=kfold)
print(results.mean())

0.9863479638430714

el score es muy similar, lo que nos indicaria que no hay Overfiting

🔍 Acercamiento para ver mejor la diferencia:

Me puse a iterar y evitar que salgan las alertas. La verdad es que visualmente rompen mucho la vista. ```python import warnings warnings.filterwarnings("ignore") multiclass = ['ovr', 'multinomial'] solver_list = ['liblinear', 'newton-cg', 'lbfgs', 'sag', 'saga'] scores = [] params = [] for i in multiclass: for j in solver_list: try: model = LogisticRegression(multi_class=i, solver=j, max_iter=1000) model.fit(X_train, y_train) predictions = model.predict(X_test) params.append(i + ' + ' + j) accuracy = accuracy_score(y_test, predictions) scores.append(accuracy) print(f'Model: {i} + {j} | Accuracy: {accuracy:.4f}') except Exception as e: print(f'Error with model: {i} + {j} | {e}') warnings.filterwarnings("default") ``` 

Predicción para nuevos valores (aleatorios dentro del rango) + guardar el modelo final: ```js # rangos perimeter = [524.736000, 1985.37] EquivDiameter= [161.243764, 569.374358] Solidity = [0.919246, 0.994677] Roundness = [0.489618, 0.990685] ShapeFactor1 = [0.002778, 0.010451] ShapeFactor2 = [0.000564, 0.003665] list_cols = [perimeter, EquivDiameter, Solidity, Roundness, ShapeFactor1, ShapeFactor2] dict_cols = {} #valores random dentro del rango de cada columna for i in range(len(df_bean_over.columns)-1): # sin la predictora :O dict_cols[df_bean_over.columns[i]] = np.random.uniform(list_cols[i][0], list_cols[i][1]) new_data = pd.DataFrame(dict_cols, index= [0]) st_new_data = scaler.transform(new_data) # escalamiento pred_new_data = best_model.predict(st_new_data) # predicción prob_new_data = best_model.predict_proba(st_new_data) # probabilidad prob_new_data # probabilidad de cada clase dict_prob = {} for i in range(len(best_model.classes_)): dict_prob[best_model.classes_[i]] = prob_new_data[0][i] categories= ['BARBUNYA', 'BOMBAY', 'CALI', 'DERMASON', 'HOROZ', 'SEKER', 'SIRA'] encoding_nums = [1, 2, 3, 4, 5, 6, 7] print(f'probabilities:\n{dict_prob}\n\n', #probabilidad de que el dato pertenezca a cada 'Class' f'prediction: {pred_new_data}-> {categories[np.where(encoding_nums == pred_new_data)[0][0]]}') #predicción # guardamos el modelo def save_model(model, scaler, name): joblib.dump(model, name + '.pkl') joblib.dump(scaler, name + '_scaler.pkl') print('model saved :D') #save_model(model= best_model, scaler= scaler, name= 'logistic_regression_dry_bean') ```

Por qué obtenemos 0.99 de accuracy? Bueno en la clase anterior escribimos: ```js df_dea = X_over df_dea['Class'] = y_over ``` Debido a esto implícitamente estamos agregando la columna objetivo ('Class') en la variable predictora (X\_over). Es decir estamos incluyendo nuestra variable objetivo como variable predictora, la forma de solucionar esto es cambiando el código mencionado por: ```python df_dea = X_over.copy(deep = True) df_dea['Class'] = y_over ```

Por qué obtenemos 0.99 de accuracy? Bueno en la clase anterior escribimos: ```python df_dea = X_over df_dea['Class'] = y_over ```Debido a esto implícitamente estamos agregando la columna objetivo ('Class') en la variable predictora (X\_over)![]()!\[]\(https://imgur.com/a/XX3qD0z)Es decir estamos incluyendo nuestra variable objetivo como variable predictora, la forma de solucionar esto es cambiando el código mencionado por: df\_dea = X\_over.copy(deep = True) df\_dea\['Class'] = y\_over```python df_dea = X_over.copy(deep = True) df_dea['Class'] = y_over ``` ![]()