Criação de modelos de redes neurais (NN) em R

Introdução às redes neurais

As redes neurais ou redes neurais simuladas são um subconjunto do aprendizado de máquina inspirado no cérebro humano. Eles imitam a forma como os neurônios biológicos se comunicam entre si para chegar a uma decisão. 

Uma rede neural consiste em uma camada de entrada, uma camada oculta e uma camada de saída. A primeira camada recebe a entrada bruta, que é processada por várias camadas ocultas, e a última camada produz o resultado. 

No exemplo abaixo, simulamos o processo de treinamento de redes neurais para classificar dados tabulares. Temos os parâmetros X1 e X2 que passam por 2 camadas ocultas de 4 e 2 neurônios para produzir a saída. Com várias iterações, o modelo está melhorando na classificação dos alvos. 

Imagem criada com o TF Playground

Os algoritmos de aprendizagem profunda ou redes neurais profundas consistem em várias camadas e nós ocultos. O termo "deep" significa a profundidade das redes neurais. Em geral, eles são usados para resolver problemas complexos, como classificação de imagens, reconhecimento de fala e geração de texto.

Saiba mais sobre redes neurais lendo nosso Tutorial de aprendizagem profunda. Você aprenderá como a função de ativação, a função de perda e a retropropagação funcionam para produzir resultados precisos. 

Tipos de redes neurais

Vários tipos de redes neurais são usados para aplicações avançadas de aprendizado de máquina. Não temos um modelo de arquitetura que funcione para todos. O tipo mais antigo de rede neural é conhecido como Perceptron, criado por Frank Rosenblatt em 1958. 

Nesta seção, abordaremos os 5 tipos mais populares de redes neurais usados no setor de tecnologia. 

Redes neurais feedforward

As redes neurais feedforward consistem em uma camada de entrada, camadas ocultas e uma camada de saída. Ele é chamado de feedforward porque os dados fluem na direção direta, e não há retropropagação. Ele é usado principalmente em classificação, reconhecimento de fala, reconhecimento facial e reconhecimento de padrões.

Perceptron de múltiplas camadas

Os Perceptrons de Múltiplas Camadas (MLPs) solucionam as deficiências da rede neural feedforward, que não é capaz de aprender por meio da retropropagação. Ele é bidirecional e consiste em várias camadas ocultas e funções de ativação. Os MLPs usam a propagação direta para entradas e a retropropagação para atualizar os pesos. Elas são redes neurais básicas que estabeleceram a base para a visão computacional, a tecnologia de linguagem e outras redes neurais. 

Observação: As MLPs consistem em neurônios sigmoides, não em perceptrons, porque os problemas do mundo real não são lineares.

Redes neurais convolucionais (CNNs)

As redes neurais de convolução (CNN) são geralmente usadas em visão computacional, reconhecimento de imagens e reconhecimento de padrões. Ele é usado para extrair recursos importantes da imagem usando várias camadas convolucionais. A camada convolucional da CNN usa uma matriz personalizada (filtro) para fazer a convolução das imagens e criar um mapa. 

Em geral, as redes neurais de convolução consistem na camada de entrada, na camada de convolução, na camada de pooling, na camada totalmente conectada e na camada de saída. Leia nosso tutorial sobre Redes Neurais Convolucionais (CNN) Python com TensorFlow para saber mais sobre como a CNN funciona. 

Redes neurais recorrentes (RNNs)

As Redes Neurais Recorrentes (RNNs) são comumente usadas para dados sequenciais, como textos, sequências de imagens e séries temporais. Elas são semelhantes às redes feed-forward, exceto pelo fato de obterem entradas de sequências anteriores usando um loop de feedback. Os RNNs são usados em PNL, previsões de vendas e previsão do tempo. 

As RNNs apresentam problemas de gradiente decrescente, que são resolvidos por versões avançadas de RNNs chamadas de Redes de Memória de Curto Prazo (LSTMs) e Redes de Unidades Recorrentes Controladas (GRUs). Leia o Tutorial de Rede Neural Recorrente (RNN) para saber mais sobre LSTMs e GRUs. 

