<jupyter_start><jupyter_text>Importando os dois princiais modulos<jupyter_code>import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings("ignore")<jupyter_output><empty_output><jupyter_text>Carrregamos nosso dataset<jupyter_code>dataset = pd.read_csv('fake_data_2.csv')
dataset.head()
dataset<jupyter_output><empty_output><jupyter_text>Separamos em variaveis de input e de output<jupyter_code>X = dataset.iloc[:, :-1].values # cargo, idade, salario e bonus
Y = dataset.iloc[:, 4] # socio<jupyter_output><empty_output><jupyter_text>Tratamento de dados faltantes O problemas de valores missing contém inúmeras formas de ser resolvido, e a melhor solucao depende muito do seu conjunto de dados e do seu problema, portanto analise a sua situacao e escolha a melhor forma de tratar esse problema. 1. Deletar as colunas com dados faltantes: Essa solução ao meu ver é bem drástica e somente deverá ser utilizada quando a variável não exercer uma certa influência no resultado procurado:<jupyter_code>dataset.apply(lambda x: sum(x.isnull()),axis=0) 
# dataset.dropna(axis=1, inplace=True)<jupyter_output><empty_output><jupyter_text>2. Deletar os exemplos com dados faltantes: Uma solução bem melhor para o problema porém ainda não é a ideal para um dataset no qual você possui poucos exemplos, para aplicar basta utilizarmos a função dropna do pandas com o axis = 0:<jupyter_code># dataset.dropna(axis=0, inplace=True)<jupyter_output><empty_output><jupyter_text>3. Preencher os dados faltantes com o valor que você quiser: dataset.fillna(0)<jupyter_code># values = {'salario': valor, 'bonus': valor}
# dataset.fillna(value=values)<jupyter_output><empty_output><jupyter_text>4. Preencher os dados faltantes com a média dos valores do atributo: Essa é a minha solução favorita e que iremos utilizar nesse guia. Em nosso problema iremos fazer isso da forma mais simples, aplicando o valor da média das colunas salário e bônus nos exemplos que não possuem esse valor. Notem que se quiséssemos poderíamos ir um pouco mais afundo e calcular essas médias de acordo com o cargo para depois aplicarmos a média que mais faz sentido. Primeiro vamos voltar ao cabeçalho e importar a classe Imputer que irá nos auxiliar nessa tarefa:<jupyter_code>from sklearn.preprocessing import Imputer
# Agora criamos um objeto da classe Imputer
imputer = Imputer(missing_values = np.nan, strategy = 'mean', axis = 0)
# Agora aprilacamos o método fit do imputer apenas nas colunas com dados faltantes:
imputer = imputer.fit(X[:, 2:4])
# Por fim vamos aplicar o método transform do imputer apenas nas colunas que precisamos para calcularmos a média e salvarmos em nossa variável X:
X[:, 2:4] = imputer.transform(X[:, 1:3])
X<jupyter_output><empty_output><jupyter_text>Variáveis categóricas Outro problema do nosso dataset são as variáveis categóricas que nesse caso se restringem apenas a coluna cargo, ou seja, uma variável categórica é uma variável nominal, sem escala, não numérica.  Método get_dummies Primeiro vamos criar um dataFrame apenas com a coluna cargos:<jupyter_code>X_cargo = pd.DataFrame({'cargo':X[:,0]})<jupyter_output><empty_output><jupyter_text>X_cargo Agora vamos transformar o nosso dataFrame com uma coluna de variáveis categóricas em colunas que representam cada cargo:<jupyter_code>X_cargo = pd.get_dummies(X_cargo)
X_cargo<jupyter_output><empty_output><jupyter_text>Agora vamos extrair da variável X apenas as colunas com variáveis numéricas e transformar em um dataFrame<jupyter_code>X
X = X[:, 1:]
X = pd.DataFrame({'idade':X[:,0], 'salario':X[:,1], 'bonus':X[:,2]})
X<jupyter_output><empty_output><jupyter_text>Por fim vamos unir as colunas dos cargos ao nosso dataframe X:<jupyter_code>X = X.join(X_cargo)
X<jupyter_output><empty_output><jupyter_text>Por conseguinte também vamos transformar a nossa variável Y (é sócio) em valores numéricos, onde sim será 1 e não será zero:<jupyter_code>Y = pd.get_dummies(Y)
Y = Y['sim'].values
Y<jupyter_output><empty_output><jupyter_text>Reescala dos dados Agora temos um novo problema, você pode observar que os valores das colunas idade, salário e bônus estão em uma escala bem distinta, onde a idade varia entre 20 a 65, salário varia entre 2344 a 38000 e bônus varia entre 1200 a 28000, e isto pode causar um grande problema no treino do nosso modelo uma vez o salário por possuir uma escala muito maior que a idade terá uma influência consequentemente muito maior no resultado e isto não é que nós queremos! Além disso podemos notar que as bordas representam alguns possíveis outliers os quais queremos minimizar o impacto em nossa solução. Para solucionar esses problemas poderíamos usar diversas técnicas de estatística e algumas métricas como quartis, desvio padrão e variância ou podemos ser muito mais espertos e já usar inúmeras ferramentas do sklearn que já aplicam todas essas técnicas a fim de obter uma melhor solução para o nosso problema através da reescala dos dados.  MinMaxScaler O MinMaxScaler é uma outra alternativa a reescala de dados, seu diferencial se dá uma vez que este age sobre sobre a coluna, ou seja, o cálculo da reescala é feito de forma independente entre cada coluna, de tal forma que a nova escala se dará entre 0 e 1 (ou -1 e 1 se houver valores negativos no dataset). Importante ressaltar que essa técnica funciona melhor se a distribuição dos dados não for normal e se o desvio padrão for pequeno, além disso o MinMaxScaler não reduz de forma eficaz o impacto de outliers e também preserva a distribuição original. De forma simples o MinMaxScaler subtrai o valor em questão pelo menor valor da coluna e então divide pela diferença entre o valor máximo e mínimo:<jupyter_code>#valor = ( valor — Coluna.min) / (Coluna.max — Coluna.min)
from sklearn.preprocessing import MinMaxScaler

