scikit-learn

sklearn.model_selection.train_test_split

admin — Sun, 28 Apr 2019 09:10:21 +0000

sklearn.model_selection.train_test_split admin Dom, 28/04/2019 - 11:10

Nombre completo

sklearn.model_selection.train_test_split

Librería

scikit-learn

Sintaxis

sklearn.model_selection.train_test_split(*arrays, **options)

Descripción

La función sklearn.model_selection.train_test_split nos permite dividir un dataset en dos bloques, típicamente bloques destinados al entrenamiento y validación del modelo (llamemos a estos bloques "bloque de entrenamiento " y "bloque de pruebas" para mantener la coherencia con el nombre de la función).

Ejemplos

Para probarlo comencemos cargando un dataset:

titanic = sns.load_dataset("titanic")
titanic.head(1)

Veamos el tamaño de este dataset:

titanic.shape

(891, 15)

891 filas y 15 características (de las que una de ellas es la variable objetivo).

Si pasamos como argumento a train_test_split el dataset completo, nos devolverá dos subconjuntos del mismo, escogiendo un cierto número de filas para el subconjunto de entrenamiento y el resto para el subconjunto de pruebas:

from sklearn.model_selection import train_test_split

train, test = train_test_split(titanic, random_state = 0)

print(train.shape)
print(test.shape)

Salvo que se le indique otra cosa, la función train_test_split añade al bloque de entrenamiento el 75% de los registros, y al bloque de pruebas el 25% restante. Podemos controlar estas cifras con los parámetros train_size y test_size. Estos parámetros pueden ser números enteros, indicando exactamente el número de registros a incluir, o un número real, en cuyo caso indican el porcentaje del total de registros a incluir.

Una vez generados los bloques de entrenamiento y pruebas, podemos extraer la variable objetivo para crear, de esta forma, las estructuras que típicamente exigen los algoritmos para su entrenamiento.

El parámetro random_state simplemente fija una semilla para el generador de números aleatorios, lo que permite reproducir la función.

El parámetro shuffle (que toma el valor True por defecto) especifica si los registros deberán ser desordenados previamente o no.

Si pasamos a la función, no un dataset, sino dos estructuras de la misma longitud (típicamente el bloque de características y la variable objetivo), train_test_split va a generar bloques de entrenamiento y pruebas para ambas estructuras, haciendo innecesaria la división posterior entre bloque de características y variable objetivo:

y = titanic.pop("survived")
X = titanic

X_train, y_train, X_test, y_test = train_test_split(X, y)

X_train.shape

(668, 14)

X_train.head(2)

La función train_test_split divide el dataset de forma aleatoria, lo que puede provocar que la distribución de alguna característica no sea la esperada. Veamos un ejemplo con el mismo dataset:

titanic = sns.load_dataset("titanic")

train, test = train_test_split(titanic)

La característica "who" del dataset Titanic indica si el pasajero en cuestión era un hombre adulto, una mujer adulta o un niño. Comencemos viendo cuál es el porcentaje de estos valores en el dataset original:

titanic.groupby("who")["survived"].count()/len(titanic)

Y veamos ahora cuál es el porcentaje de estos registros en los bloques train y test generados:

train.groupby("who")["survived"].count()/len(train)

test.groupby("who")["survived"].count()/len(test)

Aun cuando esta característica está razonablemente bien distribuida, vemos que hay diferencias con respecto a la distribución original en el dataset de hasta un 3% (por ejemplo en el porcentaje de hombres adultos del bloque de pruebas).

Pues bien, el parámetro stratify nos permite generar los bloques de entrenamiento y pruebas preservando en ambos el porcentaje de las muestras del dataset original. Para ello hay que indicar en este parámetro cuál es el array de valores -que se asociarán a los datos- que determinan las etiquetas cuyas distribuciones se desea preservar. El ejemplo más sencillo es cuando pasamos a este parámetro una característica del dataset:

train, test = train_test_split(titanic, stratify = titanic["who"])

Si ahora volvemos a analizar el porcentaje de muestras con los valores que toma esta característica en los bloques de datos generados:

