15 KiB

Raw Permalink Blame History

Introducción a la clasificación

En estas cuatro lecciones, explorarás un enfoque fundamental del aprendizaje automático clásico: la clasificación. Utilizaremos varios algoritmos de clasificación con un conjunto de datos sobre las brillantes cocinas de Asia e India. ¡Espero que tengas hambre!

Celebra las cocinas panasiáticas en estas lecciones. Imagen de Jen Looper

La clasificación es una forma de aprendizaje supervisado que tiene mucho en común con las técnicas de regresión. Si el aprendizaje automático se trata de predecir valores o nombres de cosas utilizando conjuntos de datos, entonces la clasificación generalmente se divide en dos grupos: clasificación binaria y clasificación multiclase.

🎥 Haz clic en la imagen de arriba para ver un video: John Guttag del MIT introduce la clasificación.

Recuerda:

Regresión lineal te ayudó a predecir relaciones entre variables y hacer predicciones precisas sobre dónde caería un nuevo punto de datos en relación con esa línea. Por ejemplo, podrías predecir qué precio tendría una calabaza en septiembre frente a diciembre.
Regresión logística te ayudó a descubrir "categorías binarias": a este precio, ¿esta calabaza es naranja o no naranja?

La clasificación utiliza varios algoritmos para determinar otras formas de asignar una etiqueta o clase a un punto de datos. Trabajemos con estos datos de cocina para ver si, al observar un grupo de ingredientes, podemos determinar su cocina de origen.

Cuestionario previo a la lección

¡Esta lección está disponible en R!

Introducción

La clasificación es una de las actividades fundamentales del investigador de aprendizaje automático y del científico de datos. Desde la clasificación básica de un valor binario ("¿este correo electrónico es spam o no?"), hasta la clasificación y segmentación compleja de imágenes utilizando visión por computadora, siempre es útil poder ordenar datos en clases y hacer preguntas sobre ellos.

Para expresar el proceso de manera más científica, tu método de clasificación crea un modelo predictivo que te permite mapear la relación entre las variables de entrada y las variables de salida.

Problemas binarios vs. multiclase para que los algoritmos de clasificación los manejen. Infografía de Jen Looper

Antes de comenzar el proceso de limpiar nuestros datos, visualizarlos y prepararlos para nuestras tareas de aprendizaje automático, aprendamos un poco sobre las diversas formas en que el aprendizaje automático puede ser utilizado para clasificar datos.

Derivado de estadística, la clasificación utilizando aprendizaje automático clásico utiliza características como smoker, weight y age para determinar la probabilidad de desarrollar X enfermedad. Como técnica de aprendizaje supervisado similar a los ejercicios de regresión que realizaste anteriormente, tus datos están etiquetados y los algoritmos de aprendizaje automático utilizan esas etiquetas para clasificar y predecir clases (o 'características') de un conjunto de datos y asignarlas a un grupo o resultado.

✅ Tómate un momento para imaginar un conjunto de datos sobre cocinas. ¿Qué podría responder un modelo multiclase? ¿Qué podría responder un modelo binario? ¿Qué pasaría si quisieras determinar si una cocina dada probablemente utiliza fenogreco? ¿Qué pasaría si quisieras ver si, dado un regalo de una bolsa de supermercado llena de anís estrellado, alcachofas, coliflor y rábano picante, podrías crear un plato típico indio?

🎥 Haz clic en la imagen de arriba para ver un video. Toda la premisa del programa 'Chopped' es la 'cesta misteriosa', donde los chefs tienen que hacer un plato con una selección aleatoria de ingredientes. ¡Seguramente un modelo de aprendizaje automático habría ayudado!

Hola 'clasificador'

La pregunta que queremos hacer sobre este conjunto de datos de cocina es en realidad una pregunta multiclase, ya que tenemos varias cocinas nacionales potenciales con las que trabajar. Dado un lote de ingredientes, ¿a cuál de estas muchas clases se ajustará el dato?

Scikit-learn ofrece varios algoritmos diferentes para clasificar datos, dependiendo del tipo de problema que quieras resolver. En las próximas dos lecciones, aprenderás sobre varios de estos algoritmos.

