<jupyter_start><jupyter_text>Etapa de treinamento  Realizando import das bibliotecas- pandas: manipulação do dataset- sklearn: inclui modelos de aprendizado de máquina- visuals: código para printar gráfico dos resultados de vários modelos<jupyter_code>import pandas as pd
from time import time
from sklearn.model_selection import train_test_split
from sklearn.metrics import fbeta_score
from sklearn.metrics import accuracy_score
from sklearn.naive_bayes import GaussianNB
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
import visuals as vs
from sklearn.model_selection import GridSearchCV
from sklearn.metrics import make_scorer<jupyter_output><empty_output><jupyter_text>Lê o dataset "limpo" após o pré-processamento<jupyter_code>redwine = pd.read_csv('../clean-redwine.csv', sep=',')<jupyter_output><empty_output><jupyter_text>Visualiza as primeiras 10 linhas<jupyter_code>redwine.head(10)<jupyter_output><empty_output><jupyter_text>Salva a coluna cat_quality na variável rawQuality e o dataset sem as duas colunas de qualidade na variável rawFeatures<jupyter_code>rawQuality = redwine['cat_quality']
rawFeatures = redwine.drop(['quality', 'cat_quality'], axis = 1)<jupyter_output><empty_output><jupyter_text>Separa os dados em 80% para treinamento e 20% para teste<jupyter_code>X_treino, X_teste, y_treino, y_teste = train_test_split(rawFeatures, 
 rawQuality, 
 test_size = 0.2, 
 random_state = 0)

# Printa o resultado da separação
print("O conjunto de treino possui {} amostras.".format(X_treino.shape[0]))
print("O conjunto de teste possui {} amostras.".format(X_teste.shape[0]))<jupyter_output>O conjunto de treino possui 1279 amostras.
O conjunto de teste possui 320 amostras.<jupyter_text>Método responsável por executar treino e predição e avaliar a performance do algoritmo de aprendizado de máquina escolhido<jupyter_code>def avaliaPerformanceAlgoritmo(modelo, tamanhoAmostra, X_treino, y_treino, X_teste, y_teste):
    
    resultados = {}
    
    # Captura o tempo inicial de treinamento
    start = time()
    # Treina o modelo
    modelo = modelo.fit(X_treino[:tamanhoAmostra], y_treino[:tamanhoAmostra])
    # Captura o tempo final de treinamento
    end = time()
    
    # Calcula o tempo total de treinamento
    resultados['tempoTreino'] = end - start
    
    # Executa a predição para as primeiras 300 amostras de treinamento
    # e também a predição do conjunto de teste
    
    # Captura o tempo inicial de predição
    start = time()
    treinoPredictions = modelo.predict(X_treino[:300])
    testePredictions = modelo.predict(X_teste)
    # Captura o tempo final de predição
    end = time()
    
    # Calcula o tempo total de predição
    resultados['tempoPredicao'] = end - start
    
    # Calcula a acurácia nas primeiras 300 amostras de treinamento
    resultados['acuraciaTreino'] = accuracy_score(y_treino[:300], treinoPredictions)
    
    # Calcula a acurácia no conjunto de teste
    resultados['acuraciaTeste'] = accuracy_score(y_teste, testePredictions)
    
    # Calcula o F-score nas primeiras 300 amostras de treinamento
    resultados['fTreino'] = fbeta_score(y_treino[:300], treinoPredictions, beta=0.5, average='micro')
    
    # Calcula o F-score no conjunto de teste
    resultados['fTeste'] = fbeta_score(y_teste, testePredictions, beta=0.5, average='micro')
    
    print("{} treinado em {} amostras.".format(modelo.__class__.__name__, tamanhoAmostra))
    
    return resultados<jupyter_output><empty_output><jupyter_text>Utilizaremos 3 algoritmos de aprendizado de máquina para executar o treinamento e avaliar a performance de cada:- Redes Bayesianas- Desicion Tree (Àrvores de Decisão)- Random Forest (Floresta Aleatória)<jupyter_code>algoritmo1 = GaussianNB()
algoritmo2 = DecisionTreeClassifier(max_depth=None, random_state=None)
algoritmo3 = RandomForestClassifier(max_depth=None, random_state=None)

amostras_100 = len(y_treino)
amostras_10 = int(len(y_treino)*10/100)
amostras_1 = int(len(y_treino)/100)

resultados = {}
for algoritmo in [algoritmo1, algoritmo2, algoritmo3]:
    nomeAlgoritmo = algoritmo.__class__.__name__
    resultados[nomeAlgoritmo] = {}
    for i, amostras in enumerate([amostras_1, amostras_10, amostras_100]):
        resultados[nomeAlgoritmo][i] = \
        avaliaPerformanceAlgoritmo(algoritmo, amostras, X_treino, y_treino, X_teste, y_teste)
        

