Presentando Skops

'Skops' introduction.

Presentando Skops

En Hugging Face, estamos trabajando en abordar diversos problemas en el aprendizaje automático de código abierto, incluyendo, alojar modelos de forma segura y abierta, permitir la reproducibilidad, explicabilidad y colaboración. ¡Estamos emocionados de presentarte nuestra nueva biblioteca: Skops! Con Skops, puedes alojar tus modelos de scikit-learn en el Hugging Face Hub, crear tarjetas de modelo para la documentación del modelo y colaborar con otros.

Vamos a ver un ejemplo completo: primero entrenemos un modelo y veamos paso a paso cómo aprovechar Skops para sklearn en producción.

# importemos primero las bibliotecas
import sklearn
from sklearn.datasets import load_breast_cancer
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# Cargamos los datos y los dividimos
X, y = load_breast_cancer(as_frame=True, return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

# Entrenamos el modelo
modelo = DecisionTreeClassifier().fit(X_train, y_train)

Puedes utilizar cualquier nombre de archivo de modelo y método de serialización, como pickle o joblib. En este momento, nuestro backend utiliza joblib para cargar el modelo. hub_utils.init crea una carpeta local que contiene el modelo en la ruta especificada, y el archivo de configuración que contiene las especificaciones del entorno en el que se entrenó el modelo. Los datos y la tarea que se pasan a init ayudarán a Hugging Face Hub a habilitar el widget de inferencia en la página del modelo, así como las características de descubrimiento para encontrar el modelo.

from skops import hub_utils
import pickle

# guardemos el modelo
ruta_modelo = "ejemplo.pkl"
repositorio_local = "mi-modelo-asombroso"
with open(ruta_modelo, mode="bw") as f:
    pickle.dump(modelo, file=f)

# ahora vamos a inicializar un repositorio local
hub_utils.init(
    model=ruta_modelo, 
    requirements=[f"scikit-learn={sklearn.__version__}"], 
    dst=repositorio_local,
    task="clasificación-tabular",
    data=X_test,
)

El repositorio ahora contiene el modelo serializado y el archivo de configuración. La configuración contiene lo siguiente:

• Inmersión Profunda Vision Transformers en Hugging Face Optimum Graphcore
• OpenRAIL Hacia marcos de licencias de IA abiertos y responsables
• Entrena tu primer Decision Transformer

• características del modelo,
• los requisitos del modelo,
• un ejemplo de entrada tomado de X_test que hemos pasado,
• nombre del archivo del modelo,
• nombre de la tarea que se va a resolver aquí.

Ahora vamos a crear la tarjeta del modelo. La tarjeta debe tener el formato esperado por Hugging Face Hub: una parte en formato markdown y una sección de metadatos, que es una sección yaml en la parte superior. Las claves de la sección de metadatos se definen aquí y se utilizan para el descubrimiento de los modelos. El contenido de la tarjeta del modelo se determina mediante una plantilla que tiene una:

• sección yaml en la parte superior para los metadatos (por ejemplo, licencia del modelo, nombre de la biblioteca, y más)
• sección markdown con texto libre y secciones que se deben completar (por ejemplo, descripción simple del modelo). Las siguientes secciones se extraen mediante skops para completar la tarjeta del modelo:
• hiperparámetros del modelo,
• diagrama interactivo del modelo,
• Para los metadatos, se completan el nombre de la biblioteca, el identificador de la tarea (por ejemplo, clasificación-tabular) y la información requerida por el widget de inferencia.

A continuación, te guiaremos sobre cómo pasar información de forma programática para completar la tarjeta del modelo. Puedes consultar nuestra documentación sobre la plantilla predeterminada proporcionada por skops, y sus secciones aquí para ver qué espera la plantilla y cómo se ve aquí.

Puedes crear la tarjeta del modelo instanciando la clase Card de skops. Durante la serialización del modelo, el nombre de la tarea y el nombre de la biblioteca se escriben en el archivo de configuración. Esta información también se necesita en los metadatos de la tarjeta, por lo que puedes utilizar el método metadata_from_config para extraer los metadatos del archivo de configuración y pasarlos a la tarjeta al crearla. Puedes agregar información y metadatos utilizando add.

from skops import card

# creamos la tarjeta
tarjeta_modelo = card.Card(modelo, metadata=card.metadata_from_config(Path(carpeta_destino)))

limitaciones = "Este modelo no está listo para ser utilizado en producción."
descripcion_modelo = "Este es un modelo DecisionTreeClassifier entrenado en el conjunto de datos de cáncer de mama."
autores_tarjeta_modelo = "usuario_skops"
codigo_inicio = "import pickle \nwith open(nombre_archivo_dtc_pkl, 'rb') as archivo: \n    clf = pickle.load(archivo)"
cita_bibtex = "bibtex\n@inproceedings{...,año={2020}}"

# podemos agregar la información usando add
tarjeta_modelo.add(
    citation_bibtex=cita_bibtex,
    get_started_code=codigo_inicio,
    model_card_authors=autores_tarjeta_modelo,
    limitations=limitaciones,
    model_description=descripcion_modelo,
)

# podemos establecer directamente la parte de metadatos
tarjeta_modelo.metadata.license = "mit"

Ahora evaluaremos el modelo y agregaremos una descripción del método de evaluación con add. Las métricas se agregan con add_metrics, que se convertirán en una tabla.

from sklearn.metrics import (ConfusionMatrixDisplay, confusion_matrix,
                            accuracy_score, f1_score)
# hagamos una predicción y evaluemos el modelo
y_pred = model.predict(X_test)
# podemos pasar métricas usando add_metrics y pasar detalles con add
model_card.add(eval_method="El modelo se evalúa utilizando la división de prueba, en precisión y puntaje F1 con promedio macro.")
model_card.add_metrics(accuracy=accuracy_score(y_test, y_pred))
model_card.add_metrics(**{"puntaje F1": f1_score(y_test, y_pred, average="micro")})

También podemos agregar cualquier gráfico de nuestra elección a la tarjeta usando add_plot como se muestra a continuación.

import matplotlib.pyplot as plt
from pathlib import Path
# crearemos una matriz de confusión
cm = confusion_matrix(y_test, y_pred, labels=model.classes_)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=model.classes_)
disp.plot()

