Hugging Face-Pipeline

Die Snowflake Model Registry unterstützt jedes Hugging Face-Modell, das als Transformer definiert ist und mit der transformers.Pipeline-Methode geladen werden kann.

Verwenden Sie eine der folgenden Methoden, um ein Hugging Face-Modell in der Model Registry zu protokollieren:

  1. Importieren und stellen Sie ein Modell von Hugging Face mithilfe von Snowsight bereit. Anweisungen hierzu finden Sie unter Importieren und Bereitstellen von Modellen von einem externen Dienst.

  2. Erstellen Sie eine snowflake.ml.model.models.huggingface.TransformersPipeline-Instanz und rufen Sie log_model() auf:

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

    Wichtig

    • Wenn Sie kein compute_pool_for_log-Argument angeben, wird das Modell mit dem standardmäßigen CPU-Computepool protokolliert.

    • Wenn Sie ein compute_pool_for_log-Argument angeben, wird das Modell mit dem standardmäßigen Computepool protokolliert.

    • Wenn Sie das compute_pool_for_log-Argument als „None“ festlegen, werden die Modelldateien lokal heruntergeladen und dann in die Modell-Registry hochgeladen. Hierzu muss huggingface-hub installiert sein.

  3. Laden Sie das Modell aus Hugging Face in den Speicher und protokollieren Sie es in der Modell-Registry:

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

Wenn Sie Snowflake Notebooks verwenden, muss Ihrem Notebook eine Integration für den externen Zugriff zugewiesen sein, um die Gewichtungen des Modells herunterladen zu können. Diese Integration ist erforderlich, um ausgehenden Datenverkehr zu folgenden Hosts zu ermöglichen:

  • 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

Bemerkung

Diese Liste enthält nur die Hosts, die für den Zugriff auf Hugging Face erforderlich ist, und kann sich jederzeit ändern. Ihr Modell benötigt möglicherweise Artefakte aus anderen Quellen, die der Netzwerkregel als zulässig für ausgehenden Datenverkehr hinzugefügt werden sollten.

Im folgenden Beispiel wird eine neue huggingface_network_rule-Integration für den externen Zugriff zur Verwendung mit einem Notebook erstellt:

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

Weitere Informationen dazu finden Sie unter Erstellen und Verwenden einer Integration für den externen Zugriff.

Sobald Ihre Integration für den externen Zugriff erstellt ist, verbinden Sie sie mit Ihrem Notebook, um auf die Hugging Face-Modell-Repository zuzugreifen und Modellgewichtungen und -konfigurationen herunterzuladen. Weitere Informationen dazu finden Sie unter Einrichten des externen Zugriffs für Snowflake Notebooks.

Modell-Registry-API

Beim Aufrufen von log_model() unterstützt das options-Wörterbuch die folgenden Schlüssel:

Optionsschlüssel

Beschreibung

Typ

target_methods

Eine Liste der für das Modellobjekt verfügbaren Methoden. Hugging Face-Modelle verwenden standardmäßig die __call__-Methode des Objekts, falls vorhanden.

list[str]

cuda_version

Die Version der CUDA-Laufzeitumgebung, die beim Bereitstellen auf einer Plattform mit der GPU verwendet werden soll. Wenn der Wert auf None gesetzt ist, kann das Modell nicht auf einer Plattform mit einer GPU bereitgestellt werden. Der Standardwert ist 12.4.

Optional[str]

Die Modell-Registry leitet das signatures-Argument nur ab, wenn die Pipeline eine Aufgabe enthält, die in der folgenden Liste aufgeführt ist:

Bemerkung

Bei Aufgabennamen wird zwischen Groß- und Kleinschreibung unterschieden.

Das Argument sample_input_data für log_model wird bei Hugging Face-Modellen ignoriert. Geben Sie das signatures-Argument an, wenn Sie ein Hugging Face-Modell protokollieren, das nicht in der vorhergehenden Liste enthalten ist, damit die Registry die Signaturen der Zielmethoden kennt.

