<jupyter_start><jupyter_text>Por @vilsonrodrigues  Nome do Projeto   Parte I - Apresentação do Problema [1. Apresentação do Problema](apresentacao) Parte II - Preparativos Iniciais [1. Bibliotecas](bibliotecas) [2. Classe](classe) [3. Funções](funcoes) [4. Leitura da Base](leiturabase) Parte III - Desenvolvimento [1. Entendimento de Negócio](negocio) [2. Entendimento de Dados](enten_dados) [3. Preparação de Dados](preparo) [4. Métricas de Avaliação](metricas) [5. Modelagem](modelagem) [6. Avaliação de Modelo](avaliacao) [7. Conclusão e Recomendações](conclusao) [8. Implantação de Modelos](implantacao)  Parte I - Apresentação do Problema  Meta Fonte dos Dados ReferênciaHands On: Machine Learning with Scikit-Learning e Tensor Flow  Parte II - Preparativos Iniciais  1. Bibliotecas [1.1 Instalações](instalacao) [1.2 Importações](importacao)  1.1. Instalação<jupyter_code>!pip install pandas -U
!pip install scikit-learn -U
!pip install numpy -U
!pip install joblib==0.14.1
!conda install xgboost -c conda-forge --yes<jupyter_output><empty_output><jupyter_text>1.2. Importação<jupyter_code>import pandas as pd
import numpy as np

#Persistência em disco
import joblib
import pickle

#Visualização
import seaborn as sns
import matplotlib.pyplot as plt

#Transformadores e Modelador
from sklearn.pipeline          import Pipeline
from sklearn.preprocessing     import StandardScaler
from sklearn.base              import BaseEstimator, TransformerMixin

#Selecao de modelo
from sklearn.model_selection   import train_test_split
from sklearn.model_selection   import KFold
from sklearn.model_selection   import cross_val_score
from sklearn.model_selection   import GridSearchCV
from sklearn.feature_selection import SelectKBest, f_classif
from sklearn.feature_selection import chi2

#Metricas
from sklearn.metrics           import classification_report
from sklearn.metrics           import confusion_matrix
from sklearn.metrics           import make_scorer
from sklearn.metrics           import accuracy_score
from sklearn.metrics           import f1_score
from sklearn.metrics           import recall_score
from sklearn.metrics           import precision_score

#Classificadores
from sklearn.ensemble          import RandomForestClassifier
from xgboost                   import XGBClassifier
from sklearn.tree              import DecisionTreeClassifier
from sklearn.neighbors         import KNeighborsClassifier
from sklearn.naive_bayes       import GaussianNB
from sklearn.svm               import SVC
from sklearn.neural_network    import MLPClassifier

