Archivos de la categoría Formación

Los bancos lo llaman Transformación Digital yo lo llamo me da miedo Facebook

¿Si Facebook prestara dinero? ¿Si Facebook hiciera un banco? Tiene información interesante de nosotros, variables relevantes para cualquier modelo de scoring de crédito y sabe como es tu comunidad de amigos cibernéticos y cuales de ellos podrían avalarte a la hora de conceder un crédito. Además tanto Facebook, como Amazon o Wallapop tienen sus propios medios de pago y Google no tardará en crear su propio banco, unos están creando la economía del futuro y otros no pueden sobrevivir sin programadores en COBOL, entiendo que se quieran transformar aunque a lo mejor no es un tema de captar pasivo y prestar dinero a lo mejor es un tema de relacionar los recursos de las personas.

Pasando de SAS a R. Primer y ultimo elemento de un campo agrupado de un data frame

Las personas que están acostumbradas a trabajar con SAS emplean mucho los elementos first, last y by, en el blog hay ejemplos al respecto, en R podemos hacer este trabajo con la librería “estrella” dplyr de un modo relativamente sencillo. A continuación se presenta un ejemplo para entender mejor como funciona, creamos un conjunto de datos aleatorio:

id <- rpois(100,20)
mes <- rpois(100,3)+1
importe <- abs(rnorm(100))*100

df <- data.frame(cbind(id,mes,importe))

Tenemos un identificador, una variable mes y un importe y deseamos obtener el menor importe por mes el primer paso a realizar es ordenar el data frame de R por ese identificador, el mes y el importe en orden descendente:

df <- df[with(df,order(id,mes,-importe)),]

Una vez ordenado el data frame de R tenemos que seleccionar el último elemento por id para seleccionar aquellos clientes con menor importe:

library(dplyr)
df_bajo_importe <- df %>% group_by(id) %>% filter(row_number()==n())

Si deseamos seleccionar el mayor importe hacemos lo mismo:

library(dplyr)
df_bajo_importe <- df %>% group_by(id) %>% filter(row_number()==1)

Las funciones group_by unidas a filter(row_number) equivalen a esos first y last de SAS. Saludos.

¿Puede la información de Twitter servir para calcular el precio de tu seguro?

rvaquerizo

Debemos de ir introduciendo el concepto de Social Pricing en el sector asegurador, si recordamos el año pasado Admirall y Facebook tuvieron un tira y afloja por el uso de la información de Facebook para el ajuste de primas de riesgo. Facebook alegaba a la sección 3.15 de su privacidad para no permitir emplear esta información a Admirall. Probablemente es un tema más económico. El caso es que tanto Facebook, como Instagram, como Twitter, como LinkedIn, como xVideos,… tienen información muy interesante acerca de nosotros, información que se puede emplear para el cálculo de primas en el sector asegurador (por ejemplo). No voy a decir como hacer esto, este blog no es el lugar, el que quiera conocer mis ideas que se ponga en contacto conmigo. Yo soy alguien “público”, no tengo problema en dejar mis redes sociales abiertas y este caso me sirve de ejemplo para analizar que dice Twitter de mí y también sirve de ejemplo para refrescar el manejo de información con Twitter con #rstats. Esta entrada es una combinación de entradas anteriores de esta bitácora así que recordemos como empezábamos a hacer scrapping de Twitter:

 library(twitteR)
library(base64enc)

consumer_key="XXXXXXXXXxxxxXXXXXXXxx"
consumer_secret="xxXXXXXXXXxxXXXXXXXXXxxXXxxxxx"
access_token="81414758-XXxXxxxx"
access_secret="XXXxXXxXXxxxxx"

setup_twitter_oauth(consumer_key, consumer_secret, access_token=access_token, access_secret=access_secret)

Vía Oauth ya podemos trabajar con el paquete twitteR desde nuestra sesión de R y ahora lo que vamos a crear es un objeto R del tipo “user” con la información que tiene el usuario r_vaquerizo (yo mismo):

rvaquerizo <- getUser('r_vaquerizo')
rvaquerizo_seguidos <- rvaquerizo$getFriends(retryOnRateLimit=120)
seguidos <- do.call("rbind", lapply(rvaquerizo_seguidos, as.data.frame))

El objeto rvaquerizo tiene mucha información sobre mí Sigue leyendo ¿Puede la información de Twitter servir para calcular el precio de tu seguro?

Archivos shape y geojason para crear un mapa de España por códigos postales

