curso
Creación de modelos de redes neuronales (NN) en R
Introducción a las redes neuronales
Las redes neuronales o redes neuronales simuladas son un subconjunto del aprendizaje automático que se inspira en el cerebro humano. Imitan cómo las neuronas biológicas se comunican entre sí para tomar una decisión.
Una red neuronal consta de una capa de entrada, una capa oculta y una capa de salida. La primera capa recibe la entrada bruta, la procesan varias capas ocultas y la última produce el resultado.
En el ejemplo siguiente, hemos simulado el proceso de entrenamiento de redes neuronales para clasificar datos tabulares. Tenemos parámetros X1 y X2 que pasan a través de 2 capas ocultas de 4 y 2 neuronas para producir la salida. Con múltiples iteraciones, el modelo mejora en la clasificación de los objetivos.
Imagen creada con TF Playground
Los algoritmos de aprendizaje profundo o redes neuronales profundas constan de múltiples capas y nodos ocultos. Por "profunda" se entiende la profundidad de las redes neuronales. Generalmente se utilizan para resolver problemas complejos como la clasificación de imágenes, el reconocimiento de voz y la generación de textos.
Aprende más sobre redes neuronales leyendo nuestro tutorial de aprendizaje profundo. Aprenderá cómo funcionan la función de activación, la función de pérdida y la retropropagación para producir resultados precisos.
Tipos de redes neuronales
En las aplicaciones avanzadas de aprendizaje automático se utilizan múltiples tipos de redes neuronales. No tenemos un modelo de arquitectura que sirva para todos. El tipo más antiguo de red neuronal es el denominado perceptrón, creado por Frank Rosenblatt en 1958.
En esta sección trataremos los 5 tipos de redes neuronales más utilizados en la industria tecnológica.
Redes neuronales
Las redes neuronales feedforward constan de una capa de entrada, capas ocultas y una capa de salida. Se llama feedforward porque los datos fluyen en la dirección hacia adelante, y no hay retropropagación. Se utiliza sobre todo en clasificación, reconocimiento de voz, reconocimiento facial y reconocimiento de patrones.
Perceptrón multicapa
Los perceptrones multicapa (MLP) resuelven las deficiencias de las redes neuronales feedforward al no poder aprender mediante retropropagación. Es bidireccional y consta de múltiples capas ocultas y funciones de activación. Los MLP utilizan la propagación hacia delante para las entradas y la retropropagación para actualizar los pesos. Son redes neuronales básicas que han sentado las bases de la visión por ordenador, la tecnología del lenguaje y otras redes neuronales.
Nota: Los MLP están formados por neuronas sigmoidales, no por perceptrones, porque los problemas del mundo real no son lineales.
Redes neuronales convolucionales (CNN)
Las redes neuronales de convolución (CNN) se utilizan generalmente en visión por ordenador, reconocimiento de imágenes y reconocimiento de patrones. Se utiliza para extraer características importantes de la imagen mediante múltiples capas convolucionales. La capa convolucional de la CNN utiliza una matriz (filtro) personalizada para convolucionar sobre las imágenes y crear un mapa.
En general, las redes neuronales de convolución constan de una capa de entrada, una capa de convolución, una capa de agrupación, una capa totalmente conectada y una capa de salida. Lee nuestro tutorial sobre Redes Neuronales Convolucionales (CNN) en Python con TensorFlow para aprender más sobre cómo funcionan las CNN.
Redes neuronales recurrentes (RNN)
Las redes neuronales recurrentes (RNN) se utilizan habitualmente para datos secuenciales como textos, secuencias de imágenes y series temporales. Son similares a las redes feed-forward, salvo que obtienen las entradas de secuencias anteriores mediante un bucle de realimentación. Las RNN se utilizan en PNL, predicciones de ventas y previsiones meteorológicas.
Las RNN presentan problemas de gradiente evanescente, que se resuelven mediante versiones avanzadas de las RNN denominadas redes de memoria a corto plazo (LSTM) y redes de unidades recurrentes controladas (GRU). Lea el tutorial sobre redes neuronales recurrentes (RNN ) para obtener más información sobre las LSTM y las GRU.
Implementación de redes neuronales en R
Aprenderemos a crear redes neuronales con los populares paquetes de R neuralnet y Keras.
En el primer ejemplo, crearemos una red neuronal sencilla con el mínimo esfuerzo, y en el segundo, abordaremos un problema más avanzado utilizando el paquete Keras.
Vamos a configurar el entorno R descargando las bibliotecas y dependencias esenciales.
install.packages(c('neuralnet','keras','tensorflow'),dependencies = T)
Implementación sencilla de una red neuronal en R
En este primer ejemplo, utilizaremos los datos incorporados en R iris y resolveremos problemas de clasificación múltiple con una red neuronal sencilla.
Empezaremos importando paquetes R esenciales para la manipulación de datos y la formación de modelos.
library(tidyverse)
library(neuralnet)
Análisis de datos
Puede acceder a los datos escribiendo `iris` y ejecutándolo en la consola de R. Antes de entrenar los datos, tenemos que convertir los tipos de columnas de caracteres en factores.
Nota: estamos utilizando el espacio de trabajo DataCamp R para ejecutar los ejemplos.
iris <- iris %>% mutate_if(is.character, as.factor)
La función `summary` se utiliza para el análisis estadístico y la distribución de datos.
summary(iris)
Como vemos, tenemos datos equilibrados. Las tres clases objetivo tienen 50 muestras.
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
Formar y probar la división
Estableceremos semillas para la reproducibilidad y dividiremos los datos en conjuntos de datos de entrenamiento y de prueba para el entrenamiento y la evaluación del modelo. Lo dividiremos en 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,]
Entrenamiento de la red neuronal
El paquete neuralnet está anticuado, pero sigue siendo popular entre la comunidad R.
La función `neuralnet` es sencilla. No nos ofrece la libertad de crear una arquitectura de modelos totalmente personalizable.
En nuestro caso, le proporcionamos una fórmula de aprendizaje automático y datos, al igual que GLM. La fórmula consta de variables objetivo y características.
Después, creamos dos capas ocultas, la primera capa con cuatro neuronas y la segunda con dos neuronas.
model = neuralnet(
Species~Sepal.Length+Sepal.Width+Petal.Length+Petal.Width,
data=train_data,
hidden=c(4,2),
linear.output = FALSE
)
Para visualizar la arquitectura de nuestro modelo, utilizaremos la función `plot`. Requiere un objeto modelo y el argumento `rep`.
plot(model,rep = "best")
Evaluación de modelos
Para la matriz de confusión:
- Predeciremos las categorías utilizando un conjunto de datos de prueba.
- Crear una lista de nombres de categorías.
- Cree un marco de datos de predicción y sustituya las salidas numéricas por etiquetas.
- Utiliza tablas para mostrar los valores "reales" y "previstos" uno al lado del otro.
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)
Obtuvimos resultados casi perfectos. Parece que nuestro modelo ha predicho erróneamente tres muestras. Podemos mejorar el resultado añadiendo más neuronas en cada capa.
prediction_label
setosa versicolor virginica
setosa 8 0 0
versicolor 0 13 0
virginica 0 3 6
Para comprobar la precisión, primero tenemos que convertir los valores categóricos reales en numéricos y compararlos con los valores predichos. Como resultado, recibiremos una lista de valores booleanos.
Podemos utilizar la función `sum` para hallar el número de valores `TRUE` y dividirlo por el número total de muestras para obtener la precisión.
check = as.numeric(test_data$Species) == max.col(pred)
accuracy = (sum(check)/nrow(test_data))*100
print(accuracy)
El modelo ha predicho valores con una precisión del 90%.
90
Nota: el código fuente de este ejemplo está disponible en el espacio de trabajo de R: Creación de modelos de redes neuronales (NN) en R.
Red neuronal convolucional en R con Keras
En este ejemplo, utilizaremos Keras y TensorFlow para construir y entrenar un modelo de Red Neuronal Convolucional para la tarea de clasificación de imágenes. Para ello, utilizaremos el conjunto de datos de imágenes cifar10, compuesto por 60.000 imágenes en color de 32x32 etiquetadas en diez categorías.
Imagen de CIFAR-10
Importar paquetes esenciales de R.
library(keras)
library(tensorflow)
Preparación de los datos
Importaremos el conjunto de datos incorporado en Keras y lo dividiremos en conjuntos de entrenamiento y de prueba.
c(c(x_train, y_train), c(x_test, y_test)) %<-% dataset_cifar10()
Divida las características de entrenamiento y prueba por 255 para normalizar los datos.
x_train <- x_train / 255
x_test <- x_test / 255
Construir el modelo
La API de Keras nos proporciona la flexibilidad necesaria para construir arquitecturas de redes neuronales complejas totalmente personalizables.
En nuestro caso, crearemos varias capas de convolución, seguidas de la capa de agrupación máxima, la capa de abandono, la capa densa y la capa de salida.
Estamos utilizando 'Leaky ReLU' como función de activación para todas las capas excepto la capa de salida. Para ello, utilizamos "softmax".
Debemos ajustar la forma de entrada de la primera capa convolucional 2D a la forma de la imagen (32,32,3) del conjunto de datos de entrenamiento.
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 ver la arquitectura del modelo, utilizaremos la función `summary`.
summary(model)
Tenemos dos capas convolucionales seguidas de una capa de agrupamiento máximo, dos capas convolucionales más, una capa de agrupamiento máximo, una capa aplanada para filtrar al máximo la salida en vectores y, a continuación, dos capas 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
________________________________________________________________________________
Compilación del modelo
- Estableceremos la tasa de aprendizaje utilizando la función de decaimiento exponencial programada. Reduce la tasa de aprendizaje después de 1500 pasos en 0,98.
- Introduzca el objeto de tasa de aprendizaje en el optimizador Adamax.
- Nuestra función de pérdida será la entropía cruzada categórica dispersa.
- Compilar el modelo utilizando la función de pérdida y optimizador, y la métrica de rendimiento.
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"
)
Entrenamiento del modelo
Ajustaremos nuestro modelo y almacenaremos la métrica de evaluación en `history`.
- Vamos a entrenar un modelo para 10 épocas y establecer el tamaño del lote a 32.
- Añadir conjunto de datos de prueba para la validación.
- El argumento `shuffle` barajará los datos de entrenamiento al comienzo de cada época.
history <- model %>% fit(
x_train, y_train,
batch_size = 32,
epochs = 10,
validation_data = list(x_test, y_test),
shuffle = TRUE
)
Evaluación del modelo
Puede evaluar el modelo en un conjunto de datos de prueba mediante la función `evaluate`, que devolverá la pérdida final y la precisión.
model %>% evaluate(x_test, y_test)
El reentrenamiento del modelo en 50 épocas mejorará la precisión del modelo.
Loss 0.648191571235657 Accuracy 0.776799976825714
Para trazar gráficos de líneas de pérdida y precisión para cada época, utilizaremos la función `plot`.
plot(history)
Si miramos el gráfico, podemos observar que la línea aún no se ha aplanado. Esto significa que con épocas más altas, podemos mejorar las métricas del modelo.
Si estás interesado en aprender más sobre la API Keras y cómo puedes utilizarla para construir redes neuronales profundas, consulta keras: Tutorial de aprendizaje profundo en R.
Aplicaciones de las redes neuronales
Podemos encontrar ejemplos reales de redes neuronales en todas partes, desde aplicaciones móviles hasta ingeniería. Debido al reciente auge del lenguaje y los grandes modelos visuales, cada vez más empresas se interesan por implementar redes neuronales profundas para aumentar los beneficios y la satisfacción de los clientes.
En esta sección, conoceremos las 10 principales aplicaciones de las redes neuronales que están dando forma al mundo moderno.
1. Predicción tabular
Las redes neuronales simples son bastante eficaces con datos tabulares de gran tamaño. Podemos utilizarlos para problemas de clasificación, agrupación y regresión.
2. Previsión del precio de las acciones
Muchas empresas utilizan LSTM, GRU y RNN para previsiones financieras. Les permite tomar mejores decisiones.
3. Imagen médica
La detección del cáncer de mama, la detección de anomalías y la segmentación de imágenes son algunas de las aplicaciones de las redes neuronales convolucionales. Gracias a los transformadores preentrenados, hemos asistido a investigaciones avanzadas en materia de prevención de enfermedades y detección precoz de enfermedades mortales.
4. E-commerce
Las recomendaciones de productos, las experiencias personalizadas y los chatbots son algunas de las aplicaciones de las redes neuronales utilizadas en el comercio electrónico. Estos modelos se utilizan principalmente para la agrupación, el procesamiento del lenguaje natural y la visión por ordenador con el fin de mejorar la experiencia de los clientes en la plataforma.
5. Imagen generativa
Gracias a la popularidad de DALL-E 2 y a su difusión estable, este espacio se ha convertido en mainstream. Empresas como Canva y Adobe ya han implementado la capacidad de generar imágenes para aumentar el número de usuarios. Aparte del bombo y platillo, las imágenes generativas se utilizan en todos los sectores para crear datos sintéticos con el fin de mejorar el rendimiento, la estabilidad y los sesgos del modelo.
6. Texto generativo
ChatGPT, GPT-3 y GPT-NEO son los modelos de redes neuronales profundas que dominan el espacio. Estos modelos se utilizan para ayuda a la programación, chatbots, traducción, preguntas/respuestas, etc. Está en todas partes y a las empresas les resulta fácil integrarla en sus sistemas actuales.
7. Bot de chat de atención al cliente
DailoGPT y Blenderbot son modelos conversacionales populares que mejoran tu experiencia de chatbot. Son adaptables y pueden ajustarse para un fin específico. En el futuro, no veremos largos tiempos de espera; estos chatbots serán capaces de entender sus problemas y ofrecer soluciones en tiempo real.
8. Robótica
El aprendizaje por refuerzo y los modelos de redes neuronales de visión por ordenador están desempeñando un papel fundamental en las industrias de transferencia. Por ejemplo, gestión totalmente automatizada de almacenes, fábricas y experiencia de compra.
9. Reconocimiento de voz
Los modelos de redes neuronales de reconocimiento del habla, conversión de texto a voz y detección de actividad de audio se utilizan para aplicaciones de asistencia al habla, transcripción automática y comunicaciones mejoradas.
10. Multimodal
Text to Image (DALLE-2), Image Text, Visual Question Answering y extracciones de características son algunas de las aplicaciones utilizadas en las redes neuronales multimodales. En el futuro, verás texto a vídeo con audio. Podrás crear una película completa proporcionando el guión.
Conclusión
Los paquetes Keras y TensorFlow R nos proporcionan una gama completa de herramientas para crear una arquitectura de modelos compleja para tareas específicas. Puede cargar el conjunto de datos, realizar el preprocesamiento, construir y optimizar el modelo, y evaluar el modelo utilizando unas pocas líneas de código. Además, con Tensorflow, puedes monitorizar tus experimentos, configurar GPUs e implementar el modelo en producción.
En este tutorial, hemos aprendido los fundamentos de las redes neuronales, el tipo de arquitectura del modelo y la aplicación. Además, hemos aprendido a entrenar una red neuronal simple con `neuralnet` y una red neuronal convolucional con `keras`. El tutorial abarca la construcción, compilación, entrenamiento y evaluación del modelo.
Aprende más sobre Tensorflow y Keras API tomando el curso Introducción a TensorFlow en R. Aprenderá sobre tensorboard y otras API de TensorFlow, construirá redes neuronales profundas y mejorará el rendimiento del modelo utilizando regularización, abandono y optimización de hiperparámetros.
Cursos R
curso
Intermediate R
curso
Network Analysis in R
tutorial
Árboles de decisión en aprendizaje automático con R
tutorial
Tutorial de regresión lineal en R
Eladio Montero Porras
15 min
tutorial
Introducción a las redes neuronales profundas
tutorial
Introducción completa a las redes neuronales gráficas (GNN)
tutorial
Tutorial sobre cómo instalar R en Windows, Mac OS X y Ubuntu
tutorial