Autor: Fernando

Introducción

Hasta este punto del flujo de trabajo de Machine Learning, hemos cubierto la extracción de datos desde diversas fuentes, la limpieza profunda del dataset y el Análisis Exploratorio de Datos (EDA).

Sin embargo, antes de proceder a entrenar cualquier algoritmo, los datos en bruto (raw data) rara vez están listos para ofrecer un rendimiento óptimo. La Ingeniería de Características (Feature Engineering) y la Transformación de Variables constituyen la etapa puente donde adaptamos y refinamos nuestra información para maximizar la precisión de los modelos.

Objetivos de Aprendizaje de este Bloque

• Transformación No Lineal: Entender cómo ciertas operaciones matemáticas modifican la distribución de los datos para mitigar el impacto de valores atípicos y estabilizar la varianza.
• Codificación de Características (Feature Encoding): Dado que los modelos matemáticos de Machine Learning operan estrictamente con variables numéricas, aprenderemos a mapear y traducir variables categóricas (como textos o etiquetas) a representaciones numéricas inteligibles por el modelo.
• Escalado de Características (Feature Scaling): En el mundo real, cada variable viene expresada en su propia escala (por ejemplo, la edad de 0 a 100 frente al salario anual de miles de dólares). Aprenderemos a homogeneizar estos rangos, una propiedad crítica para la convergencia de muchos algoritmos.

Supuestos de los Modelos: El Caso de la Regresión Lineal

La mayoría de los algoritmos de Machine Learning se fundamentan en presunciones teóricas sobre la naturaleza y distribución de los datos. El ejemplo arquetípico es la Regresión Lineal, la cual asume de manera estricta que existe una relación lineal entre las variables predictoras (características de entrada) y la variable objetivo o etiqueta (target).

Estructura de un Modelo Lineal

Para relacionar dos variables predictoras ($x_1$ y $x_2$) con una variable de salida ($y$), planteamos la siguiente ecuación matemática:

$$f(x) = \beta_0 + \beta_1 x_1 + \beta_2 x_2$$

Donde:

• $\beta_0$ representa el intercepto (el valor de $y$ cuando todos los predictores son cero).
• $\beta_1$ y $\beta_2$ son los coeficientes o pesos matemáticos asociados a cada variable.
• El objetivo del algoritmo durante el entrenamiento es aprender los valores óptimos de estos parámetros ($\beta_0, \beta_1, \beta_2$) a partir de los datos históricos.

Ejemplo Práctico: Predicción de Taquilla Financiera (Box Office)

Para visualizar el comportamiento de un modelo lineal en el ámbito de los negocios, consideremos el escenario de predecir la recaudación de ingresos de una película en taquilla ($y$):

• Variable Predictora $x_1$: Presupuesto asignado al reparto (Cast Budget).
• Variable Predictora $x_2$: Presupuesto asignado a la campaña de mercadotecnia (Marketing Budget).

En este diseño, los coeficientes $\beta_1$ y $\beta_2$ cuantificarán matemáticamente el impacto individual de cada presupuesto en la estimación de la recaudación final.

En un sentido estrictamente matemático, la “linealidad” del modelo significa que la función avanza mediante la adición o suma de cada parámetro multiplicado por su respectivo coeficiente.

Flexibilidad mediante la Transformación

Un error común es pensar que si la relación original entre el presupuesto y la taquilla tiene una forma curva o exponencial, la regresión lineal deja de ser útil. La realidad es que podemos aplicar una transformación matemática a los datos de entrada en bruto (por ejemplo, calcular el logaritmo de $x_1$ o elevar $x_2$ al cuadrado).

Al sustituir el valor en bruto por su equivalente transformado, el modelo sigue operando bajo una estructura lineal (una suma de coeficientes multiplicados por la variable), pero ahora es capaz de capturar relaciones complejas y no lineales del mundo real:

$$f(x) = \beta_0 + \beta_1 \cdot \text{transformación}(x_1) + \beta_2 \cdot \text{transformación}(x_2)$$

A partir de la próxima sesión, desglosaremos las técnicas específicas para codificar, transformar y escalar estas variables antes de alimentar nuestros algoritmos.

El Supuesto de Normalidad en los Residuos

En el marco teórico-matemático de la Regresión Lineal, existe un supuesto fundamental: los residuos (o errores) del modelo final deben seguir una distribución normal. Los residuos representan la diferencia entre los valores reales observados y las predicciones calculadas por el algoritmo.

En el mundo real, los datos en bruto rara vez son perfectos. Con frecuencia, tanto las variables predictoras como la variable objetivo presentan sesgos significativos:

• Sesgo Positivo (Right-Skewed): Los datos se concentran en valores bajos y la distribución presenta una “cola” larga hacia la derecha (por ejemplo, los salarios de una empresa o el presupuesto de las películas).
• Sesgo Negativo (Left-Skewed): Los datos se concentran en valores altos y la cola se extiende hacia la izquierda.

Si alimentamos un modelo de regresión lineal con datos crudos fuertemente sesgados, el algoritmo tendrá dificultades para optimizar sus parámetros de forma correcta, rompiendo el supuesto de normalidad en los errores. Las transformaciones de variables modifican la escala geométrica de los datos para estabilizar su varianza y aproximarlos a una distribución normal.

Técnicas de Transformación No Lineal

Para corregir el sesgo e inducir normalidad, la librería NumPy y el ecosistema científico de Python proveen varias funciones matemáticas clave:

• Logaritmo Natural (np.log): Comprime los valores extremadamente altos y expande los valores bajos. Es la herramienta por excelencia para mitigar el sesgo positivo.
• Logaritmo Más Uno (np.log1p): Dado que matemáticamente el logaritmo de cero no está definido ($\log(0) \to -\infty$), si tu dataset contiene ceros reales, utilizar np.log romperá el código. La función log1p calcula automáticamente $\log(x + 1)$, solucionando este problema de forma segura.
• Transformación Box-Cox (scipy.stats.boxcox): Es una metodología más compleja y automatizada. A través de un parámetro lambda ($\lambda$), evalúa el dataset y encuentra de manera matemática la transformación de potencia exacta requerida para convertir una distribución sesgada en una normal.

El Efecto Visual de la Transformación Logarítmica

Al aplicar un logaritmo a un conjunto de datos con sesgo positivo, la distribución se redistribuye simétricamente:

Modelado de Rendimientos Decrecientes y Polinomios

Además de corregir la distribución, las transformaciones permiten que un algoritmo lineal capture dinámicas no lineales de la realidad económica y comercial.

Rendimientos Decrecientes (Diminishing Returns)

Consideremos la relación entre el presupuesto de una película ($x$) y la recaudación en taquilla ($y$). Un incremento de 5 millones de dólares en el presupuesto de una película independiente puede triplicar sus ganancias; sin embargo, ese mismo aumento en una superproducción multimillonaria apenas alterará su recaudación final.

Esta estructura curva de saturación representa un rendimiento decreciente. Aunque la relación original no es una línea recta, es perfectamente lineal respecto al logaritmo de los datos:

$$f(x) = \beta_0 + \beta_1 \cdot \log(x)$$

El modelo resultante sigue considerándose una regresión lineal porque la ecuación mantiene una combinación lineal (sumas y multiplicaciones directas) de los coeficientes respecto a las características, aun cuando la característica en sí sea $\log(x)$ en lugar de $x$.

Características Polinomiales (Polynomial Features)

Si los datos describen curvas más complejas con puntos de inflexión (donde la tendencia cambia de dirección), podemos elevar el grado de nuestras variables mediante polinomios.

• Grado 2 (Cuadrática): Al incorporar el término $x^2$, el modelo adquiere la flexibilidad de una parábola. Tiene un punto de inflexión (la curva sube y luego baja).$$f(x) = \beta_0 + \beta_1 x + \beta_2 x^2$$Ejemplo: En niveles extremos, un presupuesto exageradamente alto podría generar pérdidas netas debido a la imposibilidad de recuperar la inversión en taquilla.
• Grado 3 o Superior (Cúbica): Al incorporar $x^3$, el modelo puede capturar dos puntos de inflexión (la curva sube, baja y vuelve a subir).

Implementación de Transformaciones Polinomiales con Scikit-Learn

Para automatizar la creación de términos cuadráticos o cúbicos sin necesidad de calcular las potencias columna por columna de forma manual, la librería Scikit-Learn ofrece el módulo PolynomialFeatures.

En Scikit-Learn, estas herramientas operan bajo el patrón de diseño de objetos transformadores, los cuales ejecutan dos pasos fundamentales:

1. .fit(): El objeto analiza la estructura del dataset de entrada para aprender las dimensiones y variables disponibles.
2. .transform(): Utiliza las reglas aprendidas en el entrenamiento para generar un nuevo conjunto de datos con las columnas polinomiales calculadas.

Código de Implementación en Python

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# 1. Supongamos que tenemos una matriz de datos original (X_data)
# Para este ejemplo, una columna con valores del 1 al 3
X_data = np.array([[1], [2], [3]])

# 2. Instanciar la clase especificando el grado deseado (ej. Grado 2)
# Por defecto, incluye también el término de sesgo (columna de unos)
polyFeat = PolynomialFeatures(degree=2, include_bias=False)

# 3. Ajustar el transformador a los datos para que aprenda las dimensiones
polyFeat.fit(X_data)

# 4. Transformar la característica original 'x' en el nuevo espacio 'x, x^2'
X_poly = polyFeat.transform(X_data)

# Visualización del cambio estructural
print("Datos Originales:\n", X_data)
print("\nDatos Polinomiales (x, x^2):\n", X_poly)

from sklearn.preprocessing import PolynomialFeatures
import numpy as np

# 1. Supongamos que tenemos una matriz de datos original (X_data)
# Para este ejemplo, una columna con valores del 1 al 3
X_data = np.array([[1], [2], [3]])

# 2. Instanciar la clase especificando el grado deseado (ej. Grado 2)
# Por defecto, incluye también el término de sesgo (columna de unos)
polyFeat = PolynomialFeatures(degree=2, include_bias=False)

# 3. Ajustar el transformador a los datos para que aprenda las dimensiones
polyFeat.fit(X_data)

# 4. Transformar la característica original 'x' en el nuevo espacio 'x, x^2'
X_poly = polyFeat.transform(X_data)

# Visualización del cambio estructural
print("Datos Originales:\n", X_data)
print("\nDatos Polinomiales (x, x^2):\n", X_poly)

Análisis del Output

Al imprimir la matriz generada X_poly, observamos cómo el transformador expandió automáticamente el espacio de características:

Datos Originales:
 [[1]
  [2]
  [3]]

Datos Polinomiales (x, x^2):
 [[1. 1.]
  [2. 4.]
  [3. 9.]]

Datos Originales:
 [[1]
  [2]
  [3]]

Datos Polinomiales (x, x^2):
 [[1. 1.]
  [2. 4.]
  [3. 9.]]

La primera columna conserva los valores originales ($x$) y la segunda columna almacena de manera automática sus valores elevados al cuadrado ($x^2$). A partir de este momento, la matriz X_poly está lista para ser introducida en un algoritmo de regresión lineal estándar, permitiéndole trazar curvas y capturar patrones de negocio sofisticados.

Preparación de Variables: Codificación y Escalado

La selección de variables consiste en elegir el conjunto óptimo de características (features) que formarán parte de nuestro modelo. Sin embargo, antes de poder alimentar cualquier algoritmo, la mayoría de estas características deben ser transformadas. Los modelos matemáticos de Machine Learning no entienden de texto ni de etiquetas cualitativas; operan bajo matrices numéricas estrictas.

Más allá de las transformaciones logarítmicas y polinomiales, existen dos pilares fundamentales en la ingeniería de características:

• Codificación (Encoding): El proceso de convertir características no numéricas (cualitativas, categóricas u ordinales) en valores numéricos.
• Escalado (Scaling): La homogeneización del rango de las variables numéricas para que compartan una escala comparable y ningún predictor domine a otro por su magnitud matemática.

El método idóneo para transformar nuestros datos dependerá enteramente de la naturaleza intrínseca de la característica, dividiéndose principalmente en dos grandes tipologías:

                      Tipos de Datos Categóricos
                                  │
         ┌────────────────────────┴────────────────────────┐
         ▼                                                 ▼
  Datos Nominales                                   Datos Ordinales
(Sin orden jerárquico)                            (Con orden intrínseco)
Ej: Colores (Rojo, Azul)                          Ej: Rangos (Bajo, Medio, Alto)
Ej: Estado (Casado, Soltero)                      Ej: Temperatura (Frío, Templado, Caliente)

                      Tipos de Datos Categóricos
                                  │
         ┌────────────────────────┴────────────────────────┐
         ▼                                                 ▼
  Datos Nominales                                   Datos Ordinales
