<jupyter_start><jupyter_text>Atividade: Generalização  Avaliando a generalização de algoritmosEscolha uma base de classificação e compare os classificadores Logistic Regression e KNN do scikit-learn.Use pelo menos duas formas de avaliação e as repita pelo menos 10 vezes.Calcule a média das repetições de cada avaliação.  Base de Dados Dataset for classification of bank notesThe Banknote Dataset involves predicting whether a given banknote is authentic given a number of measures taken from a photograph.It is a binary (2-class) classification problem. The number of observations for each class is not balanced. There are 1,372 observations with 4 input variables and 1 output variable. The variable names are as follows:    c1: Variance of Wavelet Transformed image (continuous).    c2: Skewness of Wavelet Transformed image (continuous).    c3: Kurtosis of Wavelet Transformed image (continuous).    c4: Entropy of image (continuous).    category: Class (0 for authentic, 1 for inauthentic).The baseline performance of predicting the most prevalent class is a classification accuracy of approximately 50%.https://archive.ics.uci.edu/ml/datasets/banknote+authentication  Leitura dos Dados<jupyter_code>import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import seaborn as sns
# Leitura do arquivo csv
df = pd.read_csv("../datasets/data_banknote_authentication.csv")
df.head()<jupyter_output><empty_output><jupyter_text>Análise de valores nulos e estatísticas sobre os dados<jupyter_code># Verificação do tipo de dado e se existem valores nulos
df.info()
# Algumas estatísticas sobre a base de dados
df.describe()
df_numrecords = df.groupby('category').size().reset_index(name='qtd')
print("Número de registros por classe")
df_numrecords<jupyter_output>Número de registros por classe<jupyter_text>Separação dos conjuntos de treino e teste<jupyter_code>from sklearn.model_selection import train_test_split
# Separa dados e rótulos
y = df['category']
X = df.drop(['category'], axis=1)

# Cria conjunto de treino e teste
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=23, shuffle=True)

print(f"X_train shape :{X_train.shape}")
print(f"X_test shape :{X_test.shape}")
print(f"y_train shape :{y_train.shape}")
print(f"y_test shape :{y_test.shape}")<jupyter_output>X_train shape :(1097, 4)
X_test shape :(275, 4)
y_train shape :(1097,)
y_test shape :(275,)<jupyter_text>Desenvolvimento de modelo com pipeline- Foram criados pipelines para os dois classificadores: KNN e Regressão Logística- Os dados foram padronizados antes de alimentar os modelos utilizando a biblioteca **StandardScaler**- Os conjuntos de dados de treinamento foram separados em 10 subconjuntos (9/10 dos dados usados para treino e 1/10 para teste) utilizando a validação cruzada   **K-Fold**  (cv=10)- A partir do GridSearch foi analisada a performarce dos modelos para diferentes hiperparâmetros. Os modelos com os melhores resultados foram escolhidos- Os modelos foram avaliados utilizando os dados de teste<jupyter_code>from sklearn.pipeline import Pipeline
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV, cross_validate, KFold
from sklearn.preprocessing import StandardScaler

# Criação dos pipelines
pipe_reglog = Pipeline(steps=[
    ('scaler', StandardScaler()),
    ('LR', LogisticRegression())
])

pipe_knn = Pipeline(steps=[
    ('scaler', StandardScaler()),
    ('KNN', KNeighborsClassifier())
])

# Parâmetros do Grid Search
reglog_grid_params = [{'LR__penalty': ['l1', 'l2'],
                   'LR__C': [1, 2, 3, 4, 5, 6],
                   'LR__solver': ['liblinear']}]

knn_grid_params = [{'KNN__n_neighbors': [1, 3, 5, 7, 9],
                   'KNN__weights': ['uniform', 'distance'],
                   'KNN__metric': ['euclidean', 'manhattan']}]


# Configura o GridSearch
knnGridSearch = GridSearchCV(estimator=pipe_knn, param_grid=knn_grid_params, scoring='accuracy', verbose=3, cv=10)

reglogGridSearch = GridSearchCV(estimator=pipe_reglog, param_grid=reglog_grid_params, scoring='accuracy', verbose=3, cv=10)

list_of_grids = [knnGridSearch, reglogGridSearch]
name_of_grids = ["KNN", "Regressão Logística"]
# Treina modelos
for pipe in list_of_grids:
    pipe.fit(X_train,y_train)<jupyter_output>Fitting 10 folds for each of 20 candidates, totalling 200 fits
[CV 1/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=0.991 total time=   0.0s
[CV 2/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 3/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 4/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 5/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 6/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 7/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=0.991 total time=   0.0s
[CV 8/10] END KNN__metric=euclidean, KNN__n_neighbors=1, KNN__weights=uniform;, score=1.000 total time=   0.0s
[CV 9/10] END KNN__metric=euclidean, KNN__n_neigh[...]<jupyter_text>Avaliação dos modelosO algoritmo KNN obteve a  melhor acurácia em relação ao classificadore de Regressão Logística<jupyter_code># Avaliação dos modelos
for i, model in enumerate(list_of_grids):
    print('{} Test Accuracy: {}'.format(name_of_grids[i],
    model.score(X_test,y_test)))
    print('{} Best Params: {}'.format(name_of_grids[i], model.best_params_))<jupyter_output>KNN Test Accuracy: 1.0
KNN Best Params: {'KNN__metric': 'euclidean', 'KNN__n_neighbors': 1, 'KNN__weights': 'uniform'}
Regressão Logística Test Accuracy: 0.9854545454545455
Regressão Logística Best Params: {'LR__C': 2, 'LR__penalty': 'l1', 'LR__solver': 'liblinear'}
{'fraction_non_alphanumeric': 0.09930371352785146, 'fraction_numerical': 0.029675066312997347, 'mean_word_length': 5.840136054421769, 'pattern_counts': {'":': 0, '<': 17, '<?xml version=': 0, '>': 17, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '5', 'dir': 'jupyter-structured-clean-dedup', 'id': '473792', 'license': 'MIT', 'n_tokens_mistral': 2267, 'n_tokens_neox': 2097, 'n_words': 611, 'path': 'notebooks/3_generalizacao.ipynb', 'repo_name': 'glima91/mestrado-reconhecimento-de-padroes', 'size': '6032'}