Archivo de la categoría: Formación

Modelos tweedie con H2O. Mutualizar siniestralidad en base a factores de riesgo

Formación, Machine Learning, Modelos, R, Seguros,

Ya he escrito sobre la distribución tweedie en otra ocasión y hoy vuelvo a traeros un ejemplo de uso que además servirá para introducir un método, una forma de trabajar con modelos en H2O y R además de emplear gradient boosting machine (gbm) para la obtención de primas de riesgo. Ya hay buenos profesionales repartidos en el mercado laboral a los que les he mostrado como hacer modelos de riesgo para el sector asegurador con R y H2O dentro del Máster en Big Data de la UNED donde imparto el módulo de seguros. Pero hoy quiero traer al blog un resumen de otro tipo de modelos que nos pueden servir para segmentar una cartera de seguros en base a la siniestralidad esperada de un riesgo. Recordad que un seguro trata de mutualizar el gasto entre una cartera, no sé a priori quien va a tener un siniestro (¡si lo supiera!) pero si dispongo de información histórica de mi cartera y esa información me puede dar unas pistas sobre lo que ocurrirá a futuro (habitualmente un año), quiero ver que parte de esa información histórica es reproducible asumiendo siempre un error.

Para entender mejor como se mutualiza, como se reparte el riesgo, como se reparte la siniestralidad en nuestra cartera, vamos a emplear modelos tweedie, además los vamos a realizar con H2O y de paso os comento como trabajo en un entorno R + H2O. El ejemplo lo ilustramos con un conjunto de datos de la librería CASdatasets:

library(CASdatasets)
library(tidyverse)
data("norauto")