(Sin orden jerárquico)                            (Con orden intrínseco)
Ej: Colores (Rojo, Azul)                          Ej: Rangos (Bajo, Medio, Alto)
Ej: Estado (Casado, Soltero)                      Ej: Temperatura (Frío, Templado, Caliente)

Estrategias de Codificación Categórica

Codificación Binaria (Binary Encoding)

Es la técnica de mapeo más simple y se aplica de forma exclusiva a variables dicotómicas, es decir, aquellas que solo pueden tomar dos valores posibles. Consiste en transformar la condición de la variable en un estado booleano de $0$ o $1$ (Falso o Verdadero).

• Ejemplos: * ¿Está casado? $\to$ No = 0, Sí = 1
  • Género $\to$ Masculino = 0, Femenino = 1
  • Estado de transacción $\to$ Fallida = 0, Exitosa = 1

Codificación One-Hot (One-Hot Encoding)

Cuando nos enfrentamos a variables de tipo nominal con múltiples categorías sin orden implícito (como el color o el país de residencia), la codificación binaria simple se queda corta. Si asignáramos números correlativos ($1, 2, 3$) a una columna llamada Color (Rojo=1, Azul=2, Verde=3), el modelo interpretaría erróneamente que el Verde vale tres veces más que el Rojo, o que el Azul está “en medio” de ambos, distorsionando las operaciones matemáticas del algoritmo.

Para solucionar esto, One-Hot Encoding expande la columna original en múltiples columnas binarias independientes (tantas como categorías existan). Cada nueva columna representa una categoría exclusiva: si el registro original pertenecía a esa categoría se le asigna un $1$, y al resto un $0$.

Ejemplo de Transformación:

Supongamos que tenemos un DataFrame con una sola columna llamada Color:

Tras aplicar la transformación One-Hot Encoding, nuestro conjunto de datos se reestructura de la siguiente manera:

Codificación Ordinal (Ordinal Encoding)

A diferencia de los datos nominales, los datos ordinales sí poseen una jerarquía u orden integrado en su significado. En estos escenarios, convertir las etiquetas en números enteros secuenciales es completamente válido y deseable, ya que preserva la progresión de la variable.

• Ejemplo: Niveles de riesgo o prioridad $\to$ Bajo = 1, Medio = 2, Alto = 3.

El Dilema de la Distancia Geométrica: Al aplicar una codificación ordinal de $1, 2, 3$, le estamos indicando implícitamente al algoritmo que la distancia matemática entre Bajo y Medio ($2 – 1 = 1$) es exactamente la misma que entre Medio y Alto ($3 – 2 = 1$). En el mundo real, esta equidistancia métrica podría no existir.

Criterios de Selección: ¿One-Hot u Ordinal?

A medida que avances en tus proyectos de ciencia de datos, te enfrentarás al dilema de cuál técnica elegir para tus variables ordenadas. Tienes dos opciones principales:

1. Mantener el orden (Ordinal Encoding): Utilizas una sola columna con enteros ($1, 2, 3$). La ventaja es que conservas la noción de progresión y jerarquía, y el dataset no crece en tamaño. La desventaja es que asumes distancias matemáticas artificiales entre categorías.
2. Privilegiar la separación (One-Hot Encoding): Rompes la variable en múltiples columnas binarias. La ventaja es que eliminas el supuesto de las distancias fijas, permitiendo al modelo tratar cada estado de forma independiente. La desventaja es que pierdes por completo la información del orden secuencial y aumentas la dimensionalidad del dataset.

No existe una respuesta única; experimentar con ambas estrategias en tus Jupyter Notebooks y evaluar el impacto directo en la precisión del modelo te dará el criterio necesario para tomar la mejor decisión en cada caso de negocio.

Fundamentos del Escalado de Características (Feature Scaling)

El escalado de características es una etapa crítica en el procesamiento de datos que consiste en ajustar los rangos de nuestras variables continuas para que compartan una magnitud matemática comparable.

En los conjuntos de datos del mundo real, las variables vienen expresadas en unidades y magnitudes completamente dispares. Por ejemplo, si analizamos el éxito comercial de un artículo, podríamos tener:

• Precio del producto: Con valores que oscilan entre $0$ y $10$ dólares.
• Puntos de venta distribuidos: Con valores que oscilan entre $10,000$ y $50,000$ tiendas.

Si alimentamos un modelo directamente con estas métricas en bruto, la disparidad de magnitudes distorsionará los cálculos de muchos algoritmos, haciendo que una variable eclipse por completo a la otra debido a su tamaño numérico y no a su verdadera importancia analítica.

El Impacto de la Magnitud en los Algoritmos de Distancia

Para entender por qué la diferencia de escalas representa un problema crítico, analicemos el comportamiento de los algoritmos basados en proximidad geométrica, como K-Nearest Neighbors (KNN) o los modelos de clasificación médica.

Imaginemos un sistema diseñado para identificar pacientes en situación de riesgo. El algoritmo mapea a los individuos en un plano bidimensional y determina el diagnóstico de un nuevo paciente evaluando la distancia geométrica hacia sus “vecinos” más cercanos (es decir, si se sitúa cerca de pacientes de alto riesgo o cerca de pacientes sanos).

Un Ejemplo Extremo: Edad en Segundos vs. Operaciones Quirúrgicas

Para ilustrar la distorsión, supongamos que registramos dos variables para evaluar el riesgo clínico de un paciente:

1. Número de cirugías previas: Un indicador crítico donde una variación de $1$ a $10$ cirugías denota un cambio drástico en la fragilidad del paciente. (Rango de variación: $9$ unidades).
2. Edad del paciente: Supongamos que, por un error de diseño o de captura, la edad se mide en segundos en lugar de años.

Dado que un solo año equivale aproximadamente a $31.5$ millones de segundos, la diferencia de edad entre dos personas de 20 y 21 años se traducirá matemáticamente en una distancia de $31,500,000$ unidades.

La Consecuencia Matemática:

Al calcular la distancia geométrica (como la distancia euclidiana), el algoritmo procesará estos valores numéricos fríos:

• La brecha crítica de cirugías se pondera como un cambio insignificante de $9$ unidades.
• La diferencia de un solo año de edad se pondera como un abismo de $31.5$ millones de unidades.

Como resultado, el modelo agrupará a los pacientes basándose únicamente en que tengan exactamente la misma edad, ignorando por completo el número de cirugías. La escala ha sesgado la geometría del problema, anulando el poder predictivo del historial médico.

Estrategias Comunes de Escalado

Para solucionar este sesgo, aplicamos transformaciones matemáticas que homogeneizan las magnitudes de las características. A continuación, se detallan los tres enfoques más utilizados en Machine Learning:

[Image comparing Standard Scaling, Min-Max Scaling, and Robust Scaling on a dataset with outliers]

Escalado Estándar (Standard Scaling / Z-Score)

Este método transforma las características para que tengan una media igual a $0$ y una desviación estándar igual a $1$, expresando cada valor en términos de cuántas desviaciones estándar se aleja de la media central.

La fórmula matemática para estandarizar un valor $x$ es:

$$z = \frac{x – \mu}{\sigma}$$

Donde $\mu$ es la media de la columna y $\sigma$ es la desviación estándar.

• Consideración: El Escalado Estándar es susceptible a la influencia de valores atípicos (outliers). Si un dataset contiene un registro con un valor extremadamente alto, este arrastrará la media hacia arriba y expandirá artificialmente la desviación estándar, afectando la compresión del resto de los datos normales.

Escalado Min-Max (Min-Max Scaling / Normalization)

Esta técnica transforma los datos para confinarlos estrictamente dentro de un rango acotado, por lo general entre $0$ y $1$.

La fórmula para calcular la normalización Min-Max es:

$$x_{\text{scaled}} = \frac{x – x_{\text{min}}}{x_{\text{max}} – x_{\text{min}}}$$

Ejemplo Numérico de Prototipado:

Supongamos una columna donde el valor mínimo ($x_{\text{min}}$) es $3$ y el valor máximo ($x_{\text{max}}$) es $100$.

• Si evaluamos el valor mínimo $3$:$$\frac{3 – 3}{100 – 3} = \frac{0}{97} = 0$$
• Si evaluamos un valor intermedio como $40$:$$\frac{40 – 3}{100 – 3} = \frac{37}{97} \approx 0.381$$
• Si evaluamos el valor máximo $100$:$$\frac{100 – 3}{100 – 3} = \frac{97}{97} = 1$$
• Consideración Crítica: El escalado Min-Max es altamente sensible a los valores atípicos. Si todos los registros de una columna se encuentran entre $0$ y $10$, pero existe un único registro atípico con el valor de $10,000$, ese registro se convertirá en el $x_{\text{max}}$. Al aplicar la fórmula, todos los datos reales del negocio (entre $0$ y $10$) se verán compactados y “aplastados” en una fracción microscópica cercana a $0$, perdiendo su variabilidad y detalle visual.

Escalado Robusto (Robust Scaling)

El escalado robusto se diseñó específicamente para contrarrestar la debilidad ante los valores atípicos. En lugar de utilizar la media y la desviación estándar (sensibles a extremos) o los valores máximos y mínimos absolutos, utiliza estadísticas de posición robustas: la mediana y el Rango Intercuartílico (IQR).

La fórmula matemática es:

$$x_{\text{scaled}} = \frac{x – \text{mediana}}{\text{IQR}}$$

Donde el IQR representa la distancia entre el percentil 75 ($Q_3$) y el percentil 25 ($Q_1$), concentrando el $50\%$ central de los datos.

• Ventaja: Al basarse en la masa central de la distribución, la presencia de valores atípicos extremos en los bordes no sesga ni deforma el escalado de los datos limpios.
• Desventaja: A diferencia de Min-Max, el Escalado Robusto no garantiza que los límites finales queden confinados estrictamente entre $0$ y $1$.

Matriz de Decisiones en Ingeniería de Características

Para cerrar este bloque de preparación de datos, consolidaremos las técnicas estudiadas estructurándolas según la naturaleza de cada tipo de variable. En el desarrollo práctico con Python, la librería Scikit-Learn (sklearn.preprocessing) y la librería Pandas proveen todo el arsenal de funciones necesarias para manipular estas características de forma eficiente.

A continuación, se presenta el mapa de ruta definitivo para transformar tus datos antes de la fase de modelado:

Implementación de Herramientas según el Tipo de Dato

Variables Numéricas Continuas (Escalado)

Cuando tus datos presentan escalas dispares (como pesos, salarios o distancias), importamos los transformadores directos desde el módulo de preprocesamiento de Scikit-Learn:

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Inicialización de los motores de escalado
escalador_estandar = StandardScaler()  # Media 0, Dev. Std 1
escalador_minmax = MinMaxScaler()      # Rango acotado [0, 1]
escalador_robusto = RobustScaler()     # Basado en Mediana e IQR (antiatípicos)

from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler

# Inicialización de los motores de escalado
escalador_estandar = StandardScaler()  # Media 0, Dev. Std 1
escalador_minmax = MinMaxScaler()      # Rango acotado [0, 1]
escalador_robusto = RobustScaler()     # Basado en Mediana e IQR (antiatípicos)

Variables Nominales o Categóricas (Codificación sin Orden)

Para variables como el estado civil (Casado, Soltero) o colores (Rojo, Azul, Verde), requerimos representaciones binarias:

• LabelBinarizer: Ideal para transformar variables de texto puramente binarias (dos categorías) en ceros y unos.
• OneHotEncoder / pd.get_dummies(): Crean columnas separadas para cada categoría presente. pd.get_dummies() de Pandas es ampliamente utilizada por su simplicidad para prototipar directamente sobre DataFrames.

import pandas as pd
from sklearn.preprocessing import OneHotEncoder

# Alternativa rápida en Pandas para One-Hot Encoding
df_codificado = pd.get_dummies(df, columns=["columna_color"])

import pandas as pd
from sklearn.preprocessing import OneHotEncoder

# Alternativa rápida en Pandas para One-Hot Encoding
df_codificado = pd.get_dummies(df, columns=["columna_color"])

Variables Ordinales (Codificación con Orden)

Para registrar progresiones jerárquicas (como Bajo = 1, Medio = 2, Alto = 3), usamos OrdinalEncoder. Es fundamental pasar explícitamente el orden correcto de las categorías al transformador; de lo contrario, el algoritmo asignará los números enteros de forma alfabética o aleatoria, destruyendo la lógica del negocio.

