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:

  • 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!

Share:

Was this article helpful?

93 out of 132 found this helpful

Discover more

Inteligencia Artificial

Dentro de Code Llama La entrada de Meta AI en el espacio de Code LLM

La codificación se ha convertido rápidamente en uno de los escenarios de acción más activos para los grandes modelos ...

Inteligencia Artificial

Los autos sin conductor pueden tener dificultades para detectar a los niños y a las personas de piel oscura.

Los científicos evaluaron ocho detectores de peatones basados en inteligencia artificial utilizados en la investigaci...

Inteligencia Artificial

Uso de Computadoras Analógicas en Inteligencia Artificial (IA)

Las Computadoras Analógicas son una clase de dispositivos en los cuales las cantidades físicas como el voltaje eléctr...