Pipeline Hugging Face

The Snowflake Model Registry supports any Hugging Face model defined as transformers that can be loaded using transformers.Pipeline.

Utilisez l’une des méthodes suivantes pour connecter un modèle Hugging Face au registre des modèles :

  1. Importation et déploiement d’un modèle depuis Hugging Face et connexion du modèle au registre des modèles à partir de l’UI

  2. Utilisation de la classe``snowflake.ml.model.models.huggingface.TransformersPipeline``, vous pouvez connecter un modèle depuis Hugging Face vers un registre des modèles

    from snowflake.ml.model.models import huggingface

model = huggingface.TransformersPipeline(
    task="text-classification",
    model="ProsusAI/finbert",
    # compute_pool_for_log=... # Optional
)

mv = reg.log_model(model, model_name='finbert', version_name='v5')
    Copy

    Important

    • Si vous ne spécifiez pas un argument compute_pool_for_log, le modèle est enregistré en utilisant le pool de calcul CPU par défaut.

    • Si vous spécifiez un argument compute_pool_for_log, le modèle est enregistré en utilisant le pool de calcul spécifié.

    • Si vous spécifiez l’argument compute_pool_for_log sur Aucun, les fichiers de modèle sont téléchargés localement, puis chargés dans le registre des modèles. Cela nécessite d’installer Huggingface-hub.

  3. Chargement du modèle à partir de Hugging Face en mémoire et connexion au registre des modèles

    lm_hf_model = transformers.pipeline(
    task="text-generation",
    model="bigscience/bloom-560m",
    token="...",  # Put your HuggingFace token here.
    return_full_text=False,
    max_new_tokens=100,
)

lmv = reg.log_model(lm_hf_model, model_name='bloom', version_name='v560m')
    Copy

Lors de l’appel de log_model, le dictionnaire options prend en charge les éléments suivants :

Option

Description

target_methods

Une liste des noms des méthodes disponibles sur l’objet modèle. Les Hugging Facemodels ont les méthodes cibles suivantes par défaut, en supposant que la méthode existe : __call__.

cuda_version

La version de l’environnement d’exécution CUDA à utiliser lors du déploiement sur une plateforme avec un GPU ; la valeur par défaut est 12.4. S’il est défini manuellement sur None, le modèle ne peut pas être déployé sur une plateforme ayant un GPU.

Le registre déduit l’argument signatures si le pipeline contient une tâche de la liste suivante :

  • fill-mask

  • question-answering

  • summarization

  • table-question-answering

  • text2text-generation

  • text-classification (également appelé sentiment-analysis)

  • text-generation

  • token-classification (également appelé ner)

  • translation

  • translation_xx_to_yy

  • zero-shot-classification

The sample_input_data argument to log_model is completely ignored for Hugging Face models. Specify the signatures argument when logging a Hugging Face model that is not in the preceding list so that the registry knows the signatures of the target methods.

To see the inferred signature, use the show_functions method. The following dictionary is the result of the lmv.show_functions() method, where lmv is the model logged above:

{'name': '__CALL__',
  'target_method': '__call__',
  'signature': ModelSignature(
                      inputs=[
                          FeatureSpec(dtype=DataType.STRING, name='inputs')
                      ],
                      outputs=[
                          FeatureSpec(dtype=DataType.STRING, name='outputs')
                      ]
                  )}]
Copy

Utilisez le code suivant pour appeler le modèle lmv :

import pandas as pd
remote_prediction = lmv.run(pd.DataFrame(["Hello, how are you?"], columns=["inputs"]))
Copy

Notes sur l’utilisation

  • De nombreux modèles de visages étreints sont de grande taille et ne rentrent pas dans un entrepôt standard. Utilisez un entrepôt optimisé pour Snowpark ou choisissez une version plus petite du modèle. Par exemple, au lieu d’utiliser le modèle Llama-2-70b-chat-hf , essayez Llama-2-7b-chat-hf.

  • Les entrepôts Snowflake n’ont pas de GPUs. N’utilisez que des modèles Hugging Face optimisés CPU.

  • Certains transformateurs Hugging Face renvoient un tableau de dictionnaires par ligne d’entrée. Le registre convertit le tableau de dictionnaires en une chaîne contenant une représentation JSON du tableau. Par exemple, la sortie questions-réponses multi-sorties se présente comme suit :

    '[{"score": 0.61094731092453, "start": 139, "end": 178, "answer": "learn more about the world of athletics"},
{"score": 0.17750297486782074, "start": 139, "end": 180, "answer": "learn more about the world of athletics.\""}]'
    Copy

