Forem: Leandro Ruiz

ChatGPT en python

Leandro Ruiz — Tue, 31 Jan 2023 23:15:47 +0000

Está todo el mundo pidiéndole chistes o haciéndole confundir con acertijos. Pero en esta ocasión vamos a estar embebiendo la IA de moda a un script de python para poder hacer (finalmente) algo útil con ella y sumarla a nuestros proyectos. Pero primero...

¿Qué es ChatGPT?

Quién mejor que el propio bot para responder esta pregunta:

ChatGPT responde qué es ChatGPT

¿Cómo lo agregamos a nuestro código?

Para este artículo vamos a estar utilizando la librería pyChatGPT que es muy sencilla de implementar y usar.

Como siempre, lo primero que se hace es instalar la nueva librería e importarla:

!pip install pyChatGPT
import pyChatGPT

Iniciar sesión con token

Para poder acceder a las características de ChatGPT es necesario iniciar sesión. Hay dos formas de hacerlo, a través de las credenciales de un mail o a través de un token de sesión (que es que vamos a estar usando porque no logré hacer funcionar mi mail 😐)

Para obtener un token de sesión hay que entrar en chat.openai.com, iniciar una conversación e inspeccionar la página. Luego tomamos el código que se indica en la captura.

El token de sesión es el texto que está seleccionado

Y lo pegamos en el código. Que quedaría de la siguiente manera:

session_token = "pegar token"

session_api = pyChatGPT.ChatGPT(session_token=session_token)

Chateando con ChatGPT

Para finalmente poder interactuar con ChatGPT, solo necesitamos dos métodos: .send_message() y .get().

pregunta = session_api.send_message(input())

respuesta = "".join(pregunta.get("message"))

Y listo.

Pero para hacer la experiencia de usuario más amigable vamos a hacer que el script le de un poco de conversación al usuario.

También vamos a implementar la posibilidad de guardar la pregunta que hicimos junto con la respuesta que recibimos.

¿Cómo guardamos nuestras interacciones en un archivo local?

Almacenando las preguntas y respuestas

Cuando pensaba en lo que quería hacer con ChatGPT lo primero que pensé es en que quería guardar cada una de las preguntas y las respuestas. Además de eso, quería tener la fecha y hora en que fue realizada la consulta y la posibilidad de agregar etiquetas para poder catalogar las respuestas más en detalle.

Por lo que en principio tendríamos cuatro columnas: "Pregunta", "Respuesta", "Fecha y hora" y "Etiquetas".

Crear listas vacías

El primer paso es tan simple como crear una lista por cada columna:

_preguntas = []
_respuestas = []
_fechaHora = []
_etiqueta = []

Donde vamos a almacenar cada uno de los datos cada vez que el chat nos responda.

Link a GitHub

Armar una iteración por cada consulta

Vamos a crear un loop donde cada vez que obtenemos una respuesta, el script nos pregunta si queremos realizar una nueva pregunta.
Esto quedaría más o menos así:

run = True
while run:
    # ingresar mensaje
    pregunta = input()

    # haciendo request
    respuesta = session_api.send_message(pregunta)

    # obtener respuesta
    respuesta = "".join(respuesta.get("message"))
    # imprimir respuesta
    print(respuesta)

    # preguntar si el usuario continua
    run = bool(input("¿Desea continuar? "))
    print()
# despedida
print("¡Hasta luego!")

El siguiente paso es que en cada iteración guarde la fecha y hora (para esto se necesita importar el módulo time) de la consulta y que el script pregunte si se desea añadir etiquetas a la respuesta obtenida y guardar todos estos datos en la listas que se crearon anteriormente:

import time

run = True
while run:
    # ingresar mensaje
    pregunta = input()

    # haciendo request
    respuesta = session_api.send_message(pregunta)

    # obtener respuesta
    respuesta = "".join(respuesta.get("message"))

    # imprimir respuesta
    print()
    print(respuesta)
    # obtener fecha y hora
    ahora = time.strftime("%d/%m/%y") + " " + time.strftime("%H:%M:%S")

    # preguntar si el usuario quiere guardar la pregunta y respuesta
    guardarPregunta = input("¿Desea guardar esta respuesta?: ")
    if guardarPregunta.lower() == "si":
        # guardar pregunta y respuesta
        _preguntas += [pregunta]
        _respuestas += [respuesta]
        # guardar hora de ejecucion
        _fechaHora += [ahora]

        # agregar etiquetas
        agregarEtiqueta = input("¿Desea agregar alguna etiqueta? ")
        if agregarEtiqueta.lower() == "si":
            nuevaEtiqueta = input("Escriba el nombre de la etiqueta (puede agregar varias separandolas con una coma): ")
            _etiqueta += [nuevaEtiqueta]
        else:
            _etiqueta += [""]
    # para crear un pandas dataframe se necesita que cada lista tenga la misma longitud
    # por eso se crea una etiqueta vacía en caso de que no se requiera

    # preguntar si el usuario continua
    run = bool(input("¿Desea continuar? "))
    print()

print("¡Hasta luego!")

Guardar las interacciones en una tabla

Una vez que se chateó con la IA es hora de exportar los datos que se decidieron guardar hacia un pandas dataframe.
Se guardan las listas dentro de un diccionario y lo convertimos a un dataframe:

import pandas as pd

historial = {"Pregunta": _preguntas, 
             "Respuesta": _respuestas,
             "Fecha y hora": _fechaHora,
             "Etiquetas": _etiqueta}

# crear pandas dataframe con las listas
df_historial = pd.DataFrame(historial)

df_historial

Exportar la tabla a un archivo local

Para exportar un archivo lo primero que necesitamos es la dirección en la que se va a encontrar el archivo. En mi caso lo voy a guardar en la misma carpeta que el proyecto por lo que no tengo que escribir la dirección completa:

import os
from pathlib import Path

# el nombre que tiene el archivo final
nombre_archivo = "Historial chatGPT.xlsx"

# obtener carpeta donde se encuentra el proyecto
project_root = os.path.dirname(os.path.dirname(__file__))
carpeta_proyecto = os.path.join(project_root, 'Proyecto ChatGPT')

direccion_archivo = Path(os.path.join(carpeta_proyecto), nombre_archivo)

Y en este momento se abren dos posibilidades: el archivo existe o no. Para la primera opción lo que buscamos es que actualice el archivo anexando las nuevas interacciones. Y para la segunda necesitaríamos que cree el archivo y que guarde las interacciones que obtuvimos.

Probando ChatGPT para desarrollar en python

Mientras armaba este script y llegué a esta parte comencé a googlear como verificar que un archivo existía en determinada ubicación y si la respuesta era negativa que lo creara.
Estuve más de media hora probando varias maneras que encontré hasta que recordé que ¡podía preguntarle a ChatGPT!
Por lo que le pregunté y el código que me proporcionó funcionó perfectamente y es el que vas a ver a continuación.

# a partir de acá el código fue generado por chatgpt (solo traduje lo que podía al español)

try:
    # verifica si existe "HistorialChatGPT.xlsx" en la carpeta del proyecto
    if os.path.exists(direccion_archivo):
        # lee el archivo existe
        archivo_existente = pd.read_excel(direccion_archivo)
        # anexa la nueva info en el excel
        actualizar_archivo = pd.concat([archivo_existente, df_historial], ignore_index=True)
        # sobreescribe el archivo con la nueva info
        actualizar_archivo.to_excel(direccion_archivo, index=False)
        print("Se actualizó el archivo correctamente.")
    # si no existe lo crea con los datos que guardó
    else:
        df_historial.to_excel(direccion_archivo, index=False)
        print("Se creó el archivo exitosamente.")
# excepción por si el archivo existe y está abierto
except PermissionError:
    print("Por favor cierre el archivo antes de efectuar los cambios.")

Conclusión

¿Se puede hacer mejor? ¡Claro que sí! Pero lo hice en tres días y hace más de un año que no programaba en python. 😅
Te invito a dejar en los comentarios si se te ocurre alguna forma de mejorar este mini proyecto.
¡Muchas gracias por llegar hasta acá!

Conexión a SQL Server con Python

Leandro Ruiz — Mon, 22 Feb 2021 18:03:49 +0000

En esta ocasión quiero hablar sobre como accedes a un SQL Server usando Python. Estuve investigando un poco y la solución que encontré mas practica es _mssql.

_mssql es una librería de código abierto que de una forma simple y eficiente nos permite ingresar y modificar a bases de datos SQL utilizando Python.

Conectarse a una base de datos SQL

El primer paso es muy sencillo, para crear la conexión primero importamos la librería _mssql y llamamos al método .connect():

import _mssql

server = 'SERVER_NAME'
user = 'USER_NAME'
password = '<PASSWORD>'
database = 'MY_DATABASE'
conn = _mssql.connect(server, user, password, database)

# aqui creamos una tabla de ejemplo

conn.execute_non_query('CREATE TABLE pets(id INT, name VARCHAR(100))')
conn.execute_non_query("INSERT INTO pets VALUES(1, 'Firulais')")
conn.execute_non_query("INSERT INTO pets VALUES(2, 'Pelusa')")

De esta forma ya deberíamos estar conectados a la base de datos SQL, pero ahora viene lo importante: poder utilizar estos datos a través de queries.

Realizar Queries

Y para poder realizar queries y manipular la base de datos, debemos llamar al método .execute_query(). Aquí dejo un ejemplo:

conn.execute_query('SELECT * FROM pets WHERE name=%s', 'Firulais')

# como extraer filas de una tabla
for row in conn:
    print "ID=%d, Name=%s" % (row['id'], row['name'])

Dejo el link a la documentación de esta librería.

Van un par de ejemplos más de como realizar queries:

# contar filas de una tabla
num_pets = conn.execute_scalar("SELECT COUNT(*) FROM pets")

# seleccionar segunda fila de determinada tabla
pet_2 = conn.execute_row("SELECT * FROM pets WHERE id=%d", 2)

Cierre de la conexión

Una vez terminadas todas las tareas que se debían realizar con la base de datos, procedemos a cerrar la conexión con el SQL Server:

conn.close()

Este paso es importante para no desperdiciar recursos en tareas que ya han sido finalizadas o que ya no son necesarias 👍

Conclusión

_mssql es una buena alternativa a pyodbc y mymssql ya que su sintaxis es mas simple para establecer la conexión con la base de datos y también al momento de realizar queries.

Espero que mi aporte te haya sido de utilidad, y ¡hasta la próxima!

Conéctate a una base de datos de Oracle con Python

Leandro Ruiz — Mon, 08 Feb 2021 23:12:02 +0000

Este es un tutorial muy sencillo con los primeros pasos para lograr una conexión a una base de datos de Oracle con unos pocos scripts en Python.