#modo não-perturbe
import warnings
warnings.filterwarnings("ignore")<jupyter_output><empty_output><jupyter_text>2. Classe Classe para realizar x-ação<jupyter_code><jupyter_output><empty_output><jupyter_text>3. Funções Função que usa GridSearch para avaliar o melhor modelo disponível, retornar estatísticas dos resultados e persistir em disco os modelos gerados<jupyter_code>def avaliar_modelos(df, hyperparameters):

  #Dicionários
  model_param_disciplinas = {}
  best_acc_disciplinas = {}
  scoring_disciplinas = {}
  #feature_importances_disciplinas = {}

  #Seleciona o codigo de cada disciplina no dataframe, --alteravel--
  lista_disciplinas = df["disciplina"].unique()  

  #Verifica se esta vazio
  if lista_disciplinas is None:
	  return None

  #Convertendo categorias do target de string para numerico (0,1)
  df["situacao_categoria"] = pd.Categorical(df["situacao"]).codes

  #Pipeline para transformar em categoria e verificar melhores parametros
  pipeline_transform = Pipeline(steps = [('num_pipeline', NumericalTransformer()),
                                         ('fs',SelectKBest(chi2)),
                                         ('sc',StandardScaler()),
                                         ('clf',XGBClassifier())
                               ])

  #Grid para testar todos os parâmetros                               
  grid_search = GridSearchCV(
                          estimator = pipeline_transform, 
                          param_grid = hyperparameters,
                          cv= 5,
                          scoring = {'Accuracy': make_scorer(accuracy_score)},
                          #scoring = {"AUC": "roc_auc", "Accuracy": make_scorer(accuracy_score), "F1":"f1", "Recall":"recall", "Precision":"precision"},
                          return_train_score=True,
                          n_jobs=-1,#indica o numero de processos em paralelo, -1 significa usar todos
                          refit='Accuracy')


  #itera sobre a lista de disciplinas
  for disciplina in lista_disciplinas:
    data_iter = df.loc[df["disciplina"].str.contains(disciplina),:]
    
    #Treinando Grid
    best_model = grid_search.fit(data_iter.drop(columns = ["disciplina","situacao_categoria"]), data_iter["situacao_categoria"])
 
    #Extraindo informações do treino
    param_modelo = best_model.best_params_
    model_param_disciplinas[disciplina] = param_modelo['clf']
    best_acc_disciplinas[disciplina] = best_model.best_score_

    #Resultado de metricas
    result = pd.DataFrame(best_model.cv_results_)
    result = result[['mean_train_Accuracy', 'std_train_Accuracy','mean_test_Accuracy', 'std_test_Accuracy','rank_test_Accuracy']].copy()
    result["std_ratio"] = result.std_test_Accuracy/result.std_train_Accuracy
    result = result.sort_values(by="rank_test_Accuracy",ascending=True)    
    scoring_disciplinas[disciplina] = result.iloc[0,:]

    #Características mais importantes
    #feature_importances_disciplinas[disciplina] = grid.best_estimator_.feature_importances_
    
    #Salvando modelo
    joblib.dump(best_model, 'modelo_' + disciplina + '.pkl')


  #Transformando o dicionário para Dataframe
  df_best_acc = pd.DataFrame.from_dict(best_acc_disciplinas, orient="index")
  df_best_acc.columns = ["accuracy"]
  df_scor_disc = pd.DataFrame.from_dict(scoring_disciplinas, orient="index")

  #Concatenando DataFrames
  df_relatorio = pd.concat([df_best_acc, df_scor_disc], axis=1, sort=False)

  return (df_relatorio,model_param_disciplinas)<jupyter_output><empty_output><jupyter_text>4. Leitura da Base<jupyter_code>df = pd.read_csv('')