Para instalar la librería CASdatasets seguid las instrucciones, no hagáis el español como hice yo. El conjunto de datos de trabajo será norauto que contiene los datos de una cartera de seguros de automóviles. Como he comentado, si simplificamos, lo que buscamos es reproducir esa parte del pasado en el año siguiente. En nuestro caso tenemos un importe siniestral y si asumimos que no hay IPC (si, el IPC afecta a los seguros por eso os suben aunque no hayáis tenido siniestros Seguir leyendo Modelos tweedie con H2O. Mutualizar siniestralidad en base a factores de riesgo →

Computer Vision con R. OpenCV de andar por casa

Big Data, Formación, Inteligencia Artificial, Monográficos, R

Trabajando con Computer Vision aprecio que estamos muy limitados por las máquinas que usamos, o tiene mucho sentido montar GPUs en casa del tamaño del aire acondicionado y por supuesto no tiene sentido el consumo energético que implica. Aquí estoy yo montando una GPU para el análisis de imágenes.

Este tema implica que la Computer Vision no lo podrá usar el común de los data scientist, a los necesarios conocimientos técnicos y matemáticos se añade el disponer de unos recursos tecnológicos que no están al alance de cualquiera. Sin embargo, los conocimientos técnicos y matemáticos los puedes adquirir o puedes aprovecharte de los entornos colaborativos. Pero, podemos iniciarnos en el reconocimiento de imágenes con R y la librería openCV y si salen algunos temas en los que estoy enredando es posible que la reducción de dimensionalidad y la geometría nos ahorre máquinas y energía.

Vamos a emplear dos ejemplos para ver las posibilidades de openCV más R. Partimos de una primera imagen en la que hay 4 personas jugando al futbol y un balón está volando en el aire. Siento no saber de donde saqué esta foto, si tiene algún tipo de derecho hacédmelo llegar. 

library(opencv)
library(tidyverse)

ub = "https://analisisydecision.es/wp-content/uploads/2020/11/futbol.png"

futbol <- ocv_read(ub)

Tenemos la imagen cargada y empezar por ocv_edges(futbol) para ver los límites de las imágenes:

Con ocv_face(futbol) podemos ver las caras que identifica Seguir leyendo Computer Vision con R. OpenCV de andar por casa →

R + Python = reticulate

Big Data, Formación, Monográficos, Python, R

He sido reticente a usar reticulate con R porque no me gusta R markdown y si he trabajado con Python no he necesitado R y viceversa. Ahora tengo en mente algún juego/proyecto de esos que se quedan siempre en el tintero por falta de tiempo o interés pero me están sirviendo para elaborar unos apuntes sobre R markdow y Python que voy a sintetizaros en esta entrada por si a alguien le fuera de utilidad.

Todo comenzará con remotes::install_github("rstudio/reticulate") yo, a pesar de tener varios entornos de Python Anacoda, dejé que se instalara el Miniconda y trabajo con el entorno rstudio. Estoy habituado a que esta labor la realicen los ingenieros (para eso están) y la verdad es que no he tocado nada de la instalación, he dejado a R que lo configure. Si tenéis problemas con Rtools y Windows id a este enlace y lo resolvéis como indica. Al hacer esto partimos de un entorno sin los paquetes habituales y por ello, una vez ejecutemos library(reticulate), tenemos que instalar los paquetes de Python en el entorno de rstudio de Miniconda con py_install('pandas'). De este modo nos podemos ir configurando un entorno con los paquetes que necesitemos.

Disponiendo del entorno requerido ya podemos abrir nuestro notebook en markdown y ejecutar código R o Python, según necesitemos. Un ejemplo a lo ‘mecagüen’ que podéis ejecutar tal cual (si disponéis de los paquetes) en vuestro notebook: Seguir leyendo R + Python = reticulate →

Añadiendo gráficos de tarta a nuestros mapas de ggplot con scatterpie

Formación, Gráficos, Mapas, R

Los gráficos de tarta o pie charts tienen algunos peligros y el ahora escribiente no es muy partidario de su uso, sin embargo la librería scatterpie facilita mucho su realización en R y quería traer al blog un método más o menos sencillo para entender como hacer el gráfico y como disponer los datos.

Obtención del shp con el mapa

Se comienza por realizar un mapa sin nada con ggplot y raster que a los seguidores de los artículos de R del blog les será familiar:

library(scatterpie)
library(tidyverse)
library(raster)

Espania <- getData('GADM', country='Spain', level=1)
Espania$name = Espania$NAME_1

mapa.comunidades <- map_data(Espania)

Se obtiene el shp con el mapa por Comunidades de GADM, el nivel de Comunidad Autónoma es el 1, para crear un data frame que emplear en ggplot necesitamos un campo name que la función map_data transformará en region, en este paso recomiendo usar como name el campo que más sencillo sea de cruzar, habitualmente códigos porque los nombres de las Comunidades Autónomas son un follón. En este caso si se emplea el nombre para entender mejor los datos necesarios para crear los gráficos de bolas y que el código sea reproducible (con las cositas del wordpress).

Pintar un mapa sin nada

A la hora de pintar el mapa se va a emplear geom_map, habitualmente se usa geom_polygon:

mapa.comunidades <- mapa.comunidades %>% mutate(lat=case_when(
  region %in% c('Islas Canarias') ~ lat + 6,
  TRUE ~ lat),
  long=case_when(
    region %in% c('Islas Canarias') ~  long + 6,
    TRUE ~long))

mapa <- ggplot(data = mapa.comunidades, aes(x = long, y = lat)) +
  geom_map (map= mapa.comunidades, aes(map_id=region), fill=NA, color="grey50") +
  labs(title = "Mapa sin nada") + 
  theme(panel.grid.major = element_blank(), 
        panel.grid.minor = element_blank()) +
  theme(axis.title.x=element_blank(),
        axis.text.x=element_blank(),
        axis.ticks.x=element_blank(),
        axis.title.y=element_blank(),
        axis.text.y=element_blank(),
        axis.ticks.y=element_blank())
mapa

Como sabéis ggplot es perfectamente modulable y podéis elegir colores de fondo, colores de línea, ubicación de títulos,… muchas veces tantas posibilidades pueden provocar que nos perdamos. Si recomiendo en estos gráficos eliminar los ejes y los textos de los ejes.

Datos para los piechart

Para las tartas se prefiere simular datos. En el ejemplo vamos a realizar una tarta para cada comunidad y el tamaño de la tarta tendrá una escala determinada.

#Datos por comunidad
comunidades <- data.frame(region = unique(mapa.comunidades$region)) 
comunidades$proporcion_1 <- round(runif(nrow(comunidades)),2)
comunidades$proporcion_2 <- 1 - comunidades$proporcion_1

#Nos inventamos una escala para el tamaño de la bola
comunidades$escala <- rpois(nrow(comunidades), 2) + 1

Cada comunidad autónoma tiene 2 proporciones y se crea un campo escala para definir el radio del gráfico de tarta, los datos tienen que tener disposición de columna. Ahora se ha de ubicar cada piechart dentro del mapa y para ello se opta por una solución sencilla, ubicarla en el punto medio por Comunidad Autónoma:

#Necesitamos ubicar cada comunidad, en el centro del objeto
ubicacion <- mapa.comunidades %>% group_by(region) %>% summarise(lat=mean(lat), long=mean(long))

comunidades <- left_join(comunidades, ubicacion)

Ahora el data frame comunidades tiene una latitud y una longitud para ubicar cada piechart. Ahora sólo es necesario realizar el mapa.

Mapa final

Y el mapa con el que comienza la entrada se realiza con este sencillo código:

mappie <- mapa + labs(title = "No uséis bolas") +
  geom_scatterpie(data = comunidades, aes(x=long, y=lat, group = region, r = escala/50 * 6),
                  cols = c('proporcion_1', 'proporcion_2'), 
                  legend_name = "Leyenda")

mappie

geom_scatterpie necesita los datos, la posición y la region, el tamaño, el radio del gráfico lo especificamos con r y siempre irá multiplicado por 6 (por temas de escala). En cols es necesario especificar las variables a representar, en este caso solo tenemos 2 proporciones, son pocos parámetros complejos y la solución no es mala si no fuera por que se tratan de gráficos de tarta. Saludos.

Calcular porcentajes por grupos con dplyr

Formación, R

A la hora de sumarizar datos con dplyr podemos calcular porcentajes dentro de grupos o subgrupos con transmute. La sintaxis es sencilla pero tiene la peculiaridad que sólo obtendremos como salida lo que indiquemos en transmute. Mejor lo entendéis en un ejemplo:

Conjunto de datos aleatorio de ejemplo:

library(dplyr)
observaciones = 100
grupo_1 = rpois(observaciones, 0.5)
grupo_2 = rpois(observaciones, 1)

df = cbind.data.frame(grupo_1, grupo_2) %>% mutate(id_cliente=n())

Sumarizamos por grupos:

df %>% group_by(grupo_1, grupo_2) %>% summarise(clientes = n())

Contamos clientes y calculamos el porcentaje sobre el total:

df %>% group_by(grupo_1, grupo_2) %>% 
  summarise(clientes = n(),
            pct_total = n()/nrow(df))

Suelo usar nrow se aceptan sugencias. Calculamos el porcentaje para el subgrupo del grupo_1, primer ejemplo de uso de transmute:

df %>% group_by(grupo_1, grupo_2) %>% 
  summarise(clientes = n()) %>% 
  transmute(grupo_2, pct_grupo = clientes/sum(clientes))

Vemos que clientes ha desaparecido, sólo obtenemos grupo_1, grupo_2 y pct_grupo. Si queremos el porcentaje sobre el total:

df %>% group_by(grupo_1, grupo_2) %>% 
  summarise(clientes = n()) %>% 
  transmute(grupo_2, pct_grupo = clientes/sum(clientes),
            pct_total = clientes/nrow(df))

Aquí lo tengo todo recogido, para cuando no lo recuerde. Saludos.

Tablas elegantes en #rstats y formattable

Business Intelligence, Formación, R

Las salidas de la consola de R para muchos de nosotros son más que suficientes. Además en mi caso particular prefiero poner las cosas más elegantes en otras herramientas como Excel, Qlik Sense o Tableau. Pero me he dado cuenta que hay una librería que sí uso cuando directamente copio y pego salidas de R en correos, presentaciones o si empleo markdown (rara vez); esta librería es formattable, es posible que haya mejores librerías pero esta es la que yo uso desde hace un par de años.

Vamos a ilustrar algunos ejemplos de uso con un código ya conocido, extraemos la información de casos de COVID de Datadista y vamos a poner una tabla con la evolución de casos, UCI, altas y fallecimientos para el mes de octubre de 2020:

library(tidyverse)
library(formattable)
library(lubridate)

data <- read.csv("https://raw.githubusercontent.com/datadista/datasets/master/COVID%2019/nacional_covid19.csv",
         check.names=FALSE)

colnames(data)[1] = 'fecha'

data$Fecha <- as.Date(data$fecha, "%Y-%m-%d")
data$`Casos nuevos` <- c( NA, diff(data$casos_pcr))
data$`Altas nuevas`<- c( NA, diff(data$Altas))
data$`Fallecimientos nuevos` <- c( NA, diff(data$fallecimientos))
data$`UCI nuevas` <- c(NA, diff(data$ingresos_uci))

data_filtered <- data %>% filter(month(Fecha)==10 & `Casos nuevos`>0) %>% 
  select(Fecha, `Casos nuevos`, `Altas nuevas`,  `Fallecimientos nuevos`, `UCI nuevas`)

formattable(data_filtered)

Y si queremos el HTML:

format_table(data_filtered)
Fecha Casos nuevos Altas nuevas Fallecimientos nuevos UCI nuevas
2020-10-01 9419 NA 182 88
2020-10-02 11325 NA 113 59
2020-10-05 23480 NA 139 83
2020-10-06 11998 NA 261 71
2020-10-07 10491 NA 76 49
2020-10-08 12423 NA 126 102
2020-10-09 12788 NA 241 90
2020-10-12 27856 NA 195 85
2020-10-13 7118 NA 80 38
2020-10-14 11970 NA 209 80
2020-10-15 13318 NA 140 73
2020-10-16 15186 NA 222 86
2020-10-19 37889 NA 217 147

Copiando y pegando podemos incrustar en html. Seguir leyendo Tablas elegantes en #rstats y formattable →

Evita problemas con Excel desde R. De tocar el dato a un proceso

Excel, Formación, R

En estos días hemos vivido una situación con Excel y los datos de COVID de UK peculiar. Hemos aparecido todos en las redes sociales para reírnos de Excel y de los que usan Excel. De nuevo partidarios de Matlab, R, Python,… ¡a la gresca! Mi opinión la podéis leer en Twitter y creo que sobre este tema puedo opinar. En mi vida profesional me he especializado en cambiar equipos de negocio, por ese motivo tanto ir y venir de compañía. Uno de esos cambios consiste en transformar super usuarios de Excel a usuarios de herramientas más apropiadas para la gestión de la información.

Mi carrera en el sector de la gestión de la información comenzó introduciendo SAS allí donde Business Objects  y Access ya eran insuficientes. Continué con SAS durante muchos años, siempre con guiños al software libre porque R me permitía llegar allá donde SAS n€c€sitaba otro$ módulo$. En los últimos años estoy alternando el uso de Python con R. Sin embargo, mis ponencias y mis presentaciones de servicios están incluyendo el siguiente gráfico:

Soy partidario de SAS, es la mejor herramienta, de SPSS no opino porque no he trabajado lo suficiente (¿sigue existiendo Clementine?) pero no son gratis, una PYME no puede permitirse un alto gasto en software.  Python con sus IDE y Pandas son muy duros para personas acostumbradas a las fórmulas de Excel. Ahí aparece R y sobre todo el universo tidyverse y RStudio, es la clave del cambio y lo que debe hacer que todos esos super usuarios de Excel miren hacía R. Por eso se me ocurrió ese dibujo y ahí estoy.

No usemos Excel como motor de BBDD, no toquemos manualmente los datos, empecemos a entender que la gestión de datos no es un buscar objetivo, la gestión de datos es un proceso que, además, puede ser usado por otro y se puede reproducir no es estático. Se trata de evitar fórmulas que solo entiende el autor, programas de Visual Basic que no entiende ni  el autor y yo sugiero crear un flujo de este modo: chimpún %>% chimpún %>% chimpún. No es difícil y no se trata de prescindir de Excel, porque a Excel ya irán tus datos preparados, nunca podrás tocar un dato previo ya que pasamos del dato en bruto guardado en una BBDD o repositorio al dato final que si usarás en Excel.

Si soy yo el que te ayuda ese proceso prefiero usar R:

  1. Es gratuito, te instalas R y RStudio y los paquetes que necesites.
  2. Es sencillo, unas instrucciones te permiten hacer con dplyr el 90% del trabajo que haces en Excel con cientos de fórmulas.

Un ejemplo práctico, pasando datos de R a Excel

Por último me gustaría ilustrar este trabajo con un ejemplo para poder evaluar la complejidad y como podrías plantear este trabajo, necesitamos leer diariamente los datos de COVID que publica Datadista para disponer de un Excel con esos datos y pintar nuestro seguimiento, también sería interesante obtener un pequeño resumen que nos permita localizar datos atípicos en la serie que se publica. Vamos a emplear la librería openxlsx para generar un Excel con este propósito. El primer paso será leer los datos de Datadista (incluyen los programas para facilitar la cosa) y crear nuestros objetos en R:

library(dplyr)
library(ggplot2)
library(gridExtra)
library(grid)

data <-
  read.csv("https://raw.githubusercontent.com/datadista/datasets/master/COVID%2019/nacional_covid19.csv",
           check.names=FALSE)

colnames(data)[1] = 'fecha'

data$fecha <- as.Date(data$fecha, "%Y-%m-%d")
data$Casos.nuevos <- c( NA, diff(data$casos_pcr))
data$Altas.nuevas <- c( NA, diff(data$Altas))
data$Fallecimientos.nuevos <- c( NA, diff(data$fallecimientos))
data$UCI.nuevos <- c(NA, diff(data$ingresos_uci))

Un ejemplo claro, por algún motivo en Windows el nombre de la variable fecha contiene algún carácter extraño, modifico el nombre con colnames, esta acción queda reflejada en un proceso. Si se producen cambios en los campos de la tabla quedan recogidos en un código que puede ser reproducible por cualquier persona de la organización, podemos (es conveniente) llevar un control de versiones del código por si se produjeran cambios. Las fórmulas empleadas no distan de las que usamos en Excel y si se desconoce que fórmula usar R tiene una comunidad de usuarios por detrás que estarán dispuestos a ayudar, eso no pasa con SAS (por ejemplo).

Continuamos y deseamos realizar un gráfico con los casos nuevos por día para buscar posibles anomalías:

p1 <- ggplot(data,aes(x=fecha,y=Casos.nuevos),na.rm = TRUE) +
  geom_line() +
  geom_smooth() + ggtitle("Casos nuevos") + theme_minimal()

p2 <- ggplot(data,aes(x=fecha,y=Fallecimientos.nuevos),na.rm = TRUE) +
  geom_line() + geom_smooth() + ggtitle("Fallecimientos nuevos") + theme_minimal()

p3 <- ggplot(data,aes(x=fecha,y=UCI.nuevos),na.rm = TRUE) + geom_line() +
  geom_smooth() + ggtitle("UCI nuevos") + theme_minimal()

p <- grid.arrange(p1, p2, p3, ncol=2)

Este paso puede ser más duro, hacer gráficos en R ya no es seleccionar datos y tipo de gráfico pero en dos líneas hemos hecho un gráfico, es el mismo para las tres variables que deseamos analizar y deseamos unir todos los gráficos de ggplot en uno lo hacemos con una función que se llama grid.arrange. Esto lo haces una vez, no lo repites siempre y si lo intentas hacer con Visual Basic lo conseguirás pero otro compañero no podrá abrir las macros, a otro no le funciona,… -¿esto quién lo hizo? -¡pero si ya está jubilado!

Ahora lo que hacemos es poner estos datos en un Excel para hacer nuestros resúmenes, nuestro cuadro de mando con tablas dinámicas,… lo que sea para lo que Excel si es una gran herramienta (si, he puesto cuadros de mando). Este código también es más complejo pero siempre es el mismo:

library(openxlsx)

excel <- createWorkbook()
addWorksheet(excel, sheetName = "DatosCOVID")

print(p)
writeDataTable(excel,sheet = "DatosCOVID", x=data)
insertPlot(excel, sheet = "DatosCOVID", startRow = 2, startCol = length(data) + 2, )

saveWorkbook(excel, "C:/temp/datos_covid.xlsx")
remove(excel)

Creamos un “entorno excel” con createWorkbook al que podemos añadir hojas con addWoksheet y en esas hojas añadimos elementos, una tabla con writeDataTable y un gráfico, que necesitamos imprimir previamente, con insertPlot. Vemos que los datos que publica el Ministerio sobre el Covid tienen anomalías, parece ser que un día concreto resucitaron 1.900 personas, podríamos ir al código y eliminarlo.

Para un usuario de Excel pueden parecer complicadas las fórmulas sin embargo podemos evitar problemas referenciando celdas, modificando celdas, borrando elementos,… Y no es más complejo que una fórmula de Excel.

Manejo de datos básico con Python datatable

Formación, Machine Learning, Python,

Nueva entrada dedicada al data management con Python, esta vez con datatable. No voy a justificar el uso de datatable antes que pandas, en un vistazo rápido por la web encontráis numerosas ocasiones en las que datatable es más eficiente que pandas en el manejo de datos con Python. En cuanto a la complejidad en el uso de uno u otro mi opinión no es objetiva porque  me cuesta mucho trabajar con Pandas.

Asumo que habéis instalado datatable en vuestro entorno de Python (siempre por encima de la versión 3.5) y una vez está instalado os propongo obtener un conjunto de datos del repositorio de analisisydecision. Por supuesto la carga de este csv de ejemplo la realizamos con datatable y la función fread:

import datatable as dt
path = 'https://raw.githubusercontent.com/analisisydecision/intro_python_data_science/master/'
dt_df = dt.fread(path + 'index.csv')
dt_df.head()

dt_df.shape

Hemos creado un data frame con datatable, podremos pasarlo a lista o a data frame en pandas con .to_pandas(). En la línea de siempre las tareas que vamos a revisar con datatable en Python son:

  • Seleccionar columnas
  • Eliminar columnas
  • Seleccionar registros
  • Crear nuevas variables
  • Sumarizar datos
  • Renombrar variables
  • Ordenar datos

Seguir leyendo Manejo de datos básico con Python datatable →

Transformaciones de variables cuantitativas en modelos binomiales

Formación, Machine Learning

Para mejorar la capacidad predictiva de nuestros modelos binomiales es recomendable transformar las variables independientes. Existen técnicas que lo hacen de modo automático pero hoy os quería mostrar en un video un método “casero” para agrupar una variable cuantitativa con respecto a una variable respuesta, todo muy orientado a que la transformación tenga un sentido de negocio.

El código empleado para hacer el video es el siguiente:

from urllib import urlretrieve
link = 'https://raw.githubusercontent.com/yhat/demo-churn-pred/master/model/churn.csv'
urlretrieve(link, "churn.txt")

import pandas as pd
import numpy as np
df = pd.read_csv("churn.txt")
df.head(5)

import matplotlib
matplotlib.use('TkAgg')
import matplotlib.pyplot as plt

pd.crosstab(df['Churn?'], columns='count').plot(kind='bar')
plt.show();

df['churn'] = np.where(df['Churn?'] == 'True.', 1, 0)

pd.crosstab(df['churn'], columns='count')

df['Day Mins'].isnull().sum()
df['Day Mins'].describe()
plt.hist(df['Day Mins'], bins=20); plt.show();

df['minutos'] = np.where(df['Day Mins'] >= 270, 270, (df['Day Mins']//10)*10)
df['minutos'] = np.where(df['minutos'] <= 70, 70, df['minutos'])

pd.crosstab(df['minutos'], columns='count')
plt.hist(df['minutos']); plt.show();

churn =  pd.DataFrame((df['churn']).groupby(df['minutos']).mean())
clientes = pd.DataFrame((df['churn']).groupby(df['minutos']).count())


fig = plt.figure()
ax = clientes['churn'].plot(kind='bar', grid=True)
ax2 = ax.twinx()
ax2.plot(churn['churn'].values, linestyle='-', linewidth=2.0,color='red')
plt.show();

Variables categóricas en cajas, treemap con R

Formación, R, Seguros

La representación de variables categóricas en cajas es uno de los gráficos que más utilizo, empezaron a gustarme debido al uso de Qlik Sense y sus gráficos de cajas, me permitían comparar variables categóricas en un periodo frente a otro. En R podemos usar la librería treemap para realizar estos gráficos y comparar variables categóricas. En este caso interesa comparar una variable dentro de dos grupos.

Para ilustrar el ejemplo nos suministran un conjunto de datos con información de un seguro de responsabilidad civil de motocicletas de una compañía sueca. Este conjunto de datos está en la librería CASdatasets de R:

library(tidyverse)
library(CASdatasets)

data(swmotorcycle)

Nos piden evaluar la variable RiskClass, esta variable es categórica y viene definida como la relación de la potencia de la moto en KW x 100 entre el peso de la moto + 75 kg (peso medio del piloto). Esta relación se divide en 7 clases que son necesarias de evaluar.

Vamos a crear una variable binomial Tiene_siniestro si el importe del siniestro es mayor que 0 tomará “Tiene siniestro”, si el importe es <=0 tomará “No tiene siniestro”. Y mediante la librería de R treemap compararemos la exposición al riesgo de cada grupo Tiene_siniestro x RiskClass. Para llevar a cabo esta comparativa usaremos un gráfico de cajas Seguir leyendo Variables categóricas en cajas, treemap con R →