‘Búsqueda potenciada en el 🤗 Hub’

Búsqueda en 🤗 Hub

La biblioteca huggingface_hub es una interfaz ligera que proporciona un enfoque programático para explorar los puntos finales de alojamiento que Hugging Face proporciona: modelos, conjuntos de datos y Espacios.

Hasta ahora, buscar en el Hub a través de esta interfaz era complicado de lograr, y había muchos aspectos de los que un usuario tenía que “saber” y acostumbrarse.

En este artículo, veremos algunas características nuevas emocionantes agregadas a huggingface_hub para ayudar a reducir esa barrera y proporcionar a los usuarios una API amigable para buscar los modelos y conjuntos de datos que desean usar sin salir de sus interfaces Jupyter o Python.

• El Reformador – Empujando los límites del modelado de lenguaje
• Modelos del Codificador-Decodificador basados en Transformadores
• Portando el sistema de traducción fairseq wmt19 a transformers

Antes de comenzar, si no tiene la última versión de la biblioteca huggingface_hub en su sistema, ejecute la siguiente celda:

!pip install huggingface_hub -U

Situar el problema:

Primero, imaginemos el escenario en el que te encuentras. Te gustaría encontrar todos los modelos alojados en el Hugging Face Hub para la clasificación de texto, que fueron entrenados en el conjunto de datos GLUE y son compatibles con PyTorch.

Tal vez simplemente puedas abrir https://huggingface.co/models y usar los widgets allí. Pero esto requiere salir de tu IDE y escanear esos resultados, todo lo cual requiere unos cuantos clics de botón para obtener la información que necesitas.

¿Y si hubiera una solución a esto sin tener que salir de tu IDE? Con una interfaz programática, también podría ser fácil ver cómo se integra esto en los flujos de trabajo para explorar el Hub.

Aquí es donde entra huggingface_hub.

Para aquellos familiarizados con la biblioteca, es posible que ya sepan que podemos buscar este tipo de modelos. Sin embargo, acertar con la consulta es un proceso doloroso de prueba y error.

¿Podríamos simplificar eso? ¡Vamos a descubrirlo!

Encontrar lo que necesitamos

Primero importaremos HfApi, que es una clase que nos ayuda a interactuar con el alojamiento backend de Hugging Face. Podemos interactuar con los modelos, conjuntos de datos y más a través de ella. Junto con esto, importaremos algunas clases auxiliares: ModelFilter y ModelSearchArguments

from huggingface_hub import HfApi, ModelFilter, ModelSearchArguments

api = HfApi()

Estas dos clases pueden ayudarnos a plantear una solución a nuestro problema anterior. La clase ModelSearchArguments es una especie de espacio de nombres que contiene cada uno de los parámetros válidos que podemos buscar.

Echemos un vistazo:

>>> model_args = ModelSearchArguments()

>>> model_args

Atributos o claves disponibles:
 * author
 * dataset
 * language
 * library
 * license
 * model_name
 * pipeline_tag

Podemos ver una variedad de atributos disponibles para nosotros (más sobre cómo se hace esta magia más adelante). Si categorizáramos lo que queremos, probablemente podríamos separarlos así:

• pipeline_tag (o tarea): Clasificación de texto
• dataset: GLUE
• library: PyTorch

Dada esta separación, tendría sentido encontrarlos dentro de nuestros model_args que hemos declarado:

>>> model_args.pipeline_tag.TextClassification

'text-classification'

>>> model_args.dataset.glue

'dataset:glue'

>>> model_args.library.PyTorch

'pytorch'

Lo que comenzamos a notar es parte de la comodidad que brindamos aquí. ModelSearchArguments (y el complemento DatasetSearchArguments) tienen una interfaz legible por humanos con salidas formateadas que la API quiere, como la forma en que el conjunto de datos GLUE debe buscarse con dataset:glue.

Esto es importante porque sin esta “hoja de trucos” de saber cómo se deben escribir ciertos parámetros, ¡puedes sentarte fácilmente frustrado mientras intentas buscar modelos con la API!

Ahora que sabemos cuáles son los parámetros correctos, podemos buscar fácilmente en la API:

>>> modelos = api.list_models(filter = (
>>>     model_args.pipeline_tag.TextClassification, 
>>>     model_args.dataset.glue, 
>>>     model_args.library.PyTorch)
>>> )
>>> print(len(modelos))

    140

¡Encontramos que había 140 modelos coincidentes que cumplen nuestros criterios! (en el momento de escribir esto). Y si nos acercamos a uno, podemos ver que realmente parece correcto:

>>> modelos[0]

    Información del modelo: {
        modelId: Jiva/xlm-roberta-large-it-mnli
        sha: c6e64469ec4aa17fedbd1b2522256f90a90b5b86
        lastModified: 2021-12-10T14:56:38.000Z
        tags: ['pytorch', 'xlm-roberta', 'text-classification', 'it', 'dataset:multi_nli', 'dataset:glue', 'arxiv:1911.02116', 'transformers', 'tensorflow', 'license:mit', 'zero-shot-classification']
        pipeline_tag: zero-shot-classification
        siblings: [ModelFile(rfilename='.gitattributes'), ModelFile(rfilename='README.md'), ModelFile(rfilename='config.json'), ModelFile(rfilename='pytorch_model.bin'), ModelFile(rfilename='sentencepiece.bpe.model'), ModelFile(rfilename='special_tokens_map.json'), ModelFile(rfilename='tokenizer.json'), ModelFile(rfilename='tokenizer_config.json')]
        config: None
        private: False
        downloads: 680
        library_name: transformers
        likes: 1
    }