df.head()<jupyter_output><empty_output><jupyter_text>Parte III - Desenvolvimento  1. Entendimento de Negócio ● Determinar objetivos de Negócio ● Estabelecer Critérios de Sucesso da Iniciativa ● Análise do contexto: terminologia, benefício, riscos e plano de contingência ● Determinar objetivos de Mineração de Dados ● Plano do Projeto  2. Entendimento de Dados [2.1 Descrição de Dados](descricao) [2.2 Qualidade de Dados](qualidade) [2.3 Exploração de Dados](exploracao) 2.1 Descrição de Dados  Número de Atributos (colunas): x  Número de Registros (linhas): y registros Base contêm y dados sem nenhum valor não-nulo.  Tipos dos Atributos:| Inteiros | Floats(Ponto Flutuante) | Booleano (Binários) | String (Texto) || --- | --- | --- | --- || a | b | c | d |Descrição de Colunas: 1. Nomes  Contêm nomes de clientes Coluna Alvo 10. Coluna_Preditora  Coluna que quero predizer<jupyter_code>df.info()
df.select_dtypes(include=['int64','float64']).describe()
profile = ProfileReport(df, title='Pandas Profiling Report', html={'style':{'full_width':True}})<jupyter_output><empty_output><jupyter_text>2.2 Qualidade dos dados Plotando correlação entre os dados númericos<jupyter_code>corr = df.corr()
corr = corr.style.background_gradient(cmap='Blues')
corr<jupyter_output><empty_output><jupyter_text>Falar um pouco da correlação 2.3 Exploração de Dados<jupyter_code><jupyter_output><empty_output><jupyter_text>3. Preparação de Dados<jupyter_code><jupyter_output><empty_output><jupyter_text>4. Métricas de Avaliação  Métricas de Avaliação:| Regressores | Classificadores| --- | --- || RMSE| Matriz de Confusão || MAE| Acurácia || R2| Precisão / Recall / F1 || R2 Ajustado| AUC | 5. Modelagem Dicionário com hiper-parâmetros dos algoritmos preditivos<jupyter_code>hyperparameters = [
                  {"clf":[RandomForestClassifier()],
                  "clf__n_estimators": [100],
                  "clf__criterion": ["entropy"],
                  "clf__max_leaf_nodes": [64],
                  "clf__random_state": [42],
                  "fs__score_func":[chi2],
                  "fs__k":[4,9,15,30]
                  },
              
                  {"clf":[KNeighborsClassifier()],
                  "clf__n_neighbors":[5,9,11],
                  "fs__score_func":[chi2],
                  "fs__k":[4,9,15,30]                 
                  },
              
                  {"clf":[SVC()],
                  "clf__kernel":["sigmoid",'rbf'],
                  "clf__degree":[3,4],
                  "clf__gamma":[0.1,0.5,1],
                  "clf__C":[0.001,1,2],
                  "fs__score_func":[chi2],
                  "fs__k":[4,9,15,25,31] 
                  },
              
                  {"clf":[GaussianNB()]
                  },
              
                  {"clf":[MLPClassifier()],
                  "clf__hidden_layer_sizes": [(64,),(128,)],
                  "clf__activation": ["logistic"],
                  "clf__solver": ["sgd"],
                  "clf__max_iter": [500],
                  "clf__early_stopping":[True],
                  "clf__n_iter_no_change":[20],
                  "clf__validation_fraction":[0.20], 
                  },
              
                  {"clf":[XGBClassifier()],
                  "clf__n_estimators": [50,100],
                  "clf__max_depth": [4,6],
                  "clf__learning_rate": [0.001, 0.01,0.1],
                  "clf__random_state": [42],
                  "clf__subsample": [1.0],
                  "clf__colsample_bytree": [1.0],
                  "fs__score_func":[chi2],
                  "fs__k":[5,8,15,25,31]
                  }
  ]<jupyter_output><empty_output><jupyter_text>6. Avaliação dos Modelos [6.1 Chamada da Função](chamada) [6.2 Teste de Modelo](teste) 6.1 Chamada da Função<jupyter_code>(df_relatorio, model_param_disciplinas) = avaliar_modelos(df, hyperparameters)
df_relatorio.head()
model_param_disciplinas<jupyter_output><empty_output><jupyter_text>6.2 Teste de Modelo Importando Modelo<jupyter_code>modelo_teste = joblib.load('modelo_.pkl')<jupyter_output><empty_output><jupyter_text>Aplicando a transformação no teste<jupyter_code>num_transf = NumericalTransformer()
df_teste = model.transform(df)
df_teste.head(2)<jupyter_output><empty_output><jupyter_text>Realizando teste de um modelo, prevendo probabilidade de ser aprovado<jupyter_code>df_teste.iloc[42,:]
df_teste.info()
modelo_teste.predict(df_teste.iloc[42,:])<jupyter_output><empty_output><jupyter_text>7. Conclusão e Recomendações  8. Implantação de Modelos<jupyter_code><jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.10256171401956218, 'fraction_numerical': 0.016301816488122962, 'mean_word_length': 3.1839438815276697, 'pattern_counts': {'":': 41, '<': 61, '<?xml version=': 0, '>': 61, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 6, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '15', 'dir': 'jupyter-structured-clean-dedup', 'id': '656949', 'license': 'MIT', 'n_tokens_mistral': 3717, 'n_tokens_neox': 3539, 'n_words': 717, 'path': 'Modelo_de_Projeto.ipynb', 'repo_name': 'vilsonrodrigues/PortfolioDataScience', 'size': '10735'}