Pipeline do Hugging Face

O Snowflake Model Registry oferece suporte a qualquer modelo do Hugging Face definido como transformador que pode ser carregado usando o método transformers.Pipeline.

Use um dos seguintes métodos para registrar um modelo do Hugging Face no Model Registry:

  1. Importar e implementar um modelo do Hugging Face usando o Snowsight. Consulte Importação e implementação de modelos de um serviço externo para obter instruções.

  2. Criar uma instância snowflake.ml.model.models.huggingface.TransformersPipeline e chamar log_model():

    # reg: snowflake.ml.registry.Registry

from snowflake.ml.model.models import huggingface


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

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

    Importante

    • Se você não especificar um argumento compute_pool_for_log, o modelo será registrado usando o pool de computação da CPU padrão.

    • Se você especificar um argumento compute_pool_for_log, o modelo será registrado usando o pool de computação especificado.

    • Se você especificar o argumento compute_pool_for_log como None, os arquivos de modelo serão baixados localmente e depois carregados no registro de modelos. Isso requer a instalação do huggingface-hub.

  3. Carregar o modelo do Hugging Face na memória e registrá-lo no Model 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')

Se você usa o Snowflake Notebooks, para baixar os pesos do modelo, precisa ter uma integração de acesso externo anexada ao seu notebook. Essa integração é necessária para permitir a saída para os seguintes hosts:

  • 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

Nota

Essa lista é apenas dos hosts necessários para acessar o Hugging Face e pode ser alterada a qualquer momento. Seu modelo pode exigir artefatos de outras fontes, que devem ser adicionados à regra de rede conforme permitido para saída.

O exemplo a seguir cria uma nova integração de acesso externo huggingface_network_rule para uso com um notebook:

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

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

Consulte Criação e uso de uma integração de acesso externo para obter mais informações.

Depois de criar sua integração de acesso externo, anexe-a ao seu notebook e tenha acesso ao repositório de modelos do Hugging Face para baixar os pesos e as configurações do modelo. Consulte Configurar acesso externo para o Snowflake Notebooks para obter mais informações.

API do registro de modelo

Ao chamar log_model(), o dicionário options oferece suporte às seguintes chaves:

Chave de opção

Descrição

Tipo

target_methods

Uma lista de métodos disponíveis no objeto de modelo. Por padrão, os modelos do Hugging Face usam o método __call__ do objeto, se houver.

list[str]

cuda_version

A versão do tempo de execução CUDA a ser usada na implantação em uma plataforma com GPU. Se definido como None, o modelo não poderá ser implantado em uma plataforma com GPU. O padrão é 12.4.

Optional[str]

O registro de modelos infere o argumento signatures se o pipeline contém uma tarefa da seguinte lista:

Nota

Os nomes das tarefas diferenciam maiúsculas de minúsculas.

O argumento sample_input_data para log_model é ignorado nos modelos do Hugging Face. Especifique o argumento signatures ao registrar um modelo do Hugging Face que não está na lista acima, para que o registro saiba as assinaturas dos métodos de destino.

Para ver a assinatura inferida, chame o método show_functions(). Essa assinatura fornece os tipos e nomes de colunas necessários para a entrada da função de modelo, bem como o formato da respectiva saída. O exemplo a seguir mostra a assinatura do modelo bigscience/bloom-560m com uma tarefa de text-generation:

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

O exemplo a seguir mostra como invocar um modelo usando a assinatura anterior:

# model: snowflake.ml.model.ModelVersion

import pandas as pd

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

Notas de uso

  • Muitos modelos do Hugging Face são grandes e não cabem em um warehouse padrão. Use um warehouse otimizado para Snowpark ou escolha uma versão menor do modelo. Por exemplo, uma alternativa ao modelo Llama-2-70b-chat-hf é Llama-2-7b-chat-hf.

  • Os warehouses Snowflake não têm GPUs. Use apenas modelos Hugging Face otimizados para CPU.

  • Alguns transformadores Hugging Face retornam uma matriz de dicionários por linha de entrada. O registro de modelos converte a matriz de dicionários em uma cadeia de caracteres que contém uma representação JSON da matriz. Por exemplo, a saída de resposta a perguntas com várias saídas é semelhante a esta:

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

Exemplo

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

Resultado:

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

Assinaturas inferidas para pipelines Hugging Face

