La operación con fechas en meses con el formato YYYYMM es tarea habitual cuando trabajamos con tablas particionadas. De hecho hay una entrada en el blog sobre esto muy popular. Me ha surgido este tema con Python y os pongo la función que he creado:
[source languaje=”python”]
def dif_mes(d1, d2):
return (d1//100 – d2//100) * 12 + d1%100 – d2%100
dif_mes (201812,201709)
[/source]
Muy sencilla, por si os surge la necesidad.
Muchos de los lectores de esta bitácora conocéis https://www.datanalytics.com/ el blog de Carlos Gil. En él ha publicado un libro/manual de R de acceso libre para todos aquellos que necesitéis una guía que abarque desde lo más básico al tratamiento de datos con R pasando por Shiny y análisis estadísticos de esos viejunos tan denostados últimamente.
De todas formas no sé como no deja este mundillo y se dedica plenamente a su faceta hostelera. En palabras de mi hijo: “El mejor brunch de Madrid, un 10”.
Los días 13 y 14 de Febrero no podéis perderos en Madrid el ILOVEFS18 un evento al que si estáis por aquí no podéis faltar. Para más información tenéis el siguiente link:
http://medialab-prado.es/article/ilovefs18
¡Nos vemos!
Desde hace tiempo mis frases son más cortas. Creo que es un problema de las redes sociales, sobre todo twitter, que está cambiando mi comportamiento. Para analizar si esto está pasando se me ha ocurrido analizar la longitud de las frases de este blog desde sus inicios y de paso aprovechar para hacer web scraping con la librería Beatifulshop de Python. La idea es recorrer el blog y calcular la longitud de las frases y representar gráficamente como ha ido evolucionando esa longitud.
Podía haber trabajado directamente con la base de datos de wordpress pero he preferido leer las páginas de la web. Hay un problema, si véis el nombre de las páginas no tiene un orden cronológico, son el nombre de la propia entrada [https://analisisydecision.es/los-bancos-lo-llaman-transformacion-digital-yo-lo-llamo-me-da-miedo-facebook/] pero es cierto que se almacena una vista por mes de las entradas publicadas [https://analisisydecision.es/2017/02/] vamos a emplear esas vistas que no recogen la entrada entera pero si las primeras frases, con estas limitaciones vamos a medir la longitud de las frases.
Luego la analizamos paso a paso pero la función de Python que voy a emplear es:
import pandas as pd from bs4 import BeautifulSoup import requests import re import time import string def extrae (anio, mes): url = "https://analisisydecision.es/" + anio + "/" + mes + "/" print (url) # Realizamos la petición a la web pagina = requests.get(url) soup = BeautifulSoup(pagina.content, 'html.parser') m = str(soup.find_all('p')) m = BeautifulSoup(m) m = str(m.get_text()) frases = pd.DataFrame(m.split("."),columns=['frase']) frases['largo'] = frases['frase'].str.len() frases['mes'] = anio + mes frases['frase'] = frases['frase'].apply(lambda x:''.join([i for i in x if i not in string.punctuation])) frases = frases.loc[frases.largo>10] time.sleep(60) return frases |
Os comento paso a paso, a la función le vamos a pasar el mes y el año y esa será la url que lee https://analisisydecision.es/2017/02/ esa es la web sobre la que vamos a hacer el scraping. Vía request obtenemos la web y BeatifulSoup sólo para quedarnos con el contenido en HTML de la web cargada (más…)
¿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.
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.
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:
[sourcecode lang=”R”]
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)
[/sourcecode]
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):
[sourcecode lang=”R”]
rvaquerizo <- getUser(‘r_vaquerizo’)
rvaquerizo_seguidos <- rvaquerizo$getFriends(retryOnRateLimit=120)
seguidos <- do.call("rbind", lapply(rvaquerizo_seguidos, as.data.frame))
[/sourcecode]
El objeto rvaquerizo tiene mucha información sobre mí (más…)
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:
El único problema… no está actualizado, si quieres el mapa actualizado prepara 5.000 € para tu proyecto de fin de grado, master,…
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).
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 (más…)