Pipeline Hugging Face

Le registre des modèles de Snowflake prend en charge tout modèle de Hugging Face défini comme transformateur qui peut être chargé avec la méthode transformers.Pipeline.

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

  1. Importez et déployez un modèle depuis Hugging Face à l’aide de Snowsight. Consultez Importer et déployer des modèles à partir d’un service externe pour obtenir des instructions.

  2. Créez une instance snowflake.ml.model.models.huggingface.TransformersPipeline et appelez log_model() :

    # reg: snowflake.ml.registry.Registry

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')

    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. Chargez le modèle à partir de Hugging Face en mémoire et connectez-le au registre des modèles :

    # reg: snowflake.ml.registry.Registry

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')

Si vous utilisez Snowflake Notebooks, afin de télécharger les poids du modèle, vous devez disposer d’une intégration d’accès externe attachée à votre notebook. Cette intégration est nécessaire pour permettre la sortie vers les hôtes suivants :

  • huggingface.co

  • hub-ci.huggingface.co

  • cdn-lfs-us-1.hf.co

  • cdn-lfs-eu-1.hf.co

  • cdn-lfs.hf.co

  • transfer.xethub.hf.co

  • cas-server.xethub.hf.co

  • cas-bridge.xethub.hf.c

Note

Cette liste d’hôtes ne comprend que ceux requis pour accéder à Hugging Face et peut changer à tout moment. Votre modèle peut nécessiter des artefacts provenant d’autres sources, qui doivent être ajoutés à la règle réseau comme autorisés pour la sortie.

L’exemple suivant crée une nouvelle intégration d’accès externe huggingface_network_rule pour l’utilisation avec un notebook :

CREATE NETWORK RULE huggingface_network_rule
TYPE = HOST_PORT
VALUE_LIST = (
    'huggingface.co',
    'hub-ci.huggingface.co',
    'cdn-lfs-us-1.hf.co',
    'cdn-lfs-eu-1.hf.co',
    'cdn-lfs.hf.co',
    'transfer.xethub.hf.co',
    'cas-server.xethub.hf.co',
    'cas-bridge.xethub.hf.co'
)
MODE = EGRESS
COMMENT = 'Network Rule for Hugging Face external access';

CREATE EXTERNAL ACCESS INTEGRATION huggingface_access_integration
ALLOWED_NETWORK_RULES = (huggingface_network_rule)
ENABLED = true;

Pour plus d’informations, voir Création et utilisation d’une intégration d’accès externe.

Une fois votre intégration d’accès externe créée, attachez-la à votre notebook et accédez au référentiel de modèles Hugging Face pour télécharger les poids et les configurations du modèle. Pour plus d’informations, voir Configurer l’accès externe pour Snowflake Notebooks.

API de registre de modèles

Lorsque vous appelez log_model(), le dictionnaire options prend en charge les clés suivantes :

Clé d’option

Description

Type

target_methods

Une liste des méthodes disponibles sur l’objet modèle. Les modèles Hugging Face utilisent la méthode __call__ de l’objet par défaut, si elle existe.

list[str]

cuda_version

La version de l’environnement d’exécution CUDA à utiliser lors du déploiement sur une plateforme avec un GPU. Si elle est définie sur None, le modèle ne peut pas être déployé sur une plateforme avec un GPU. La valeur par défaut est 12.4.

Optional[str]

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

Note

Les noms des tâches sont sensibles à la casse.

L’argument sample_input_data de log_model est complètement ignoré pour les modèles Hugging Face. Spécifiez l’argument signatures lors de l’enregistrement d’un modèle Hugging Face qui ne figure pas dans la liste précédente afin que le registre connaisse les signatures des méthodes cibles.

Pour voir la signature déduite, appelez la méthode show_functions(). Cette signature vous donne les types et les noms de colonnes requis pour l’entrée de la fonction de modèle, ainsi que le format de sa sortie. L’exemple suivant montre la signature du modèle bigscience/bloom-560m avec une tâche de text-generation :

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

L’exemple suivant montre comment invoquer un modèle à l’aide de la signature précédente :

# model: snowflake.ml.model.ModelVersion

import pandas as pd

remote_prediction = model.run(pd.DataFrame(["Hello, how are you?"], columns=["inputs"]))

