Upload folder using huggingface_hub

cuadernos/semana_4/01_ClasificacionNoSupervisada_KMeans.ipynb

@@ -0,0 +1,521 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# S4 · Ejercicio 4 — Estratificación socioeconómica con K-Means\n",
+    "\n",
+    "**Curso de Big Data · Dr. Abel Coronado** · Semana 4\n",
+    "\n",
+    "🎯 **Objetivo.** Agrupar manzanas del Censo en K=5 estratos con K-Means (no supervisado) y exportar el resultado.\n",
+    "\n",
+    "📦 **Datos.** `/data/raw/geodatos_mexico/censo_2020_nacional.parquet`.\n",
+    "\n",
+    "✅ **Prerrequisitos.** Censo cargado en HDFS. Requiere geopandas (pip install geopandas).\n",
+    "\n",
+    "📝 **Entregable.** Resultado de estratificación en HDFS y/o GeoPackage exportado.\n",
+    "\n",
+    "🛠️ **Stack del laboratorio.** Spark 4.0 · Sedona 1.8.0 (_2.13) · HDFS 3.3.6 · Elasticsearch 8.14 · JupyterLab\n",
+    "\n",
+    "⬇️ **Descarga (Hugging Face):** https://huggingface.co/datasets/abxda/bdp-lab/resolve/main/cuadernos/semana_4/01_ClasificacionNoSupervisada_KMeans.ipynb\n",
+    "\n",
+    "💬 **¿Un error?** Toma una captura (celda + mensaje) y repórtalo por **Blackboard**, indicando tu SO y el paso.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> Cuaderno **probado** en el laboratorio (Spark 4.0). Lee los comentarios de cada celda: explican el porqué de cada paso.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22b8aa6c-6107-409a-a3fd-f1b7c5a19f16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 1: Inicialización de Spark y Sedona\n",
+    "# =============================================================================\n",
+    "from pyspark.sql import SparkSession\n",
+    "import pyspark.sql.functions as F\n",
+    "from pyspark.sql.functions import col, when\n",
+    "from sedona.spark import SedonaContext\n",
+    "\n",
+    "# Detener cualquier sesión previa para una inicialización limpia\n",
+    "try:\n",
+    "    spark.stop()\n",
+    "    print(\"Sesión de Spark anterior detenida.\")\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "print(\"» Paso 1: Configurando la sesión de Spark para clustering geoespacial...\")\n",
+    "spark = (\n",
+    "    SparkSession.builder.appName(\"KMeans_Socioeconomico_HDFS\")\n",
+    "    .config(\"spark.driver.memory\", \"4g\")\n",
+    "    .config(\"spark.sql.shuffle.partitions\", \"200\")\n",
+    "    .config(\n",
+    "        \"spark.jars.packages\",\n",
+    "        \"org.apache.sedona:sedona-spark-4.0_2.13:1.8.0,\"\n",
+    "        \"org.datasyslab:geotools-wrapper:1.8.0-33.1\"\n",
+    "    )\n",
+    "    .config(\"spark.serializer\", \"org.apache.spark.serializer.KryoSerializer\")\n",
+    "    .config(\"spark.kryo.registrator\", \"org.apache.sedona.core.serde.SedonaKryoRegistrator\")\n",
+    "    .config(\"spark.sql.extensions\", \"org.apache.sedona.sql.SedonaSqlExtensions\")\n",
+    "    .getOrCreate()\n",
+    ")\n",
+    "\n",
+    "sedona = SedonaContext.create(spark)\n",
+    "print(\"✅ Sesión de Spark con Apache Sedona iniciada correctamente.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8c8ff5bc-bac3-4776-bd93-ba2867c3f303",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 2: Carga y Selección de Datos BASE (MODIFICADO para más robustez)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 2: Cargando las columnas BASE para calcular los indicadores.\")\n",
+    "\n",
+    "# --- 2.1 Definir ruta y variables base según el diccionario ---\n",
+    "CENSO_PATH_HDFS = \"hdfs:///data/raw/geodatos_mexico/censo_2020_nacional.parquet\"\n",
+    "variables_base_censo = [\n",
+    "    'CVEGEO', 'geometry',\n",
+    "    'PEA', 'P_12YMAS', 'P18YM_PB', 'P_18YMAS',\n",
+    "    'VIVPARH_CV', 'VPH_STVP', 'VPH_SPMVPI', 'VPH_CVJ'\n",
+    "]\n",
+    "\n",
+    "# --- 2.2 Cargar y seleccionar ---\n",
+    "print(f\"   Cargando Censo desde: {CENSO_PATH_HDFS}\")\n",
+    "censo_completo_sdf = spark.read.format(\"geoparquet\").load(CENSO_PATH_HDFS)\n",
+    "censo_base_sdf = censo_completo_sdf.select(variables_base_censo)\n",
+    "\n",
+    "# --- 2.3 ¡NUEVO! Limpieza de NULOS ---\n",
+    "# Obtenemos la lista de variables numéricas para rellenar\n",
+    "variables_numericas = [v for v in variables_base_censo if v not in ['CVEGEO', 'geometry']]\n",
+    "\n",
+    "# Rellenamos los valores nulos con 0 solo en las columnas numéricas\n",
+    "censo_base_sin_nulos_sdf = censo_base_sdf.na.fill(0, subset=variables_numericas)\n",
+    "print(\"   Valores nulos reemplazados por 0.\")\n",
+    "\n",
+    "\n",
+    "print(f\"✅ Datos base del Censo cargados y pre-limpiados. Total de manzanas: {censo_base_sin_nulos_sdf.count():,}\")\n",
+    "censo_base_sin_nulos_sdf.show(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f047d4d0-0e71-4de5-aa19-21cf1da2fcf0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 3: Limpieza de Datos Negativos (MODIFICADO)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 3: Limpiando los datos. Reemplazando valores negativos por 0.\")\n",
+    "\n",
+    "# La lista de variables a limpiar sigue siendo la misma\n",
+    "variables_a_limpiar = [v for v in variables_base_censo if v not in ['CVEGEO', 'geometry']]\n",
+    "\n",
+    "# Ahora partimos del DataFrame que ya no tiene nulos\n",
+    "censo_limpio_sdf = censo_base_sin_nulos_sdf\n",
+    "\n",
+    "# Iteramos y aplicamos la limpieza de negativos\n",
+    "for variable in variables_a_limpiar:\n",
+    "    censo_limpio_sdf = censo_limpio_sdf.withColumn(\n",
+    "        variable,\n",
+    "        when(col(variable) < 0, 0.0).otherwise(col(variable))\n",
+    "    )\n",
+    "\n",
+    "print(\"✅ Datos base completamente limpios (sin nulos ni negativos) y listos para el cálculo.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b077e69b-3294-40bb-88e9-e6b3dbb49a66",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 4: Cálculo de Indicadores (SIN CAMBIOS, pero ahora más seguro)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 4: Calculando los indicadores porcentuales.\")\n",
+    "\n",
+    "# Usamos el DataFrame completamente limpio para los cálculos\n",
+    "indicadores_sdf = censo_limpio_sdf.withColumn(\n",
+    "    \"ECO1_R\",\n",
+    "    when(col(\"P_12YMAS\") > 0, (col(\"PEA\") / col(\"P_12YMAS\")) * 100).otherwise(0.0)\n",
+    ").withColumn(\n",
+    "    \"EDU46_R\",\n",
+    "    when(col(\"P_18YMAS\") > 0, (col(\"P18YM_PB\") / col(\"P_18YMAS\")) * 100).otherwise(0.0)\n",
+    ").withColumn(\n",
+    "    \"VIV82_R\",\n",
+    "    when(col(\"VIVPARH_CV\") > 0, (col(\"VPH_STVP\") / col(\"VIVPARH_CV\")) * 100).otherwise(0.0)\n",
+    ").withColumn(\n",
+    "    \"VIV83_R\",\n",
+    "    when(col(\"VIVPARH_CV\") > 0, (col(\"VPH_SPMVPI\") / col(\"VIVPARH_CV\")) * 100).otherwise(0.0)\n",
+    ").withColumn(\n",
+    "    \"VIV84_R\",\n",
+    "    when(col(\"VIVPARH_CV\") > 0, (col(\"VPH_CVJ\") / col(\"VIVPARH_CV\")) * 100).otherwise(0.0)\n",
+    ")\n",
+    "\n",
+    "print(\"   Verificación de los indicadores calculados:\")\n",
+    "indicadores_sdf.select(\"CVEGEO\", \"ECO1_R\", \"EDU46_R\", \"VIV82_R\", \"VIV83_R\", \"VIV84_R\").show(5)\n",
+    "print(\"✅ Indicadores calculados exitosamente.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "61d00fcb-4a6c-4953-bbc7-af1e8da592ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 5: Preparación para K-Means (VectorAssembler) (MODIFICADO)\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.feature import VectorAssembler\n",
+    "\n",
+    "print(\"\\n» Paso 5: Ensamblando los indicadores calculados en un vector de 'features'.\")\n",
+    "\n",
+    "# Las columnas de entrada para el clustering ahora son nuestros indicadores calculados\n",
+    "variables_a_clusterizar = ['ECO1_R', 'EDU46_R', 'VIV82_R', 'VIV83_R', 'VIV84_R']\n",
+    "\n",
+    "assembler = VectorAssembler(\n",
+    "    inputCols=variables_a_clusterizar,\n",
+    "    outputCol=\"features\",\n",
+    "    handleInvalid=\"skip\"\n",
+    ")\n",
+    "\n",
+    "# Transformamos el DataFrame con los indicadores para añadir la columna 'features'\n",
+    "censo_preparado_sdf = assembler.transform(indicadores_sdf)\n",
+    "\n",
+    "print(\"   Muestra del DataFrame con la nueva columna 'features':\")\n",
+    "censo_preparado_sdf.select(\"CVEGEO\", \"features\").show(5, truncate=False)\n",
+    "print(\"✅ Datos vectorizados y listos para K-Means.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "44c434ac-b8ee-4373-a830-c73219bd352d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 6: Entrenamiento del Modelo K-Means (SIN CAMBIOS)\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.clustering import KMeans\n",
+    "\n",
+    "print(\"\\n» Paso 6: Entrenando el modelo K-Means. (Esto puede tardar)\")\n",
+    "\n",
+    "# Definir y entrenar el modelo\n",
+    "kmeans = KMeans(featuresCol=\"features\", k=5, seed=1)\n",
+    "kmeans_model = kmeans.fit(censo_preparado_sdf)\n",
+    "print(\"✅ Modelo K-Means entrenado.\")\n",
+    "\n",
+    "# Asignar cada manzana a un clúster\n",
+    "censo_estratificado_sdf = kmeans_model.transform(censo_preparado_sdf)\n",
+    "\n",
+    "print(\"\\n   Muestra de manzanas con su clúster ('prediction') asignado:\")\n",
+    "censo_estratificado_sdf.select(\"CVEGEO\", \"prediction\").show(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11e39449-59ce-4ea7-b682-42569bb665f5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 7: Análisis e Interpretación de los Clústeres (SIN CAMBIOS EN LÓGICA)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 7: Analizando los perfiles de cada clúster.\")\n",
+    "\n",
+    "# Agrupamos por clúster y calculamos promedios\n",
+    "perfiles_clusters = censo_estratificado_sdf.groupBy(\"prediction\").agg(\n",
+    "    F.mean(\"ECO1_R\").alias(\"prom_pob_activa\"),\n",
+    "    F.mean(\"EDU46_R\").alias(\"prom_educ_superior\"),\n",
+    "    F.mean(\"VIV82_R\").alias(\"prom_tv_paga\"),\n",
+    "    F.mean(\"VIV83_R\").alias(\"prom_streaming\"),\n",
+    "    F.mean(\"VIV84_R\").alias(\"prom_videojuegos\"),\n",
+    "    F.count(\"*\").alias(\"num_manzanas\")\n",
+    ").orderBy(\"prediction\")\n",
+    "\n",
+    "print(\"--- Perfiles de los 5 Estratos Socioeconómicos Encontrados (basados en indicadores calculados) ---\")\n",
+    "perfiles_clusters.show(truncate=False)\n",
+    "print(\"✅ Análisis de clústeres completado.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ee4de204-5eed-4b4c-b8ea-0373554bf6b4",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 8: Guardado del Resultado Final (MODIFICADO)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 8: Guardando el resultado final en HDFS.\")\n",
+    "\n",
+    "# Seleccionamos las columnas que queremos en nuestro archivo final\n",
+    "columnas_finales = [\n",
+    "    \"CVEGEO\",\n",
+    "    \"prediction\", # El ID del clúster/estrato\n",
+    "    \"ECO1_R\", \"EDU46_R\", \"VIV82_R\", \"VIV83_R\", \"VIV84_R\", # Los indicadores que calculamos\n",
+    "    \"geometry\"\n",
+    "]\n",
+    "resultado_final_sdf = censo_estratificado_sdf.select(columnas_finales) \\\n",
+    "    .withColumnRenamed(\"prediction\", \"estrato_socioeconomico\")\n",
+    "\n",
+    "# Definir la ruta de salida\n",
+    "OUTPUT_PATH_HDFS = \"hdfs:///data/processed/estratificacion_socioeconomica_calculada.geoparquet\"\n",
+    "print(f\"   Guardando en: {OUTPUT_PATH_HDFS}\")\n",
+    "\n",
+    "# Guardar como GeoParquet\n",
+    "resultado_final_sdf.write.format(\"geoparquet\").mode(\"overwrite\").save(OUTPUT_PATH_HDFS)\n",
+    "\n",
+    "print(f\"✅ ¡Proceso completado! El GeoParquet con la estratificación calculada está listo en HDFS.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "353e0d22-ed76-4975-9e11-4f000f98f0c0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 9: Instalación de Librerías (si es necesario)\n",
+    "# =============================================================================\n",
+    "#python -m pip install geopandas pygeos\n",
+    "\n",
+    "import geopandas as gpd\n",
+    "print(\"✅ Librerías para exportación listas.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3febdd04-46a9-48e7-82e9-febc447d4d36",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 10: Definición de Niveles y Colores para los Clústeres\n",
+    "# =============================================================================\n",
+    "from pyspark.sql.functions import col, lit, when\n",
+    "\n",
+    "print(\"\\n» Paso 9: Asignando niveles socioeconómicos (Alto, Medio, Bajo) a los clústeres.\")\n",
+    "\n",
+    "# --- 1. Calcular el Score Socioeconómico ---\n",
+    "# Partimos del DataFrame 'perfiles_clusters' que ya calculamos\n",
+    "perfiles_con_score_sdf = perfiles_clusters.withColumn(\n",
+    "    \"score_socioeconomico\",\n",
+    "    (col(\"prom_pob_activa\") + col(\"prom_educ_superior\") + col(\"prom_tv_paga\") + col(\"prom_streaming\") + col(\"prom_videojuegos\")) / 5\n",
+    ").orderBy(col(\"score_socioeconomico\").desc())\n",
+    "\n",
+    "print(\"   Perfiles de clústeres ordenados por score socioeconómico:\")\n",
+    "perfiles_con_score_sdf.show()\n",
+    "\n",
+    "# --- 2. Asignar Niveles y Colores ---\n",
+    "# Recolectamos los resultados ordenados al driver para una manipulación más sencilla (es una tabla muy pequeña)\n",
+    "perfiles_pandas = perfiles_con_score_sdf.toPandas()\n",
+    "\n",
+    "# Creamos la asignación de nivel y color\n",
+    "# Para K=5: 2 Altos, 1 Medio, 2 Bajos\n",
+    "niveles = ['Alto', 'Alto', 'Medio', 'Bajo', 'Bajo']\n",
+    "colores = ['Verde', 'Verde', 'Amarillo', 'Rojo', 'Rojo']\n",
+    "perfiles_pandas['nivel'] = niveles\n",
+    "perfiles_pandas['color'] = colores\n",
+    "\n",
+    "# Convertimos de vuelta a un DataFrame de Spark para poder hacer el join\n",
+    "niveles_sdf = spark.createDataFrame(perfiles_pandas)\n",
+    "\n",
+    "print(\"\\n--- Tabla Final de Perfiles con Nivel y Color Asignado ---\")\n",
+    "niveles_sdf.select(\"prediction\", \"score_socioeconomico\", \"nivel\", \"color\", \"num_manzanas\").show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fd3fd170-54db-4c6a-bc37-3e3fb5fb35ff",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 11: Unir Colores al DataFrame Principal\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 11: Uniendo la información de nivel y color al DataFrame de manzanas.\")\n",
+    "\n",
+    "# El DataFrame 'resultado_final_sdf' ya está en memoria\n",
+    "# Unimos por el ID del clúster\n",
+    "manzanas_con_color_sdf = resultado_final_sdf.join(\n",
+    "    niveles_sdf.select(\"prediction\", \"nivel\", \"color\"),\n",
+    "    resultado_final_sdf.estrato_socioeconomico == niveles_sdf.prediction,\n",
+    "    \"left\"\n",
+    ").drop(\"prediction\") # Eliminamos la columna duplicada del join\n",
+    "\n",
+    "print(\"   Muestra de las manzanas con su nuevo nivel y color:\")\n",
+    "manzanas_con_color_sdf.select(\"CVEGEO\", \"estrato_socioeconomico\", \"nivel\", \"color\").show(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0b86d61-9df6-40f0-9cd6-ee444cbb52da",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "niveles_sdf.show(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "e5a2392e-9b75-44ee-be18-bfc57f6c0e2b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "manzanas_con_color_sdf.show(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "79eb0b70-9009-4f6a-a078-46e0987765f8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 11: GUARDAR EL RESULTADO FINAL EN HDFS\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 11: Guardando el resultado final con colores como GeoParquet en HDFS.\")\n",
+    "\n",
+    "# Define la ruta de salida en HDFS.\n",
+    "OUTPUT_HDFS_PATH = \"/data/processed/estratificacion_colores_geoparquet\"\n",
+    "\n",
+    "print(f\"   Guardando en la ruta de HDFS: {OUTPUT_HDFS_PATH}\")\n",
+    "\n",
+    "# .coalesce(1) une el resultado en un solo archivo Parquet dentro de la carpeta en HDFS.\n",
+    "manzanas_con_color_sdf.coalesce(1).write.format(\"geoparquet\").mode(\"overwrite\").save(OUTPUT_HDFS_PATH)\n",
+    "\n",
+    "print(f\"✅ Resultado guardado exitosamente en HDFS.\")\n",
+    "\n",
+    "# --- Detenemos la sesión de Spark ---\n",
+    "spark.stop()\n",
+    "print(\"✅ Sesión de Spark detenida.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1e5669b9-2850-4da4-81ac-36a7fac7f91b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 12: DESCARGA DE HDFS Y CONVERSIÓN A GEOPACKAGE (SCRIPT LOCAL)\n",
+    "# =============================================================================\n",
+    "# Este script se ejecuta localmente, sin necesidad de Spark.\n",
+    "# Asegúrate de que las librerías 'hdfs' y 'geopandas' están instaladas.\n",
+    "\n",
+    "import os\n",
+    "from hdfs import InsecureClient\n",
+    "import geopandas as gpd\n",
+    "\n",
+    "print(\"\\n» Paso 12: Descargando resultado desde HDFS y convirtiendo a GeoPackage.\")\n",
+    "\n",
+    "# --- 1. Definición de Rutas ---\n",
+    "# Ruta de origen en HDFS (la que acabamos de guardar)\n",
+    "HDFS_SOURCE_PATH = \"/data/processed/estratificacion_colores_geoparquet\"\n",
+    "\n",
+    "# Ruta de destino local. Se creará una carpeta con este nombre en el directorio actual.\n",
+    "# os.getcwd() asegura que sea en 'C:\\BDP\\notebooks' si ejecutas el notebook desde ahí.\n",
+    "LOCAL_DEST_PATH = os.path.join(os.getcwd(), \"estratificacion_colores_geoparquet\")\n",
+    "\n",
+    "GEOPACKAGE_FILENAME = \"estratificacion_nacional_colores.gpkg\"\n",
+    "\n",
+    "print(f\"Directorio de origen en HDFS: {HDFS_SOURCE_PATH}\")\n",
+    "print(f\"Directorio de destino local: {LOCAL_DEST_PATH}\")\n",
+    "print(f\"Archivo de salida final: {GEOPACKAGE_FILENAME}\")\n",
+    "\n",
+    "\n",
+    "# --- 2. Descarga desde HDFS ---\n",
+    "try:\n",
+    "    print(\"\\nConectando al cliente HDFS...\")\n",
+    "    # Conexión al NameNode (puerto 9870 es el estándar en BDPv4)\n",
+    "    client = InsecureClient('http://localhost:9870')\n",
+    "\n",
+    "    print(\"Iniciando la descarga...\")\n",
+    "    # overwrite=True borrará el directorio local si ya existe.\n",
+    "    client.download(HDFS_SOURCE_PATH, LOCAL_DEST_PATH, overwrite=True)\n",
+    "    print(\"✅ ¡Descarga desde HDFS completada exitosamente!\")\n",
+    "\n",
+    "except Exception as e:\n",
+    "    print(f\"❌ Ocurrió un error durante la descarga: {e}\")\n",
+    "    # Detenemos la ejecución si la descarga falla\n",
+    "    raise SystemExit(\"No se puede continuar sin los datos.\")\n",
+    "\n",
+    "\n",
+    "# --- 3. Conversión a GeoPackage ---\n",
+    "print(\"\\nIniciando conversión a GeoPackage...\")\n",
+    "try:\n",
+    "    # Verificamos si la descarga fue exitosa antes de continuar\n",
+    "    if os.path.exists(LOCAL_DEST_PATH):\n",
+    "        # Leer el GeoParquet descargado con GeoPandas\n",
+    "        print(f\"   Leyendo GeoParquet desde la carpeta local: {LOCAL_DEST_PATH}\")\n",
+    "        manzanas_gdf = gpd.read_parquet(LOCAL_DEST_PATH)\n",
+    "        print(f\"   Datos cargados en GeoPandas. Total de manzanas: {len(manzanas_gdf):,}\")\n",
+    "\n",
+    "        # Guardar como GeoPackage\n",
+    "        print(f\"   Guardando como GeoPackage en: {GEOPACKAGE_FILENAME}\")\n",
+    "        manzanas_gdf.to_file(GEOPACKAGE_FILENAME, driver=\"GPKG\")\n",
+    "\n",
+    "        print(f\"\\n✅ ¡Éxito! El archivo '{GEOPACKAGE_FILENAME}' ha sido creado.\")\n",
+    "    else:\n",
+    "        print(\"❌ ERROR: El directorio local no fue encontrado después de la descarga.\")\n",
+    "\n",
+    "except Exception as e:\n",
+    "    print(f\"❌ Ocurrió un error durante la conversión a GeoPackage: {e}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9601b461-9cab-4d4c-ba25-7f67dea94f2a",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cuadernos/semana_4/02_CalculoVariablesDenueOxxo.ipynb

@@ -0,0 +1,439 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# S4 · Ejercicio 5a — Ingeniería de características espacial (OXXO)\n",
+    "\n",
+    "**Curso de Big Data · Dr. Abel Coronado** · Semana 4\n",
+    "\n",
+    "🎯 **Objetivo.** Construir el dataset de entrenamiento OXXO vs Abarrotes con features espaciales (buffers + spatial joins de DENUE y Censo con Sedona).\n",
+    "\n",
+    "📦 **Datos.** `/data/raw/geodatos_mexico/{censo_2020_nacional,denue_nacional}.parquet`.\n",
+    "\n",
+    "✅ **Prerrequisitos.** Censo y DENUE en HDFS. Paso PESADO: sube spark.driver.memory (8g) o acota a un estado.\n",
+    "\n",
+    "📝 **Entregable.** `/data/processed/ml_dataset_final.geoparquet` creado en HDFS.\n",
+    "\n",
+    "🛠️ **Stack del laboratorio.** Spark 4.0 · Sedona 1.8.0 (_2.13) · HDFS 3.3.6 · Elasticsearch 8.14 · JupyterLab\n",
+    "\n",
+    "⬇️ **Descarga (Hugging Face):** https://huggingface.co/datasets/abxda/bdp-lab/resolve/main/cuadernos/semana_4/02_CalculoVariablesDenueOxxo.ipynb\n",
+    "\n",
+    "💬 **¿Un error?** Toma una captura (celda + mensaje) y repórtalo por **Blackboard**, indicando tu SO y el paso.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> Cuaderno **probado** en el laboratorio (Spark 4.0). Lee los comentarios de cada celda: explican el porqué de cada paso.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f53e3851-a5e2-48e0-861f-3f199fca6636",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 1: Inicialización de Spark y Sedona\n",
+    "# =============================================================================\n",
+    "from pyspark.sql import SparkSession\n",
+    "import pyspark.sql.functions as F\n",
+    "from pyspark.sql.functions import col, expr, lower, substring, when, rand, lit, sum as _sum\n",
+    "from sedona.spark import SedonaContext\n",
+    "\n",
+    "# Detener cualquier sesión previa para una inicialización limpia\n",
+    "try:\n",
+    "    spark.stop()\n",
+    "    print(\"Sesión de Spark anterior detenida.\")\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "print(\"» Paso 1: Configurando la sesión de Spark para un procesamiento geoespacial intensivo...\")\n",
+    "spark = (\n",
+    "    SparkSession.builder.appName(\"FeatureEngineeringOXXO_HDFS\")\n",
+    "    .config(\"spark.driver.memory\", \"4g\")\n",
+    "    .config(\"spark.sql.shuffle.partitions\", \"200\") # Optimización para los joins\n",
+    "    .config(\n",
+    "        \"spark.jars.packages\",\n",
+    "        \"org.apache.sedona:sedona-spark-4.0_2.13:1.8.0,\"\n",
+    "        \"org.datasyslab:geotools-wrapper:1.8.0-33.1\"\n",
+    "    )\n",
+    "    .config(\"spark.serializer\", \"org.apache.spark.serializer.KryoSerializer\")\n",
+    "    .config(\"spark.kryo.registrator\", \"org.apache.sedona.core.serde.SedonaKryoRegistrator\")\n",
+    "    .config(\"spark.sql.extensions\", \"org.apache.sedona.sql.SedonaSqlExtensions\")\n",
+    "    .getOrCreate()\n",
+    ")\n",
+    "\n",
+    "sedona = SedonaContext.create(spark)\n",
+    "print(\"✅ Sesión de Spark con Apache Sedona iniciada correctamente.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "062cc696-8029-42e2-969d-d49288707405",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 2: Carga de Datos y Preprocesamiento Inicial (Versión Corregida)\n",
+    "# =============================================================================\n",
+    "import pyspark.sql.functions as F\n",
+    "from pyspark.sql.functions import col, lower, substring, when\n",
+    "\n",
+    "# --- LÍNEA DE CORRECCIÓN AÑADIDA AQUÍ ---\n",
+    "# Importamos los tipos de datos desde el módulo correcto\n",
+    "from pyspark.sql.types import IntegerType, DoubleType, LongType, FloatType\n",
+    "\n",
+    "print(\"\\n» Paso 2: Cargando y pre-procesando los datos base desde HDFS.\")\n",
+    "\n",
+    "# --- 2.1 Definir las rutas en HDFS ---\n",
+    "CENSO_PATH_HDFS = \"hdfs:///data/raw/geodatos_mexico/censo_2020_nacional.parquet\"\n",
+    "DENUE_PATH_HDFS = \"hdfs:///data/raw/geodatos_mexico/denue_nacional.parquet\"\n",
+    "\n",
+    "# --- 2.2 Cargar DataFrames usando el formato 'geoparquet' ---\n",
+    "print(f\"   Cargando Censo desde: {CENSO_PATH_HDFS}\")\n",
+    "censo_sdf = spark.read.format(\"geoparquet\").load(CENSO_PATH_HDFS)\n",
+    "\n",
+    "print(f\"   Cargando DENUE desde: {DENUE_PATH_HDFS}\")\n",
+    "denue_raw_sdf = spark.read.format(\"geoparquet\").load(DENUE_PATH_HDFS)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4d4ae7e5-f5f5-4504-a239-105f9f7ca8b3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# --- 2.3 Preprocesamiento del DENUE ---\n",
+    "print(\"   Procesando DENUE: creando 'est_per_ocu', 'codigo_act_2c', etc.\")\n",
+    "denue_sdf = denue_raw_sdf.withColumn(\"codigo_act_2c\", substring(col(\"codigo_act\"), 1, 2)) \\\n",
+    "    .withColumn(\"nom_estab\", lower(col(\"nom_estab\"))) \\\n",
+    "    .withColumn(\"entidad\", lower(col(\"entidad\"))) \\\n",
+    "    .withColumn(\"municipio\", lower(col(\"municipio\"))) \\\n",
+    "    .withColumn(\"localidad\", lower(col(\"localidad\"))) \\\n",
+    "    .withColumn(\"est_per_ocu\",\n",
+    "        when(col(\"per_ocu\").contains(\"0 a 5\"), 2.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"6 a 10\"), 8.0)\n",
+    "        .when(col(\"per_ocu\").contains(\"11 a 30\"), 20.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"31 a 50\"), 40.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"51 a 100\"), 75.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"101 a 250\"), 175.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"251 y más\"), 350.0)\n",
+    "        .otherwise(1.0)\n",
+    "    )\n",
+    "\n",
+    "# --- 2.4 Preprocesamiento del Censo ---\n",
+    "# Reemplazar nulos por 0 en todas las columnas numéricas del censo\n",
+    "print(\"   Limpiando Censo: Reemplazando nulos por 0 en columnas numéricas.\")\n",
+    "# AHORA ESTA LÍNEA FUNCIONARÁ CORRECTAMENTE\n",
+    "numeric_censo_cols = [f.name for f in censo_sdf.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]\n",
+    "censo_sdf = censo_sdf.na.fill(0, subset=numeric_censo_cols)\n",
+    "\n",
+    "censo_count = censo_sdf.count()\n",
+    "denue_count = denue_sdf.count()\n",
+    "\n",
+    "print(f\"✅ Datos base cargados y pre-procesados. Censo: {censo_count:,} filas, DENUE: {denue_count:,} filas.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6a42d9d3-2c7f-4740-9fca-6d3da9e382f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "denue_sdf.show(n=2, truncate=False, vertical=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7c7938a9-ed6d-44c7-b7aa-20a2a2526ed9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 3: Creación del Dataset Balanceado (OXXO vs Abarrotes)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 3: Creando el dataset balanceado 'nacional_sdf'.\")\n",
+    "\n",
+    "# --- 3.1 Filtrar OXXOs y Abarrotes ---\n",
+    "oxxos_sdf = denue_sdf.filter(\n",
+    "    (col(\"codigo_act\") == '462112') &\n",
+    "    (col(\"nom_estab\").contains(\"oxxo\")) &\n",
+    "    (~col(\"nom_estab\").contains(\"distribuc\"))\n",
+    ").withColumn(\"klass\", lit(1))\n",
+    "\n",
+    "abarrotes_sdf = denue_sdf.filter(col(\"codigo_act\") == '461110').withColumn(\"klass\", lit(0))\n",
+    "\n",
+    "# --- 3.2 Muestreo Aleatorio y Unión ---\n",
+    "oxxo_count = oxxos_sdf.count()\n",
+    "print(f\"   Número de OXXOs encontrados: {oxxo_count:,}\")\n",
+    "abarrotes_sample_sdf = abarrotes_sdf.orderBy(rand(seed=42)).limit(oxxo_count)\n",
+    "\n",
+    "# --- 3.3 Creación del DataFrame 'nacional' ---\n",
+    "nacional_cols = [\"id\", \"klass\", \"codigo_act\", \"codigo_act_2c\", \"clee\", \"nom_estab\", \"cve_ent\", \"est_per_ocu\", \"geometry\"]\n",
+    "# Renombramos 'est_per_ocu' a 'personal' para coincidir con tu script\n",
+    "nacional_sdf = oxxos_sdf.select(nacional_cols).withColumnRenamed(\"est_per_ocu\", \"personal\") \\\n",
+    "                      .unionByName(abarrotes_sample_sdf.select(nacional_cols).withColumnRenamed(\"est_per_ocu\", \"personal\"))\n",
+    "\n",
+    "print(f\"✅ Dataset 'nacional_sdf' creado con {nacional_sdf.count():,} registros totales.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6e6df6a3-3e16-4a33-b2b9-a4a1e3351fa6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 4: Feature Engineering con Agregaciones Espaciales (Versión Corregida)\n",
+    "# =============================================================================\n",
+    "from pyspark.sql.types import IntegerType, DoubleType, LongType, FloatType\n",
+    "\n",
+    "print(\"\\n» Paso 4: Realizando Feature Engineering con Spatial Joins (esto puede tardar).\")\n",
+    "\n",
+    "# --- 4.1 Creación de Buffers---\n",
+    "print(\"   Creando buffers de 100m y 500m...\")\n",
+    "nacional_con_buffers = nacional_sdf \\\n",
+    "    .withColumn(\"buffer_100m\", expr(\"ST_Buffer(geometry, 100)\")) \\\n",
+    "    .withColumn(\"buffer_500m\", expr(\"ST_Buffer(geometry, 500)\"))\n",
+    "\n",
+    "# Esto evita que Spark tenga que recalcular los buffers cada vez.\n",
+    "print(f\"   Buffers creados Total de filas: {nacional_con_buffers.count()}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7b59c10c-7614-4806-bc8e-613e92daf345",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- 4.2 Función para agregar features de DENUE ---\n",
+    "def aggregate_denue_features(base_df, denue_df, buffer_col_name, suffix):\n",
+    "    print(f\"      Agregando features del DENUE para buffer {suffix}...\")\n",
+    "    \n",
+    "    # Spatial Join\n",
+    "    joined = base_df.join(denue_df.alias(\"d\"), expr(f\"ST_Intersects({buffer_col_name}, d.geometry)\"))\n",
+    "    \n",
+    "    # Agregación general de personal\n",
+    "    agg_epo = joined.groupBy(base_df.id).agg(_sum(\"d.est_per_ocu\").alias(f\"epo_{suffix}\"))\n",
+    "    \n",
+    "    # Agregación por actividad y pivote\n",
+    "    act_codes = ['51', '54', '11', '22', '52', '71', '43', '31', '61', '46', '23', '55', '93', '53', '81', '33', '48', '32', '56', '49', '62', '21', '72']\n",
+    "    # CORRECCIÓN: Especificamos el DataFrame para el 'id' en groupBy\n",
+    "    agg_pivot = joined.groupBy(base_df.id).pivot(\"d.codigo_act_2c\", act_codes).agg(_sum(\"d.est_per_ocu\"))\n",
+    "    \n",
+    "    # Renombrar columnas pivotadas\n",
+    "    for code in act_codes:\n",
+    "        agg_pivot = agg_pivot.withColumnRenamed(code, f\"act_{code}_{suffix}\")\n",
+    "        \n",
+    "    # Unir ambas agregaciones\n",
+    "    return agg_epo.join(agg_pivot, \"id\", \"outer\")\n",
+    "\n",
+    "# --- 4.3 Función para agregar features del Censo ---\n",
+    "def aggregate_censo_features(base_df, censo_df, buffer_col_name, suffix):\n",
+    "    print(f\"      Agregando features del CENSO para buffer {suffix}...\")\n",
+    "    \n",
+    "    # Spatial Join\n",
+    "    joined = base_df.join(censo_df.alias(\"c\"), expr(f\"ST_Intersects({buffer_col_name}, c.geometry)\"))\n",
+    "    \n",
+    "    # Crear dinámicamente las expresiones de agregación\n",
+    "    numeric_censo_cols = [f.name for f in censo_df.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]\n",
+    "    agg_exprs = [_sum(f\"c.{col}\").alias(f\"censo_{col}_{suffix}\") for col in numeric_censo_cols]\n",
+    "    \n",
+    "    return joined.groupBy(base_df.id).agg(*agg_exprs)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d8c12cb7-581c-4228-aa1b-aa5b94a8d10f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- 4.4 Ejecutar las agregaciones ---\n",
+    "denue_agg_100 = aggregate_denue_features(nacional_con_buffers, denue_sdf, \"buffer_100m\", \"100\")\n",
+    "denue_agg_500 = aggregate_denue_features(nacional_con_buffers, denue_sdf, \"buffer_500m\", \"500\")\n",
+    "censo_agg_100 = aggregate_censo_features(nacional_con_buffers, censo_sdf, \"buffer_100m\", \"100\")\n",
+    "censo_agg_500 = aggregate_censo_features(nacional_con_buffers, censo_sdf, \"buffer_500m\", \"500\")\n",
+    "\n",
+    "print(\"✅ Agregaciones de entorno completadas.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6185a452-2cac-4577-8de9-8925d6b7aad7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 5: Unión Final, Limpieza y Guardado (Versión Corregida y Robusta)\n",
+    "# =============================================================================\n",
+    "print(\"\\n» Paso 5: Uniendo todas las features en el dataset final.\")\n",
+    "\n",
+    "# --- 5.1 Unir todas las features de forma secuencial y limpia ---\n",
+    "# Empezamos con nuestro DataFrame base\n",
+    "final_sdf = nacional_sdf\n",
+    "\n",
+    "# Unimos cada tabla de agregados una por una, usando una condición de join simple\n",
+    "# y especificando que el tipo de join es 'left_outer'\n",
+    "final_sdf = final_sdf.join(denue_agg_100, \"id\", \"left_outer\")\n",
+    "final_sdf = final_sdf.join(denue_agg_500, \"id\", \"left_outer\")\n",
+    "final_sdf = final_sdf.join(censo_agg_100, \"id\", \"left_outer\")\n",
+    "final_sdf = final_sdf.join(censo_agg_500, \"id\", \"left_outer\")\n",
+    "\n",
+    "# --- 5.2 Limpieza Final ---\n",
+    "# Rellenar con 0 todos los valores nulos que resultaron de los left joins\n",
+    "final_sdf = final_sdf.na.fill(0)\n",
+    "\n",
+    "# Restar el personal del propio establecimiento de las columnas agregadas.\n",
+    "# Es importante asegurarse de que las columnas pivotadas existan antes de intentar usarlas.\n",
+    "# Si un código de actividad no tenía ningún negocio en un buffer, la columna no se creará.\n",
+    "# Para hacerlo robusto, verificamos si la columna existe.\n",
+    "if \"act_46_100\" in final_sdf.columns:\n",
+    "    final_sdf = final_sdf.withColumn(\"act_46_100\", col(\"act_46_100\") - col(\"personal\"))\n",
+    "\n",
+    "if \"act_46_500\" in final_sdf.columns:\n",
+    "    final_sdf = final_sdf.withColumn(\"act_46_500\", col(\"act_46_500\") - col(\"personal\"))\n",
+    "\n",
+    "# Hacemos lo mismo para el total de personal ocupado (epo)\n",
+    "if \"epo_100\" in final_sdf.columns:\n",
+    "    final_sdf = final_sdf.withColumn(\"epo_100\", col(\"epo_100\") - col(\"personal\"))\n",
+    "\n",
+    "if \"epo_500\" in final_sdf.columns:\n",
+    "    final_sdf = final_sdf.withColumn(\"epo_500\", col(\"epo_500\") - col(\"personal\"))\n",
+    "\n",
+    "\n",
+    "print(\"   Mostrando una muestra del dataset final para Machine Learning:\")\n",
+    "# Preparamos una lista de columnas a mostrar, verificando que existan\n",
+    "cols_to_show = [\"id\", \"klass\", \"personal\"]\n",
+    "if \"epo_100\" in final_sdf.columns: cols_to_show.append(\"epo_100\")\n",
+    "if \"act_46_100\" in final_sdf.columns: cols_to_show.append(\"act_46_100\")\n",
+    "if \"censo_POBTOT_100\" in final_sdf.columns: cols_to_show.append(\"censo_POBTOT_100\")\n",
+    "\n",
+    "final_sdf.select(cols_to_show).show()\n",
+    "\n",
+    "\n",
+    "# --- 5.3 Guardar el resultado en HDFS ---\n",
+    "OUTPUT_PATH_HDFS = \"hdfs:///data/processed/ml_dataset_final.geoparquet\"\n",
+    "print(f\"\\nGuardando el dataset final enriquecido en: {OUTPUT_PATH_HDFS}\")\n",
+    "\n",
+    "final_sdf.write.format(\"geoparquet\").mode(\"overwrite\").save(OUTPUT_PATH_HDFS)\n",
+    "\n",
+    "print(\"\\n✅ ¡Proceso completado! El dataset para ML está listo en HDFS.\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3ad38a2f-d3d4-46c1-ac98-b538c1e9d3b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 6: Inspección del Dataset Final\n",
+    "# =============================================================================\n",
+    "\n",
+    "print(\"\\n» Paso 6: Inspeccionando el esquema del dataset final para Machine Learning.\")\n",
+    "\n",
+    "# --- 1. Definir la ruta del archivo de resultado en HDFS ---\n",
+    "FINAL_DATASET_PATH = \"hdfs:///data/processed/ml_dataset_final.geoparquet\"\n",
+    "\n",
+    "# --- 2. Leer el dataset final desde HDFS ---\n",
+    "print(f\"   Leyendo el resultado desde: {FINAL_DATASET_PATH}\")\n",
+    "ml_dataset_sdf = spark.read.format(\"geoparquet\").load(FINAL_DATASET_PATH)\n",
+    "\n",
+    "# --- 3. Mostrar el Esquema Completo ---\n",
+    "print(\"\\n--- Esquema Completo del DataFrame Final ---\")\n",
+    "# .printSchema() es la forma estándar y más clara de ver la estructura\n",
+    "ml_dataset_sdf.printSchema()\n",
+    "\n",
+    "# --- 4. Mostrar una Muestra de los Datos para Contexto ---\n",
+    "print(\"\\n--- Muestra de los Datos Finales (primeras 5 filas) ---\")\n",
+    "# Seleccionamos algunas columnas clave de cada categoría de features para verificar\n",
+    "# que la unión fue exitosa y los valores tienen sentido.\n",
+    "cols_to_show = [\n",
+    "    \"id\",\n",
+    "    \"klass\",\n",
+    "    \"personal\",\n",
+    "    \"epo_100\",          # Agregado DENUE general\n",
+    "    \"act_46_100\",       # Agregado DENUE por actividad\n",
+    "    \"censo_POBTOT_100\", # Agregado CENSO\n",
+    "    \"epo_500\",          # Agregado DENUE general (500m)\n",
+    "    \"act_46_500\",       # Agregado DENUE por actividad (500m)\n",
+    "    \"censo_POBTOT_500\"  # Agregado CENSO (500m)\n",
+    "]\n",
+    "\n",
+    "# Filtramos las columnas que realmente existen en el DataFrame para evitar errores\n",
+    "existing_cols_to_show = [col_name for col_name in cols_to_show if col_name in ml_dataset_sdf.columns]\n",
+    "\n",
+    "ml_dataset_sdf.select(existing_cols_to_show).show()\n",
+    "\n",
+    "\n",
+    "# --- 5. Opcional: Detener la sesión si ya no la necesitas ---\n",
+    "# print(\"\\nSi has terminado tu análisis, puedes detener la sesión con spark.stop()\")\n",
+    "# spark.stop()\n",
+    "# print(\"✅ Sesión de Spark detenida.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9ac2708a-5549-4b2d-ab66-df08eb090ce3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# --- 6. Detener la sesión de Spark ---\n",
+    "spark.stop()\n",
+    "print(\"✅ Sesión de Spark detenida.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5afefad-0cda-4c09-b957-fc2b9ad3fd33",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c5298500-7c6d-4a8e-a870-5d4abf8a6f2d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cuadernos/semana_4/03_ClasificacionSupervisada_GBT.ipynb

@@ -0,0 +1,298 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# S4 · Ejercicio 5b — Entrenar y evaluar el modelo OXXO (GBT)\n",
+    "\n",
+    "**Curso de Big Data · Dr. Abel Coronado** · Semana 4\n",
+    "\n",
+    "🎯 **Objetivo.** Entrenar un GBTClassifier sobre el dataset balanceado, evaluar (Accuracy/F1/AUC/matriz de confusión) y guardar el modelo en HDFS.\n",
+    "\n",
+    "📦 **Datos.** `/data/processed/ml_dataset_final.geoparquet` (salida del 5a).\n",
+    "\n",
+    "✅ **Prerrequisitos.** Ejercicio 5a completado.\n",
+    "\n",
+    "📝 **Entregable.** Modelo en `hdfs:///models/gbt_oxxo_model` + reporte de métricas (AUC esperado ~0.92).\n",
+    "\n",
+    "🛠️ **Stack del laboratorio.** Spark 4.0 · Sedona 1.8.0 (_2.13) · HDFS 3.3.6 · Elasticsearch 8.14 · JupyterLab\n",
+    "\n",
+    "⬇️ **Descarga (Hugging Face):** https://huggingface.co/datasets/abxda/bdp-lab/resolve/main/cuadernos/semana_4/03_ClasificacionSupervisada_GBT.ipynb\n",
+    "\n",
+    "💬 **¿Un error?** Toma una captura (celda + mensaje) y repórtalo por **Blackboard**, indicando tu SO y el paso.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> Cuaderno **probado** en el laboratorio (Spark 4.0). Lee los comentarios de cada celda: explican el porqué de cada paso.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "2a2082c7-71d2-43c2-b240-16a9f98e4cc8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 1: Inicialización de Spark y Sedona\n",
+    "# =============================================================================\n",
+    "from pyspark.sql import SparkSession\n",
+    "import pyspark.sql.functions as F\n",
+    "from pyspark.sql.functions import col, expr, lower, substring, when, rand, lit, sum as _sum\n",
+    "from sedona.spark import SedonaContext\n",
+    "\n",
+    "# Detener cualquier sesión previa para una inicialización limpia\n",
+    "try:\n",
+    "    spark.stop()\n",
+    "    print(\"Sesión de Spark anterior detenida.\")\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "print(\"» Paso 1: Configurando la sesión de Spark para un procesamiento geoespacial intensivo...\")\n",
+    "spark = (\n",
+    "    SparkSession.builder.appName(\"FeatureEngineeringOXXO_HDFS\")\n",
+    "    .config(\"spark.driver.memory\", \"4g\")\n",
+    "    .config(\"spark.sql.shuffle.partitions\", \"200\") # Optimización para los joins\n",
+    "    .config(\n",
+    "        \"spark.jars.packages\",\n",
+    "        \"org.apache.sedona:sedona-spark-4.0_2.13:1.8.0,\"\n",
+    "        \"org.datasyslab:geotools-wrapper:1.8.0-33.1\"\n",
+    "    )\n",
+    "    .config(\"spark.serializer\", \"org.apache.spark.serializer.KryoSerializer\")\n",
+    "    .config(\"spark.kryo.registrator\", \"org.apache.sedona.core.serde.SedonaKryoRegistrator\")\n",
+    "    .config(\"spark.sql.extensions\", \"org.apache.sedona.sql.SedonaSqlExtensions\")\n",
+    "    .getOrCreate()\n",
+    ")\n",
+    "\n",
+    "sedona = SedonaContext.create(spark)\n",
+    "print(\"✅ Sesión de Spark con Apache Sedona iniciada correctamente.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d479f2a0-7b6c-4f7e-ab2d-eb8e5768fce0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 1: Preparación de Datos para Machine Learning (Versión Corregida)\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.feature import VectorAssembler\n",
+    "from pyspark.sql.functions import col\n",
+    "import pyspark.sql.functions as F\n",
+    "\n",
+    "# --- LÍNEA DE CORRECCIÓN AÑADIDA AQUÍ ---\n",
+    "# Importamos las clases de tipos de datos desde el módulo correcto\n",
+    "from pyspark.sql.types import IntegerType, DoubleType, LongType, FloatType\n",
+    "\n",
+    "\n",
+    "print(\"\\n» Paso 2: Preparando el dataset para el entrenamiento del modelo.\")\n",
+    "\n",
+    "# --- 1. Cargar el dataset final si no está en memoria ---\n",
+    "if 'ml_dataset_sdf' not in locals():\n",
+    "    FINAL_DATASET_PATH = \"hdfs:///data/processed/ml_dataset_final.geoparquet\"\n",
+    "    print(f\"   Leyendo el dataset final desde: {FINAL_DATASET_PATH}\")\n",
+    "    ml_dataset_sdf = spark.read.format(\"geoparquet\").load(FINAL_DATASET_PATH)\n",
+    "\n",
+    "# --- 2. Seleccionar las Features y el Label ---\n",
+    "# Lista de columnas a excluir del conjunto de features\n",
+    "cols_to_exclude = [\n",
+    "    'id', 'klass', 'codigo_act', 'codigo_act_2c', 'clee',\n",
+    "    'nom_estab', 'cve_ent', 'geometry'\n",
+    "]\n",
+    "\n",
+    "# Obtenemos la lista de todas las columnas numéricas automáticamente\n",
+    "# AHORA ESTA LÍNEA FUNCIONARÁ CORRECTAMENTE\n",
+    "all_numeric_cols = [f.name for f in ml_dataset_sdf.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]\n",
+    "\n",
+    "# Filtramos para obtener la lista final de features\n",
+    "feature_cols = [c for c in all_numeric_cols if c not in cols_to_exclude]\n",
+    "\n",
+    "print(f\"\\n   Se usarán {len(feature_cols)} columnas como features.\")\n",
+    "print(f\"   La variable objetivo (label) es: 'klass'\")\n",
+    "\n",
+    "print(\"\\n   Guardando la lista de columnas de features para la inferencia...\")\n",
+    "features_df_to_save = spark.createDataFrame(feature_cols, \"string\")\n",
+    "FEATURES_LIST_PATH = \"hdfs:///models/gbt_oxxo_model_features\"\n",
+    "features_df_to_save.coalesce(1).write.mode(\"overwrite\").text(FEATURES_LIST_PATH)\n",
+    "print(f\"✅ Lista de features guardada en: {FEATURES_LIST_PATH}\")\n",
+    "\n",
+    "# --- 3. Crear el Vector de Features ---\n",
+    "assembler = VectorAssembler(\n",
+    "    inputCols=feature_cols,\n",
+    "    outputCol=\"features\",\n",
+    "    handleInvalid=\"skip\"\n",
+    ")\n",
+    "\n",
+    "model_data_sdf = assembler.transform(ml_dataset_sdf)\n",
+    "model_data_sdf = model_data_sdf.withColumnRenamed(\"klass\", \"label\")\n",
+    "final_prepared_data = model_data_sdf.select(\"label\", \"features\")\n",
+    "\n",
+    "print(\"\\n   Dataset preparado. Mostrando una muestra con la columna 'features' vectorizada:\")\n",
+    "final_prepared_data.show(5, truncate=50)\n",
+    "\n",
+    "print(\"\\n✅ Datos listos para el pipeline de Machine Learning.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "88e07d4d-8ce5-4d78-a869-4e7759642dee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 2: Entrenamiento del Modelo de Clasificación (GBT)\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.classification import GBTClassifier\n",
+    "from pyspark.ml.evaluation import MulticlassClassificationEvaluator, BinaryClassificationEvaluator\n",
+    "\n",
+    "# --- 1. División en Conjuntos de Entrenamiento y Prueba ---\n",
+    "# Usamos una división 80/20, con una semilla para reproducibilidad\n",
+    "(training_data, test_data) = final_prepared_data.randomSplit([0.8, 0.2], seed=42)\n",
+    "\n",
+    "print(\"Datos divididos en conjuntos de entrenamiento y prueba:\")\n",
+    "print(f\"   Registros de entrenamiento: {training_data.count():,}\")\n",
+    "print(f\"   Registros de prueba: {test_data.count():,}\")\n",
+    "\n",
+    "# --- 2. Definir el Modelo ---\n",
+    "# Usamos GBTClassifier, el equivalente de Gradient-Boosted Trees en Spark.\n",
+    "gbt = GBTClassifier(\n",
+    "    featuresCol=\"features\",\n",
+    "    labelCol=\"label\",\n",
+    "    maxDepth=5,       # Profundidad máxima de los árboles\n",
+    "    maxIter=20        # Número de árboles a entrenar\n",
+    ")\n",
+    "\n",
+    "# --- 3. Entrenar el Modelo ---\n",
+    "print(\"\\nEntrenando el modelo GBTClassifier... (Esto puede tardar varios minutos)\")\n",
+    "gbt_model = gbt.fit(training_data)\n",
+    "print(\"✅ Modelo entrenado exitosamente.\")\n",
+    "\n",
+    "# --- 4. Realizar Predicciones en el Conjunto de Prueba ---\n",
+    "print(\"\\nRealizando predicciones en el conjunto de prueba...\")\n",
+    "predictions = gbt_model.transform(test_data)\n",
+    "\n",
+    "print(\"   Muestra de las predicciones:\")\n",
+    "predictions.select(\"label\", \"prediction\", \"probability\").show(10)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5911733e-bcb6-4c23-a9cd-0ca7f53b9d50",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 3: Evaluación del Rendimiento del Modelo\n",
+    "# =============================================================================\n",
+    "\n",
+    "print(\"\\n» Paso 8: Evaluando el rendimiento del modelo entrenado.\")\n",
+    "\n",
+    "# --- 1. Métricas de Clasificación Múltiple ---\n",
+    "# Usaremos MulticlassClassificationEvaluator para obtener Accuracy, F1, etc.\n",
+    "\n",
+    "# Accuracy\n",
+    "evaluator_acc = MulticlassClassificationEvaluator(labelCol=\"label\", predictionCol=\"prediction\", metricName=\"accuracy\")\n",
+    "accuracy = evaluator_acc.evaluate(predictions)\n",
+    "print(f\"\\n   Accuracy: {accuracy:.4f}\")\n",
+    "\n",
+    "# F1 Score\n",
+    "evaluator_f1 = MulticlassClassificationEvaluator(labelCol=\"label\", predictionCol=\"prediction\", metricName=\"f1\")\n",
+    "f1_score = evaluator_f1.evaluate(predictions)\n",
+    "print(f\"   F1 Score: {f1_score:.4f}\")\n",
+    "\n",
+    "# Precision\n",
+    "evaluator_precision = MulticlassClassificationEvaluator(labelCol=\"label\", predictionCol=\"prediction\", metricName=\"weightedPrecision\")\n",
+    "precision = evaluator_precision.evaluate(predictions)\n",
+    "print(f\"   Weighted Precision: {precision:.4f}\")\n",
+    "\n",
+    "# Recall\n",
+    "evaluator_recall = MulticlassClassificationEvaluator(labelCol=\"label\", predictionCol=\"prediction\", metricName=\"weightedRecall\")\n",
+    "recall = evaluator_recall.evaluate(predictions)\n",
+    "print(f\"   Weighted Recall: {recall:.4f}\")\n",
+    "\n",
+    "# --- 2. Métrica de Clasificación Binaria (AUC) ---\n",
+    "# Usaremos BinaryClassificationEvaluator para el Área Bajo la Curva ROC.\n",
+    "evaluator_auc = BinaryClassificationEvaluator(labelCol=\"label\", rawPredictionCol=\"rawPrediction\", metricName=\"areaUnderROC\")\n",
+    "auc = evaluator_auc.evaluate(predictions)\n",
+    "print(f\"\\n   Area Under ROC (AUC): {auc:.4f}\")\n",
+    "\n",
+    "\n",
+    "# --- 3. Matriz de Confusión ---\n",
+    "# La creamos manualmente agrupando los resultados\n",
+    "print(\"\\n   Matriz de Confusión:\")\n",
+    "predictions.groupBy('label', 'prediction').count().show()\n",
+    "\n",
+    "print(\"\\n✅ Evaluación del modelo completada.\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c0982c95-a21d-4efe-b2b2-1e262c2163f2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 4: Guardado del Modelo Entrenado\n",
+    "# =============================================================================\n",
+    "\n",
+    "print(\"\\n» Guardando el modelo GBT entrenado en HDFS.\")\n",
+    "\n",
+    "# --- 1. Definir la ruta de guardado en HDFS ---\n",
+    "MODEL_PATH_HDFS = \"hdfs:///models/gbt_oxxo_model\"\n",
+    "\n",
+    "# --- 2. Guardar el modelo ---\n",
+    "# Usamos .overwrite() para poder re-entrenar y guardar nuevas versiones del modelo\n",
+    "# sin tener que borrar manualmente la carpeta.\n",
+    "gbt_model.write().overwrite().save(MODEL_PATH_HDFS)\n",
+    "\n",
+    "print(f\"✅ Modelo guardado exitosamente en: {MODEL_PATH_HDFS}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f30f8ed1-4ceb-44fa-b8ce-ff40d800af9b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "spark.stop()\n",
+    "print(\"\\n✅ Sesión de Spark detenida.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9a72757d-dba1-48ab-b4a1-7b674e7cec26",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cuadernos/semana_4/04_PrediccionPorCoordenada.ipynb

@@ -0,0 +1,413 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# S4 · Ejercicio 5c — Inferencia: predecir por coordenada\n",
+    "\n",
+    "**Curso de Big Data · Dr. Abel Coronado** · Semana 4\n",
+    "\n",
+    "🎯 **Objetivo.** Cargar el modelo guardado y predecir OXXO vs Abarrotes para una coordenada nueva, recalculando sus features espaciales en vivo.\n",
+    "\n",
+    "📦 **Datos.** Modelo `gbt_oxxo_model` + censo/denue en HDFS.\n",
+    "\n",
+    "✅ **Prerrequisitos.** Ejercicio 5b completado. Requiere pyproj.\n",
+    "\n",
+    "📝 **Entregable.** Predicción (clase + probabilidad) para al menos 2 coordenadas de prueba.\n",
+    "\n",
+    "🛠️ **Stack del laboratorio.** Spark 4.0 · Sedona 1.8.0 (_2.13) · HDFS 3.3.6 · Elasticsearch 8.14 · JupyterLab\n",
+    "\n",
+    "⬇️ **Descarga (Hugging Face):** https://huggingface.co/datasets/abxda/bdp-lab/resolve/main/cuadernos/semana_4/04_PrediccionPorCoordenada.ipynb\n",
+    "\n",
+    "💬 **¿Un error?** Toma una captura (celda + mensaje) y repórtalo por **Blackboard**, indicando tu SO y el paso.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> Cuaderno **probado** en el laboratorio (Spark 4.0). Lee los comentarios de cada celda: explican el porqué de cada paso.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "383f3cfd-f5ad-40b3-8ac2-cefac331849a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 1: Inicialización de Spark y Sedona\n",
+    "# =============================================================================\n",
+    "from pyspark.sql import SparkSession\n",
+    "import pyspark.sql.functions as F\n",
+    "from pyspark.sql.functions import col, expr, lit, sum as _sum\n",
+    "from sedona.spark import SedonaContext\n",
+    "\n",
+    "# Detener cualquier sesión previa para una inicialización limpia\n",
+    "try:\n",
+    "    spark.stop()\n",
+    "    print(\"Sesión de Spark anterior detenida.\")\n",
+    "except:\n",
+    "    pass\n",
+    "\n",
+    "print(\"» Paso 1: Configurando la sesión de Spark para un procesamiento geoespacial...\")\n",
+    "spark = (\n",
+    "    SparkSession.builder.appName(\"PrediccionOXXO_HDFS\")\n",
+    "    .config(\"spark.driver.memory\", \"4g\")\n",
+    "    .config(\n",
+    "        \"spark.jars.packages\",\n",
+    "        \"org.apache.sedona:sedona-spark-4.0_2.13:1.8.0,\"\n",
+    "        \"org.datasyslab:geotools-wrapper:1.8.0-33.1\"\n",
+    "    )\n",
+    "    .config(\"spark.serializer\", \"org.apache.spark.serializer.KryoSerializer\")\n",
+    "    .config(\"spark.kryo.registrator\", \"org.apache.sedona.core.serde.SedonaKryoRegistrator\")\n",
+    "    .config(\"spark.sql.extensions\", \"org.apache.sedona.sql.SedonaSqlExtensions\")\n",
+    "    .getOrCreate()\n",
+    ")\n",
+    "\n",
+    "sedona = SedonaContext.create(spark)\n",
+    "print(\"✅ Sesión de Spark con Apache Sedona iniciada correctamente.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a4001447-b043-43f5-a47f-884225233b64",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 2: Carga de Datos y Modelo\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.classification import GBTClassificationModel\n",
+    "from pyspark.sql.functions import col, lower, substring, when\n",
+    "from pyspark.sql.types import IntegerType, DoubleType, LongType, FloatType\n",
+    "\n",
+    "print(\"\\n» Paso 2: Cargando recursos necesarios desde HDFS.\")\n",
+    "\n",
+    "# --- 2.1 Definir las rutas en HDFS ---\n",
+    "CENSO_PATH_HDFS = \"hdfs:///data/raw/geodatos_mexico/censo_2020_nacional.parquet\"\n",
+    "DENUE_PATH_HDFS = \"hdfs:///data/raw/geodatos_mexico/denue_nacional.parquet\"\n",
+    "MODEL_PATH_HDFS = \"hdfs:///models/gbt_oxxo_model\"\n",
+    "\n",
+    "# --- 2.2 Cargar DataFrames ---\n",
+    "print(f\"   Cargando Censo desde: {CENSO_PATH_HDFS}\")\n",
+    "censo_sdf = spark.read.format(\"geoparquet\").load(CENSO_PATH_HDFS)\n",
+    "\n",
+    "print(f\"   Cargando DENUE desde: {DENUE_PATH_HDFS}\")\n",
+    "denue_raw_sdf = spark.read.format(\"geoparquet\").load(DENUE_PATH_HDFS)\n",
+    "\n",
+    "# --- 2.3 Cargar el Modelo GBT ---\n",
+    "print(f\"   Cargando modelo GBT desde: {MODEL_PATH_HDFS}\")\n",
+    "gbt_model = GBTClassificationModel.load(MODEL_PATH_HDFS)\n",
+    "print(\"✅ Modelo cargado exitosamente.\")\n",
+    "\n",
+    "# --- 2.4 Preprocesamiento de DENUE y Censo (IDÉNTICO AL DEL ENTRENAMIENTO) ---\n",
+    "# Es crucial replicar exactamente el mismo pre-procesamiento.\n",
+    "print(\"   Pre-procesando DENUE y Censo...\")\n",
+    "denue_sdf = denue_raw_sdf.withColumn(\"codigo_act_2c\", substring(col(\"codigo_act\"), 1, 2)) \\\n",
+    "    .withColumn(\"est_per_ocu\",\n",
+    "        when(col(\"per_ocu\").contains(\"0 a 5\"), 2.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"6 a 10\"), 8.0)\n",
+    "        .when(col(\"per_ocu\").contains(\"11 a 30\"), 20.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"31 a 50\"), 40.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"51 a 100\"), 75.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"101 a 250\"), 175.5)\n",
+    "        .when(col(\"per_ocu\").contains(\"251 y más\"), 350.0)\n",
+    "        .otherwise(1.0)\n",
+    "    )\n",
+    "\n",
+    "numeric_censo_cols = [f.name for f in censo_sdf.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]\n",
+    "censo_sdf = censo_sdf.na.fill(0, subset=numeric_censo_cols)\n",
+    "\n",
+    "print(\"✅ Recursos cargados y pre-procesados.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "58558096-c896-48c9-8f1d-f8e6a331ff3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 3: Función de Inferencia (Versión Corregida y Robusta)\n",
+    "# =============================================================================\n",
+    "from pyspark.ml.feature import VectorAssembler\n",
+    "from pyspark.sql.functions import lit\n",
+    "import pyproj # Asegúrate de que esta librería está disponible\n",
+    "\n",
+    "# --- Copiamos las mismas funciones de agregación (sin cambios) ---\n",
+    "def aggregate_denue_features(base_df, denue_df, buffer_col_name, suffix):\n",
+    "    joined = base_df.join(denue_df.alias(\"d\"), expr(f\"ST_Intersects({buffer_col_name}, d.geometry)\"))\n",
+    "    agg_epo = joined.groupBy(base_df.id).agg(_sum(\"d.est_per_ocu\").alias(f\"epo_{suffix}\"))\n",
+    "    act_codes = ['51', '54', '11', '22', '52', '71', '43', '31', '61', '46', '23', '55', '93', '53', '81', '33', '48', '32', '56', '49', '62', '21', '72']\n",
+    "    agg_pivot = joined.groupBy(base_df.id).pivot(\"d.codigo_act_2c\", act_codes).agg(_sum(\"d.est_per_ocu\"))\n",
+    "    for code in act_codes:\n",
+    "        agg_pivot = agg_pivot.withColumnRenamed(code, f\"act_{code}_{suffix}\")\n",
+    "    return agg_epo.join(agg_pivot, \"id\", \"outer\")\n",
+    "\n",
+    "def aggregate_censo_features(base_df, censo_df, buffer_col_name, suffix):\n",
+    "    joined = base_df.join(censo_df.alias(\"c\"), expr(f\"ST_Intersects({buffer_col_name}, c.geometry)\"))\n",
+    "    numeric_censo_cols = [f.name for f in censo_df.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]\n",
+    "    agg_exprs = [_sum(f\"c.{col}\").alias(f\"censo_{col}_{suffix}\") for col in numeric_censo_cols]\n",
+    "    return joined.groupBy(base_df.id).agg(*agg_exprs)\n",
+    "\n",
+    "# --- Función de conversión de coordenadas ---\n",
+    "def convertir_4326_a_6372(lon, lat):\n",
+    "    crs_origen = pyproj.CRS(\"EPSG:4326\")\n",
+    "    crs_destino = pyproj.CRS(\"EPSG:6372\")\n",
+    "    transformador = pyproj.Transformer.from_crs(crs_origen, crs_destino, always_xy=True)\n",
+    "    x_6372, y_6372 = transformador.transform(lon, lat)\n",
+    "    return (x_6372, y_6372)\n",
+    "\n",
+    "\n",
+    "# --- Función principal para la predicción (CORREGIDA) ---\n",
+    "def predecir_potencial_tienda(lat, lon):\n",
+    "    \"\"\"\n",
+    "    Calcula todas las features para una coordenada dada, usa el modelo cargado\n",
+    "    para predecir y devuelve el resultado.\n",
+    "    \"\"\"\n",
+    "    print(f\"\\nCalculando features para la coordenada (Lat: {lat}, Lon: {lon})...\")\n",
+    "\n",
+    "    # 1. Cargar la lista de features EXACTAS usadas en el entrenamiento\n",
+    "    FEATURES_LIST_PATH = \"hdfs:///models/gbt_oxxo_model_features\"\n",
+    "    training_feature_cols = spark.read.text(FEATURES_LIST_PATH).rdd.map(lambda row: row.value).collect()\n",
+    "    print(f\"   Se usarán {len(training_feature_cols)} features consistentes con el modelo.\")\n",
+    "\n",
+    "    # 2. Convertir coordenadas y crear DataFrame inicial\n",
+    "    x_proj, y_proj = convertir_4326_a_6372(lon, lat)\n",
+    "    point_df = spark.createDataFrame([(1, x_proj, y_proj)], [\"id\", \"x\", \"y\"]) \\\n",
+    "                    .withColumn(\"geometry\", expr(\"ST_Point(x, y)\"))\n",
+    "\n",
+    "    # 3. Crear buffers y calcular features agregadas (igual que antes)\n",
+    "    point_with_buffers = point_df.withColumn(\"buffer_100m\", expr(\"ST_Buffer(geometry, 100)\")).withColumn(\"buffer_500m\", expr(\"ST_Buffer(geometry, 500)\"))\n",
+    "    denue_agg_100 = aggregate_denue_features(point_with_buffers, denue_sdf, \"buffer_100m\", \"100\")\n",
+    "    denue_agg_500 = aggregate_denue_features(point_with_buffers, denue_sdf, \"buffer_500m\", \"500\")\n",
+    "    censo_agg_100 = aggregate_censo_features(point_with_buffers, censo_sdf, \"buffer_100m\", \"100\")\n",
+    "    censo_agg_500 = aggregate_censo_features(point_with_buffers, censo_sdf, \"buffer_500m\", \"500\")\n",
+    "\n",
+    "    # 4. Unir todo\n",
+    "    features_df = point_df.select(\"id\") \\\n",
+    "        .join(denue_agg_100, \"id\", \"left_outer\") \\\n",
+    "        .join(denue_agg_500, \"id\", \"left_outer\") \\\n",
+    "        .join(censo_agg_100, \"id\", \"left_outer\") \\\n",
+    "        .join(censo_agg_500, \"id\", \"left_outer\") \\\n",
+    "        .na.fill(0)\n",
+    "\n",
+    "    # 5. *** ASEGURAR TODAS LAS COLUMNAS ***\n",
+    "    # Iterar sobre la lista de features del entrenamiento. Si una columna no existe\n",
+    "    # en nuestro DataFrame de predicción, la añadimos con valor 0.\n",
+    "    existing_cols = features_df.columns\n",
+    "    for col_name in training_feature_cols:\n",
+    "        if col_name not in existing_cols:\n",
+    "            features_df = features_df.withColumn(col_name, lit(0))\n",
+    "    # 6. Ensamblar el vector de features usando la lista del entrenamiento\n",
+    "    assembler = VectorAssembler(inputCols=training_feature_cols, outputCol=\"features\", handleInvalid=\"skip\")\n",
+    "    final_df = assembler.transform(features_df)\n",
+    "\n",
+    "    # 7. Realizar la predicción\n",
+    "    print(\"   Realizando predicción con el modelo GBT...\")\n",
+    "    prediction_result = gbt_model.transform(final_df)\n",
+    "\n",
+    "    # 8. Extraer y devolver el resultado\n",
+    "    result_row = prediction_result.select(\"prediction\", \"probability\").first()\n",
+    "    prediction = result_row['prediction']\n",
+    "    probability = result_row['probability']\n",
+    "    clase = \"OXXO\" if prediction == 1.0 else \"Abarrotes\"\n",
+    "    confianza = probability[int(prediction)] * 100\n",
+    "    \n",
+    "    return clase, confianza\n",
+    "\n",
+    "print(\"✅ Función de inferencia (con consistencia de features) definida.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "13a2bd5f-9141-4111-8ce0-a3ab0956c54d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#python -m pip install pyproj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b2ed25f7-f823-4bf0-96ea-c9d6789cfc2e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pyproj\n",
+    "\n",
+    "def convertir_4326_a_6372(lon, lat):\n",
+    "    # Definir los sistemas de coordenadas de origen (WGS84) y destino (ITRF2008 / Mexico)\n",
+    "    crs_origen = pyproj.CRS(\"EPSG:4326\")\n",
+    "    crs_destino = pyproj.CRS(\"EPSG:6372\")\n",
+    "    # Crear el objeto para transformar entre los dos sistemas\n",
+    "    # always_xy=True asegura que el orden de entrada es (longitud, latitud)\n",
+    "    transformador = pyproj.Transformer.from_crs(crs_origen, crs_destino, always_xy=True)\n",
+    "    # Realizar la transformación\n",
+    "    x_6372, y_6372 = transformador.transform(lon, lat)\n",
+    "    return (x_6372, y_6372)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "eb9bce06-e95c-4084-a9f7-7d977f2c1131",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 4: Probar la Predicción\n",
+    "# =============================================================================\n",
+    "\n",
+    "# --- Define las coordenadas de la nueva ubicación a evaluar ---\n",
+    "# Ejemplo 1: Una zona residencial en la Ciudad de México\n",
+    "latitud_usuario = 19.3541\n",
+    "longitud_usuario = -99.1687\n",
+    "clase_predicha, confianza_prediccion = predecir_potencial_tienda(latitud_usuario, longitud_usuario)\n",
+    "\n",
+    "# --- Mostrar el resultado de forma clara ---\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"              RESULTADO DE LA PREDICCIÓN\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"Coordenadas       : Lat {latitud_usuario}, Lon {longitud_usuario}\")\n",
+    "print(f\"Potencial sugerido: {clase_predicha}\")\n",
+    "print(f\"Confianza         : {confianza_prediccion:.2f}%\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "7e3b54e0-9301-43cc-adbf-7f41b56037f3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# =============================================================================\n",
+    "# Celda 4: Probar la Predicción\n",
+    "# =============================================================================\n",
+    " \n",
+    "# --- Define las coordenadas de la nueva ubicación a evaluar ---\n",
+    "# Ejemplo 1: Una zona residencial en la Aguascalientes\n",
+    "latitud_usuario = 21.936843851728213\n",
+    "longitud_usuario = -102.2605316444216\n",
+    "clase_predicha, confianza_prediccion = predecir_potencial_tienda(latitud_usuario, longitud_usuario)\n",
+    "\n",
+    "# --- Mostrar el resultado de forma clara ---\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"              RESULTADO DE LA PREDICCIÓN\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"Coordenadas       : Lat {latitud_usuario}, Lon {longitud_usuario}\")\n",
+    "print(f\"Potencial sugerido: {clase_predicha}\")\n",
+    "print(f\"Confianza         : {confianza_prediccion:.2f}%\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "f5362942-22b1-4c68-bac9-d4b5da4e8548",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# =============================================================================\n",
+    "# Celda 4: Probar la Predicción\n",
+    "# =============================================================================\n",
+    " \n",
+    "# --- Define las coordenadas de la nueva ubicación a evaluar ---\n",
+    "# Ejemplo 1: Una zona residencial en la Aguascalientes\n",
+    "latitud_usuario = 20.6496963691001\n",
+    "longitud_usuario = -103.26470786900687\n",
+    "clase_predicha, confianza_prediccion = predecir_potencial_tienda(latitud_usuario, longitud_usuario)\n",
+    "\n",
+    "# --- Mostrar el resultado de forma clara ---\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"              RESULTADO DE LA PREDICCIÓN\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"Coordenadas       : Lat {latitud_usuario}, Lon {longitud_usuario}\")\n",
+    "print(f\"Potencial sugerido: {clase_predicha}\")\n",
+    "print(f\"Confianza         : {confianza_prediccion:.2f}%\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bc8702e-594e-472d-a875-9c5602aea45b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#curl -X POST http://localhost:5001/predict -H \"Content-Type: application/json\" -d \"{\\\"latitude\\\": 20.6496963691001, \\\"longitude\\\": -103.26470786900687}\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "26e4e326-a9a9-4518-8e64-1c17018c3847",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "050a7f15-859d-4aef-8be8-a82f56f2e992",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# =============================================================================\n",
+    "# Celda 4: Probar la Predicción\n",
+    "# =============================================================================\n",
+    " \n",
+    "# --- Define las coordenadas de la nueva ubicación a evaluar ---\n",
+    "#Primer anillo Santa Anita Avenida importante\n",
+    "latitud_usuario = 21.894639049283427\n",
+    "longitud_usuario = -102.27747206999581\n",
+    "clase_predicha, confianza_prediccion = predecir_potencial_tienda(latitud_usuario, longitud_usuario)\n",
+    "\n",
+    "# --- Mostrar el resultado de forma clara ---\n",
+    "print(\"\\n\" + \"=\"*50)\n",
+    "print(\"              RESULTADO DE LA PREDICCIÓN\")\n",
+    "print(\"=\"*50)\n",
+    "print(f\"Coordenadas       : Lat {latitud_usuario}, Lon {longitud_usuario}\")\n",
+    "print(f\"Potencial sugerido: {clase_predicha}\")\n",
+    "print(f\"Confianza         : {confianza_prediccion:.2f}%\")\n",
+    "print(\"=\"*50)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "ffa42242-d79c-4998-beab-70f7700a18cb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

cuadernos/semana_4/05_api.py

@@ -0,0 +1,194 @@
+# api.py
+import os
+import sys
+from flask import Flask, request, jsonify
+
+# =============================================================================
+# --- CONFIGURACIÓN CRÍTICA DE ENTORNO PARA SPARK ---
+# =============================================================================
+
+# Especifica la ruta a tu ejecutable de Python.
+# ¡¡¡DEBES AJUSTAR ESTA RUTA A TU PROPIA INSTALACIÓN!!!
+# Puedes encontrarla ejecutando en tu terminal: where python
+import sys as _sys
+PYTHON_EXECUTABLE_PATH = _sys.executable  # autodetección (corregido)
+
+if not os.path.exists(PYTHON_EXECUTABLE_PATH):
+    raise FileNotFoundError(f"El ejecutable de Python no se encontró en: {PYTHON_EXECUTABLE_PATH}\n"
+                            "Por favor, ajusta la variable PYTHON_EXECUTABLE_PATH en el script api.py.")
+
+os.environ['PYSPARK_PYTHON'] = PYTHON_EXECUTABLE_PATH
+os.environ['PYSPARK_DRIVER_PYTHON'] = PYTHON_EXECUTABLE_PATH
+
+# Si Spark no está en el PATH del sistema, también puedes añadir esto:
+# os.environ['SPARK_HOME'] = r'C:\BDP\spark'
+# sys.path.append(os.path.join(os.environ['SPARK_HOME'], 'python'))
+# sys.path.append(os.path.join(os.environ['SPARK_HOME'], 'python', 'lib', 'py4j-0.10.9.7-src.zip'))
+
+
+from pyspark.sql import SparkSession
+import pyspark.sql.functions as F
+from pyspark.sql.functions import col, expr, lit, sum as _sum
+from pyspark.ml.classification import GBTClassificationModel
+from pyspark.ml.feature import VectorAssembler
+from pyspark.sql.types import IntegerType, DoubleType, LongType, FloatType
+from sedona.spark import SedonaContext
+import pyproj
+
+# =============================================================================
+# 1. INICIALIZACIÓN GLOBAL DE LA API Y SPARK
+# =============================================================================
+print("--- INICIANDO SERVIDOR DE PREDICCIÓN ---")
+
+app = Flask(__name__)
+
+print("» Paso 1: Configurando la sesión de Spark (esto puede tardar)...")
+
+HDFS_NAMENODE_HOST = "localhost" # Ajustado para un entorno local común
+HDFS_NAMENODE_PORT = "9000"
+
+spark = (
+    SparkSession.builder.appName("API_PrediccionOXXO")
+    .config("spark.driver.memory", "4g")
+    .config(
+        "spark.jars.packages",
+        "org.apache.sedona:sedona-spark-4.0_2.13:1.8.0,"
+        "org.datasyslab:geotools-wrapper:1.8.0-33.1"
+    )
+    .config("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
+    .config("spark.kryo.registrator", "org.apache.sedona.core.serde.SedonaKryoRegistrator")
+    .config("spark.sql.extensions", "org.apache.sedona.sql.SedonaSqlExtensions")
+    .config("spark.hadoop.fs.defaultFS", f"hdfs://{HDFS_NAMENODE_HOST}:{HDFS_NAMENODE_PORT}")
+    .getOrCreate()
+)
+sedona = SedonaContext.create(spark)
+print("✅ Sesión de Spark iniciada.")
+
+# --- Cargar todos los recursos necesarios a la memoria ---
+print("\n» Paso 2: Cargando modelos y datos base a memoria...")
+
+CENSO_PATH_HDFS = "/data/raw/geodatos_mexico/censo_2020_nacional.parquet"
+DENUE_PATH_HDFS = "/data/raw/geodatos_mexico/denue_nacional.parquet"
+MODEL_PATH_HDFS = "/models/gbt_oxxo_model"
+FEATURES_LIST_PATH = "/models/gbt_oxxo_model_features"
+
+# Cargar dataframes
+g_censo_sdf = spark.read.format("geoparquet").load(CENSO_PATH_HDFS)
+g_denue_raw_sdf = spark.read.format("geoparquet").load(DENUE_PATH_HDFS)
+
+# Cargar modelo
+g_gbt_model = GBTClassificationModel.load(MODEL_PATH_HDFS)
+
+# Cargar lista de features
+g_training_feature_cols = spark.read.text(FEATURES_LIST_PATH).rdd.map(lambda row: row.value).collect()
+
+# Pre-procesar dataframes base
+print("   Pre-procesando DENUE y Censo...")
+g_denue_sdf = g_denue_raw_sdf.withColumn("codigo_act_2c", F.substring(col("codigo_act"), 1, 2)) \
+    .withColumn("est_per_ocu",
+        F.when(col("per_ocu").contains("0 a 5"), 2.5)
+        .when(col("per_ocu").contains("6 a 10"), 8.0)
+        .when(col("per_ocu").contains("11 a 30"), 20.5)
+        .when(col("per_ocu").contains("31 a 50"), 40.5)
+        .when(col("per_ocu").contains("51 a 100"), 75.5)
+        .when(col("per_ocu").contains("101 a 250"), 175.5)
+        .when(col("per_ocu").contains("251 y más"), 350.0)
+        .otherwise(1.0)
+    )
+numeric_censo_cols = [f.name for f in g_censo_sdf.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]
+g_censo_sdf = g_censo_sdf.na.fill(0, subset=numeric_censo_cols)
+print("✅ Recursos cargados y listos.")
+
+
+# =============================================================================
+# 2. FUNCIONES HELPERS (sin cambios)
+# =============================================================================
+def aggregate_denue_features(base_df, denue_df, buffer_col_name, suffix):
+    joined = base_df.join(denue_df.alias("d"), expr(f"ST_Intersects({buffer_col_name}, d.geometry)"))
+    agg_epo = joined.groupBy(base_df.id).agg(_sum("d.est_per_ocu").alias(f"epo_{suffix}"))
+    act_codes = ['51', '54', '11', '22', '52', '71', '43', '31', '61', '46', '23', '55', '93', '53', '81', '33', '48', '32', '56', '49', '62', '21', '72']
+    agg_pivot = joined.groupBy(base_df.id).pivot("d.codigo_act_2c", act_codes).agg(_sum("d.est_per_ocu"))
+    for code in act_codes:
+        agg_pivot = agg_pivot.withColumnRenamed(code, f"act_{code}_{suffix}")
+    return agg_epo.join(agg_pivot, "id", "outer")
+
+def aggregate_censo_features(base_df, censo_df, buffer_col_name, suffix):
+    joined = base_df.join(censo_df.alias("c"), expr(f"ST_Intersects({buffer_col_name}, c.geometry)"))
+    numeric_censo_cols = [f.name for f in censo_df.schema.fields if isinstance(f.dataType, (IntegerType, DoubleType, LongType, FloatType))]
+    agg_exprs = [_sum(f"c.{col}").alias(f"censo_{col}_{suffix}") for col in numeric_censo_cols]
+    return joined.groupBy(base_df.id).agg(*agg_exprs)
+
+def convertir_4326_a_6372(lon, lat):
+    crs_origen = pyproj.CRS("EPSG:4326")
+    crs_destino = pyproj.CRS("EPSG:6372")
+    transformador = pyproj.Transformer.from_crs(crs_origen, crs_destino, always_xy=True)
+    x_6372, y_6372 = transformador.transform(lon, lat)
+    return (x_6372, y_6372)
+
+# =============================================================================
+# 3. ENDPOINT DE LA API (sin cambios)
+# =============================================================================
+@app.route("/predict", methods=["POST"])
+def predict():
+    """Endpoint que recibe coordenadas y devuelve una predicción."""
+    data = request.get_json()
+    if not data or 'latitude' not in data or 'longitude' not in data:
+        return jsonify({"error": "Petición inválida. Se requiere 'latitude' y 'longitude' en el cuerpo JSON."}), 400
+
+    lat_4326 = data['latitude']
+    lon_4326 = data['longitude']
+
+    try:
+        print(f"Recibida petición para: Lat={lat_4326}, Lon={lon_4326}")
+        
+        x_proj, y_proj = convertir_4326_a_6372(lon_4326, lat_4326)
+        point_df = spark.createDataFrame([(1, x_proj, y_proj)], ["id", "x", "y"]) \
+                        .withColumn("geometry", expr("ST_Point(x, y)"))
+
+        point_with_buffers = point_df.withColumn("buffer_100m", expr("ST_Buffer(geometry, 100)")).withColumn("buffer_500m", expr("ST_Buffer(geometry, 500)"))
+        denue_agg_100 = aggregate_denue_features(point_with_buffers, g_denue_sdf, "buffer_100m", "100")
+        denue_agg_500 = aggregate_denue_features(point_with_buffers, g_denue_sdf, "buffer_500m", "500")
+        censo_agg_100 = aggregate_censo_features(point_with_buffers, g_censo_sdf, "buffer_100m", "100")
+        censo_agg_500 = aggregate_censo_features(point_with_buffers, g_censo_sdf, "buffer_500m", "500")
+
+        features_df = point_df.select("id") \
+            .join(denue_agg_100, "id", "left_outer") \
+            .join(denue_agg_500, "id", "left_outer") \
+            .join(censo_agg_100, "id", "left_outer") \
+            .join(censo_agg_500, "id", "left_outer") \
+            .na.fill(0)
+        
+        existing_cols = features_df.columns
+        for col_name in g_training_feature_cols:
+            if col_name not in existing_cols:
+                features_df = features_df.withColumn(col_name, lit(0))
+
+        assembler = VectorAssembler(inputCols=g_training_feature_cols, outputCol="features")
+        final_df = assembler.transform(features_df)
+        prediction_result = g_gbt_model.transform(final_df)
+        
+        result_row = prediction_result.select("prediction", "probability").first()
+        prediction_val = result_row['prediction']
+        probability = result_row['probability']
+        
+        clase = "OXXO" if prediction_val == 1.0 else "Abarrotes"
+        confianza = probability[int(prediction_val)]
+
+        response = {
+            "input_coordinates": {
+                "latitude": lat_4326,
+                "longitude": lon_4326
+            },
+            "prediction": clase,
+            "confidence": round(confianza * 100, 2)
+        }
+        
+        print(f"Predicción exitosa: {response}")
+        return jsonify(response)
+
+    except Exception as e:
+        print(f"ERROR: Ha ocurrido un error procesando la petición: {e}")
+        return jsonify({"error": "Error interno del servidor.", "details": str(e)}), 500
+
+if __name__ == "__main__":
+    app.run(host='0.0.0.0', port=5001, debug=False)

cuadernos/semana_4/06_kafka_streaming.ipynb

@@ -0,0 +1,299 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# S4 · Ejercicio 6 — Streaming en tiempo real con Kafka\n",
+    "\n",
+    "**Curso de Big Data · Dr. Abel Coronado** · Semana 4\n",
+    "\n",
+    "🎯 **Objetivo.** Leer un topic de Kafka con Spark Structured Streaming y agregar al vuelo.\n",
+    "\n",
+    "📦 **Datos.** Topic Kafka `promedios` (mensajes inyectados a mano por terminal).\n",
+    "\n",
+    "✅ **Prerrequisitos.** Kafka arrancado (:9092). Conector spark-sql-kafka-0-10_2.13:4.0.0.\n",
+    "\n",
+    "📝 **Entregable.** Captura del DataFrame de streaming mostrando agregados por tipo.\n",
+    "\n",
+    "🛠️ **Stack del laboratorio.** Spark 4.0 · Sedona 1.8.0 (_2.13) · HDFS 3.3.6 · Elasticsearch 8.14 · JupyterLab\n",
+    "\n",
+    "⬇️ **Descarga (Hugging Face):** https://huggingface.co/datasets/abxda/bdp-lab/resolve/main/cuadernos/semana_4/06_kafka_streaming.ipynb\n",
+    "\n",
+    "💬 **¿Un error?** Toma una captura (celda + mensaje) y repórtalo por **Blackboard**, indicando tu SO y el paso.\n",
+    "\n",
+    "---\n",
+    "\n",
+    "> Cuaderno **probado** en el laboratorio (Spark 4.0). Lee los comentarios de cada celda: explican el porqué de cada paso.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "c4f8d1a8-05bb-4dbb-a0d1-802deb0dbf24",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyspark.sql import SparkSession\n",
+    "from pyspark import SparkContext\n",
+    "from pyspark import SparkConf\n",
+    "spark = SparkSession. \\\n",
+    "builder. \\\n",
+    "appName('UNIR'). \\\n",
+    "config(\"spark.executor.memory\", \"1g\"). \\\n",
+    "config(\"spark.driver.memory\", \"2g\"). \\\n",
+    "config('spark.dirver.maxResultSize', '1g'). \\\n",
+    "config('spark.jars.packages','org.apache.spark:spark-sql-kafka-0-10_2.13:4.0.0'). \\\n",
+    "getOrCreate()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b60edadc-1958-4542-b8e9-9e1fa40f1694",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def promediarValores(df):\n",
+    "   df.createOrReplaceTempView(\"resultadoMedio\")\n",
+    "   promedios = spark.sql(\"\"\"SELECT tipo, AVG(total) AS promedio FROM resultadoMedio GROUP BY tipo ORDER BY promedio DESC\"\"\")\n",
+    "   return promedios"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "48e0d421-f5a9-49a8-8d0a-892d787954f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "tiposStreamingDF = (spark\n",
+    "  .readStream\n",
+    "  .format(\"kafka\")\n",
+    "  .option(\"kafka.bootstrap.servers\", \"127.0.0.1:9092\")\n",
+    "  .option(\"subscribe\", \"promedios\")\n",
+    "  .load())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0aca7c60-8cbd-484d-bfee-447b609d5eab",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from pyspark.sql.types import StructType, StructField, StringType, DoubleType\n",
+    "import pyspark.sql.functions as F\n",
+    "esquema = StructType([\\\n",
+    "  StructField(\"tipo\", StringType()),\\\n",
+    "  StructField(\"total\", DoubleType())\\\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "3bef5b58-45f8-4cd0-a3f8-236e6aff138b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "parsedDF = tiposStreamingDF\\\n",
+    "     .select(\"value\")\\\n",
+    "     .withColumn(\"value\", F.col(\"value\").cast(StringType()))\\\n",
+    "     .withColumn(\"parejas\", F.from_json(F.col(\"value\"), esquema))\\\n",
+    "     .withColumn(\"tipo\", F.col(\"parejas.tipo\"))\\\n",
+    "     .withColumn(\"total\", F.col(\"parejas.total\"))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "5e180263-f093-4969-9f33-96a1eb16839b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "promediosStreamingDF = promediarValores(parsedDF)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "98ca4f6f-6bab-4a66-b273-c1e21b869723",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "salida = promediosStreamingDF\\\n",
+    "                    .writeStream\\\n",
+    "                    .queryName(\"AgregacionPromedios\")\\\n",
+    "                    .outputMode(\"complete\")\\\n",
+    "                    .format(\"memory\")\\\n",
+    "                    .option(\"checkpointLocation\", \"hdfs://localhost:9000/tmp/checkpoints/promedios\")\\\n",
+    "                    .start()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "a3a0c21b-2556-46a2-b34d-acdbd6eb521c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "promediosDF = spark.sql(\"select * from AgregacionPromedios\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ebc4a8cb-4d01-4ab8-a044-c9fefb98b467",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+----+--------+\n",
+      "|tipo|promedio|\n",
+      "+----+--------+\n",
+      "+----+--------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "promediosDF.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "bc8efb86-e866-46bd-b20d-f3edea705547",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "kafka-topics.bat --list --bootstrap-server localhost:9092\n",
+    "\n",
+    "kafka-topics.bat --create --topic promedios --bootstrap-server localhost:9092 --partitions 1 --replication-factor 1\n",
+    "\n",
+    "kafka-topics.bat --list --bootstrap-server localhost:9092\n",
+    "\n",
+    "kafka-console-producer.bat --topic promedios --bootstrap-server localhost:9092"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "1bf078d9-de20-43d7-87ab-195ac9665b28",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "{\"tipo\": \"gasto\", \"total\": 3.5}\n",
+    "{\"tipo\": \"ingreso\", \"total\": 7.0}\n",
+    "{\"tipo\": \"ingreso\", \"total\": 6.5}\n",
+    "{\"tipo\": \"gasto\", \"total\": 1.5}\n",
+    "{\"tipo\": \"gasto\", \"total\": 2.5}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "e34f42a4-849c-4e9a-b413-88fbf775c6f3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+-----+--------+\n",
+      "| tipo|promedio|\n",
+      "+-----+--------+\n",
+      "|gasto|     3.5|\n",
+      "+-----+--------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "promediosDF.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d9b0e34c-f617-406a-a68f-34ac9f3ac80f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+-------+--------+\n",
+      "|   tipo|promedio|\n",
+      "+-------+--------+\n",
+      "|ingreso|     7.0|\n",
+      "|  gasto|     3.5|\n",
+      "+-------+--------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "promediosDF.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "e6f576bc-f56c-4a12-90dd-bb3f01fbad7c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+-------+--------+\n",
+      "|   tipo|promedio|\n",
+      "+-------+--------+\n",
+      "|ingreso|    6.75|\n",
+      "|  gasto|     3.5|\n",
+      "+-------+--------+\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "promediosDF.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "efa99fb4-203f-4c26-8477-d85bec5249d1",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#kafka-topics.bat --delete --topic promedios --bootstrap-server localhost:9092"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}