Um die abgeleitete Signatur zu sehen, rufen Sie die show_functions()-Methode. auf. Diese Signatur gibt die erforderlichen Typen und Spaltennamen für die Eingabe der Modellfunktion sowie das Format der Ausgabe an. Das folgende Beispiel zeigt die Signatur für das Modell bigscience/bloom-560m mit einer Aufgabe zur text-generation:

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

Das folgende Beispiel zeigt, wie ein Modell mithilfe der vorherigen Signatur aufgerufen wird:

# model: snowflake.ml.model.ModelVersion

import pandas as pd

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

Nutzungshinweise

  • Viele Hugging Face-Modelle sind groß und passen nicht in ein Standard-Warehouse. Verwenden Sie ein Snowpark-optimiertes Warehouse, oder wählen Sie eine kleinere Version des Modells aus. Eine Alternative zum Llama-2-70b-chat-hf-Modell ist beispielsweise Llama-2-7b-chat-hf.

  • Snowflake-Warehouses haben keine GPUs. Verwenden Sie nur CPU-optimierte Hugging Face-Modelle.

  • Einige Hugging Face-Transformatoren geben pro Eingabezeile ein Array von Dictionarys zurück. Die Modell-Registry konvertiert dieses Array der Wörterbücher in eine Zeichenfolge, die eine JSON-Repräsentation des Arrays enthält. Die Mehrfach-Ausgabe für die Beantwortung von Fragen sieht zum Beispiel so aus:

    '[{"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.\""}]'

Beispiel

# 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

Ergebnis:

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

Abgeleitete Signaturen für Hugging Face-Pipelines

In diesem Abschnitt werden die abgeleiteten Signaturen für unterstützte Hugging Face-Pipelines beschrieben, einschließlich einer Beschreibung und eines Beispiels für die erforderlichen Eingaben und erwarteten Ausgaben. Alle Ein- und Ausgaben sind Snowpark-DataFrames.

Fill-Mask-Pipeline

Eine Pipeline, deren Aufgabe „fill-mask „ ist, hat die folgenden Ein- und Ausgaben.

Eingaben

  • inputs: Zeichenfolge für eine zu befüllende Maske.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Objekten enthält, von denen jedes Schlüssel wie score, token, token_str oder sequence enthalten kann. Weitere Details dazu finden Sie unter FillMaskPipeline.

Beispiel:

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

Codebeispiel

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

Token-Klassifizierung

Eine Pipeline, deren Aufgabe „ner“ oder token-classification ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • inputs: Eine Zeichenfolge, die die zu klassifizierenden Token enthält.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnisobjekten enthält, von denen jedes Schlüssel wie entity, score, index, word, name, start oder end enthalten kann. Weitere Details dazu finden Sie unter TokenClassificationPipeline.

Beispiel:

----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
|"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}, {...  |

Codebeispiel

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

Beantworten von Fragen (Einzelausgabe)

Eine Pipeline, deren Aufgabe „ question-answering “ ist, wobei top_k entweder nicht gesetzt oder auf 1 gesetzt ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • question: Eine Zeichenfolge, die die zu beantwortende Frage enthält.

  • context: Zeichenfolge, die die Antwort enthalten kann.

Beispiel:

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

Ausgaben

  • score: Gleitkomma-Konfidenzwert von 0,0 bis 1,0.

  • start: Integer-Index des ersten Tokens der Antwort im Kontext.

  • end: Integer-Index des letzten Tokens der Antwort im ursprünglichen Kontext.

  • answer: Eine Zeichenfolge, die die gefundene Antwort enthält.

Beispiel:

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

Codebeispiel

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

Beantworten von Fragen (mehrere Ausgaben)

Eine Pipeline, deren Aufgabe „ question-answering “ ist, wobei top_k auf größer als 1 gesetzt ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • question: Eine Zeichenfolge, die die zu beantwortende Frage enthält.

  • context: Zeichenfolge, die die Antwort enthalten kann.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnisobjekten enthält, von denen jedes Schlüssel wie score, start, end oder answer enthalten kann.

Beispiel:

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

Codebeispiel

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

Zusammenfassungen