Como sabéis Correos (empresa de capital 100% público) ha decidido no colaborar con CartoCiudad (leer los comentarios de este enlace) y poner precio a los mapas de España por códigos postales. El ahora escribiente no se descargó todas las provincias y no puede pasaros estos archivos shape, sin embargo un comentario de Iñigo Flores en el mismo enlace de antes nos pone en la pista de un dataset con los códigos postales. Podemos encontrar tanto los archivos shape como los archivos geojson:

Pulsa aquí para acceder al repositorio git de Iñigo con los archivos necesarios para realizar un mapa de España por códigos postales.

El único problema... no está actualizado, si quieres el mapa actualizado prepara 5.000 € para tu proyecto de fin de grado, master,...

Gráfico de barras y líneas con Python

grafico de barras y lineas python

Típico gráfico de dos ejes de barras y líneas donde las barras miden una exposición y las líneas una frecuencia, en el mundo actuarial son muy habituales y son muy útiles para ver proporciones dentro de grupos a la vez que representamos el tamaño del grupo. Los datos habituales del curso de GLM for insurance data:

import pandas as pd
df = pd.read_csv('http://www.businessandeconomics.mq.edu.au/our_departments/Applied_Finance_and_Actuarial_Studies/acst_docs/glms_for_insurance_data/data/claimslong.csv')

df.head()

Ya tenemos un data frame con nuestros datos leyendo directamente del csv, ahora preparamos los datos para representarlos:

frecuencia =  pd.DataFrame((df['claim']).groupby(df['period']).mean())
exposicion = pd.DataFrame((df['claim']).groupby(df['period']).count())

No tenemos un campo exposición en los datos, asumo que la exposición es igual al número de registros así que la frecuencia será la media de los siniestros y la exposición el total de registros, el análisis lo hacemos por el campo period, es el campo por el que agrupamos y ahora solo tenemos que realizar el gráfico:

import matplotlib.pyplot as plt

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

El eje principal es ax y representa la exposición en barras, con ax.twinx añadimos eje secundario, ax2 que será la línea que contiene la frecuencia. No es un código python complejo y es un tipo de gráfico que nos ofrece mucha información. En breve GLM con python (espero).

Machine learning. Elegir el mejor Gradient Boost de forma iterativa con GridSearchCV

Carlos [aka "el tete"] me está enseñando python y una de las cosas que me ha enseñado es seleccionar de forma iterativa el mejor modelo con GridSearchCV y por si fuera poco vamos a emplear el método de clasificación "gradient boosting" para que no caiga en desuso sobre todo porque es una técnica que, bajo mi punto de vista, ofrece modelos muy estables. El ejemplo para ilustrar el proceso ya es conocido ya que vamos a estimar la letra O, mi talento no da para mucho más. Recordamos los primeros pasos:

import numpy as np
import pandas as pd
from pylab import *
 
largo = 10000
 
df = pd.DataFrame(np.random.uniform(0,100,size=(largo, 2)), columns=list('XY'))
 
dependiente1 = np.where(((df.X-50)**2/20**2 + (df.Y-50)**2/40**2>1) ,1,0)
dependiente2 = np.where(((df.X-50)**2/30**2 + (df.Y-50)**2/50**2>1) ,1,0)
dependiente = dependiente1 - dependiente2
 
plt.scatter(df.X, df.Y,c=dependiente,marker=".")
show()

Tenemos una letra O fruto de jugar con la ecuación de la elipse y ahora creamos el conjunto de datos con el que entrenamos el modelo y el conjunto de datos de test para comprobar posteriormente como funciona:

#Dividimos en validacion y test
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df,dependiente,stratify=dependiente,
test_size = 0.5, random_state=123)

Nada nuevo bajo el sol pero me gusta poner los ejemplos al completo para que sean reproducibles. Ahora vienen las enseñanzas "del tete":

# GradientBoostingClassifier
from sklearn.ensemble import GradientBoostingClassifier 
from sklearn.model_selection import GridSearchCV
np.random.seed(40)

#Parámetros para iterar
fun_perdida = ('deviance', 'exponential')
profundidad = range(5,15)
minimo_split =range(5,10,1)
learning_rate = [ 0.01, 0.1, 0.2, 0.3]

modeloGBM = GradientBoostingClassifier(random_state=1,n_estimators =100)

param_grid = dict(max_depth = profundidad, min_samples_split=minimo_split,
                  loss = fun_perdida, learning_rate=learning_rate)