Comencemos.

Crea una conexión con Python

Te puedes conectar a una base de datos de Oracle usando cx_Oracle de dos diferentes maneras: de manera autónoma (dudosa traducción de standalone) o con una conexión agrupada (pooled connection en ingles).

Las conexiones autónomas son útiles cuando la aplicación necesita que un solo usuario inicie sesión en la base de datos mientras que la conexión agrupada es critica para el desempeño cuando la aplicación se conecta y desconecta de la base de datos con frecuencia.

El primer paso para conectarse es crear un modulo config.py para guardar la configuración de nuestra base de datos:

username = 'user'
password = '<password>'
dsn = 'localhost/pdborcl'
port = 1512
encoding = 'UTF-8'

En este modulo, dsn tiene dos partes: el servidor(localhost) y la base de datos conectable (pdborcl).

Si la base de datos Oracle está en example.com, tienes que usar el siguiente dsn:

dsn = 'example.com/pdborcl'

Crea conexiones autónomas

Para crear una conexion autonoma, usamos el metodo cx_Oracle.connect() o cx_Oracle.Connection().

El siguiente script connect.py muestra como crear una conexion a una base de datos Oracle:

import cx_Oracle
import config

connection = None
try:
    connection = cx_Oracle.connect(
        config.username,
        config.password,
        config.dsn,
        encoding=config.encoding)

    # imprime la version de la base de datos
    print(connection.version)

except cx_Oracle.Error as error:
    print(error)

finally:
    # release the connection
    if connection:
    connection.close()

Crea conexiones agrupadas

La conexión agrupada de cx_Oracle le permite a las aplicaciones crear y mantener un grupo de conexiones a la base de datos.

Internamente, cx_Oracle implementa una conexión en grupo usando la tecnología de sesiones en grupo de Oracle. En general, cada conexión en un grupo de cx_Oracle corresponde a una sesión en la base de datos.

Para crear una conexión agrupada, se usa el método cx_Oracle.SessionPool(). El siguiente script connect_pool.py ilustra como crear este tipo de conexión:

import cx_Oracle
import config

# crea la sesion en grupo
pool = cx_Oracle.SessionPool(
    config.username,
    config.password,
    config.database,
    min=100,
    max=100,
    increment=0,
    encoding=config.encoding)

# consigue una conexion del grupo
connection = pool.acquire()

# usa la conexion
print('Using the connection')

# libera la conexion del grupo
pool.release(connection)

# cierra el grupo
pool.close()

En caso de que se supere el número máximo de sesiones en el grupo, cuando se llame al método acquire() este producirá un error "ORA-24459: OCISessionGet() timed out waiting for pool to create new connections".

Una solución podría ser llamar al siguiente argumento:

getmode = cx_Oracle.SPOOL_ATTRVAL_WAIT to the cx_Oracle.SessionPool()

Que logrará prevenir la excepción, pero causará que la sesión espere a que haya una conexión disponible.

Por esta razón es una practica recomendada crear un grupo con un número fijo de conexiones (es decir, que min y max tengan el mismo valor y que increment sea igual a cero).

Conclusión

Quizás en otra ocasión repasemos como realizar queries en una base de datos Oracle, pero por el momento creo que este artículo es un buen comienzo.

Espero que mi aporte te haya sido de utilidad, y ¡hasta la proxima!

Guia rápida sobre Ensemble Learning

Leandro Ruiz — Thu, 03 Dec 2020 16:49:03 +0000

En muchas ocasiones, los cientificos de datos nos enfrentamos a la decisión sobre qué modelo usar para una determinada tarea de regresión o clasificación. Pero ante este dilema hay una respuesta sencilla que puede encajar muy bien en la mayoría de los proyectos.

Esta respuesta es nada mas ni nada menos que el Ensemble Learning (o aprendizaje en conjunto en su traducción al español).

Introducción a Ensemble Learning

En el campo del aprendizaje automático, si agrupamos las predicciones de un conjunto de algoritmos (tanto para clasificación como para regresión) vamos a obtener mejores resultados que con el mejor predictor individual.

Por ejemplo:

Entrenamos un grupo de Decision Trees, cada uno con un sub-grupo diferente de datos de entrenamiento. Luego, para realizar predicciones lo que hacemos es obtener los resultados de cada arbol y predecir la clase que obtiene mas votos (en caso de regresión, es el promedio de todas las predicciones).

Veamos un ejemplo rapido para ver como funciona este metodo usando Scikit-Learn:

from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.ensemble import VotingClassifier
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split

log_clf = LogisticRegression()
rnd_clf = RandomForestClassifier()
svm_clf = SVC()

voting_clf = VotingClassifier(
    estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],
    voting='hard')

X, y = make_moons(n_samples=1000, noise=0.3, random_state=42)

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.35, random_state=42)

from sklearn.metrics import accuracy_score

for clf in (log_clf, rnd_clf, svm_clf, voting_clf):
  clf.fit(X_train, y_train)
  y_pred = clf.predict(X_test)
  print(clf.__class__.__name__, accuracy_score(y_test, y_pred))

LogisticRegression 0.8514285714285714
RandomForestClassifier 0.9142857142857143
SVC 0.9028571428571428
VotingClassifier 0.9057142857142857

Lo primero que hacemos es definir los modelos que vamos a agrupar para crear nuestro algoritmo. En este caso, vamos a usar RandomForestClassifier, LogisticRegression y SVC (Support Vector Classifier). Luego, agrupamos los tres modelos usando el metodo VotingClassifier y lo entrenamos.

El Ensemble Learning funciona mejor si los algoritmos a agrupar son los mas independientes posibles unos de otros. De esta manera, van a realizar distintos tipos de errores, mejorando la precisión del conjunto.

Diferencias entre `hard` y `soft` voting.

Si todos los clasificadores son capaces de estimar las probabilidades de cada clase (es decir, tienen disponible el metodo predict_proba()), entonces podemos configurar nuestro algoritmo grupal para que prediga la clase con la mayor probabilidad por clase, promediando los resultados dados por cada algoritmo. Esta tecnica es conocida como soft voting. En algunas ocasiones es capaz de obtener mejores resultados que el hard voting porque le da mayor peso a los votos mas probables de ser correctos. Lo unico que hay que hacer es reemplazar voting="hard" por voting="soft" y asegurarnos que todos los clasificadores estiman las probabilidades por clase. De manera predeterminada SVC no tiene esta opcion activada, por lo que debes configurar el hiper-parámetro probability como True (lo que hará que SVC use cross-validation para estimar las probabilidades de cada clase, volviendo mas lento el entrenamiento, y añadiendo el metodo predict_proba()).

Veamos como queda nuestro modelo en conjunto luego de estas modificaciones:

log_clf = LogisticRegression()
rnd_clf = RandomForestClassifier()
svm_clf = SVC(probability=True)

voting_clf = VotingClassifier(
    estimators=[('lr', log_clf), ('rf', rnd_clf), ('svc', svm_clf)],
    voting='soft')

for clf in (log_clf, rnd_clf, svm_clf, voting_clf):
  clf.fit(X_train, y_train)
  y_pred = clf.predict(X_test)
  print(clf.__class__.__name__, accuracy_score(y_test, y_pred))

LogisticRegression 0.8514285714285714
RandomForestClassifier 0.92
SVC 0.9028571428571428
VotingClassifier 0.9142857142857143

Como podemos ver, nuestro modelo obtuvo unos resultados ligeramente mejores con soft voting.

Bagging y Pasting

Como ya vimos, una manera de tener un diverso grupo de clasificadores es usar diferentes algoritmos en la etapa de entrenamiento. Pero otra forma de obtener esto es usando un solo algoritmo durante todo el proceso pero entrenarlos con distintas porciones del set de datos de entrenamiento. Cuando el muestreo de datos se realiza con reemplazamientos, este metodo se llama bagging (abreviatura de bootstrap aggregating). Y cuando el muestreo es sin reemplazamiento, es llamado pasting.

En otras palabras, tanto el bagging como el pasting permiten muestrear instancias de entrenamiento varias veces en varios predictores, pero solo el bagging permite muestrear instancias de entrenamiento varias veces para el mismo predictor.

Link a GitHub

Una vez que todos los predictores son entrenados, el conjunto puede realizar una predicción para una nueva instancia agregando las predicciones de todos los predictores. La función de agregación es normalmente el modo estadístico (es decir, la predicción más frecuente, como un clasificador hard voting) para clasificación, o el promedio para regresión. Cada predictor individual tiene un sesgo mayor que si hubiera sido entrenado con el set de datos original, pero la agregación reduce el sesgo y la varianza. Generalmente, el resultado final es que el conjunto tiene un sesgo similar pero una varianza menor que un solo predictor entrenado con el set original.

Bagging y Pasting en Scikit-Learn

Se puede usar BaggingClassifier para tareas de clasificación, y BaggingRegressor para regresión.

Algunos parámetros para bagging son:

n_estimators: número de predictores en el conjunto.
max_samples: número de muestras del set de entrenamiento para entrenar cada predictor.
bootstrap: True para usar bagging, False para usar pasting.
n_jobs: número de núcleos del CPU para usar en el entrenamiento (-1 usa todos los núcleos disponibles).

Acá tenemos un ejemplo de bagging:

from sklearn.ensemble import BaggingClassifier
from sklearn.tree import DecisionTreeClassifier

bag_clf = BaggingClassifier(
    DecisionTreeClassifier(), n_estimators=1000,
    max_samples=200, bootstrap=True, n_jobs=-1, random_state=0)
bag_clf.fit(X_train, y_train)
y_pred = bag_clf.predict(X_test)

print(accuracy_score(y_test, y_pred))

0.9057142857142857

Y por acá un ejemplo de pasting:

pas_clf = BaggingClassifier(
    DecisionTreeClassifier(), n_estimators=1000,
    max_samples=200, bootstrap=False, n_jobs=-1, random_state=0)
pas_clf.fit(X_train, y_train)
y_pred = pas_clf.predict(X_test)

print(accuracy_score(y_test, y_pred))

0.9085714285714286

Y por el simple hecho de comparar, veamos como resulta un solo Decision Tree haciendo todo el trabajo:

tree = DecisionTreeClassifier()
tree.fit(X_train, y_train)
y_pred = tree.predict(X_test)
print(accuracy_score(y_test, y_pred))

0.8714285714285714

Tal como se esperaba, tenemos mejores resultados usando 1000 arboles en lugar de 1.

Conclusión

Espero que este articulo les haya ayudado tanto como me ayudó a mi mientras lo confeccionaba. Muchas gracias por llegar hasta aquí y ¡hasta la proxima!

Fin

¡Sorpresa para quienes llegaron al final!

Evaluación Out-of-Bag

