Rede neural para classificação com Tensorflow

Este artigo foi publicado como parte do Blogathon de Ciência de Dados

Neste artigo, construirei modelos de redes neurais com TensorFlow para resolver um problema de classificação. Vamos explorar juntos como podemos abordar um problema de classificação no Tensorflow. Mas, em primeiro lugar, gostaria de ter certeza de que somos capazes de responder a estas perguntas:

que é Rede Neural?

O principal objetivo de uma rede neural é tentar encontrar a relação entre características de um conjunto de dados, e consiste em um conjunto de algoritmos que imitam o trabalho do cérebro humano. Um “neurônio” em uma rede neural é uma função matemática que coleta e classifica informações de acordo com uma arquitetura específica.

O que é Classificação?

O problema de classificação envolve prever se algo pertence a uma classe ou não. Em outras palavras, enquanto fazemos isso, tentamos ver se algo é uma coisa ou outra.

Tipos de Classificação

• Suponha que você queira prever se uma pessoa tem diabetes ou não. Se você está enfrentando esse tipo de situação, existem duas possibilidades, certo? Isso é chamado Classificação Binária.
• Suponha que você queira identificar se uma foto é de um brinquedo, de uma pessoa ou de um gato, certo? isso é chamado Classificação multiclasse porque existem mais de duas opções.
• Suponha que você queira decidir quais categorias devem ser atribuídas a um artigo. Se sim, é chamado Classificação de vários rótulos, pois um artigo pode ter mais de uma categoria atribuída. Vamos dar nossa explicação através deste artigo. Podemos atribuir categorias como “Deep Learning, TensorFlow, Classificação” etc.

Agora podemos avançar porque temos um entendimento comum do problema em que iremos trabalhar. Então, é hora de codificar. Espero que você os escreva comigo porque a única maneira de melhorar e cometer menos erros é escrever mais código.

Estamos começando importando as bibliotecas que usaremos:

importar numpy como np importar pandas como pd importar matplotlib.pyplot como plt importar tensorflow como tf print(tf.__version__)

Criando um conjunto de dados

É hora de criar um conjunto de dados para trabalhar:

de sklearn.datasets importar amostras make_circles = 1000 X, y = make_circles (amostras, ruído = 0.03, random_state = 42)