vs.visualizarPerformanceAlgoritmos(resultados)<jupyter_output>GaussianNB treinado em 12 amostras.
GaussianNB treinado em 127 amostras.
GaussianNB treinado em 1279 amostras.
DecisionTreeClassifier treinado em 12 amostras.
DecisionTreeClassifier treinado em 127 amostras.
DecisionTreeClassifier treinado em 1279 amostras.
RandomForestClassifier treinado em 12 amostras.
RandomForestClassifier treinado em 127 amostras.
RandomForestClassifier treinado em 1279 amostras.<jupyter_text>Podemos observar nos resultados que a performance do algoritmo de Redes Bayesianas não é tão boa se comparado com os algoritmos de Decision Tree e Random Forest.  Criando um modelo , utilizando o algoritmo RandomForest, que mostrou ser mais eficiente para esse estudo<jupyter_code>modelo = RandomForestClassifier(max_depth=None, random_state=None)<jupyter_output><empty_output><jupyter_text>Treina o modelo<jupyter_code>modelo = modelo.fit(X_treino, y_treino)<jupyter_output>/home/bergmann/.local/lib/python3.6/site-packages/sklearn/ensemble/forest.py:245: FutureWarning: The default value of n_estimators will change from 10 in version 0.20 to 100 in 0.22.
  "10 in version 0.20 to 100 in 0.22.", FutureWarning)<jupyter_text>Extrai os atributos mais importantes<jupyter_code>atributosImportances = modelo.feature_importances_
print(X_treino.columns)
print(atributosImportances)<jupyter_output>Index(['fixed acidity', 'volatile acidity', 'citric acid', 'residual sugar',
       'chlorides', 'free sulfur dioxide', 'total sulfur dioxide', 'density',
       'pH', 'sulphates', 'alcohol'],
      dtype='object')
[0.06987333 0.12574212 0.07213422 0.08087362 0.0576745  0.06453822
 0.07121392 0.10214625 0.07846819 0.1069749  0.17036073]<jupyter_text>O gráfico abaixo mostra em ordem da esquerda para direita os 5 atributos mais importantes para determinar um vinho de boa qualidade, sendo a porcentagem de álcool o mais determinante.<jupyter_code>vs.plotaAtributos(atributosImportances, X_treino, y_treino)<jupyter_output><empty_output><jupyter_text>Inicializa um novo classificador RandomForest<jupyter_code>classificador = RandomForestClassifier(max_depth=None, random_state=None)<jupyter_output><empty_output><jupyter_text>Criando alguns parâmetros para o algoritmo, sendo eles:- n_estimators: Números de àrvores na floresta- max_features: Número de atributos a considerar quando procurando a melhor separação- max_depth: A profundidade máxima da àrvore<jupyter_code>parametros = {'n_estimators': [10, 20, 30], 'max_features':[3,4,5,None], 'max_depth': [5,6,7,None]}<jupyter_output><empty_output><jupyter_text>Cria um objeto fbeta_score com make_scorer()<jupyter_code>scorer = make_scorer(fbeta_score, beta=0.5, average="micro")<jupyter_output><empty_output><jupyter_text>Realiza um grid search no classificador utilizando o scorer como método de scoring<jupyter_code>gridObj = GridSearchCV(classificador, parametros, scoring=scorer)<jupyter_output><empty_output><jupyter_text>Realiza o Fit do objeto de busca e encontra os parâmetros ótimos<jupyter_code>grid_fit = gridObj.fit(X_treino, y_treino)<jupyter_output>/home/bergmann/.local/lib/python3.6/site-packages/sklearn/model_selection/_split.py:1978: FutureWarning: The default value of cv will change from 3 to 5 in version 0.22. Specify it explicitly to silence this warning.
  warnings.warn(CV_WARNING, FutureWarning)<jupyter_text>Pega o best_estimator_ do objeto de busca, que nada mais é do que o classificador otimizado<jupyter_code>classificadorOtimizado = grid_fit.best_estimator_
classificadorPredicoes = (classificador.fit(X_treino, y_treino)).predict(X_teste)
classificadorOtimizadoPredicoes = classificadorOtimizado.predict(X_teste)<jupyter_output><empty_output><jupyter_text>Finalmente executa o modelo preditivo construído<jupyter_code>dados = [[7.4, 0.7, 0, 1.9, 76, 11, 34, 0.9978, 3.51, 0.56, 9.4], # Esta linha no dataset possui quality 5, logo será 1
           [7.3, 0.65, 0, 1.2, 65, 15, 21, 0.9946, 3.39, 0.47, 10], # Esta linha no dataset possui quality 7, logo será 2
           [6.7, 0.76, 0.02, 1.8, 78, 6, 12, 996, 3.55, 0.63, 9.95]] # Esta linha no dataset possui quality 3, logo será 0

for i, quality in enumerate(classificadorOtimizado.predict(dados)):
    print("Predição da qualidade do vinho {} é: {}".format(i+1, quality))<jupyter_output>Predição da qualidade do vinho 1 é: 1
Predição da qualidade do vinho 2 é: 2
Predição da qualidade do vinho 3 é: 0
{'fraction_non_alphanumeric': 0.0863007484690406, 'fraction_numerical': 0.038557496030845996, 'mean_word_length': 5.8630350194552525, 'pattern_counts': {'":': 0, '<': 67, '<?xml version=': 0, '>': 67, 'https://': 0, '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': '18', 'dir': 'jupyter-structured-clean-dedup', 'id': '548796', 'license': 'MIT', 'n_tokens_mistral': 3418, 'n_tokens_neox': 3122, 'n_words': 791, 'path': 'redwine/notebooks/Training.ipynb', 'repo_name': 'bergmannlucas/winequality-prediction-model', 'size': '8818'}