# guardamos el gráfico
plt.savefig(Path(local_repo) / "confusion_matrix.png")

# el gráfico se escribirá en la tarjeta del modelo con el nombre confusion_matrix
# pasamos la ruta del gráfico en sí
model_card.add_plot(confusion_matrix="confusion_matrix.png")

Guardemos la tarjeta del modelo en el repositorio local. El nombre del archivo aquí debería ser README.md ya que eso es lo que espera Hugging Face Hub.

model_card.save(Path(local_repo) / "README.md")

Ahora podemos enviar el repositorio a Hugging Face Hub. Para esto, usaremos push de hub_utils. Hugging Face Hub requiere tokens de autenticación, por lo tanto, debes pasar tu token en notebook_login si inicias sesión desde un cuaderno, o huggingface-cli login si inicias sesión desde la CLI.

# si el repositorio no existe en Hugging Face Hub, se creará cuando establezcamos create_remote en True
repo_id = "skops-user/my-awesome-model"
hub_utils.push(
    repo_id=repo_id,
    source=local_repo,
    token=token,
    commit_message="¡enviando archivos al repositorio desde el ejemplo!",
    create_remote=True,
)

Una vez que enviamos el modelo al Hub, cualquier persona puede usarlo a menos que el repositorio sea privado. Puedes descargar los modelos usando download. Además del archivo del modelo, el repositorio contiene la configuración del modelo y los requisitos del entorno.

download_repo = "modelo-descargado"
hub_utils.download(repo_id=repo_id, dst=download_repo)

El widget de inferencia está habilitado para hacer predicciones en el repositorio.

Si los requisitos de tu proyecto han cambiado, puedes usar update_env para actualizar el entorno.

hub_utils.update_env(path=local_repo, requirements=["scikit-learn"])

Puedes ver el repositorio de ejemplo enviado con el código anterior aquí. Hemos preparado dos ejemplos para mostrar cómo guardar tus modelos y usar las utilidades de la tarjeta del modelo. Puedes encontrarlos en la sección de recursos a continuación.

Recursos

• Tutorial de tarjeta de modelo
• Tutorial de hub_utils
• Documentación de skops

We will continue to update Zepes; if you have any questions or suggestions, please contact us!