Archivo de la categoría: Machine Learning

Obteniendo los parámetros de mi modelo GAM

Vimos como los modelos GAM iban más allá del GLM porque en el momento de obtener los parámetros asociados al modelo de un factor nos proponían, en vez de una función lineal una función de suavizado no paramétrica para aquellos factores susceptibles de transformar en variables numéricas ordinales con un sentido determinado. Se trabajó con un modelo de riesgo con una sola variable como era la edad y al sumarizar el modelo no era posible obtener los parámetros en la salida. En último término nuestra intención con este tipo de modelos es obtener esos parámetros para transformarlos en relatividades. Qué sentido tiene obtener un buen modelo para Negocio si su resultado no se puede expresar en términos de incrementos o descuentos, en términos de relatividades.

La entrada del blog que ahora os propongo nos permite extraer los parámetros de cualquier modelo GLM o GAM a partir de la función predict y una de las opciones más olvidadas por todos nosotros:

predict(modelo, newdata = datos,  type = "terms")

con type = “terms” lo que obtenemos en el momento de realizar la predicción son los parámetros del modelo que aplicamos, no es el resultado de la predicción.

Obteniendo las relatividades de nuestro modelo GAM

Partimos del ejemplo que estamos manejando en la serie de entradas:

library(dplyr)

varib <- c(edad = 2L, sexo = 1L, zona = 1L, clase_moto = 1L, antveh = 2L,
           bonus = 1L, exposicion = 8L, nsin = 4L, impsin = 8L)

varib.classes <- c("integer", rep("factor", 3), "integer",
                   "factor", "numeric", rep("integer", 2))

con <- url("https://staff.math.su.se/esbj/GLMbook/mccase.txt")
moto <- read.fwf(con, widths = varib, header = FALSE,
                 col.names = names(varib),
                 colClasses = varib.classes,
                 na.strings = NULL, comment.char = "")


library(mgcv)

moto$edad_numero <- as.numeric(moto$edad)

gam.1 <- gam(nsin ~ s(edad_numero,bs="cr",k=3) + zona, data=filter(moto,exposicion>0), 
             offset = log(exposicion), family = poisson(link='log'))
summary(gam.1)

Ejecutad este código y obtendréis un modelo GAM con la zona por la que circula el riesgo y una función de suavizado de la edad del asegurado. A la hora de sumarizar el modelo para la edad, la variable suavizada, no vemos parámetros solo una función, si queremos obtener parámetros solo aparece la zona, ¿cómo puedo obtener las relatividades que me arroja este modelo? Empleando predict como se indicó con anterioridad:

terminos <- data.frame(exp(predict(gam.1, newdata = moto, type = "terms")))
names(terminos) <- c("rela_zona","rela_edad") 
terminos <- cbind.data.frame(terminos,select(moto,zona,edad))

Se crea el data.frame terminos que tiene el exponencial del parámetro asociado a ese registro para los factores participantes en el modelo. Cabe señalar que predict no respeta el orden de las variables en el modelo, primero pone las variables que no están suavizadas y después las suavizadas. Después de obtener los parámetros registro a registro lo que hacemos es añadir al data frame los factores de los que deseamos obtener las relatividades y como os podéis imaginar la tabla de relatividades finalmente es el resultado de seleccionar los distintos elementos:

rela_zona <- distinct(select(terminos,zona,rela_zona))
rela_edad <- distinct(select(terminos,edad,rela_edad))

Ya sabéis, no subestiméis a predict...
 

Modelos GAM con R. Dejando satisfechos a los equipos de negocio

Los modelos GAM (Generalized Additive Model) son el conjuntos de modelos que tenemos los estadísticos, actuarios, data scientist o como nos denominen en el momento que leas esto para dejar a nuestros equipos de negocio contentos con los resultados de nuestro modelo GLM. No voy a entrar en los aspectos teóricos de este tipo de modelos, hay documentación como esta que os puede ayudar. Por qué se quedan contentos los equipos de negocio, porque nos ayudan a dar sentido a los modelos. Retomemos un ejemplo que vimos en otra entrada del blog: https://analisisydecision.es/los-parametros-del-modelo-glm-como-relatividades-como-recargos-o-descuentos/ en esta entrada presentamos como el resultado de un modelo GLM se transforma en una relatividad, en un mecanismo para ofrecer recargos y descuentos.