Cuando usamos bagging, algunas instancias pueden ser seleccionadas varias veces para cualquier predictor, mientras que otros pueden no ser seleccionados en absoluto. Predeterminadamente, BaggingClassifier selecciona m instancias de entrenamiento con reemplazamiento (bootstrap=True), donde m es el tamaño del set de entrenamiento. Esto significa que en promedio solo el 63 % de las instancias de entrenamiento son seleccionadas para cada predictor. El 37 % restante (que no son las mismas para todos los predictores) de las instancias que no son muestreadas son llamadas instancias out-of-bag (oob).

Ya que un predictor nunca ve las instancias oob durante el entrenamiento, pueden ser utilizadas para evaluar sin la necesidad de un set de validación. Puedes evaluar al conjunto en si al promediar las evaluaciones oob para cada predictor.

En Scikit-Learn, puedes configurar oob_score=True cuando estas creando un BaggingClassifier para pedir una evaluación oob luego del entrenamiento. El resultado de la evaluación esta disponible a través de la variable oob_score:

bag_clf = BaggingClassifier(
    DecisionTreeClassifier(), n_estimators=500,
    bootstrap=True, n_jobs=-1, oob_score=True)

bag_clf.fit(X_train, y_train)
bag_clf.oob_score_

0.9061538461538462

De acuerdo a esta evaluación oob, este BaggingClassifier es capaz de alcanzar un 90.6 % de precisión en el test set. Vamos a verificarlo:

y_pred = bag_clf.predict(X_test)
accuracy_score(y_test, y_pred)

0.9142857142857143

¡Obtuvimos un 91.4 % de precision en el set de prueba! Bastante acertado.

Incluso tambien tenemos disponible la función de decisión oob:

bag_clf.oob_decision_function_

array([[0.        , 1.        ],
       [0.97206704, 0.02793296],
       [1.        , 0.        ],
       ...,
       [0.99408284, 0.00591716],
       [0.88333333, 0.11666667],
       [0.        , 1.        ]])

Ahora sí es el final, muchas gracias por leerme. ¡Hasta luego!

Matemáticas para Machine Learning

Leandro Ruiz — Thu, 15 Oct 2020 21:16:24 +0000

Tabla de Contenidos

Álgebra Lineal
1. Escalares
2. Vectores
3. Matrices
4. Tensores
5. Hiperplanos
6. Operaciones Matemáticas Relevantes
  1. Producto de punto (dot product)
  2. Producto Hadamard (element-wise product)
  3. Producto Tensor (outer product)
Estadística
1. Probabilidad
  1. Probabilidad vs. Posibilidad
  2. Bayesianos vs. Frequentistas
  3. Probabilidad Condicional
  4. Teorema de Bayes
  5. Probabilidad Posterior
2. Distribuciones
  1. Teorema del Limite Central
  2. Muestras vs. Población
  3. Métodos de re-muestreo
  4. Sesgo de Selección
  5. Posibilidad

Álgebra Lineal

Escalares

En matemáticas, cuando el termino escalar es mencionado, estamos hablando de elementos en un vector. Un escalar es un número real y un elemento en un campo usado para definir el espacio vectorial.

En computación, el termino escalar es sinónimo con el termino variable y su locación de almacenamiento emparejado con un nombre simbólico. Esta locación de almacenamiento mantiene una cantidad desconocida de información llamada valor.

Vectores

Para nuestro uso, definimos un vector como lo siguiente:

Para un integral positivo n, un vector es un n-taple, un (multi)set o array de n números, llamados elementos o escalares.

Lo que estamos diciendo es que queremos crear una estructura de datos llamada vector a través de un proceso llamado vectorización. El número de elementos en el vector es llamado "orden" (o "longitud") del vector. Los vectores también pueden representar puntos en un espacion de n-dimensiones. En el sentido espacial, la distancia Euclideana desde el origen al punto representado por el vector nos da la "longitud" del vector.

En texto matemático, vemos a los vectores escritos asi:

Hay muchas maneras diferentes de manejar la vectorización, y se pueden aplicar muchos pasos de preprocesamiento, dando diferentes grados de efectividad en los resultados del modelo.

Matrices

Considera una matriz como un grupo de vectores en el que todos tienen la misma dimensión (número de columnas). De esta manera una matriz es un array de dos dimensiones para el cual tenemos filas y columnas.

Si nuestra matriz debe ser de tamaño n x m, tiene n filas y m columnas.

Tensores

Un tensor es un array multidimensional al nivel más fundamental. Es más una estructura matematica general que un vector. Se puede ver a los vectores como una subclase de tensores.

Con tensores, las filas se extienden a lo largo del eje y y las columnas a lo largo del eje x. Cada eje es una dimensión, y los tensores tienen dimensiones adicionales. Los tensores también tienen un rango. Comparativamente, un escalar es de rango 0 y un vector es rango 1. También se puede ver que una matriz es de rango 2. Cualquier entidad de rango 3 y superior es considerado un tensor.

Hiperplanos

Otro objeto de álgebra lineal del que debemos estar al tanto es el hiperplano. En el campo de la geometría, el hiperplano es un subespacio de una dimensión menos que su espacio ambiental. En un espacio de tres dimensiones, los hiperplanos deben tener dos dimensiones. En un espacio de dos dimensiones se considera a una linea de una dimension como el hiperplano.

Un hiperplano es una construcción matemática que divide en n espacios dimensionales en "partes" separadas y por lo tanto es util en aplicaciones como clasificación.

Optimizar los parámetros del hiperplano es un concepto central en modelado lineal.

Operaciones Matemáticas Relevantes

Producto de punto (dot product)

Una operación central de la algebra lineal que se ve muy seguido en Machine Learning es el producto de punto. El producto de punto es llamado a veces como "producto escalar" o "producto interno". Este producto toma dos vectores de la misma longitud y devuelve un solo número. Esto se hace combinando las entradas en los dos vectores, multiplicándolas y luego sumando los productos así obtenidos. Sin ponerse muy matemático (inmediatamente), es importante mencionar que este solo número codifica mucha informacion.

Para empezar, el producto de punto es una medida de cuan grandes son los elementos individuales en cada vector. Dos vectores con valores bastante grandes pueden dar resultados grandes, y dos vectores con valores bastante chicos van a dar valores chicos. Cuando los valores relativos de estos vectores son contabilizados matemáticamente con algo llamado normalización, el producto de punto es una medida de cuan similares son estos vectores. Esta nocion matemática de un producto de punto de dos vectores normalizados es llamada similitud coseno.

Producto Hadamard (element-wise product)

Otra operación comun en la álgebra lineal que se ve en la práctica es el producto Hadamard (es la mejor traduccion que encontre). Esta operación toma dos vectores de la misma longitud y produce un vector de la misma longitud con cada elemento correspondiente multiplicados juntos de los dos vectores originales.

Producto Tensor (outer product)

Esto es conocido como el "producto tensor" de dos vectores de entrada. Tomamos cada elemento de una columna del vector y lo multiplicamos por todos los elementos en la fila del vector creando una nueva fila en la matriz resultante.

Estadística

Ahora vamos a repasar tres conceptos básicos en estadística, estos son:

Probabilidades
Distribuciones
Posibilidades

También hay otros conceptos que me gustaria resaltar de estadística descriptiva y estadística inferencial. Estadística descriptiva incluye a:

Histogramas
Boxplots
Scatterplots
Promedio
Desviación estándar
Coeficiente de correlación

Esto contrasta con la forma en que la estadística inferencial se ocupa de las técnicas para generalizar de una muestra a una población. A continuación, se muestran algunos ejemplos de estadísticas inferenciales:

Valor-P
Intervalos de confianza

La relación entre probabilidad y estadística inferencial:

Razonamiento probabilistico de la población a la muestra (razonamiento deductivo)
Razonamiento estadístico inferencial de la muestra a la población

Antes de que podamos entender lo que una muestra especifica nos dice sobre la población original, necesitamos entender la incertidumbre asociada a tomar una muestra de una población dada.

Probabilidad

Definimos la probabilidad de un evento E como un número entre 0 y 1. En este contexto, el valor 0 infiere que el evento E no tiene chances de ocurrir, y el valor 1 significa que el evento E va a ocurrir con seguridad. Muchas veces veremos a la probabilidad expresada como un número decimal, pero también podemos expresarlo como un porcentaje entre 0 y 100 %. Un ejemplo podría ser una probabilidad de 0.35 expresado como 35 por ciento (0.35 x 100 = 35 por ciento).

EL ejemplo canónico de medir la probabilidad es observar cuantas veces una moneda cae en cara o en cruz (por ejemplo, 50 % de cada lado). La probabilidad del espacio muestral es siempre 1 porque esto representa todos los posibles resultados para una determinada prueba. Como podemos ver con los dos resultados ("cara" y "cruz") para la moneda lanzada, 0.50 + 0.50 = 1 porque la probabilidad total del espacio muestral siempre debe resultar en 1. Se expresa la probabilidad de un evento de la siguiente manera:

P(E) = 0.5

Y se lee como: La probabilidad del evento E es 0.5

Probabilidad vs. Posibilidad

Muchas veces personas que apenas comienzan en la estadística o el aprendizaje automático pueden confundir el significado de probabilidad y posibilidad. Antes de seguir, vamos a dejar en claro que:

P(E) = (Chances de que E ocurra) / Chances totales

Vemos esto en el ejemplo de tomar un az (de 4) de un mazo de 52 cartas donde obtenemos esto:

4 / 52 = 0.077

Por lo tanto, posibilidades se define como:

(Chances de que E ocurra) : (Chances de que E NO ocurra)

Ahora, el ejemplo de la carta se convierte en "las posibilidades de tomar un az":

4 : (52 - 4) = 1 / 12 = 0.083333333333...

La principal diferencia aqui es la eleccion del denominador (chances totales ante chances que no ocurra) haciendo que estos dos sean dos conceptos diferentes en estadística.

La probabilidad se encuentra en el centro de las redes neuronales y el aprendizaje profundo por su rol en extracción de características y clasificación, dos de las principales funciones de redes neuronales profundas.

Aun más probabilidad: Bayesianos vs. Frequentistas

Hay dos corrientes principales dentro de la estadística llamadas Bayesianismo y frequentismo. La diferencia básica entre las corrientes es cómo probabilidad es definida.

Con los frequentistas, probabilidad solo tiene significado en el contexto de repetir una medición. Cuando medimos algo, veremos pequeñas variaciones dadas a los cambios en el equipo que utilizamos para recolectar datos. Si medimos algo un buen número de veces, la frequencia del valor dado indica la probabilidad de medir ese valor.