X_minMax = X.copy()
X_minMax[['idade', 'salario', 'bonus']] = MinMaxScaler().fit_transform(X[['idade', 'salario', 'bonus']])
X
X_minMax # Nova estrutura de dados das variaveis independentes<jupyter_output><empty_output><jupyter_text>Feature Selection Os atributos presentes no seu dataset e que você utiliza nos dados de treino, terão grande influência na precisão e resultado do seu modelo preditivo. Atributos irrelevantes terão impacto negativo na performance, enquanto atributos colineares podem afetar o grau de acurácia do modelo. O Scikit-learn possui funções que automatizam o trabalho de extração e seleção de variáveis.A etapa de Feature Selection é onde selecionamos os atributos (variáveis) que serão melhores candidatas a variáveis preditoras. O Feature Selection nos ajuda a reduzir o overfitting (quando o algoritmo aprende demais), aumenta a acurácia do modelo e reduz o tempo de treinamento.  Selecionando os melhores atributos Agora que temos nossos dados reescalados em alguns datasets podemos contar com muitas colunas/atributos para nos auxiliar na tarefa de predição, porém nem sempre todos esses atributos possuem informações relevantes e muita das vezes podem levar o modelo a ter um resultado inferior do que se tivéssemos usados apenas poucos atributos. Portanto um trabalho importante é selecionar os atributos que mais fazem sentido e agregam valor em nossa solução. Para isso podemos contar com o SelectKBest do sklearn, onde o K representa o número máximo de atributos que desejamos ter em nosso dataset a ser “inputado” em nossa etapa de treino, dado o K o SelectKBest trata de encontrar os K melhores atributos a serem usados. Importante ressaltar que aqui não existe uma melhor maneira de se escolher o valor para K a solução é tentar com diferentes valores e compararmos os resultados. Uma observação importante é que o SelectKBest não suporta dados valores negativos, portanto todos os métodos de reescala que transformam os valores em um intervalo que possui negativos devem ser descartados caso você queira aplica-lo. Em nosso exemplo irei experimentar K = 6 pois possuímos 8 atributos e irei utilizar o método de reescala MinMaxScaler, sinta-se à vontade para experimentar qualquer valor de K e qualquer método de reescala! O método fit_transform já nos retorna os valores dos atributos mais importantes por tanto podemos passar a usar o retorno como o nosso novo X<jupyter_code>from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
X_new = SelectKBest(chi2, k=6).fit_transform(X_minMax, Y)

