Crear Modelo red neuronal CNN.
Python
Publicado el 14 de Enero del 2024 por Hilario (144 códigos)
573 visualizaciones desde el 14 de Enero del 2024
Paso 1: Preparar tus datos.
--------------------------
Organizar tus datos:
Divide tus datos en conjuntos de entrenamiento y prueba. El conjunto de entrenamiento se utiliza para entrenar el modelo, mientras que el conjunto de prueba se utiliza para evaluar su rendimiento.
Asegúrate de tener etiquetas asociadas a cada imagen para supervisar el entrenamiento.
Preprocesamiento de imágenes:
----------------------------
Normaliza las imágenes (escala los valores de píxeles entre 0 y 1).
Redimensiona las imágenes según los requisitos de entrada de tu red neuronal.
Paso 2: Crear la arquitectura de la CNN.
---------------------------------------
Importar bibliotecas:
Importa TensorFlow y Keras.
Definir el modelo:
Crea un modelo secuencial (Sequential) o funcional de Keras.
-----------------------------------------------------------
Agrega capas convolucionales, capas de agrupación (pooling), y capas totalmente conectadas según tu arquitectura.
Paso 3: Compilar el modelo.
--------------------------
Compilar el modelo:
Especifica la función de pérdida, el optimizador y las métricas que se utilizarán para evaluar el rendimiento del modelo.
Utiliza el método compile de Keras.
Paso 4: Entrenar el modelo.
--------------------------
Entrenar el modelo:
Utiliza el método fit de Keras.
Proporciona el conjunto de entrenamiento y valida con el conjunto de prueba.
Ajusta el número de épocas y el tamaño del lote según sea necesario.
Paso 5: Evaluar el modelo.
-------------------------
Evaluar el modelo:
Utiliza el conjunto de prueba para evaluar el rendimiento del modelo.
Puedes usar el método evaluate de Keras.
Paso 6: Guardar el modelo entrenado.
----------------------------------
Guardar el modelo:
Utiliza la función save de Keras para guardar el modelo entrenado en un archivo.
PRESENTACION DE LAS IMAGENES DE ENTRENAMIENTO.
********************************************
Básicamente estamos hablando de dos formas:
[indent]CASO_1
*****
Imaginate que tengo estas imagenes:
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg
[/indent]
*************************************************************************************
Sí, en tu caso, no hay clases específicas y solo tienes un conjunto de imágenes numeradas, simplemente colocarlas en orden jerárquico dentro del directorio de entrenamiento (train) es suficiente. La estructura que te proporciono como ejemplo refleja esa simplicidad.
Esta podría ser una ruta normal de archivos, al que llamamos en el directorio principal: ProyectoCNN
[indent]ProyectoCNN/
└── dataset/
└── train/
├── imagen_1.jpg
├── imagen_2.jpg
├── imagen_3.jpg
├── imagen_4.jpg
├── imagen_5.jpg
├── imagen_6.jpg
├── imagen_7.jpg
├── imagen_8.jpg
├── ...
└── imagen_124.jpg
[/indent]
----------------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------------
CASO_2.
*********
En nuestro ejemplo utilizaremos, este formato de almacenamiento (CASO_2.), para entrenar el modelo.
Bien, imaginate ahora que tenemos estos directorios de clase:
(En mi caso, con el fin de coger el concepto de su funcionamiento solo he aportado 3 imagenes para cada tipo. Por lo
que los resultados de la predicción son bastante pobre, para aumentar la eficacia debería hacerse con miles de imagenes. Ten en cuenta que habitualmente para train, los modelos ya entrenados que descargamos pueden rondar las 60.000 imagenes.)
[[indent]b]camiones:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg
turismos:
--------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg
autocares:
----------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg
motocicletas:
------------
imagen_1.jpg
imagen_2.jpg
imagen_3.jpg
imagen_4.jpg
imagen_5.jpg
imagen_6.jpg
imagen_7.jpg
imagen_8.jpg
.....
imagen_121.jpg
imagen_122.jpg
imagen_123.jpg
imagen_124.jpg[/b]
[/indent]
Como organizarias las imagenes para entrenar un modelo CNN.
----------------------------------------------------------
En principio, nosotros las organizariamos como sigue. Sin duda
puede haber más opciones que puedes experimentar,siempre que des la ruta adecuada
de acceso a tu modelo:ProyectoCNN.
└── dataset/
├── train/
│ ├── camiones/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── turismos/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ ├── autocares/
│ │ ├── imagen_1.jpg
│ │ ├── imagen_2.jpg
│ │ ├── ...
│ │ └── imagen_124.jpg
│ └── motocicletas/
│ ├── imagen_1.jpg
│ ├── imagen_2.jpg
│ ├── ...
│ └── imagen_124.jpg
├── validation/
│ (mismo formato que 'train')
└── test/
(mismo formato que 'train')
En este ejemplo, he organizado las imágenes en tres conjuntos: entrenamiento (train), validación (validation), y prueba (test). Cada conjunto tiene subdirectorios para cada clase de vehículo (camiones, turismos, autocares, motocicletas). Esto es una práctica común al trabajar con modelos de aprendizaje profundo.
Espero que esto te ayude a estructurar tus datos para el entrenamiento de tu modelo CNN. Asegúrate de ajustar la división entre conjuntos de entrenamiento, validación y prueba según tus necesidades específicas.
**************************************************************************************************************
Los directorios "validation" y "test" son comúnmente utilizados en el entrenamiento de modelos de aprendizaje profundo, como las redes neuronales convolucionales (CNN), para evaluar el rendimiento del modelo en datos que no ha visto durante el entrenamiento. Aquí hay una breve descripción de cada uno:
Conjunto de Validación:
----------------------
Propósito: Se utiliza durante el entrenamiento del modelo para ajustar los hiperparámetros y evitar el sobreajuste (overfitting).
Composición:
---------------
Contiene datos adicionales que no se utilizan para entrenar directamente el modelo, pero se emplean para evaluar su rendimiento durante cada época (epoch) del entrenamiento.
Cómo se usa:
-----------
Después de cada época (epoch), de entrenamiento, el modelo se evalúa en el conjunto de validación. Esto permite ajustar los hiperparámetros del modelo para mejorar su rendimiento en datos que no forman parte del conjunto de entrenamiento.
Conjunto de Prueba (Test):
-------------------------
Propósito:
----------------
Se utiliza al final del entrenamiento para evaluar el rendimiento final del modelo en datos completamente nuevos que no se han visto en absoluto durante el proceso de entrenamiento.
Composición:
-----------
Contiene datos independientes que el modelo nunca ha visto ni durante el entrenamiento ni durante la validación.
Cómo se usa:
-----------
Una vez que el modelo ha sido entrenado y ajustado utilizando el conjunto de entrenamiento y de validación, se evalúa de manera final en el conjunto de prueba para obtener una estimación imparcial de su rendimiento en datos no vistos.
La separación entre conjuntos de entrenamiento, validación y prueba ayuda a garantizar que el modelo sea capaz de generalizar bien a datos no vistos y no se sobreajuste a los datos de entrenamiento específicos.
En resumen, el conjunto de validación es utilizado para ajustar los hiperparámetros y evitar el sobreajuste durante el entrenamiento, mientras que el conjunto de prueba proporciona una evaluación final del rendimiento del modelo en datos completamente nuevos y no vistos.
********************************************************************************************************************
Debes asegurarte, para no generar errores, que las rutas, en tu caso, sean exactas.
El ejercicio para generar el módelo tendría este código, que también te pongo en el editor de códigos:
----------------------------------------------------------------------------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# Rutas de los datos de entrenamiento, validación y prueba
train_data_dir = 'ProyectoCNN/dataset/train'
validation_data_dir = 'ProyectoCNN/dataset/validation'
test_data_dir = 'ProyectoCNN/dataset/test'
# Parámetros
batch_size = 32
img_height = 64
img_width = 64
# Crear generadores de datos para entrenamiento, validación y prueba
train_datagen = ImageDataGenerator(rescale=1./255)
validation_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)
train_generator = train_datagen.flow_from_directory(
train_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical') # 'categorical' ya que hay más de dos clases
validation_generator = validation_datagen.flow_from_directory(
validation_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')
test_generator = test_datagen.flow_from_directory(
test_data_dir,
target_size=(img_height, img_width),
batch_size=batch_size,
class_mode='categorical')
# Construir el modelo CNN
model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(img_height, img_width, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dense(4, activation='softmax')) # 'softmax' ya que hay más de dos clases
# Compilar el modelo
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Entrenar el modelo
model.fit(train_generator, epochs=10, validation_data=validation_generator)
# Evaluar el modelo en el conjunto de prueba
test_loss, test_acc = model.evaluate(test_generator)
print(f'Precisión en el conjunto de prueba: {test_acc}')
# Guardar el modelo
model.save('modelo_cnn_proyecto.h5')
**********************************************************************************************************
**************************************************************************************************************
Bien. En mi caso. Una vez creado el modelo con esta ruta: /home/margarito/python/modelo_cnn_proyecto.h5.
Necesito entrenar una red neuronal CNN, con el modelo: modelo_cnn_proyecto.h5 Que dada la ruta de esta
imagen de un turismo en esta ruta:/home/margarito/python/coche.jpeg . Me diga si es un camion,
una motocicleta, un coche, o un autocar.ñ
-----------------------------------------------------------------------------------------------------------
Después de haber entrenado tu modelo, puedes usarlo para hacer predicciones sobre nuevas imágenes.
Aquí tienes un ejemplo de cómo cargar el modelo y realizar una predicción sobre la imagen de un turismo:
import tensorflow as tf
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np
# Cargar el modelo previamente entrenado
modelo = tf.keras.models.load_model('/home/margarito/python/modelo_cnn_proyecto.h5')
# Cargar la imagen de un coche
img_path = '/home/margarito/python/coche.jpeg'
img = image.load_img(img_path, target_size=(64, 64))
img_array = image.img_to_array(img)
img_array = np.expand_dims(img_array, axis=0)
img_array = preprocess_input(img_array)
# Realizar la predicción
predictions = modelo.predict(img_array)
# Obtener las clases predichas
class_indices = {0: 'camiones', 1: 'turismos', 2: 'autocares', 3: 'motocicletas'}
predicted_class = class_indices[np.argmax(predictions)]
# Imprimir el resultado
print(f'Predicción: {predicted_class}')
------------------------------------------------------------------------------------------
Este script carga la imagen del coche, la preprocesa de manera adecuada para el modelo, realiza la predicción y luego imprime la clase predicha. Asegúrate de que la imagen esté en el formato adecuado y ajusta las rutas según sea necesario. Recuerda que el modelo fue entrenado con clases específicas ('camiones', 'turismos', 'autocares', 'motocicletas'), así que las clases predichas deben coincidir con estas categorías.
************************************************************************************
[b]El ejercicio fue realizado bajo plataforma Linux.
Concretamente:Ubuntu 20.04.6 LTS
Editado con:Sublime Text.
-------------------------
Se debe de tener en cuenta que en tu ordenador deberan estar cargadas las librerias necesarias.
En nuestro caso:
---------------
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
-------------------------------------------
from tensorflow.keras.preprocessing import image
from tensorflow.keras.applications.vgg16 import preprocess_input, decode_predictions
import numpy as np
************************************************************************************
Ejecucion de los programas:
#Crear_Modelo_CN_Aula-28.py
#Ejecución:python3 Crear_Modelo_CN_Aula-28.py
--------------------------------------------------
#Util_Modelo_Creado_Aula-28.py
#Ejecutar: python3 Util_Modelo_Creado_Aula-28.py
*******************************************************************************************************