Esta seção descreve as assinaturas inferidas para os pipelines Hugging Face compatíveis, incluindo uma descrição e um exemplo das entradas necessárias e das saídas esperadas. Todas as entradas e saídas são Snowpark DataFrames.

Pipeline de máscara de preenchimento

Um pipeline cuja tarefa é «fill-mask « tem as seguintes entradas e saídas.

Entradas

  • inputs: uma cadeia de caracteres onde há uma máscara para preencher.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de objetos, cada um dos quais pode conter chaves como score, token, token_str ou sequence. Para obter mais detalhes, consulte FillMaskPipeline.

Exemplo:

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

Exemplo de código

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
)

Classificação de token

Um pipeline cuja tarefa é «ner» ou `token-classification<https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.TokenClassificationPipeline>`_ tem as seguintes entradas e saídas.

Entradas

  • inputs: Uma cadeia de caracteres com os tokens a serem classificados.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de objetos de resultado, cada um dos quais pode conter chaves como entity, score, index, word, name, start ou end. Para obter mais detalhes, consulte TokenClassificationPipeline.

Exemplo:

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

Exemplo de código

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
)

Resposta a perguntas (saída única)

Um pipeline cuja tarefa é «question-answering «, em que top_k não está definido ou está definido como 1, tem as seguintes entradas e saídas.

Entradas

  • question: Uma cadeia de caracteres com a pergunta a ser respondida.

  • context: uma cadeia de caracteres que pode conter a resposta.

Exemplo:

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

Saídas

  • score: pontuação de confiança de ponto flutuante de 0,0 a 1,0.

  • start: índice inteiro do primeiro token da resposta no contexto.

  • end: índice inteiro do último token da resposta no contexto original.

  • answer: Uma cadeia de caracteres com a resposta encontrada.

Exemplo:

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

Exemplo de código

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
)

Resposta a perguntas (várias saídas)

Um pipeline cuja tarefa é «question-answering «, em que top_k é definido e é maior que 1, tem as seguintes entradas e saídas.

Entradas

  • question: Uma cadeia de caracteres com a pergunta a ser respondida.

  • context: uma cadeia de caracteres que pode conter a resposta.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de objetos de resultado, cada um dos quais pode conter chaves como score, start, end ou answer.

Exemplo:

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

Exemplo de código

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
)

Resumo

Um pipeline cuja tarefa é «summarization «, onde return_tensors é falso ou não definido, tem as seguintes entradas e saídas.

Entradas

  • documents: Uma cadeia de caracteres com texto para resumir.

Exemplo:

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

Saídas

  • summary_text: Uma cadeia de caracteres com o resumo gerado ou, se num_return_sequences for maior que 1, uma cadeia de caracteres com uma representação JSON de uma lista de resultados, cada um dos quais é um dicionário com campos, incluindo summary_text.

Exemplo:

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

Exemplo de código

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
)

Tabela de respostas a perguntas

Um pipeline cuja tarefa é «table-question-answering « tem as seguintes entradas e saídas.

Entradas

  • query: Uma cadeia de caracteres com a pergunta a ser respondida.

  • table: Uma cadeia de caracteres com um dicionário serializado em JSON no formato {column -> [values]}, que representa a tabela que pode conter uma resposta.

Exemplo:

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

Saídas

  • answer: Uma cadeia de caracteres com uma possível resposta.

  • coordinates: Uma lista de inteiros que representam as coordenadas das células onde a resposta foi localizada.

  • cells: Uma lista de cadeias de caracteres com o conteúdo das células onde a resposta foi localizada.

  • aggregator: Uma cadeia de caracteres com o nome do agregador usado.

Exemplo:

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

Exemplo de código

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
)

Classificação de texto (saída única)

Um pipeline cuja tarefa é «text-classification « ou «análise de sentimento», onde top_k não é definido ou é nenhum (none), tem as seguintes entradas e saídas.

Entradas

  • text: uma cadeia de caracteres para classificar.

  • text_pair: Uma cadeia de caracteres para classificar juntamente com text e que é usada com modelos que calculam similaridade de texto. Deixe em branco se o modelo não o utilizar.

Exemplo:

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

Saídas

  • label: Uma cadeia de caracteres que representa o rótulo de classificação de texto.

  • score: uma pontuação de confiança de ponto flutuante de 0,0 a 1,0.

Exemplo:

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

Exemplo de código

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
)

Classificação de texto (saída múltipla)