# Resultados
print('\nNúmero original de features:', X.shape[1])
print('\nNúmero reduzido de features:', X_new.shape[1])
print('\nFeatures (Variáveis Selecionadas): \n\n', features)
X_new<jupyter_output><empty_output><jupyter_text>Eliminação Recursiva de Atributos https://scikit-learn.org/stable/modules/generated/sklearn.feature_selection.RFE.html Esta é outra técnica para seleção de atributos, que recursivamente remove os atributos e constrói o modelo com os atributos remanescentes. Esta técnica utiliza a acurácia do modelo para identificar os atributos que mais contribuem para prever a variável alvo. Em inglês esta técnia é chamada Recursive Feature Elimination (RFE). O exemplo abaixo utiliza a técnica de eliminação recursiva de atributos com um algoritmo de Regressão Logística para selecionar as 3 melhores variáveis preditoras. O RFE selecionou as variáveis preg, mass e pedi, que estão marcadas como True em "Atributos Selecionados" e com valor 1 em "Ranking dos Atributos".<jupyter_code>from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# Criação do modelo
modelo = LogisticRegression(solver='lbfgs')

# RFE
rfe = RFE(modelo, 3)
fit = rfe.fit(X_minMax, Y)

# Print dos resultados
print("Variáveis Preditoras:", X_minMax.columns[0:3])
print("Variáveis Selecionadas: %s" % fit.support_)
print("Ranking dos Atributos: %s" % fit.ranking_)
print("Número de Melhores Atributos: %d" % fit.n_features_)<jupyter_output>Variáveis Preditoras: Index(['idade', 'salario', 'bonus'], dtype='object')
Variáveis Selecionadas: [False False  True  True  True False False False]
Ranking dos Atributos: [4 2 1 1 1 3 6 5]
Número de Melhores Atributos: 3<jupyter_text>Principal Component Analysis (PCA) Por fim podemos aplicar a técnica PCA nos atributos escolhidos, de forma grossa o PCA nada mais é que uma técnica a qual transforma atributos com uma certa correlação em um único atributo. O PCA deve ser aplicado apenas em casos em que o seu dataset possui muitas colunas, realmente um número muito grande e o treino do seu modelo acaba por ser muito demorado ou inviável devido ao alto número de colunas, uma vez que o PCA é uma técnica na qual sempre haverá perda de informações. Em nosso exemplo o PCA será aplicado de forma meramente ilustrativa uma vez que não possuímos muitas colunas. O atributo n_components representa quantos atributos queremos deixar, outra ideia é utilizar o parâmetro n_components=’mle’ dado isto Minka’s MLE será utilizado para escolher a melhor dimensão a ser mantida no seu caso<jupyter_code>from sklearn.decomposition import PCA
pca = PCA(n_components='mle')
X_new = pca.fit_transform(X_minMax)<jupyter_output><empty_output><jupyter_text>O PCA precisa ser alimentado com dados normalizados. Utilizar o PCA em dados não normalizados pode gerar resultados inesperados.  Amostragem - Resampling Você precisa saber se seu modelo preditivo vai funcionar bem quando receber novos dados. A melhor maneira de avaliar a performance do modelo é fazer previsões em dados que você já conhece o resultado. Outra maneira de testar a performance do seu modelo é utilizar técnicas estatísticas como métodos de amostragem que permitem você estimar quão bem seu modelo irá fazer previsões em novos dados. A avaliação do modelo é uma estimativa de quão bem o algoritmo será capaz de prever em novos dados. Isso não garante performance. Após avaliar o modelo, nós podemos treiná-lo novamente com os dados de treino e então prepará-lo para uso operacional em produção. Existem diversas técnicas para isso e estudaremos duas aqui: Conjunto de dados de treino e de teste e Cross Validation.  Separando os seus dados em um conjunto de treino e de teste https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html Este é o método mais utilizado para avaliar performance de um algoritmo de Machine Learning. Dividimos nossos dados originais em dados de treino e de teste. Treinamos o algoritmo nos dados de treino e fazemos as previsões nos dados de teste e avaliamos o resultado. A divisão dos dados vai depender do seu dataset, mas utiliza-se com frequência tamanhos entre 70/30 (treino/teste) e 65/35 (treino/teste). Este método é bem veloz e ideal para conjuntos de dados muito grandes. O ponto negativo é a possibilidade de alta variância.  Vamos começar com o método Train Test SPlit do sklearn<jupyter_code>from sklearn.model_selection import train_test_split

