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:
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.
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')
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.
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')
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;
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:
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"]))
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.", ""],
]
)
)
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.
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
)
Token-Klassifizierung
Eine Pipeline, deren Aufgabe „ner“ oder token-classification ist, hat die folgenden Eingaben und Ausgaben.
Eingaben
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
)
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
)
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
)
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
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
)
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
)
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
)
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
)
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
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
)
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
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
)
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
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
)
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)