train.groupby("who")["survived"].count()/len(train)

test.groupby("who")["survived"].count()/len(test)

...comprobamos que son cifras muy próximas a las originales, tal y como queríamos.

Esta opción está especialmente indicada en datasets muy desequilibrados, en los que una división del mismo puede incluso dejar todos los registros con cierto valor en una característica en un único bloque.

SimpleImputer

admin — Sun, 28 Apr 2019 08:57:59 +0000

SimpleImputer admin Dom, 28/04/2019 - 10:57

Nombre completo

sklearn.impute.SimpleImputer

Librería

scikit-learn

Sintaxis

class sklearn.impute.SimpleImputer(missing_values=nan, strategy=’mean’, fill_value=None, verbose=0, copy=True)

Descripción

La función sklearn.impute.SimpleImputer permite sustituir valores nulos por otros valores según varias estrategias disponibles. La estrategia a ejecutar se indica mediante el parámetro strategy.

Una vez instanciado el imputador, puede entrenarse con el método fit (que genera un array conteniendo los valores por los que sustituir los valores nulos de cada característica) y puede ejecutarse la sustitución con el método transform. El atributo statistics_ nos da acceso al array de valores a imputar (uno por cada característica). Debe tenerse en cuenta que el resultado del imputador es un array NumPy, no un dataframe.

Parámetros

missing_values: Objeto que representa un valor nulo. Puede ser un número, una cadena de texto, np.ana (valor por defecto) o None.
strategy: Estrategia a ejecutar. Puede tomar los siguientes valores
- mean: (opción por defecto) reemplazando los valores nulos con la media de los valores de su misma columna
- median: reemplazando los valores nulos con la mediana de los valores de su misma columna
- most_frequent: reemplazando los valores nulos con el valor más frecuente de su misma columna
- constant: reemplazando los valores nulos con un valor constante, pudiendo ser tanto un número como una cadena de texto

En este último caso, el parámetro fill_value indica el valor en cuestión.

Ejemplos

Partimos del siguiente dataframe:

df = pd.DataFrame({
"x": [1, np.nan, 4, 2],
"y": [np.nan, 2, 5, 2],
"z": [0, 2, np.nan, 4]
})
df

Importamos e instanciamos ahora el imputador:

from sklearn.impute import SimpleImputer
si = SimpleImputer()

Lo entrenamos (ya hemos visto que, por defecto, la estrategia es el sustituir los valores nulos por el valor medio de las características):

si.fit(df)

Los valores a imputar ya han sido calculados:

si.statistics_

array([2.33333333, 3. , 2. ])

Por último, podríamos generar el array final usando el método transform:

si.transform(df)

También podríamos haber modificado los datos originales directamente usando el método fit_transform:

si.fit_transform(df)

Podríamos sustituir los valores nulos tan solo de una de las características aplicando el imputador solo a la columna correspondiente, considerando que los métodos de entrenamiento de esta función esperan un array de entrada de dos dimensiones:

df["x"] = si.fit_transform(df["x"].values.reshape(-1, 1))
df

(en un caso sencillo como éste también podríamos recurrir a la función fillna de pandas).

LabelEncoder

admin — Sun, 14 Apr 2019 12:34:45 +0000

LabelEncoder admin Dom, 14/04/2019 - 14:34

Nombre completo

sklearn.preprocessing.LabelEncoder

Librería

scikit-learn

Sintaxis

sklearn.preprocessing.LabelEncoder()

Descripción

La función sklearn.preprocessing.LabelEncoder codifica etiquetas de una característica categórica en valores numéricos entre 0 y el número de clases menos 1. Una vez instanciado, el método fit lo entrena (creando el mapeado entre las etiquetas y los números) y el método transform transforma las etiquetas que se incluyan como argumento en los números correspondientes. El método fit_transform realiza ambas acciones simultáneamente.

El único atributo de esta función, classes_, almacena el array que mapea etiquetas y números (que coinciden con el índice de cada etiqueta en el array).

Ejemplos

Apliquemos esta función al dataset Titanic:

titanic = sns.load_dataset("titanic")
titanic.head(1)

