Machine learning Sacred: Mejore su flujo de trabajo

La afinación del modelo es mi tarea menos favorita como científico de datos. Yo lo odio . Creo que es porque administrar los experimentos es algo que siempre resulta muy complicado. Mientras buscaba herramientas para ayudarme, vi a mucha gente mencionar Sacred así que decidí intentarlo.

En este artículo, veremos cómo usarlo. Machine learning Sacred y Omniboard para gestionar nuestros experimentos. Alerta de spoiler: la herramienta es impresionante y construir experimentos es realmente divertido.

¿Cómo funciona Machine learning Sacred?

Usamos decoradores sagrados en nuestro modelo de guión de entrenamiento. ¡Eso es! La herramienta almacena automáticamente información sobre el experimento para cada ejecución. Hoy almacenaremos la información utilizando MongoDB y la visualizaremos utilizando la herramienta Omniboard. Ok, comencemos.

Usando SAGRADO

Aquí hay una guía paso a paso:

1. Crea un experimento
2. Define la función principal del experimento
3. Agrega los parámetros de configuración
4. Añade otras métricas
5. Ejecutar el experimento

1 – Crear un experimento

Primero necesitamos crear un experimento. Es muy simple:

from sacred import Experiment
ex = Experiment("our_experiment")

Listo!

2 – Define la función principal del experimento

El método de ejecución ejecuta la función principal del experimento. El decorador @ ex.automain define y ejecuta la función principal del experimento cuando ejecutamos el script de Python.

Es equivalente a:

from sacred import Experimentex = Experiment("our_experiment")@ex.main
def run():
    pass

if __name__ == '__main__':
    ex.run_commandline()

Usemos @ ex.automain en su lugar:

from sacred import Experiment

ex = Experiment("our_experiment")

@ex.automain
def run():
    pass

3 – Agregue los parámetros de configuración

Los parámetros de configuración también se almacenan en la base de datos para cada ejecución. Hay muchas maneras de configurarlos: a través de Config Scopes Dictionaries y Config Files . Sigamos con el alcance de configuración aquí.

Usaremos este Online Retail Dataset y utilizaremos el validador cruzado de series de tiempo de scikit-learn para dividir los datos. El modelo predecirá si un pedido será cancelado o no. Definamos el parámetro de criterio:

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import TimeSeriesSplit
import pandas as pd
from sacred import Experiment 

ex = Experiment('online_retail_tree') @ex.config

def cfg():    
    criterion = "entropy" 
@ex.automain
def run(criterion):    
    dateparse = lambda x: pd.datetime.strptime(x, '%d/%m/%Y %H:%M')    

df = pd.read_csv("Online Retail.csv", parse_dates["InvoiceDate"], date_parser=dateparse, decimal=",")    
df = df.sort_values(by="InvoiceDate")        

df["canceled"] = df["InvoiceNo"].apply(lambda x: x[0] == "C")
    X = df.loc[:,["Quantity","UnitPrice"]]    
    y = df.loc[:, ["canceled"]]         

    ts_split = TimeSeriesSplit(n_splits=10)     
    
    clf = DecisionTreeClassifier(criterion=criterion)  
   
    for train_index, test_index in ts_split.split(X):        
        X_train = X.iloc[train_index]        
        y_train = y.iloc[train_index]                 
        
        X_test = X.iloc[test_index]        
        y_test = y.iloc[test_index]                 
        
        clf.fit(X_train, y_train.values.ravel())         
        y_pred = clf.predict(X_test)

4 – Agregando otras métricas

Lo sagrado recopila información sobre los experimentos, pero usualmente También quiero medir otras cosas. En nuestro caso, aquí quiero saber el número de pedidos cancelados en cada división . Podemos usar la API de Métricas para eso.

Machine learning Sacred admite el seguimiento de series numéricas (por ejemplo, int, float) usando la API de Métricas. El método _run.log_scalar (metric_name, value, step) toma un nombre de métrica (por ejemplo, “training.loss”), el valor medido y el paso de iteración en el que se tomó el valor. Si no se especifica ningún paso, se configura un contador que se incrementa en uno automáticamente para cada métrica. – Métricas API

from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import TimeSeriesSplit
import pandas as pd

from sacred import Experiment

ex = Experiment('online_retail_tree')

@ex.config
def cfg():    
    criterion = "entropy"

@ex.automain
def run(criterion):    
    dateparse = lambda x: pd.datetime.strptime(x, '%d/%m/%Y %H:%M')    

df = pd.read_csv("Online Retail.csv", parse_dates["InvoiceDate"], date_parser=dateparse, decimal=",")    

df = df.sort_values(by="InvoiceDate")    

df["canceled"] = df["InvoiceNo"].apply(lambda x: x[0] == "C")    

    X = df.loc[:,["Quantity","UnitPrice"]]    
    y = df.loc[:, ["canceled"]]    ts_split = TimeSeriesSplit(n_splits=10)     
    
    clf = DecisionTreeClassifier(criterion=criterion)  
   
    for train_index, test_index in ts_split.split(X):        
        X_train = X.iloc[train_index]        
        y_train = y.iloc[train_index]        
     
        X_test = X.iloc[test_index]        
        y_test = y.iloc[test_index]
     
        clf.fit(X_train, y_train.values.ravel())         
        y_pred = clf.predict(X_test)5 — Running the experiment
       
       true_cancel_count = y_test["canceled"].value_counts().tolist()[1]  
           
       pred_cancel_count = y_pred.tolist().count(True)  
      
       train_cancel_count = y_train["canceled"].value_counts().tolist()[1]     
       
       ex.log_scalar("true_cancel_count", true_cancel_count)
       ex.log_scalar("pred_cancel_count", pred_cancel_count)
       ex.log_scalar("train_cancel_orders", train_cancel_count)

5 – Ejecutando el experimento

Usaremos MongoDB Observer para almacenar la información sobre el experimento:

Sacred te ayuda brindando un Interfaz de observador para tus experimentos. Al adjuntar un observador, puede recopilar toda la información acerca de la ejecución incluso cuando todavía se está ejecutando. – Observando un experimento

Para guardar los datos en una base de datos de mongo llamada my_database, simplemente ejecutamos python3 my_experiment.py -m my_database.

Ahora hay datos sobre el experimento, pero ahora necesitamos visualizarlo. Usaremos Omniboard para eso.

Machine learning Sacred usando OMNIBOARD

Omniboard es un panel para Machine learning Sacred escrito con React, Node.js, Express y Bootstrap.

Para instalarlo, ejecute npm install -g omniboard y para comenzar, ejecutamos omniboard -m hostname: port: database, en nuestro caso: omniboard -m localhost: 27017: my_database.

Podemos ver si un experimento falló o no, la duración del experimento, agregue notas, etc.

La vista detallada muestra un gráfico con las métricas que rastreamos y también podemos ver la salida de la línea de comandos, el código fuente (impresionante) y otros detalles del experimento

¿Y qué?

Sagrado es una gran herramienta porque ahora no tenemos que preocuparnos por guardar los resultados de nuestros experimentos . Todo se almacena automáticamente y podemos retroceder y analizar cualquier experimento .

La herramienta fue diseñada para introducir una sobrecarga mínima y en mi opinión, eso es lo que lo hace genial.

El mensaje principal aquí es: ¡prueba Machine learning Sacred! Puedo decir que mi flujo de trabajo es mucho mejor ahora por eso. 🙂

¿Utiliza otra herramienta para el mismo propósito? Me gustaría escuchar acerca de otras alternativas también. ¡Y gracias por leer!