Alai

Introducción

«¿Construir un modelo de aprendizaje profundo en unos minutos? ¡Tardará horas en entrenarse! Ni siquiera tengo una máquina lo suficientemente buena». He escuchado esto innumerables veces de aspirantes a científicos de datos que rehúyen construir modelos de aprendizaje profundo en sus propias máquinas.

¡No es necesario trabajar para Google u otras grandes empresas tecnológicas para trabajar en conjuntos de datos de aprendizaje profundo! Es totalmente posible construir tu propia red neuronal desde cero en cuestión de minutos sin necesidad de alquilar los servidores de Google. Los estudiantes de Fast.ai diseñaron un modelo sobre el conjunto de datos Imagenet en 18 minutos – y yo mostraré algo similar en este artículo.

El aprendizaje profundo es un campo muy amplio, por lo que nos centraremos un poco y aceptaremos el reto de resolver un proyecto de Clasificación de Imágenes. Además, utilizaremos una arquitectura de aprendizaje profundo muy simple para lograr una puntuación de precisión bastante impresionante.

Puedes considerar el código de Python que veremos en este artículo como un punto de referencia para construir modelos de Clasificación de Imágenes. Una vez que tengas una buena comprensión del concepto, sigue adelante y juega con el código, participa en competiciones y sube en la tabla de clasificación.

Si eres nuevo en el aprendizaje profundo y estás fascinado por el campo de la visión por ordenador (¿quién no lo está?), echa un vistazo al curso ‘Computer Vision using Deep Learning’. Es una introducción completa a este maravilloso campo y te preparará para lo que inevitablemente va a ser un enorme mercado de trabajo en un futuro próximo.

Proyecto para aplicar la Clasificación de Imágenes

Más del 25% de todos los ingresos en el Comercio Electrónico se atribuye a la ropa & accesorios. Un problema importante al que se enfrentan es la categorización de estas prendas a partir sólo de las imágenes, especialmente cuando las categorías proporcionadas por las marcas son inconsistentes. Esto plantea un interesante problema de visión por ordenador que ha llamado la atención de varios investigadores de aprendizaje profundo.

Fashion MNIST es un sustituto del muy conocido conjunto de datos de aprendizaje automático «hello world» – MNIST, que puede comprobarse en el problema de práctica «Identify the digits». En lugar de dígitos, las imágenes muestran un tipo de ropa, por ejemplo, una camiseta, un pantalón, un bolso, etc. El conjunto de datos utilizado en este problema fue creado por Zalando Research.

Práctica ahora

Tabla de contenidos

1. Qué es la clasificación de imágenes y sus casos de uso
2. Configuración de la estructura de nuestros datos de imágenes
3. Desglose de la construcción del modelo Proceso
4. Establecimiento del planteamiento del problema y comprensión de los datos
5. Pasos para construir el modelo de clasificación de imágenes
6. Asumir otro reto

¿Qué es la clasificación de imágenes?

Considere la siguiente imagen:

La habrá reconocido al instante: es un coche (elegante). Da un paso atrás y analiza cómo has llegado a esta conclusión: te han mostrado una imagen y has clasificado la clase a la que pertenece (un coche, en este caso). Y eso, en pocas palabras, es lo que significa la clasificación de imágenes.

Hay un número potencialmente n de categorías en las que se puede clasificar una imagen determinada. Comprobar y clasificar manualmente las imágenes es un proceso muy tedioso. La tarea se vuelve casi imposible cuando nos enfrentamos a un número masivo de imágenes, digamos 10.000 o incluso 100.000. ¿Qué utilidad tendría si pudiéramos automatizar todo este proceso y etiquetar rápidamente las imágenes según su clase correspondiente?

Los coches de conducción autónoma son un gran ejemplo para entender dónde se utiliza la clasificación de imágenes en el mundo real. Para permitir la conducción autónoma, podemos construir un modelo de clasificación de imágenes que reconozca varios objetos, como vehículos, personas, objetos en movimiento, etc. en la carretera. Veremos un par de casos de uso más adelante en este artículo, pero hay muchas más aplicaciones a nuestro alrededor. Utiliza la sección de comentarios debajo del artículo para hacerme saber qué casos de uso potenciales se te ocurren!