En este dataset se incluyen varias características categóricas: sex, embarked, class... Vamos a aplicar el codificador a la característica "embark_town", por ejemplo. Comencemos confirmando los valores diferentes en este campo:

titanic.embark_town.unique()

array(['Southampton', 'Cherbourg', 'Queenstown', nan], dtype=object)

Vemos que en el campo hay valores nulos que deberían ser tratados previamente. Como en este escenario el objetivo es probar el codificador LabelEncoder, vamos a optar por agrupar los valores nulos en una categoría independiente, dejando de lado opciones más sofisticadas como predicción vía Machine Learning:

titanic.embark_town.fillna("nan", inplace = True)

titanic.embark_town.unique()

array(['Southampton', 'Cherbourg', 'Queenstown', 'nan'], dtype=object)

Hemos convertido los valores nulos en etiquetas de texto con el valor "nan". Ahora ya podemos aplicar el codificador:

embark_town_codified = le.fit_transform(titanic.embark_town)

Veamos el mapa creado y comparemos los valores originales y las valores generados:

le.classes_

array(['Cherbourg', 'Queenstown', 'Southampton', 'nan'], dtype=object)

Este array nos indica que el valor "Cherbourg" va a ser mapeado al número 0, "Queenstown" al 1, etc.

pd.DataFrame({
"original": titanic.embark_town[:6],
"codificada": embark_town_codified[:6]
})

Ahora podríamos agregar los valores al dataframe o sustituir la columna original por el array que hemos creado. También podríamos hacerlo directamente:

titanic.embark_town = le.fit_transform(titanic.embark_town)

titanic.head()

Para terminar, el método inverse_transform permite transformar las etiquetas generadas en los valores originales.

MaxAbsScaler

admin — Mon, 08 Apr 2019 20:10:04 +0000

MaxAbsScaler admin Lun, 08/04/2019 - 22:10

Nombre completo

sklearn.preprocessing.MaxAbsScaler

Librería

scikit-learn

Sintaxis

sklearn.preprocessing.MaxAbsScaler(copy=True)

Descripción

La función sklearn.preprocessing.MaxAbsScaler escala y traslada cada característica del array de entrada de forma que el valor absoluto máximo de cada una sea 1.0 (es decir, todas las características pasan a tener valores en el rango [-1, 1]).

El array de entrada debe ser de números reales (enteros o de tipo float). No se aceptan números complejos.

Parámetros

copy: (True por defecto) booleano. Si toma el valor False y el array de entrada es un array NumPy, la transformación se realiza inplace.

Atributos:

scale_: (array) escalado relativo de cada característica
max_abs_: (array) máximo valor de cada característica
n_samples_seen_: (entero), número de muestras (filas) procesadas.

Resultado

El resultado de los métodos fit_transform y transform es siempre un array NumPy de tipo float.

Ejemplos

Comenzamos importando las librerías involucradas y creando el dataframe que queremos escalar:

import pandas as pd
import numpy as np
from sklearn.preprocessing import MaxAbsScaler

df = pd.DataFrame({
"w": [5, 2, -100],
"x": [2, 10, -2],
"y": [100, 0, -10],
"z": [0.5, 0.1, -0.1],
})
df

Instanciamos el escalador, lo entrenamos con el dataframe y lo transformamos:

scaler = MaxAbsScaler()
scaler.fit_transform(df)

Observamos que los valores máximos y mínimos en todas las características son 1 y -1. El procedimiento seguido por el escalador ha sido comprobar el valor máximo absoluto de cada característica y dividir todas los valores (de cada característica) por su máximo absoluto. Podemos comprobar los valores máximos encontrados visualizando el valor del atributo max_abs_:

scaler.max_abs_

array([100. , 10. , 100. , 0.5])

La escala aplicada (cifra por la que dividir los valores de cada característica) viene dada por el atributo scale_ (la escala debe coincidir con el valor máximo encontrado):

scaler.scale_

array([100. , 10. , 100. , 0.5])

Por último, el atributo n_samples_seen_ devuelve el número de muestras (filas de datos) procesadas:

scaler.n_samples_seen_