imprimir (X >> [[ 0.75424625 0.23148074] [-0.75615888 0.15325888] [-0.81539193 0.17328203] ... [-0.13690036 -0.81001183] [0.67036156 -0.76750154 0.28105665] [0.96382443 XNUMX]]

imprimir (y) >> [1 1 1 1 0 1 1 1 1 0]

Ok, vimos nosso conjunto de dados com mais detalhes, mas ainda não sabemos nada sobre ele, certo? É por isso que aqui um passo importante é tornar-se um com os dados, e a visualização é a melhor maneira de fazer isso.

círculo = pd.DataFrame({ 'X0': X[:, 0], 'X1': X[:, 1], 'rótulo': y}) círculo.head()

Aqui surge uma questão: com que tipo de rótulos estamos lidando?

círculo.label.value_counts() >> 1 500 0 500 Nome: rótulo, dtype: int64

Parece que estamos lidando com um problema de classificação binária, porque temos 2 rótulos (0 e 1).

plt.scatter(X[:,0], X[:,1], c = y, cmap = plt.cm.RdYlBu)

Como mencionei acima, a melhor maneira de obter dados é a visualização. Agora o próprio enredo diz que tipo de modelo precisamos construir. Construiremos um modelo capaz de distinguir pontos azuis de pontos vermelhos.

Antes de construir qualquer modelo de rede neural, devemos verificar os formatos de nossos recursos de entrada e saída. eles devem ser iguais!

imprimir (forma X., forma y) imprimir (len (X), len (y)) >> (1000, 2) (1000,) 1000 1000

Temos a mesma quantidade de valores para cada recurso, mas a forma de X é diferente? Por que? Vamos dar uma olhada.

X[0], y[0] >> (matriz([0.75424625, 0.23148074]), 1)

Ok, temos 2 recursos X por 1 ano. Assim podemos seguir em frente sem nenhum problema.

Etapas na modelagem de rede neural para classificação com Tensorflow

No TensorFlow existem estágios fixos para a criação de um modelo:

• Criação de um modelo – reúna as camadas de uma rede neural usando a API funcional ou sequencial
• Compilando um modelo – definir como o desempenho de um modelo deve ser medido e como ele deve melhorar (função de perda e otimizador)
• Ajustando um modol – deixar um modelo encontrar padrões nos dados

Estaremos usando a API Sequencial. Então vamos começar

tf.random.set_seed(42)

modelo_1 = tf.keras.Sequential([tf.keras.layers.Dense(1)])

 otimizador = tf.keras.optimizers.SGD(), #SGD significa métricas de gradiente descendente estocástico = ['precisão']) model_1.fit(X, y, épocas = 5)

>> Época 1/5 32/32 [==============================] - 1s 1ms/passo - perda: 2.8544 - precisão: 0.4600 Época 2/5 32/32 [==============================] - 0s 2ms/passo - perda : 0.7131 - precisão: 0.5430 Época 3/5 32/32 [==============================] - 0s 2ms/passo - perda: 0.6973 - precisão: 0.5090 Época 4/5 32/32 [==============================] - 0s 2ms /passo - perda: 0.6950 - precisão: 0.5010 Época 5/5 32/32 [==============================] - 0s 1ms/passo - perda: 0.6942 - precisão: 0.4830

A precisão do modelo é de aproximadamente 50%, o que basicamente significa que o modelo está apenas adivinhando, vamos tentar treiná-lo por mais tempo

model_1.fit(X, y, épocas = 200, verbose = 0) #definimos verbose = 0 para remover o procedimento de treinamento) model_1.evaluate(X, y)

>> 32/32 [==============================] - 0s 1ms/passo - perda: 0.6935 - precisão: 0.5000 [0.6934829950332642, 0.5]

Mesmo depois de 200 épocas, ele ainda funciona como se estivesse adivinhando. O próximo passo é adicionar mais camadas e treinar por mais tempo.

tf.random.set_seed(42)

model_2 = tf.keras.Sequential([ tf.keras.layers.Dense(1), tf.keras.layers.Dense(1) ]) model_2.compile(loss = tf.keras.losses.BinaryCrossentropy(), otimizador = tf.keras.optimizers.SGD(), métricas = ['precisão']) model_2.fit(X, y, épocas = 100, detalhado = 0)

 modelo_2.avaliar(X,y)

>> 32/32 [==============================] - 0s 1ms/passo - perda: 0.6933 - precisão: 0.5000 [0.6933314800262451, 0.5]

Mesmo assim, não há nem uma pequena mudança, parece que algo está errado.

Melhorando o modelo de rede neural para classificação com Tensorflow

Existem diferentes maneiras de melhorar um modelo em diferentes estágios:

• Criando um modelo – adicione mais camadas, aumente o número de unidades ocultas (neurônios), altere as funções de ativação de cada camada
• Compilando um modelo – tente diferentes funções de otimização, por exemplo, use Adam() em vez de SGD().
• Ajustando um modelo – poderíamos aumentar o número de épocas

Vamos tentar adicione mais neurônios e tente Adam otimizador

tf.random.set_seed(42)

model_3 = tf.keras.Sequential([tf.keras.layers.Dense(100), # adicione 100 neurônios densos tf.keras.layers.Dense(10), # adicione outra camada com 10 neurônios tf.keras.layers.Dense (1) ]) model_3.compile(loss=tf.keras.losses.BinaryCrossentropy(), optimizador=tf.keras.optimizers.Adam(), métricas=['precisão']) model_3.fit(X, y, épocas =100, detalhado=0)

model_3.evaluate(X,y) >> 32/32 [==============================] - 0s 1ms/passo - perda: 0.6980 - precisão: 0.5080 [0.6980254650115967, 0.5080000162124634]

Ainda não estou melhorando! Vamos visualizar os dados para ver o que está errado.

Visualize o modelo de rede neural

Para visualizar as previsões do nosso modelo, vamos criar uma função plot_decision_boundary() que:

• Inclui um modelo treinado, recursos e rótulos
• Crie uma grade de malha com os diferentes valores de X.
• Faz previsões em toda a malha.
• Plota as previsões com linha.

Observação:  Esta função foi adaptada de dois recursos:

CS231n Feito com noções básicas de ML 

def plot_decision_boundary(model, X, y): # Defina os limites do eixo do gráfico e crie uma grade de malha x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1 y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1 xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np .linspace(y_min, y_max, 100)) # Crie valores X (vamos prever todos eles) x_in = np.c_[xx.ravel(), yy.ravel()] # Faça previsões usando o treinado model y_pred = model.predict(x_in) # Verifica se há multiclasse

 if len(y_pred[0]) > 1: print("doing multiclass rating...") # Temos que remodelar nossas previsões para deixá-las prontas para plotagem y_pred = np.argmax(y_pred, axis=1).reshape( xx.shape) else: print("fazendo classificação binária...") y_pred = np.round(y_pred).reshape(xx.shape) # Traça o limite de decisão plt.contourf(xx, yy, y_pred, cmap=plt. cm.RdYlBu, alfa=0.7) plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu) plt.xlim(xx.min( ), xx.max()) plt.ylim(yy.min(), yy.max()) plot_decision_boundary(model_3, X, y)

Aqui está! Mais uma vez, a visualização nos mostra o que está errado e o que fazer? Nosso modelo está tentando traçar uma linha reta através dos dados, mas nossos dados não são separáveis ​​por uma linha reta. Há algo faltando em nosso problema de classificação? O que é isso?

Isso é não-linearidade! Precisamos de algumas linhas não lineares. Você pode ficar confuso agora, se está pensando que não viu esse tipo de função antes, você está errado, porque viu. Vamos vê-los visualmente. A visualização sempre funciona melhor!

Existem algumas funções de ativação em Rede Neural que podemos usar, como ReLu, Sigmóide. Vamos criar um pouco tensor de brinquedo e verifique essas funções nele.

Funções de ativação para redes neurais

A = tf.cast(tf.range(-12,12), tf.float32) print(A) >> tf.Tensor( [-12. -11. -10. -9. -8. -7. - 6. -5. -4. -3. -2. -1. 0. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11.], forma=(24,), dtype=float32)

Vamos ver como fica o nosso tensor de brinquedo?

plt.plot(A)

Parece assim, uma linha reta! 

Agora vamos recriar funções de ativação para ver o que elas fazem com nosso tensor.

Sigmóide:

def sigmóide(x): retornar 1 / (1 + tf.exp(-x)) sigmóide(A) plt.plot(sigmóide(A))

Uma linha não reta!

ReLu:

def relu(x): return tf.maximum(0,x) plt.plot(relu(A))

Outra linha não reta!

Agora que você viu funções de ativação não lineares, e é isso que funcionará para nós, o modelo não pode aprender nada em um conjunto de dados não linear com funções de ativação linear! Se aprendemos isso, é hora de dividir nossos dados em conjuntos de treinamento e teste e construir modelos fortes.

X_train, y_train = X[:800], y[:800] X_test, y_test = X[800:], y[800:] X_train.shape, X_test.shape >>((800, 2), (200, 2 ))

tf.random.set_seed(42)

model_4 = tf.keras.Sequential([tf.keras.layers.Dense(4, activate = 'relu'), #podemos corrigir "tf.keras.activations.relu" também tf.keras.layers.Dense(4 , ativação = 'relu'), tf.keras.layers.Dense(1, ativação = 'sigmoid') ]) model_4.compile( loss= tf.keras.losses.binary_crossentropy, otimizador = tf.keras.optimizers.Adam( lr = 0.01), métricas = ['precisão']) model_4.fit(X_train, y_train, épocas = 25, detalhado = 0)

Avalie o modelo

perda, precisão = model_4.evaluate(X_test, y_test) print(f' Perda do modelo no conjunto de teste: {perda}') print(f' Precisão do modelo no conjunto de teste: {100*accuracy}')

>> 7/7 [==============================] - 0s 2ms/passo - perda: 0.1247 - precisão: 1.0000 Perda de modelo no conjunto de teste: 0.1246885135769844 Precisão do modelo no conjunto de teste: 100.0

plt.figure(figsize=(12, 6)) plt.subplot(1, 2, 1) plt.title("Trein") plot_decision_boundary(model_4, X=X_train, y=y_train) plt.subplot(1, 2, 2) plt.title("Teste") plot_decision_boundary(model_4, X=X_test, y=y_test) plt.show()

Vamos dar uma breve olhada no que estamos falando neste artigo. Juntos, vimos como abordar uma tarefa de classificação na rede neural com o TensorFlow. Criamos 3 modelos da primeira forma que nos veio à cabeça, e com a ajuda da visualização percebemos onde erramos, exploramos a linearidade, a não linearidade e por fim, conseguimos construir um modelo generalizado. O que eu estava tentando mostrar com todos esses códigos e os passos que segui era que nada é 100% preciso ou fixo, tudo continua mudando a cada dia. Para adivinhar qual problema você provavelmente enfrentará em que tipo de dados e ver quais combinações levam a um melhor resultado, tudo que você precisa é escrever muito mais código e ganhar experiência.

Espero que o artigo tenha sido um pouco útil para você e tenha feito algumas contribuições.

A mídia mostrada neste artigo não é propriedade da Analytics Vidhya e é usada a critério do autor

Relacionado

Fonte: https://www.analyticsvidhya.com/blog/2021/11/neural-network-for-classification-with-tensorflow/