Exemple

# Prepare model
import transformers
import pandas as pd

finbert_model = transformers.pipeline(
    task="text-classification",
    model="ProsusAI/finbert",
    top_k=2,
)

# Log the model
mv = registry.log_model(
    finbert_model,
    model_name="finbert",
    version_name="v1",
)

# Use the model
mv.run(pd.DataFrame(
        [
            ["I have a problem with my Snowflake that needs to be resolved asap!!", ""],
            ["I would like to have udon for today's dinner.", ""],
        ]
    )
)
Copy

Résultat :

0  [{"label": "negative", "score": 0.8106237053871155}, {"label": "neutral", "score": 0.16587384045124054}]
1  [{"label": "neutral", "score": 0.9263970851898193}, {"label": "positive", "score": 0.05286872014403343}]
Copy

Signatures déduites pour les pipelines Hugging Face

Snowflake Model Registry déduit automatiquement les signatures des pipelines Hugging Face contenant une seule tâche à partir de la liste suivante :

  • fill-mask

  • question-answering

  • summarization

  • table-question-answering

  • text2text-generation

  • text-classification (alias sentiment-analysis)

  • text-generation

  • token-classification (alias ner)

  • translation

  • translation_xx_to_yy

  • zero-shot-classification

Cette section décrit les signatures de ces types de pipelines Hugging Face, y compris une description et un exemple des entrées requises et des sorties attendues. Toutes les entrées et les sorties sont des DataFrames Snowpark.

Pipeline Fill-mask

Un pipeline dont la tâche est « fill-mask » a les entrées et sorties suivantes.

Entrées

  • inputs : une chaîne où il y a un masque à remplir.

Exemple :

--------------------------------------------------
|"inputs"                                        |
--------------------------------------------------
|LynYuu is the [MASK] of the Grand Duchy of Yu.  |
--------------------------------------------------

Sorties

  • outputs : une chaîne contenant une représentation JSON d’une liste d’objets de résultat, chacun pouvant contenir des clés telles que score, token, token_str, ou sequence. Pour plus de détails, voir FillMaskPipeline.