Eine Pipeline, deren Aufgabe „ summarization “ ist und bei der return_tensors den Wert „False“ hat oder nicht aktiviert ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • documents: Eine Zeichenfolge, die den zusammenzufassenden Text enthält.

Beispiel:

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

Ausgaben

  • summary_text: Eine Zeichenfolge, die die generierte Zusammenfassung enthält, oder, wenn num_return_sequences größer als 1 ist, eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnissen enthält, von denen jedes ein Dictionary ist, das Felder enthält, einschließlich summary_text.

Beispiel:

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

Codebeispiel

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

Beantworten von Fragen mit Tabelle

Eine Pipeline, deren Aufgabe „ table-question-answering “ ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • query: Eine Zeichenfolge, die die zu beantwortende Frage enthält.

  • table: Eine Zeichenfolge, die ein JSON-serialisiertes Dictionary in der Form {column -> [values]} enthält, das die Tabelle darstellt, die eine Antwort enthalten kann.

Beispiel:

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

Ausgaben

  • answer: Eine Zeichenfolge, die eine mögliche Antwort enthält.

  • coordinates: Eine Liste von Ganzzahlen, die die Koordinaten der Speicherorte darstellen, an denen die Antwort gefunden wurde.

  • cells: Eine Auflistung von Zeichenfolgen, die den Inhalt der Zellen enthalten, in denen sich der Speicherort der Antwort befand.

  • aggregator: Eine Zeichenfolge, die den Namen des verwendeten Aggregators enthält.

Beispiel:

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

Codebeispiel

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

Textklassifizierung (Einzelausgabe)

Eine Pipeline, deren Aufgabe „text-classification „ oder „sentiment-analysis“ ist, wobei top_k den Wert None hat oder nicht gesetzt ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • text: Zeichenfolge zum Klassifizieren.

  • text_pair: Eine Zeichenfolge, die zusammen mit text klassifiziert wird und der mit Modellen verwendet wird, die die Textähnlichkeit berechnen. Leer lassen, wenn das Modell es nicht verwendet.

Beispiel:

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

Ausgaben

  • label: Eine Zeichenfolge, die die Klassifizierung des Textes angibt.

  • score: Ein Gleitkomma-Konfidenzwert von 0,0 bis 1,0.

Beispiel:

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

Codebeispiel

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

Textklassifizierung (mehrere Ausgaben)

Eine Pipeline, deren Aufgabe „text-classification „ oder „sentiment-analysis“ ist, wobei top_k einen Zahlenwert hat, hat die folgenden Eingaben und Ausgaben.

Bemerkung

Eine Textklassifizierungsaufgabe wird als Mehrfachausgabe betrachtet, wenn top_k auf eine beliebige Zahl gesetzt wird, auch wenn diese Zahl 1 ist. Um eine Einzelausgabe zu erhalten, verwenden Sie einen top_k-Wert von „None“.

Eingaben

  • text: Zeichenfolge zum Klassifizieren.

  • text_pair: Eine Zeichenfolge, die zusammen mit text klassifiziert wird der mit Modellen verwendet wird, die die Textähnlichkeit berechnen. Leer lassen, wenn das Modell es nicht verwendet.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnissen enthält, die jeweils Felder enthalten, die label und score umfassen.

Beispiel:

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

Codebeispiel

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

Text-zu-Text-Generierung

Eine Pipeline, deren Aufgabe „ text2text-generation “ ist und bei der return_tensors den Wert „False“ hat oder nicht aktiviert ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • inputs: Eine Zeichenfolge, die eine Eingabeaufforderung enthält.

Beispiel:

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

Ausgaben

  • generated_text : Eine Zeichenfolge, die den generierten Text enthält, wenn num_return_sequences gleich 1 ist, oder, wenn num_return_sequences größer als 1 ist, eine Zeichenfolge, die eine JSON-Liste von Ergebnis-Dictionarys darstellt, die Felder einschließlich generated_text enthalten.

Beispiel:

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

Codebeispiel

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

Bemerkung

