Aula 16 – Tensor Flow – Redes Neurais – Classificação com Estimator API

More videos
   

Aula 16 – Tensor Flow – Redes Neurais – Classificação com Estimator API

Voltar para página principal do blog

Todas as aulas desse curso

Aula 15                      Aula 17

Meu github:

https://github.com/toticavalcanti

Documentação oficial do TensorFlow:

https://www.tensorflow.org/

Link para o notebook da aula:

notebook-da-aula

Quer aprender python3 de graça e com certificado? Acesse então:

https://workover.com.br/python-codigo-fluente

Python com Tensorflow

Python com Tensorflow

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

https://digitalinnovation.one/

Link do código fluente no Pinterest

Aproveito para deixar meus link de afiliados:

Hostinger

Digital Ocean

One.com

Toti:

https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA

Backing track / Play-along:

https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA

Código Fluente

https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w

Putz!

https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw

Fiquem a vontade para me adicionar ao linkedin.

Aula 16 – Tensor Flow – Redes Neurais – Classificação com Estimator API

Nessa aula iremos construir um modelo classificador de rede neural profunda ou densa ( DNN ) usando o DNNClassifier do tensorflow.

Lembrando que uma rede neural profunda (DNN) é uma rede neural artificial (ANN) com várias camadas entre as camadas de entrada e saída.

A base de dados que iremos usar é o: Pima Indians Diabetes

É uma classificação binária, 1 se o paciente tem diabetes e 0 se o paciente não tem diabetes.

Contexto

Esse conjunto de dados é originalmente do Instituto Nacional de Diabetes e Doenças Digestivas e Renais.

O objetivo do conjunto de dados é prever diagnosticamente se um paciente tem diabetes ou não, com base em certas medidas diagnósticas incluídas no conjunto de dados.

Várias restrições foram colocadas na seleção dessas instâncias de um banco de dados maior.

Em particular, todos os pacientes aqui são mulheres com pelo menos 21 anos de herança indígena Pima.

Os Pima são índios norte-americanos que tradicionalmente viviam ao longo dos rios Gila e Salt no Arizona, EUA.

Conteúdo

O conjunto de dados consiste em várias variáveis preditoras médicas e uma variável de destino, ou resultado.

As variáveis preditoras incluem o número de gestações que a paciente teve, seu IMC, nível de insulina, idade e assim por diante.

Variáveis ou Features

Pregnancies: Número de gestações
Glucose: concentração de glicose no plasma ao longo de 2 horas em um teste de tolerância à glicose oral
BloodPressure: pressão arterial diastólica (mm Hg)
SkinThickness: espessura da dobra da pele do tríceps (mm)
Insulin: insulina sérica de 2 horas (mu U / ml)
BMI: IMC, índice de massa corporal (peso em kg / (altura em m) 2)
DiabetesPedigreeFunction: função de linhagem de diabetes (uma função que avalia a probabilidade de diabetes com base no histórico familiar)
Age: Idade (anos)
Outcome: variável de classe (0 se não diabético, 1 se diabético)

Normalização

O objetivo da normalização é alterar os valores das colunas numéricas no conjunto de dados usando uma escala comum, sem distorcer diferenças nos intervalos de valores ou perda de informações evitando que o modelo fique enviesado.

Imagine por exemplo que você tenha uma coluna variando entre 0 e 1, uma outra entre -10 e 10, uma outra entre 1000 e 10000, essa grande diferença na escala pode causar problemas quando você tenta combinar os valores.

Logo aqui abaixo, tem o código do notebook da aula, todo comentado.


# -*- coding: utf-8 -*-
"""04-neural-network-classification.ipynb

Automatically generated by Colaboratory.

Original file is located at
    https://colab.research.google.com/drive/1xeBEsdArLqHNB4cRQdUZsZisLrkrfZfK

# Tensorflow 1

## Aula 16 - Tensor Flow - Redes Neurais - Classificação com DNNClassifier

Trabalharemos com uma base de dados real, é o Pima Indians Diabetes Database

Usaremos o classificador de rede neural densa ( DNNClassifier )

### Importa o tensorflow
"""

import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()

"""## Importa o numpy, o pandas e o matplotlib"""

# Commented out IPython magic to ensure Python compatibility.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# %matplotlib inline

"""## Leitura dos dados e análise exploratória"""

# Nome para a coluna ou mapa de recursos
columns_to_named = ["Pregnancies","Glucose","BloodPressure",
           "SkinThickness","Insulin","BMI","DiabetesPedigreeFunction",
           "Age","Class"]

