<jupyter_start><jupyter_text>Minicurso - ML (P2) <NAME> -  <NAME> - <NAME>Este segundo módulo se dedica ao treinamento e avaliação de árvores de decisão, Perceptron Multicamadas (MLP) e Random Forest (RF) utilizando os dados do repositório sonar do UCI Machine Learning (link abaixo). O dataset constitui características de reflexão de objetos utilizando sonar e a variável dependente descreve se objeto é uma pedra (R) ou um minério (M). Vamos tentar prever essa relação.Link dataset : https://archive.ics.uci.edu/ml/datasets/Connectionist+Bench+(Sonar,+Mines+vs.+Rocks)<jupyter_code>import random
import warnings
import pydotplus
import numpy as np
import pandas as pd  
from IPython.display import Image 
from sklearn.metrics import accuracy_score
from sklearn.externals.six import StringIO
from IPython.core.display import display, HTML
from sklearn.neural_network import MLPClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.model_selection import train_test_split, cross_validate, GridSearchCV
warnings.filterwarnings("ignore")
df = pd.read_csv('data/sonar.all-data.csv', sep = ',', header = None)
# Renomeia com list comprehension
df.columns = ['x' + str(i+1) if i != (df.shape[1]-1)  else 'y' for i in df.columns]
df.head()
df.shape
# Matriz de entrada
X = np.array(df[df.columns[:-1]])
# Matriz de saída
Y = np.array(df[df.columns[-1]])
# Divisão em treinamento e teste (70 % treinamento e 30% teste)
p = 0.7 # porc. para treinamento
train_x, test_x, train_y, test_y = train_test_split(X, Y, test_size = 1-p, random_state = 42)<jupyter_output><empty_output><jupyter_text>Árvores de Decisão<jupyter_code>dtree = DecisionTreeClassifier(random_state = 76)
dtree = dtree.fit(train_x, train_y)
pred_y = dtree.predict(test_x)
accuracy_score(test_y, pred_y)
# Visualização da árvore treinada
dot_data = StringIO()
export_graphviz(dtree, out_file=dot_data,  
                filled=True, rounded=True,
                special_characters=True, feature_names = list(df.columns)[:-1])
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
Image(graph.create_png())
# Com KFold cross validate
dtree = DecisionTreeClassifier(random_state = 76)
cv_results = cross_validate(dtree, X, Y, cv = 10, 
                            scoring = 'accuracy', return_estimator = True, n_jobs = -1)
# Acurácia de treinamento do melhor modelo (média e desvio padrão)
train_score = cv_results['train_score']
print('Acurácia treinamento : ' + str(train_score.mean()) + ' +- ' 
      + str(train_score.std()))
# Acurácia de teste do melhor modelo (média e desvio padrão)
test_score = cv_results['test_score']
print('Acurácia teste : ' + str(test_score.mean()) + ' +- ' 
      + str(test_score.std()))
# Selecionando a melhor árvore obtida no cross validation
best_tree = cv_results['estimator'][np.argmax(cv_results['test_score'])]
best_tree<jupyter_output><empty_output><jupyter_text>MLP<jupyter_code># Parâmetros cujas combinações serão testadas
mlp_param = {
    'hidden_layer_sizes': [(10,20), (10,20,10), (10)],
    'activation': ['tanh', 'relu'],
    'solver': ['sgd', 'adam'],
    'alpha': [0.01, 0.05],
    'learning_rate': ['constant'],
}
# Testa todas as combinações de parâmetros do MLP com KFold
clf_gs_mlp = GridSearchCV(MLPClassifier(), mlp_param, cv=10, n_jobs=-1).fit(X, Y)
# Pega index do melhor modelo
idx=clf_gs_mlp.best_index_
# Acurácia de treinamento do melhor modelo (média e desvio padrão)
train_score_mean = clf_gs_mlp.cv_results_['mean_train_score'][idx]
train_score_std = clf_gs_mlp.cv_results_['std_train_score'][idx]
print('Acurácia treinamento : ' + str(train_score_mean) + ' +- ' 
      + str(train_score_std))
# Acurácia de teste do melhor modelo (média e desvio padrão)
test_score_mean = clf_gs_mlp.cv_results_['mean_test_score'][idx]
test_score_std = clf_gs_mlp.cv_results_['std_test_score'][idx]
print('Acurácia teste : ' + str(test_score_mean) + ' +- ' 
      + str(test_score_std))<jupyter_output>Acurácia teste : 0.6778846153846154 +- 0.19444393937803617<jupyter_text>RF<jupyter_code># Parâmetros cujas combinações serão testadas
rf_param = {
    'n_estimators': [5, 10, 15, 30], 
    'max_depth': [3, 5, 10], 
    'min_samples_split': [2, 3],
}
# Testa todas as combinações de parâmetros do RF com KFold
clf_gs_rf = GridSearchCV(RandomForestClassifier(n_jobs = -1), rf_param, cv=10, n_jobs=-1).fit(X, Y)
# Pega index do melhor modelo
idx=clf_gs_rf.best_index_
# Acurácia de treinamento do melhor modelo (média e desvio padrão)
train_score_mean = clf_gs_rf.cv_results_['mean_train_score'][idx]
train_score_std = clf_gs_rf.cv_results_['std_train_score'][idx]
print('Acurácia treinamento : ' + str(train_score_mean) + ' +- ' 
      + str(train_score_std))
# Acurácia de teste do melhor modelo (média e desvio padrão)
test_score_mean = clf_gs_rf.cv_results_['mean_test_score'][idx]
test_score_std = clf_gs_rf.cv_results_['std_test_score'][idx]
print('Acurácia teste : ' + str(test_score_mean) + ' +- ' 
      + str(test_score_std))<jupyter_output>Acurácia teste : 0.7307692307692307 +- 0.13574610744555834
{'fraction_non_alphanumeric': 0.11832583610404851, 'fraction_numerical': 0.02562096616467827, 'mean_word_length': 5.5229591836734695, 'pattern_counts': {'":': 0, '<': 18, '<?xml version=': 0, '>': 18, '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': '4', 'dir': 'jupyter-structured-clean-dedup', 'id': '208252', 'license': 'MIT', 'n_tokens_mistral': 2066, 'n_tokens_neox': 1962, 'n_words': 428, 'path': 'arvores_e_MLP.ipynb', 'repo_name': 'mateuspedrino/minicurso_machine_learning', 'size': '5134'}