Redes de convolucion
Las redes de convolucion o redes neuronales convolucionales (CNN) son un tipo de arquitectura de aprendizaje profundo especialmente diseñada para procesar datos con estructura espacial o temporal, como imágenes, señales de audio y series temporales.
Estas redes están formadas por capas de convolución, que extraen características locales del dato, y capas de agrupación o pooling, que reducen la dimensionalidad y mejoran la eficiencia del modelo. Finalmente, las CNN incluyen capas densas o totalmente conectadas, encargadas de realizar la clasificación o regresión final, según el objetivo del modelo.
Diferencias entre redes de capas densas y de convolucion
Si las redes neuronales de capas densas están compuestas por capas completamente conectadas, donde cada neurona de una capa está conectada a todas las neuronas de la capa siguiente en las redes de convolucion las neuronas están conectadas localmente a regiones específicas de la entrada mediante filtros de convolución.
La capas densas aprenden patrones globales mientras que en las redes de convolucion aprenden patrones locales dentro de la imagen en pequeñas ventanas de 2 dimensiones.
En las redes de convolución una vez que aprenden una característica en un punto concreto de la imagen, esta puede ser reconocida en cualquier otra parte, en cambio en las redes densamente conectadas tienen que volver a aprender nuevamente la característica si este aparece en otro sitio de la imagen.
Como funcionan las redes de convolucion
Las redes neuronales convolucionales (o redes de convolución) funcionan aplicando filtros de convolución a lo largo de sus capas para extraer características importantes de los datos, especialmente en imágenes. Estas redes están compuestas por varias capas especializadas que procesan la información paso a paso:
Capas de convolución
Las capas convolucionales extraen características locales relevantes mediante filtros o kernels, que son matrices de pesos. Estos filtros se deslizan sobre la imagen (de izquierda a derecha y de arriba hacia abajo), detectando bordes, formas y texturas, y generando mapas de características que representan la información aprendida.
Función de activación
Después de cada operación de convolución, se aplica una función de activación no lineal como ReLU (Rectified Linear Unit). Esta función introduce no linealidades al modelo, devolviendo el valor si es positivo y cero si es negativo, permitiendo que la red aprenda patrones complejos.
Capas de agrupación (pooling)
Las capas de agrupación, como el max pooling o el average pooling, reducen la dimensionalidad de los mapas de características. Esto mejora la eficiencia del modelo y ayuda a evitar el sobreajuste al conservar solo la información más relevante.
Capa densa o completamente conectada
Tras las capas convolucionales y de agrupación, los mapas de características se aplanan y se envían a una capa densa (fully connected) que realiza la clasificación final. Esta etapa integra la información extraída y predice la clase correspondiente según la tarea del modelo.
Para que sirven las redes de convolucion
- Para clasificar de imágenes
- Detectar objetos
- Segmentar imágenes
- Reconocimiento facial
- Clasificación de texto en imágenes
Codigo de ejemplo
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D,Dense,Flatten
import keras.datasets.mnist as mnist
import numpy as np
from sklearn.metrics import confusion_matrix
from keras.utils import to_categorical
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,x_test):
x_train = x_train.reshape((60000,28,28,1))
x_train = x_train.astype('float32') /255
x_test = x_test.reshape((10000,28,28,1))
x_test = x_test.astype('float32') /255
return x_train,x_test
def codificacionEtiquetas(y_train,y_test):
#Codificamos las salidas en formato en codificacion one-hot
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
return y_train,y_test
def getModelo():
# Definimos el modelo
modelo = Sequential()
# Primera capa de convolución
modelo.add(Conv2D(32, (5, 5), activation='relu', input_shape=(28, 28, 1)))
modelo.add(MaxPooling2D((2,2)))
# Segunda capa de convolución
modelo.add(Conv2D(64, (5, 5), activation='relu'))
modelo.add(MaxPooling2D((2,2)))
modelo.add(Flatten())
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):
modelo.fit(x_train, y_train,batch_size=100,epochs=5,verbose=1)
return modelo
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,x_test, = normalizar(x_train,x_test)
y_train,y_test=codificacionEtiquetas(y_train,y_test)
modelo = getModelo()
modelo = compilarModelo(modelo)
modelo = fit(modelo,x_train, y_train)
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))