from sklearn.preprocessing import OrdinalEncoder

# Definir explícitamente el orden jerárquico de los factores
orden_categorias = [["Bajo", "Medio", "Alto"]]
encoder_ordinal = OrdinalEncoder(categories=orden_categorias)

from sklearn.preprocessing import OrdinalEncoder

# Definir explícitamente el orden jerárquico de los factores
orden_categorias = [["Bajo", "Medio", "Alto"]]
encoder_ordinal = OrdinalEncoder(categories=orden_categorias)

Resumen del Módulo: Preparación de Datos

Hemos cubierto los pilares fundamentales para transformar datos crudos en tensores matemáticos optimizados:

1. Transformaciones No Lineales: Vimos cómo las funciones logarítmicas (np.log1p) suavizan el sesgo positivo y cómo las transformaciones polinomiales expanden la flexibilidad de nuestros modelos permitiéndoles trazar curvas mediante combinaciones lineales.
2. Codificación Categórica: Aprendimos a aislar variables cualitativas sin orden mediante esquemas One-Hot para evitar falsas métricas de vecindad, y a estructurar variables jerárquicas mediante codificadores ordinales.
3. Escalado Estadístico: Analizamos visualmente el riesgo de que variables con rangos numéricos masivos eclipsen por completo a métricas críticas en algoritmos basados en distancias (como KNN), y estudiamos cómo la estandarización y normalización mitigan este problema.

Introducción al Análisis Exploratorio de Datos (EDA)

Una vez que hemos completado la fase de limpieza e higiene de nuestras tablas, avanzamos hacia el siguiente pilar fundamental del flujo de trabajo de Machine Learning: el Análisis Exploratorio de Datos (o EDA, por sus siglas en inglés: Exploratory Data Analysis).

Podemos definir el EDA como la conversación inicial que un científico de datos mantiene con un conjunto de datos antes de tomar decisiones técnicas o algoritmos. Es la fase de reconocimiento donde se examina de forma exhaustiva la información para resumir sus características estructurales básicas, utilizando herramientas tanto estadísticas como de visualización gráfica.

¿Por qué es vital realizar un buen EDA?

• Validación de Sanidad: Permite determinar de forma matemática si los datos recopilados realmente tienen sentido lógico o si, por el contrario, exigen una fase adicional de limpieza profunda, reestructuración o recolección de nuevas variables.
• Descubrimiento de Patrones: Facilita la detección temprana de tendencias, correlaciones ocultas y anomalías espaciales en la muestra. En el entorno corporativo, los hallazgos puros derivados de un EDA riguroso suelen aportar tanto o más valor estratégico para el negocio que las propias predicciones matemáticas finales del modelo de Machine Learning.

Herramientas y Técnicas de Análisis en el EDA

El análisis exploratorio se divide operativamente en dos grandes familias de técnicas que se complementan entre sí:

Técnicas Estadísticas (Resúmenes Numéricos)

Consisten en extraer las métricas de tendencia central, dispersión y asociación matemática de las variables. Entre los estadísticos fundamentales destacan:

• Media y Mediana: Para ubicar el centro de gravedad numérico de los datos.
• Mínimos y Máximos: Para establecer los rangos operativos de las variables.
• Correlaciones: Para medir el grado de dependencia lineal entre las distintas columnas del dataset.

Técnicas Visuales (Gráficos)

Los ojos humanos procesan los patrones geométricos con mayor rapidez que las tablas de números. El EDA se apoya en tres representaciones icónicas:

• Histogramas: Para observar la distribución probabilística y la densidad de una variable numérica.
• Gráficos de Dispersión (Scatter Plots): Ideales para proyectar la relación o correlación entre dos variables continuas e identificar agrupaciones naturales (clusters).
• Diagramas de Caja (Box Plots): Para evaluar la dispersión cuartílica y geolocalizar valores atípicos (outliers).

El Ecosistema Tecnológico en Python: Durante el proceso de manipulación de tablas y cálculo de resúmenes estadísticos, la librería estándar por excelencia es Pandas. Para la generación de la capa gráfica y visual, el ecosistema se apoya firmemente en Matplotlib y Seaborn.

Caso Práctico: Análisis de Perfiles de Candidatos (Job Applicants)

Para comprender cómo interactúan estas métricas en un entorno de negocio real, consideremos un dataset corporativo diseñado para evaluar las características de un grupo de aspirantes a puestos de trabajo:

• Aplicación de la Media: Podemos calcular el promedio de las puntuaciones obtenidas en las entrevistas y desglosarlo por ciudad o función laboral. Esto permite contextualizar el rendimiento de un candidato específico frente a la media exacta de sus competidores directos en su misma región geográfica.
• Aplicación de la Moda (Valor Máximo de Frecuencia): Útil para analizar campos de texto libre o materiales de solicitud. Al extraer la moda de los textos de los currículums, la empresa puede identificar cuáles son las palabras clave o habilidades técnicas que más se repiten entre los aspirantes.
• Aplicación de Correlaciones: Mediante el cruce estadístico de la columna de “Años de Experiencia” frente a los resultados de las “Evaluaciones Técnicas”, la organización puede evaluar inmediatamente si existe una relación lineal ascendente (a mayor experiencia, mayor puntuación técnica) antes de proceder a la fase de modelado predictivo.

Muestreo de Datos (Sampling) en DataFrames

En muchas ocasiones, los científicos de datos se enfrentan a volúmenes masivos de información que saturan la memoria del sistema o ralentizan los tiempos de cómputo de los algoritmos. Para solucionar esto de manera eficiente, se recurre al muestreo aleatorio (random sampling).

Razones Técnicas para Muestrear

1. Optimización Computacional: Reducir el dataset original a una muestra representativa acelera los análisis exploratorios y prototipados rápidos sin degradar la calidad de las conclusiones.
2. División de Datos (Train/Test Split): Es la base para entrenar un modelo en una porción de datos aleatoria y reservar otra muestra completamente independiente para evaluar su capacidad de generalización en fases de testeo.
3. Preservación de Proporciones (Muestreo Estratificado): Supongamos que trabajamos con un dataset médico para detectar una enfermedad grave que solo padece el 1% de la población mundial. Si tomamos una muestra aleatoria simple muy pequeña, corremos el riesgo de generar un subconjunto donde no haya ningún individuo enfermo o, por el contrario, donde estén sobrerrepresentados. El muestreo estratificado (stratified sampling) asegura que la muestra mantenga exactamente la proporción del 1% del evento de interés.

Implementación de muestreo con Pandas (.sample)

La librería Pandas proporciona el método integrado .sample(), diseñado específicamente para extraer filas aleatorias de un objeto DataFrame de forma óptima.

El siguiente bloque de código demuestra cómo extraer una muestra aleatoria fija de cinco filas, asegurando que no existan registros repetidos mediante el argumento replace=False (comportamiento por defecto), y seleccionando únicamente un segmento de columnas mediante indexación implícita con .iloc:

import pandas as pd

# Suponiendo que 'df' es nuestro DataFrame cargado (ej. el dataset Iris)
# 1. Extracción de una muestra aleatoria de 5 registros sin reemplazo
muestra_df = df.sample(n=5, replace=False)

# 2. Segmentación: seleccionar todas las filas extraídas (:) 
# y restringir a las últimas tres columnas (-3:)
resultado_final = muestra_df.iloc[:, -3:]

# 3. Visualización del resultado
print(resultado_final)

import pandas as pd

# Suponiendo que 'df' es nuestro DataFrame cargado (ej. el dataset Iris)
# 1. Extracción de una muestra aleatoria de 5 registros sin reemplazo
muestra_df = df.sample(n=5, replace=False)

# 2. Segmentación: seleccionar todas las filas extraídas (:) 
# y restringir a las últimas tres columnas (-3:)
resultado_final = muestra_df.iloc[:, -3:]

# 3. Visualización del resultado
print(resultado_final)

Análisis del Output Resultante

Al ejecutar el código sobre una base de datos biológica como Iris, la consola devolverá una estructura limpia con índices aleatorios y únicamente las últimas tres columnas indexadas:

Plaintext

     petal_length    petal_width        species
34            1.5            0.2         setosa
112           5.5            2.1      virginica
78            4.5            1.5     versicolor
14            1.2            0.2         setosa
143           5.9            2.3      virginica

     petal_length    petal_width        species
34            1.5            0.2         setosa
112           5.5            2.1      virginica
78            4.5            1.5     versicolor
14            1.2            0.2         setosa
143           5.9            2.3      virginica

• Explicación del Indexado: El operador -3: indica a Python que empiece a contar desde la tercera columna empezando por el final de la tabla (en este caso, petal_length) y avance hasta el término del DataFrame, logrando un aislamiento preciso de los datos que queremos inspeccionar visualmente.

6. El Ecosistema de Librerías de Visualización en Python

Para llevar a cabo un Análisis Exploratorio de Datos (EDA) efectivo, Python ofrece tres herramientas principales de visualización que interactúan entre sí de forma jerárquica:

                  Ecosistema de Visualización en Python
                  
                         ┌───────────────────┐
                         │      Seaborn      │  <- Estética avanzada y
                         │ (High-level API)  │     gráficos estadísticos
                         └─────────┬─────────┘
                                   │ (Construido sobre)
                         ┌─────────▼─────────┐
                         │     Matplotlib    │  <- Motor gráfico base
                         │    (Core Engine)  │     y control absoluto
                         └─────────▲─────────┘
                                   │ (Wrapper de)
                         ┌─────────┴─────────┐
                         │   Pandas .plot()  │  <- Prototipado rápido
                         │  (Quick Wrapper)  │     directo desde tablas
                         └───────────────────┘

• Matplotlib (matplotlib.pyplot): Es la librería fundacional y el motor gráfico estándar de Python. Ofrece un control absoluto y microscópico sobre cada elemento del gráfico (ejes, etiquetas, colores, fuentes). Su gran flexibilidad la convierte en la base de la que dependen las demás librerías.
• Pandas Plotting: Consiste en una interfaz integrada (wrapper) construida directamente sobre Matplotlib. Permite generar gráficos de manera rápida mediante sintaxis abreviada directamente desde un DataFrame (ej. df.plot()). Es ideal para inspecciones rápidas sobre la marcha, aunque carece de la flexibilidad fina de Matplotlib.
• Seaborn: Una librería de alto nivel desarrollada sobre Matplotlib y diseñada específicamente para el análisis estadístico. Viene configurada con estilos visuales modernos por defecto y proporciona funciones simplificadas para trazar gráficos complejos (como mapas de calor, correlaciones cruzadas o modelos lineales) que requerirían decenas de líneas de código en Matplotlib puro.

Efecto de Integración: Cuando importas Seaborn (import seaborn as sns) en tu entorno de trabajo, este reconfigura automáticamente las preferencias estéticas globales de Matplotlib. Así, cualquier gráfico posterior que generes usando código puro de Matplotlib adoptará el formato limpio y estilizado característico de Seaborn.

Gráficos Fundamentales con Matplotlib

Para inicializar el motor de gráficos de Matplotlib en entornos interactivos como Jupyter Notebooks, es una buena práctica incluir la directiva mágica %matplotlib inline. Esto asegura que los gráficos se rendericen e integren directamente debajo de las celdas de código.

Gráfico de Dispersión Básico (Scatter Plot)

Se utiliza para examinar visualmente la relación espacial entre dos variables numéricas continuas. Para configurarlo como un diagrama de puntos puro, debemos anular el trazado de líneas continuo mediante el parámetro ls="" (line style) y definir un marcador circular con marker="o".

import matplotlib.pyplot as plt
%matplotlib inline

# Trazado de dispersión entre longitud y ancho del sépalo
plt.plot(df["sepal_length"], df["sepal_width"], ls="", marker="o")
plt.xlabel("Sepal Length")
plt.ylabel("Sepal Width")
plt.title("Relación Sépalo")
plt.show()

import matplotlib.pyplot as plt
%matplotlib inline

# Trazado de dispersión entre longitud y ancho del sépalo
plt.plot(df["sepal_length"], df["sepal_width"], ls="", marker="o")
plt.xlabel("Sepal Length")
plt.ylabel("Sepal Width")
plt.title("Relación Sépalo")
plt.show()

Gráficos Multicapa con Leyendas

Matplotlib permite superponer múltiples series de datos sobre el mismo lienzo de forma acumulativa. Cada llamada consecutiva a plt.plot() dibuja una nueva capa de información antes de renderizar la figura final con plt.show().

# Capa 1: Datos de Sépalo (Azul por defecto)
plt.plot(df["sepal_length"], df["sepal_width"], ls="", marker="o", label="Sépalo")