Implementação de redes neurais em R

Aprenderemos a criar redes neurais com os populares pacotes R neuralnet e Keras. 

No primeiro exemplo, criaremos uma rede neural simples com o mínimo de esforço e, no segundo exemplo, abordaremos um problema mais avançado usando o pacote Keras. 

Vamos configurar o ambiente do R baixando as bibliotecas e dependências essenciais. 

install.packages(c('neuralnet','keras','tensorflow'),dependencies = T)

Implementação de rede neural simples em R

Neste primeiro exemplo, usaremos a íris de dados integrada do R e resolveremos problemas de multiclassificação com uma rede neural simples. 

Começaremos importando pacotes R essenciais para manipulação de dados e treinamento de modelos. 

library(tidyverse)
library(neuralnet)

Data Analysis

Você pode acessar os dados digitando `iris` e executando-o no console do R. Antes de treinar os dados, precisamos converter os tipos de colunas de caracteres em fatores.

Observação: estamos usando o espaço de trabalho do DataCamp R para executar os exemplos. 

iris <- iris %>% mutate_if(is.character, as.factor)

A função `summary` é usada para análise estatística e distribuição de dados. 

summary(iris)

Como podemos ver, temos dados equilibrados. Todas as três classes-alvo têm 50 amostras. 

Sepal.Length    Sepal.Width     Petal.Length    Petal.Width  
Min.   :4.300   Min.   :2.000   Min.   :1.000   Min.   :0.100 
1st Qu.:5.100   1st Qu.:2.800   1st Qu.:1.600   1st Qu.:0.300 
Median :5.800   Median :3.000   Median :4.350   Median :1.300 
Mean   :5.843   Mean   :3.057   Mean   :3.758   Mean   :1.199 
3rd Qu.:6.400   3rd Qu.:3.300   3rd Qu.:5.100   3rd Qu.:1.800 
Max.   :7.900   Max.   :4.400   Max.   :6.900   Max.   :2.500 
      Species 
setosa    :50 
versicolor:50 
virginica :50 

Treinamento e teste de divisão

Definiremos a semente para reprodutibilidade e dividiremos os dados em conjuntos de dados de treinamento e teste para treinamento e avaliação do modelo. Nós o dividiremos em 80:20. 

set.seed(245)
data_rows <- floor(0.80 * nrow(iris))
train_indices <- sample(c(1:nrow(iris)), data_rows)
train_data <- iris[train_indices,]
test_data <- iris[-train_indices,]

Treinamento da rede neural

O pacote neuralnet está desatualizado, mas ainda é popular entre a comunidade R. 

A função `neuralnet` é simples. Ele não nos dá a liberdade de criar uma arquitetura de modelo totalmente personalizável. 

Em nosso caso, estamos fornecendo a ele uma fórmula e dados de aprendizado de máquina, assim como o GLM. A fórmula consiste em variáveis e recursos de destino. 

Depois disso, criamos duas camadas ocultas, a primeira camada com quatro neurônios e a segunda com dois neurônios. 

model = neuralnet(
    Species~Sepal.Length+Sepal.Width+Petal.Length+Petal.Width,
data=train_data,
hidden=c(4,2),
linear.output = FALSE
)

Para visualizar a arquitetura do nosso modelo, usaremos a função `plot`. Requer um objeto de modelo e um argumento `rep`. 

plot(model,rep = "best")

Avaliação do modelo

Para a matriz de confusão:

1. Faremos a previsão de categorias usando um conjunto de dados de teste. 
2. Crie uma lista de nomes de categorias.
3. Crie um dataframe de previsão e substitua as saídas numéricas por rótulos. 
4. Use tabelas para exibir valores "reais" e "praticados" lado a lado. 

pred <- predict(model, test_data)
labels <- c("setosa", "versicolor", "virginca")
prediction_label <- data.frame(max.col(pred)) %>%     
mutate(pred=labels[max.col.pred.]) %>%
select(2) %>%
unlist()

