4. Hola mundo con scikit-learn: ¿Es una manzana o una naranja?

4.1 Planteo del problema

Para nuestro primer "Hola mundo" en Machine Learning, vamos a resolver un problema de clasificación muy sencillo: enseñar a una máquina a distinguir entre manzanas y naranjas. El objetivo es que, dadas ciertas características de una fruta, el modelo pueda predecir con la mayor precisión posible a qué categoría pertenece.

Para que la computadora pueda "entender" las frutas, debemos representarlas en un formato numérico. A estas representaciones las llamamos características (en inglés, features). En nuestro caso, hemos elegido dos características simples:

• Peso: El peso de la fruta en gramos.
• Textura: La textura de la piel de la fruta. Para simplificar, hemos asignado un valor numérico a cada categoría: 0 para una textura suave (lisa) y 1 para una textura rugosa.

Además de las características, necesitamos las etiquetas (en inglés, labels), que son las respuestas correctas que queremos que el modelo aprenda. En nuestro caso, las etiquetas son:

• 0: para las manzanas.
• 1: para las naranjas.

Este pequeño conjunto de datos, con sus características y etiquetas, será nuestro conjunto de entrenamiento. A partir de él, el modelo aprenderá los patrones que le permitirán clasificar nuevas frutas.

4.2 Algoritmo elegido: Árbol de decisión

Para este problema, hemos elegido un algoritmo de clasificación llamado árbol de decisión. Este algoritmo es muy popular en Machine Learning, especialmente para principiantes, por su simplicidad y su facilidad de interpretación.

Un árbol de decisión funciona de manera muy similar a como lo haría un ser humano al tomar una decisión. Se basa en una serie de preguntas sobre las características de los datos para llegar a una conclusión. Por ejemplo, el árbol podría aprender a hacer las siguientes preguntas:

1. ¿La textura de la fruta es rugosa (1)?
2. Si la respuesta es sí, entonces es probable que sea una naranja.
3. Si la respuesta es no (es decir, la textura es suave (0)), entonces, ¿cuál es el peso de la fruta?
4. Si el peso es mayor a 140 gramos, podría ser una naranja, de lo contrario, es más probable que sea una manzana.

La gran ventaja de los árboles de decisión es que son modelos de "caja blanca", lo que significa que podemos ver exactamente cómo el modelo está tomando sus decisiones. Esto los hace muy útiles para entender la relación entre las características y las etiquetas de nuestros datos.

4.3 Código de ejemplo

A continuación, se muestra el código completo en Python para entrenar nuestro modelo de árbol de decisión y utilizarlo para predecir el tipo de una nueva fruta. El código está dividido en cinco pasos principales:

# 1) Importar lo esencial
from sklearn.tree import DecisionTreeClassifier

# 2) Datos de entrenamiento
#    Cada fila = [peso, textura]
X = [
    [150, 1],  # naranja
    [170, 1],  # naranja
    [130, 0],  # manzana
    [140, 0],  # manzana
    [160, 1],  # naranja
    [120, 0],  # manzana
]
y = [1, 1, 0, 0, 1, 0]  # 0 = manzana, 1 = naranja

# 3) Crear y entrenar el modelo
modelo = DecisionTreeClassifier(random_state=42)
modelo.fit(X, y)

# 4) Predecir un caso nuevo
nueva_fruta = [[152, 1]]  # fruta de 152 g y rugosa
prediccion = modelo.predict(nueva_fruta)[0]

# 5) Mostrar resultado en lenguaje humano
etiquetas = ["manzana", "naranja"]
print(f"La fruta de 152 g y textura rugosa es probablemente: {etiquetas[prediccion]}")

Salida esperada:

La fruta de 152 g y textura rugosa es probablemente: naranja

Explicación del código:

1. Importar la clase del modelo: Primero, importamos la clase DecisionTreeClassifier de la librería Scikit-learn.
2. Definir los datos de entrenamiento: Creamos dos listas de Python: X para las características y y para las etiquetas. Cada elemento de X es una lista que representa una fruta, y cada elemento de y es la etiqueta correspondiente.
3. Crear y entrenar el modelo: Creamos una instancia de la clase DecisionTreeClassifier y la guardamos en la variable modelo. Luego, llamamos al método fit() para entrenar el modelo con nuestros datos de entrenamiento. El parámetro random_state se utiliza para garantizar que el resultado sea reproducible.
4. Hacer una predicción: Creamos una nueva lista llamada nueva_fruta con las características de una fruta que queremos clasificar. Luego, llamamos al método predict() para obtener la predicción del modelo.
5. Interpretar el resultado: El modelo nos devuelve un número (0 o 1). Para que el resultado sea más fácil de entender, creamos una lista de etiquetas de texto y la utilizamos para mostrar el nombre de la fruta predicha.

4.4 Lo que aprendemos con este ejemplo

Este sencillo ejemplo nos ha permitido dar nuestros primeros pasos en el mundo del Machine Learning y aprender algunos conceptos fundamentales:

• El flujo de trabajo de Scikit-learn: Hemos visto cómo importar un modelo, preparar los datos, entrenar el modelo con el método fit() y hacer predicciones con el método predict(). Este es el flujo de trabajo básico que seguiremos en la mayoría de los proyectos de Machine Learning con Scikit-learn.
• La importancia de la representación de los datos: Hemos aprendido que, para que un modelo de Machine Learning pueda procesar los datos, es necesario representarlos en un formato numérico.
• La diferencia entre características y etiquetas: Hemos entendido la distinción entre las características (los atributos de nuestros datos) y las etiquetas (lo que queremos predecir).
• La interpretabilidad de los modelos: Hemos visto que algunos modelos, como los árboles de decisión, son fáciles de interpretar, lo que nos ayuda a entender cómo funcionan.

4.5 Limitaciones y próximos pasos

Aunque nuestro primer modelo funciona, es importante ser conscientes de sus limitaciones:

• Conjunto de datos muy pequeño: En el mundo real, los conjuntos de datos son mucho más grandes y contienen mucho más ruido.
• Falta de evaluación del modelo: No hemos medido qué tan bueno es nuestro modelo. Para ello, necesitamos dividir nuestros datos en un conjunto de entrenamiento y un conjunto de prueba, y utilizar métricas de evaluación para medir su rendimiento.
• Modelo no optimizado: No hemos intentado optimizar nuestro modelo. Podríamos, por ejemplo, probar diferentes algoritmos o ajustar los parámetros de nuestro árbol de decisión para ver si podemos obtener mejores resultados.

En los próximos capítulos, profundizaremos en estos conceptos y aprenderemos a construir modelos de Machine Learning más robustos y precisos. Veremos cómo trabajar con conjuntos de datos más grandes, cómo evaluar el rendimiento de nuestros modelos y cómo optimizarlos para obtener los mejores resultados posibles.