# Capa 2: Datos de Pétalo (Verde/Naranja automático)
plt.plot(df["petal_length"], df["petal_width"], ls="", marker="o", label="Pétalo")

# Activar la caja de leyendas utilizando las etiquetas 'label'
plt.legend()
plt.title("Comparativa de Sépalo vs Pétalo")
plt.show()

# Capa 1: Datos de Sépalo (Azul por defecto)
plt.plot(df["sepal_length"], df["sepal_width"], ls="", marker="o", label="Sépalo")

# Capa 2: Datos de Pétalo (Verde/Naranja automático)
plt.plot(df["petal_length"], df["petal_width"], ls="", marker="o", label="Pétalo")

# Activar la caja de leyendas utilizando las etiquetas 'label'
plt.legend()
plt.title("Comparativa de Sépalo vs Pétalo")
plt.show()

Histogramas de Distribución

Para analizar la distribución probabilística de una sola columna numérica, utilizamos la función plt.hist(). El parámetro bins determina en cuántos intervalos o “barras” se fragmenta el rango total de los datos.

# Histograma con 25 contenedores de frecuencia
plt.hist(df["sepal_length"], bins=25)
plt.xlabel("Longitud del Sépalo")
plt.ylabel("Frecuencia")
plt.show()

# Histograma con 25 contenedores de frecuencia
plt.hist(df["sepal_length"], bins=25)
plt.xlabel("Longitud del Sépalo")
plt.ylabel("Frecuencia")
plt.show()

Personalización Avanzada y Enfoque Orientado a Objetos

Cuando se requiere construir cuadros de mando (dashboards) complejos o gráficos con modificaciones estructurales estrictas, la API orientada a objetos de Matplotlib mediante plt.subplots() es la opción recomendada. Esta función separa el lienzo general (fig) del recuadro o sistema de ejes de dibujo (ax).

El siguiente script genera un gráfico de barras horizontales (ax.barh) para evaluar los primeros 10 registros de la muestra, aplicando desfases matemáticos en las etiquetas para centrarlas perfectamente en el medio de cada barra:

import numpy as np

# 1. Crear la estructura orientada a objetos (Lienzo e Hilera de ejes)
fig, ax = plt.subplots(figsize=(6, 4))

# 2. Generar índices de posición (0 a 9) y graficar barras horizontales
posiciones = np.arange(10)
ax.barh(posiciones, df["sepal_width"].iloc[:10], align="center")

# 3. Ajustar los ticks para que queden centrados en cada barra
# Desfasamos el rango para colocar el marcador visual en el medio geométrico
ax.set_yticks(posiciones)
ax.set_yticklabels(range(1, 11))

# 4. Inyección de metadatos de texto mediante el objeto 'ax'
ax.set(xlabel="Ancho del Sépalo (cm)", ylabel="Índice del Candidato", title="Análisis de Muestra Corta")
plt.show()

import numpy as np

# 1. Crear la estructura orientada a objetos (Lienzo e Hilera de ejes)
fig, ax = plt.subplots(figsize=(6, 4))

# 2. Generar índices de posición (0 a 9) y graficar barras horizontales
posiciones = np.arange(10)
ax.barh(posiciones, df["sepal_width"].iloc[:10], align="center")

# 3. Ajustar los ticks para que queden centrados en cada barra
# Desfasamos el rango para colocar el marcador visual en el medio geométrico
ax.set_yticks(posiciones)
ax.set_yticklabels(range(1, 11))

# 4. Inyección de metadatos de texto mediante el objeto 'ax'
ax.set(xlabel="Ancho del Sépalo (cm)", ylabel="Índice del Candidato", title="Análisis de Muestra Corta")
plt.show()

Visualización Rápida con Sintaxis de Pandas

Si los datos ya están estructurados en un DataFrame de Pandas, podemos encadenar operaciones de agregación estadística (como .groupby()) directamente con el método de asistencia visual .plot(), reduciendo la cantidad de código necesario.

Python

# 1. Agrupar por especie y calcular el promedio de todas las métricas
resumen_especies = df.groupby("species").mean()

# 2. Trazar un gráfico de barras directamente desde el DataFrame agrupado
resumen_especies.plot(
    kind="bar",
    color=["red", "blue", "black", "green"],
    fontsize=10,
    figsize=(4, 4)
)

plt.ylabel("Promedio (cm)")
plt.title("Métricas Promedio por Especie")
plt.show()

# 1. Agrupar por especie y calcular el promedio de todas las métricas
resumen_especies = df.groupby("species").mean()

# 2. Trazar un gráfico de barras directamente desde el DataFrame agrupado
resumen_especies.plot(
    kind="bar",
    color=["red", "blue", "black", "green"],
    fontsize=10,
    figsize=(4, 4)
)

plt.ylabel("Promedio (cm)")
plt.title("Métricas Promedio por Especie")
plt.show()

Visualizaciones Avanzadas con Seaborn

Gráfico de Pares (Pair Plot)

Es una de las funciones más potentes de Seaborn para el análisis exploratorio. sns.pairplot() genera de forma automática una matriz de gráficos cruzados entre todas las variables numéricas del dataset.

• Fuera de la diagonal: Muestra gráficos de dispersión (scatter plots) para evaluar correlaciones entre pares de variables.
• En la diagonal: Al cruzar una variable consigo misma, el algoritmo la sustituye automáticamente por curvas de densidad o histogramas de distribución.
• El parámetro hue: Segmenta y colorea los puntos según una variable categórica (como la especie), lo que permite identificar visualmente si las clases son linealmente separables.

import seaborn as sns

# Matriz de correlación visual segmentada por especies
sns.pairplot(data=df, hue="species", size=2.5)
plt.show()

import seaborn as sns

# Matriz de correlación visual segmentada por especies
sns.pairplot(data=df, hue="species", size=2.5)
plt.show()

Gráfico de Densidad Hexagonal (Hexbin Joint Plot)

Cuando trabajamos con miles de registros, un gráfico de dispersión tradicional sufre de saturación (overplotting), impidiendo ver dónde se concentran realmente los puntos. El gráfico sns.jointplot con el parámetro kind="hex" agrupa los puntos espaciales en celdas hexagonales: cuanto más oscuro es el hexágono, mayor es la densidad de registros en esa zona. Además, incluye las distribuciones marginales en los márgenes superior derecho.

# Gráfico conjunto de densidad hexagonal con distribuciones marginales
sns.jointplot(data=df, x="sepal_length", y="sepal_width", kind="hex")
plt.show()

# Gráfico conjunto de densidad hexagonal con distribuciones marginales
sns.jointplot(data=df, x="sepal_length", y="sepal_width", kind="hex")
plt.show()

Segmentación por Rejillas de Facetas (Facet Grid)

El objeto FacetGrid permite subdividir el dataset en función de una o más variables categóricas, creando subgráficos independientes (facets) organizados en columnas o filas. Esto facilita la comparación directa de distribuciones entre diferentes categorías.

# 1. Definir la cuadrícula estructural basada en la columna de especies
grid = sns.FacetGrid(data=df, col="species", margin_titles=True)

# 2. Mapear un histograma de la variable deseada en cada una de las facetas
grid.map(plt.hist, "sepal_width", bins=10)
plt.show()

# 1. Definir la cuadrícula estructural basada en la columna de especies
grid = sns.FacetGrid(data=df, col="species", margin_titles=True)

# 2. Mapear un histograma de la variable deseada en cada una de las facetas
grid.map(plt.hist, "sepal_width", bins=10)
plt.show()

Visualización Avanzada: Integración de Pandas y Seaborn

El Análisis Exploratorio de Datos (EDA) se potencia cuando combinamos la estructuración rápida de datos con capacidades de visualización avanzadas. A continuación, analizaremos cómo automatizar y sofisticar nuestros gráficos utilizando la sintaxis nativa de Pandas y el motor estadístico de Seaborn.

Sintaxis de Trazado de Pandas con Agrupaciones (.groupby)

Por defecto, al llamar al método .plot() en un DataFrame de Pandas, la librería intenta trazar un gráfico de líneas. Sin embargo, cuando se combina con funciones de agregación estadística como .groupby(), podemos mapear resúmenes multivariables rápidamente.

Si quisiéramos analizar el promedio de las dimensiones del dataset Iris (longitud y ancho de pétalos y sépalos) para cada una de las especies, podemos definir colores personalizados y un tamaño de lienzo compacto de $4 \times 4$ pulgadas mediante el argumento figsize:

Python

# Agrupar por la columna objetivo y calcular la media de cada característica
df_resumen = df.groupby("species").mean()

# Generar gráfico de barras con parámetros personalizados
df_resumen.plot(
    kind="bar", 
    color=["red", "blue", "black", "green"], 
    fontsize=10, 
    figsize=(4, 4)
)

# Agrupar por la columna objetivo y calcular la media de cada característica
df_resumen = df.groupby("species").mean()

# Generar gráfico de barras con parámetros personalizados
df_resumen.plot(
    kind="bar", 
    color=["red", "blue", "black", "green"], 
    fontsize=10, 
    figsize=(4, 4)
)

Al ejecutar este bloque, el eje $X$ mostrará las categorías (setosa, versicolor, virginica) y las barras representarán las medias de cada característica, diferenciadas según la paleta de colores inyectada.

Matrices de Correlación Visual: sns.pairplot

Una de las utilidades más potentes de Seaborn para el análisis exploratorio es el Pair Plot (gráfico de pares). Mediante una sola línea de código, sns.pairplot() construye una matriz tridimensional que cruza todas las variables numéricas del DataFrame entre sí.

• Fuera de la diagonal: Se generan gráficos de dispersión (scatter plots) automáticos que revelan la relación espacial y la correlación entre dos variables distintas.
• En la diagonal: Dado que cruzar una variable consigo misma generaría una línea recta sin valor analítico, Seaborn la sustituye de forma inteligente por un histograma o una curva de densidad para mostrar la distribución univariable.
• El argumento hue: Al igualar este parámetro a una columna categórica (como hue="species"), el algoritmo segmenta y colorea los datos por clases. Esto permite identificar de un vistazo si las poblaciones o perfiles de negocio son linealmente separables.

import seaborn as sns
import matplotlib.pyplot as plt

# Importar Seaborn e implementar el gráfico de pares global
sns.pairplot(data=df, hue="species", height=2.5)
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt

# Importar Seaborn e implementar el gráfico de pares global
sns.pairplot(data=df, hue="species", height=2.5)
plt.show()

💡 Caso de Uso en Negocios: Esta misma lógica se aplica al entorno corporativo. Si sustituyéramos las variables biológicas por métricas como Inversión en Publicidad (Ad Spend) y Retorno de Ingresos (Revenue), el pair plot nos mostraría instantáneamente la dispersión y efectividad de las campañas, además de la distribución de las ventas en el mismo lienzo.

Gráficos de Densidad Hexagonal: sns.jointplot

Cuando un conjunto de datos contiene miles de registros, los gráficos de dispersión tradicionales sufren de saturación de puntos (overplotting). Los marcadores se superponen unos sobre otros creando masas de color uniformes donde es imposible determinar dónde se concentra la mayoría de los datos.

Para resolver este problema, Seaborn ofrece el gráfico de agrupación hexagonal (Hexbin plot), invocable mediante sns.jointplot() con el argumento kind="hex".

Características del Gráfico Hexagonal:

1. Contenedores Geométricos: El espacio bidimensional se divide en hexágonos regulares que actúan como “contenedores de frecuencia”.
2. Escala de Densidad: Las celdas hexagonales se colorean con una escala de intensidad. Los hexágonos más oscuros denotan una densidad de datos muy alta (zonas de solapamiento frecuente), mientras que los más claros representan registros aislados.
3. Márgenes de Distribución: En las secciones superior y derecha del gráfico, se renderizan de forma automática los histogramas univariables de los ejes $X$ e $Y$, permitiendo un doble diagnóstico en una sola mirada.

Python

# Trazado conjunto con densidad de hexágonos e histogramas marginales
sns.jointplot(data=df, x="sepal_length", y="sepal_width", kind="hex")
plt.show()

# Trazado conjunto con densidad de hexágonos e histogramas marginales
sns.jointplot(data=df, x="sepal_length", y="sepal_width", kind="hex")
plt.show()

Segmentación Estructural mediante sns.FacetGrid

Cuando el objetivo del análisis es aislar por completo el comportamiento de una variable según subcategorías específicas (similar a realizar operaciones analíticas en paralelo), la herramienta ideal es FacetGrid.