Um pipeline cuja tarefa é «text-classification « ou «análise de sentimento», onde top_k é definido como um número, tem as seguintes entradas e saídas.

Nota

Uma tarefa de classificação de texto é considerada de saída múltipla se top_k for definido como qualquer número, mesmo que esse número seja 1. Para obter uma saída única, use um valor top_k de Nenhum.

Entradas

  • text: uma cadeia de caracteres para classificar.

  • text_pair: Uma cadeia de caracteres para classificar juntamente com text, que é usada com modelos que calculam similaridade de texto. Deixe em branco se o modelo não o utilizar.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de resultados, cada um dos quais contém campos que incluem label e score.

Exemplo:

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

Exemplo de código

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
)

Geração de texto para texto

Um pipeline cuja tarefa é «geração de texto para texto «, onde return_tensors é falso ou não definido, tem as seguintes entradas e saídas.

Entradas

  • inputs: Uma cadeia de caracteres com um prompt.

Exemplo:

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

Saídas

  • generated_text: Uma cadeia de caracteres com o texto gerado se num_return_sequences for 1, ou se num_return_sequences for maior que 1, uma representação de cadeia de caracteres de uma lista JSON de dicionários de resultados com campos incluindo generated_text.

Exemplo:

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

Exemplo de código

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
)

Nota

Pipelines de geração de texto para texto onde return_tensors é verdadeiro não são suportados.

Geração de tradução

Um pipeline cuja tarefa é «translation «, onde return_tensors é falso ou não definido, tem as seguintes entradas e saídas.

Nota

Pipelines de geração de tradução onde return_tensors é verdadeiro não são suportados.

Entradas

  • inputs: Uma cadeia de caracteres com texto a ser traduzido.

Exemplo:

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

Saídas

  • translation_text: Uma cadeia de caracteres que representa a tradução gerada se num_return_sequences for 1, ou uma representação de cadeia de caracteres de uma lista JSON de dicionários de resultados, cada um contendo campos que incluem translation_text.

Exemplo:

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

Exemplo de código

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
)

Classificação zero-shot

Um pipeline cuja tarefa é «zero-shot-classification « tem as seguintes entradas e saídas.

Entradas

  • sequences: Uma cadeia de caracteres com o texto a ser classificado.

  • candidate_labels: Uma lista de cadeias de caracteres com os rótulos a serem aplicados ao texto.

Exemplo:

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

Saídas

  • sequence: a cadeia de caracteres de entrada.

  • labels: Uma lista de cadeias de caracteres que representam os rótulos aplicados.

  • scores: uma lista de pontuações de confiança de ponto flutuante para cada rótulo.

Exemplo:

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

Geração de texto

Um pipeline cuja tarefa é «geração de texto «, onde return_tensors é falso ou não definido, tem as seguintes entradas e saídas.

Nota

Pipelines de geração de texto onde return_tensors é verdadeiro não são suportados.

Entradas

  • inputs: Uma cadeia de caracteres com um prompt.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de objetos de resultado, cada um dos quais contém campos que incluem generated_text.

Exemplo:

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

Exemplo de código

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
)

Geração de texto (compatível com OpenAI)

Um pipeline cuja tarefa é «geração de texto «, onde return_tensors é falso ou não definido, tem as seguintes entradas e saídas.

Durante o registro do modelo, ao fornecer a assinatura snowflake.ml.model.openai_signatures.OPENAI_CHAT_SIGNATURE, o modelo será compatível com a API OpenAI. Isso permite que os usuários passem solicitações no estilo openai.client.ChatCompletion ao modelo.

Nota

Pipelines de geração de texto onde return_tensors é verdadeiro não são suportados.

Entradas

  • messages: uma lista de dicionários com as mensagens que serão enviadas ao modelo.

  • max_completion_tokens: o número máximo de tokens a serem gerados.

  • temperature: a temperatura que será usada para a geração.

  • stop: a sequência de parada que será usada para a geração.

  • n: o número de gerações a serem produzidas.

  • stream: se a geração será ou não transmitida.

  • top_p: o valor p superior que será usado para a geração.

  • frequency_penalty: a penalidade de frequência que será usada para a geração.

  • presence_penalty: a penalidade de presença que será usada para a geração.

Exemplo:

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

Saídas

  • outputs: Uma cadeia de caracteres com uma representação JSON de uma lista de objetos de resultado, cada um dos quais contém campos que incluem generated_text.

Exemplo:

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

Exemplo de código

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)