<jupyter_start><jupyter_text>Calculando entropia<jupyter_code>from collections import Counter
import math

def entropy(class_probabilities):
  """dada uma lista de probabilidades de classe, compute a entropia"""
  return sum(-p * math.log(p, 2) for p in class_probabilities if p) # ignora probabilidades zero, pois o resultado é 0

def class_probabilities(labels):
  total_count = len(labels)
  return [count / total_count for count in Counter(labels).values()]

def data_entropy(labeled_data):
  labels = [label for _, label in labeled_data]
  probabilities = class_probabilities(labels)
  return entropy(probabilities)

fields = {
    'teste1': 'foo',
    # 'teste2': 'foo',
    'teste3': 'foo2',
}  
# Se entropia = 1.0 conjunto totalmente dividido, quanto mais próximo de 1.0 melhor
print(data_entropy(fields.items()))<jupyter_output>1.0<jupyter_text>Acessando o drive<jupyter_code>from google.colab import drive
drive.mount('/content/drive')

!pip install pandas<jupyter_output>Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount("/content/drive", force_remount=True).
Requirement already satisfied: pandas in /usr/local/lib/python3.6/dist-packages (1.1.2)
Requirement already satisfied: numpy>=1.15.4 in /usr/local/lib/python3.6/dist-packages (from pandas) (1.18.5)
Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.6/dist-packages (from pandas) (2.8.1)
Requirement already satisfied: pytz>=2017.2 in /usr/local/lib/python3.6/dist-packages (from pandas) (2018.9)
Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.6/dist-packages (from python-dateutil>=2.7.3->pandas) (1.15.0)<jupyter_text>Inspecionando Dataframes com Pandas Profiling -> dataset https://www.kaggle.com/allen-institute-for-ai/CORD-19-research-challenge/discussion/139347- Quantidade de pacientes;- Idade dos paciêntes;- Etc.<jupyter_code>import pandas as pd

df = pd.read_csv('/content/drive/My Drive/Inteligência Artificial/UA 8/aula 16/dataset_einstein.csv', sep=';')
# print(df.head(50))
# df.info()

count_row = df.shape[0]  # PEGANDO OS NÚMEROS DE REGISTROS
count_col = df.shape[1]  # PEGANDO OS NUMEROS DE COLUNAS

print(count_row)
print(count_col)
# REPAREM QUE HÁ MUITOS REGISTROS EM QUE HÁ DADOS FALTANDO NOS CAMPOS<jupyter_output>5644
11<jupyter_text>Pandas Profiling<jupyter_code>!pip install -U pandas-profiling<jupyter_output><empty_output><jupyter_text>Trabalhando com o Pandas Profiling<jupyter_code>from pandas_profiling import ProfileReport

#Carregando o dataframe no profile report e configurando como html
profile = ProfileReport(df, title='Profile Covid-19', html={'style':{'full_width': True}})

profile.to_notebook_iframe()<jupyter_output><empty_output><jupyter_text>Versão mínima<jupyter_code>profile_minimo = ProfileReport(df, minimal=True)

profile_minimo.to_notebook_iframe()<jupyter_output><empty_output><jupyter_text>Importando modulos para a arvore de decisao<jupyter_code>import numpy as np
import itertools
import pandas as pd
import matplotlib.pyplot as plt

#Arvore
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn import preprocessing
from sklearn.model_selection import train_test_split
from sklearn.externals.six import StringIO

#Analise
import pydotplus
import matplotlib.image as mpimg
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from IPython.display import Image<jupyter_output>/usr/local/lib/python3.6/dist-packages/sklearn/externals/six.py:31: FutureWarning: The module is deprecated in version 0.21 and will be removed in version 0.23 since we've dropped support for Python 2.7. Please rely on the official version of six (https://pypi.org/project/six/).
  "(https://pypi.org/project/six/).", FutureWarning)<jupyter_text>REMOVENDO OS REGISTROS NOS QUAIS PELO MENOS UM CAMPO ESTÁ EM BRANCO (NAN)<jupyter_code>df = df.dropna()

print(df.head(5))

print('Quantidade de campos(colunas): ', df.shape[1])
print('Total de registros:', df.shape[0])

#VAMOS VERIFICAR SE O BANCO DE DADOS ESTÁ BALANCEADO OU DESBALANCEADO
print ('Total de registros negativos: ', df[df['SARS-Cov-2 exam result'] =='negative'].shape[0])
print ('Total de registros positivos: ', df[df['SARS-Cov-2 exam result'] =='positive'].shape[0])<jupyter_output>Patient ID  Patient age quantile  ... Proteina C reativa mg/dL  Creatinine
1   126e9dd13932f68                    17  ...                -0.147895    2.089928
8   8bb9d64f0215244                     1  ...                -0.286986   -1.838623
28  fc41531ca4faf1e                    13  ...                -0.434025   -0.701411
29  891d0f6449ff3d7                    14  ...                -0.529401    0.332418
30  ebdd7c67fcb21b4                     9  ...                 0.545572    1.021638

[5 rows x 11 columns]
Quantidade de campos(colunas):  11
Total de registros: 357
Total de registros negativos:  302
Total de registros positivos:  55<jupyter_text>Precisamos converter o Dataframe para um Array Numpy, que é o tipo de dados que iremos usar no treinamento. Também iremos já separar o Dataset em dois. Um com as features de entrada, e outro com os labels (etiquetas, rótulos do registro).Neste caso, estamos tentando fazer um classificador para o teste do Covid, neste caso, queremos treinar o nosso modelo com a etiqueta presente no campo 'SARS-Cov-2 exam result'<jupyter_code># VAMOS JOGAR AS ETIQUETAS PARA Y
Y = df['SARS-Cov-2 exam result'].values 
print(Y)