Con el enfoque Bayesiano, ampliamos la idea de probabilidad para cubrir aspectos de certeza sobre declaraciones. La probabilidad nos da una declaración de nuestro conocimiento sobre cuál será el resultado de la medición. Para los Bayesianos, nuestro conocimiento sobre un evento es fundamentalmente relacionado con la probabilidad.

Los frequentistas confían en muchos, muchos ensayos a ciegas de un experimento antes de hacer declaraciones sobre la estimación de una variable. Los bayesianos, por otro lado, manejan "creencias" (en términos matemáticos, "distribuciones") sobre la variable y actualizan sus creencias sobre la variable a medida que llega nueva información.

Probabilidad Condicional

Cuando queremos saber la probabilidad de un evento basado en la existencia de otro evento, expresamos esto como una probabilidad condicional. Esto se expresa de la siguiente manera:

P = (E|F) donde:
E es el evento cuya probabilidad es en la que estamos interesados.
F es el evento que ya ocurrió.

Un ejemplo podría ser expresar como una persona con un ritmo cardiaco sano tiene una probabilidad menor de morir en una Unidad de Terapia Intensiva durante una visita hospitalaria:

P(Muerte en UTI|Ritmo cardiaco anormal) > P(Muerte en UTI| Ritmo cardiaco sano)

Algunas veces, escucharemos que el segundo evento, F, es referido como la condición. La probabilidad condicional es interesante en aprendizaje automático y aprendizaje profundo porque en algunas situaciones estaremos interesados en como ocurren multiples evenots y como estos interactuan. Nos interesa la probabilidad condicional en el aprendizaje automático en el contexto en que le enseñaríamos a un clasificador que

P = (E|F) donde E es nuestro objetivo y F es un número de atributos sobre la entidad para la que estamos prediciendo E. Un ejemplo podría ser predecir la mortalidad (aqui, E) dados una medidas tomadas en una UTI para cada paciente (aqui, F).

Teorema de Bayes

Una de las aplicaciones mas comunes de la probabilidad condicional es el teorema de Bayes. En el campo de la medicina, se ha visto usado para calcular la probabilidad de que un paciente que da positivo en una prueba para una enfermedad especifica en realidad tiene la enfermedad.

Se define la formula de Bayes para dos eventos, A and B, asi:

Probabilidad Posterior

En la estadística Bayesiana, se llama probabilidad posterior de un evento aleatorio a la probabilidad condicional que se asigna despues de considerar la evidencia. La distribución de la probabilidad posterior es definida como la distribución de la probabilidad de una cantidad desconocida condicionada por la evidencia recopilada en un experimento tratada como una variable desconocida. Vemos este concepto en acción con la función de activación softmax, en donde valores brutos de entrada son convertidos en probabilidades posteriores.

Distribuciones

La distribución de la probabilidad es una especificación de la estructura estocastica de variables aleatorias. En estadística, confiamos en hacer suposiciones sobre cómo se distribuyen los datos para sacar conclusiones sobre los datos. Queremos una fórmula que especifique qué tan frecuentes son los valores de las observaciones en la distribución y como estos valores pueden ser tomados por puntos en la distribución. Una distribución comun es conocida como la distribución normal (también llamada la distribución Gaussiana, o la curva de campana). Queremos ajustar el dataset con una distribución porque si el dataset esta razonablemente cerca a la distribución, podemos sacar conclusiones basadas en la distribución teorica sobre como operamos con los datos.

Clasificamos distribuciones como continuas o discretas. Una distribución discreta tiene datos que pueden asumir solo ciertos valores. En una distribución continua, los datos pueden tener cualquier valor dentro de un rango. Un ejemplo de distribución continua puede ser la distribución normal. Un ejemplo de distribución discreta puede ser la distribución binomial.

La distribución normal nos permite asumir que las distribuciones muestrales de las estadísticas (por ejemplo, la "media muestral") se distribuye normalmente en condiciones específicas. La distribución normal, o distribución Gaussiana, fue nombrada así en honor al matemático y físico del siglo XVIII Karl Gauss. La distribución normal es definida por su promedio y su desviación estandar y tiene generalmente la misma forma a traves de todas sus variaciones.

Otras distribuciones relevantes en el aprendizaje automático incluyen a:

Distribución binomial
Distribución Gaussiana inversa
Distribución normal logarítmica

La distribución de los datos de entrenamiento en el aprendizaje automático es importante para comprender cómo vectorizar los datos para el modelado.

Teorema del Limite Central

Si el tamaño muestral es lo suficientemente grande, la distribución de la muestra del promedio muestral se aproxima a la distribución normal. Esto es cierto a pesar de la distribución de la población de donde las muestras fueron tomadas.

Basados en este hecho, podemos realizar inferencias estadísticas usando pruebas basadas en la aproximada normalidad del promedio. Vemos que esto es cierto independientemente de si la muestra se extrae de una población que no se distribuye normalmente.

En ciencias de la computación, vemos que esto se usa cuando un algoritmo extrae repetidamente muestras de un tamaño específico de una población no normal. Cuando graficamos el histograma de la población de muestra de los extractos de una distribución normal, podemos ver este efecto en acción.

Dado que la distribución de cola larga (como Zipf, leyes de potencia y distribuciones de Pareto) es un escenario en el que una población de alta frecuencia es seguida por una población de baja frecuencia que disminuye gradualmente de manera asintótica. Estas distribuciones fueron descubiertas por Benoit Mandelbrot en los '50s y luego popularizadas por el escritor Chris Anderson en su libro The Long Tail: Why the Future of Business is Selling Less of More.

Un ejemplo sería clasificar los artículos que vende un minorista, entre los cuales algunos artículos son excepcionalmente populares y vemos una gran cantidad de artículos únicos con cantidades relativamente pequeñas vendidas. Esta distribucion de rango-frequencia (principalmente de popularidad o "cuantos fueron vendidos") a veces forma leyes de poder. Desde esta perspectiva, podemos considerarlos como distribuciones de cola larga.

Vemos estas distribuciones de cola larga manifestadas en:

Daños de un terremoto

El daño es peor a la vez que la escala del temblor incrementa, asi que el peor de los casos cambia.

Campos de maiz

A veces vemos eventos fuera del registro histórico, mientras que nuestro modelo tiende a ajustarse a la media.

Prediciendo fatalidad luego de visita a UTI

Podemos tener eventos muy fuera del alcance de lo que sucede dentro de la visita a la UCI que afecten la mortalidad.

Estos ejemplos son relevantes para problemas de clasificación porque la mayoría de los modelos estadísticos dependen de la inferencia de grandes cantidades de datos. Si el evento más interesante ocurre por fuera de la cola de la distribución y no tenemos representado esto en los datos de entrenamiento, nuestro modelo puede dar resultados impredecibles. Este efecto se puede mejorar en modelos no lineales como las redes neuronales. Consideraríamos esta situación como el caso especial del problema "en la muestra/fuera de muestra". Incluso un practicante experimentado del aprendizaje automático puede sorprenderse de lo bien que se desempeña un modelo en una muestra de datos de entrenamiento sesgada, pero no logra generalizar bien en la población más grande de datos.

Las distribuciones de cola larga tratan con la posibilidad real de de que ocurran eventos que son cinco veces la desviacion estandar. Debemos ser conscientes de obtener una representación decente de los eventos en nuestros datos de entrenamiento para evitar el sobreajuste de los datos de entrenamiento.

Muestras vs. Población

La población de los datos es definida como todas las unidades que nos gustaria estudiar o utilizar como modelo para nuestro experimento. Un ejemplo puede ser definir nuestra población de estudio como "todos los programadores en Python en el estado de Tennessee".

Una muestra de los datos es un subconjunto de la población de los datos que esperamos que represente una distribución precisa de los datos sin presentar sesgo de muestra (por ejemplo, sesgar la distribución de la muestra en función de cómo muestreamos la población).

Métodos de re-muestreo

El bootstrapping y la validación cruzada (cross-validation) son dos métodos comunes de re-muestreo que son muy útiles para el aprendizaje automático. En el contexto del aprendizaje automático con bootstrapping, estamos extrayendo muestras aleatorias de otra muestra para generar una nueva muestra que tenga un equilibrio entre la cantidad de muestras por clase. Esto es útil cuando deseamos modelar contra un conjunto de datos con clases altamente desequilibradas.

La validación cruzada (también llamada estimacion de rotacion) es un método para estimar cuan bien un modelo generaliza en los datos de entrenamiento. En validacion cruzada dividimos los datos de entrenamiento en N número de divisiones y luego separamos estas porciones en grupos de entrenamiento y de prueba. Entrenamos los grupos de entrenamiento y luego evaluamos el modelo en los grupos de prueba. Luego, rotamos las divisiones entre los dos grupos todas las veces que podamos hasta agotar todas las variaciones. No hay un número magico para esta practica. También es comun ver una porción separada para usar como datos de validación durante el entrenamiento.

Sesgo de Selección

En el sesgo de selección estamos lidiando con un método de muestreo que no tiene una aleatorización adecuada y sesga la muestra de manera que no es representativa de la población que nos gustaria modelar. Necesitamos estar atentos al sesgo de selección cuando re-muestreamos datasets asi no se presenta sesgo en nuestros modelos que solo van a disminuir la precisión de nuestro modelo para la población total de los datos.

Posibilidad

Cuando discutimos la posibilidad de que ocurra un evento pero no hacemos referencia específica a su probabilidad numérica, estamos usando el término informal, posibilidad. Normalmente, cuando usamos este término, estamos hablando de un evento que tiene una probabilidad razonable de ocurrir, pero aun así podría no ocurrir. También pueden haber factores que no fueron observados que pueden influenciar en el evento. Informalmente posibilidad es usado también como sinónimo de probabilidad.

Traduccion del libro:
Josh Paterson & Adam Gibson. (2017). Deep Learning: A Practitioneers Approach. USA: O'Reilly.

Recetas para visualización de datos con Seaborn

Leandro Ruiz — Tue, 22 Sep 2020 20:48:41 +0000

En este articulo voy a recopilar algunos bloques de código que me han sido de gran utilidad en varios proyectos de machine learning. Seaborn es una librería para visualización en Python que contiene una gran variedad de gráficos con mucha personalización.

Gráficos básicos

Gráfico de correlación:

import seaborn as sns
sns.regplot(x='1st_feature', y='2nd_feature', data=df)

Gráfico de datos residuales:

sns.residplot(df['features'], df['target'])

Boxplot (o subplot), para ver outliers:

sns.boxplot(x='1st_feature', y='2nd_feature', data=df)

Gráfico de densidad:

plt.figure(figsize = (14,6))
plt.title('Plot Title')
sns.set_color_codes("pastel")
sns.distplot(df['1st_feature'], kde=True, bins=200, color="blue")
plt.show()

