Cursos  /  Datos grandes, paralelo e IA con R
Nivel Avanzado 100% online

Datos grandes, paralelo e IA con R

Saque el máximo rendimiento a su propia computadora: Parquet, arrow y DuckDB para datos que no caben en memoria, cómputo en paralelo con mirai y targets, y modelos de lenguaje locales o gratuitos para codificar textos y redactar boletines a escala, siempre validados.

Requisito previoRecomendado: Pronóstico de series de tiempo con R

Lo que aprenderá

Proyecto final

Un pipeline en su propia laptop que procesa el panel del OIJ y genera, verificado, el boletín de cada cantón.

Conocer los límites de su computadora. Medir núcleos, memoria y tiempos antes de optimizar, y saber por qué se acaban 4 GB.
Trabajar con datos que no caben en memoria. Pasar a Parquet por lotes y consultarlo con arrow y DuckDB sin cargarlo entero.
Usar todos los núcleos. Paralelizar en una sola máquina con mirai y future, y organizar el trabajo en un pipeline de targets.
Usar la IA con criterio profesional. Pedirle a un modelo el SQL de DuckDB y verificarlo contra dplyr; codificar miles de textos con modelos validados.
Escalar sin gastar de más. Llamadas en paralelo y por lotes, el costo calculado antes de lanzar y embeddings guardados en Parquet.
Redactar a escala sin inventar cifras. Un boletín por cantón con Quarto, verificado: el modelo redacta y las cifras salen de los datos.
Ver los objetivos detallados11 objetivos
  1. Diagnosticar su equipo (núcleos, memoria, disco, GPU), declarar su perfil (A–D) y predecir el tiempo, la memoria y el costo de una corrida antes de lanzarla, para luego medirlos y explicar la diferencia
  2. Escribir funciones que señalan errores con clase y en español, reintentan pedidos a un servicio con httr2 y se comprueban con pruebas de testthat que fallan cuando deben, dentro de un proyecto y sin crear un paquete
  3. Reemplazar ciclos por map() y su familia para leer muchos archivos y servicios paginados, fallar sin detenerse y rectangular JSON anidado
  4. Explicar por qué se acaban 4 GB de memoria (copiar al modificar, tipos, columnas que no hacen falta) y medir con bench y profvis antes de optimizar
  5. Convertir un CSV mayor que la memoria a Parquet particionado, por lotes, y consultarlo con arrow y DuckDB sin cargarlo entero, con límites de memoria e hilos que no cuelgan una laptop, incluido un Parquet remoto por HTTPS
  6. Repartir trabajo entre los núcleos de una máquina con mirai y purrr::in_parallel() (y leer código con future y furrr), con memoria por trabajador, semillas reproducibles y sin anidar paralelismo; y usar la máquina de un laboratorio por SSH
  7. Convertir un análisis en un flujo de targets con ramificación dinámica y crew local, que se puede reanudar y que solo recalcula lo que cambió
  8. Usar con criterio profesional un modelo de lenguaje desde R, como un instrumento medido: salida estructurada con ellmer, modelo fijado, registro de cada llamada, semáforo de datos como código y validación contra un conjunto de oro (kappa y F1 por estrato territorial), comparada con el método clásico
  9. Elegir con números entre un modelo abierto en el propio equipo (Ollama, cuantización, tokens por segundo) y una API (en paralelo o por lotes, dentro de límites gratuitos), según privacidad, costo, tiempo y calidad
  10. Calcular embeddings en CPU, guardarlos en Parquet y buscar por similitud en DuckDB, validando la búsqueda con exhaustividad en k
  11. Redactar con apoyo de un modelo 84 boletines cantonales con Quarto con parámetros, renderizados en paralelo a partir de borradores congelados, con la prosa verificada por pruebas, cada cifra calculada por código, una plantilla de referencia para medir el aporte del modelo y la declaración de uso de IA generada desde el registro, como la pide una revista o un comité de tesis

Temario

01Su máquina es el laboratorio2 videos
  1. Qué podrá hacer al terminar · 5 min
  2. Diagnóstico: núcleos, memoria, disco y GPU · 5 min
02Funciones que aguantan escala3 videos
  1. cli_abort() con clase · 15 min
  2. Condiciones y reintentos con httr2 · 15 min
  3. testthat en un proyecto, sin paquete · 15 min
03purrr y datos anidados4 videos
  1. map() y su familia · 15 min
  2. Muchos archivos del OIJ y del MEP · 15 min
  3. Fallar sin detenerse: safely() y .progress · 5 min
  4. JSON paginado de la capa del MEP · 15 min