Text-zu-Text-Generierungs-Pipelines, bei denen return_tensors den Wert „True“ hat, werden nicht unterstützt.

Übersetzungsgenerierung

Eine Pipeline, deren Aufgabe „ translation “ ist und bei der return_tensors den Wert „False“ hat oder nicht aktiviert ist, hat die folgenden Eingaben und Ausgaben.

Bemerkung

Übersetzungsgenerierungs-Pipelines, bei denen return_tensors den Wert „True“ hat, werden nicht unterstützt.

Eingaben

  • inputs: Eine Zeichenfolge, die zu übersetzenden Text enthält.

Beispiel:

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

Ausgaben

  • translation_text: Eine Zeichenfolge, die eine generierte Übersetzung darstellt, wenn num_return_sequences gleich 1 ist, oder eine Zeichenfolge, die eine JSON-Liste von Ergebnis-Dictionarys darstellt, die jeweils Felder enthalten, die translation_text enthalten.

Beispiel:

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

Codebeispiel

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

Zero-Shot-Klassifizierung

Eine Pipeline, deren Aufgabe „ zero-shot-classification “ ist, hat die folgenden Eingaben und Ausgaben.

Eingaben

  • sequences: Eine Zeichenfolge, die den zu klassifizierenden Text enthält.

  • candidate_labels: Eine Liste von Zeichenfolgen mit den Labels, die auf den Text angewendet werden sollen.

Beispiel:

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

Ausgaben

  • sequence: Die Eingabezeichenfolgen.

  • labels: Eine Liste von Zeichenfolgen, die die verwendeten Etiketten darstellen.

  • scores: Liste von Gleitkomma-Konfidenzwerten für jedes Label.

Beispiel:

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

Textgenerierung

Eine Pipeline, deren Aufgabe „ text-generation “ ist und bei der return_tensors den Wert „False“ hat oder nicht aktiviert ist, hat die folgenden Eingaben und Ausgaben.

Bemerkung

Textgenerierungs-Pipelines, bei denen return_tensors den Wert „True“ hat, werden nicht unterstützt.

Eingaben

  • inputs: Eine Zeichenfolge, die eine Eingabeaufforderung enthält.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnisobjekten enthält, die jeweils Felder enthalten, die generated_text umfassen.

Beispiel:

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

Codebeispiel

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

Textgenerierung (OpenAI-kompatibel)

Eine Pipeline, deren Aufgabe „ text-generation “ ist und bei der return_tensors den Wert „False“ hat oder nicht aktiviert ist, hat die folgenden Eingaben und Ausgaben.

Durch die Bereitstellung der snowflake.ml.model.openai_signatures.OPENAI_CHAT_SIGNATURE-Signatur während der Modellprotokollierung ist das Modell mit der OpenAI API kompatibel. So können Benutzende Anfragen in der Form von openai.clientChatCompletion an das Modell übergeben.

Bemerkung

Textgenerierungs-Pipelines, bei denen return_tensors den Wert „True“ hat, werden nicht unterstützt.

Eingaben

  • messages: Eine Liste von Wörterbüchern, die die Nachrichten enthalten, die an das Modell gesendet werden sollen.

  • max_completion_tokens: Die maximale Anzahl von zu generierenden Token.

  • temperature: Die für die Generierung zu verwendende Temperatur.

  • stop: Die Stoppsequenz, die für die Generierung verwendet werden soll.

  • n: Die Anzahl der zu erstellenden Generierungen.

  • stream: Ob die Generierung gestreamt werden soll.

  • top_p: Der Top-p-Wert, der für die Generierung verwendet werden soll.

  • frequency_penalty: Die Häufigkeits-Penalty, die für die Generierung verwendet werden sollen.

  • presence_penalty: Die Präsenz-Penalty, die für die Generierung verwendet werden sollen.

Beispiel:

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

Ausgaben

  • outputs: Eine Zeichenfolge, die eine JSON-Repräsentation einer Liste von Ergebnisobjekten enthält, die jeweils Felder enthalten, die generated_text umfassen.

Beispiel:

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

Codebeispiel

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