Una rejilla de facetas (FacetGrid) toma un criterio de segmentación (por ejemplo, las distintas especies) y genera un lienzo independiente para cada una, ordenándolas en columnas. Luego, mediante el método .map(), podemos “inyectar” el tipo de gráfico que deseamos replicar en cada contenedor.

# 1. Inicializar la cuadrícula estructurando las columnas según la especie
grid = sns.FacetGrid(data=df, col="species", margin_titles=True)

# 2. Mapear un histograma del ancho del sépalo en cada una de las facetas creadas
grid.map(plt.hist, "sepal_width", bins=10)
plt.show()

# 1. Inicializar la cuadrícula estructurando las columnas según la especie
grid = sns.FacetGrid(data=df, col="species", margin_titles=True)

# 2. Mapear un histograma del ancho del sépalo en cada una de las facetas creadas
grid.map(plt.hist, "sepal_width", bins=10)
plt.show()

Si quisiéramos evaluar una característica diferente bajo la misma estructura, simplemente reconfiguramos el mapeo sobre el objeto:

# 3. Reutilizar la cuadrícula para analizar la longitud del sépalo por separado
grid_longitud = sns.FacetGrid(data=df, col="species", margin_titles=True)
grid_longitud.map(plt.hist, "sepal_length", bins=10)
plt.show()

# 3. Reutilizar la cuadrícula para analizar la longitud del sépalo por separado
grid_longitud = sns.FacetGrid(data=df, col="species", margin_titles=True)
grid_longitud.map(plt.hist, "sepal_length", bins=10)
plt.show()

Conclusiones del Módulo EDA

Con estas metodologías concluimos la base teórica del Análisis Exploratorio de Datos:

• Métricas y Gráficos en Sintonía: El EDA combina la precisión numérica de los resúmenes estadísticos (medias, medianas, correlaciones) con el impacto visual de los histogramas y diagramas de dispersión.
• Ecosistema Jerárquico: Recordamos que Matplotlib actúa como el motor flexible de bajo nivel, Pandas como la vía de prototipado veloz y Seaborn como la solución óptima para análisis estadísticos complejos y estéticos.
• Muestreo Estratificado: Al enfrentarnos a datos masivos o desbalanceados, el submuestreo controlado protege la fidelidad de las proporciones poblacionales.

La Importancia de la Limpieza de Datos (Data Cleaning)

Una vez recuperada la información de nuestras fuentes, entramos en una de las fases más críticas y que más tiempo consume en el flujo de trabajo: la limpieza de datos.

En el ámbito del Machine Learning rige una máxima fundamental: “Garbage-In, Garbage-Out” (Si entra basura, sale basura). Un modelo predictivo es un reflejo matemático directo de los datos con los que ha sido entrenado; si los datos de entrada son erróneos, ruidosos o están mal formateados, las predicciones resultantes serán completamente deficientes y carecerán de fiabilidad.

Cuando alimentamos un algoritmo con observaciones (rows) deficientes, distorsionamos de forma inmediata la relación matemática real entre nuestras características (features) y la variable objetivo (target).

El impacto de los errores en los componentes del modelo

• Etiquetas (Labels): Si las variables de salida que intentamos predecir contienen errores humanos, el modelo aprenderá patrones falsos. Consideremos el histórico repositorio de imágenes ImageNet: si los encargados de etiquetar las fotos clasifican erróneamente un gato como un perro, el algoritmo asimilará características visuales equivocadas, frustrando la precisión final en producción.
• Algoritmos: Los programas informáticos estiman sus parámetros asumiendo por defecto que los datos representan fielmente la realidad. No tienen la capacidad intuitiva de saber si un dato es un error de registro o un evento real.
• Características (Features): Imagina un modelo de detección de fraude bancario donde los importes de las transacciones o las ubicaciones geográficas se registren de manera incorrecta. Un simple desfase en los dígitos puede hacer que una transacción legítima sea clasificada como fraude, o peor aún, que un patrón delictivo real pase desapercibido.

Desafíos Corporativos en la Gestión de Datos

A pesar de que los líderes empresariales priorizan el uso de la analítica avanzada, la gestión de la infraestructura de datos plantea tres grandes problemáticas operativas:

1. Escasez de Datos (Lack of Data): Para que un modelo de Machine Learning generalice correctamente, necesita un volumen mínimo de datos relevantes. Si no existen, la organización debe reestructurar sus métodos de captura o adquirir bases de datos de terceros.
2. Exceso de Datos e Infoxicación: Paradójicamente, poseer demasiada información fragmentada en decenas de servidores, nubes híbridas e infraestructuras on-premises satura la capacidad analítica. El problema deja de ser estadístico y se convierte en un reto de ingeniería de datos: recolectar, centralizar y unificar bajo un mismo criterio antes de programar el modelo.
3. Calidad Deficiente de los Datos: Las encuestas del sector revelan que el 60% de los líderes empresariales se enfrentan a serias dificultades para gestionar la calidad de sus datos. La Inteligencia Artificial no puede desplegarse en una organización si sus cimientos informáticos carecen de un control de calidad riguroso.

Anatomía de los Datos Corruptos o “Sucios”

¿A qué nos referimos exactamente cuando afirmamos que un conjunto de datos está “sucio” (messy data)? Principalmente a cinco escenarios:

• Datos Duplicados: Introducen un peso artificial y sesgan el algoritmo. En el caso del fraude con tarjetas de crédito, si una misma transacción fraudulenta se duplica por error 200 veces en la tabla, el modelo hipertrofiará la importancia de esas características específicas, memorizando un patrón artificial.
• Texto Inconsistente y Errores Tipográficos: Las computadoras son literales. Para un algoritmo, los registros "Madrid", "madrid", "Madrid " o "Madrdi", son cuatro categorías de ciudades completamente distintas, fragmentando la potencia predictiva de la característica.
• Datos Faltantes (Missing Data): La ausencia de registros es inevitable en el mundo real. Sin embargo, una concentración excesiva de valores nulos en columnas clave anula su utilidad, obligándonos a descartar indicadores que podrían haber sido proyectores altamente determinantes.
• Valores Atípicos (Outliers): Valores anómalos o extremos que se desvían drásticamente de la tendencia general de la muestra. Pueden sesgar las medias estadísticas y descolocar las líneas de regresión de los modelos, ocultando la verdadera estructura matemática subyacente.
• Conflictos de Sincronización (Sourcing): Desajustes temporales o de formato que ocurren al fusionar datos extraídos de sistemas operativos dispares (por ejemplo, cruzar bases de datos transaccionales con registros de interacciones web).

Estrategias para el Tratamiento de Datos Duplicados

Frente a las observaciones repetidas, el científico de datos no debe aplicar una política de eliminación automatizada sin antes realizar un análisis de contexto. La naturaleza del problema dicta la regla de limpieza:

¿Los duplicados representan la realidad?
 ├── SÍ (Ej. Mediciones físicas idénticas en Iris con pocos decimales) ──> MANTENER observaciones.
 └── NO (Ej. Mismo archivo de imagen subido múltiples veces) ───────────> ELIMINAR mediante filtrado.

¿Los duplicados representan la realidad?
 ├── SÍ (Ej. Mediciones físicas idénticas en Iris con pocos decimales) ──> MANTENER observaciones.
 └── NO (Ej. Mismo archivo de imagen subido múltiples veces) ───────────> ELIMINAR mediante filtrado.

• Cuándo mantener los duplicados: En conjuntos de datos científicos o de mediciones biológicas (como el dataset Iris), es perfectamente factible encontrar dos flores con las mismas dimensiones de sépalo y pétalo si el instrumento de medición solo registra dos decimales. Al ser una ocurrencia real de la naturaleza, ambas observaciones deben conservarse para no alterar la distribución de probabilidad real.
• Cuándo eliminar los duplicados: En tareas de visión artificial o clasificación de imágenes, tener copias binarias exactamente iguales del mismo archivo de imagen no aporta información nueva al proceso de aprendizaje. Al contrario, satura el almacenamiento y sesga los pesos de la red neuronal, por lo que deben ser eliminados.

Buenas Prácticas en el Laboratorio de Datos

Antes de realizar cualquier purga o eliminación física de registros, es fundamental aplicar filtros exploratorios en Pandas para inspeccionar visualmente la estructura de los duplicados. Como regla de seguridad en ingeniería de datos, nunca destruyas o sobreescribas la base de datos original; mantén siempre una copia intacta de los datos crudos por si requieres auditar o recuperar información esencial en las fases avanzadas del proyecto.

Gestión de Valores Faltantes (Missing Data)

Los modelos de Machine Learning son ecuaciones matemáticas que requieren un valor numérico o categórico en cada celda para operar; no aceptan celdas en blanco o vacías porque carecen de información para realizar cálculos. Por lo tanto, el científico de datos debe aplicar políticas consistentes para asegurar que cada característica (feature) y etiqueta (label) contengan información válida.

Existen tres estrategias principales para resolver la ausencia de datos:

                          Estrategias para Valores Faltantes
                                          │
         ┌────────────────────────────────┼────────────────────────────────┐
         ▼                                ▼                                ▼
Eliminación Completa             Imputación de Datos               Enmascaramiento (Masking)
(Descarte de filas/columnas)     (Sustitución estadística)        (Creación de nueva categoría)

                          Estrategias para Valores Faltantes
                                          │
         ┌────────────────────────────────┼────────────────────────────────┐
         ▼                                ▼                                ▼
Eliminación Completa             Imputación de Datos               Enmascaramiento (Masking)
(Descarte de filas/columnas)     (Sustitución estadística)        (Creación de nueva categoría)

Eliminación Completa (Deletion)

Consiste en descartar filas (observaciones) o columnas (características) enteras que contengan nulos. Si asumimos que todas las variables del dataset son útiles para el negocio, la práctica común se reduce a eliminar las filas afectadas.

• Pros: Es una solución rápida y directa. Limpia el conjunto de datos de inmediato sin necesidad de inventar o “adivinar” un valor de reemplazo artificial.
• Contras: Si la ausencia de datos se extiende por muchas filas, corremos el riesgo de perder un volumen crítico de información. Además, si los datos faltan por un sesgo sistemático (por ejemplo, un sensor que falla siempre a altas temperaturas), eliminar esos registros sesgará por completo el entrenamiento del modelo.

B. Imputación de Datos (Imputation)

Consiste en rellenar las celdas vacías utilizando métricas estadísticas calculadas a partir del resto de la muestra, como la media (promedio), la mediana o algoritmos predictivos más complejos (como K-Nearest Neighbors).

• Pros: Evita la pérdida de observaciones valiosas, manteniendo la integridad del volumen del dataset para el entrenamiento del algoritmo.
• Contras: Introduce un nuevo nivel de incertidumbre y ruido. El modelo entrenará asumiendo que esos valores estimados son certezas reales del mundo real, lo que puede debilitar su precisión en producción.

C. Enmascaramiento (Masking)

Esta técnica consiste en transformar los valores faltantes en una categoría explícita e independiente (por ejemplo, crear la categoría "Desconocido" o "No aportado"). Se aplica bajo la premisa de que la ausencia del dato en sí misma constituye una señal de información útil.

• Ejemplo Práctico: Imaginemos una encuesta de satisfacción telefónica donde la última pregunta queda sistemáticamente en blanco. Esto puede indicar que los usuarios tienden a colgar el teléfono exhaustos antes de finalizar. Registrar esa celda vacía con la etiqueta "Colgó antes del fin" aporta un valor analítico real para el modelo.
• Pros: Mantiene intactas las filas y columnas sin alterar artificialmente los valores numéricos mediante promedios.
• Contras: Añade incertidumbre al asumir homogéneamente que todos los datos faltantes de esa columna ocurren por la misma razón exacta.

Identificación y Tratamiento de Valores Atípicos (Outliers)

Un valor atípico u outlier es una observación que se desvía de forma drástica y anormal respecto a la tendencia general del resto de los datos. Por lo general, representan anomalías o errores de captura que distorsionan el fenómeno real que el modelo intenta asimilar.

El peligro de ignorar los outliers

Supongamos que analizamos las ventas semanales de un comercio local. La inmensa mayoría de los registros oscila en un rango normal entre $10$ y $50$. Sin embargo, debido a un error tipográfico en el sistema, una semana registra un valor de $3000$.

Si el modelo predictivo se basa en promedios estadísticos elementales para proyectar el futuro:

• Sin el outlier, el promedio real rondaría los $30$.
• Al introducir el valor de $3000$ en un conjunto de datos pequeño, la media se dispara artificialmente a un rango de $200$ o $300$.

Como resultado, el modelo generará predicciones sobredimensionadas que no reflejan el comportamiento histórico real del negocio.