¿Y cómo se gestionan los valores nulos? Hagamos la prueba:

df = pd.DataFrame({
"w": [5, np.nan, -100],
"x": [2, 10, -2],
"y": [np.nan, 0, -10],
"z": [0.5, 0.1, -0.1],
})
df

scaler.fit_transform(df)

Veamos los valores máximos encontrados:

scaler.max_abs_

array([100. , 10. , 10. , 0.5])

Comprobamos que los valores nulos se ignoran durante el entrenamiento y se mantienen durante la transformación.

¿Y si todos los valores de una característica son nulos?

df = pd.DataFrame({
"w": [5, np.nan, -100],
"x": [2, 10, -2],
"y": [np.nan, np.nan, np.nan],
"z": [0.5, 0.1, -0.1],
})
df

scaler.fit_transform(df)

C:\Users\xxx\Anaconda3\lib\site-packages\sklearn\preprocessing\data.py:923: RuntimeWarning: All-NaN slice encountered max_abs = np.nanmax(np.abs(X), axis=0)

Vemos que, a pesar del error que devuelve, el resultado es correcto.

Visualización de un árbol de decisión

admin — Wed, 03 Apr 2019 13:53:04 +0000

Visualización de un árbol de decisión admin Mié, 03/04/2019 - 15:53

La librería sklearn incluye la función sklearn.tree.export_graphviz que permite la visualización de un árbol de decisión. Probémosla con el dataset de tips proveído por la librería seaborn:

import seaborn as sns

tips = sns.load_dataset("tips")
tips.sample(5)

Como la implementación del árbol de decisión para escenarios de regresión de sklearn no permite trabajar con características categóricas, comenzamos codificándolas:

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
tips.sex = le.fit_transform(tips.sex)
tips.smoker = le.fit_transform(tips.smoker)
tips.day = le.fit_transform(tips.day)
tips.time = le.fit_transform(tips.time)

Ahora podemos crear las estructuras X e y:

y = tips.pop("tip")
X = tips

...e importar el algoritmo, instanciarlo y entrenarlo (con los parámetros por defecto salvo la profundidad máxima, que fijamos en 3 para no crear un árbol demasiado grande):

from sklearn.tree import DecisionTreeRegressor
model = DecisionTreeRegressor(max_depth = 3)
model.fit(X, y)

Ahora importamos la función export_graphviz y un par de clases adicionales de sklearn, IPython y pydotplus:

from sklearn.externals.six import StringIO
from IPython.display import Image
from sklearn.tree import export_graphviz
import pydotplus

dot_data = StringIO()
export_graphviz(model, out_file = dot_data,
filled = True, rounded = True,
special_characters = True)
graph = pydotplus.graph_from_dot_data(dot_data.getvalue())
Image(graph.create_png())

Aunque entrar en el detalle de las funciones involucradas haría este escenario excesivamente complejo, aquí van algunos comentarios:

Los parámetros usados en export_graphviz son los siguientes:

El primer parámetro es el modelo entrenado, ya sea de regresión o de clasificación.
out_file indica el fichero o el manejador al que volcar el resultado, en este caso es un objeto de la clase StringIO.
El parámetro filled colorea los nodos generados para indicar en cuáles existe un valor más frecuente que otros (en clasificación) o en cuáles hay valores extremos (en regresión).
rounded muestra los rectángulos representando los nodos con las esquinas redondeadas
special_characters, por último, incluye en el gráfico generado caracteres especiales (el ignorarlos tendría sentido solo para asegurar la compatibilidad con el formato PostScript)

La función pydotplus.graph_from_dot_data carga un gráfico en formato DOT y, por último, la función Image(graph.create_png()) crea y muestra la imagen generada en formato png.

Categoría

scikit-learn

Codificación One Hot Encoding de un conjunto de características categóricas con sklearn

admin — Mon, 03 Dec 2018 19:28:59 +0000

Codificación One Hot Encoding de un conjunto de características categóricas con sklearn admin Lun, 03/12/2018 - 20:28

El método para aplicar una codificación de tipo One-Hot-Encoding a un conjunto de características categóricas pasa por:

Codificación de las características con valores entre 0 y el número de clases -1, por ejemplo mediante la función LabelEncoder de sklearn.
Aplicación de la codificación One-Hot-Encoding, por ejemplo mediante la función OneHotEncoder de sklearn.

Para aplicar ambas codificaciones, además de importar las funciones correspondientes, solo hay que considerar que la función OneHotEncoder necesita como entrada una estructura de tipo array, por lo que habrá que redimensionar la salida de LabelEncoder. Así, si tenemos la siguiente lista de valores (también podría ser una serie Pandas):

y = ["a", "b", "a", "c"]

Podemos realizar la conversión con el siguiente código:

from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder

ohe = OneHotEncoder(sparse = False)
le = LabelEncoder()
ohe.fit_transform(le.fit_transform(y).reshape(-1, 1))

Si deseásemos que el resultado fuese una matriz dispersa, bastaría con crear la instancia de la clase OneHotEncoder sin el argumento sparse (o dándole el valor True)

Otra alternativa consiste en la creación de una clase, CatOneHotEncoder que aplique ambas condificaciones:

from sklearn.preprocessing import OneHotEncoder
from sklearn.preprocessing import LabelEncoder

class CatOneHotEncoder():

    def __init__(self):
        self.ohe = OneHotEncoder()
        self.le = LabelEncoder()

def fit_transform(self, x):
return self.ohe.fit_transform(self.le.fit_transform(x).reshape(-1, 1))

def transform(self, x):
return self.ohe.transform(self.la.transform( x.reshape(-1, 1)))

Opción que nos permite añadir métodos adicionales, como transform que nos permitirá transformar un segundo listado de características tras haber entrenado la clase.

Categoría

scikit-learn

KFold

admin — Mon, 03 Dec 2018 19:27:10 +0000

KFold admin Lun, 03/12/2018 - 20:27

Nombre completo

sklearn.model_selection.KFold

Librería

scikit-learn

Sintaxis

class sklearn.model_selection.KFold(n_splits=’warn’, shuffle=False, random_state=None)

Descripción

La función sklearn.model_selection.KFold divide un conjunto de datos en k bloques. A continuación, considera uno de ellos como conjunto de validación y el resto como conjunto de entrenamiento, devolviendo las k combinaciones posibles (la primera combinación es la que considera el primer bloque como conjunto de validación y el resto como conjunto de entrenamiento, la segunda es la que considera el segundo bloque como conjunto de validación y el resto como conjunto de entrenamiento, etc.).

Parámetros

n_splits: entero, valor por defecto = 3. Número de bloques en el que dividir el conjunto de datos.
shuffle: boolean, opcional. Si toma el valor True, los datos se van a mezclar antes de generar los k bloques.
random_state: entero o None, opcional, valor por defecto = None. Semilla a utilizar en el generador de números aleatorios cuando shuffle toma el valor True para la mezcla de los datos.

Ejemplos

Supongamos que deseamos dividir un conjunto de 12 números (del 0 al 11, generados mediante la función range) en tres bloques, considerando uno de ellos como conjunto de validación y los otros dos como conjunto de entrenamiento, y generar los índices correspondientes para cada una de las combinaciones posibles:

from sklearn.model_selection import KFold
cv = KFold(n_splits = 3)
for train_indices, test_indices in cv.split(range(12)):
print(train_indices, test_indices)

El resultado devuelto es:

Si hacemos uso del argumento shuffle fijándolo al valor True:

from sklearn.model_selection import KFold
cv = KFold(n_splits = 3, shuffle = True)
for train_indices, test_indices in cv.split(range(12)):
print(train_indices, test_indices)

el resultado es:

Si tenemos el siguiente dataframe:

df = pd.DataFrame({
"a": [1, 2, 1, 3, 2, 1],
"b": [2, 4, 3, 6, 7, 1]
})

..y queremos dividirlo en conjuntos de entrenamiento y validación a partir de 3 bloques de registros, el código a utilizar sería el siguiente:

from sklearn.model_selection import KFold
cv = KFold(n_splits = 3)
for train_indices, test_indices in cv.split(df):
print(train_indices, test_indices)