04Programar con el tidyverse2 videos
  1. Abrazar con {{ }} · 15 min
  2. across() y pick() a fondo · 15 min
05Medir y entender la memoria3 videos
  1. bench y profvis · 15 min
  2. Por qué se acaban 4 GB · 15 min
  3. El disco como memoria · 5 min
06Parquet y arrow5 videos
  1. Del CSV inflado a Parquet por lotes · 15 min
  2. Particiones y filtros que no leen todo · 15 min
  3. Esquemas distintos y el número de filas · 5 min
  4. Tipos que ahorran memoria · 5 min
  5. nanoparquet para archivos pequeños · 5 min
07DuckDB5 videos
  1. dbplyr sobre Parquet y show_query() · 15 min
  2. duckplyr y cuándo vuelve a R · 15 min
  3. Uniones y ventanas grandes · 15 min
  4. memory_limit, threads y temp_directory · 5 min
  5. Pídale a un modelo el SQL de DuckDB y verifíquelo contra dplyr · 15 min
08Integradora A: el panel del OIJ en el perfil A1 videos
  1. Práctica integradora A: del panel al agregado cantonal · 30 min
09Paralelo en una máquina6 videos
  1. Procesos, núcleos y memoria por trabajador · 15 min
  2. mirai::daemons() y purrr::in_parallel() · 15 min
  3. future, furrr y future.mirai; tune con mirai · 15 min
  4. Semillas en paralelo · 5 min
  5. daemons(sync = TRUE) para depurar · 5 min
  6. No anidar paralelismo · 5 min
10targets y crew local4 videos
  1. De script a _targets.R · 15 min
  2. Ramificación dinámica sobre fragmentos Parquet · 15 min
  3. crew_controller_local() según el perfil · 15 min
  4. Qué se invalida · 5 min
11Más allá de su laptop, sin nube2 videos
  1. La máquina del laboratorio por SSH · 15 min
  2. Parquet remoto por HTTPS · 5 min
12IA responsable: el modelo de lenguaje como instrumento validado4 videos
  1. ellmer con un modelo local, gratuito o de pago, y el semáforo de datos como código · 15 min
  2. Salida estructurada que el código valida · 15 min
  3. Conjunto de oro, kappa y F1 por estrato · 15 min
  4. El prompt como código · 5 min
13IA responsable: elegir con datos un modelo abierto en su equipo4 videos
  1. Ollama por dentro · 15 min
  2. Medir tokens por segundo y elegir el modelo más pequeño que pasa el oro · 15 min
  3. Cuándo acelera Ollama en paralelo: CPU frente a GPU · 5 min
  4. Corridas largas reanudables y datos protegidos: retención y borrado · 15 min
14IA responsable: muchas llamadas a APIs, con el costo estimado3 videos
  1. parallel_chat_structured() dentro de los límites de una capa gratuita · 15 min
  2. batch_chat_structured(): lotes más baratos y reanudables · 15 min
  3. Estimar tiempo y costo antes de lanzar · 5 min
15IA responsable: embeddings en Parquet y búsqueda validada4 videos
  1. Qué es un embedding; trocear y calcular en CPU · 15 min
  2. Guardar en Parquet y cuentas de memoria · 15 min
  3. Usos: buscar, encontrar duplicados, agrupar · 15 min
  4. Validar la búsqueda con exhaustividad en k · 5 min
16IA responsable: redactar 84 boletines con un modelo y verificarlos5 videos
  1. Hechos por cantón y una plantilla de referencia · 15 min
  2. Borradores estructurados ligados a hecho_id · 15 min
  3. El verificador como pruebas · 15 min
  4. 84 boletines en paralelo desde borradores congelados, con su declaración · 5 min
  5. Revisión humana y vitals: cuánto aporta el modelo frente a la plantilla · 5 min
17Integradora B: la cobertura de las zonas alejadas1 videos
  1. Práctica integradora B: la cascada sobre el corpus de prensa · 30 min
18Proyecto final y cierre3 videos
  1. Presentación del proyecto y pruebas que fallan · 15 min
  2. Resolución guiada de un proyecto paralelo: la ficha de cada DRE del MEP · 30 min
  3. Cierre de la serie · 5 min

Este curso dentro de la serie

01
Análisis de datos
02
Visualización
03
Texto
04
Fechas
05
Geoespacial
06
Clustering
07
Predictivos
08
Pronóstico
09
Datos grandes e IA