Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias
Uso de APIs para extraer
información de internet
Lucas Antonio II, Valentina e Ignacio.
Universidad de los Andes

Bienvenidos a este tutorial que cubre el contenido de la tercer sesión

complementaria. Esta sesión profundizará nuestra comprensión la adquisición
de datos de la web a través de APIS .1

Reconocimiento: La mayoría de los materiales presentadoos aquí fueron aportados

por profesores complementarios anteriores, especialmente Eduard-Martínez
(https://eduard-martinez.github.io/). Estamos verdaderamente agradecidos por su
ayuda.

Qué son las APIs?

A grandes razgos se podría decir que podemos dividir las páginas web en dos
categorías Client-side y Server-side según si estas son programadas para que el
código que las crea se ejecuta desde el computador del usuario (client-side) o
desde un servidor (server-side).
 En la clase pasada aprendimos a realizar webscraping sobre las páginas que
son client-side aprovechando que el código fuente de estas está disponible
Qué son las APIs?
para ser inspeccionado. El día de hoy vamos a aprender a extraer información
API Datos Abiertos de páginas que funcionen a partir de APIs.
Regularización o Shrinkage Cuando se comienza a hablar sobre las APIs, generalmente la conversación se
Ejercicio práctico centra al rededor de conceptos un poco abstractos. Por ende, para aterrizar
esta idea comencemos con algo físico: un servidor. Un servidor no es más que
Referencias
un computador más grande. Este tiene las mismas partes que el PC que utiliza
para trabajar, sólo que es más rápido y potente. Normalmente, los servidores
no tienen monitor, teclado ni ratón, lo que los hace parecer inaccesibles. La
realidad es que los ingenieros de TI se conectan a ellos de forma remota.

Los servidores se utilizan para todo tipo de cosas. Algunos almacenan datos,
otros envían correos electrónicos. El tipo de servidor con el que más
interactúa la gente es el servidor web. Estos son los servidores que le envían a
tu PC el contenido de una página web cuando visitas internet.

Las páginas web de las aerolíneas son un buen ejemplo de páginas server-side
porque cuando deseas comprar algun tiquete, debes seleccionar una fecha, un
origen y un destino, y a partir de esa información el ordenador realiza lo que se
le conoce como request al servidor donde está alojada la página. Gracias a este
request el servidor produce una response que envía de vuelta a tu ordenador y
en esta se encuentra la data con los precios de los vuelos disponibles para las
fechas y rutas seleccionadas.

Lo que aprenderá a hacer en esta clase consiste en realizar directamente el

request que desea desde R . Esto generalmente se realiza a través de una API o
Application Program Interface lo cual no es más que un conjunto de reglas y
métodos con los cuales las diferentes aplicaciones se comunican entre sí.
 A continuación le presentamos un pequeño diccionario de terminología: -
Server: Un ordenador potente que ejecuta una API. - Client: Un programa que
Qué son las APIs?
intercambia datos con un servidor a través de una API. - Protocol: La
API Datos Abiertos “etiqueta” subyacente a la forma en que los ordenadores se comunican entre sí
Regularización o Shrinkage (por ejemplo, HTTP). - Methods: Los “verbos” que los clientes utilizan para
hablar con un servidor. El principal que usaremos es GET (es decir, pedir a un
Ejercicio práctico
servidor que recupere información), pero otros métodos comunes son POST,
Referencias PUT y DELETE. - Requests: Lo que el cliente pide al servidor (ver Métodos
arriba). - Response: La respuesta del servidor. Incluye un Status Code (por
ejemplo, “404” si no se ha encontrado, o “200” si se ha encontrado), una
cabecera (es decir, meta-información sobre la respuesta), y un cuerpo (es decir,
el contenido real que nos interesa). etc.

Un punto clave en todo esto es que, en el caso de las APIs web, podemos
acceder a la información directamente desde la base de datos de la API si
podemos especificar la(s) URL(s) correcta(s). Estas URL se conocen como API
endpoints.

Los API endpoints son, en muchos sentidos, similares a las URL normales de los
sitios web que todos estamos acostumbrados a visitar. Para empezar, puede
navegar hasta ellos en su navegador web. Sin embargo, mientras que los sitios
web normales muestran la información en contenido HTML enriquecido -
imágenes, vídeos de gatos, buen formato, etc.-, un API endpoint es mucho
menos atractivo visualmente. Si navega por el navegador hasta un punto final
de la API, sólo verá un montón de texto aparentemente sin formato. En
realidad, lo que está viendo es (probablemente) JSON (JavaScript Object
Notation) o XML (Extensible Markup Language).

No hay que preocuparse demasiado por la sintaxis de JSON y XML. Lo

importante es que el objeto de tu navegador -esa carga de texto
aparentemente sin formato- está en realidad estructurado y formateado con
 mucha precisión. Además, contiene información valiosa que podemos leer
fácilmente en R (o Python, Julia, etc.) Sólo tenemos que conocer el API
Qué son las APIs?
endpoint adecuado para los datos que queremos.
API Datos Abiertos

Regularización o Shrinkage
API Datos Abiertos
Ejercicio práctico
Para este clase vamos a visitar la página web de Datos Abiertos del Gobierno
Referencias Nacional (https://www.datos.gov.co/) la cual tiene más de 6,000 bases de
datos sobre diversos sectores como agricultura, ciencia, minería, economía,
educación, vivienda, transporte, entre otros.

Para la clase vamos a utilizar la API del sitio para obtener los casos de
desnutrición en Bucaramanga desde el 2019 hasta la actualidad. El url con la
información general de la base es este (https://www.datos.gov.co/Salud-y-
Protecci-n-Social/51-Casos-de-Desnutrici-n-Aguda-en-menores-de-5-A-
o/epsv-yhtj).

Como podemos ver, la base presenta una caracterización de los casos de

desnutrición en población menor de 5 años reportados a través del sistema de
vigilancia epidemiologica de Bucaramanga desagregados por grado de
desnutrición, régimen de afiliación, Área, Sexo, Comuna, Escala, Peso, talla,
sintomatología de edema, pálidez y piel reseca.

# Limpiamos nuestro ambiente

rm(list = ls())

# Cargamos los paquetes

library(pacman)
p_load(tidyverse, fastDummies, caret, glmnet, MLmetrics)
 ##
Qué son las APIs? ## The downloaded binary packages are in
## /var/folders/lp/bhbhb__n1_z91_rjfqljxcdc0000gn/T//RtmpHaA1y
API Datos Abiertos
4/downloaded_packages
Regularización o Shrinkage
Para acceder a los datos podemos seguir el paso a paso de la documentación
Ejercicio práctico
de la página (https://dev.socrata.com/foundry/www.datos.gov.co/epsv-yhtj).
Referencias Allí se nos enseña a crear una cuenta en la plataforma socrata y
posteriormente se nos enseña a crear unA API para scrapear los datos de la
página de Datos Abiertos utilizando los paquetes de socrata para los
diferentes softwares de programación

No obstante, la API de Datos Abiertos tiene ciertos endpoints que nos permite
descargar los datos directamente desde unas urls. Para esta clase tomaremos
este camino el cual es más directo y rápido.

Para descargar a la base de datos vamos a entrar al siguiente link

(https://www.datos.gov.co/Salud-y-Protecci-n-Social/51-Casos-de-
Desnutrici-n-Aguda-en-menores-de-5-A-o/epsv-yhtj) y luego vamos a hacer
click sobre el botón que dice API . De ahí vamos a cambiar el formato de
descarga de JSON a CSV y finalmente vamos a copiar el link resultante.
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias

df <- read_csv("https://www.datos.gov.co/resource/epsv-yhtj.cs
v")

# Analicemos la estructura de la base

glimpse(df)
 ## Rows: 346
Qué son las APIs? ## Columns: 27
## $ orden <dbl> 1, 2, 3, 4, 5, 6, 7, 8, 9,
API Datos Abiertos
10, 11, 12, 13, 14…
Regularización o Shrinkage ## $ fec_not <chr> "21/10/2019", "24/10/2019",
"25/10/2019", "28…
Ejercicio práctico
## $ semana_epidemiologica <dbl> 43, 43, 43, 44, 44, 44, 44,
Referencias 44, 46, 46, 47, 4…
## $ a_o <dbl> 2019, 2019, 2019, 2019, 201
9, 2019, 2019, 201…
## $ edad_ <dbl> 2, 1, 2, 11, 10, 3, 17, 17,
10, 4, 7, 7, 4, 1…
## $ uni_med_ <dbl> 1, 1, 1, 2, 2, 1, 3, 3, 2,
2, 2, 2, 2, 2, 1, …
## $ uniedad <dbl> 12, 11, 12, 211, 210, 13, 3
17, 317, 210, 24, …
## $ grupo_etario <chr> "2 a 5 Años", "< 2 Años",
"2 a 5 Años", "2 a …
## $ curso_de_vida <chr> "Primera infancia", "Primer
a infancia", "Prim…
## $ sexo <chr> "F", "F", "F", "M", "F",
"F", "M", "M", "M", …
## $ area_ <dbl> 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, …
## $ barrio <chr> "REGADEROS", "GIRARDOT", "L
A AURORA", "NAPOLE…
## $ num_comuna <chr> "2 NORORIENTAL", "4 OCCIDEN
TAL", "13 ORIENTAL…
## $ tipo_de_seguridad_social <chr> "C", "N", "C", "S", "S",
"N", "N", "N", "S", …
## $ cod_ase_ <chr> "EPS037", NA, "EPS017", "ES
S133", "ESS133", N…
 ## $ aseguradora <chr> "NUEVA EPS S.A.", "NO AFILI
ADO", "E.P.S. FAMI…
Qué son las APIs? ## $ estrato <dbl> 2, 1, 3, 1, 1, 3, 1, 1, 1,
API Datos Abiertos 1, 1, 2, 1, 1, 2, …
## $ edema <dbl> 2, 2, 2, 2, 2, 2, 2, 2, 2,
Regularización o Shrinkage 2, 2, 2, 2, 2, 2, …
Ejercicio práctico ## $ delgadez <dbl> 2, 1, 2, 1, 1, 1, 1, 1, 1,
1, 2, 1, 2, 2, 1, …
Referencias ## $ oiel_reseca <dbl> 2, 1, 2, 2, 1, 2, 1, 1, 2,
2, 2, 2, 2, 2, 2, …
## $ hiperpigm <dbl> 2, 1, 2, 2, 1, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, …
## $ cambios_cabello <dbl> 2, 1, 2, 2, 1, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, …
## $ palidez <dbl> 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, …
## $ departamento <chr> "SANTANDER", "SANTANDER",
"SANTANDER", "SANTA…
## $ municipio <chr> "BUCARAMANGA", "BUCARAMANG
A", "BUCARAMANGA", …
## $ zscorept_aprox <dbl> -2.28, -2.70, -3.26, -2.52,
-2.07, -2.10, -4.…
## $ interpretaci_n_zscore_pt <chr> "Desnutrición aguda moderad
a", "Desnutrición …

# Chequeamos los NAs de la base

sapply(df, function(x) sum(is.na(x)))
 ## orden fec_not semana_
Qué son las APIs? epidemiologica
## 0 0
API Datos Abiertos
0
Regularización o Shrinkage ## a_o edad_
uni_med_
Ejercicio práctico
## 0 0
Referencias 0
## uniedad grupo_etario
curso_de_vida
## 0 0
0
## sexo area_
barrio
## 0 0
0
## num_comuna tipo_de_seguridad_social
cod_ase_
## 0 0
38
## aseguradora estrato
edema
## 0 16
0
## delgadez oiel_reseca
hiperpigm
## 0 0
0
## cambios_cabello palidez
departamento
## 0 0
0
 ## municipio zscorept_aprox interpreta
ci_n_zscore_pt
Qué son las APIs? ## 0 0
API Datos Abiertos 0

Regularización o Shrinkage

Ejercicio práctico
# Una de las variables con NAs es cod_ase_ la cual corresponde
Referencias # al identificador de la aseguradora. Esta variable parece no
# relevante. La vamos a dropear
df <- select(df, -cod_ase_)

# Ahora la única variable con NAs es el estrato.

df$estrato %>%
table(useNA = "ifany") %>%
prop.table() %>%
round(3) * 100

## .
## 1 2 3 4 6 <NA>
## 47.7 36.1 8.7 2.3 0.6 4.6
 # No obstante los NAs representan menos del 5% de las entradada
Qué son las APIs? s
# Vamos a imputarla con el valor más frecuente
API Datos Abiertos df$estrato[is.na(df$estrato)] <- 1
Regularización o Shrinkage
# Seleccionamos las variables relevantes
Ejercicio práctico df <- df %>%
Referencias select(orden, edad_, uni_med_, grupo_etario, sexo, area_,
num_comuna, tipo_de_seguridad_social, estrato, edema,
delgadez, oiel_reseca, hiperpigm, cambios_cabello,
palidez, zscorept_aprox, interpretaci_n_zscore_pt)

# Construimos la edad
# uni_med_ se refiere a la unidad de medida de la edad:
# 1. Años 2. Meses 3. Dias 4. Horas 5. Minutos 0. No aplica
table(df$uni_med_)

##
## 1 2 3
## 233 109 4
 # Vamos a pasar todas las edades a dias
Qué son las APIs? df$edad_[df$uni_med_ == 1] = df$edad_[df$uni_med_ == 1] * 365
df$edad_[df$uni_med_ == 2] = df$edad_[df$uni_med_ == 2] * 30
API Datos Abiertos

Regularización o Shrinkage # Arreglamos las variables dicótomas para que sean 1 y 0

variables_dicotomas <- c("edema", "delgadez", "oiel_reseca",
Ejercicio práctico "hiperpigm", "cambios_cabello", "palid
Referencias ez")
df[,variables_dicotomas] = df[,variables_dicotomas] - 1

# Definimos las variables categoricas

variables_categoricas <- c("orden", "uni_med_", "grupo_etario",
"sexo", "area_", "num_comuna",
"tipo_de_seguridad_social", "estrat
o",
"edema", "delgadez", "oiel_reseca",
"hiperpigm", "cambios_cabello",
"palidez", "interpretaci_n_zscore_p
t")

for (v in variables_categoricas) {
df[, v] <- as.factor(df[, v, drop = T])
}

# Convertimos el puntaje en positivo

df$zscorept_aprox <- -df$zscorept_aprox

# Estudiemos la relación entre el puntaje zscore con la desnutr

ición
ggplot(df, aes(x = edad_, y = zscorept_aprox,
color = interpretaci_n_zscore_pt)) +
 geom_point() +
theme_bw() +
Qué son las APIs? labs(x = "Edad en días", y = "Puntaje de desnutrición") +
API Datos Abiertos scale_color_discrete(name = "Interpretación") +
theme(legend.position="bottom")
Regularización o Shrinkage

Ejercicio práctico
Referencias
 # Ahora procedemos a dummyficar la base
Qué son las APIs? df2 <- model.matrix(~ zscorept_aprox + edad_ + uni_med_ +
grupo_etario + sexo + area_ + num_comuna
API Datos Abiertos +
Regularización o Shrinkage tipo_de_seguridad_social + estrato +
edema + delgadez + oiel_reseca +
Ejercicio práctico hiperpigm + cambios_cabello + palidez, d
f) %>%
Referencias
as.data.frame()

# Ahora vamos a revisar la distribución de nuestra variable a p

redecir
ggplot(df2, aes(x = zscorept_aprox)) +
geom_histogram(bins = 50, fill = "darkblue") +
labs(x = "Puntaje de desnutrición", y = "Cantidad") +
theme_bw()
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias

Ahora que tenemos nuestros datos limpios vamos a estudiar los modelos de
regularización. Nuestro objetivo será predecir el puntaje de desnutrición
usando nuestros datos. Note que solo tenemos 343 observaciones y 42
regresores.

Antes de comenzar con la programación vamos a revisar los principales

aspectos teóricos.

Regularización o Shrinkage
Esta metodología consiste en ajustar el modelo incluyendo todos los
predictores pero aplicando una penalización que fuerce a que las estimaciones
de los coeficientes de regresión tiendan a cero. Con esto se intenta evitar
 overfitting, reducir varianza, atenuar el efecto de la correlación entre
predictores y minimizar la influencia en el modelo de los predictores menos
Qué son las APIs?
relevantes. Por lo general, aplicando regularización se consigue modelos con
API Datos Abiertos mayor poder predictivo (generalización). Tres de los métodos de
Regularización o Shrinkage regularización más empleados son Ridge, Lasso y Elastic net.

Ejercicio práctico Dado que estos métodos de regularización actúan sobre la magnitud de los
coeficientes del modelo, todos deben de estár en la misma escala, por esta
Referencias
razón es necesario estandarizar o normalizar los predictores antes de
entrenar el modelo. Los métodos están especialmente indicados para
situaciones en las que hay un mayor número de predictores que de
observaciones.

Ridge
La regularización Ridge penaliza la suma de los coeficientes elevados al
cuadrado (||β||2 ). A esta penalización se le conoce como l2 y
2 p 2
= ∑ β
j=1 j

tiene el efecto de reducir de forma proporcional el valor de todos los

coeficientes del modelo pero sin que estos lleguen a cero. El grado de
penalización está controlado por el hiperparámetro λ. Cuando λ = 0 , la
penalización es nula y el resultado es equivalente al de un modelo lineal por
mínimos cuadrados ordinarios (OLS). A medida que λ aumenta, mayor es la
penalización y menor el valor de los predictores.

n p p p

2 2
∑(y i − β0 − ∑ βj xij ) + λ∑β = suma residuos cuadrados + λ ∑ β
j

i=1 j=1 j=1 j=1

La principal ventaja de aplicar Ridge frente al ajuste por mínimos cuadrados

ordinarios (OLS) es la reducción de la varianza. En situaciones en las que la
relación entre la variable respuesta y los predictores es aproximadamente
 lineal, las estimaciones por mínimos cuadrados tienen poco sesgo pero aún
pueden sufrir alta varianza (pequeños cambios en los datos de entrenamiento
Qué son las APIs?
tienen mucho impacto en el modelo resultante). Este problema se acentúa
API Datos Abiertos conforme el número de predictores introducido en el modelo se aproxima al
Regularización o Shrinkage número de observaciones de entrenamiento, llegando al punto en que, si
p > n , no es posible ajustar el modelo por mínimos cuadrados ordinarios.
Ejercicio práctico
Empleando un valor adecuado de λ, el método de Ridge es capaz de reducir
Referencias varianza sin apenas aumentar el sesgo, consiguiendo así un menor error total.

La desventaja del método Ridge es que, el modelo final, incluye todos los
predictores. Esto es así porque, si bien la penalización fuerza a que los
coeficientes tiendan a cero, nunca llegan a ser exactamente cero (solo si
λ = ∞ ). Este método consigue minimizar la influencia sobre el modelo de los

predictores menos relacionados con la variable respuesta pero, en el modelo

final, van a seguir apareciendo. Aunque esto no supone un problema para la
precisión del modelo, sí lo es para su interpretación.

Lasso
La regularización Lasso penaliza la suma del valor absolutos de los coeficientes
de regresión (||β||1 = ∑ j=1 |βj |). A esta penalización se le conoce como l1 y
p

tiene el efecto de forzar a que los coeficientes de los predictores tiendan a

cero. Dado que un predictor con coeficiente de regresión cero no influye en el
modelo, lasso consigue excluir los predictores menos relevantes. Al igual que
en Ridge, el grado de penalización está controlado por el hiperparámetro λ.
Cuando λ = 0 , el resultado es equivalente al de un modelo lineal por mínimos
cuadrados ordinarios. A medida que λ aumenta, mayor es la penalización y
más predictores quedan excluidos.
 n p p p

2
∑(y i − β0 − ∑ βj xij ) + λ ∑ |βj | = suma residuos cuadrados + λ ∑
Qué son las APIs? i=1 j=1 j=1 j=1

API Datos Abiertos

Regularización o Shrinkage
Comparación de Ridge y Lasso
La principal diferencia práctica entre Lasso y Ridge es que el primero consigue
Ejercicio práctico
que algunos coeficientes sean exactamente cero, por lo que realiza selección
Referencias de predictores, mientras que el segundo no llega a excluir ninguno. Esto
supone una ventaja notable de Lasso en escenarios donde no todos los
predictores son importantes para el modelo y se desea que los menos
influyentes queden excluidos.

Por otro lado, cuando existen predictores altamente correlacionados

(linealmente), Ridge reduce la influencia de todos ellos a la vez y de forma
proporcional, mientras que Lasso tiende a seleccionar uno de ellos, dándole
todo el peso y excluyendo al resto. En presencia de correlaciones, esta
selección varía mucho con pequeñas perturbaciones (cambios en los datos de
entrenamiento), por lo que, las soluciones de Lasso, son muy inestables si los
predictores están altamente correlacionados.

Para conseguir un equilibrio óptimo entre estas dos propiedades, se puede

emplear lo que se conoce como penalización elastic net, que combina ambas
estrategias.

Elastic Net
Elastic net incluye una regularización que combina la penalización l1 y l2 (
). El grado en que influye cada una de las
1 2
αλ||β|| + (1 − α)||β||
1 2 2

penalizaciones está controlado por el hiperparámetro α. Su valor está

comprendido en el intervalo [0, 1]. Cuando α = 0 , se aplica Ridge y cuando
α = 1 se aplica Lasso. La combinación de ambas penalizaciones suele dar
 lugar a buenos resultados. Una estrategia frecuentemente utilizada es
asignarle casi todo el peso a la penalización l1 (α muy próximo a 1) para
Qué son las APIs?
conseguir seleccionar predictores y un poco a la l2 para dar cierta estabilidad
API Datos Abiertos en el caso de que algunos predictores estén correlacionados.
Regularización o Shrinkage n p 2 p p
∑ (y i − β 0 − ∑ βj xij ) 1 − α
i=1 j=1
2
Ejercicio práctico + λ (α ∑ |βj | + + ∑β )
j
2n 2
j=1 j=1

Referencias

λ óptimo
Encontrar el mejor modelo implica identificar el valor óptimo del
hiperparámetro de regularización lambda (λ). Al tratarse de un
hiperparámetro, no hay forma de saber de antemano qué valor es el adecuado.
Una forma de lograrlo es emplear validación cruzada o generalized cross
validation (CV), esta última es una adaptación eficiente de leave-one-out cross
validation disponible para la regulación Ridge.

Las principales implementaciones en R de estos métodos ( glmnet y H2O )

incorporan validación cruzada, sin embargo, hay situaciones para las que no
son adecuadas. Por ejemplo, si los datos tienen un orden temporal (series
temporales), la validación cruzada debe hacer un reparto ordenado de las
observaciones, lo que se consigue fácilmente con otros paquetes como
tidymodels o mlr3 .

Aunque el valor óptimo de λ es aquel con el que se minimiza el error de

validación cruzada, una práctica extendida es utilizar, en lugar de este, el
mayor valor de λ que se aleja menos de una desviación típica del óptimo. De
este modo, se consigue un modelo más sencillo (excluye más predictores) pero
cuya capacidad predictiva es similar a la conseguida con el modelo más
complejo.
 glmnet
Qué son las APIs?
El paquete glmnet incorpora toda una serie de funcionalidades para entrenar
API Datos Abiertos modelos lineales (regresión y clasificación) con regularización Ridge, Lasso y
Regularización o Shrinkage Elastic Net.

Ejercicio práctico La función glmnet() empleada para entrenar los modelos no permite utilizar
formulas, necesita una matriz x con el valor de los predictores y un vector y
Referencias
con la variable respuesta.

Estas matrices pueden crearse de forma rápida con la función

model.matrix() , identificando los predictores y generando las variables
dummy necesarias en caso de que los predictores sean cualitativos.

El objeto devuelto por la función glmnet( ) contiene toda la información

relevante del modelo entrenado. Con las funciones plot() , print() ,
coef() y predict() se puede extraer su información de forma eficiente.

Ejercicio práctico
Ahora vamos a dividir nuestra base en entrenamiento y prueba. En
entrenamiento vamos a estimar los modelos de regresión lineal, ridge y lasso y
vamos a evaluar su capacidad de predicción en la base de prueba.

Comenzaremos dividiendo nuestra base y estandarizando.

 # Ahora vamos a dividir la base en train y test
Qué son las APIs? set.seed(666)
id_train <- sample(1:nrow(df2), size = 0.7*nrow(df2),
API Datos Abiertos
replace = FALSE)
Regularización o Shrinkage
train <- df2[id_train, ]
Ejercicio práctico
test <- df2[-id_train, ]
Referencias
# Convertimos la y en log
y_train <- log(train[,"zscorept_aprox"])
X_train <- select(train, -zscorept_aprox)
y_test <- log(test[,"zscorept_aprox"])
X_test <- select(test, -zscorept_aprox)

# Estandarizamos la base de datos.

# Solo necesitamos estandarizar la variable de edad
mu <- mean(X_train$edad_)
sigma <- sd(X_train$edad_)
X_train$edad_ <- (X_train$edad_ - mu)/sigma
X_test$edad_ <- (X_test$edad_ - mu)/sigma

Regresión lineal
# Analicemos regresión lineal
train2 <- cbind(y_train, X_train)
modelo_reg <- lm("y_train ~ -1 + .", data = train2)
summary(modelo_reg)
 ##
Qué son las APIs? ## Call:
## lm(formula = "y_train ~ -1 + .", data = train2)
API Datos Abiertos
##
Regularización o Shrinkage ## Residuals:
## Min 1Q Median 3Q Max
Ejercicio práctico
## -0.38100 -0.15723 -0.04124 0.11666 0.59671
Referencias ##
## Coefficients: (4 not defined because of singularities)
## Estimate Std. Error t v
alue Pr(>|t|)
## `(Intercept)` 1.016200 0.106838
9.512 < 2e-16 ***
## edad_ -0.020495 0.020764 -
0.987 0.324800
## uni_med_2 0.029104 0.045880
0.634 0.526569
## uni_med_3 0.640917 0.169082
3.791 0.000198 ***
## `grupo_etario2 a 5 Años` 0.015076 0.042564
0.354 0.723553
## sexoM -0.064496 0.031640 -
2.038 0.042812 *
## area_2 -0.231864 0.227013 -
1.021 0.308300
## area_3 -0.008087 0.163333 -
0.050 0.960560
## `num_comuna10 PROVENZA` -0.015297 0.083815 -
0.183 0.855364
## `num_comuna11 SUR` -0.044836 0.073241 -
0.612 0.541113
## `num_comuna12 CABECERA DEL LLANO` -0.051014 0.170317 -
 0.300 0.764849
## `num_comuna13 ORIENTAL` -0.014859 0.077738 -
Qué son las APIs? 0.191 0.848602
API Datos Abiertos ## `num_comuna14 MORRORICO` -0.057693 0.056899 -
1.014 0.311819
Regularización o Shrinkage ## `num_comuna14 MORRORRICO` 0.619655 0.227885
Ejercicio práctico 2.719 0.007115 **
## `num_comuna15 CENTRO` -0.014270 0.119685 -
Referencias 0.119 0.905212
## `num_comuna16 LAGOS DEL CACIQUE` NA NA
NA NA
## `num_comuna17 MUTIS` -0.019882 0.087103 -
0.228 0.819677
## `num_comuna2 NORORIENTAL` -0.051563 0.072423 -
0.712 0.477308
## `num_comuna28. LA CUMBRE - CARMEN` NA NA
NA NA
## `num_comuna3 SAN FRANCISCO` -0.055229 0.050474 -
1.094 0.275167
## `num_comuna4 OCCIDENTAL` -0.035135 0.052389 -
0.671 0.503210
## `num_comuna5 GARCIA ROVIRA` -0.003317 0.072803 -
0.046 0.963709
## `num_comuna6 LA CONCORDIA` -0.035929 0.142733 -
0.252 0.801512
## `num_comuna7 LA CIUDADELA` -0.005451 0.177883 -
0.031 0.975583
## `num_comuna8 SUR OCCIDENTE` -0.044350 0.117961 -
0.376 0.707333
## `num_comuna9 LA PEDREGOSA` 0.289470 0.165116
1.753 0.081097 .
## `num_comunaCORREG. 2` -0.162221 0.225569 -
 0.719 0.472871
## `num_comunaCORREG. 3` NA NA
Qué son las APIs? NA NA
API Datos Abiertos ## `num_comunaSIN INFORMACION` -0.118840 0.109526 -
1.085 0.279200
Regularización o Shrinkage ## tipo_de_seguridad_socialE -0.163849 0.241718 -
Ejercicio práctico 0.678 0.498642
## tipo_de_seguridad_socialI -0.142367 0.256666 -
Referencias 0.555 0.579728
## tipo_de_seguridad_socialN 0.015432 0.064948
0.238 0.812427
## tipo_de_seguridad_socialP 0.187952 0.150478
1.249 0.213098
## tipo_de_seguridad_socialS 0.040062 0.045658
0.877 0.381290
## estrato2 0.017050 0.033790
0.505 0.614400
## estrato3 0.020471 0.071726
0.285 0.775625
## estrato4 -0.057827 0.123005 -
0.470 0.638776
## estrato6 -0.176119 0.238856 -
0.737 0.461769
## edema1 NA NA
NA NA
## delgadez1 -0.026612 0.032334 -
0.823 0.411459
## oiel_reseca1 -0.117787 0.059018 -
1.996 0.047300 *
## hiperpigm1 0.295638 0.075165
3.933 0.000115 ***
## cambios_cabello1 -0.021939 0.067897 -
 0.323 0.746940
## palidez1 -0.133293 0.060977 -
Qué son las APIs? 2.186 0.029970 *
API Datos Abiertos ## ---
## Signif. codes: 0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' '
Regularización o Shrinkage 1
Ejercicio práctico ##
## Residual standard error: 0.2226 on 202 degrees of freedom
Referencias ## Multiple R-squared: 0.9625, Adjusted R-squared: 0.9551
## F-statistic: 129.7 on 40 and 202 DF, p-value: < 2.2e-16

df_coeficientes_reg <- modelo_reg$coefficients %>%

enframe(name = "predictor", value = "coeficiente")

df_coeficientes_reg %>%
filter(predictor != "`(Intercept)`") %>%
ggplot(aes(x = reorder(predictor, abs(coeficiente)),
y = coeficiente)) +
geom_col(fill = "darkblue") +
coord_flip() +
labs(title = "Coeficientes del modelo de regresión",
x = "Variables",
y = "Coeficientes") +
theme_bw()
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias
 # Evaluamos el modelo de regresión lineal
Qué son las APIs? y_hat_in1 <- predict(modelo_reg, newdata = X_train)
y_hat_out1 <- predict(modelo_reg, newdata = X_test)
API Datos Abiertos

Regularización o Shrinkage # Métricas dentro y fuera de muestra. Paquete MLmetrics

r2_in1 <- R2_Score(y_pred = exp(y_hat_in1), y_true = exp(y_trai
Ejercicio práctico n))
Referencias rmse_in1 <- RMSE(y_pred = exp(y_hat_in1), y_true = exp(y_trai
n))

r2_out1 <- R2_Score(y_pred = exp(y_hat_out1), y_true = exp(y_te

st))
rmse_out1 <- RMSE(y_pred = exp(y_hat_out1), y_true = exp(y_tes
t))

resultados <- data.frame(Modelo = "Regresión lineal",

Muestra = "Dentro",
R2_Score = r2_in1, RMSE = rmse_in1) %
>%
rbind(data.frame(Modelo = "Regresión lineal",
Muestra = "Fuera",
R2_Score = r2_out1, RMSE = rmse_out1))
 Lasso
Qué son las APIs?

API Datos Abiertos # Para obtener un ajuste con regularización Lasso se indica arg
umento alpha = 1.
Regularización o Shrinkage # Si no se especifica valor de lambda, se selecciona un rango a
utomático.
Ejercicio práctico
modelo_lasso <- glmnet(
Referencias x = X_train,
y = y_train,
alpha = 1,
nlambda = 300,
standardize = FALSE
)

# Analicemos cómo cambian los coeficientes para diferentes lamb

das
regularizacion <- modelo_lasso$beta %>%
as.matrix() %>%
t() %>%
as_tibble() %>%
mutate(lambda = modelo_lasso$lambda)

regularizacion <- regularizacion %>%

pivot_longer(
cols = !lambda,
names_to = "predictor",
values_to = "coeficientes"
)

regularizacion %>%
ggplot(aes(x = lambda, y = coeficientes, color = predictor))
+
 geom_line() +
scale_x_log10(
Qué son las APIs? breaks = scales::trans_breaks("log10", function(x) 10^x),
API Datos Abiertos labels = scales::trans_format("log10",
scales::math_format(10^.x))
Regularización o Shrinkage ) +
Ejercicio práctico labs(title = "Coeficientes del modelo en función de la regula
rización (Lasso)", x = "Lambda", y = "Coeficientes") +
Referencias theme_bw() +
theme(legend.position="bottom")
 # ¿Cómo escoger el mejor lambda?
Qué son las APIs? # Veamos cuál es el mejor prediciendo (fuera de muestra)
# En este caso vamos a crear la predicción para cada uno de los
API Datos Abiertos
# 300 lambdas seleccionados
Regularización o Shrinkage predicciones_lasso <- predict(modelo_lasso,
newx = as.matrix(X_test))
Ejercicio práctico
lambdas_lasso <- modelo_lasso$lambda
Referencias
# Cada predicción se va a evaluar
resultados_lasso <- data.frame()
for (i in 1:length(lambdas_lasso)) {
l <- lambdas_lasso[i]
y_hat_out2 <- predicciones_lasso[, i]
r22 <- R2_Score(y_pred = y_hat_out2, y_true = y_test)
rmse2 <- RMSE(y_pred = y_hat_out2, y_true = y_test)
resultado <- data.frame(Modelo = "Lasso",
Muestra = "Fuera",
Lambda = l,
R2_Score = r22,
RMSE = rmse2)
resultados_lasso <- bind_rows(resultados_lasso, resultado)
}

ggplot(resultados_lasso, aes(x = Lambda, y = RMSE)) +

geom_point() +
geom_line() +
theme_bw() +
scale_y_continuous(labels = scales::comma)
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias

ggplot(resultados_lasso, aes(x = Lambda, y = R2_Score)) +

geom_point() +
geom_line() +
theme_bw() +
scale_y_continuous(labels = scales::comma)
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias
 filtro <- resultados_lasso$RMSE == min(resultados_lasso$RMSE)
Qué son las APIs? mejor_lambda_lasso <- resultados_lasso[filtro, "Lambda"]

API Datos Abiertos

# Guardamos el mejor Lasso
Regularización o Shrinkage y_hat_in2 <- predict.glmnet(modelo_lasso,
newx = as.matrix(X_train),
Ejercicio práctico
s = mejor_lambda_lasso)
Referencias y_hat_out2 <- predict.glmnet(modelo_lasso,
newx = as.matrix(X_test),
s = mejor_lambda_lasso)

# Métricas dentro y fuera de muestra. Paquete MLmetrics

r2_in2 <- R2_Score(y_pred = exp(y_hat_in2), y_true = exp(y_trai
n))
rmse_in2 <- RMSE(y_pred = exp(y_hat_in2), y_true = exp(y_trai
n))

r2_out2 <- R2_Score(y_pred = exp(y_hat_out2), y_true = exp(y_te

st))
rmse_out2 <- RMSE(y_pred = exp(y_hat_out2), y_true = exp(y_tes
t))

# Guardamos el desempeño
resultados2 <- data.frame(Modelo = "Lasso",
Muestra = "Dentro",
R2_Score = r2_in2, RMSE = rmse_in2) %
>%
rbind(data.frame(Modelo = "Lasso",
Muestra = "Fuera",
R2_Score = r2_out2, RMSE = rmse_out2))
 # Juntamos resultados con regresión lineal
resultados <- rbind(resultados, resultados2)
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias
 Ridge
Qué son las APIs?

API Datos Abiertos # Ridge. Alpha = 0

modelo_ridge <- glmnet(
Regularización o Shrinkage x = X_train,
Ejercicio práctico y = y_train,
alpha = 0,
Referencias nlambda = 300,
standardize = FALSE
)

# Analicemos cómo cambian los coeficientes para diferentes lamb

das
regularizacion2 <- modelo_ridge$beta %>%
as.matrix() %>%
t() %>%
as_tibble() %>%
mutate(lambda = modelo_ridge$lambda)

regularizacion2 <- regularizacion2 %>%

pivot_longer(
cols = !lambda,
names_to = "predictor",
values_to = "coeficientes"
)

regularizacion2 %>%
ggplot(aes(x = lambda, y = coeficientes, color = predictor))
+
geom_line() +
scale_x_log10(
breaks = scales::trans_breaks("log10", function(x) 10^x),
 labels = scales::trans_format("log10",
scales::math_format(10^.x))
Qué son las APIs? ) +
API Datos Abiertos labs(title = "Coeficientes del modelo en función de la regula
rización (Ridge)", x = "Lambda", y = "Coeficientes") +
Regularización o Shrinkage theme_bw() +
Ejercicio práctico theme(legend.position="bottom")

Referencias
 # ¿Cómo escoger el mejor lambda?
Qué son las APIs? # Veamos cuál es el mejor prediciendo (fuera de muestra)
# En este caso vamos a crear la predicción para cada uno de los
API Datos Abiertos
# 300 lambdas seleccionados
Regularización o Shrinkage predicciones_ridge <- predict(modelo_ridge,
newx = as.matrix(X_test))
Ejercicio práctico
lambdas_ridge <- modelo_ridge$lambda
Referencias
# Cada predicción se va a evaluar
resultados_ridge <- data.frame()
for (i in 1:length(lambdas_ridge)) {
l <- lambdas_ridge[i]
y_hat_out3 <- predicciones_ridge[, i]
r23 <- R2_Score(y_pred = y_hat_out3, y_true = y_test)
rmse3 <- RMSE(y_pred = y_hat_out3, y_true = y_test)
resultado <- data.frame(Modelo = "Ridge",
Muestra = "Fuera",
Lambda = l,
R2_Score = r23,
RMSE = rmse3)
resultados_ridge <- bind_rows(resultados_ridge, resultado)
}

ggplot(resultados_ridge, aes(x = Lambda, y = RMSE)) +

geom_point() +
geom_line() +
theme_bw() +
scale_y_continuous(labels = scales::comma)
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias

ggplot(resultados_ridge, aes(x = Lambda, y = R2_Score)) +

geom_point() +
geom_line() +
theme_bw() +
scale_y_continuous(labels = scales::comma)
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias
 filtro <- resultados_ridge$RMSE == min(resultados_ridge$RMSE)
Qué son las APIs? mejor_lambda_ridge <- resultados_ridge[filtro, "Lambda"]

API Datos Abiertos

# Guardamos el mejor Ridge
Regularización o Shrinkage y_hat_in3 <- predict.glmnet(modelo_ridge,
newx = as.matrix(X_train),
Ejercicio práctico
s = mejor_lambda_ridge)
Referencias y_hat_out3 <- predict.glmnet(modelo_ridge,
newx = as.matrix(X_test),
s = mejor_lambda_ridge)

# Métricas dentro y fuera de muestra. Paquete MLmetrics

r2_in3 <- R2_Score(y_pred = exp(y_hat_in3), y_true = exp(y_trai
n))
rmse_in3 <- RMSE(y_pred = exp(y_hat_in3), y_true = exp(y_trai
n))

r2_out3 <- R2_Score(y_pred = exp(y_hat_out3), y_true = exp(y_te

st))
rmse_out3 <- RMSE(y_pred = exp(y_hat_out3), y_true = exp(y_tes
t))

# Guardamos el desempeño
resultados3 <- data.frame(Modelo = "Ridge",
Muestra = "Dentro",
R2_Score = r2_in3, RMSE = rmse_in3) %
>%
rbind(data.frame(Modelo = "Ridge",
Muestra = "Fuera",
R2_Score = r2_out3, RMSE = rmse_out3))

# Juntamos resultados con regresión lineal y lasso

resultados <- rbind(resultados, resultados3)
 library(knitr)
Qué son las APIs? library(kableExtra)
API Datos Abiertos kable(resultados, digits = 2) %>%
kable_styling()
Regularización o Shrinkage

Ejercicio práctico
Modelo Muestra R2_Score RMSE
Referencias
Regresión lineal Dentro 0.30 0.67

Regresión lineal Fuera -0.13 0.76

Lasso Dentro 0.04 0.78

Lasso Fuera 0.00 0.72

Ridge Dentro 0.12 0.75

Ridge Fuera 0.01 0.71

 plot_final <- data.frame(Modelo = "Regresion lineal",
Qué son las APIs?
API Datos Abiertos
Regularización o Shrinkage
Ejercicio práctico
Referencias
ggplot(plot_final, aes(x = Real, y = Predicho, color = Modelo))
Real = exp(y_test),
Predicho = exp(y_hat_out1)[,drop = T]) %>%
rbind(
data.frame(Modelo = "Lasso",
Real = exp(y_test),
Predicho = exp(y_hat_out2)[,,drop = T])
) %>%
rbind(
data.frame(Modelo = "Ridge",
Real = exp(y_test),
Predicho = exp(y_hat_out3)[,,drop = T])
)
+
geom_point() +
theme_bw() +
geom_abline(intercept = 0, slope = 1, size = 0.5,
linetype = "dashed") +
coord_fixed() +
labs(title = "Resultados del pronóstico")
Qué son las APIs?

API Datos Abiertos

Regularización o Shrinkage

Ejercicio práctico
Referencias

Referencias
McDermott, G. (2020). Lecture 7: Webscraping: (2) Client-side and
APIs. Data science for economists. https://github.com/uo-
ec607/lectures (https://github.com/uo-ec607/lectures)
Cooksey, B. (2014). An introduction to APIs.
https://zapier.com/learn/apis/ (https://zapier.com/learn/apis/)

1. Valen los descargos habituales de responsabilidad. Si tiene comentarios

o sugerencias, envíe un mensaje a través de Slack . Son bienvenidos y
se considerarán en su calificación final.↩︎