table(test_data$Species, prediction_label)

Obtivemos resultados quase perfeitos. Parece que nosso modelo previu erroneamente três amostras. Podemos melhorar o resultado adicionando mais neurônios em cada camada. 

           prediction_label
            setosa versicolor virginica
  setosa          8          0        0
  versicolor      0         13        0
  virginica       0          3        6 

Para verificar a precisão, primeiro temos de converter os valores categóricos reais em valores numéricos e compará-los com os valores previstos. Como resultado, receberemos uma lista de valores booleanos. 

Podemos usar a função `sum` para encontrar o número de valores `TRUE` e dividi-lo pelo número total de amostras para obter a precisão. 

check = as.numeric(test_data$Species) == max.col(pred)
accuracy = (sum(check)/nrow(test_data))*100
print(accuracy)

O modelo previu valores com 90% de precisão. 

90

Observação: o código-fonte desse exemplo está disponível no espaço de trabalho do R: Criação de modelos de redes neurais (NN) em R.

Rede neural convolucional em R com Keras

Neste exemplo, usaremos o Keras e o TensorFlow para criar e treinar um modelo de rede neural convolucional para a tarefa de classificação de imagens. Para isso, usaremos o conjunto de dados de imagens cifar10, que consiste em 60.000 imagens coloridas 32x32 rotuladas em dez categorias.

Imagem do CIFAR-10

Importar pacotes essenciais do R. 

library(keras)
library(tensorflow)

Preparando os dados

Importaremos o conjunto de dados incorporado do Keras e o dividiremos em conjuntos de treinamento e teste. 

c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_cifar10()

Divida os recursos de treinamento e teste por 255 para normalizar os dados. 

x_train <- x_train / 255
x_test <-  x_test / 255

Criação do modelo

A API do Keras nos oferece a flexibilidade de criar uma arquitetura de rede neural complexa totalmente personalizável. 

Em nosso caso, criaremos várias camadas de convolução, seguidas pela camada de pooling máximo, camada de dropout, camada densa e camada de saída. 

Estamos usando "Leaky ReLU" como função de ativação para todas as camadas, exceto a camada de saída. Para isso, estamos usando o "softmax". 

Precisamos definir a forma de entrada da primeira camada convolucional 2D com a forma da imagem (32,32,3) do conjunto de dados de treinamento. 

model <- keras_model_sequential()%>%
  # Start with a hidden 2D convolutional layer
  layer_conv_2d(
    filter = 16, kernel_size = c(3,3), padding = "same",
    input_shape = c(32, 32, 3), activation = 'leaky_relu'
  ) %>%

  # 2nd hidden layer
  layer_conv_2d(filter = 32, kernel_size = c(3,3), activation = 'leaky_relu') %>%
 

  # Use max pooling
  layer_max_pooling_2d(pool_size = c(2,2)) %>%
  layer_dropout(0.25) %>%

  # 3rd and 4th hidden 2D convolutional layers
  layer_conv_2d(filter = 32, kernel_size = c(3,3), padding = "same", activation = 'leaky_relu') %>%

  layer_conv_2d(filter = 64, kernel_size = c(3,3), activation = 'leaky_relu') %>%

  # Use max pooling
  layer_max_pooling_2d(pool_size = c(2,2)) %>%
  layer_dropout(0.25) %>%
 
  # Flatten max filtered output into feature vector
  # and feed into dense layer
  layer_flatten() %>%
  layer_dense(256, activation = 'leaky_relu') %>%
  layer_dropout(0.5) %>%

  # Outputs from dense layer
  layer_dense(10, activation = 'softmax')

Para visualizar a arquitetura do modelo, usaremos a função `summary`. 

summary(model)

Temos duas camadas convolucionais seguidas por uma camada de pooling máximo, mais duas camadas convolucionais, uma camada de pooling máximo, uma camada achatada para maximizar a saída filtrada em vetores e, em seguida, duas camadas densas. 