Ejercicio - limpia y equilibra tus datos

La primera tarea, antes de comenzar este proyecto, es limpiar y equilibrar tus datos para obtener mejores resultados. Comienza con el archivo en blanco notebook.ipynb en la raíz de esta carpeta.

Lo primero que debes instalar es imblearn. Este es un paquete de Scikit-learn que te permitirá equilibrar mejor los datos (aprenderás más sobre esta tarea en un momento).

Para instalar imblearn, ejecuta pip install, de esta manera:
```
pip install imblearn
```

Importa los paquetes necesarios para importar tus datos y visualizarlos, también importa SMOTE desde imblearn.

import pandas as pd
import matplotlib.pyplot as plt
import matplotlib as mpl
import numpy as np
from imblearn.over_sampling import SMOTE

Ahora estás listo para importar los datos.

La siguiente tarea será importar los datos:
```
df  = pd.read_csv('../data/cuisines.csv')
```
Usar read_csv() leerá el contenido del archivo csv cusines.csv y lo colocará en la variable df.

Verifica la forma de los datos:

df.head()

Las primeras cinco filas se ven así:

|     | Unnamed: 0 | cuisine | almond | angelica | anise | anise_seed | apple | apple_brandy | apricot | armagnac | ... | whiskey | white_bread | white_wine | whole_grain_wheat_flour | wine | wood | yam | yeast | yogurt | zucchini |
| --- | ---------- | ------- | ------ | -------- | ----- | ---------- | ----- | ------------ | ------- | -------- | --- | ------- | ----------- | ---------- | ----------------------- | ---- | ---- | --- | ----- | ------ | -------- |
| 0   | 65         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 1   | 66         | indian  | 1      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 2   | 67         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 3   | 68         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 0      | 0        |
| 4   | 69         | indian  | 0      | 0        | 0     | 0          | 0     | 0            | 0       | 0        | ... | 0       | 0           | 0          | 0                       | 0    | 0    | 0   | 0     | 1      | 0        |

Obtén información sobre estos datos llamando a info():

df.info()

Tu salida se parece a:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 2448 entries, 0 to 2447
Columns: 385 entries, Unnamed: 0 to zucchini
dtypes: int64(384), object(1)
memory usage: 7.2+ MB

Ejercicio - aprendiendo sobre cocinas

Ahora el trabajo comienza a ponerse más interesante. Descubramos la distribución de datos por cocina.

Grafica los datos como barras llamando a barh():
```
df.cuisine.value_counts().plot.barh()
```
Hay un número finito de cocinas, pero la distribución de datos es desigual. ¡Puedes arreglar eso! Antes de hacerlo, explora un poco más.

Descubre cuántos datos hay disponibles por cocina e imprímelos:

thai_df = df[(df.cuisine == "thai")]
japanese_df = df[(df.cuisine == "japanese")]
chinese_df = df[(df.cuisine == "chinese")]
indian_df = df[(df.cuisine == "indian")]
korean_df = df[(df.cuisine == "korean")]

print(f'thai df: {thai_df.shape}')
print(f'japanese df: {japanese_df.shape}')
print(f'chinese df: {chinese_df.shape}')
print(f'indian df: {indian_df.shape}')
print(f'korean df: {korean_df.shape}')

La salida se ve así:

thai df: (289, 385)
japanese df: (320, 385)
chinese df: (442, 385)
indian df: (598, 385)
korean df: (799, 385)

Descubriendo ingredientes

Ahora puedes profundizar en los datos y aprender cuáles son los ingredientes típicos por cocina. Deberías limpiar los datos recurrentes que crean confusión entre cocinas, así que aprendamos sobre este problema.

Crea una función create_ingredient() en Python para crear un marco de datos de ingredientes. Esta función comenzará eliminando una columna poco útil y ordenará los ingredientes por su cantidad:

def create_ingredient_df(df):
    ingredient_df = df.T.drop(['cuisine','Unnamed: 0']).sum(axis=1).to_frame('value')
    ingredient_df = ingredient_df[(ingredient_df.T != 0).any()]
    ingredient_df = ingredient_df.sort_values(by='value', ascending=False,
    inplace=False)
    return ingredient_df

