Red neuronales capas densas: concepto, funcionamiento y ejemplo en TensorFlow
¿Qué es la red neuronal de capas densas?
Las red neuronal de capas densas (tambien conocidas como fully connected) son aquellas en las que cada neurona de una capa está conectada a todas las neuronas de la capa siguiente. Esta estructura permite que la red aprenda patrones complejos, siendo común en tareas de clasificación, reconocimiento de imágenes o procesamiento de datos estructurados.
Una capa densa es, por tanto, una capa de neuronas totalmente conectada. Su función es transformar las entradas mediante una combinación lineal de los pesos y una función de activación.
Ejemplo práctico: clasificación de dígitos con una red neuronal capas de densas
A continuación, presentamos un ejemplo utilizando Python, Keras y TensorFlow para construir una red neuronal densa capaz de clasificar dígitos escritos a mano del dataset MNIST.
from tensorflow import keras
from keras.models import Sequential
from keras.layers import Dense
from sklearn.metrics import confusion_matrix
mnist = keras.datasets.mnist
import numpy as np
def getDatos():
(x_train, y_train) , (x_test, y_test)= mnist.load_data()
return x_train, y_train,x_test, y_test
def normalizar(x_train, y_train,x_test, y_test):
x_train = x_train.astype("float32")
x_test = x_test.astype("float32")
x_train = x_train / 255
x_test = x_test / 255
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
return x_train, y_train, x_test, y_test
def codificacionEtiquetas(y_train,y_test):
y_train = keras.utils.to_categorical(y_train, num_classes=10)
y_test = keras.utils.to_categorical(y_test, num_classes=10)
return y_train,y_test
def getModelo():
modelo = Sequential()
modelo.add(Dense(10, activation='sigmoid', input_shape=(784,)))
modelo.add(Dense(10, activation='softmax'))
modelo.summary()
return modelo
def compilarModelo(modelo):
modelo.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
return modelo
def fit(modelo,x_train, y_train):
batch_size = 50
epochs=10
modelo.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1
)
def evaluarModelo(modelo,x_test, y_test):
test_loss, test_acc = modelo.evaluate(x_test, y_test)
print('Test loss:', test_loss)
print('Test accuracy:', test_acc)
def getPredicciones(modelo,x_test):
prediciones = modelo.predict(x_test)
return prediciones
x_train, y_train,x_test, y_test = getDatos()
x_train, y_train, x_test, y_test = normalizar(x_train, y_train,x_test, y_test)
y_train,y_test=codificacionEtiquetas(y_train,y_test)
#Construimos el modelo
modelo = getModelo()
#Compilamos el modelo
modelo = compilarModelo(modelo)
#Entrenamos el modelo
fit(modelo,x_train, y_train)
#Evaluamos el modelo
evaluarModelo(modelo,x_test, y_test)
prediciones=getPredicciones(modelo,x_test)
y_predic = np.argmax(prediciones, axis=1)
y_test_b = np.argmax(y_test, axis=1)
print(confusion_matrix(y_test_b,y_predic))
Matriz de confusión:
[[ 956 0 2 2 0 3 10 2 5 0] [ 0 1113 2 3 1 2 4 1 9 0] [ 13 19 873 17 21 10 19 22 37 1] [ 2 2 34 886 1 42 3 20 15 5] [ 1 7 5 1 869 0 17 2 4 76] [ 29 10 8 60 6 678 22 9 55 15] [ 19 5 15 1 13 15 881 0 9 0] [ 5 26 23 1 11 0 0 919 4 39] [ 12 19 15 29 15 26 19 14 804 21] [ 14 5 3 18 69 9 4 33 10 844]]
1. ¿Cómo se cargan los datos?
Los datos se cargan directamente desde keras.datasets.mnist, que contiene 60.000 imágenes para entrenamiento y 10.000 para pruebas.
(x_train, y_train), (x_test, y_test) = mnist.load_data()2. ¿Cómo se procesan y normalizan los datos?
- Las imágenes se convierten a
float32y se normalizan dividiendo por 255. - Luego, se “aplanan” de 28×28 a vectores de 784 dimensiones para que puedan entrar en una capa densa.
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)3. ¿Cómo se codifican las etiquetas?
Se transforman en vectores one-hot para poder utilizar categorical_crossentropy como función de pérdida.
y_train = keras.utils.to_categorical(y_train, num_classes=10)
y_test = keras.utils.to_categorical(y_test, num_classes=10)4. ¿Cómo se define la arquitectura de la red neuronal?
La red tiene dos capas densas:
- Una capa con 10 neuronas y activación
sigmoid, que recibe las 784 entradas. - Una capa final con 10 neuronas y activación
softmaxpara clasificación multiclase.
modelo = Sequential()
modelo.add(Dense(10, activation='sigmoid', input_shape=(784,)))
modelo.add(Dense(10, activation='softmax'))5. ¿Cuál es la configuración del proceso de aprendizaje?
Se usa:
- Pérdida:
categorical_crossentropy - Optimizador:
sgd(descenso de gradiente estocástico) - Métrica:
accuracy
modelo.compile(loss='categorical_crossentropy', optimizer='sgd', metrics=['accuracy'])6. ¿Cómo se entrena el modelo?
El entrenamiento se realiza durante 10 épocas con un batch size de 50.
modelo.fit(x_train, y_train, batch_size=50, epochs=10, verbose=1)7. ¿De qué manera se evalúa el modelo?
Se evalúa con el conjunto de test para obtener la pérdida y la precisión:
test_loss, test_acc = modelo.evaluate(x_test, y_test)
print('Test loss:', test_loss)
print('Test accuracy:', test_acc)8. ¿Cuál es la forma de generar predicciones?
El modelo predice las probabilidades por clase, que se convierten a etiquetas con argmax.
predicciones = modelo.predict(x_test)
y_predic = np.argmax(predicciones, axis=1)
y_test_b = np.argmax(y_test, axis=1)Finalmente, se puede usar una matriz de confusión para analizar el rendimiento:
print(confusion_matrix(y_test_b, y_predic))Conclusión
La red neuronal capas densas ofrece una forma poderosa y flexible de resolver tareas de clasificación. Comprender la estructura de las capas densas y cómo configurarlas adecuadamente es esencial para obtener buenos resultados en problemas del mundo real.
Este ejemplo con Keras y MNIST es una excelente base para adentrarse en redes más complejas y problemas más exigentes.