Gráfico de densidad con dos clases de objetivos:

class_0 = df.loc[df['target_feature'] == 0]["1st_feature"]
class_1 = df.loc[df['target_feature'] == 1]["2nd_feature"]
plt.figure(figsize = (14,6))
plt.title('Plot Title')
sns.set_color_codes("pastel")
sns.distplot(class_0, kde=True, bins=200, color="green", label='1st feature')
sns.distplot(class_1, kde=True, bins=200, color="red", label='2nd feature')
plt.legend()
plt.show()

Gráfico de cajas con varios atributos:

# 1st_feature= x, 2nd_feature = y, 3rd_feature = labels
def boxplot_variation(1st_feature, 2nd_feature, 3rd_feature, width=16):
    fig, ax1 = plt.subplots(ncols=1, figsize=(width,6))
    s = sns.boxplot(ax = ax1, x=1st_feature, y=2nd_feature, hue=3rd_feature,
                data=df, palette="PRGn",showfliers=False)
    s.set_xticklabels(s.get_xticklabels(),rotation=90)
    plt.show();

Graficando atributos importantes:

tmp = pd.DataFrame({'Feature': x_train, 'Feature importance': clf.feature_importances_})
tmp = tmp.sort_values(by='Feature importance', ascending=False)
plt.figure(figsize = (7,4))
plt.title('Features importance', fontsize=14)
s = sns.barplot(x=x_train, y='Feature importance', data=tmp)
s.set_xticklabels(s.get_xticklabels(), rotation=90)
plt.show()

Mapa de calor de la matriz de correlación en forma de triángulo:

# corr_matrix son las correlaciones a graficar usando .corr()
mask = np.triu(np.ones_like(corr_matrix, dtype=np.bool))
f, ax = plt.subplots(figsize=(11, 9))
cmap = sns.diverging_palette(220, 10, as_cmap=True)
sns.heatmap(corr_matrix, mask=mask, cmap=cmap, vmax=.3, center=0,
            square=True, linewidths=.5, cbar_kws={"shrink": .5})

Pairplots

Pairplot básico:

sns.pairplot(df)

Seleccionando atributos:

sns.pairplot(df, vars=["1st_feature", "2nd_feature"])

Diferentes atributos en filas y columnas:

sns.pairplot(df,
                 x_vars=["1st_feature", "2nd_feature"],
                 y_vars=["3rd_feature", "4th_feature"])

Graficando solo el triángulo inferior y ajustando un modelo lineal:

sns.pairplot(df, kind='reg', corner=True)

Conclusión

Esto es todo por ahora, quizas en el futuro haga una segunda parte con mas tipos de gráficos.

¡Muchas gracias por llegar hasta aqui!

Usando pipelines para ahorrar tiempo

Leandro Ruiz — Tue, 15 Sep 2020 20:27:18 +0000

Existe una forma muy sencilla de ahorrarnos tiempo en la etapa de pre-procesamiento y de ajuste de parámetros para nuestros modelos de aprendizaje automático.

Nota: Por lo que entiendo, en español se le llama tubería, pero como no me siento cómodo hablando de plomería, la llamaré con su nombre en ingles; pipeline.

Ahora sin más, comenzemos:

Lo primero es importar el objeto pipeline de Scikit-Learn:

from sklearn.pipeline import Pipeline
from sklearn.preprocessing import MinMaxScaler
from sklearn.svm import SVC

pipe = Pipeline([('scaler', MinMaxScaler()), ('svm', SVC())])

Aquí hemos creado dos pasos: el primero, llamado "scaler", es una instancia de MinMaxScaler, y el segundo, llamado "svm", es una instancia de SVC. Ahora, podemos entrenar nuestra pipeline, como cualquier otro estimador de Scikit-Learn:

pipe.fit(X_train, y_train)

Usando pipelines con Grid Search

Primero, creamos una grilla de parámetros (parameter grid):

param_grid = {'svm__C': [0.001, 0.01, 0.1, 1, 10, 100],
              'svm__gamma': [0.001, 0.01, 0.1, 1, 10, 100]}

Con esta grilla, usamos GridSearchCV como siempre:

grid = GridSearchCV(pipe, param_grid=param_grid, cv=5) # we call the pipeline as an attribute
grid.fit(X_train, y_train)
print("Best cross-validation accuracy: {:.2f}".format(grid.best_score_))
print("Test set score: {:.2f}".format(grid.score(X_test, y_test)))
print("Best parameters: {}".format(grid.best_params_))

Código completo en este link.

Una mejor froma de hacer pipelines

Usando make_pipeline de Scikit-Learn, es mucho más sencillo crear una pipeline:

from sklearn.pipeline import make_pipeline
# sintaxis estandar
pipe_long = Pipeline([("scaler", MinMaxScaler()), ("svm", SVC(C=100))])
# sintaxis abreviada
pipe_short = make_pipeline(MinMaxScaler(), SVC(C=100))

Accediendo a los atributos de los pasos

En algún momento querrás inspeccionar los atributos de uno de los pasos de la pipeline. Por ejemplo, los coeficientes de un modelo lineal o los componentes extraidos por PCA (Principal Component Analysis). La forma mas facil de acceder a estos pasos en una pipeline es a través del atributo named_steps, que es un diccionario con los nombres de los atributos como estimadores:

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA

pipe = make_pipeline(StandardScaler(), PCA(n_components=2), StandardScaler())
print("Pipeline steps:\n{}".format(pipe.steps))

pipe.fit(cancer.data)
# extrae los primeros dos componentes principales del paso de "pca"
components = pipe.named_steps['pca'].components_

print("components.shape: {}".format(components.shape))

Accediendo a atributos en una pipeline con Grid Search

Vamos a realizar una grid search en un clasificador de regresión lineal, usando una pipeline y un StandardScaler para escalar los datos antes de pasarlos al clasificador.

from sklearn.linear_model import LogisticRegression

pipe = make_pipeline(StandardScaler(), LogisticRegression(max_iter=1000))

El parametro de la regularización para ajustar en regresión logistica es el parámetro c:

param_grid = {'logisticregression__C': [0.01, 0.1, 1, 10, 100]}

Recuerda: La sintaxis para definir una cuadrícula de parámetros para una pipeline es especificar para cada parámetro el nombre del paso, seguido por __ (doble guion bajo), seguido por el nombre del parámetro. Por ejemplo, para acceder al parámetro gamma de un modelo svm, llamamos a svm__gamma, para el parametro C de un modelo LogisticRegression, llamamos a logisticregression__C.

Divide el dataset y entrena el modelo:

X_train, X_test, y_train, y_test = train_test_split(cancer.data, cancer.target, random_state=4)

grid = GridSearchCV(pipe, param_grid, cv=5)
grid.fit(X_train, y_train)

¿Así que cómo accedemos a los coeficientes del mejor modelo de regresión logistica que fue encontrado por GridSearchCV?

print('Best estimator:\n{}'.format(grid.best_estimator_))

En este caso, el best_estimator_ es una pipeline con dos pasos, StandardScaler y LogisticRegression. Para acceder al paso LogisticRegression, podemos usar el atributo named_steps de la pipeline:

print("Logistic regression step:\n".format(grid.best_estimator_.named_steps['logisticregression']))

Ahora que ya tenemos la regresión logística entrenada, podemos acceder a los coeficientes asociados a cada atributo de entrada:

print("Logistic regression coefficients:\n{}".format(grid.best_estimator_.named_steps['logisticregression'].coef_))

Link a GitHub

Obteniendo pasos de pre-procesamiento con Grid-Search

Usando pipelines, podemos encapsular todos los pasos de pre-procesamiento en nuestro proceso de aprendizaje automático es un solo estimador de Scikit-Learn. Otro beneficio de hacer esto es que podemos ajustar los parámetros del pre-procesamiento usando el resultado de una tarea supervisada como regresión o clasificación.

from sklearn.datasets import load_boston
boston = load_boston()
from sklearn.linear_model import Ridge

X_train, X_test, y_train, y_test = train_test_split(
    boston.data, boston.target, random_state=0)

from sklearn.preprocessing import PolynomialFeatures
pipe = make_pipeline(StandardScaler(), PolynomialFeatures(), Ridge())

¿Cómo sabemos que grados de polinomios elegir, o si elegir polinomios o interacciones? Idealmente, queremos seleccionar el parámetro de grado en función del resultado de la clasificación. Usando nuestra pipeline, podemos buscar sobre el parámetro de grado junto con el parámetro alpha o Ridge.
Para hacer esto, definimos una param_grid que contiene ambos, pre-fijados apropiadamente por el nombre de los pasos:

param_grid = {'polynomialfeatures__degree': [1, 2, 3],
              'ridge__alpha': [0.001, 0.01, 0.1, 1, 10, 100]}

Ahora podemos correr de nuevo la grilla de parametros:

grid = GridSearchCV(pipe, param_grid=param_grid, cv=5, n_jobs=-1)
grid.fit(X_train, y_train)

Ahora podemos visualizar los resultados de la validacion cruzada(cross-validation) usando un heat-map:

plt.matshow(grid.cv_results_['mean_test_score'].reshape(3, -1),
            vmin=0, cmap='viridis')
plt.xlabel("ridge__alpha")
plt.ylabel("polynomialfeatures__degree")
plt.xticks(range(len(param_grid['ridge__alpha'])), param_grid['ridge__alpha'])
plt.yticks(range(len(param_grid['polynomialfeatures__degree'])),
           param_grid['polynomialfeatures__degree'])
plt.colorbar()

Usando Grid-Search para saber que modelo usar

Aquí dejo un ejemplo comparando un RandomForestClassifier y un SVC. Sabemos que el SVC quizás necesite datos escalados, así que tambien buscamos sobre usar StandardScaler o no pre-procesar los datos. Para el RandomForestClassifier, ya sabemos que no necesita ningun tipo de pre-procesamiento.
Comenzamos definiendo la pipeline. Aquí, nombramos los pasos explicitamente. Queremos dos pasos, uno de pre-procesamiento y despues el clasificador. Podemos instanciar esto usando SVC y StandardScaler:

pipe = Pipeline([('preprocessing', StandardScaler()), ('classifier', SVC())])

Ahora podemos definir la grilla de parámetros para realizar la busqueda. Queremos que el clasificador sea un RandomForestClassifier o SVC. Como tienen diferentes parámetros a ajustar, y necesitan diferentes pre-procesamientos, podemos hacer una lista de grillas de búsqueda:

from sklearn.ensemble import RandomForestClassifier

param_grid = [
              {'classifier': [SVC()], 'preprocessing': [StandardScaler(), None],
               'classifier__gamma': [0.001, 0.01, 0.1, 1, 10, 100],
               'classifier__C': [0.001, 0.01, 0.1, 1, 10, 100]},
              {'classifier': [RandomForestClassifier (n_estimators=100)],
               'preprocessing': [None], 'classifier__max_features': [1, 2, 3]}]