Si desarrollamos un modelo GLM en último término podríamos enseñar este gráfico al responsable comercial:

Parece evidente que a mayor edad mayor proporción de siniestros, además, a partir de los 40 – 45 puede considerarse que las relatividades no varían. Se aprecian tendencias, pero no tiene sentido de negocio aplicar directamente los resultados de las estimaciones, no podemos aplicar esas relatividades obtenidas, es necesario realizar un suavizado y seguramente nos veríamos tentados, una vez hecho el modelo, de aplicar unos suavizados posteriores a la obtención de los parámetros. Podríamos hacer:

#g2 es el gráfico anterior obtenido en https://analisisydecision.es/los-parametros-del-modelo-glm-como-relatividades-como-recargos-o-descuentos/

spline_edad_factor < - smooth.spline(relatividades$rela,w=relatividades$exp,spar=0.65)
g2 + geom_line(aes(y=spline_edad_factor$y *5000), group=1, color="green",size=1.5)

Con smoot.spline hacemos una función de suavizado para nuestras relatividades, el nivel del suavizado lo controlamos con el parámetro spar que va desde 0 (sin suavizado) a 1 (función lineal). El caso es que el resultado de ese suavizado ya podría tener un mayor sentido de negocio y tendríamos más contentos a nuestro equipo comercial, pero... lo estamos haciendo a posteriori, eso no es una estimación, es echar balones fuera. Bien, qué os parece si tenemos un mecanismo para hacer una función previa a la estimación, pues este mecanismo se denomina modelo GAM y la librería de R que vamos a emplear para aproximarnos a ellos es mgcv. Vamos a replicar el modelo más básico con la edad del conductor. Seguir leyendo Modelos GAM con R. Dejando satisfechos a los equipos de negocio

Inteligencia Arficial frente a un juego de niños. La partícula tonta de Nicolás

Pablo Picasso decía que en aprender a pintar como los pintores del renacimiento tardó unos años pero pintar como los niños le llevó toda la vida y en ocasiones creo que hacemos las cosas difíciles porque nos creemos que hacemos cosas difíciles y entonces llega un niño de nueve años y dice “Papá un punto que primero vaya a la izquierda y luego a la derecha no es tan difícil”.
Os pongo en antecedentes, el pasado 7 de mayo fui al AWS Summit de Madrid porque Sergio Caballero iba a contar uno de los casos de uso. Los de AWS no se deben ni imaginar de las maravillas que ha hecho Sergio en el Ayuntamiento de Alcobendas porque sólo dejaron que hablara 10 minutos, muy torpes ellos, su trabajo es mejor escaparate que el planteado por Mai-Lan Tomsen, un error en el planteamiento de la jornada. El caso es que había una “competición” de vehículos que circulaban por un circuito guiados por complicados algoritmos de inteligencia artificial. Vimos algún “bucanero serio” de alguno de los participantes, ya sabemos reinforcement learning, pero reinforcement reinforcement. Otros participantes más o menos honrosos, en fin, distraído. Viendo la competición me entraron ganas de participar y al llegar a casa me siento a preparar un algoritmo que recorriera el circuito del Jarama de Madrid, no un circuito cualquiera un circuito donde yo he visto ganar carreras a Jorge Martínez Aspar.

Portátil y R, empiezo mi trabajo con imager, busco en la Wikipedia el circuito, lo cargo, genero un data frame, selecciono puntos y comienzo a diseñar mi propia estrategia de reinforcement learning combinadas con técnicas de machine learning, algo como “SVM direccionables” se acerca por detrás mi hijo y me suelta “Papá un punto que primero vaya a la izquierda y luego a la derecha no es tan difícil”. Bueno, pues en 20 minutos sale esto:

De momento no funciona pero no me digáis que no es genial la idea, lo que hace con pocas líneas de código y una consulta en sql. En el repositorio de analisisydecision tenéis el código en R que realiza esta maravilla, he llamado al código partícula tonta y tiene aspectos interesantes en cuanto al uso de la librería imager de R para el tratamiento de imágenes y como transformo una imagen en un data frame de coordenadas y por supuesto la genial idea de Nicolás.