Exemple :

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"outputs"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|[{"score": 0.9066258072853088, "token": 3007, "token_str": "capital", "sequence": "lynyuu is the capital of the grand duchy of yu."}, {"score": 0.08162177354097366, "token": 2835, "token_str": "seat", "sequence": "lynyuu is the seat of the grand duchy of yu."}, {"score": 0.0012052370002493262, "token": 4075, "token_str": "headquarters", "sequence": "lynyuu is the headquarters of the grand duchy of yu."}, {"score": 0.0006560495239682496, "token": 2171, "token_str": "name", "sequence": "lynyuu is the name of the grand duchy of yu."}, {"score": 0.0005427763098850846, "token": 3200, "token_str"...  |
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Classification de jetons

Un pipeline dont la tâche est « ner » ou « token-classification » a les entrées et sorties suivantes.

Entrées

  • inputs : une chaîne contenant les jetons à classer.

Exemple :

------------------------------------------------
|"inputs"                                      |
------------------------------------------------
|My name is Izumi and I live in Tokyo, Japan.  |
------------------------------------------------

Sorties

  • outputs : une chaîne contenant une représentation JSON d’une liste d’objets de résultat, chacun pouvant contenir des clés telles que entity, score, index, word, name, start, ou end. Pour plus de détails, voir TokenClassificationPipeline.

Exemple :

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"outputs"                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|[{"entity": "PRON", "score": 0.9994392991065979, "index": 1, "word": "my", "start": 0, "end": 2}, {"entity": "NOUN", "score": 0.9968984127044678, "index": 2, "word": "name", "start": 3, "end": 7}, {"entity": "AUX", "score": 0.9937735199928284, "index": 3, "word": "is", "start": 8, "end": 10}, {"entity": "PROPN", "score": 0.9928083419799805, "index": 4, "word": "i", "start": 11, "end": 12}, {"entity": "PROPN", "score": 0.997334361076355, "index": 5, "word": "##zumi", "start": 12, "end": 16}, {"entity": "CCONJ", "score": 0.999173104763031, "index": 6, "word": "and", "start": 17, "end": 20}, {...  |

Réponse aux questions (sortie unique)

Un pipeline dont la tâche est « question-answering », où top_k est soit non défini, soit défini sur 1, a les entrées et sorties suivantes.

Entrées

  • question : une chaîne contenant la question à laquelle il faut répondre.

  • context : une chaîne qui peut contenir la réponse.

Exemple :

-----------------------------------------------------------------------------------
|"question"                  |"context"                                           |
-----------------------------------------------------------------------------------
|What did Doris want to do?  |Doris is a cheerful mermaid from the ocean dept...  |
-----------------------------------------------------------------------------------

Sorties

  • score : score de confiance en virgule flottante comprise entre 0,0 et 1,0.

  • start : indice entier du premier jeton de la réponse dans le contexte.

  • end : indice entier du dernier jeton de la réponse dans le contexte original.

  • answer : une chaîne contenant la réponse trouvée.

Exemple :

--------------------------------------------------------------------------------
|"score"           |"start"  |"end"  |"answer"                                 |
--------------------------------------------------------------------------------
|0.61094731092453  |139      |178    |learn more about the world of athletics  |
--------------------------------------------------------------------------------

Réponse aux questions (sorties multiples)

Un pipeline dont la tâche est « question-answering », où top_k est défini et est supérieur à 1, a les entrées et sorties suivantes.

Entrées

  • question : une chaîne contenant la question à laquelle il faut répondre.

  • context : une chaîne qui peut contenir la réponse.

Exemple :

-----------------------------------------------------------------------------------
|"question"                  |"context"                                           |
-----------------------------------------------------------------------------------
|What did Doris want to do?  |Doris is a cheerful mermaid from the ocean dept...  |
-----------------------------------------------------------------------------------

Sorties

  • outputs : une chaîne contenant une représentation JSON d’une liste d’objets de résultat, chacun pouvant contenir des clés telles que score, start, end, ou answer.

Exemple :

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"outputs"                                                                                                                                                                                                                                                                                                                                        |
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|[{"score": 0.61094731092453, "start": 139, "end": 178, "answer": "learn more about the world of athletics"}, {"score": 0.17750297486782074, "start": 139, "end": 180, "answer": "learn more about the world of athletics.\""}, {"score": 0.06438097357749939, "start": 138, "end": 178, "answer": "\"learn more about the world of athletics"}]  |
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Synthétisation

Un pipeline dont la tâche est « summarization », où return_tensors est False ou unset, a les entrées et sorties suivantes.

Entrées

  • documents : une chaîne contenant le texte à résumer.

Exemple :

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"documents"                                                                                                                                                                                               |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|Neuro-sama is a chatbot styled after a female VTuber that hosts live streams on the Twitch channel "vedal987". Her speech and personality are generated by an artificial intelligence (AI) system  wh...  |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Sorties

  • summary_text : une chaîne contenant soit le résumé généré, soit, si num_return_sequences est supérieur à 1, une chaîne contenant une représentation JSON d’une liste de résultats, chaque dictionnaire contenant des champs incluant summary_text.

Exemple :

---------------------------------------------------------------------------------
|"summary_text"                                                                 |
---------------------------------------------------------------------------------
| Neuro-sama is a chatbot styled after a female VTuber that hosts live streams  |
---------------------------------------------------------------------------------

Réponse aux questions sur les tables

Un pipeline dont la tâche est « table-question-answering » a les entrées et sorties suivantes.

Entrées

  • query : une chaîne contenant la question à laquelle il faut répondre.

  • table : une chaîne contenant un dictionnaire sérialisé JSON sous la forme {column -> [values]} représentant la table pouvant contenir une réponse.

Exemple :

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"query"                                  |"table"                                                                                                                                                                                                                                                   |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|Which channel has the most subscribers?  |{"Channel": ["A.I.Channel", "Kaguya Luna", "Mirai Akari", "Siro"], "Subscribers": ["3,020,000", "872,000", "694,000", "660,000"], "Videos": ["1,200", "113", "639", "1,300"], "Created At": ["Jun 30 2016", "Dec 4 2017", "Feb 28 2014", "Jun 23 2017"]}  |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Sorties

  • answer : une chaîne contenant une réponse possible.

  • coordinates : une liste d’entiers représentant les coordonnées des cellules où se trouve la réponse.

  • cells : une liste de chaînes contenant le contenu des cellules où se trouve la réponse.

  • aggregator : une chaîne contenant le nom de l’agrégateur utilisé.

Exemple :

----------------------------------------------------------------
|"answer"     |"coordinates"  |"cells"          |"aggregator"  |
----------------------------------------------------------------
|A.I.Channel  |[              |[                |NONE          |
|             |  [            |  "A.I.Channel"  |              |
|             |    0,         |]                |              |
|             |    0          |                 |              |
|             |  ]            |                 |              |
|             |]              |                 |              |
----------------------------------------------------------------

Classification de textes (sortie unique)

Un pipeline dont la tâche est « text-clasification » ou « sentiment-analysis », où top_k n’est pas défini ou est « None », a les entrées et sorties suivantes.

Entrées

  • text : une chaîne à classer.

  • text_pair : une chaîne à classer avec text, utilisée avec les modèles qui calculent la similarité des textes. Laissez vide si le modèle ne l’utilise pas.

Exemple :

----------------------------------
|"text"       |"text_pair"       |
----------------------------------
|I like you.  |I love you, too.  |
----------------------------------

Sorties

  • label : une chaîne représentant le libellé de classification du texte.

  • score : un score de confiance en virgule flottante compris entre 0,0 et 1,0.

Exemple :

--------------------------------
|"label"  |"score"             |
--------------------------------
|LABEL_0  |0.9760091304779053  |
--------------------------------

Classification de textes (sorties multiples)

Un pipeline dont la tâche est « text-clasification » ou « sentiment-analysis », où top_k est défini comme un nombre, a les entrées et sorties suivantes.

Note

Une tâche de classification de texte est considérée comme à sorties multiples si top_k est défini comme un nombre quelconque, même si ce nombre est 1. Pour obtenir une sortie unique, utilisez la valeur None pour top_k.

Entrées

  • text : une chaîne à classer.

  • text_pair : une chaîne à classer avec text, utilisée avec les modèles qui calculent la similarité des textes. Laissez vide si le modèle ne l’utilise pas.

Exemple :

--------------------------------------------------------------------
|"text"                                              |"text_pair"  |
--------------------------------------------------------------------
|I am wondering if I should have udon or rice fo...  |             |
--------------------------------------------------------------------

Sorties

  • outputs : une chaîne contenant une représentation JSON d’une liste de résultats, dont chacun contient des champs comprenant label et score.

Exemple :

--------------------------------------------------------
|"outputs"                                             |
--------------------------------------------------------
|[{"label": "NEGATIVE", "score": 0.9987024068832397}]  |
--------------------------------------------------------

Génération de texte

Un pipeline dont la tâche est « text-generation », où return_tensors est False ou non défini, a les entrées et sorties suivantes.

Note

Les pipelines de génération de texte pour lesquels return_tensors est True ne sont pas pris en charge.

Entrées

  • inputs : une chaîne qui contient une invite.

Exemple :

--------------------------------------------------------------------------------
|"inputs"                                                                      |
--------------------------------------------------------------------------------
|A descendant of the Lost City of Atlantis, who swam to Earth while saying, "  |
--------------------------------------------------------------------------------

Sorties

  • outputs : une chaîne contenant une représentation JSON d’une liste d’objets de résultats, chacun d’entre eux contenant des champs dont generated_text.

Exemple :

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"outputs"                                                                                                                                                                                                 |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|[{"generated_text": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, \"For my life, I don't know if I'm gonna land upon Earth.\"\n\nIn \"The Misfits\", in a flashback, wh...  |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Génération de texte à texte

Un pipeline dont la tâche est « text2text-generation », où return_tensors est False ou non défini, a les entrées et sorties suivantes.

Note

Les pipelines de génération de texte à texte où return_tensors est True ne sont pas pris en charge.

Entrées

  • inputs : une chaîne qui contient une invite.

Exemple :

--------------------------------------------------------------------------------
|"inputs"                                                                      |
--------------------------------------------------------------------------------
|A descendant of the Lost City of Atlantis, who swam to Earth while saying, "  |
--------------------------------------------------------------------------------

Sorties

  • generated_text : une chaîne contenant le texte généré si num_return_sequences vaut 1, ou si num_return_sequences est supérieur à 1, une représentation sous forme de chaîne d’une liste JSON de dictionnaires de résultats contenant des champs incluant generated_text.

Exemple :

----------------------------------------------------------------
|"generated_text"                                              |
----------------------------------------------------------------
|, said that he was a descendant of the Lost City of Atlantis  |
----------------------------------------------------------------

Génération de traductions

Un pipeline dont la tâche est « translation », où return_tensors est False ou unset, a les entrées et sorties suivantes.

Note

Les pipelines de génération de traductions pour lesquels return_tensors est True ne sont pas pris en charge.

Entrées

  • inputs : une chaîne contenant le texte à traduire.

Exemple :

------------------------------------------------------------------------------------------------------
|"inputs"                                                                                            |
------------------------------------------------------------------------------------------------------
|Snowflake's Data Cloud is powered by an advanced data platform provided as a self-managed service.  |
------------------------------------------------------------------------------------------------------

Sorties

  • translation_text : une chaîne représentant la traduction générée si num_return_sequences est 1, ou une chaîne représentant une liste JSON de dictionnaires de résultats, chacun contenant des champs incluant translation_text.

Exemple :

---------------------------------------------------------------------------------------------------------------------------------
|"translation_text"                                                                                                             |
---------------------------------------------------------------------------------------------------------------------------------
|Le Cloud de données de Snowflake est alimenté par une plate-forme de données avancée fournie sous forme de service autogérés.  |
---------------------------------------------------------------------------------------------------------------------------------

Classification Zero-shot

Un pipeline dont la tâche est « zero-shot-classification » a les entrées et sorties suivantes.

Entrées

  • sequences : chaîne contenant le texte à classer.

  • candidate_labels : une liste de chaînes contenant les libellés à appliquer au texte.

Exemple :

-----------------------------------------------------------------------------------------
|"sequences"                                                       |"candidate_labels"  |
-----------------------------------------------------------------------------------------
|I have a problem with Snowflake that needs to be resolved asap!!  |[                   |
|                                                                  |  "urgent",         |
|                                                                  |  "not urgent"      |
|                                                                  |]                   |
|I have a problem with Snowflake that needs to be resolved asap!!  |[                   |
|                                                                  |  "English",        |
|                                                                  |  "Japanese"        |
|                                                                  |]                   |
-----------------------------------------------------------------------------------------

Sorties

  • sequence : la chaîne d’entrée.

  • labels : une liste de chaînes représentant les libellés qui ont été appliqués.

  • scores : une liste de scores de confiance en virgule flottante pour chaque libellé.

Exemple :

--------------------------------------------------------------------------------------------------------------
|"sequence"                                                        |"labels"        |"scores"                |
--------------------------------------------------------------------------------------------------------------
|I have a problem with Snowflake that needs to be resolved asap!!  |[               |[                       |
|                                                                  |  "urgent",     |  0.9952737092971802,   |
|                                                                  |  "not urgent"  |  0.004726255778223276  |
|                                                                  |]               |]                       |
|I have a problem with Snowflake that needs to be resolved asap!!  |[               |[                       |
|                                                                  |  "Japanese",   |  0.5790848135948181,   |
|                                                                  |  "English"     |  0.42091524600982666   |
|                                                                  |]               |]                       |
--------------------------------------------------------------------------------------------------------------
Langage: Français