Nota de Contexto Analítico: Aunque muchos outliers deben ser depurados para no sesgar el algoritmo, algunos valores atípicos son altamente informativos. Un pico de $3000$ en ventas podría no ser un error, sino el reflejo de una campaña de marketing viral masiva. Investigar la raíz de un outlier suele ofrecer conclusiones estratégicas más valiosas que analizar los datos estandarizados.

Detección Visual de Outliers

El análisis exploratorio gráfico es el primer mecanismo para capturar anomalías espaciales en nuestras variables. Las librerías de visualización en Python (como Seaborn) ofrecen herramientas directas para este fin:

• Histogramas y Gráficos de Densidad (sns.displot): Permiten evaluar la distribución de la frecuencia de los datos. Un bloque de barras aislado y muy alejado de la gran “campana” central delata la presencia de outliers.
• Diagramas de Caja o Boxplots (sns.boxplot): Es el estándar gráfico por excelencia para identificar atípicos. Representa visualmente la mediana, los cuartiles y dibuja los valores anómalos como puntos aislados fuera de unos límites calculados conocidos como “bigotes”.

Implementación en Python (Seaborn)

import seaborn as sns
import matplotlib.pyplot as plt

# Generación de un gráfico de distribución (Histograma)
sns.displot(data=df, x="unemployment", bins=30)
plt.show()

# Generación de un diagrama de caja para detectar puntos atípicos
sns.boxplot(data=df, x="unemployment")
plt.show()

import seaborn as sns
import matplotlib.pyplot as plt

# Generación de un gráfico de distribución (Histograma)
sns.displot(data=df, x="unemployment", bins=30)
plt.show()

# Generación de un diagrama de caja para detectar puntos atípicos
sns.boxplot(data=df, x="unemployment")
plt.show()

Detección Matemática: El Criterio del Rango Intercuartílico ($IQR$)

Para identificar y aislar matemáticamente estos puntos sin depender exclusivamente de la interpretación visual, aplicamos el método estadístico del Rango Intercuartílico ($IQR$).

El $IQR$ mide la dispersión del 50% central de los datos y se calcula restando el percentil 75 ($Q_3$) menos el percentil 25 ($Q_1$):

$$IQR = Q_3 – Q_1$$

A partir de ahí, establecemos un límite inferior y superior matemáticos (“los bigotes del boxplot”). Cualquier dato que se encuentre fuera de estas fronteras se define formalmente como un outlier:

$$\text{Límite Mínimo} = Q_1 – 1.5 \times IQR$$

$$\text{Límite Máximo} = Q_3 + 1.5 \times IQR$$

Desarrollo del Algoritmo en Python con NumPy

El siguiente bloque de código automatiza el cálculo de los límites matemáticos y utiliza técnicas de comprensión de listas (list comprehension) para extraer la lista exacta de valores que superan la frontera superior de desempleo:

Python

import numpy as np

# 1. Extracción de los percentiles estructurales de la columna
q25 = np.percentile(df["unemployment"], 25)  # Cuartil 1 (Q1)
q75 = np.percentile(df["unemployment"], 75)  # Cuartil 3 (Q3)

# 2. Cálculo del Rango Intercuartílico
iqr = q75 - q25

# 3. Definición matemática de las fronteras de tolerancia
limite_min = q25 - 1.5 * iqr
limite_max = q75 + 1.5 * iqr

# 4. Filtrado y aislamiento de los outliers superiores
outliers = [x for x in df["unemployment"] if x > limite_max]

print(f"Valores atípicos detectados por encima del límite ({limite_max}): {outliers}")

import numpy as np

# 1. Extracción de los percentiles estructurales de la columna
q25 = np.percentile(df["unemployment"], 25)  # Cuartil 1 (Q1)
q75 = np.percentile(df["unemployment"], 75)  # Cuartil 3 (Q3)

# 2. Cálculo del Rango Intercuartílico
iqr = q75 - q25

# 3. Definición matemática de las fronteras de tolerancia
limite_min = q25 - 1.5 * iqr
limite_max = q75 + 1.5 * iqr

# 4. Filtrado y aislamiento de los outliers superiores
outliers = [x for x in df["unemployment"] if x > limite_max]

print(f"Valores atípicos detectados por encima del límite ({limite_max}): {outliers}")

Además del método $IQR$, otra estrategia avanzada para detectar valores atípicos en modelos predictivos consiste en el análisis de residuos (evaluando residuos estandarizados, eliminados o studentizados), una técnica matemática que estudia la desviación entre las predicciones del modelo y los valores reales para capturar observaciones rebeldes. En la próxima sección profundizaremos en estas técnicas de diagnóstico avanzado.

Detección Avanzada de Outliers: El Análisis de Residuos

Además de los métodos gráficos y estadísticos tradicionales como el $IQR$, el Machine Learning nos ofrece una perspectiva alternativa para detectar anomalías mediante el uso de residuos.

¿Qué es un residuo?

En el contexto de un modelo predictivo (como una regresión), un residuo es la diferencia matemática entre el valor real observado y el valor estimado o predicho por nuestro algoritmo:

$$\text{Residuo} = \text{Valor Real} – \text{Valor Predicho}$$

Los residuos cuantifican de forma directa el fallo del modelo. Si un punto del dataset arroja un residuo inusualmente grande, significa que las reglas generales que el modelo ha aprendido no sirven para explicar esa observación concreta. Por lo tanto, ese registro se convierte en un candidato inmediato a valor atípico.

Enfoques Estadísticos Basados en Residuos

Para evaluar adecuadamente estos desvíos sin importar la escala de la variable, recurrimos a tres tratamientos matemáticos:

1. Residuos Estandarizados (Standardized Residuals): Consiste en tomar el residuo bruto y dividirlo por su error estándar. Esta normalización es vital para dar contexto. Por ejemplo, cometer un error de $4$ unidades es insignificante si nuestra variable objetivo se mueve en un rango de millones de dólares, pero es un fallo crítico si la variable oscila únicamente entre $0$ y $5$.
2. Residuos Eliminados (Deleted Residuals): El procedimiento consiste en extraer físicamente una observación del conjunto de datos, reentrenar el modelo predictivo sin ella y evaluar qué proyecta el nuevo algoritmo para ese punto específico. Si al retirar la observación el comportamiento general del modelo experimenta un cambio drástico, se confirma que dicho punto ejercía una influencia desproporcionada (típica de un outlier).
3. Residuos Studentizados (Studentized Residuals): También denominados residuos studentizados externamente. Es una técnica híbrida avanzada que toma los residuos eliminados explicados en el punto anterior y los estandariza dividiéndolos por su error estándar calculado. Al aislar por completo la influencia del punto sospechoso durante el cálculo de la varianza, es uno de los criterios matemáticos más robustos para diagnosticar observaciones rebeldes en producción.

Estrategias Operativas ante la Detección de un Outlier

Una vez identificado un valor atípico mediante criterios matemáticos o de residuos, el científico de datos dispone de cinco vías de actuación. La elección de una técnica sobre otra dependerá estrictamente del contexto de negocio y del diseño de los datos.

Resumen del Bloque de Limpieza de Datos

Con esta sección cerramos el módulo estratégico de preparación y depuración de datos:

• Misión Crítica: La limpieza de datos determina el techo de precisión de cualquier sistema de Inteligencia Artificial. Ignorar este paso conduce inevitablemente al efecto Garbage-In, Garbage-Out.
• Tratamiento Criterioso: La gestión de duplicados, valores faltantes y puntos atípicos jamás debe automatizarse a ciegas. Cada decisión debe sopesar la pérdida de volumen informativo frente a la introducción de incertidumbre o sesgos artificiales.
• Diagnóstico Avanzado: Herramientas como los diagramas de caja, el rango intercuartílico ($IQR$) y las métricas de residuos transforman la limpieza en un proceso matemático auditable y reproducible.

Una vez que hemos garantizado la higiene analítica de nuestras tablas, estamos listos para avanzar hacia la siguiente etapa del flujo de trabajo: el Análisis Exploratorio de Datos (EDA), donde buscaremos correlaciones ocultas antes de entrenar nuestros primeros modelos de Machine Learning.

El viaje de la ciencia de datos comienza siempre con la obtención de materia prima. Para construir cualquier modelo predictivo o extraer conclusiones analíticas, primero debemos dominar la ingeniería de adquisición de datos.

En este artículo, exploraremos las estrategias esenciales para recuperar información desde múltiples orígenes —incluyendo bases de datos relacionales (SQL), no relacionales (NoSQL), interfaces de programación (APIs) y almacenes en la nube—, centrándonos en la ingesta práctica de los formatos de archivo más extendidos del sector: CSV y JSON.

La Ingesta de Archivos CSV (Comma Separated Values)

El formato CSV (Valores Separados por Comas) es uno de los estándares más antiguos y populares para el intercambio de datos estructurados. Consiste en archivos de texto plano organizados en filas, donde cada dato o valor se encuentra delimitado convencionalmente por una coma.

A través de la librería Pandas en Python, la lectura e integración de estos archivos en estructuras tabulares de memoria conocidas como DataFrames se resuelve con apenas unas pocas líneas de código.

Implementación básica en Python

Para cargar un archivo CSV en nuestro entorno de desarrollo (como un Jupyter Notebook), se sigue el flujo de importación y definición de rutas estándar:

import pandas as pd

# Definición de la ruta del archivo estructurado
file_path = "data/iris_data.csv"

# Ingesta del archivo mediante la función nativa de Pandas
data = pd.read_csv(file_path)

# Visualización de las primeras 5 observaciones en el notebook
print(data.iloc[0:5])

import pandas as pd

# Definición de la ruta del archivo estructurado
file_path = "data/iris_data.csv"

# Ingesta del archivo mediante la función nativa de Pandas
data = pd.read_csv(file_path)

# Visualización de las primeras 5 observaciones en el notebook
print(data.iloc[0:5])

Al ejecutar estas instrucciones utilizando un conjunto de datos como el histórico Iris, Pandas procesará la estructura de texto y nos devolverá una representación tabular limpia con sus respectivas columnas de características y objetivo:

Parámetros avanzados para el control de lectura

En la práctica, los archivos CSV del mundo real rara vez vienen perfectamente formateados. La función pd.read_csv cuenta con una serie de argumentos cruciales para mitigar inconsistencias durante la ingesta:

• Manejo de delimitadores alternativos (sep): No todos los archivos mal llamados “CSV” usan comas. Si nos enfrentamos a un archivo separado por tabuladores (TSV), podemos modificar el separador usando la sintaxis de escape de Python para tabulaciones (\t):

df = pd.read_csv(file_path, sep='\t')

df = pd.read_csv(file_path, sep='\t')

• Manejo de espacios en blanco (delim_whitespace): Cuando los datos se separan mediante espacios en blanco variables o irregulares en lugar de un carácter fijo, habilitar este parámetro le indica a Pandas que trate cualquier secuencia de espacios como un único delimitador válido.
• Gestión de cabeceras erróneas o ausentes (header): Muchos archivos del mundo real incluyen comentarios o filas vacías en la parte superior. Con el argumento header, podemos especificar explícitamente qué número de fila debe ser interpretado como el nombre de las columnas.
• Asignación manual de nombres (names): Si el archivo carece por completo de una fila de títulos, podemos pasar una lista de cadenas con los nombres deseados a través del parámetro names. Es obligatorio asegurar que la longitud de esta lista coincida exactamente con el número de columnas físicas del archivo.
• Tratamiento personalizado de valores nulos (na_values): En ocasiones, los errores de captura o la ausencia de datos se representan con cadenas específicas (como “NA”, “N/A”, o códigos numéricos anómalos como 99). Pasar estos patrones al parámetro na_values fuerza a Pandas a convertirlos automáticamente en valores nulos reales (NaN), facilitando su posterior limpieza estadística.

Gestión de Archivos JSON (JavaScript Object Notation)

El formato JSON (Notación de Objetos JavaScript) es el estándar por excelencia para la transferencia de información semiestructurada en la web. Es la estructura nativa en la que opera la inmensa mayoría de las APIs modernas y las bases de datos no relacionales (NoSQL).

Su propósito es almacenar información de una manera organizada, jerárquica y fácil de leer tanto para humanos como para máquinas. Conceptualmente, la estructura de un archivo JSON es idéntica a la de los diccionarios de Python, basada en un sistema de pares clave-valor (key-value).

Si analizamos una única fila de datos mapeada en formato JSON, la clave actúa como el nombre de la característica (columna) y el valor representa el dato de esa celda en particular:

{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2,
  "species": "setosa"
}

{
  "sepal_length": 5.1,
  "sepal_width": 3.5,
  "petal_length": 1.4,
  "petal_width": 0.2,
  "species": "setosa"
}