Notes sur l’utilisation

  • De nombreux modèles Hugging Face 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, une alternative à l” Llama-2-70b-chat-hf le modèle est 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 des modèles convertit ce 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.\""}]'

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.", ""],
        ]
    )
)

Résultat :

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

Signatures déduites pour les pipelines Hugging Face

Cette section décrit les signatures déduites des pipelines Hugging Face pris en charge, 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"...  |
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="fill-mask",
    model="google-bert/bert-base-uncased",
)

mv = registry.log_model(
    model=model,
    model_name="GOOGLE_BERT_BASE_UNCASED",
)

input_df = pd.DataFrame([{"text": "LynYuu is the [MASK] of the Grand Duchy of Yu."}])
mv.run(
    input_df,
    # function_name="__call__", # Optional
)

Classification de jetons

Un pipeline dont la tâche est « ner » ou token-classification » présente 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}, {...  |

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="token-classification",
    model="dslim/bert-base-NER",
)

mv = registry.log_model(
    model=model,
    model_name="BERT_BASE_NER",
)

mv.run(
    pd.DataFrame([{"inputs": "My name is Izumi and I live in Tokyo, Japan."}]),
    # function_name="__call__", # Optional
)

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

Exemple de code

import transformers
import pandas as pd


model = transformers.pipeline(
    task="question-answering",
    model="deepset/roberta-base-squad2",
)

QA_input = {
    "question": "Why is model conversion important?",
    "context": "The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks.",
}

mv = registry.log_model(
    model=model,
    model_name="ROBERTA_BASE_SQUAD2",
)

mv.run(
    pd.DataFrame.from_records([QA_input]),
    # function_name="__call__", # Optional
)

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"}]  |
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd


model = transformers.pipeline(
    task="question-answering",
    model="deepset/roberta-base-squad2",
    top_k=3,
)

QA_input = {
    "question": "Why is model conversion important?",
    "context": "The option to convert models between FARM and transformers gives freedom to the user and let people easily switch between frameworks.",
}

mv = registry.log_model(
    model=model,
    model_name="ROBERTA_BASE_SQUAD2",
)

mv.run(
    pd.DataFrame.from_records([QA_input]),
    # function_name="__call__", # Optional
)

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

Exemple de code

import transformers
import pandas as pd


model = transformers.pipeline(
    task="summarization",
    model="facebook/bart-large-cnn",
)

text = "The transformers library is a great library for natural language processing which provides a unified interface for many different models and tasks."

mv = registry.log_model(
    model=model,
    model_name="BART_LARGE_CNN",
)

mv.run(
    pd.DataFrame.from_records([{"documents": text}]),
    # function_name="__call__", # Optional
)

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          |                 |              |
|             |  ]            |                 |              |
|             |]              |                 |              |
----------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd
import json

model = transformers.pipeline(
    task="table-question-answering",
    model="microsoft/tapex-base-finetuned-wikisql",
)

data = {
    "year": [1896, 1900, 1904, 2004, 2008, 2012],
    "city": ["athens", "paris", "st. louis", "athens", "beijing", "london"],
}
query = "What is the city of the year 2004?"


mv = registry.log_model(
    model=model,
    model_name="TAPEX_BASE_FINETUNED_WIKISQL",
)

mv.run(
    pd.DataFrame.from_records([{"query": query, "table": json.dumps(data)}]),
    # function_name="__call__", # Optional
)

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

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="text-classification",
    model="cardiffnlp/twitter-roberta-base-sentiment-latest",
)

text = "I'm happy today!"


mv = registry.log_model(
    model=model,
    model_name="TWITTER_ROBERTA_BASE_SENTIMENT_LATEST",
)

mv.run(
    pd.DataFrame.from_records([{"text": text}]),
    # function_name="__call__", # Optional
)

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}]  |
--------------------------------------------------------

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="text-classification",
    model="cardiffnlp/twitter-roberta-base-sentiment-latest",
    top_k=3,
)

text = "I'm happy today!"


mv = registry.log_model(
    model=model,
    model_name="TWITTER_ROBERTA_BASE_SENTIMENT_LATEST",
)

mv.run(
    pd.DataFrame.from_records([{"text": text}]),
    # function_name="__call__", # Optional
)

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.

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

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="text2text-generation",
    model="google-t5/t5-small",
)

text = "Tell me a joke."