grid = GridSearchCV(modeloGBM, param_grid, cv=10,scoring= 'roc_auc')
grid.fit(X_train,y_train)

mejor_modelo = modeloGBM.fit(X_train,y_train)

Los protragonistas de la entrada son GradientBoostingClassifier Sigue leyendo Machine learning. Elegir el mejor Gradient Boost de forma iterativa con GridSearchCV

Mosaic plot con python

Entrada análoga a otra realizada con R hace mucho tiempo empleando R, ahora realizo esta tarea con pytho. Estos gráficos van a ser necesarios para un fregado en el que ando metido ahora y como podéis ver es una tarea muy sencilla:

 
import pandas as pd
df = pd.read_csv('http://www.businessandeconomics.mq.edu.au/our_departments/Applied_Finance_and_Actuarial_Studies/acst_docs/glms_for_insurance_data/data/claimslong.csv')

from statsmodels.graphics.mosaicplot import mosaic
mosaic(df, ['agecat', 'valuecat'])
show()

Y da como resultado:

mosaic_plot_python

Saludos.

¿Si hacemos modelos de riesgo con python?
 

Parámetros en las consultas de Hive. Ejemplo con fechas

Soy cinturón blanco de Hive pero aprovecho el blog para mostraros como he añadido unas variables a mi consulta de Hive, en realidad espero que algún alma caritativa me indique alguna forma más elegante. Necesito que mis consultas vayan parametrizadas por fechas que hacen mención a particiones de la tabla, estas particiones no son variables fecha, son string con el formato YYYYMMDD así que es necesario transformar las variables para realizar operaciones con ellas. En este caso tengo una fecha inicio y quiero irme tres meses hacia atrás:

set inicio="20161231";
set f_aux = add_months(from_unixtime(unix_timestamp(${hiveconf:inicio} ,'yyyyMMdd'), 'yyyy-MM-dd'),-3);
set f_mes_menos3 = from_unixtime(unix_timestamp(${hiveconf:f_aux} ,'yyyy-MM-dd'), 'yyyyMMdd');

Con set defino las variables de mi entorno a las que yo referencio como ${hiveconf:variable}, desconozco si hay otra forma mejor de hacerlo y transformo de caracter a fecha con from_unixtime + unix_timestamp para así poder usar la función add_months que no me funcionaba con string. Después deshago el cambio y ya tengo otra variable a partir de la primera, puedo automatizar mis parámetros. ¿Lo estoy haciendo bien?

Machine learnig. Análisis gráfico del funcionamiento de algunos algoritmos de clasificacion

Letra_O

De forma gráfica os voy a presentar algunas técnicas de clasificación supervisada de las más empleadas en Machine Learning y podremos ver cómo se comportan de forma gráfica en el plano. Como siempre prefiero ilustrarlo a entrar en temas teóricos y para esta tarea se me ha ocurrido pintar una letra O y comenzar a trabajar con Python, así de simple. Lo primero es tener los datos, evidentemente serán puntos aleatorios en el plano donde pintamos una variable dependiente con forma de O:

 
import numpy as np
import pandas as pd
from pylab import *

largo = 10000

df = pd.DataFrame(np.random.uniform(0,100,size=(largo, 2)), columns=list('XY'))

dependiente1 = np.where(((df.X-50)**2/20**2 + (df.Y-50)**2/40**2>1) ,1,0)
dependiente2 = np.where(((df.X-50)**2/30**2 + (df.Y-50)**2/50**2>1) ,1,0)
dependiente = dependiente1 - dependiente2

plt.scatter(df.X, df.Y,c=dependiente,marker=".")
show()

Se crea un data frame con 10.000 registros y dos variables aleatorias con valores entre 0 y 100 X e Y. Soy consciente de la forma en la que se obtiene la variable dependiente, no entiendo como funciona np.where con condiciones múltiples y por ello toman valor 1 aquellas observaciones del plano que están entre las dos eclipses que pinto dentro del plano. Con todo esto tenemos unos datos como ilustran el scatter plot con el que se inicia esta entrada. El siguiente paso será dividir los datos en validación y test mediante train_test_split:

 
#Dividimos en validacion y test
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(df,dependiente,stratify=dependiente,
test_size = 0.5, random_state=123)

Ahora vamos a estudiar gráficamente como se comportan algunos algoritmos de machine learning para clasificar la letra O en el espacio. Empezamos por los árboles de decisión Sigue leyendo Machine learnig. Análisis gráfico del funcionamiento de algunos algoritmos de clasificacion