X_train, X_test, Y_train, Y_test = train_test_split(X_minMax, Y, test_size = 0.2, random_state = 0)
X_train
X_test
# Criação do modelo
modelo = LogisticRegression()

# Treinamento do modelo
modelo.fit(X_train, Y_train)

# Score do modelo nos dados de teste
result = modelo.score(X_test, Y_test)
print("Acurácia nos Dados de Teste: %.3f%%" % (result * 100.0))<jupyter_output>Acurácia nos Dados de Teste: 66.667%<jupyter_text>Cross Validation https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.cross_val_score.html Cross Validation é uma técnica que pode ser utilizada para avaliar a performance de um modelo com menos variância que a técnica de dividir os dados em treino/teste. Com esta técnica dividimos os dados em partes normalmente chamadas de k-folds (por exemplo k = 5, k = 10). Cada parte é chamada fold. O algoritmo é treinado em k-1 folds. Cada fold é usado no treinamento de forma repetida e um fold por vez. Após executar o processo em k-1 folds, podemos sumarizar a performance em cada fold usando a média e o desvio padrão (Eu disse que Estatística era importante no processo de Big Data Analytics). O resultado é normalmente mais confiável e oferece maior acurácia ao modelo. A chave deste processo está em definir o correto valor de k, de modo que o número de folds represente adequadamente o número de repetições necessárias. Esta é a minha forma favorita de separar o dataset, pois o KFold facilita que possamos separar o nosso conjunto de dadas em conjunto de treinos e teste K vezes (indicado no parâmetro n_splits) e portanto fazer o treino e validar os resultados para 3 conjuntos diferentes de treino e teste. Antes precisamos colocar a nossa variável X em um formato de array.<jupyter_code>from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score


?KFold

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = LogisticRegression(solver='lbfgs')
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 77.083%<jupyter_text>Avaliando a Performance As métricas que você escolhe para avaliar a performance do modelo vão influenciar a forma como a performance é medida e comparada com modelos criados com outros algoritmos. Vamos utilizar o mesmo algoritmo, mas com métricas diferentes e assim comparar os resultados. A função cross_validation.cross_val_score() será usada para avaliar a performance.  Métricas para Algoritmos de Classificação https://scikit-learn.org/stable/modules/model_evaluation.html<jupyter_code># Acurácia
# Número de previsões corretas. É útil apenas quando existe o mesmo número de observações em cada classe.
# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = LogisticRegression(solver='lbfgs')
resultado = cross_val_score(modelo, X_new, Y, cv = kfold, scoring = 'accuracy')

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))
# Curva ROC 
# A Curva ROC permite analisar a métrica AUC (Area Under the Curve).
# Essa é uma métrica de performance para classificação binária, em que podemos definir as classes em positiavs e negativas.
# Problemas de classificação binária são um trade-off sentre Sensitivity e Specifity.
# Sensitivity é a taxa de verdadeiros positivos (TP). Ese é o número de instâncias positivas da primeira classe que foram previstas corretamente.
# Specifity é a taxa de verdadeiros negativos (TN). Esse é o número de instâncias da segunda classe que foram previstas corretamente.
# Valores acima de 0.5 indicam uma boa taxa de previsão.