# Ler o conjunto de dados e renomeia a coluna
df = pd.read_csv(
    "https://raw.githubusercontent.com/toticavalcanti/pima-indians-diabetes/master/diabetes.csv", 
    header = 0, 
    names = columns_to_named)

# Resumo dos dados
df.describe()

# Contagem de valores nulos
df.isnull().sum()

corr = df.corr()
print(corr)
sns.heatmap(corr, 
         xticklabels=corr.columns, 
         yticklabels=corr.columns)

"""No mapa de calor acima, as cores mais brilhantes indicam mais correlação. 
Como podemos ver na tabela e no mapa de calor, os níveis de glicose, idade, IMC e número de gestações têm correlação significativa com a variável de resultado, Outcome, que mudei o nome para Class.
 Observe também a correlação entre pares de características, como idade e gravidez, ou insulina e espessura da pele.

## Diabéticos e não diabéticos
"""

# Gráfico de contagem de resultados
sns.countplot(x = 'Class',data = df)

"""### Histograma de cada característica"""

# Histograma de cada característica
import itertools
col = df.columns[:8]
plt.subplots(figsize = (20, 15))
length = len(col)
for i, j in itertools.zip_longest(col, range(length)):
    plt.subplot((length/2), 3, j + 1)
    plt.subplots_adjust(wspace = 0.1,hspace = 0.5)
    df[i].hist(bins = 20)
    plt.title(i)
plt.show()

"""### Gráfico de pares"""

sns.pairplot(data = df, hue = 'Class')
plt.show()

"""### Função Data_Process() normaliza os dados e faz a divisão do dataset em treino e teste retornando: X_Train, X_Test, Y_Train, Y_Test

## Importa o train_test_split
"""

from sklearn.model_selection import train_test_split

def Data_Process():
    col_norm =['Pregnancies', 'Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI', 'DiabetesPedigreeFunction']
    
    # Normalização usando uma função Lambda personalizada    
    df1_norm = df[col_norm].apply(lambda x :( (x - x.min()) / (x.max()-x.min()) ) )
    
    X_Data = df1_norm
    Y_Data = df["Class"]
    
    X_Train, X_Test, Y_Train, Y_Test = train_test_split(X_Data,Y_Data, test_size=0.3,random_state=101)
    
    return X_Train, X_Test, Y_Train, Y_Test

"""## Função create_feature_column() retorna as colunas de recursos, ou seja, as features"""

def create_feature_column():
    
    feat_Pregnancies = tf.feature_column.numeric_column('Pregnancies')
    feat_Glucose = tf.feature_column.numeric_column('Glucose')
    feat_BloodPressure = tf.feature_column.numeric_column('BloodPressure')
    feat_SkinThickness_tricep = tf.feature_column.numeric_column('SkinThickness')
    feat_Insulin = tf.feature_column.numeric_column('Insulin')
    feat_BMI = tf.feature_column.numeric_column('BMI')
    feat_DiabetesPedigreeFunction = tf.feature_column.numeric_column('DiabetesPedigreeFunction')
    
    feature_column = [feat_Pregnancies, feat_Glucose, feat_BloodPressure, 
                  feat_SkinThickness_tricep, feat_Insulin, 
                 feat_BMI , feat_DiabetesPedigreeFunction] 
    
    return feature_column

"""## Divide os dados em 80% dos dados para treino e 30% para teste através da função Data_Process() """

X_Train, X_Test, Y_Train, Y_Test = Data_Process()

"""## Chama a função que definimos mais acima create_feature_column() que retorna as features"""

feature_column = create_feature_column()

"""## O pandas_input_fn() retorna a função de entrada que vai alimentar o DataFrame Pandas no modelo

Vamos usar a input_func para treinar o modelo e a eval_func para testar o modelo
"""

input_func = tf.estimator.inputs.pandas_input_fn(X_Train, 
                                                 Y_Train,
                                                 batch_size = 50,
                                                 num_epochs = 1000,
                                                 shuffle = True)

eval_func = tf.estimator.inputs.pandas_input_fn(X_Test,
                                               Y_Test,
                                               batch_size = 50,
                                               num_epochs = 1,
                                               shuffle = False)

predict_input_fn = tf.estimator.inputs.pandas_input_fn(
      x = X_Test,
      num_epochs = 1,
      shuffle = False)