Por cierto, al ver el resultado Nicolás dijo que no sólo derecha e izquierda, también era necesario un arriba y abajo. Tengo abandonado el proyecto, como muchos, pero la anécdota me ayudó en mi trabajo.

Calendario de días laborales con Pandas

Es habitual escuchar que un científico de datos es un estadístico que trabaja con Python. En parte, tiene razón. Sin embargo, quien ha trabajado dentro del mundo académico sabe que para un estadístico las vacas son esféricas y los meses tienen 365,25/12 días. En cambio, en el mundo real, ni hay dos vacas iguales ni un mes igual a otro.
Sirva esta entrada para poner en valor todo aquel trabajo adicional y tiempo dedicado por aquellos que trabajan con datos y huyen de simplificaciones estadísticas, ya se denominen científicos de datos o cómo quieran llamarse.

Series temporales con Pandas

Pandas, como se ha visto aquí, es la librería por excelencia para el manejo de datos ya que permite trabajar fácilmente con tablas numéricas y series temporales.
Una utilidad disponible en Pandas en relación a las series temporales es crear directamente rangos de fechas con la función pd.date_range(), la cual utiliza los siguientes parámetros (no todos obligatorios):

  • start: Inicio del rango. Límite izquierdo para generar fechas.
  • end: Fin del rango. Límite derecho para generar fechas.
  • period: Número de periodos a generar
  • freq: Frecuencia de las proyecciones. Entre otros:
    • D: Diaria (por defecto)
    • Y: Anual
    • M: Mensual
  • closed: Si queremos excluir el inicio (closed=’right’) o el final (closed=’left’)
  • name: Nombre del DatetimeIndex resultante (por defecto ninguno)

Ejemplo básico de una serie temporal

import pandas as pd
s = pd.date_range(start='2019-01-01', periods=12, freq='M')
df = pd.DataFrame(s, columns=['Fecha'])
print(df)
        Fecha
0  2019-01-31
1  2019-02-28
2  2019-03-31
3  2019-04-30
4  2019-05-31
5  2019-06-30
6  2019-07-31
7  2019-08-31
8  2019-09-30
9  2019-10-31
10 2019-11-30
11 2019-12-31

Crear una serie temporal con los últimos días laborales de cada mes

En determinados ámbitos, principalmente financiero y actuarial, resulta especialmente útil manejar rangos de fechas en donde los días de la serie correspondan al primer o último día laboral del mes (por ejemplo, cuando proyectamos pagos de cupones o rentas).
Para ello, la función pd.date_range() dispone de diferentes valores para el parámetro frecuencia. En el siguiente ejemplo, ‘BM’ corresponde con BusinessMonthEnd (último día laboral del mes):

import pandas as pd
s = pd.date_range('2019-01-01', periods=12, freq='BM')
df = pd.DataFrame(s, columns=['Fecha'])
print(df)
        Fecha
0  2019-01-31
1  2019-02-28
2  2019-03-29
3  2019-04-30
4  2019-05-31
5  2019-06-28
6  2019-07-31
7  2019-08-30
8  2019-09-30
9  2019-10-31
10 2019-11-29
11 2019-12-31

Aunque si queremos mayor exactitud, debemos tener en cuenta los días festivos (por ejemplo, si calculamos costes que dependan de los días exactamente transcurridos entre cupón y cupón, un 1 día entre 20 representa un 5% de error). Conocer los días festivos dentro de un periodo de tiempo es especialmente útil cuando estimamos usos y comportamientos humanos (transporte público, asistencias médicas, cargas en servidores informáticos…). En el sector asegurador, dichos patrones pueden afectar directamente en las reservas contables, por ejemplo, a la hora de calcular los costes incurridos pero no declarados (IBNR). De hecho, en algunas compañías aseguradoras es habitual que se incrementen ligeramente los ratios de siniestralidad los años bisiestos simplemente por disponer de un día natural más que el resto.