X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = LogisticRegression(solver='lbfgs')
resultado = cross_val_score(modelo, X_new, Y, cv = kfold, scoring = 'roc_auc')

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 91.667%<jupyter_text>Algoritmos de Classificação Não temos como saber qual algoritmo vai funcionar melhor na construção do modelo, antes de testarmos o algoritmo com nosso dataset. O ideal é testar alguns algoritmos e então escolher o que fornece melhor nível de precisão. Vamos testar um conjunto de algoritmos de classificação, nas mesmas condições.  Regressão Logística Algoritmo Linear. O algoritmo de Regressão Logística assume que seus dados estão em uma Distribuição Normal para valores numéricos que podem ser modelados com classificação binária. Este foi o logoritmo que estivemos calculando anteriormente. Outro algoritmo de classificacao é:   Linear Discriminant Analysis Algoritmo Linear. Técnica estatística para classificação binária. Também assume que os dados estão em Distribuição Normal.<jupyter_code># Importamos o modulo
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = LinearDiscriminantAnalysis()
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 85.417%<jupyter_text>KNN - K-Nearest Neighbors Algoritmo Não-Linear que utiliza uma métrica de distância para encontrar o valor de K mais adequado as instâncias do dataset de treino.<jupyter_code># Importamos o modulo
from sklearn.neighbors import KNeighborsClassifier

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = KNeighborsClassifier()
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 93.750%<jupyter_text>Naive Bayes Algoritmo Não-Linear. Calcula a Probabilidade de cada classe e a probabilidade condicional de cada classe dado uma variável de entrada. As probabilidades são então estimadas para os novos dados e multiplicadas, assumindo que são independentes (suposição simples ou Naive). Assume dados em distirbuição Gaussiana (Normal)<jupyter_code># Importamos o modulo
from sklearn.naive_bayes import GaussianNB

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = GaussianNB()
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 77.083%<jupyter_text>CART (Classification and Regression Trees) Algoritmo Não-Linear. O algoritmo CART constrói uma árvore binária a partir do dataset de treino. Cada atributo e cada valor de cada atributo são avaliados com o objetivo de reduzir a função de custo (Cost Function).<jupyter_code># Importamos o modulo
from sklearn.tree import DecisionTreeClassifier

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = DecisionTreeClassifier()
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 85.417%<jupyter_text>SVM - Support Vector Machines O objetivo deste algoritmo é buscar uma linha que melhor separa duas classes dentro de um conjunto de dados. As instâncias de dados que estão mais próximas desta linha que separa as classes, são chamadas support vectors. O SVM tem sido estendido para suportar multiclasses. Support Vector Machines são algoritmos de classificação muito poderosos. Quando usados em conjunto com “Random forest” e outras ferramentas de aprendizagem de máquina, dão uma dimensão muito diferente para montagem de modelos. Assim, eles se tornam cruciais para os casos em que é necessária um poder de previsão muito elevado. Esses algoritmos são um pouco mais difíceis de visualizar devido à complexidade na formulação.<jupyter_code># Importamos o modulo
from sklearn.svm import SVC

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
modelo = SVC()
resultado = cross_val_score(modelo, X_new, Y, cv = kfold)

# Usamos a média e o desvio padrão
print("Acurácia Final: %.3f%%" % (resultado.mean() * 100.0))<jupyter_output>Acurácia Final: 72.917%<jupyter_text>Seleção do Modelo Preditivo Veremos que os algoritmos de Regressão Logística e Linear Discriminant Analysis apresentaram o melhor nível de precisão.<jupyter_code># Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

num_folds = 4
seed = 7

# Separando os dados em folds

kfold = KFold(num_folds, True, random_state = seed)

# Criando o modelo
# Preparando a lista de modelos
modelos = []
modelos.append(('LR', LogisticRegression()))
modelos.append(('LDA', LinearDiscriminantAnalysis()))
modelos.append(('NB', GaussianNB()))
modelos.append(('KNN', KNeighborsClassifier()))
modelos.append(('CART', DecisionTreeClassifier()))
modelos.append(('SVM', SVC()))

# Avaliando cada modelo em um loop
resultados = []
nomes = []

for nome, modelo in modelos:
    kfold = KFold(n_splits = num_folds, random_state = seed)
    cv_results = cross_val_score(modelo, X_new, Y, cv = kfold, scoring = 'accuracy')
    resultados.append(cv_results)
    nomes.append(nome)
    msg = "%s: %f (%f)" % (nome, cv_results.mean(), cv_results.std())
    print(msg)<jupyter_output>LR: 0.791667 (0.125000)
