Clasificación de imágenes de etiquetas múltiples: predicción de etiquetas de imágenes

Hay tantas cosas que podemos hacer usando algoritmos de visión artificial: 
 

• Detección de objetos
• Segmentación de imagen
• Traducción de imágenes
• Seguimiento de objetos (en tiempo real) y mucho más.

¿Qué es la clasificación de imágenes multietiqueta?  
Comprendamos el concepto de clasificación de imágenes de etiquetas múltiples con un ejemplo intuitivo. Si te muestro la imagen de una pelota, la clasificarás fácilmente como una pelota en tu mente. La siguiente imagen que os muestro es de una terraza. Ahora podemos dividir las dos imágenes en dos clases, es decir, bola o no-bola. 
Cuando tenemos solo dos clases en las que se pueden clasificar las imágenes, esto se conoce como un problema de clasificación binaria de imágenes. 
 

• Cuando existen más de dos categorías en las que se pueden clasificar las imágenes.
• Una imagen no pertenece a más de una categoría

Si se cumplen las dos condiciones anteriores, se habla de un problema de clasificación de imágenes multiclase.
Requisitos previos: 
comencemos con algunos requisitos previos:
aquí, usaremos los siguientes idiomas y editores: 
 

• Idioma/intérprete: Python 3 (preferiblemente Python 3.8) de python.org
• Editor: Cuaderno Jupyter iPython
• Sistema operativo: Windows 10 x64
• Conjunto de datos: descargue cualquier conjunto de datos de imágenes de Kaggle o Internet.
• Requisitos de Python: este proyecto requiere que se instalen las siguientes bibliotecas a través de pip: Numpy, Pandas, MatPlotLib, Scikit Learn, Scikit Image.

En la ventana de CMD, ejecute el siguiente comando para instalar los requisitos:
       ——————————————————————————-
       | pip install numpy pandas matplotlib notebook scikit-image scikit-learn |
       ———————————————————————————- 
Nota: reemplaza pip con conda si usas anaconda!!
Ahora ejecute jupyter y abra el cuaderno en los archivos que descargó anteriormente. 
 

Pasos a seguir: 
 

Pasos para la clasificación de etiquetas

Paso 1: Importando las bibliotecas que necesitamos.

# system libraries
import os
import warnings
 
# ignoring all the warnings
warnings.simplefilter('ignore')
 
# import data handling libraries
import numpy as np
import pandas as pd
 
# importing data visualisation libraries
import matplotlib.pyplot as plt
% matplotlib inline
 
# import image processing library
from skimage.io import imread, imshow
from skimage.transform import resize
from skimage.color import rgb2grey

Paso 2: Lectura de imágenes de destino en el proyecto 
En esta parte del artículo, indicaremos a Python que lea las imágenes una por una y luego inserte los datos de píxeles de las imágenes en arrays que podamos usar. Luego, crearemos listas de archivos con la biblioteca os de Python. 
 

os.listdir(ruta) devuelve una lista que contiene los nombres de las entradas en el directorio dado por la ruta. 
 

r = os.listdir(r"C:\Users\Garima Singh\Desktop\data\mugshots\r")
# This is the path to the image folder
 
v = os.listdir(r"C:\Users\Garima Singh\Desktop\data\mugshots\v")
d = os.listdir(r"C:\Users\Garima Singh\Desktop\data\mugshots\d")
 
print(r[0:10])

Paso 3: Creación e importación de datos de las imágenes y configuración de un límite.  
Aquí, usaremos la función imread de NumPy y scikit-image. Como tenemos los datos descargados, podemos contar rápidamente cuántas imágenes por tema tenemos. Por ejemplo, suponga que tiene 100 imágenes en cada carpeta (r, v y d), puede establecer un límite variable con valores de 100. El siguiente paso es crear arrays vacías para estos datos y llenar estas arrays con datos. Rápidamente haremos 3 arreglos para acomodar los datos de la serie de imágenes. Creamos una array llena de valores «Ninguno» usando el siguiente fragmento de código:
 

limit = 100
# Creating the list of blank spaces that can potentially hold data:
ra_images = [None]*limit
 
# Creating loop variables:
i, j = 0, 0
 
# This part of the code loops over all the images
# in the list "r" and reads it into the jth element
# of the array we made in line 2.
for i in r:
    if(j<limit):
        ra_images[j] = imread(r"C:\Users\data\mugshots\r\\" + i)
        j+= 1
    else:
        break
       
# Similarly, we will fill up the data into the other 2 arrays

Paso 4: ensamblaje del conjunto de datos y aplanamiento y remodelación de las arrays.  
En esta sección, utilizaremos el marco de datos de pandas para fusionar estas 3 arrays de datos en una sola array de datos. En este momento, nuestra array de imágenes tiene un tamaño de 28 × 28. Necesitamos convertir esta array en una array de 28 ^ 2 x 1. Esto básicamente significa que tenemos que tomar cada imagen y convertirla en una fila de datos en nuestro conjunto de datos.
 

# Finding out the number of columns per image in our dataset.
# We will use the shape function on any one image in our array
# and use the dimensions we get as the number of columns in row.
number_of_columns = ra_grey[1].shape[0] * ra_grey[1].shape[1]
print(number_of_columns)
 
# This means we will be using this many columns
# per row in our dataset.
# Our dataset has 300 images, so:
# Our dataset will be an array of dimensions
# 784 x 300 => 300 images of 784 pixels each.