En el siguiente ejemplo introducimos una lista con un par de días festivos simplemente para ver el funcionamiento: el 31 de mayo (Día de Castilla-La Mancha) y 28 de febrero (Día de Andalucía). Posteriormente calculamos los días transcurridos entre pagos si estos se produjeran el último día de mes:

import pandas as pd
fiestas = ['2019-02-28','2019-05-31']
es_holidays = pd.tseries.offsets.CustomBusinessMonthEnd(holidays=fiestas)
s = pd.date_range('2019-01-01', periods=12, freq=es_holidays)
df = pd.DataFrame(s, columns=['Fecha'])
df['n_dias'] = df['Fecha'].diff().dt.days.fillna(0)
print(df)
        Fecha  n_dias
0  2019-01-31     0.0
1  2019-02-27    27.0
2  2019-03-29    30.0
3  2019-04-30    32.0
4  2019-05-30    30.0
5  2019-06-28    29.0
6  2019-07-31    33.0
7  2019-08-30    30.0
8  2019-09-30    31.0
9  2019-10-31    31.0
10 2019-11-29    29.0
11 2019-12-31    32.0

(Como puede observarse, el 28-2 y 31-5 no aparecen en el calendario de pagos)

Reglas de cálculo para los días festivos

Por último, existe la opción de escribir reglas para calcular los días festivos (ya que normalmente estos son trasladados al siguiente día laboral). En ciertos países, como Estados Unidos, existen leyes al respecto (como la Uniform Monday Holiday Act of 1968), cuyas reglas están incluidas en Pandas y pueden consultarse haciendo un print(USFederalHolidayCalendar.rules).

Sin embargo, en muchos otros países no existen reglas para determinar los festivos del año (como ocurre en España), sino que cada año las fiestas laborales son fijadas por normativa. No obstante, vamos a aventurarnos a crear las reglas del calendario laboral español con la premisa de que los festivos que caigan en domingo se pasan al lunes siguiente (instrucción observance=sunday_to_monday). Posteriormente, mostramos los días laborales de diciembre para comprobar su funcionamiento.

from pandas.tseries.holiday import *
from pandas.tseries.offsets import CustomBusinessDay

class EsBusinessCalendar(AbstractHolidayCalendar):
   rules = [
     Holiday('Año Nuevo', month=1, day=1, observance=sunday_to_monday),
     Holiday('Epifanía del Señor', month=1, day=6, observance=sunday_to_monday),
     Holiday('Viernes Santo', month=1, day=1, offset=[Easter(), Day(-2)]),
     Holiday('Día del Trabajador', month=5, day=1, observance=sunday_to_monday),
     Holiday('Asunción de la Virgen', month=8, day=15, observance=sunday_to_monday),
     Holiday('Día de la Hispanidad', month=10, day=12, observance=sunday_to_monday),
     Holiday('Todos los Santos', month=11, day=1, observance=sunday_to_monday),
     Holiday('Día Constitución', month=12, day=6, observance=sunday_to_monday),
     Holiday('Inmaculada Concepción', month=12, day=8, observance=sunday_to_monday),	    
     Holiday('Navidad', month=12, day=25, observance=sunday_to_monday)
   ]

es_BD = CustomBusinessDay(calendar=EsBusinessCalendar())
s = pd.date_range('2019-12-01', end='2019-12-31', freq=es_BD)
df = pd.DataFrame(s, columns=['Fecha'])
print(df)
        Fecha
0  2019-12-02
1  2019-12-03
2  2019-12-04
3  2019-12-05
4  2019-12-10
5  2019-12-11
6  2019-12-12
7  2019-12-13
8  2019-12-16
9  2019-12-17
10 2019-12-18
11 2019-12-19
12 2019-12-20
13 2019-12-23
14 2019-12-24
15 2019-12-26
16 2019-12-27
17 2019-12-30
18 2019-12-31

(Se aprecia como el domingo 8 de diciembre es reemplazado por el lunes 9)

Así, una vez creado nuestro calendario de fiestas nacionales, podemos utilizarlo para conocer las fiestas de próximos años, por ejemplo para el año 2020:

calendar = EsBusinessCalendar()
print(calendar.holidays(start='2020-01-01', end='2020-12-31'))
DatetimeIndex(['2020-01-01', '2020-01-06', '2020-04-10', '2020-05-01',
               '2020-08-15', '2020-10-12', '2020-11-02', '2020-12-07',
               '2020-12-08', '2020-12-25'],
              dtype='datetime64[ns]', freq=None)

Las fiestas regionales o locales pueden ser incluidas de la misma manera, aunque hay que tener en cuenta que en ciertas comunidades es costumbre trasladar ciertas fiestas al 19 de marzo o el jueves del Corpus en vez de al siguiente lunes (en ese caso habría que crear una nueva función basada en la función de Pandas sunday_to_monday).

Nuestro calendario puede ser utilizado también en otras librerías como Prophet. Prophet es una librería avanzada de machine learning creada por Facebook, enfocada a modelos de regresión no lineales de datos a lo largo del tiempo, la cual requiere un listado de días festivos que debe ser proporcionado por el usuario.

¿Qué nos pasa con R? (de nuevo)

Hace años ya sorprendió R situándose muy arriba en la lista tiobe de lenguajes de programación subió en los años siguientes y ahora nos encontramos con una sorprendente bajada en el índice:

¿Volvemos a tener complejo por usar R? A veces tengo la sensación de que no eres un “pro” si no usas Python. Debe ser que determinados framework funcionan mejor en otros lenguajes, o no, pero nos da vergüenza usar R (de nuevo).

Crear una RESTful API con R con plumber

Podéis buscar info en la web acerca de lo que es una REST y una RESTful pero el objetivo de este trabajo es la creación de una API para “escorear” unos datos a partir de un modelo que hemos creado en R. Vamos a hacer lo más sencillo, un modelo de regresión lineal creado por R será guardado y una API con datos podrá llamar a este modelo mediante un cliente RESTful para obtener una predicción. Esta será la primera de una serie de entradas que le voy a dedicar a Carlos, un antiguo compañero mío y que me ha enseñado a desaprender y el primer guiño a Carlos será abandonar mi subversion local para conectar mi RStudio con GitHub, todo el trabajo que voy desarrollando lo tenéis en https://github.com/analisisydecision/Modelo1. Si echáis un vistazo al repositorio ya os podéis imaginar hacia donde irán encaminadas esta serie de entradas.

Bien, lo primero será crear y guardar el modelo con R:

#Programa de creación del modelo
Altura <-c(175,180,162,157,180,173,171,168,165,165)
Peso <-c(80,82,57,63,78,65,66,67,62,58)

modelo1 <- lm(Peso~Altura)
summary(modelo1)
save(modelo1, file = "modelo1/modelo1.rda")
#rm(modelo1)

Modelo de regresión lineal simple de alturas y pesos que guarda en la carpeta modelo1 el objeto con el modelo. Ahora quiero crear una API que, dada una altura, me estime el peso. Para ello creo un nuevo programa en R que debería llamarse despliegue pero que llamo depliegue_modelo1.R debido a que es bastante tarde. Este programa es una función para realizar una predicción que tiene el siguiente contenido:

library(jsonlite)

load("modelo1/modelo1.rda")

#* @post /prediccion
predict.peso <- function(Altura) {
data <- list(
Altura=Altura
)
prediccion <- predict.lm(modelo1, data )
return(prediccion)
}

Este código es el core de nuestra API a la que llamamos prediccion y que recibirá un json con ‘{“Altura”:XXX}’ y retornará la predicción del peso para esa altura. Y ahora viene plumber que es el “fontanero” que nos permite canalizar las llamadas a nuestra API prediccion. Esta llamada la hacemos con la función plumb:

library(plumber)
r <- plumb("depliegue_modelo1.R")
r$run(port=8000)

Ejecutado este código nuestra API esta funcionando en el puerto 8000 y sólo nos queda probarla y para ello yo recomiendo añadir una extensión de RESTClient a nuestro navegador habitual, en mi caso concreto es Chrome y he añadido una extensión Cliente de servicios Web RESTful y al ejecutarla tengo que modificar:

Como cuerpo de la solicitud pasamos un json con la altura y le damos a enviar, como respuesta debemos obtener [73.2291]. Lo que hemos hecho es una solicitud curl con la sintaxis:

curl -i -H Accept:application/json -X POST http://127.0.0.1:8000/prediccion -H Content-Type: application/json -d '{"Altura":175} '

Si ponéis esto en el terminal debe funcionar. ¿Qué os parece si empezamos a poner en producción modelos de R?

 

Truco Python. Seleccionar o eliminar variables de un data frame en base a un prefijo, sufijo o si contienen un caracter

A la hora de seleccionar las características de un data frame es posible que nos encontremos con la necesidad de seleccionar o eliminar características del data frame y que el nombre de esas características tenga un determinado patrón. Esta labor la podemos realizar mediante selección de elementos en listas, en esta entrada del blog vamos a tener 3 tipos de selecciones:

1. Seleccionar o eliminar aquellas variables que empiezan por un determinado prefijo
2. Seleccionar o eliminar aquellas variables que contienen una cadena de caracteres
3. Seleccionar o eliminar aquellas variables que finalizan con un sufijo

Para ilustrar este trabajo generamos un data frame con datos aleatorios y 10 columnas:

import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randint(0,100,size=(100, 10)),
columns=['A1','A2','A3','B1','B2','B3','C1','C2','C3','DA'])

El primero de los filtros a realizar es identificar que variables de nuestro data frame contienen el string ‘A’:

col = list(df.columns)
#Filtro 1: Columnas que tienen una A
filtro1 = [col for col in df if col.find('A')>=0]
#Eliminar
df1_drop = df.drop(columns=filtro1)
#Seleccionar
df1_keep = df[filtro1]

Siempre vamos a hacer el mismo proceso, las características de nuestro data frame irán en una lista, después recorremos la lista y seleccionamos aquellos donde el método .find(‘A’) sea mayor o igual a 0, con esto hemos creado una sublista con aquellas características que tienen el string ‘A’ mediante .drop(columns=) eliminamos del data frame los elementos contenidos en una lista Seguir leyendo Truco Python. Seleccionar o eliminar variables de un data frame en base a un prefijo, sufijo o si contienen un caracter

Notebook para empezar (y probar) en spark y scala

No debo enseñar Spark a nadie, no soy ni un usuario avanzado, ni le veo mucho recorrido. Sin embargo tengo que hacer diversos procesos con dataframes en spark y realizar modelos con MLlib y tengo que “perder tiempo” probando cosas, necesitaba un entorno sencillo en casa. En un primer momento exploré máquinas virtuales y alguna sandbox. Ninguna me convencía y le  pedí a un compañero mío, Juanvi, que sabe mucho que me montara un entorno con un notebook de spark para poder jugar con scala y MLlib de modo sencillo. En vez de montarme el entorno en 20 minutos me escribió un correo con 3 direcciones que me están siendo de mucha utilidad y quería compartirlas con vosotros.

La primera dirección es el repositorio donde está alojado este desarrollo del notebook de spark: https://github.com/spark-notebook/spark-notebook Lo primero que debemos estudiar es la documentación y por último generar o seleccionar el notebook que deseamos.  Aquí me gustaría hacer una anotación, no he sido capaz de hacer funcionar en Windows ninguna distribución que no sea de docker, sin ningún problema las dos distribuciones que he probado en Ubuntu y en el Apple sin problema con docker, al final, por temas profesionales, he optado por una versión con Hive-parquet y spark 2.0.1:

[code] docker pull andypetrella/spark-notebook:0.7.0-scala-2.10.6-spark-2.0.1-hadoop-2.7.2-with-hive
docker run -p 9001:9001 andypetrella/spark-notebook:0.7.0-scala-2.10.6-spark-2.0.1-hadoop-2.7.2-with-hive
[/code]

Instalado y arrancado el servicio nos conectamos a http://localhost:9001/ y ya tienes un entorno de pruebas más que digno que funciona mejor que las sandbox que he probado. Un tema, si alguien puede aportar más sobre la distribución del Notebook en Windows que comente la entrada. Espero que pueda ser de utilidad, saludos.

 

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 Seguir leyendo Machine learning. Elegir el mejor Gradient Boost de forma iterativa con GridSearchCV