Ahora que ya tenemos un manejo de nuestro tema, vamos a sumergirnos en cómo se construye un modelo de clasificación de imágenes, cuáles son los requisitos previos para ello, y cómo se puede implementar en Python.

Configuración de la estructura de nuestros datos de imagen

Nuestros datos tienen que estar en un formato particular con el fin de resolver un problema de clasificación de imágenes. Veremos esto en acción en un par de secciones, pero ten en cuenta estas indicaciones hasta que lleguemos allí.

Deberías tener 2 carpetas, una para el conjunto de entrenamiento y otra para el conjunto de prueba. En el conjunto de entrenamiento, tendrás un archivo .csv y una carpeta de imágenes:

• El archivo .csv contiene los nombres de todas las imágenes de entrenamiento y sus correspondientes etiquetas verdaderas
• La carpeta de imágenes tiene todas las imágenes de entrenamiento.

El archivo .csv de nuestro conjunto de prueba es diferente al presente en el conjunto de entrenamiento. Este archivo .csv del conjunto de prueba contiene los nombres de todas las imágenes de prueba, pero no tienen las etiquetas correspondientes. ¿Puede adivinar por qué? Nuestro modelo se entrenará con las imágenes presentes en el conjunto de entrenamiento y las predicciones de etiquetas se harán con las imágenes del conjunto de prueba

Si tus datos no están en el formato descrito anteriormente, tendrás que convertirlos en consecuencia (de lo contrario las predicciones serán erróneas y bastante inútiles).

Desglosando el proceso de construcción del modelo

Antes de sumergirnos en el código de Python, vamos a tomarnos un momento para entender cómo se diseña normalmente un modelo de clasificación de imágenes. Podemos dividir este proceso a grandes rasgos en 4 etapas. Cada etapa requiere una cierta cantidad de tiempo para ejecutarse:

1. Carga y preprocesamiento de datos – 30% de tiempo
2. Definición de la arquitectura del modelo – 10% de tiempo
3. Entrenamiento del modelo – 50% de tiempo
4. Estimación del rendimiento – 10% de tiempo

Déjame explicar cada uno de los pasos anteriores con un poco más de detalle. Esta sección es crucial porque no todos los modelos se construyen a la primera. Usted tendrá que volver después de cada iteración, afinar sus pasos, y ejecutarlo de nuevo. Tener una sólida comprensión de los conceptos subyacentes será de gran ayuda para acelerar todo el proceso.

Etapa 1: Cargar y preprocesar los datos

Los datos son oro en lo que respecta a los modelos de aprendizaje profundo. Tu modelo de clasificación de imágenes tiene muchas más posibilidades de funcionar bien si tienes una buena cantidad de imágenes en el conjunto de entrenamiento. Además, la forma de los datos varía según la arquitectura/marco que utilicemos.

De ahí el paso crítico de preprocesamiento de datos (el paso eternamente importante en cualquier proyecto). Recomiendo encarecidamente pasar por ‘Basics of Image Processing in Python’ para entender mejor cómo funciona el preprocesamiento con los datos de las imágenes.

Pero aún no hemos llegado al final. Para ver cómo funciona nuestro modelo en datos no vistos (y antes de exponerlo al conjunto de pruebas), necesitamos crear un conjunto de validación. Esto se hace partiendo los datos del conjunto de entrenamiento.

En resumen, entrenamos el modelo en los datos de entrenamiento y lo validamos en los datos de validación. Una vez que estamos satisfechos con el rendimiento del modelo en el conjunto de validación, podemos utilizarlo para hacer predicciones en los datos de prueba.

Tiempo requerido para este paso: Requerimos alrededor de 2-3 minutos para esta tarea.

Etapa 2: Definir la arquitectura del modelo

Este es otro paso crucial en nuestro proceso de construcción de modelos de aprendizaje profundo. Tenemos que definir cómo será nuestro modelo y eso requiere responder a preguntas como:

• ¿Cuántas capas convolucionales queremos?
• ¿Cuál debe ser la función de activación para cada capa?
• ¿Cuántas unidades ocultas debe tener cada capa?

Y muchas más. Estos son esencialmente los hiperparámetros del modelo que juegan un papel MASIVO a la hora de decidir lo buenas que serán las predicciones.

¿Cómo decidimos estos valores? Excelente pregunta. Una buena idea es elegir estos valores basándose en investigaciones/estudios existentes. Otra idea es seguir experimentando con los valores hasta encontrar la mejor coincidencia, pero esto puede ser un proceso bastante lento.

Tiempo requerido para este paso: Debería tomar alrededor de 1 minuto para definir la arquitectura del modelo.

Etapa 3: Entrenamiento del modelo

Para el entrenamiento del modelo, requerimos:

• Imágenes de entrenamiento y sus correspondientes etiquetas verdaderas
• Imágenes de validación y sus correspondientes etiquetas verdaderas (usamos estas etiquetas sólo para validar el modelo y no durante la fase de entrenamiento)

También definimos el número de épocas en este paso. Para empezar, ejecutaremos el modelo durante 10 epochs (puedes cambiar el número de epochs más tarde).

Tiempo requerido para este paso: Dado que el entrenamiento requiere que el modelo aprenda estructuras, necesitamos unos 5 minutos para realizar este paso.

¡Y ahora es el momento de hacer predicciones!

Etapa 4: Estimación del rendimiento del modelo

Por último, cargamos los datos de prueba (imágenes) y pasamos por el paso de preprocesamiento aquí también. A continuación, predecimos las clases para estas imágenes utilizando el modelo entrenado.

Tiempo requerido para este paso: ~ 1 minuto.

Configuración del planteamiento del problema y comprensión de los datos

Vamos a recoger un reto realmente interesante para entender la clasificación de imágenes. Tenemos que construir un modelo que pueda clasificar un conjunto dado de imágenes en función de la ropa (camisa, pantalón, zapatos, calcetines, etc.). En realidad es un problema al que se enfrentan muchos minoristas de comercio electrónico, lo que lo convierte en un problema de visión por ordenador aún más interesante.

Este reto se llama ‘Identifica las prendas’ y es uno de los problemas de práctica que tenemos en nuestra plataforma DataHack. Tendrás que registrarte y descargar el conjunto de datos desde el enlace anterior.

Tenemos un total de 70.000 imágenes (dimensión 28 x 28), de las cuales 60.000 son del conjunto de entrenamiento y 10.000 del de prueba. Las imágenes de entrenamiento están preetiquetadas según el tipo de ropa con 10 clases en total. Las imágenes de prueba, por supuesto, no están etiquetadas. El reto es identificar el tipo de ropa presente en todas las imágenes de prueba.

Construiremos nuestro modelo en Google Colab ya que proporciona una GPU gratuita para entrenar nuestros modelos.

Pasos para construir nuestro modelo

Es hora de poner en marcha tus habilidades con Python y ensuciarte las manos. ¡Por fin llegamos a la parte de implementación de nuestro aprendizaje!

1. Configuración de Google Colab
2. Importación de bibliotecas
3. Carga y preprocesamiento de datos – (3 mins)
4. Creación de un conjunto de validación
5. Definir la estructura del modelo – (1 min)
6. Entrenar el modelo – (5 min)
7. Hacer predicciones – (1 min)

Veamos cada paso en detalle.

Paso 1: Configurar Google Colab

Como vamos a importar nuestros datos desde un enlace de Google Drive, tendremos que añadir unas cuantas líneas de código en nuestro cuaderno de Google Colab. Crea un nuevo cuaderno de Python 3 y escribe los siguientes bloques de código:

!pip install PyDrive

Esto instalará PyDrive. Ahora importaremos unas cuantas librerías necesarias:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

A continuación, crearemos una variable drive para acceder a Google Drive:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Para descargar el conjunto de datos, utilizaremos el ID del archivo subido a Google Drive:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Sustituye el ‘id’ en el código anterior por el ID de tu archivo. Ahora descargaremos este archivo y lo descomprimiremos:

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Debes ejecutar estos bloques de código cada vez que inicies tu cuaderno.