Ahora instanciamos y corremos la grilla como siempre:

X_train, X_test, y_train, y_test = train_test_split(
    cancer.data, cancer.target, random_state=0)

grid = GridSearchCV(pipe, param_grid, cv=5)
grid.fit(X_train, y_train)

print("Best params:\n{}\n".format(grid.best_params_))
print("Best cross-validation score: {:.2f}".format(grid.best_score_))
print("Test-set score: {:.2f}".format(grid.score(X_test, y_test)))

Y de esta sencilla manera, obtenemos el mejor modelo con sus mejores parámetros incluidos.

Conclusión

Crear pipelines es una gran manera de ahorrar mucho tiempo en nuestros proyectos. Espero que este articulo les haya servido, y si llegaste hasta aquí, muchas gracias. ¡Hasta la proxima!

Principios Basicos sobre Deep Learning

Leandro Ruiz — Fri, 11 Sep 2020 18:30:34 +0000

Primero: neuronas artificiales

La arquitectura de las redes neuronales biológicas fueron la inspiración para descubrir como construir una maquina inteligente. Esta es la lógica detras de redes neuronales artificiales (artificial neural networks, o ANN en ingles): una RNA es un modelo de aprendizaje automático inspirado por las redes de neuronas biológicas que se encuentran en nuestro cerebro.

Poder de computo con neuronas

El neurofisiologo Warren McCullcoh y el matemático Walter Pitts propusieron un modelo muy simple de una neurona biológica, que más tarde se comenzó a conocer como una neurona artificial: tiene una o más entradas binarias (0-1) y una salida binaria. La neurona artificial activa la salida cuando más de un cierto número de sus entradas esta activa.

El Perceptron

El perceptron es una de las arquitecturas de RNA mas simples, inventada en 1957 por Frank Rosenblatt. Está basada en una neurona artificial levemente diferente llamada unidad lógica de umbral (threshold logic unit, o TLU en ingles). Las entradas y salidas son números (en lugar de valores binarios 0-1), y cada conexión de entrada esta asociada a un peso.

No podía escribir ecuaciones en LaTeX y por esa razón todas las ecuaciones estarán en formato Gist.

Una sola ULU puede ser usada para una clasificación lineal binaria simple. Computa una combinación lineal de las entradas, y si el resultado excede un determinado límite, la salida es de clase positiva. De otra manera la salida es de clase negativa (al igual que una regresión logística o un clasificador SVM lineal).

Un perceptron esta compuesto basicamente por una sola capa de ULUs, con una ULU conectada a cada entrada. Cuando todas las neuronas en una capa estan conectadas a cada neurona de la capa anterior (por ejemplo, las neuronas de entrada), la capa es llamada una capa completamente conectada, o una capa densa. Ademas, una caracteristica de sesgo adicional es generalmente añadida (x_0 = 1): tipicamente es representada usando un tipo especial de neurona llamada neurona de sesgo, que da como resultado 1 todo el tiempo. Un perceptron con dos entradas y tres salidas puede clasificar instancias simultaneamente en tres clases binarias diferentes, lo que lo convierte en clasificador de multiples salidas.

Esta ecuación hace posible calcular de manera eficiente las salidas de una capa de neuronas artificiales para varios casos a la vez:

Asi que, ¿cómo se entrena a un perceptron? Cuando son entrenados toman en cuenta el error producido por la red cuando realiza una predicción; la regla de aprendizaje del perceptron informa conexiones que ayudan a reducir el error. Más especificamente, el perceptron se alimenta una instancia de entrenamiento a la vez, y para cada instancia realiza una predicción. Para cada neurona de salida que produjo una predicción erronea, refuerza los pesos de conexión de las entradas que habrían contribuido a la predicción correcta.

Ecuacion de la regla de aprendizaje de un perceptron (con pesos actualizados):

El limite de decisión de cada neurona de salida es lineal, por lo tanto los perceptrones son incapaces de aprender patrones complejos (como un clasificador de regresión logística). De todas maneras, si las instancias de entrenamiento son separables linealmente, Rosenblatt demostró que este algoritmo puede converger a una solución. Esto es llamado el teorema de convergencia del perceptron.

Scikit-Learn provee una clase Perceptron que implementa una red de un solo ULU:

import numpy as np
from sklearn.datasets import load_iris
from sklearn.linear_model import Perceptron

iris = load_iris()
X = iris.data[:, (2, 3)]
y = (iris.target == 0).astype(np.int)

per_clf = Perceptron()
per_clf.fit(X, y)

y_pred = per_clf.predict([[2, 0.5]])

Quizas te hayas dado cuenta que el algoritmo de aprendizaje del perceptron se parece mucho a un descenso de gradiente estocástico (Stochastic Gradient Descent). De hecho, la clase Perceptron de Scikit-Learn es equivalente a usar un SGDClassifier con los siguientes hiperparámetros: loss='perceptron', learning_rate='constant', eta=0.1 (la tasa de aprendizaje), y penalty=None (sin regularización).

Ten en cuenta que al contrario de los clasificadores de regresión logística, los perceptrones no dan como resultado una probabilidad de clase; en su lugar, hace predicciones basado en un limite duro. Esta es una de las razones para preferir regresión logística sobre un perceptron.

En su monografía de 1969 Perceptrons, Marvin Minsky y Seymour Papert subrayaron un número de serias debilidades en los perceptrones- en particular el hecho de que son incapaces de resolver algunos problemas triviales. Esto es verdad en cualquier otro modelo de clasificación lineal (como los de regresión logística).

Resulta que algunas de las limitaciones de los perceptrones pueden ser eliminadas al apilar multiples perceptrones. La RNA resultante es llamada Perceptron Multicapa (MLP).

Hace unas semanas, escribi un articulo (en ingles) sobre como crear un Perceptron multicapa con PySpark. Les dejo el repositorio de GitHub con una introducción al aprendizaje profundo y un Jupyter notebook donde probamos el algoritmo:

Link a GitHub

Conclusión

Eso es todo por el articulo de hoy, muchas gracias por llegar hasta acá.

No se nada sobre A/B testing

Leandro Ruiz — Fri, 04 Sep 2020 18:16:12 +0000

Pero eso va a cambiar ahora.

Estoy buscando trabajo como data scientist hace algunos dias y descubrí que es un requisito muy común tener conocimientos sobre A/B testing. Por lo tanto me puse manos a la obra y esto es todo lo que aprendí sobre ello.

¿Que es un A/B testing?

Es un experimento controlado donde se enfrenta un cambio (usualmente en un sitio web) ante su forma original. Por ejemplo, cambiando el color de un botón de compra de azul a naranja.

En este caso se realizar un A/B test para saber que botón funciona mejor.

Tambien se puede utilizar este tipo de test en otras situaciones, tales como:

Cambios de diseño.
Cambios en la interfaz de usuario.
Cambios en un algoritmo.
Cambios de precios (aunque no es muy recomendable).

¿Cómo se mide?

Antes que nada, el primer paso para realizar este experimento es definir que métrica se quiere optimizar. Puede ser ingresos, ganancias, clicks o visualizaciones de publicidad. Se puede elegir una o varias de estas métricas segun el caso. Cuando muchas de estas mejoran, quiere decir que se va por el camino correcto.

Es muy importante saber a quien atribuir una conversión. Por ejemplo, si realizamos un cambio en la página A, y un usuario pasa de la página A a la página B, y luego a la página C, ¿es gracias al cambio realizado?

Tambien hay que tener en cuenta que cuando se realiza un A/B test, la varianza es nuestro enemigo. Por eso intenta elegir una métrica que tenga poca varianza para no afectar a las conclusiones del experimento.

T-statistic y p-value

Son dos herramientas de la estadística para saber si un resultado es real.

T-statistic

T-statistic o T-test (test-T en español), es una medición de la diferencia en comportamiento entre los dos grupos, expresado en unidades de error estándar.

Su resultado se interpreta de la siguiente manera: un valor-T alto significa que hay probabilidad de una diferencia real. Uno bajo, indica lo contrario.

Además, hay alternativas a esta prueba según la métrica que se observa: prueba exacta de Fisher (porcentaje de clics), E-test (transacciones por usuario), Chi-squared test (cantidad de ordenes).

p-value

El p-value (valor-p) es la probabilidad de que el experimento satisfaga la hipótesis nula, es decir, la probabilidad de que no haya una diferencia real entre los dos grupos.

Un valor-p bajo nos indica que hay una alta probabilidad de que el cambio tenga un impacto real en las métricas analizadas.

Asi que, lo que estamos buscando es un T-statistic alto y un p-value bajo. Pero antes de comenzer el experimento, hay que decidir el limite inicial de éxito que estamos buscando. Puede ser un valor-p de 1 o 5 (más riesgo), pero siempre es posible que el resultado sea aleatorio.

Cuando el resultado del experimento es negativo, no querras correrlo por mucho tiempo o te expones a perder dinero. Por eso es una buena idea que monitorees los resultados a diario.

Midiendo T-statistic y p-value en Python

Gracias a la biblioteca scipy es bastante simple medir estos valores.

Vamos a utilizar datos sintéticos como ilustración:

In[1]:
    import numpy as np
    from scipy import stats

    A = np.random.normal(26.0, 5.0, 10000)
    B = np.random.normal(25.0, 5.0, 10000)

    stats.ttest_ind(A, B)

Out[1]: 
    Ttest_indResult(statistic=-14.702166911741832, pvalue=1.1209149921150975e-48)

El valor de T-test negativo nos indica que realizamos un mal cambio, y el valor-p muy bajo nos confirma que es muy improbable de que el resultado sea asi de casualidad.

En resumen, lo que estamos buscando es un test-T alto un valor-p bajo, para estar seguros que nuestros cambios son positivos y consecuencia del experimento y no del azar.

Link a GitHub

¿Cuando terminar el experimento?

Depende de los objetivos fijados antes del experimento, si llegaste al valor-p de 1 o 5, es un buen momento.

Si pasan muchos días donde el valor-p no baja, quiere decir que no va a ocurrir, y ahi debes decidir cual es el tiempo máximo que estas dispuesto a esperar (pueden ser unas tres o cuatro semanas más) entendiendo que puedes utilizar ese tiempo para otro experimento.

A/B test gotchas

Correlación no implica causalidad. Siempre existe la posibilidad de que no haya un efecto real.