Model: "sequential"
________________________________________________________________________________
Layer (type)                        Output Shape                    Param #    
================================================================================
conv2d_3 (Conv2D)                   (None, 32, 32, 16)              448        
________________________________________________________________________________
conv2d_2 (Conv2D)                   (None, 30, 30, 32)              4640       
________________________________________________________________________________
max_pooling2d_1 (MaxPooling2D)      (None, 15, 15, 32)              0          
________________________________________________________________________________
dropout_2 (Dropout)                 (None, 15, 15, 32)              0          
________________________________________________________________________________
conv2d_1 (Conv2D)                   (None, 15, 15, 32)              9248       
________________________________________________________________________________
conv2d (Conv2D)                     (None, 13, 13, 64)              18496      
________________________________________________________________________________
max_pooling2d (MaxPooling2D)        (None, 6, 6, 64)                0          
________________________________________________________________________________
dropout_1 (Dropout)                 (None, 6, 6, 64)                0          
________________________________________________________________________________
flatten (Flatten)                   (None, 2304)                    0          
________________________________________________________________________________
dense_1 (Dense)                     (None, 256)                     590080     
________________________________________________________________________________
dropout (Dropout)                   (None, 256)                     0          
________________________________________________________________________________
dense (Dense)                       (None, 10)                      2570       
================================================================================
Total params: 625,482
Trainable params: 625,482
Non-trainable params: 0
________________________________________________________________________________

Compilação do modelo

1. Definiremos a taxa de aprendizado usando a função de decaimento exponencial do cronograma. Ele reduz a taxa de aprendizado após 1500 etapas em 0,98.
2. Alimente o objeto de taxa de aprendizado no otimizador Adamax.
3. Nossa função de perda será a entropia cruzada categórica esparsa.
4. Compile o modelo usando a função de perda e otimizador e a métrica de desempenho.

learning_rate <- learning_rate_schedule_exponential_decay(
  initial_learning_rate = 5e-3,
  decay_rate = 0.96,
  decay_steps = 1500,
  staircase = TRUE
)
opt <- optimizer_adamax(learning_rate = learning_rate)

loss <- loss_sparse_categorical_crossentropy(from_logits = TRUE)


model %>% compile(
  loss = loss,
  optimizer = opt,
  metrics = "accuracy"
)

Treinamento do modelo

Ajustaremos nosso modelo e armazenaremos a métrica de avaliação em `history`. 

• Vamos treinar um modelo para 10 épocas e definir o tamanho do lote como 32. 
• Adição de conjunto de dados de teste para validação.
• O argumento `shuffle` embaralhará os dados de treinamento no início de cada época. 

history <- model %>% fit(
  x_train, y_train,
  batch_size = 32,
  epochs = 10,
  validation_data = list(x_test, y_test),
  shuffle = TRUE
)

Avaliação do modelo

Você pode avaliar o modelo em um conjunto de dados de teste usando a função `evaluate`, que retornará a perda final e a precisão. 

model %>% evaluate(x_test, y_test)

O retreinamento do modelo em 50 épocas aumentará a precisão do modelo. 

Loss 0.648191571235657 Accuracy 0.776799976825714

Para traçar gráficos de linha de perda e precisão para cada época, usaremos a função `plot`. 

plot(history)

Observando o gráfico, podemos notar que a linha ainda não se achatou. Isso significa que, com épocas maiores, podemos melhorar as métricas do modelo. 

Se você estiver interessado em saber mais sobre a API do Keras e como usá-la para criar redes neurais profundas, consulte keras: Aprendizagem profunda em R tutorial. 

Aplicações de redes neurais

Podemos encontrar exemplos reais de redes neurais em todos os lugares, desde aplicativos móveis até engenharia. Devido ao recente boom da linguagem e dos grandes modelos visuais, mais empresas estão se interessando em implementar redes neurais profundas para aumentar os lucros e a satisfação do cliente. 