Paso 2 : Importa las librerías que necesitaremos durante nuestra fase de construcción del modelo.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Paso 3: Recuerda los pasos de preprocesamiento que comentamos anteriormente. Los usaremos aquí después de cargar los datos.

train = pd.read_csv('train.csv')

A continuación, leeremos todas las imágenes de entrenamiento, las almacenaremos en una lista y, finalmente, convertiremos esa lista en un array de numpy.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Como se trata de un problema de clasificación multiclase (10 clases), codificaremos de una sola vez la variable objetivo.

y=train.valuesy = to_categorical(y)

Paso 4: Crear un conjunto de validación a partir de los datos de entrenamiento.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Paso 5: Definir la estructura del modelo.

Crearemos una arquitectura sencilla con 2 capas convolucionales, una capa oculta densa y una capa de salida.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

A continuación, compilaremos el modelo que hemos creado.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Paso 6: Entrenar el modelo.

En este paso, entrenaremos el modelo con las imágenes del conjunto de entrenamiento y lo validaremos utilizando, lo has adivinado, el conjunto de validación.

model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

Paso 7: ¡Hacer predicciones!

Inicialmente seguiremos los pasos que realizamos al tratar los datos de entrenamiento. Cargaremos las imágenes de prueba y predeciremos sus clases utilizando la función model.predict_classes().

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Importaremos el archivo de prueba:

test = pd.read_csv('test.csv')

Ahora, leeremos y almacenaremos todas las imágenes de prueba:

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

También crearemos un archivo de envío para subirlo a la página de la plataforma DataHack (para ver cómo quedan nuestros resultados en la tabla de clasificación).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Descarga este archivo sample_cnn.csv y súbelo a la página del concurso para generar tus resultados y comprobar tu posición en la tabla de clasificación. Esto le dará una solución de referencia para empezar con cualquier problema de clasificación de imágenes.

Puede probar técnicas de ajuste de hiperparámetros y regularización para mejorar aún más el rendimiento de su modelo. Te animo a que consultes este artículo para entender este paso de ajuste con mucho más detalle – ‘A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Tomando un desafío diferente

Pongamos a prueba nuestro aprendizaje en un conjunto de datos diferente. En esta sección vamos a resolver el problema de práctica «Identificar los dígitos». Sigue adelante y descarga el conjunto de datos. Antes de continuar, intenta resolverlo por tu cuenta. Ya tienes las herramientas para resolverlo, ¡sólo tienes que aplicarlas! Vuelve aquí para comprobar tus resultados o si te quedas atascado en algún momento.

En este reto, tenemos que identificar el dígito en una imagen dada. Tenemos un total de 70.000 imágenes: 49.000 etiquetadas en el conjunto de entrenamiento y las 21.000 restantes en el conjunto de prueba (las imágenes de prueba no están etiquetadas). Necesitamos identificar/predecir la clase de estas imágenes no etiquetadas.

¿Listo para empezar? ¡Genial! Crea un nuevo cuaderno de Python 3 y ejecuta el siguiente código:

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Envía este archivo en la página de problemas de práctica para obtener un número de precisión bastante decente. Es un buen comienzo, pero siempre se puede mejorar. Siga jugando con los valores de los hiperparámetros y vea si puede mejorar nuestro modelo básico.

Notas finales

Quien dijo que los modelos de aprendizaje profundo requerían horas o días para ser entrenados. Mi objetivo aquí era mostrar que se puede llegar a un modelo de aprendizaje profundo bastante decente en un tiempo doblemente rápido. Deberías coger retos similares e intentar codificarlos también desde tu lado. No hay nada como aprender haciendo!

Los mejores científicos y analistas de datos tienen estos códigos listos antes de que comience un Hackathon. Utilizan estos códigos para realizar las primeras presentaciones antes de sumergirse en un análisis detallado. Una vez que tienen una solución de referencia, empiezan a mejorar su modelo utilizando diferentes técnicas.