Ahora puedes usar esa función para obtener una idea de los diez ingredientes más populares por cocina.

Llama a create_ingredient() y gráficalo llamando a barh():

thai_ingredient_df = create_ingredient_df(thai_df)
thai_ingredient_df.head(10).plot.barh()

Haz lo mismo para los datos japoneses:

japanese_ingredient_df = create_ingredient_df(japanese_df)
japanese_ingredient_df.head(10).plot.barh()

Ahora para los ingredientes chinos:

chinese_ingredient_df = create_ingredient_df(chinese_df)
chinese_ingredient_df.head(10).plot.barh()

Grafica los ingredientes indios:

indian_ingredient_df = create_ingredient_df(indian_df)
indian_ingredient_df.head(10).plot.barh()

Finalmente, grafica los ingredientes coreanos:

korean_ingredient_df = create_ingredient_df(korean_df)
korean_ingredient_df.head(10).plot.barh()

Ahora, elimina los ingredientes más comunes que crean confusión entre cocinas distintas, llamando a drop():

¡A todos les encanta el arroz, el ajo y el jengibre!
```
feature_df= df.drop(['cuisine','Unnamed: 0','rice','garlic','ginger'], axis=1)
labels_df = df.cuisine #.unique()
feature_df.head()
```

Equilibra el conjunto de datos

Ahora que has limpiado los datos, utiliza SMOTE - "Técnica de Sobremuestreo de Minorías Sintéticas" - para equilibrarlos.

Llama a fit_resample(), esta estrategia genera nuevas muestras mediante interpolación.
```
oversample = SMOTE()
transformed_feature_df, transformed_label_df = oversample.fit_resample(feature_df, labels_df)
```
Al equilibrar tus datos, obtendrás mejores resultados al clasificarlos. Piensa en una clasificación binaria. Si la mayoría de tus datos pertenecen a una clase, un modelo de aprendizaje automático va a predecir esa clase con más frecuencia, simplemente porque hay más datos para ella. El equilibrio de los datos elimina este sesgo.

Ahora puedes verificar los números de etiquetas por ingrediente:

print(f'new label count: {transformed_label_df.value_counts()}')
print(f'old label count: {df.cuisine.value_counts()}')

Tu salida se parece a:

new label count: korean      799
chinese     799
indian      799
japanese    799
thai        799
Name: cuisine, dtype: int64
old label count: korean      799
indian      598
chinese     442
japanese    320
thai        289
Name: cuisine, dtype: int64

Los datos están limpios, equilibrados y muy deliciosos.

El último paso es guardar tus datos equilibrados, incluyendo etiquetas y características, en un nuevo marco de datos que pueda exportarse a un archivo:
```
transformed_df = pd.concat([transformed_label_df,transformed_feature_df],axis=1, join='outer')
```
Puedes echar un último vistazo a los datos usando transformed_df.head() y transformed_df.info(). Guarda una copia de estos datos para usarlos en futuras lecciones:
```
transformed_df.head()
transformed_df.info()
transformed_df.to_csv("../data/cleaned_cuisines.csv")
```
Este nuevo CSV ahora se encuentra en la carpeta de datos raíz.

🚀Desafío

Este currículo contiene varios conjuntos de datos interesantes. Explora las carpetas data y ve si alguna contiene conjuntos de datos que serían apropiados para clasificación binaria o multiclase. ¿Qué preguntas harías sobre este conjunto de datos?

Cuestionario posterior a la lección

Revisión y autoestudio

Explora la API de SMOTE. ¿Para qué casos de uso es más adecuada? ¿Qué problemas resuelve?

Tarea

Explora métodos de clasificación

Descargo de responsabilidad:
Este documento ha sido traducido utilizando el servicio de traducción automática Co-op Translator. Si bien nos esforzamos por garantizar la precisión, tenga en cuenta que las traducciones automatizadas pueden contener errores o imprecisiones. El documento original en su idioma nativo debe considerarse la fuente autorizada. Para información crítica, se recomienda una traducción profesional realizada por humanos. No nos hacemos responsables de malentendidos o interpretaciones erróneas que puedan surgir del uso de esta traducción.

15 KiB Raw Permalink Blame History