Efectos de novedad: tu cambio funciona solo porque es nuevo. La unica forma de asegurarse de los resultados es hacer el experimento de nuevo, y replicar los resultados.
Efectos temporales: si llevas a cabo el experimento en Navidad (donde la gente gasta más) o en verano (donde la gente esta más tiempo de vacaciones). Por esto, hay que estar conciente del momento del año donde se realiza la prueba. En caso de realizarlo en una epoca "especial", deberías comparar los resultados con el mismo periodo del año anterior.
Selección parcial: hay que tener cuidado con la manera en que eliges en que grupo irá cada usuario (por ejemplo, poner usuarios nuevos en un grupo y viejos en otro), porque puede condicionarse la forma en que reaccione un grupo al cambio. Tambien debes asegurarte que durante una sesián el usuario permanezca en el grupo asignado.

Performa un A/A test (es decir, usar dos grupos iguales) para chequear la parcialidad u otro tipo de problemas.

Ruido en los datos

Es muy importante limpiar los datos antes de hacer un A/B testing. Hay que observar que tipo de outliers hay, ya que puede haber muchos comportamientos extraños que necesitan ser filtrados.

Errores en la atribución

Debes pensar como vas a contar conversiones como una función de distancia del cambio que realizaste, y ponerte de acuerdo en como vas a medir esos efectos. Además, si estas llevando a cabo varios experimentos al mismo tiempo, ¿estos crearán problemas al otro? Eso es mucho muy importante.

De nuevo, siempre hay que tomar los resultados con un grano de sal. Hay muchas cosas que pueden alterar los resultados. Además, si no tienes mucho tiempo, tienes que tomar los resultados con cuidado e idealmente probarlos de nuevo en otro momento.

Conclusión

Estos son los aspectos básicos de A/B testing, yo tampoco sabía nada sobre esto pero gracias a la investigación que realice para este artículo tengo una buena base de conceptos.

Introduccion a LightGBM

Leandro Ruiz — Sat, 29 Aug 2020 17:41:48 +0000

¿Que es LightGBM?

GBM = Gradient Boosted Machines

Es un framework que usa algoritmos basados en arboles con la eficiencia como objetivo principal.

Puede ser utilizado tanto para clasificación como para regresión (mas info en el parámetro objective).

¿Cómo funciona?

A diferencia de XGBoost (entre otros) que utiliza algoritmos basados en la clasificación previa, LightGBM usa algoritmos basados en histogramas (es decir, que agrupa los valores de atributos continuos en bins discretos) para agilizar el entrenamiento y reducir el uso de memoria.

Ademas, esta optimizado para que el arbol crezca en la dirección de los mejores nodos (ayudando a una mejor administración de memoria).

(algunos) Parámetros

LightGBM tiene más de 100 parámetros, pero aquí haré un resumen de los más importantes:

max_depth: Este parámetro previene que los arboles crezcan muy profundo. Los arboles poco profundos tienen menos probabilidad de overfitting. Configurar este parámetro es muy importante si el dataset es pequeño.
num_leaves: Controla la complejidad del modelo. El valor debe ser menor a 2^max_depth para prevenir overfitting. Si se lo ajusta con un valor grande puede aumentar la precisión a riesgo de aumentar el overfitting.
min_data_in_leaf: Configurar este parámetro con un valor grande puede ayudar a prevenir que los arboles crezcan demasiado profundo. Este es otro parámetro que ayuda a controlar el overfitting del modelo. Si es un valor demasiado grande puede provocar underfitting.
max_bin: como ya vimos, LightGBM agrupa los valores de atributos continuos en bins discretos usando histogramas. Configura max_bin para especificar el numero de bins en los que los valores pueden ser agrupados. Un valor bajo puede ayudar a controlar el overfitting y a mejorar la velocidad del entrenamiento, mientras que un valor grande mejora la precisión del modelo.
feature_fraction: Este parámetro habilita el submuestreo de atributos. feature_fraction especifica las fracciones de los atributos que se seleccionaran aleatoriamente en cada iteración. Por ejemplo, feature_fraction = .75 seleccionará al azar el 75 % de los atributos en cada iteración. Configurar este parámetro puede aumentar la velocidad de entrenamiento y ayuda a prevenir el overfitting.
bagging_fraction: bagging_fraction especifica las fracciones de los datos que se seleccionaran aleatoriamente en cada iteración. Por ejemplo, bagging_fraction = .75 seleccionará al azar el 75 % de los datos en cada iteración. Configurar este parámetro puede aumentar la velocidad de entrenamiento y ayuda a prevenir el overfitting.
num_iteration: Fija el número de iteraciones de boosting. El valor predeterminado es 100. Para clasificación multi-clase, LightGBM crea num_class * num_iteration arboles. Configurar este parámetro influencia en la velocidad de entrenamiento.
objective: Como en XGBoost, LightGBM soporta multiples objetivos. El objetivo predeterminado esta configurado en regresión. Ajusta este parametro para especificar el tipo de tarea que tu modelo quiere llevar a cabo. Para tareas de regresión, las opciones son regression_l2, regression_l1, poisson, quantile, mape, gamma, huber, fair, o tweedie. Para tareas de clasificacion, las opciones son binary, multiclass, o multiclassova. Es importante configurar este parámetro correctamente para evitar resultados impredecibles o baja precision.

Link a GitHub

Ejemplo Practico

En el pasado cree un proyecto usando LightGBM pero esta vez lo voy a utilizar con un dataset diferente.

En este caso estare clasificando a diferentes aplicantes a un préstamo. No voy a hacer un analisis de los datos, directamente iré al desarrollo del modelo.

Resultados

Luego de una busqueda de parámetros, evalué el modelo y dió estos resultados:

The accuracy of prediction is: 0.9078853557678597
The roc_auc_score of prediction is: 0.9115936285698222
The null accuracy is: 0.653429345501212

Confusion Matrix

Importancia de los atributos

Como podemos ver, LightGBM es un algoritmo confiable incluso en este dataset de tamaño mediano (46751 filas).

Group Your Data by the Index

Leandro Ruiz — Fri, 14 Aug 2020 18:57:01 +0000

A few days ago, I was working on a project on risk management, until I came across a simple problem that I had never seen.

The Problem

I needed to group data on the different IDs of a transaction dataset. This dataset contains 8,250 transactions for 1,125 customers of a bank.
Here are the first five rows:

id	pay_normal	prod_code	prod_limit	update_date	new_balance	highest_balance	report_date
54982353	19	10	NaN	16/07/2011	31677.6	204037.0	14/12/2015
54982353	11	2	NaN	21/02/2001	0.0	248874.0	22/06/2007
54982353	1	10	NaN	08/01/2006	0.0	1622.0	NaN
54982353	1	10	NaN	21/11/2006	0.0	NaN	NaN
54982353	0	10	NaN	30/09/2005	0.0	NaN	NaN

As you can see, all the rows have the same ID and I needed to group all the transactions according to the ID that created them.

Without having the solution in my head, I started looking in my Data Science books and more than anything those that were about data analysis and feature engineering but I didn't find anything.

For this reason I started looking at Stack Overflow until I found something that looked like my situation but I had to adapt it to the characteristics of the project.