# X SERÁ A NOSSA MATRIZ COM AS FEATURES
# VAMOS PEGAR OS CAMPOS DE TREINAMENTO (Hemoglobin, Leukocytes, Basophils, Proteina C reativa mg/dL)

X = df[['Hemoglobin', 'Leukocytes', 'Basophils','Proteina C reativa mg/dL']].values

# VAMOS MOSTRAR X 
print(X)<jupyter_output><empty_output><jupyter_text>Agora precisamos dividir o nosso Dataset em dois: um para o treino (80% dos dados) e outro para o teste (20% dos dados)<jupyter_code>X_treino, X_teste, Y_treino, Y_teste = train_test_split(X, Y, test_size=0.2, random_state=3)<jupyter_output><empty_output><jupyter_text>CRIAR UM ALGORTIMO QUE SERÁ DO TIPO DE ÁRVORE DE DECISÃO<jupyter_code>algortimo_arvore = DecisionTreeClassifier(criterion='entropy', max_depth=5)
# AGORA EM MINHA_ARVORE EU TENHO ASSOCIADA A ELA O ALGORITMO DE TREINAMENTO, 
# BASICAMENTE A RECEITA QUE VIMOS NA PARTE TÉORICA.<jupyter_output><empty_output><jupyter_text>AGORA PRECISAMOS TREINÁ-LA<jupyter_code>modelo = algortimo_arvore.fit(X_treino, Y_treino)<jupyter_output><empty_output><jupyter_text>PODEMOS MOSTRAR A FEATURE MAIS IMPORTANTE (WHITE BOX?)<jupyter_code>print (modelo.feature_importances_)


nome_features = ['Hemoglobin', 'Leukocytes', 'Basophils','Proteina C reativa mg/dL']
nome_classes = modelo.classes_<jupyter_output><empty_output><jupyter_text>MONTAR A IMAGEM DA ÁRVORE<jupyter_code>dot_data = StringIO()
export_graphviz(modelo, out_file=dot_data, filled=True, feature_names=nome_features, class_names=nome_classes, rounded=True, special_characters=True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())  
Image(graph.create_png())
graph.write_png("arvore.png")
Image('arvore.png')<jupyter_output><empty_output><jupyter_text>APLICANDO O MODELO NA BASE DE TESTES E ARMAZENDO O RESULTADO EM Y_PREDICOES<jupyter_code>Y_predicoes = modelo.predict(X_teste)<jupyter_output><empty_output><jupyter_text>AVALIAÇÃO DO MODELO VAMOS AVALIAR O VALOR REAL DO DATASET Y_TESTE COM AS PREDIÇÕES<jupyter_code>print("ACURÁCIA DA ÁRVORE: ", accuracy_score(Y_teste, Y_predicoes))
print (classification_report(Y_teste, Y_predicoes))

# PRECISÃO: DAS CLASSIFICAÇÕES QUE O MODELO FEZ PARA UMA DETERMINADA CLASSE
# RECALL: DOS POSSÍVEIS DATAPOINTS PERTECENTES A UMA DETERMINADA CLASSE<jupyter_output>ACURÁCIA DA ÁRVORE:  0.8472222222222222
              precision    recall  f1-score   support

    negative       0.87      0.97      0.91        60
    positive       0.60      0.25      0.35        12

    accuracy                           0.85        72
   macro avg       0.73      0.61      0.63        72
weighted avg       0.82      0.85      0.82        72<jupyter_text>Vamos entender a Matriz de Confusão<jupyter_code>def plot_confusion_matrix(cm, classes,
                          normalize=False,
                          title='Confusion matrix',
                          cmap=plt.cm.Blues):
    """
    This function prints and plots the confusion matrix.
    Normalization can be applied by setting `normalize=True`.
    """
    plt.imshow(cm, interpolation='nearest', cmap=cmap)
    plt.title(title)
    plt.colorbar()
    tick_marks = np.arange(len(classes))
    plt.xticks(tick_marks, classes, rotation=45)
    plt.yticks(tick_marks, classes)
    
    if normalize:
        cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]
        print("Matriz de Confusão Normalizada")
    else:
        print('Matriz de Confusão sem normalizacão ')

    print(cm)

    thresh = cm.max() / 2.
    for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
        plt.text(j, i, cm[i, j],
                 horizontalalignment="center",
                 color="white" if cm[i, j] > thresh else "black")

    plt.tight_layout()
    plt.ylabel('Rótulo real')
    plt.xlabel('Rótulo prevista')

matrix_confusao = confusion_matrix(Y_teste, Y_predicoes)
plt.figure()
plot_confusion_matrix(matrix_confusao, classes=nome_classes,
                      title='Matrix de Confusao')<jupyter_output>Matriz de Confusão sem normalizacão 
[[58  2]
 [ 9  3]]
{'fraction_non_alphanumeric': 0.10016924053310768, 'fraction_numerical': 0.03511741061984345, 'mean_word_length': 4.206497797356828, 'pattern_counts': {'":': 0, '<': 62, '<?xml version=': 0, '>': 70, 'https://': 3, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 12, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '17', 'dir': 'jupyter-structured-clean-dedup', 'id': '452831', 'license': 'MIT', 'n_tokens_mistral': 3660, 'n_tokens_neox': 3403, 'n_words': 818, 'path': 'aulas/arvore_de_decisao.ipynb', 'repo_name': 'danilovbarbosa/machine_learning', 'size': '9454'}