Archivo

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,...

Truco Python. Reemplazar una cadena de caracteres en los nombres de las columnas de un data frame

Más largo el título de la entrada que la entrada en si misma. Tenemos un conjunto de datos que os podéis descargar de este link que ya es conocido. Os descargáis los datos y creamos un data frame que tiene 10.000 registros y 251 columnas, casi todas se llaman attx y queremos cambiar el nombre a columna_x. Mi sugerencia para hacerlo vía pandas es:

import pandas as pd
df = pd.read_csv('C:\\temp\\wordpress\\au2_10000.csv')
df.head()

df.columns = df.columns.str.replace('att','columna_')
df.head()

Espero que sea de utilidad. Saludos.

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

Como me encuentro hoy, con #rstats

Happy_con_R

Gráfico absurdo con R y un buen ejemplo de las cosas que hace pi. Tras 2 meses de dolores intensos en mi hombro hoy sólo noto una molestia, y claro...

plot(rep(10,10),rep(10,10),ann=FALSE,type="n",
     ,xlim=c(-1,1),ylim=c(-1,1),axes=FALSE)
radio <- 1
theta <- seq(0, 2 * pi, length = 200)
lines(x = radio * cos(theta), y = radio * sin(theta))
radio <- 1.1 
theta <- seq(-0.75, -3*pi/4 , length = 100)
lines(x = radio * cos(theta) , y = radio * sin(theta) + 0.5 )
points(-0.5,0.5,pch=1,cex=3)
points(0.5,0.5,pch=1,cex=3)