[Link to GitHub](https://github.com/ruizleandro/Risk-Management-with-LightGBM)

The Solution

To get around this problem you need the well-known groupby of Pandas.

First, we are going to group the prod_code according to their ID (if you want to know more you can enter GitHub with the link above). But we are going to group the various prod_code values into a list with the following code:

df_0 = payment_data.groupby(['id'])['prod_code'].apply(list).reset_index()
df_0.head(10)

This is the output:

id	prod_code
54982353	[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1...
54982356	[27, 27, 10, 6, 6, 12, 10]
54982387	[1, 6, 6, 6, 6, 1, 10, 10, 1, 10, 10]
54982463	[5, 13]
54982530	[10, 10, 10, 10]
54982549	[17, 6, 6, 1, 2, 5, 17, 17, 17, 17]
54982579	[2, 10, 10, 10, 10, 10, 2, 10, 10, 1, 10, 10, ...
54982665	[10, 10, 5, 10]
54982697	[10, 10]
54982721	[10, 6, 1, 5, 13, 10, 5, 10, 13, 12]
54982725	[10]

As we can see, now we have all the unique different values of prod_code (one for every transaction made) grouped by the ID.
The next feature that I needed to group was new_balance , where I decided to get the mean of all the new balances for every prod_code:

df_1 = payment_data.groupby(['id'])['new_balance'].apply(np.mean, axis=0).reset_index()
df_1.head(10)

id	new_balance
54982353	42033.133333
54982356	2277.771429
54982387	117455.127273
54982463	39890.400000
54982530	1261.200000
54982549	410060.400000
54982579	86454.654545
54982665	40112.400000
54982697	8752.800000
54982721	49843.440000
54982725	15817.200000

Now, I had to group all the different types of overall payment: OVD_t1, OVD_t2, and OVD_t3. First, I grouped the sum of every type with their correspondent ID and then grouped all the types together in one dataframe.
For this I had to use the function reduce:

from functools import reduce

df_OVD_t1 = payment_data.groupby(['id'])['OVD_t1'].apply(np.sum, axis=0).reset_index()
df_OVD_t2 = payment_data.groupby(['id'])['OVD_t2'].apply(np.sum, axis=0).reset_index()
df_OVD_t3 = payment_data.groupby(['id'])['OVD_t3'].apply(np.sum, axis=0).reset_index()
OVD_dfs = [df_OVD_t1, df_OVD_t2, df_OVD_t3]
df_2 = reduce(lambda left,right: pd.merge(left,right,on='id'), OVD_dfs)
df_2.head(10)

id	OVD_t1	OVD_t2	OVD_t3
54982353	3	2	38
54982356	0	0	0
54982387	3	0	0
54982463	0	0	0
54982530	0	0	0
54982549	6	2	0
54982579	1	0	0
54982665	0	2	26
54982697	0	0	0
54982721	2	1	43
54982725	0	0	0

The final feature that I needed to group was pay_normal. Here, the only operation that I applied was np.sum because I needed the total of times that the payment was normal for every client.

df_3 = payment_data.groupby(['id'])['pay_normal'].apply(np.sum, axis=0).reset_index()
df_3.head(10)

id	pay_normal
54982353	229
54982356	117
54982387	246
54982463	34
54982530	56
54982549	211
54982579	323
54982665	34
54982697	45
54982721	109
54982725	36

Merging all the Dataframes into one

The final step for this task was to merge all the dataframes that I created into only one. For this, I used the reduce function again in the same form as in the grouping of the OVD_types before.

dfs = [df_0, df_1, df_2, df_3]
df_final = reduce(lambda left,right: pd.merge(left,right,on='id'), dfs) 
df_final.head(10)

id	prod_code	new_balance	OVD_t1	OVD_t2	OVD_t3	pay_normal
54982353	[10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1...	42033.133333	3	2	38	229
54982356	[27, 27, 10, 6, 6, 12, 10]	2277.771429	0	0	0	117
54982387	[1, 6, 6, 6, 6, 1, 10, 10, 1, 10, 10]	117455.127273	3	0	0	246
54982463	[5, 13]	39890.400000	0	0	0	34
54982530	[10, 10, 10, 10]	1261.200000	0	0	0	56
54982549	[17, 6, 6, 1, 2, 5, 17, 17, 17, 17]	410060.400000	6	2	0	211
54982579	[2, 10, 10, 10, 10, 10, 2, 10, 10, 1, 10, 10, ...	86454.654545	1	0	0	323
54982665	[10, 10, 5, 10]	40112.400000	0	2	26	34
54982697	[10, 10]	8752.800000	0	0	0	45
54982721	[10, 6, 1, 5, 13, 10, 5, 10, 13, 12]	49843.440000	2	1	43	109
54982725	[10]	15817.200000	0	0	0	36

Conclusion

And that's it. I hope this tutorial helps you, and thanks for getting here.

Build a Multilayer Perceptron with PySpark

Leandro Ruiz — Wed, 22 Jul 2020 18:25:12 +0000

In this article we will build a multilayer perceptron, using Spark. The dataset that we are going to use for this exercise contains close to 75k records, with some sample customer journey data on a retail web site. There are 16 input features to predict whether the visitor is likely to convert. We have a balanced target class in this dataset. We will use MultilayerPerceptronClassifier from Spark's ML library. We start by importing a few important dependencies.

from pyspark.sql import SparkSession
spark = SparkSession.builder.appName('deep_learning').getOrCreate()
import os
import numpy as np
import pandas as pd
from pyspark.sql.types import *

Now we load the dataset into Spark, for feature engineering and model training. As mentioned, there are 16 input features and 1 output column (Orders_Normalized).

[In]: data = spark.read.csv('dl_data.csv', header=True, inferSchema=True)
[In]: data.printSchema()
[Out]: root
        |-- Visit_Number_Bucket: string (nullable = true)
        |-- Page_Views_Normalized: double (nullable = true)
        |-- Orders_Normalized: integer (nullable = true)
        |-- Internal_Search_Successful_Normalized: double (nullable = true)
        |-- Internal_Search_Null_Normalized: double (nullable = true)
        |-- Email_Signup_Normalized: double (nullable = true)
        |-- Total_Seconds_Spent_Normalized: double (nullable = true)
        |-- Store_Locator_Search_Normalized: double (nullable = true)
        |-- Mapped_Last_Touch_Channel: string (nullable = true)
        |-- Mapped_Mobile_Device_Type: string (nullable = true)
        |-- Mapped_Browser_Type: string (nullable = true)
        |-- Mapped_Entry_Pages: string (nullable = true)
        |-- Mapped_Site_Section: string (nullable = true)
        |-- Mapped_Promo_Code: string (nullable = true)
        |-- Maped_Product_Name: string (nullable = true)
        |-- Mapped_Search_Term: string (nullable = true)
        |-- Mapped_Product_Collection: string (nullable = true)

We change the name of the label column from Orders_Normalized to label, to be able to train the model.

[In]: data = data.withColumnRenamed('Orders_Normalized', 'label')
[In]: data.printSchema()
[Out]: root
        |-- Visit_Number_Bucket: string (nullable = true)
        |-- Page_Views_Normalized: double (nullable = true)
        |-- label: integer (nullable = true)
        |-- Internal_Search_Successful_Normalized: double (nullable = true)
        |-- Internal_Search_Null_Normalized: double (nullable = true)
        |-- Email_Signup_Normalized: double (nullable = true)
        |-- Total_Seconds_Spent_Normalized: double (nullable = true)
        |-- Store_Locator_Search_Normalized: double (nullable = true)
        |-- Mapped_Last_Touch_Channel: string (nullable = true)
        |-- Mapped_Mobile_Device_Type: string (nullable = true)
        |-- Mapped_Browser_Type: string (nullable = true)
        |-- Mapped_Entry_Pages: string (nullable = true)
        |-- Mapped_Site_Section: string (nullable = true)
        |-- Mapped_Promo_Code: string (nullable = true)
        |-- Maped_Product_Name: string (nullable = true)
        |-- Mapped_Search_Term: string (nullable = true)
        |-- Mapped_Product_Collection: string (nullable = true)

Because we are dealing with both numerical and categorical coluns, we must write a pipeline to create features combinind both for model training. Therefore, we import Pipeline, VectorAssembler, and OneHotEncoder, to create feature vectors. We will also import MultiClassificationEvaluator and MultilayerPerceptron, to check the performance of the model.

from pyspark.ml.feature import OneHotEncoder, VectorAssembler, StringIndexer
from pyspark.ml import Pipeline
from pyspark.sql.functions import udf, StringType
from pyspark.ml.evaluation import MulticlassClassificationEvaluator
from pyspark.ml.classification import MultilayerPerceptronClassifier

Link to GitHub

Split into Train and Test Sets

We now split the data into train, validation, and test sets, for the training of the model.

train, validation, test = data.randomSplit([0.7, 0.2, 0.1], 1234)

Data Preprocessing

We create separate lsits of categorical columns and numeric columns based on datatypes.

categorical_columns = [item[0] for item in data.dtypes if item[1].startswith(
    'string')]
numeric_columns = [item[0] for item in data.dtypes if item[1].startswith(
    'double')]
indexers = [StringIndexer(inputCol=column, outputCol='{0}_index'.format(
    column)) for column in categorical_columns]

We now create consolidated feature vectors, using VectorAssembler:

featuresCreator = VectorAssembler(
    inputCols=[indexer.getOutputCol() for indexer in indexers] + numeric_columns,
    outputCol='features')
layers = [len(featuresCreator.getInputCols()), 4, 2, 2]

Model Building

The next step is to build the MultilayerPerceptron model. One can play around with different hyperparameters, such as number of layers and maxiters, to improve performance of the model.

classifier = MultilayerPerceptronClassifier(labelCol='label',
                                            featuresCol='features',
                                            maxIter=100,
                                            layers=layers,
                                            blockSize=128,
                                            seed=1234)

Now that we have defined every stage, we add all these steps to the pipeline and tun it on the training data.

pipeline = Pipeline(stages=indexers + [featuresCreator, classifier])
model = pipeline.fit(train)

We now calculate the predictions of the model on train, validation and test datasets.

train_output_df = model.transform(train)
validation_output_df = model.transform(validation)
test_output_df = model.transform(test)

train_predictionAndLabels = train_output_df.select('prediction', 'label')
validation_predictionAndLabels = validation_output_df.select('prediction', 'label')
test_predictionAndLabels = test_output_df.select('prediction', 'label')

Model Evaluation

We define three different metrics, to evaluate the performance of the model.

[In]: metrics = ['weightedPrecision', 'weightedRecall', 'accuracy']
[In]: for metric in metrics:
        evaluator = MulticlassClassificationEvaluator(metricName=metric)
        print('Train ' + metric + ' = ' + str(evaluator.evaluate(
            train_predictionAndLabels)))
        print('Validation ' + metric + ' = ' + str(evaluator.evaluate(
            validation_predictionAndLabels)))
        print('Test ' + metric + ' = ' + str(evaluator.evaluate(
            test_predictionAndLabels)))
[Out]: Train weightedPrecision = 0.9722605697126978
[Out]: Validation weightedPrecision = 0.9734944186485901
[Out]: Test weightedPrecision = 0.9710090865749514
[Out]: Train weightedRecall = 0.9718655625913297
[Out]: Validation weightedRecall = 0.9731379731379731
[Out]: Test weightedRecall = 0.9706199460916443
[Out]: Train accuracy = 0.9718655625913297
[Out]: Validation accuracy = 0.9731379731379731
[Out]: Test accuracy = 0.9706199460916443

As we can see, the deep learning model is doing reasonably well on the test data, based on the input signal.

Forem: Leandro Ruiz

ChatGPT en python

Está todo el mundo pidiéndole chistes o haciéndole confundir con acertijos. Pero en esta ocasión vamos a estar embebiendo la IA de moda a un script de python para poder hacer (finalmente) algo útil con ella y sumarla a nuestros proyectos. Pero primero...

¿Qué es ChatGPT?

¿Cómo lo agregamos a nuestro código?

Iniciar sesión con token

Chateando con ChatGPT

¿Cómo guardamos nuestras interacciones en un archivo local?

Almacenando las preguntas y respuestas

Crear listas vacías

Armar una iteración por cada consulta

Guardar las interacciones en una tabla

Exportar la tabla a un archivo local

Probando ChatGPT para desarrollar en python

Conclusión

Conexión a SQL Server con Python

Conectarse a una base de datos SQL

Realizar Queries

Cierre de la conexión

Conclusión

Conéctate a una base de datos de Oracle con Python

Crea una conexión con Python

Crea conexiones autónomas

Crea conexiones agrupadas

Conclusión

Guia rápida sobre Ensemble Learning

Introducción a Ensemble Learning

Diferencias entre hard y soft voting.

Bagging y Pasting

Bagging y Pasting en Scikit-Learn

Conclusión

Fin

Evaluación Out-of-Bag

Matemáticas para Machine Learning

Tabla de Contenidos

Álgebra Lineal

Escalares

Vectores

Matrices

Tensores

Hiperplanos

Operaciones Matemáticas Relevantes

Producto de punto (dot product)

Producto Hadamard (element-wise product)

Producto Tensor (outer product)

Estadística

Probabilidad

Probabilidad vs. Posibilidad

Aun más probabilidad: Bayesianos vs. Frequentistas

Probabilidad Condicional

Teorema de Bayes

Probabilidad Posterior

Distribuciones

Teorema del Limite Central

Muestras vs. Población

Métodos de re-muestreo

Sesgo de Selección

Posibilidad

Recetas para visualización de datos con Seaborn

Gráficos básicos

Pairplots

Conclusión

Usando pipelines para ahorrar tiempo

Existe una forma muy sencilla de ahorrarnos tiempo en la etapa de pre-procesamiento y de ajuste de parámetros para nuestros modelos de aprendizaje automático.

Usando pipelines con Grid Search

Una mejor froma de hacer pipelines

Accediendo a los atributos de los pasos

Accediendo a atributos en una pipeline con Grid Search

Obteniendo pasos de pre-procesamiento con Grid-Search

Usando Grid-Search para saber que modelo usar

Conclusión

Principios Basicos sobre Deep Learning

Primero: neuronas artificiales

Poder de computo con neuronas

El Perceptron

Conclusión

No se nada sobre A/B testing

¿Que es un A/B testing?

¿Cómo se mide?

T-statistic y p-value

Diferencias entre `hard` y `soft` voting.