"""## Cria o modelo DNN ( Deep Neural Network )"""

dnnmodel = tf.estimator.DNNClassifier(
                                        hidden_units = [20,20],
                                        feature_columns = feature_column,
                                        n_classes = 2,
                                        activation_fn = tf.nn.softmax,
                                        dropout = None,
                                        optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
                                    )

"""## Treino do modelo"""

history = dnnmodel.train(input_fn = input_func, steps = 500)

"""## Teste do modelo"""

dnnmodel.evaluate(eval_func)

"""## Predições"""

from sklearn.metrics import confusion_matrix, classification_report

predictions = list(dnnmodel.predict(input_fn = predict_input_fn))
prediction = [p["class_ids"][0] for p in predictions]
data = classification_report(Y_Test, prediction)
conmat = confusion_matrix(Y_Test, prediction)

"""## Análise

## Instala no notebook o scikit-plot

OBS. Basta rodar uma vez, por isso tá comentado, se quiser instalar é só descomentar
"""

!pip install scikit-plot

import scikitplot as skplt
skplt.metrics.plot_confusion_matrix(Y_Test, 
                                    prediction,
                                   figsize = (6,6),
                                   title = "Confusion Matrix")

print(data)

Função de custo

Antes de seguir para as métricas, vamos lembrar que a função de custo, ou de perda ( loss ), é o que queremos minimizar treinando a rede, afim de que ela faça seu trabalho corretamente, que no nosso caso é dizer se um paciente tem diabetes ou não baseado nas features que os dados oferece.

Métricas

accuracy = (TP + TN)/(TP + TN + FP + FN)

precision = TP / (TP + FP)

recall = TP / (TP + FN)

f1-score = 2 * precision * recall / precision + recall = TP / TP + 0.5 * (FP + FN)

Onde: TP = True positive; FP = False positive; TN = True negative; FN = False negative

O f1-score na análise estatística da classificação binária, é uma medida da precisão de um teste. É calculado a partir da precisão e recuperação do teste

A precision é definida como ‘a qualidade de ser exato‘ e refere-se a quão próximas duas ou mais medições estão umas das outras, independentemente de essas medições serem precisas ou não. É possível que as medições de precisão não sejam precisas.

O support é número de ocorrências de cada rótulo em y_true. No caso do diabetes dataset, a quantidade de pessoas com diabetes e sem diabetes.

A precision / mean: média da precisão

A accuracy é a porcentagem do número correto de classificações. Lembrando que é necessário que a proporção de exemplos para cada classe sejam iguais, é uma boa métrica para quando as penalidades de acerto e erro para cada classe forem as mesmas.

A accuracy é definida como ‘o grau em que o resultado de uma medição está em conformidade com o valor correto ou padrão‘ e, essencialmente, refere-se a quão próxima uma medição está de seu valor acordado.

accuracy_baseline: linha base da precisão com base na média dos rótulos. Isso é o melhor que o modelo pode fazer ao prever uma classe sempre.

auc ou área sob a curva (ROC): informa algo sobre a taxa de verdadeiro / falso positivo. Resumindo, é uma métrica interessante para tarefas com classes desproporcionais.

auc_precision_recall: É a porcentagem de instâncias relevantes, entre as instâncias recuperadas, que foram recuperadas sobre a quantidade total de instâncias relevantes.

Quando você treina uma rede, geralmente a alimenta com insumos em lotes.

No exemplo, o tamanho do lote é 50, então a loss é a soma das perdas em um lote, enquanto a perda média é a média das perdas em todos os lotes.

Average_loss: Você geralmente está minimizando alguma função de custo, e este é o valor médio de perda dessa função de custo em todos os lotes.

loss: O valor atual da perda do lote atual, ou seja, a soma da perda do último lote.

global_step: Número de iterações

label/mean:  O label é o valor que a rede deve produzir, ou seja, prever para uma determinada entrada. Resumindo, é o label dividido pelo número de elementos.

prediction/mean: é a soma de todas essas saídas dividida pelo número de saídas.

Por essa aula é só, nos vemos na próxima, \o/ e até lá.

Link para o notebook da aula:

notebook-da-aula

Voltar para página principal do blog

Todas as aulas desse curso

Aula 15                      Aula 17

Meu github:

https://github.com/toticavalcanti

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Novamente deixo meus link de afiliados:

Hostinger

Digital Ocean

One.com

Obrigado, até a próxima e bons estudos. 😉

About The Author
-

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>