Nesta seção, conheceremos as 10 principais aplicações das redes neurais que estão moldando o mundo moderno. 

1. Previsão tabular

As redes neurais simples são bastante eficazes em dados tabulares grandes. Podemos usá-los para problemas de classificação, agrupamento e regressão. 

2. Previsão de preços de ações

Muitas empresas estão usando LSTM, GRU e RNN para previsões financeiras. Isso permite que eles tomem decisões melhores. 

3. Imagens médicas

A detecção de câncer de mama, a detecção de anomalias e a segmentação de imagens são algumas das aplicações das redes neurais convolucionais. Graças aos transformadores pré-treinados, temos visto pesquisas avançadas na prevenção de doenças e na detecção precoce de doenças fatais.  

4. Comércio eletrônico

Recomendações de produtos, experiências personalizadas e chatbots são algumas das aplicações das redes neurais usadas no comércio eletrônico. Esses modelos são usados principalmente para agrupamento, processamento de linguagem natural e visão computacional para melhorar a experiência dos clientes na plataforma. 

5. Imagem geradora

Devido à popularidade de DALL-E 2 e à difusão estável, esse espaço se tornou popular. Empresas como Canva e Adobe já implementaram o recurso de imagem generativa para aumentar o número de usuários. Além do hype mainstream, as imagens generativas são usadas em todos os setores para criar dados sintéticos para melhorar o desempenho, a estabilidade e as tendências do modelo. 

6. Texto generativo

ChatGPT, GPT-3 e GPT-NEO são os modelos de rede neural profunda que dominam o espaço. Esses modelos são usados para assistência de programação, chatbots, tradução, perguntas/respostas e muito mais. Ele está em toda parte, e as empresas estão achando fácil integrá-lo aos seus sistemas atuais.

7. Bot de bate-papo de atendimento ao cliente

DailoGPT e Blenderbot são modelos de conversação populares que aprimoram sua experiência com o chatbot. Eles são adaptáveis e podem ser ajustados para uma finalidade específica. No futuro, não veremos longos tempos de espera; esses chatbots serão capazes de entender seus problemas e fornecer soluções em tempo real. 

8. Robótica

O aprendizado por reforço e os modelos de rede neural de visão computacional estão desempenhando um papel importante nos setores de transferência. Por exemplo, gerenciamento de armazém, fábricas e experiência de compra totalmente automatizados. 

9. Reconhecimento de fala

Os modelos de rede neural de reconhecimento de fala, conversão de texto em fala e detecção de atividade de áudio são usados para assistência à fala, transcrição automática e aplicativos de comunicação aprimorados. 

10. Multimodal

Texto para imagem (DALLE-2), texto para imagem, resposta a perguntas visuais e extração de recursos são alguns dos aplicativos usados em redes neurais multimodais. No futuro, você verá texto para vídeo com áudio. Você poderá criar um filme completo fornecendo o roteiro.

Conclusão

Os pacotes R Keras e TensorFlow nos oferecem uma gama completa de ferramentas para criar arquiteturas de modelos complexos para tarefas específicas. Você pode carregar o conjunto de dados, realizar o pré-processamento, criar e otimizar o modelo e avaliar o modelo usando algumas linhas de código. Além disso, com o Tensorflow, você pode monitorar seus experimentos, configurar GPUs e implantar o modelo na produção. 

Neste tutorial, aprendemos os conceitos básicos das redes neurais, o tipo de arquitetura do modelo e a aplicação. Além disso, aprendemos a treinar uma rede neural simples usando o `neuralnet` e uma rede neural convolucional usando o `keras`. O tutorial abrange a criação, a compilação, o treinamento e a avaliação do modelo. 

Saiba mais sobre a API do Tensorflow e do Keras fazendo o curso Introduction to TensorFlow in R. Você aprenderá sobre o tensorboard e outras APIs do TensorFlow, criará redes neurais profundas e aprimorará o desempenho do modelo usando regularização, eliminação e otimização de hiperparâmetros.