Es un poco más legible y no hay que adivinar “¿Acerté con este parámetro?”

¿Sabías que también puedes obtener la información de este modelo programáticamente con su ID de modelo? Así es cómo lo harías:

api.model_info('Jiva/xlm-roberta-large-it-mnli')

Llevándolo a otro nivel

Vimos cómo podemos utilizar los ModelSearchArguments y DatasetSearchArguments para eliminar las conjeturas cuando queremos buscar en el Hub, pero ¿qué pasa si tenemos una consulta muy compleja y desordenada?

Tal como: quiero buscar todos los modelos entrenados tanto para la clasificación de texto como para la clasificación de cero disparo, que fueron entrenados en los conjuntos de datos Multi NLI y GLUE, y son compatibles tanto con PyTorch como con TensorFlow (una consulta más exacta para obtener el modelo anterior).

Para configurar esta consulta, haremos uso de la clase ModelFilter. Está diseñada para manejar este tipo de situaciones, por lo que no necesitamos devanarnos los sesos:

>>> filt = ModelFilter(
>>>     task = ["text-classification", "zero-shot-classification"],
>>>     trained_dataset = [model_args.dataset.multi_nli, model_args.dataset.glue],
>>>     library = ['pytorch', 'tensorflow']
>>> )
>>> api.list_models(filt)

    [Información del modelo: {
         modelId: Jiva/xlm-roberta-large-it-mnli
         sha: c6e64469ec4aa17fedbd1b2522256f90a90b5b86
         lastModified: 2021-12-10T14:56:38.000Z
         tags: ['pytorch', 'xlm-roberta', 'text-classification', 'it', 'dataset:multi_nli', 'dataset:glue', 'arxiv:1911.02116', 'transformers', 'tensorflow', 'license:mit', 'zero-shot-classification']
         pipeline_tag: zero-shot-classification
         siblings: [ModelFile(rfilename='.gitattributes'), ModelFile(rfilename='README.md'), ModelFile(rfilename='config.json'), ModelFile(rfilename='pytorch_model.bin'), ModelFile(rfilename='sentencepiece.bpe.model'), ModelFile(rfilename='special_tokens_map.json'), ModelFile(rfilename='tokenizer.json'), ModelFile(rfilename='tokenizer_config.json')]
         config: None
         private: False
         downloads: 680
         library_name: transformers
         likes: 1
     }]

Muy rápidamente vemos que es un enfoque mucho más coordinado para buscar a través de la API, ¡sin ninguna complicación adicional para ti!

¿Qué es la magia?

Muy brevemente hablaremos sobre la magia subyacente que nos da este tipo de datos similar a un diccionario enumerado, el AttributeDictionary.

En gran medida inspirado en la clase AttrDict de la biblioteca fastcore, la idea general es tomar un diccionario normal y potenciarlo para la programación exploratoria al proporcionar autocompletado para cada clave en el diccionario.

Como vimos antes, esto se vuelve aún más fuerte cuando tenemos diccionarios anidados por los que podemos explorar, ¡como model_args.dataset.glue!

Para aquellos familiarizados con JavaScript, imitamos cómo funciona la clase object.

Esta sencilla clase de utilidad puede ofrecer una experiencia mucho más centrada en el usuario al explorar tipos de datos anidados e intentar comprender qué hay allí, ¡como el resultado de una solicitud a la API!

Como se mencionó anteriormente, ampliamos el AttrDict de algunas formas clave:

• Puedes eliminar claves con del model_args[key] o con del model_args.key
• Esa representación limpia __repr__ que vimos antes

No obstante, un concepto muy importante a tener en cuenta es que si una clave contiene un número o un carácter especial, debe indexarse como un diccionario, y no como un objeto.

>>> from huggingface_hub.utils.endpoint_helpers import AttributeDictionary

Un ejemplo muy breve de esto es si tenemos un AttributeDictionary con una clave de 3_c:

>>> d = {"a":2, "b":3, "3_c":4}
>>> ad = AttributeDictionary(d)

>>> # Como un atributo
>>> ad.3_c

 File "<ipython-input-6-c0fe109cf75d>", line 2
    ad.3_c
        ^
SyntaxError: símbolo inválido

>>> # Como una clave de diccionario
>>> ad["3_c"]

4

Pensamientos finales

Espero que en este momento tengas una breve comprensión de cómo esta nueva API de búsqueda puede afectar directamente tu flujo de trabajo y exploración del Hub. Junto con esto, quizás conozcas un lugar en tu código donde el AttributeDictionary podría ser útil para ti.

A partir de aquí, asegúrate de consultar la documentación oficial sobre Cómo buscar en el Hub de manera eficiente ¡y no olvides darnos una estrella!

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