Fase de entrenamiento del modelo

Curso Profesional de Computer Vision con TensorFlow

Contenido del curso

Comprender la visión computarizada

Dimensionamiento de proyecto de visión computarizada

Obtención y procesamiento de los datos

Entrena, testea y optimiza tus modelos

Producto con visión computarizada en producción

Siguientes pasos en inteligencia artificial

Tomar examen

Fase de entrenamiento del modelo

Todos los cursos GRATIS

Se acaba en:

00díasd:00hrsh:00minm:00segs

Resumen

Instalar la librería de object Detection en Google Colab:

import os
%cd /content
!git clone --quiet https://github.com/tensorflow/models.git
%cd /content/models/
#!git checkout 58d19c67e1d30d905dd5c6e5092348658fed80af
!apt-get update && apt-get install -y -qq protobuf-compiler python-pil python-lxml python-tk
!pip install -q Cython contextlib2 pillow lxml matplotlib
!pip install -q pycocotools
%cd /content/models/research
!protoc object_detection/protos/*.proto --python_out=.
os.environ['PYTHONPATH'] += ':/content/models/research/:/content/models/research/slim/'
!python object_detection/builders/model_builder_test.py

Descargar los modelos pre-entrenados en este caso SSD + MobileNetV2

!wget --no-check-certificate http://download.tensorflow.org/models/object_detection/tf2/20200711/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz \
-O /content/ssd_mobilenet_v2_fpnlite_320x320_coco17_tpu-8.tar.gz

Mario Alexander Vargas Celis

Estudiante

Hace 2 años

La fase de entrenamiento del modelo es el proceso en el cual el modelo de machine learning aprende a reconocer patrones en los datos para realizar predicciones o clasificaciones. En TensorFlow, el proceso generalmente incluye la carga de datos, la definición del modelo, la configuración de parámetros de entrenamiento, y el ajuste del modelo con los datos de entrenamiento. Aquí te explico cada paso.

### 1. **Preparación de los datos**

Supongamos que ya tienes un conjunto de datos en formato **TFRecord**. Carguemos y preparemos los datos para el entrenamiento.

```python

import tensorflow as tf

# Función para leer y parsear el archivo TFRecord

def parse_tfrecord_fn(example):

feature_description = {

'image': tf.io.FixedLenFeature([], tf.string),

'label': tf.io.FixedLenFeature([], tf.int64),

}

parsed_example = tf.io.parse_single_example(example, feature_description)

image = tf.io.decode_jpeg(parsed_example['image'], channels=3) # Decodificar JPEG

image = tf.image.resize(image, [128, 128]) # Redimensionar

image = tf.cast(image, tf.float32) / 255.0 # Normalizar

label = parsed_example['label']

return image, label

# Cargar el dataset desde el archivo TFRecord

train_dataset = tf.data.TFRecordDataset('train_data.tfrecord')

train_dataset = train_dataset.map(parse_tfrecord_fn)

train_dataset = train_dataset.shuffle(buffer_size=1000).batch(32).prefetch(tf.data.AUTOTUNE)

```

### 2. **Definir el modelo**

Puedes definir un modelo usando la API tf.keras.Sequential o la API funcional de Keras. Aquí tienes un ejemplo de modelo simple de clasificación para imágenes.

```python

from tensorflow.keras import layers, models

model = models.Sequential([

layers.Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),

layers.MaxPooling2D((2, 2)),

layers.Conv2D(64, (3, 3), activation='relu'),

layers.MaxPooling2D((2, 2)),

layers.Conv2D(64, (3, 3), activation='relu'),

layers.Flatten(),

layers.Dense(64, activation='relu'),

layers.Dense(10, activation='softmax') # Asumiendo 10 clases

])

```

### 3. **Compilar el modelo**

La compilación del modelo define el optimizador, la función de pérdida, y las métricas a utilizar durante el entrenamiento.

```python

model.compile(optimizer='adam',

loss='sparse_categorical_crossentropy',

metrics=['accuracy'])

```

### 4. **Entrenar el modelo**

Ahora puedes entrenar el modelo usando el método fit de Keras, indicando los datos de entrenamiento y el número de épocas.

```python

# Entrenar el modelo

history = model.fit(train_dataset, epochs=10)

```

Aquí history guardará un registro de la pérdida y la precisión en cada época, que puede ayudarte a analizar el rendimiento del modelo.

### 5. **Evaluación del modelo**

Después del entrenamiento, evalúa el rendimiento del modelo en el conjunto de datos de prueba.

```python

# Cargar datos de prueba (TFRecord)

test_dataset = tf.data.TFRecordDataset('test_data.tfrecord')

test_dataset = test_dataset.map(parse_tfrecord_fn).batch(32)

# Evaluar el modelo

test_loss, test_accuracy = model.evaluate(test_dataset)

print(f"Precisión en datos de prueba: {test_accuracy:.2f}")

```

### 6. **Ajustes adicionales y visualización del entrenamiento**

Puedes visualizar el progreso del entrenamiento usando la información de history. Esto es útil para identificar problemas como el sobreajuste.

```python

import matplotlib.pyplot as plt

# Graficar pérdida y precisión

plt.plot(history.history['accuracy'], label='Precisión de entrenamiento')

plt.plot(history.history['loss'], label='Pérdida de entrenamiento')

plt.xlabel('Épocas')

plt.ylabel('Precisión / Pérdida')

plt.legend()

plt.show()

```

### Resumen

1. **Preparación de datos**: Se preprocesan y cargan los datos desde TFRecord.

2. **Definición del modelo**: Se configura una red neuronal que ajusta los datos de entrada.

3. **Compilación**: Se eligen el optimizador, la función de pérdida, y las métricas.

4. **Entrenamiento**: Se entrena el modelo con los datos de entrenamiento.

5. **Evaluación**: Se mide el rendimiento en los datos de prueba.

Esta estructura es común en proyectos de machine learning, especialmente en visión computarizada, y te permite ajustar el modelo gradualmente hasta obtener el rendimiento deseado.

Fase de entrenamiento del modelo

Comprender la visión computarizada

¿Por qué aprender computer vision?

¿Qué es la visión computarizada?

Tipos de visión computarizada

Introducción a object detection: clasificación + localización

Aprende a identificar problemas

Dimensionamiento de proyecto de visión computarizada

Cómo definir los tiempos de tu proyecto

Cómo costear tu proyecto

Cómo identificar los roles necesarios en el proyecto

Producto mínimo viable en computer vision

Obtención y procesamiento de los datos

Obtención de datos para tu proyecto

Limpieza de la base de datos

Distribución de datos en entrenamiento y testeo

Etiquetado de los datos de test

Etiquetado de los datos de train

Transforma tu base de datos a TFRecord

Transformar CSV a TFRecord

Entrena, testea y optimiza tus modelos

Librerías a importar durante fase de entrenamiento

Fase de entrenamiento del modelo

Balanceo de imágenes y data augmentation

Entrena, evalua y optimiza con TensorBoard

Validación de modelo en un entorno de ejecución

Re-entrenamiento del modelo para obtener mejores resultados

Seguimiento de centroides con OpenCV

Configuración de los centroides con OpenCV

Algoritmo de dirección y conteo con OpenCV

Crea un ciclo de entrenamiento de tu modelo: MLOps

Producto con visión computarizada en producción

Prepara tu entorno en Google Cloud Platform

Carga y preprocesamiento de modelos

Postprocesamiento de modelos

Despliega y consume tu modelo en producción

Bonus: aprende a apagar las máquinas de GCP para evitar sobrecostos

Siguientes pasos en inteligencia artificial

Siguientes pasos en inteligencia artificial

Comparte tu proyecto de detección de vehículos en carretera y certifícate

Todos los cursos GRATIS

Resumen