LDA: 0.770833 (0.272431)
NB: 0.791667 (0.125000)
KNN: 0.854167 (0.148780)
CART: 0.791667 (0.125000)
SVM: 0.708333 (0.297560)<jupyter_text>Otimização do Modelo - Ajuste de Hyperparâmetros Todos os algoritmos de Machine Learning são parametrizados, o que significa que você pode ajustar a performance do seu modelo preditivo, através do tuning (ajuste fino) dos parâmetros. Seu trabalho é encontrar a melhor combinação entre os parâmetros em cada algoritmo de Machine Learning. Esse processo também é chamado de Otimização de Hyperparâmetros. O scikit-learn oferece dois métodos para otimização automática dos parâmetros: Grid Search Parameter Tuning e Random Search Parameter Tuning.   Grid Search Parameter Tuning Este método realiza metodicamente combinações entre todos os parâmetros do algoritmo, criando um grid. Vamos experimentar este método utilizando o algoritmo de Regressão Logística.<jupyter_code># Importamos o modulo
from sklearn.model_selection import GridSearchCV

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

# Definindo os valores que serão testados
valores_grid = {'penalty': ['l1','l2'], 'C': [0.001,0.01,0.1,1,10,100,1000]}

# Criando o modelo
modelo = LogisticRegression()

# Criando o grid
grid = GridSearchCV(estimator = modelo, param_grid = valores_grid)
grid.fit(X_new, Y)

# Print do resultado
print("Acurácia: %.3f" % (grid.best_score_ * 100))
print("Melhores Parâmetros do Modelo:\n", grid.best_estimator_)<jupyter_output>Acurácia: 92.857
Melhores Parâmetros do Modelo:
 LogisticRegression(C=0.001, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='warn',
          n_jobs=None, penalty='l2', random_state=None, solver='warn',
          tol=0.0001, verbose=0, warm_start=False)<jupyter_text>Random Search Parameter Tuning Este método gera amostras dos parâmetros dos algoritmos a partir de uma distribuição randômica uniforme para um número fixo de iterações. Um modelo é construído e testado para cada combinação de parâmetros.<jupyter_code># Import dos módulos
from sklearn.model_selection import RandomizedSearchCV

# Criamos uma nova variavel para nao afetar ao dataset
X_new = X_minMax.values

# Definindo os valores que serão testados
seed = 7
iterations = 14

# Definindo os valores que serão testados
valores_grid = {'penalty': ['l1','l2'], 'C': [0.001,0.01,0.1,1,10,100,1000]}

# Criando o modelo
modelo = LogisticRegression()

# Criando o grid
rsearch = RandomizedSearchCV(estimator = modelo, 
                             param_distributions = valores_grid, 
                             n_iter = iterations, 
                             random_state = seed)
rsearch.fit(X_new, Y)

# Print dos resultados
print("Acurácia: %.3f" % (rsearch.best_score_ * 100))
print("Melhores Parâmetros do Modelo:\n", rsearch.best_estimator_)<jupyter_output>Acurácia: 92.857
Melhores Parâmetros do Modelo:
 LogisticRegression(C=0.001, class_weight=None, dual=False, fit_intercept=True,
          intercept_scaling=1, max_iter=100, multi_class='warn',
          n_jobs=None, penalty='l2', random_state=None, solver='warn',
          tol=0.0001, verbose=0, warm_start=False)
{'fraction_non_alphanumeric': 0.06358534920755289, 'fraction_numerical': 0.014066884052475923, 'mean_word_length': 5.326457183976973, 'pattern_counts': {'":': 0, '<': 97, '<?xml version=': 0, '>': 97, 'https://': 4, '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': '27', 'dir': 'jupyter-structured-clean-dedup', 'id': '91235', 'license': 'MIT', 'n_tokens_mistral': 9402, 'n_tokens_neox': 8954, 'n_words': 3344, 'path': 'Treino01-Pre-Processamento.ipynb', 'repo_name': 'pauloventurab/Treinos', 'size': '26374'}