Hugging Face-Pipeline¶

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

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

Importieren und Bereitstellen eines Modells aus Hugging Face und Protokollieren des Modells in der Modell-Registry über die UI
Durch Verwendung der snowflake.ml.model.models.huggingface.TransformersPipeline-Klasse können Sie ein Modell von Hugging Face in der Modell-Registry protokollieren.
```
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.

Laden des Modells aus Hugging Face in den Speicher und Protokollierung in der Modell-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

Beim Aufrufen von log_model unterstützt das options-Wörterbuch Folgendes:

Option	Beschreibung
`target_methods`	Liste mit den Namen der für das Modellobjekt verfügbaren Methoden. Hugging Face-Modelle haben standardmäßig die folgenden Zielmethoden, vorausgesetzt, die Methode existiert: `__call__`.
`cuda_version`	Die Version der CUDA-Laufzeit, die beim Bereitstellen auf einer Plattform mit einem GPU verwendet werden soll; der Standardwert ist 12.4. Wird das Modell manuell auf `None` gesetzt, kann es nicht auf einer Plattform mit GPU eingesetzt werden.

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

fill-mask
question-answering
summarization
table-question-answering
text2text-generation
text-classification (auch sentiment-analysis genannt)
text-generation
token-classification (auch ner genannt)
translation
translation_xx_to_yy
zero-shot-classification

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

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

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

Copy

Verwenden Sie den folgenden Code, um das Modell lmv aufzurufen:

import pandas as pd
remote_prediction = lmv.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. Versuchen Sie zum Beispiel, statt des Modells Llama-2-70b-chat-hf das Modell Llama-2-7b-chat-hf zu verwenden.
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 Registrierung konvertiert das 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.\""}]'
```
Copy

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

Copy

Abgeleitete Signaturen für Hugging Face-Pipelines¶

Die Snowflake Model Registry leitet die Signaturen von Hugging Face Pipelines, die eine einzelne Aufgabe enthalten, automatisch aus der folgenden Liste ab:

fill-mask
question-answering
summarization
table-question-answering
text2text-generation
text-classification (Alias sentiment-analysis)
text-generation
token-classification (Alias ner)
translation
translation_xx_to_yy
zero-shot-classification

In diesem Abschnitt werden die Signaturen dieser Typen von 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"...  |
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

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

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

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

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

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

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

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

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

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.

Bemerkung

Text-zu-Text-Generierungs-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¶

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

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

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