TensorFlow e Keras

Instalação dos pacotes auxiliares...

              
 pip3 install pandas seaborn matplotlib numpy
              
            

Instalação do TensorFlow e Keras

              
 sudo apt install python3-pip

 pip3 install virtualenv

 virtualenv -p python3 TensorKeras

 source TensorKeras/bin/activate

 pip3 install tensorflow=1.5 keras
              
            

Implementação

Librarys para manipulação e visualização:

              
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
              
            

Seleção de atributos:

              
#Criação das colunas para tabela
columns = [i-1 for i in range(1,15)]
columns[0] = 'Class'

#Leitura do dataset com pandas
df = pd.read_csv('wine.data.txt')

#Recriação de dataframe com as colunas criadas
df = pd.DataFrame(df.values.tolist(), columns=columns)

#Visualização das correlações em um mapa de calor
plt.figure(figsize=(10, 10))
sns.heatmap(df.iloc[:, 1:].corr(), annot=True)


#Lista com atributos de menor correlação
selected_columns = [3, 2, 4, 2, 13, 2, 4, 13, 6, 13, 6, 12]
selected_columns = set(selected_columns)
selected_columns.add('Class')

#Configura o tipo de dados
df = df.astype('float32')

#Função para selecionar um percentil do conjunto de dados
def split_data(data, percent=0.8):
    index = int(percent * len(data))
    return data[:index], data[index:]

#Resolver problemas com as classes ([1, 2, 3] -> [0, 1, 2])
df['Class'] = df['Class'] - 1

#Separa as classes do conjunto de dados
labels = df.iloc[:, 0].values

#Seleciona os atributos fracamente correlacionados
features = df[list(selected_columns)].values

#Separa o conjunto de dados com a função 'split_data'
X_train, X_test = split_data(features)
Y_train, Y_test = split_data(labels)

np.save('X_train', X_train)
np.save('X_test', X_test)
np.save('Y_train', Y_train)
np.save('Y_test', Y_test)
              
            

Visualização do mapa de correlação

O que é Keras?

Implementação com Keras

Importe as libs nescessárias

              
import numpy as np
from keras.models import Sequential
from keras.layers import Dense
from keras.utils import to_categorical
import matplotlib.pyplot as plt
from keras.optimizers import Adam
from keras.initializers import TruncatedNormal
              
            

Recuperando dados e configurando a rede

              
#Carrega os dados salvos no pré-processamento com numpy
X_train, X_test = np.load('X_train.npy'), np.load('X_test.npy')
Y_train, Y_test = np.load('Y_train.npy'), np.load('Y_test.npy')

#Criando uma matriz binária '[1,0,0]'
Y_train, Y_test = to_categorical(Y_train), to_categorical(Y_test)

#Recupera a quantidade de valores armazenados
input_dim = len(X_train[0, :])
classes_num = len(Y_train[0, :])

model = Sequential()
init = TruncatedNormal(stddev=0.01, seed=10)

#Configurando modelo da rede
model.add(Dense(units=50, activation='relu', input_dim=input_dim,
          kernel_initializer=init))
model.add(Dense(units=classes_num, activation='softmax',
          kernel_initializer=init))

#Inicializando o otimizador
adam = Adam(lr=0.007)

#Configurando a forma de compilação da rede
model.compile(loss='categorical_crossentropy',
              optimizer=adam,
              metrics=['accuracy'])

#Treino da rede
history = model.fit(X_train, Y_train, epochs=800,
          validation_data=(X_test, Y_test), shuffle=False)

plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='best')
plt.show()

plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='best')
plt.show()
              
            

Gráfico de acurácia e perda

O que é TensorFlow?

Conceitos

Implementação com TensorFlow

Importe o TensorFlow

              
import tensorflow as tf
              
            

Criando modelo

              
  Y_train, Y_test = tf.keras.utils.to_categorical(Y_train), tf.keras.utils.to_categorical(Y_test)

  features_num = len(X_train[0])

  l1 = 50

  l2 = len(Y_train[0])

  tf.set_random_seed(10)

  #Criando entrada para os dados e classes
  X = tf.placeholder(shape=[None, features_num], dtype=tf.float32, name="Input")
  labels = tf.placeholder(shape=[None, l2], dtype=tf.float32, name="Labels")


  with tf.name_scope("Hidden_Layer") as scope:
      #Criando pesos e bias da camada intermediária
      W1 = tf.Variable(tf.truncated_normal([features_num, l1], stddev=0.01), name="W1")
      B1 = tf.Variable(tf.zeros([l1]), name="B1")

      #Calculando saída da camada intermediária
      l1_activation = tf.nn.relu(tf.matmul(X, W1) + B1, name="l1_activation")
              
            

Grafo da Camada Intermediária

              
with tf.name_scope("Final_Layer") as scope:
    #Criando pesos e bias da camada de saída
    W2 = tf.Variable(tf.truncated_normal([l1, l2], stddev=0.01), name="W2")
    B2 = tf.Variable(tf.zeros([l2]), name="B2")

    #Calculando saída da camada de saída
    final_result = tf.nn.softmax(tf.matmul(l1_activation, W2) + B2, name="result")
              
            

Grafo da Camada Final

              
with tf.name_scope("Loss_function") as scope:
    #Criando a entropia cruzada
    loss_func = -tf.reduce_sum(labels * tf.log(final_result))
              
            

Grafo da Função de Custo

              
with tf.name_scope('Accuracy') as scope:
    #Verificando se a classe predita é igual à real [1, 0, 0] [0.1, 0.9, 0.0]
    is_correct = tf.equal(tf.argmax(final_result, axis=1), tf.argmax(labels, axis=1))

    #Calculando a acurácia
    accuracy = tf.reduce_mean(tf.cast(is_correct, tf.float32))
              
            

Grafo da acurácia

Referências