mv = registry.log_model(
    model=model,
    model_name="T5_SMALL",
)

mv.run(
    pd.DataFrame.from_records([{"inputs": text}]),
    # function_name="__call__", # Optional
)

Note

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

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.  |
---------------------------------------------------------------------------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="translation",
    model="deepvk/kazRush-kk-ru",
)

text = "Иттерді кім шығарды?"


mv = registry.log_model(
    model=model,
    model_name="KAZRUSH_KK_RU",
)

mv.run(
    pd.DataFrame.from_records([{"inputs": text}]),
    # function_name="__call__", # Optional
)

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   |
|                                                                  |]               |]                       |
--------------------------------------------------------------------------------------------------------------

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...  |
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd

model = transformers.pipeline(
    task="text-generation",
    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
)

mv = registry.log_model(
    model=model,
    model_name="TINYLLAMA",
)

text = "A descendant of the Lost City of Atlantis, who swam to Earth while saying,"
mv.run(
    pd.DataFrame.from_records([{"inputs": text}]),
    # function_name="__call__", # Optional
)

Génération de texte (compatible avec OpenAI)

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.

En fournissant la signature snowflake.ml.model.openai_signatures.OPENAI_CHAT_SIGNATURE, lors de la journalisation du modèle, le modèle sera compatible avec l’API OpenAI. Cela permet aux utilisateurs de transmettre des requêtes de style openai.client.ChatCompletion au modèle.

Note

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

Entrées

  • messages : une liste de dictionnaires contenant les messages à envoyer au modèle.

  • max_completion_tokens : Le nombre maximal de jetons à générer.

  • temperature : La température à utiliser pour la génération.

  • stop : La séquence d’arrêt à utiliser pour la génération.

  • n : Le nombre de générations à produire.

  • stream : Indique s’il convient de diffuser la génération.

  • top_p : La valeur p supérieure à utiliser pour la génération.

  • frequency_penalty : La pénalité de fréquence à utiliser pour la génération.

  • presence_penalty : La pénalité de présence à utiliser pour la génération.

Exemple :

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| messages                                                                                                                                                                                          |   max_completion_tokens |   temperature | stop   |   n | stream   |   top_p |   frequency_penalty |  presence_penalty |
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| [{'role': 'system', 'content': 'Complete the sentence.'}, {'role': 'user', 'content': [{'type': 'text', 'text': 'A descendant of the Lost City of Atlantis, who swam to Earth while saying, '}]}] |                     250 |           0.9 |        |   3 | False    |       1 |                 0.1 |               0.2 |
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

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 :

-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| id           | object          |     created | model                                      | choices                                                                                                                                      |  usage                                                               |
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
| chatcmpl-... | chat.completion | 1.76912e+09 | /shared/model/model/models/TINYLLAMA/model | [{'finish_reason': 'stop', 'index': 0, 'logprobs': None, 'message': {'content': 'The descendant is not actually ...', 'role': 'assistant'}}] | {'completion_tokens': 399, 'prompt_tokens': 52, 'total_tokens': 451} |
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Exemple de code

import transformers
import pandas as pd
from snowflake.ml.model import openai_signatures

model = transformers.pipeline(
    task="text-generation",
    model="TinyLlama/TinyLlama-1.1B-Chat-v1.0",
)


mv = registry.log_model(
    model=model,
    model_name="TINYLLAMA",
    signatures=openai_signatures.OPENAI_CHAT_SIGNATURE,
)

# create a pd.DataFrame with openai.client.chat.completion arguments
x_df = pd.DataFrame.from_records(
    [
        {
            "messages": [
                {
                    "role": "system",
                    "content": [
                        {
                            "type": "text",
                            "text": "Complete the sentence.",
                        }
                    ],
                },
                {
                    "role": "user",
                    "content": [
                        {
                            "type": "text",
                            "text": "A descendant of the Lost City of Atlantis, who swam to Earth while saying, ",
                        }
                    ],
                },
            ],
            "max_completion_tokens": 250,
            "temperature": 0.9,
            "stop": None,
            "n": 3,
            "stream": False,
            "top_p": 1.0,
            "frequency_penalty": 0.1,
            "presence_penalty": 0.2,
        }
    ],
)

# OpenAI Chat Completion compatible output
output_df = mv.run(X=x_df)