Lectura y Escritura de JSON en Pandas

La manipulación de estas estructuras se realiza de manera simétrica a los archivos planos mediante funciones optimizadas de entrada y salida:

• Lectura de datos (pd.read_json): Para cargar el archivo semiestructurado en memoria y transformarlo en un DataFrame plano, basta con invocar la función pasando la ruta correspondiente:

df_json = pd.read_json("data/iris_data.json")

df_json = pd.read_json("data/iris_data.json")

• Escritura de datos (to_json): Una vez que hayamos concluido los procesos de transformación o limpieza sobre nuestras variables en memoria, podemos exportar el DataFrame de vuelta a un archivo JSON físico definiendo el nombre de salida:

data.to_json("data/output_cleaned.json")

data.to_json("data/output_cleaned.json")

Resolución de problemas de orientación espacial (orient)

A diferencia de las tablas rígidas de un CSV, un archivo JSON puede estructurarse u orientarse de múltiples formas (por registros, por columnas, por índices o dividido en listas independientes).

Si al importar un archivo JSON los datos se cargan de forma desalineada o el intérprete arroja un error de lectura, el primer paso obligado es revisar la documentación del parámetro orient. Probar diferentes configuraciones de este argumento (como split, records, index, columns o values) le explicará a Pandas la dirección exacta en la que se organizaron las claves dentro del fichero, asegurando una conversión exitosa a filas y columnas.

Conexión e Ingesta desde Bases de Datos SQL

Cuando trabajamos en entornos corporativos o con infraestructuras de datos maduras, la información estructurada suele almacenarse en sistemas de gestión de bases de datos relacionales o SQL (Structured Query Language). Estas bases de datos se caracterizan por tener un esquema fijo y altamente estructurado, organizando la información en tablas interconectadas mediante claves funcionales.

Existen múltiples motores SQL en el mercado, cada uno con sutiles diferencias de sintaxis pero con una lógica operativa idéntica:

• Sistemas Tradicionales / Locales: PostgreSQL, MySQL, Microsoft SQL Server, Oracle DB o IBM Db2.
• Sistemas de Almacenamiento en la Nube (Data Warehouses): AWS Redshift o Google BigQuery.

Para interactuar con ellos desde Python, necesitamos utilizar la librería conectora específica de cada motor junto con los métodos nativos de Pandas.

Implementación Práctica con SQLite

El paquete estándar sqlite3 viene integrado en la instalación nativa de Python y es ideal para entornos de pruebas o bases de datos ligeras en archivo. El flujo de trabajo consta de tres fases: inicializar la ruta física, abrir un canal de comunicación o conexión (con) y lanzar la consulta analítica (query).

import sqlite3
import pandas as pd

# 1. Definición de la ruta donde reside la base de datos relacional
db_path = "data/classic_rock.db"

# 2. Establecimiento del canal de conexión física
con = sqlite3.connect(db_path)

# 3. Construcción de la consulta estructurada en formato string
query = "SELECT * FROM rock_songs;"

# 4. Ingesta directa del resultado SQL hacia un DataFrame de Pandas
df_rock = pd.read_sql(query, con)

import sqlite3
import pandas as pd

# 1. Definición de la ruta donde reside la base de datos relacional
db_path = "data/classic_rock.db"

# 2. Establecimiento del canal de conexión física
con = sqlite3.connect(db_path)

# 3. Construcción de la consulta estructurada en formato string
query = "SELECT * FROM rock_songs;"

# 4. Ingesta directa del resultado SQL hacia un DataFrame de Pandas
df_rock = pd.read_sql(query, con)

Alternativas de Conexión Corporativa

Si necesitas migrar este mismo bloque de código para extraer datos de los servidores de producción de tu empresa, solo debes sustituir el conector inicial importando el controlador adecuado:

• SQLAlchemy: Una de las librerías de mapeo objeto-relacional más potentes, compatible con casi cualquier motor SQL del mercado.
• Psycopg2: El driver optimizado específico para infraestructuras basadas en PostgreSQL.
• ibm_db: El conector dedicado para la familia de bases de datos IBM Db2.

Ingesta desde bases de datos NoSQL (No Relacionales)

En el polo opuesto encontramos las bases de datos NoSQL, diseñadas para almacenar información no estructurada o semiestructurada. Al prescindir de esquemas rígidos de filas y columnas fijas, reducen drásticamente los costes de infraestructura tecnológica y permiten lecturas masivas a gran velocidad.

La mayoría de los motores NoSQL orientados a documentos almacenan sus registros directamente en el formato JSON que analizamos previamente.

Tipos principales de arquitecturas NoSQL

1. Bases de Datos Documentales (ej. MongoDB): Cada observación equivale a un “documento” independiente (un archivo jerárquico JSON) con sus propias propiedades internas.
2. Almacenes Clave-Valor (ej. Redis): Sistemas hiperrápidos donde se apunta a un identificador único (ID) para recuperar un bloque de datos asociado (nombre, dirección, etc.).
3. Bases de Datos de Grafos (ej. Neo4j): Diseñadas de forma nativa para el análisis de redes complejas. Son el motor detrás de plataformas como LinkedIn o Facebook, estructuradas para calcular conexiones de primer, segundo o tercer nivel entre usuarios de forma inmediata.
4. Familias de Columnas Anchas (ej. Cassandra): Agrupan columnas lógicamente relacionadas en “familias de columnas”. Por ejemplo, los datos de un usuario pueden segmentarse en una familia Personal (nombre, edad) y otra Profesional (experiencia, visa).

Conexión y Extracción en MongoDB con pymongo

Para interactuar con una base de datos NoSQL como MongoDB, importamos el método MongoClient para abrir la conexión corporativa (la cual puede requerir credenciales de seguridad si el servidor reside en la nube).

from pymongo import MongoClient
import pandas as pd

# 1. Apertura del cliente de conexión (local o URL en la nube)
con = MongoClient()

# 2. Selección de la base de datos específica dentro del servidor
db = con.database_name

# 3. Consulta de la colección de documentos mediante llaves vacías {} (equivale a SELECT *)
# Esto genera un objeto cursor que funciona como un generador de documentos JSON
cursor = db.collection_name.find({})

# 4. Conversión del generador en una lista nativa de diccionarios Python
dict_list = list(cursor)

# 5. Volcado de la lista estructurada dentro del DataFrame analítico
df_nosql = pd.DataFrame(dict_list)

from pymongo import MongoClient
import pandas as pd

# 1. Apertura del cliente de conexión (local o URL en la nube)
con = MongoClient()

# 2. Selección de la base de datos específica dentro del servidor
db = con.database_name

# 3. Consulta de la colección de documentos mediante llaves vacías {} (equivale a SELECT *)
# Esto genera un objeto cursor que funciona como un generador de documentos JSON
cursor = db.collection_name.find({})

# 4. Conversión del generador en una lista nativa de diccionarios Python
dict_list = list(cursor)

# 5. Volcado de la lista estructurada dentro del DataFrame analítico
df_nosql = pd.DataFrame(dict_list)

Acceso a Datos en la Nube y APIs Públicas

Muchos proveedores de datos corporativos no exigen conexiones directas a servidores de bases de datos; en su lugar, habilitan APIs (Application Programming Interfaces). Las APIs actúan como ventanillas de servicio técnico automatizadas: envías una solicitud con ciertos parámetros y la API te devuelve un archivo estructurado (normalmente JSON) de forma inmediata. Un ejemplo común es el uso de APIs para extraer tweets históricos o métricas publicitarias desde plataformas como Amazon o Google.

Asimismo, la comunidad científica suele alojar bases de datos de libre acceso directamente en la nube. Pandas permite saltarse la descarga manual de estos archivos en tu ordenador; si conoces la dirección web (URL) del fichero, puedes inyectarlo directamente en memoria:

import pandas as pd

# Definición de la URL del set de datos en un repositorio en la nube (ej. UC Irvine ML Repository)
data_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

# Descarga, procesamiento y conversión a DataFrame en un único paso
df_cloud = pd.read_csv(data_url)

import pandas as pd

# Definición de la URL del set de datos en un repositorio en la nube (ej. UC Irvine ML Repository)
data_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"

# Descarga, procesamiento y conversión a DataFrame en un único paso
df_cloud = pd.read_csv(data_url)

¿Cómo aprenden las máquinas? Una Guía Introductoria al Machine Learning y Deep Learning

En la era digital, escuchamos los términos Inteligencia Artificial, Machine Learning y Deep Learning casi a diario. Sin embargo, ¿sabemos realmente qué significan y cómo se diferencian?

A menudo se piensa en la informática como un conjunto de reglas estrictas escritas por humanos. Pero existe una rama tecnológica que rompe con este esquema: las máquinas que aprenden a partir de la experiencia. A continuación, desglosaremos los conceptos fundamentales para entender esta revolución tecnológica, que muchos ya consideran “la nueva electricidad”.

¿Qué es el Machine Learning (Aprendizaje Automático)?

El Machine Learning (ML) es un subconjunto de la Inteligencia Artificial centrado en el estudio y la construcción de programas que no son programados explícitamente. En lugar de seguir instrucciones fijas, estos algoritmos descubren patrones ocultos a medida que se les expone a una mayor cantidad de datos a lo largo del tiempo.

La regla de oro del ML: A mayor volumen de datos de calidad, mejor será la capacidad del algoritmo para entender los patrones subyacentes.

Sin embargo, es importante destacar que el rendimiento de estos algoritmos tradicionales tiene un límite: llega un punto en el que el aprendizaje se estanca (efecto de rendimiento decreciente), independientemente de cuántos datos nuevos agreguemos.

Los Componentes del Aprendizaje: Características frente a Objetivo

Para entender cómo una máquina procesa la información, debemos desglosar un conjunto de datos en sus dos elementos fundamentales. Tomemos como ejemplo el famoso Iris Dataset, un conjunto de datos clásico en el mundo académico que registra las medidas de tres especies de flores (Virginica, Setosa y Versicolor):

• Características (Features): Son las variables independientes, es decir, las propiedades observables que introducimos en el algoritmo. En el caso de las flores, las características son cuatro de sus medidas físicas: la longitud del sépalo, el ancho del sépalo, la longitud del pétalo y el ancho del pétalo.
• Variable Objetivo (Target): Es la columna o etiqueta final que el programa intenta predecir de forma automática. En este ejemplo, el objetivo es determinar con precisión la especie de la flor.

El flujo de producción: El algoritmo se entrena cruzando las features con sus respectivos targets. Una vez que el modelo ha aprendido la relación matemática entre ambos componentes, se puede poner en producción. A partir de ese momento, si le entregamos únicamente las cuatro características de una nueva flor, la máquina será capaz de adivinar la especie correcta sin necesidad de que un humano la etiquete.

Los Dos Grandes Pilares: Aprendizaje Supervisado vs. No Supervisado

Dependiendo de los datos que tengamos y del objetivo que busquemos, el Machine Learning se divide principalmente en dos metodologías:

El Desafío de los Datos Complejos y el Nacimiento del Deep Learning

El Machine Learning tradicional es extraordinario trabajando con datos estructurados (tablas, números, categorías). Por ejemplo, para predecir si un correo es spam, o si una transacción es fraudulenta, podemos definir características claras como la hora, el monto o la ubicación.

Sin embargo, ¿qué pasa cuando intentamos que una máquina identifique si una imagen contiene un gato o un perro?

Para una computadora, una imagen es una rejilla de miles de píxeles (una pequeña foto de 256 x 256 píxeles se traduce en más de 65.000 características). Si analizamos cada píxel de forma aislada, perdemos la relación espacial (cómo se conecta un píxel con el de al lado para formar un ojo o una nariz).

Para solucionar esta limitación del ML tradicional, nació el Deep Learning (Aprendizaje Profundo).

Deep Learning: Redes Neuronales y Autoaprendizaje

El Deep Learning (DL) es, a su vez, un subconjunto del Machine Learning que utiliza modelos matemáticos altamente complejos llamados redes neuronales profundas.

La diferencia radical entre ambos enfoques radica en el procesamiento de las características:

• En el Machine Learning clásico: Un ingeniero o científico de datos humano debe identificar y extraer manualmente las características relevantes antes de entrenar al modelo.
• En el Deep Learning: El proceso es directo. Se introducen los píxeles brutos de la imagen en la red neuronal, y es el propio modelo el que aprende a extraer y combinar las características en capas intermedias.