Paso 5: aplanar y remodelar los datos.  
Esta es la parte del código que primero convierte la array de 28×28 en un vector de columna (es decir, una array de 784 x 1).
 

print(ra_grey[0].shape)
for i in range(limit):
    ra_grey[i] = np.ndarray.flatten(ra_grey[i]).reshape(number_of_columns, 1)
print(ra_grey[0].shape)
 
# We will use NumPy's dstack and rollaxis to remove the extra axis(the 1 part in last output) that we saw in the above code output.
 
ra_grey = np.dstack(ra_grey)
print(ra_grey.shape)
ra_grey = np.rollaxis(ra_grey, axis = 2, start = 0)
print(ra_grey.shape)
ra_grey = ra_grey.reshape(limit, number_of_columns)
print(ra_grey.shape)

Haga lo anterior para el resto de los datos, es decir, realice los 2 pasos anteriores para las próximas 2 arrays. 
 

Paso 6: Conversión de arreglos en marcos de datos 
Como se discutió antes, pandas hace un software de hoja de cálculo como un entorno para nuestras tablas. Convirtamos nuestras arrays en marcos de datos:
 

ra_data = pd.DataFrame(ra_grey)
dh_data = pd.DataFrame(dh_grey)
vi_data = pd.DataFrame(vi_grey)
 
ra_data
 
print(ra_data)

Paso 7: Agregar un nombre a las imágenes.  
En este paso agregamos una columna que contiene el nombre de nuestros sujetos.
A esto se le llama etiquetar nuestras imágenes. El modelo intentará predecir en función de los valores y generará una de estas etiquetas.
 

ra_data["label"]="R"
dh_data["label"]="D"
vi_data["label"]="V"
 
vi_data
 
# Joining and mixing the data into one dataframe.
# First, we will start with joining all 3 dataframes
# made in 3.2 into a single dataframe, using concat function.
# Note: It is recommended to join the first 2,
# then join the last one into the first pair.
 
act = pd.concat([ra_data, dh_data])
actor = pd.concat([act, vi_data])
 
actor

Paso 8: Mezclar los datos e imprimir el conjunto de datos final 
Esta es la última etapa de esta sección. Estaremos barajando los datos, para que parezcan mezclados. 
 

from sklearn.utils import shuffle
out = shuffle(actor).reset_index()
 
out
 
# Drop the column named index
out = out.drop(['index'], axis = 1)
out

Paso 9: Codificación del algoritmo de aprendizaje automático + Precisión de prueba.  
En esta sección, codificaremos el algoritmo de aprendizaje automático y descubriremos la precisión de nuestro algoritmo. 
 

# First, we will extract the x and y values of our dataset
 
x = out.values[:, :-1]
y = out.values[:, -1]
 
print(x[0:3])
print(y[0:3])
 
# From the above output, we can see that:
# x - stores the image data.
# y - stores the label data.

Paso 10: Importación de bibliotecas de ML y codificación de ML 
Importaremos algunas bibliotecas de ML, todas provendrán de sklearn y sus clases.
 

from sklearn.decomposition import PCA                  
from sklearn.svm import SVC                            
from sklearn.pipeline import make_pipeline             
from sklearn.model_selection import train_test_split   
from sklearn.model_selection import GridSearchCV       
from sklearn import metrics                          
 
# Here we will use train_test_split to create our training and testing data.
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state = 0)
 
pca = PCA(n_components = 150, whiten = True, random_state = 0)
svc = SVC(kernel ='rbf', class_weight ='balanced')
model = make_pipeline(pca, svc)
 
params = {'svc__C': [x for x in range(1, 6)],
          'svc__gamma': [0.001, 0.005, 0.006, 0.01, 0.05, 0.06, 0.004, 0.04]}
 
grid = GridSearchCV(model, params)
% time grid.fit(x_train, y_train)
print(grid.best_params_)
 
model = grid.best_estimator_
ypred = model.predict(x_test)
 
ypred[0:3]

Usaremos la clase PCA y la clase SVC para crear nuestro objeto modelo. El make_pipeline nos ayudará a crear un modelo sencillo que GridSearchSV puede probar. 
 

GridSearchSV es la función que creará un modelo con todos los parámetros en CADA combinación posible y nos dirá cuál es la mejor combinación. 
 

Ahora que tenemos el modelo con los mejores parámetros para nuestros datos, usamos estos parámetros en nuestro modelo y probamos su precisión. 
Paso 11: Diagramas y obtención de precisión 
Veamos un diagrama visualizado de caras frente a etiquetas predichas:
 

fig, ax = plt.subplots(4, 4, sharex = True,
                             sharey = True,
                        figsize = (10, 10))
 
for i, axi in enumerate(ax.flat):
    axi.imshow(x_test[i].reshape(imsize).astype(np.float64),
                   cmap = "gray", interpolation = "nearest")
 
    axi.set_title('Label : {}'.format(ypred[i]))
     
# Finally, we test our accuracy in using the following code:
print(metrics.accuracy_score(y_test, ypred) * 100)

Conclusión: 
etiquetar las imágenes para crear los datos de entrenamiento para el aprendizaje automático o la IA no es una tarea difícil. Solo necesitas las técnicas adecuadas para ello. Este artículo mostró un proceso de etiquetado de imágenes desde cero hasta el dominio.