Aunque los pasos intermedios de una red neuronal profunda no siempre son fáciles de interpretar por los humanos, el modelo es capaz de detectar primero bordes, luego combinar esos bordes para formar figuras (ojos, labios, formas) y finalmente realizar predicciones asombrosamente precisas (como reconocer el rostro de una persona específica).

Las Dos Grandes Metodologías: Aprendizaje Supervisado y No Supervisado

No todos los problemas de datos se estructuran de la misma manera ni persiguen los mismos objetivos. Por ello, el Machine Learning se divide principalmente en dos ramas bien definidas:

Aprendizaje Supervisado (Supervised Learning)

En esta modalidad, el algoritmo trabaja con un conjunto de datos completamente etiquetado. Esto significa que cada registro de entrenamiento incluye tanto las características como la respuesta correcta (el target).

• El Objetivo: Aprender a mapear las entradas con las salidas para predecir la etiqueta de datos futuros y desconocidos.
• Ejemplo 1 (Filtro de Spam): El sistema analiza miles de correos preclasificados por humanos como “Spam” o “No Spam”. Al procesar este histórico, el algoritmo detecta qué palabras o patrones se repiten en el correo basura y aprende a aislarlo en la bandeja de entrada real.
• Ejemplo 2 (Detección de Fraude Financiero): Una entidad bancaria recopila un gran volumen de transacciones financieras etiquetadas previamente como “legítimas” o “fraudulentas”. El modelo estudia las variables asociadas a cada caso y automatiza las alertas en tiempo real.

Aprendizaje No Supervisado (Unsupervised Learning)

A diferencia del anterior, aquí nos enfrentamos a bases de datos que no contienen etiquetas ni una variable objetivo. La máquina se encuentra completamente sola ante los datos brutos.

• El objetivo: encontrar una estructura interna, relaciones ocultas o agrupaciones naturales dentro del conjunto de información.
• Ejemplo (Segmentación de Clientes): En una plataforma de comercio electrónico (e-commerce), se introducen los datos de comportamiento de compra de los usuarios. Sin decirle al programa qué buscar, el algoritmo encuentra patrones comunes y los divide en grupos con perfiles similares (por ejemplo: “compradores impulsivos de fin de semana” o “buscadores de ofertas tecnológicas”). Esto permite al equipo de marketing diseñar campañas personalizadas para cada segmento.

Nota metodológica: En el Aprendizaje No Supervisado no existe una respuesta correcta o incorrecta predefinida por un humano. El científico de datos debe probar diferentes modelos matemáticos y evaluar qué agrupaciones tienen más coherencia y valor estratégico para el problema de negocio.

Datos Estructurados: El Terreno Ideal del Machine Learning Tradicional

Para cerrar esta introducción, es vital comprender qué tipo de problemas se resuelven mejor con estas técnicas clásicas. Pensemos nuevamente en el caso de la detección de fraudes con tarjetas de crédito.

Si queremos identificar una transacción sospechosa, las características idóneas a combinar son muy claras y específicas:

• La hora exacta de la transacción.
• El monto económico cobrado.
• La ubicación geográfica del comercio.
• La categoría de la compra (tecnología, alimentación, viajes, etc.).

Toda esta información se organiza de forma perfecta en tablas de filas y columnas. Este tipo de datos estructurados con características altamente intuitivas representa el escenario ideal donde los algoritmos tradicionales de Machine Learning ofrecen un rendimiento excepcional, rápido y sumamente preciso.

Aquí tienes la continuación y el cierre de esta sección del artículo, totalmente integrada y redactada con un estilo educativo y profesional:

El Límite de los Datos Estructurados: El Desafío de las Imágenes

Como hemos visto, el Machine Learning tradicional brilla cuando trabaja con datos tabulares organizados. Sin embargo, el panorama cambia drásticamente cuando intentamos resolver problemas con datos no estructurados, como las imágenes.

Imaginemos que queremos entrenar un modelo tradicional para determinar si una imagen muestra un gato o un perro. ¿Qué características (features) deberíamos extraer de forma manual?

Para una computadora, una imagen no es más que una matriz de datos numéricos que representan el color de cada píxel individual. Si intentamos usar cada píxel como una característica aislada, nos topamos inmediatamente con dos grandes obstáculos teóricos y prácticos:

1. La explosión de dimensiones: Incluso una imagen digital pequeña, de apenas $256 \times 256$ píxeles, se traduce en más de 65,000 píxeles. Esto significa obligar al algoritmo tradicional a trabajar con más de 65,000 características simultáneamente, un volumen masivo y poco eficiente para sus ecuaciones matemáticas.
2. La pérdida de la relación espacial: Si analizamos cada píxel como una variable independiente, el sistema pierde por completo el contexto de lo que hay a su alrededor. La información de un píxel solo cobra verdadero sentido en relación con sus píxeles vecinos. Son las agrupaciones de píxeles contiguos las que forman de manera conjunta una estructura reconocible, como la nariz, los ojos o la silueta de un animal.

Este callejón sin salida técnico marcó durante años las limitaciones del Machine Learning clásico, abriendo paso a una de las mayores revoluciones de la informática moderna: el Deep Learning.

Deep Learning y Redes Neuronales Profundas

El Deep Learning (Aprendizaje Profundo) es un subcampo especializado dentro del Machine Learning que aborda la complejidad mediante el uso de modelos matemáticos avanzados conocidos como redes neuronales profundas.

Su gran ventaja competitiva radica en que los ingenieros ya no necesitan definir e identificar las características de forma manual. En su lugar, el propio modelo recibe los píxeles brutos de la imagen y posee la capacidad única de aprender, extraer y combinar esas características de forma completamente autónoma, estructurando internamente las relaciones espaciales de los datos.

¿Cómo se diferencian en la práctica? Un caso de estudio

Para entender la diferencia radical en el flujo de trabajo, analicemos cómo identificarían ambos enfoques el rostro de una persona específica (por ejemplo, “Arjun”):

• En el Machine Learning Clásico: El científico de datos debe definir a priori las características matemáticas que componen un rostro (la distancia entre los ojos, la forma de la nariz, el contorno de los labios). Si el profesional tiene éxito en su estimación manual, introduce estas propiedades seleccionadas en el algoritmo para que intente predecir la identidad. Diseñar buenas características mediante este método es una tarea titánica y sumamente compleja de realizar con precisión.
• En el Deep Learning: El proceso se unifica en un único flujo de trabajo. La red neuronal recibe directamente los píxeles brutos de la fotografía. A través de sus múltiples capas intermedias (u ocultas), el modelo realiza una ingeniería de características automatizada. En las primeras capas suele identificar elementos simples como bordes y líneas; posteriormente, las capas más profundas combinan esos bordes para reconocer formas complejas (ojos, labios, orejas) hasta procesar el rostro completo y predecir de forma exacta que se trata de Arjun.

Aunque el procesamiento matemático en estas capas intermedias a menudo resulta difícil de interpretar por los seres humanos (un fenómeno conocido como “caja negra”), su utilidad práctica para resolver tareas complejas de visión artificial y clasificación de imágenes ha superado con creces cualquier tecnología previa.

Criterios de Elección: ¿Cuándo usar cada tecnología?

A pesar del enorme impacto del Deep Learning en la investigación científica de vanguardia, es fundamental desmitificar la idea de que siempre es la mejor opción. La elección de la herramienta depende estrictamente de la naturaleza del problema y de los recursos disponibles:

• El poder del Machine Learning tradicional: Sigue siendo el rey indiscutible cuando se trabaja con conjuntos de datos pequeños o cuando la información cambia y se actualiza de manera constante en el tiempo sin un patrón fijo. En estos escenarios, los algoritmos tradicionales ofrecen un rendimiento significativamente superior, son más rápidos de entrenar y requieren una fracción del coste computacional.
• El momento del Deep Learning: Se vuelve indispensable cuando nos enfrentamos a grandes volúmenes de datos masivos (Big Data) y a formatos no estructurados (imágenes, audio, vídeo o texto libre), donde el rendimiento del Machine Learning tradicional tiende a estancarse.

Comprender esta frontera técnica nos permite apreciar cómo la Inteligencia Artificial ha evolucionado desde sus fundamentos teóricos primitivos hasta convertirse en lo que muchos expertos ya catalogan como “la nueva electricidad” de nuestra sociedad.

Aquí tienes la continuación del artículo, correspondiente a la sección final del módulo donde se introducen los fundamentos técnicos, las herramientas y el ciclo de trabajo que preparan al lector para la fase práctica de la ciencia de datos.

Fundamentos del Aprendizaje Automático: Vocabulario, Herramientas y Ciclo de Trabajo

Para cerrar esta introducción general y prepararnos con éxito de cara a las fases de Análisis Exploratorio de Datos (EDA), limpieza de información e inferencia estadística, es fundamental asentar las bases metodológicas. Todo profesional del Machine Learning debe dominar un conjunto de herramientas técnicas, un flujo de trabajo ordenado y un vocabulario preciso que evite interpretaciones erróneas de los modelos en producción.

Requisitos Técnicos y de Criterio Científico

Antes de pulsar la primera línea de código, el desarrollo de modelos requiere dos pilares conceptuales que no se pueden ignorar:

1. Bases Matemáticas Fuertes: Es un error muy común saltarse los fundamentos de la estadística básica (probabilidad, cálculo de momentos, regla de Bayes) y del álgebra lineal. Sin esta base, se corre el riesgo de configurar mal los parámetros y malinterpretar por completo las métricas de rendimiento de los algoritmos.
2. El Ecosistema Python: En la práctica, el entorno estándar de trabajo se compone de Jupyter Notebooks (o entornos iPython) respaldados por librerías maduras y especializadas:

El Flujo de Trabajo Típico en Machine Learning (Workflow)

Construir un modelo predictivo no consiste simplemente en alimentar un algoritmo con datos aleatorios. Se trata de un proceso estructurado en 6 etapas secuenciales:

1. Definición del Problema (Problem Statement): Determinar con exactitud qué meta se quiere alcanzar. Por ejemplo: “Queremos un sistema capaz de clasificar diferentes razas de perros a partir de fotografías”.
2. Recolección de Datos (Data Collection): Reunir la información necesaria. Siguiendo el ejemplo anterior, no bastará con una sola imagen por raza; se requerirán miles de fotografías etiquetadas, tomadas desde diferentes ángulos y bajo distintas condiciones de luz.
3. Exploración y Preprocesamiento (Exploratory Data Analysis & Preprocessing): Limpiar los datos para que el modelo pueda interpretarlos de forma óptima. Aquí se analizan mapas de calor de densidad de píxeles, se evalúa la distribución de las muestras y se transforman las variables en arrays multidimensionales normalizados.
4. Modelado (Modeling): Entrenar los algoritmos. Normalmente se empieza construyendo un modelo base muy sencillo (baseline) para establecer un estándar mínimo de comparación antes de probar arquitecturas más complejas.
5. Validación (Validation): Evaluar si el modelo realmente resuelve el problema. Para ello se utiliza un conjunto de datos de prueba retenido o apartado (holdout set). Se trata de datos e imágenes que el modelo nunca vio durante el entrenamiento, lo que permite verificar su porcentaje real de precisión en el mundo real.
6. Toma de Decisiones y Despliegue (Deployment): Una vez que el modelo alcanza los rangos de precisión exigidos por el negocio, se comunican los resultados a las partes interesadas (stakeholders) y se traslada el código a un entorno de producción para que empiece a operar en tiempo real.

Diccionario Esencial para Científicos de Datos

Para comprender la estructura de cualquier conjunto de datos, resulta muy útil imaginar la información en el formato visual de una hoja de cálculo. Tomando de nuevo como referencia el histórico de las especies de flores Iris, definimos los cuatro términos clave:

• Variable Objetivo (Target Variable): Es la columna o propiedad específica que deseamos predecir de cara al futuro. En nuestra hoja de cálculo, la columna objetivo es Species.
• Características (Features / Explanatory Variables): Son el resto de las columnas de la tabla. Representan las variables independientes que el algoritmo analiza para buscar patrones y deducir el objetivo. En este conjunto de datos contamos con 4 características: sepal length, sepal width, petal length y petal width. Cuando el modelo trabaje en producción con datos nuevos, solo dispondrá de estas columnas.
• Observación o Ejemplo (Observation / Example): Se refiere a una fila completa dentro de la base de datos. Cada fila representa un caso de estudio individual con todas sus características y su correspondiente resolución, y sirve para que el modelo ajuste matemáticamente sus parámetros de aprendizaje.
• Etiqueta (Label): Es el valor concreto que toma la variable objetivo dentro de una observación específica. Mientras que la columna completa es el target, el dato puntual de una sola fila (por ejemplo, el valor escrito de versicolor o setosa) es la etiqueta.