

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Crie uma tarefa do AutoML para ajustar os modelos de geração de texto usando a API
<a name="autopilot-create-experiment-finetune-llms"></a>

Modelos de linguagem grandes (LLMs) se destacam em várias tarefas generativas, incluindo geração de texto, resumo, conclusão, resposta a perguntas e muito mais. Seu performance pode ser atribuído ao tamanho significativo e ao treinamento extensivo em diversos conjuntos de dados e várias tarefas. No entanto, domínios específicos, como serviços financeiros e de saúde, podem exigir ajustes personalizados para se adaptarem a dados e casos de uso exclusivos. Ao adaptar seu treinamento ao seu domínio específico, LLMs pode melhorar seu desempenho e fornecer resultados mais precisos para aplicações específicas.

O Autopilot oferece a capacidade de ajustar uma seleção de modelos de texto generativo pré-treinados. Em particular, o Autopilot suporta o **ajuste fino baseado em instruções** de uma seleção de modelos de linguagem grande de uso geral () alimentados por. LLMs JumpStart

**nota**  
Os modelos de geração de texto que suportam o ajuste fino no piloto automático estão atualmente acessíveis exclusivamente nas regiões suportadas pelo Canvas. SageMaker Consulte a documentação do SageMaker Canvas para obter a [lista completa de suas regiões suportadas](https://docs.aws.amazon.com/sagemaker/latest/dg/canvas.html).

O ajuste fino de um modelo pré-treinado requer um conjunto de dados específico de instruções claras que orientem o modelo sobre como gerar resultados ou se comportar para essa tarefa. O modelo aprende com o conjunto de dados, ajustando seus parâmetros de acordo com as instruções fornecidas. O ajuste de acordo com as instruções envolve o uso de exemplos rotulados formatados como pares de resposta a prompt e expressos como instruções. Para obter mais informações sobre o ajuste, consulte [Ajuste de um modelo de base](https://docs.aws.amazon.com/sagemaker/latest/dg/jumpstart-foundation-models-fine-tuning.html).

[As diretrizes a seguir descrevem o processo de criação de um trabalho do Amazon SageMaker Autopilot como um experimento piloto para ajustar a geração de texto LLMs usando a API Reference. SageMaker ](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-reference.html)

**nota**  
Tarefas como classificação de texto e imagem, previsão de séries temporais e ajuste de grandes modelos de linguagem estão disponíveis exclusivamente na versão 2 da [API REST do AutoML](autopilot-reference.md). Se sua linguagem preferida for Python, você pode se referir diretamente ao [AWS SDK para Python (Boto3) MLV2 ](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_auto_ml_job_v2.html)[objeto Auto](https://sagemaker.readthedocs.io/en/stable/api/training/automlv2.html#sagemaker.automl.automlv2.AutoMLV2) do Amazon SageMaker Python SDK.  
Os usuários que preferem a conveniência de uma interface de usuário podem usar o [Amazon SageMaker Canvas](https://docs.aws.amazon.com/sagemaker/latest/dg/canvas-getting-started.html) para acessar modelos pré-treinados e modelos básicos de IA generativos, ou criar modelos personalizados para textos específicos, classificação de imagens, necessidades de previsão ou IA generativa.

Para criar um experimento de piloto automático programaticamente para ajustar um LLM, você pode chamar a [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html)API em qualquer linguagem compatível com o Amazon Autopilot ou o. SageMaker AWS CLI

Para obter informações sobre como essa ação da API se traduz em uma função no idioma de sua escolha, consulte a seção [Ver também](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#API_CreateAutoMLJobV2_SeeAlso) de `CreateAutoMLJobV2` e escolha um SDK. Como exemplo, para usuários do Python, veja a sintaxe completa da solicitação de `[create\$1auto\$1ml\$1job\$1v2](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_auto_ml_job_v2)` em AWS SDK para Python (Boto3).

**nota**  
O Autopilot ajusta grandes modelos de linguagem sem exigir que vários candidatos sejam treinados e avaliados. Em vez disso, usando seu conjunto de dados, o Autopilot ajusta diretamente seu modelo de destino para aprimorar uma métrica objetiva padrão, a perda de entropia cruzada. O ajuste fino dos modelos de linguagem no Autopilot não requer a configuração do campo `AutoMLJobObjective`.

Depois que seu LLM estiver ajustado, você poderá avaliar o seu desempenhado acessando várias pontuações ROUGE por meio do `[BestCandidate](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CandidateProperties.html#sagemaker-Type-CandidateProperties-CandidateMetrics)` ao fazer uma chamada de API `[DescribeAutoMLJobV2](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJobV2.html)`. O modelo também fornece informações sobre seu treinamento e perda de validação, bem como sobre sua perplexidade. Para obter uma lista abrangente de métricas para avaliar a qualidade do texto gerado pelos modelos ajustados, consulte [Métricas para ajustar modelos de linguagem grandes no Autopilot](autopilot-llms-finetuning-metrics.md).

## Pré-requisitos
<a name="autopilot-llms-finetuning-api-prerequisites"></a>

Antes de usar o piloto automático para criar um experimento de ajuste fino em SageMaker IA, siga as seguintes etapas:
+ (Opcional) Escolha o modelo pré-treinado que você deseja ajustar.

  Para ver a lista de modelos pré-treinados disponíveis para ajuste fino no Amazon SageMaker Autopilot, consulte. [Modelos de linguagem de grande porte compatíveis para ajuste fino](autopilot-llms-finetuning-models.md) *A seleção de um modelo não é obrigatória; se nenhum modelo for especificado, o Autopilot automaticamente assume como padrão o modelo Falcon7. BInstruct*
+ Criar um conjunto de dados de instruções. Consulte [Tipos de arquivo de conjunto de dados e formato de dados de entrada](autopilot-llms-finetuning-data-format.md) para saber mais sobre os requisitos de formato do seu conjunto de dados de acordo com as instruções.
+ Coloque seus conjuntos de dados em um bucket do Amazon S3.
+ Conceda acesso total ao bucket do Amazon S3 contendo seus dados de entrada para a função de execução de SageMaker IA usada para executar seu experimento.
  + Para obter informações sobre como recuperar sua função de execução de SageMaker IA, consulte[Obtenha um perfil de execução](sagemaker-roles.md#sagemaker-roles-get-execution-role).
  + Para obter informações sobre como conceder permissões de função de execução de SageMaker IA para acessar um ou mais buckets específicos no Amazon S3, *consulte Adicionar permissões adicionais do Amazon S3* a uma função de execução de IA em. SageMaker [Criar perfil de execução](sagemaker-roles.md#sagemaker-roles-create-execution-role)
+ Além disso, você deve fornecer à sua função de execução as permissões necessárias para acessar o bucket de armazenamento padrão do Amazon S3 usado pelo. JumpStart Esse acesso é necessário para armazenar e recuperar artefatos de modelo pré-treinados em. JumpStart Para conceder acesso a esse bucket do Amazon S3, você deve criar uma nova política personalizada em linha em seu perfil de execução.

  Aqui está uma política de exemplo que você pode usar em seu editor JSON ao configurar trabalhos de ajuste do AutoML em `us-west-2`:

  *JumpStartOs nomes dos buckets seguem um padrão predeterminado que depende do Regiões da AWS. Você deve ajustar o nome do bucket adequadamente.* 

  ```
  {
      "Sid": "Statement1",
      "Effect": "Allow",
      "Action": [
          "s3:GetObject",
          "s3:PutObject",
          "s3:ListBucket"
      ],
      "Resource": [
          "arn:aws:s3:::jumpstart-cache-prod-us-west-2",
          "arn:aws:s3:::jumpstart-cache-prod-us-west-2/*"
      ]
  }
  ```

Feito isso, você pode usar o ARN desse perfil de execução nas solicitações da API do Autopilot.

## Parâmetros necessários
<a name="autopilot-llms-finetuning-api-required-params"></a>

Ao chamar `[CreateAutoMLJobV2](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html)` para criar um experimento de Autopilot para ajuste de LLM, você deve fornecer os seguintes valores:
+ Um `[AutoMLJobName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#API_CreateAutoMLJobV2_RequestSyntax)` para especificar o nome do seu trabalho. O nome deve ser do tipo `string` e ter um comprimento mínimo de 1 caractere e um comprimento máximo de 32.
+ Pelo menos um `[AutoMLJobChannel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobChannel.html)` do `training` tipo dentro do `[AutoMLJobInputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-AutoMLJobInputDataConfig)`. Esse canal especifica o nome do bucket do Amazon S3 onde seu conjunto de dados de ajuste fino está localizado. Você tem a opção de definir um canal `validation`. Se nenhum canal de validação for fornecido e um `ValidationFraction` estiver configurado no [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLDataSplitConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLDataSplitConfig.html), essa fração será utilizada para dividir aleatoriamente o conjunto de dados de treinamento em conjuntos de treinamento e validação. Além disso, você pode especificar o tipo de conteúdo (arquivos CSV ou Parquet) para o conjunto de dados.
+ Um `[AutoMLProblemTypeConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-AutoMLProblemTypeConfig)` do tipo `[TextGenerationJobConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TextGenerationJobConfig.html)` para definir as configurações do seu trabalho de treinamento.

  Em particular, você pode especificar o nome do modelo de base a ser ajustado no campo `BaseModelName`. Para ver a lista de modelos pré-treinados disponíveis para ajuste fino no Amazon SageMaker Autopilot, consulte. [Modelos de linguagem de grande porte compatíveis para ajuste fino](autopilot-llms-finetuning-models.md)
+ Um `[OutputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLOutputDataConfig.html)` para especificar o caminho de saída do Amazon S3 para armazenar os artefatos do seu trabalho do AutoML.
+ Um `[RoleArn](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJob.html#sagemaker-CreateAutoMLJob-request-RoleArn)` para especificar o ARN do perfil usada para acessar seus dados.

Veja a seguir um exemplo do formato de solicitação completo usado ao fazer uma chamada de API para `CreateAutoMLJobV2` para ajustar um modelo (`Falcon7BInstruct`).

```
{
   "AutoMLJobName": "<job_name>",
   "AutoMLJobInputDataConfig": [ 
      { 
         "ChannelType": "training",
         "CompressionType": "None",
         "ContentType": "text/csv", 
         "DataSource": { 
            "S3DataSource": { 
               "S3DataType": "S3Prefix",
               "S3Uri": "s3://<bucket_name>/<input_data>.csv"
            }
         }
      }
   ],
  "OutputDataConfig": {
      "S3OutputPath": "s3://<bucket_name>/output",
      "KmsKeyId": "arn:aws:kms:<region>:<account_id>:key/<key_value>"
   },
   "RoleArn":"arn:aws:iam::<account_id>:role/<sagemaker_execution_role_name>",
   "AutoMLProblemTypeConfig": {
        "TextGenerationJobConfig": {
            "BaseModelName": "Falcon7BInstruct"
       }
   }
}
```

Todos os outros parâmetros são opcionais.

## Parâmetros opcionais
<a name="autopilot-llms-finetuning-api-optional-params"></a>

As seções a seguir fornecem detalhes de alguns parâmetros opcionais que você pode passar para o seu trabalho AutoML de ajuste.

### Como especificar os conjuntos de dados de treinamento e validação de um trabalho do AutoML
<a name="autopilot-llms-finetuning-data-training-or-validation"></a>

Você pode fornecer seu próprio conjunto de dados da validação e taxa de divisão de dados personalizada, ou deixar o Autopilot dividir o conjunto de dados automaticamente.

Cada [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobChannel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobChannel.html)objeto (consulte o parâmetro obrigatório [Auto MLJob InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-AutoMLJobInputDataConfig)) tem um`ChannelType`, que pode ser definido como um `training` ou `validation` valores que especificam como os dados devem ser usados ao criar um modelo de aprendizado de máquina.

Pelo menos uma fonte de dados deve ser fornecida e no máximo duas fontes de dados são permitidas: uma para dados de treinamento e outra para dados de validação. A forma como você divide os dados em conjuntos de dados de treinamento e validação depende de você ter uma ou duas fontes de dados. 
+ Se você tiver apenas **uma fonte de dados**, a será `ChannelType` definida como `training` padrão e deverá ter esse valor.
  + Se o valor `ValidationFraction` em [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLDataSplitConfig.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLDataSplitConfig.html) não estiver definido, 0,2 (20%) dos dados dessa fonte serão usados para a validação por padrão. 
  + Se `ValidationFraction` for definido como um valor entre 0 e 1, o conjunto de dados será dividido com base no valor especificado, em que o valor especifica a fração do conjunto de dados usada para validação.
+ Se você tiver **duas fontes de dados**, a `ChannelType` de um dos objetos `AutoMLJobChannel` deverá ser definida como `training`, o valor padrão. A `ChannelType` da outra fonte de dados deve ser definida como `validation`. As duas fontes de dados devem ter o mesmo formato, CSV ou Parquet, e o mesmo esquema. Nesse caso, você não deve definir o valor para o `ValidationFraction` porque todos os dados de cada fonte são usados para treinamento ou validação. Definir esse valor causa um erro.

### Como habilitar a implantação automática
<a name="autopilot-llms-finetuning-auto-model-deployment"></a>

O Autopilot permite que você implante automaticamente seu modelo ajustado em um endpoint. Para habilitar a implantação automática para seu modelo ajustado, inclua um `[ModelDeployConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-ModelDeployConfig)` na solicitação de trabalho do AutoML. Isso permite a implantação de seu modelo ajustado em um SageMaker endpoint de IA. Abaixo estão as configurações disponíveis para personalização.
+ Para permitir que o Autopilot gere o nome do endpoint, defina `[AutoGenerateEndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDeployConfig.html#API_ModelDeployConfig_Contents)` como `True`.
+ Para fornecer seu próprio nome para o endpoint, defina `[AutoGenerateEndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDeployConfig.html#API_ModelDeployConfig_Contents) to False and provide a name of your choice in [EndpointName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelDeployConfig.html#API_ModelDeployConfig_Contents)`.

### Como definir a aceitação do EULA ao ajustar um modelo usando a API de AutoML
<a name="autopilot-llms-finetuning-set-eula"></a>

Para modelos que exigem a aceitação de um contrato de licença de usuário final antes do ajuste, você pode aceitar o EULA definindo o atributo `AcceptEula` do `[ModelAccessConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelAccessConfig.html)` a `True` em `[TextGenerationJobConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TextGenerationJobConfig.html)` ao configurar seu `[AutoMLProblemTypeConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-AutoMLProblemTypeConfig)`.

### Como definir hiperparâmetros para otimizar o processo de aprendizado de um modelo
<a name="autopilot-llms-finetuning-set-hyperparameters"></a>

Você pode otimizar o processo de aprendizado do seu modelo de geração de texto definindo valores de hiperparâmetros no atributo `TextGenerationHyperParameters` de `[TextGenerationJobConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TextGenerationJobConfig.html)` ao configurar seu `[AutoMLProblemTypeConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateAutoMLJobV2.html#sagemaker-CreateAutoMLJobV2-request-AutoMLProblemTypeConfig)`.

O Autopilot permite a configuração de quatro hiperparâmetros comuns em todos os modelos.
+ `epochCount`: Seu valor deve ser uma string contendo um valor inteiro dentro do intervalo de `1` até `10`.
+ `batchSize`: Seu valor deve ser uma string contendo um valor inteiro dentro do intervalo de `1` até `64`.
+ `learningRate`: Seu valor deve ser uma string contendo um valor de ponto flutuante dentro do intervalo de `0` até `1`.
+ `learningRateWarmupSteps`: Seu valor deve ser uma string contendo um valor inteiro dentro do intervalo de `0` até `250`.

Para obter mais detalhes sobre cada hiperparâmetro, consulte [Hiperparâmetros para otimizar o processo de aprendizado de seus modelos de geração de texto](autopilot-llms-finetuning-hyperparameters.md).

O exemplo de JSON a seguir mostra um `TextGenerationHyperParameters` campo passado para o TextGenerationJobConfig onde todos os quatro hiperparâmetros estão configurados.

```
"AutoMLProblemTypeConfig": {
  "TextGenerationJobConfig": {
    "BaseModelName": "Falcon7B",
    "TextGenerationHyperParameters": {"epochCount":"5", "learningRate":"0.000001", "batchSize": "32", "learningRateWarmupSteps": "10"}
  }
}
```

# Modelos de linguagem de grande porte compatíveis para ajuste fino
<a name="autopilot-llms-finetuning-models"></a>

Usando a API Autopilot, os usuários podem ajustar grandes modelos de linguagem (LLMs) que são desenvolvidos pela Amazon. SageMaker JumpStart

**nota**  
Para modelos de ajuste que exigem a aceitação de um contrato de licença de usuário final, você deve declarar explicitamente a aceitação do EULA ao criar o seu trabalho AutoML. Observe que após o ajuste de um modelo pré-treinado, os pesos do modelo original são alterados, portanto, você não precisa aceitar um EULA depois da implantação do modelo ajustado.  
Para obter informações sobre como aceitar o EULA ao criar um trabalho de ajuste usando a API AutoML, consulte [Como definir a aceitação do EULA ao ajustar um modelo usando a API de AutoML](autopilot-create-experiment-finetune-llms.md#autopilot-llms-finetuning-set-eula).

Você pode encontrar os detalhes completos de cada modelo pesquisando sua **ID do JumpStart modelo** na [tabela de modelos](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table) a seguir e, em seguida, seguindo o link na coluna **Fonte**. Esses detalhes podem incluir as linguagens compatíveis com o modelo, os vieses que pode apresentar, os conjuntos de dados empregados para ajuste, e muito mais.

A tabela a seguir lista os JumpStart modelos compatíveis que você pode ajustar com uma tarefa do AutoML.


| JumpStart ID do modelo | `BaseModelName` na solicitação de API | Description | 
| --- | --- | --- | 
| huggingface-textgeneration-dolly-v2-3b-bf16 | Dolly3B |  Dolly 3B é um grande modelo de linguagem que segue instruções de 2,8 bilhões de parâmetros, baseado em [pythia-2.8b](https://huggingface.co/EleutherAI/pythia-2.8b#pythia-28b). Ele é treinado no conjunto de dados de ajuste instruction/response fino [databricks-dolly-15k](https://huggingface.co/datasets/databricks/databricks-dolly-15k) e pode realizar tarefas como brainstorming, classificação, perguntas e respostas, geração de texto, extração de informações e resumo.  | 
| huggingface-textgeneration-dolly-v2-7b-bf16 | Dolly7B |  Dolly 7B é um grande modelo de linguagem que segue instruções de 6,9 bilhões de parâmetros, baseado em [pythia-6.9b](https://huggingface.co/EleutherAI/pythia-6.9b). Ele é treinado no conjunto de dados de ajuste instruction/response fino [databricks-dolly-15k](https://huggingface.co/datasets/databricks/databricks-dolly-15k) e pode realizar tarefas como brainstorming, classificação, perguntas e respostas, geração de texto, extração de informações e resumo.  | 
| huggingface-textgeneration-dolly-v2-12b-bf16 | Dolly12B |  Dolly 12B é um grande modelo de linguagem que segue instruções de 12 bilhões de parâmetros, baseado em [pythia-12b](https://huggingface.co/EleutherAI/pythia-12b). Ele é treinado no conjunto de dados de ajuste instruction/response fino [databricks-dolly-15k](https://huggingface.co/datasets/databricks/databricks-dolly-15k) e pode realizar tarefas como brainstorming, classificação, perguntas e respostas, geração de texto, extração de informações e resumo.  | 
| huggingface-llm-falcon-7b-bf16 | Falcon7B |  O Falcon 7B é um grande modelo de linguagem causal de 7 bilhões de parâmetros treinados em 1.500 bilhões de tokens aprimorados com corpora selecionados. O Falcon-7B é treinado apenas com dados em inglês e francês e não tende a generalizar adequadamente em outros idiomas. Como o modelo foi treinado em grandes quantidades de dados da web, ele carrega os estereótipos e vieses comumente encontrados online.  | 
| huggingface-llm-falcon-7b-instruct-bf16 | Falcon7BInstruct |  O Falcon 7B Instruct é um modelo de grande linguagem causal de 7 bilhões de parâmetros construído no Falcon 7B e ajustado em uma mistura de 250 milhões de tokens de conjuntos de dados. chat/instruct O Falcon 7B Instruct é treinado principalmente em dados em inglês e não tende a generalizar adequadamente em outros idiomas. Além disso, por ser treinado em uma corpora representativa em grande escala da web, ele carrega os estereótipos e preconceitos comumente encontrados online.  | 
| huggingface-llm-falcon-40b-bf16 | Falcon40B |  O Falcon 40B é um grande modelo de linguagem causal de 40 bilhões de parâmetros treinados em 1 trilhão de tokens aprimorados com corpora selecionados. É treinado principalmente em inglês, alemão, espanhol e francês, com capacidades limitadas em italiano, português, polonês, holandês, romeno, tcheco e sueco. Não tende a generalizar adequadamente em outros idiomas. Além disso, por ser treinado em uma corpora representativa em grande escala da web, ele carrega os estereótipos e preconceitos comumente encontrados online.  | 
| huggingface-llm-falcon-40b-instruct-bf16 | Falcon40BInstruct |  O Falcon 40B Instruct é um grande modelo de linguagem causal de 40 bilhões de parâmetros, baseado no Falcon40B e ajustado em uma mistura de Baize. Ele é treinado principalmente em dados em inglês e francês e não se generaliza adequadamente em outros idiomas. Além disso, por ser treinado em uma corpora representativa em grande escala da web, ele carrega os estereótipos e preconceitos comumente encontrados online.   | 
| huggingface-text2text-flan-t5-large | FlanT5L |  A família de modelos [https://huggingface.co/docs/transformers/model_doc/t5](https://huggingface.co/docs/transformers/model_doc/t5) é um conjunto de grandes modelos de linguagem que são ajustados em várias tarefas e podem ser treinados posteriormente. Esses modelos são adequados para tarefas como tradução de idiomas, geração de texto, conclusão de frases, desambiguação de sentido de palavras, resumo ou resposta a perguntas. O Flan T5 L é um grande modelo de linguagem de 780 milhões de parâmetros treinados em vários idiomas. [Você pode encontrar a lista dos idiomas suportados pelo Flan T5 L nos detalhes do modelo recuperados de sua pesquisa por ID do modelo na tabela JumpStart do modelo.](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table)  | 
| huggingface-text2text-flan-t5-xl | FlanT5XL |  A família de modelos [https://huggingface.co/docs/transformers/model_doc/t5](https://huggingface.co/docs/transformers/model_doc/t5) é um conjunto de grandes modelos de linguagem que são ajustados em várias tarefas e podem ser treinados posteriormente. Esses modelos são adequados para tarefas como tradução de idiomas, geração de texto, conclusão de frases, desambiguação de sentido de palavras, resumo ou resposta a perguntas. O Flan T5 XL é um grande modelo de linguagem de 3 bilhões de parâmetros treinados em vários idiomas. [Você pode encontrar a lista dos idiomas suportados pelo Flan T5 XL nos detalhes do modelo recuperados de sua pesquisa por ID do modelo na JumpStart tabela do modelo.](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table)  | 
| huggingface-text2text-flan-t5-xxll | FlanT5XXL |  A família de modelos [https://huggingface.co/docs/transformers/model_doc/t5](https://huggingface.co/docs/transformers/model_doc/t5) é um conjunto de grandes modelos de linguagem que são ajustados em várias tarefas e podem ser treinados posteriormente. Esses modelos são adequados para tarefas como tradução de idiomas, geração de texto, conclusão de frases, desambiguação de sentido de palavras, resumo ou resposta a perguntas. O Flan T5 XXL é um modelo de 11 bilhões de parâmetros. [Você pode encontrar a lista dos idiomas suportados pelo Flan T5 XXL nos detalhes do modelo recuperados de sua pesquisa por ID do modelo na JumpStart tabela do modelo.](https://sagemaker.readthedocs.io/en/stable/doc_utils/pretrainedmodels.html#built-in-algorithms-with-pre-trained-model-table)  | 
| meta-textgeneration-llama-2-7b | Llama2-7B |  O Llama 2 é uma coleção de modelos de texto generativo pré-treinados e ajustados, que variam em escala de 7 bilhões a 70 bilhões de parâmetros. O Llama2-7B é o modelo de 7 bilhões de parâmetros destinados ao uso em inglês e pode ser adaptado para uma variedade de tarefas de geração de linguagem natural.  | 
| meta-textgeneration-llama-2-7b-f | Llama2-7BChat |  O Llama 2 é uma coleção de modelos de texto generativo pré-treinados e ajustados, que variam em escala de 7 bilhões a 70 bilhões de parâmetros. O Llama2-7B é o modelo de chat de 7 bilhões de parâmetros otimizados para casos de uso de diálogo.  | 
| meta-textgeneration-llama-2-13b | Llama2-13B |  O Llama 2 é uma coleção de modelos de texto generativo pré-treinados e ajustados, que variam em escala de 7 bilhões a 70 bilhões de parâmetros. O Llama2-13B é o modelo de 13 bilhões de parâmetros destinados ao uso em inglês e pode ser adaptado para uma variedade de tarefas de geração de linguagem natural.  | 
| meta-textgeneration-llama-2-13b-f | Llama2-13BChat |  O Llama 2 é uma coleção de modelos de texto generativo pré-treinados e ajustados, que variam em escala de 7 bilhões a 70 bilhões de parâmetros. O Llama2-13B é o modelo de chat de 13 bilhões de parâmetros otimizados para casos de uso de diálogo.  | 
| huggingface-llm-mistral-7b | Mistral7B |  O Mistral 7B é um código de sete bilhões de parâmetros e um modelo de geração de texto em inglês de uso geral. Pode ser usado em vários casos de uso, incluindo resumo de texto, classificação, preenchimento de texto ou preenchimento de código.  | 
| huggingface-llm-mistral-7b-instruct | Mistral7BInstruct |  O Mistral 7B Instruct é a versão do Mistral 7B ajustada para casos de uso de conversação. Especializado, com o uso de uma variedade de conjuntos de dados de conversação disponíveis publicamente em inglês.  | 
| huggingface-textgeneration1-mpt-7b-bf16 | MPT7B |  O MPT 7B é um grande modelo de linguagem transformador no estilo decodificador com 6,7 bilhões de parâmetros, pré-treinados do zero em 1 trilhão de tokens de texto e código em inglês. Preparado para lidar com longos comprimentos de contexto.  | 
| huggingface-textgeneration1-mpt-7b-instruct-bf16 | MPT7BInstruct |  O MPT 7B Instruct é um modelo para instruções curtas após tarefas. Construído ajustando o MPT 7B em um conjunto de dados derivado dos conjuntos de dados [databricks-dolly-15k](https://huggingface.co/datasets/databricks/databricks-dolly-15k) e dos conjuntos de dados [Anthropic Helpful and Harmless (HH-RLHF)](https://huggingface.co/datasets/Anthropic/hh-rlhf).  | 

# Tipos de arquivo de conjunto de dados e formato de dados de entrada
<a name="autopilot-llms-finetuning-data-format"></a>

O ajuste fino baseado em instruções usa conjuntos de dados rotulados para melhorar o desempenho de tarefas pré-treinadas LLMs em tarefas específicas de processamento de linguagem natural (PNL). Os exemplos rotulados são formatados como prompts, pares de respostas a prompt e expressos como instruções.



Para saber mais sobre os tipos de arquivo de conjunto de dados compatíveis, consulte [Tipos de arquivos compatíveis do conjunto de dados compatíveis](#autopilot-llms-finetuning-dataset-format).

Para saber mais sobre o formato de dados de entrada, consulte [Formato de dados de entrada para ajuste fino baseado em instruções](#autopilot-llms-finetuning-input-format).

## Tipos de arquivos compatíveis do conjunto de dados compatíveis
<a name="autopilot-llms-finetuning-dataset-format"></a>

O Autopilot é compatível com conjuntos de dados de ajuste de acordo com as instruções formatados como arquivos CSV (padrão) ou como arquivos Parquet.
+ **CSV** (valores separados por vírgula) é um formato de arquivo em linhas que armazena dados em texto simples legível por humanos, o que é uma escolha frequente para troca de dados, pois é compatível com uma ampla variedade de aplicações.
+ O **Parquet** é um formato de arquivo em colunas, binário, no qual os dados são armazenados e processados com mais eficiência do que em formatos de arquivo de leitura humana como o CSV. Isso os torna uma opção melhor para problemas de big data.

**nota**  
O conjunto de dados pode consistir em vários arquivos, cada um dos quais deve seguir um modelo específico. Para obter informações sobre como formatar seus dados de entrada, consulte [Formato de dados de entrada para ajuste fino baseado em instruções](#autopilot-llms-finetuning-input-format).

## Formato de dados de entrada para ajuste fino baseado em instruções
<a name="autopilot-llms-finetuning-input-format"></a>

Cada arquivo do conjunto de dados deve seguir o seguinte formato:
+ O conjunto de dados deve conter exatamente duas colunas separadas por vírgula e nomeadas, `input` e `output`. O Autopilot não permite colunas adicionais. 
+ As colunas `input` contêm os prompts e as `output` correspondentes contêm a resposta esperada. Tanto o `input` quanto `output` estão no formato de string.

O exemplo a seguir ilustra o formato de dados de entrada para o ajuste fino baseado em instruções no Autopilot.

```
input,output
"<prompt text>","<expected generated text>"
```

**nota**  
Recomendamos usar conjuntos de dados com no mínimo 1.000 linhas para garantir o aprendizado e o performance ideais do modelo.

Além disso, o Autopilot define um limite máximo para o número de linhas no conjunto de dados e o tamanho do contexto com base no tipo de modelo que está sendo usado.
+ Os limites do número de linhas em um conjunto de dados se aplicam à contagem cumulativa de linhas em todos os arquivos dentro do conjunto de dados, incluindo vários arquivos. Se houver dois [tipos de canais](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLChannel.html) definidos (um para treinamento e outro para validação), o limite se aplicará ao número total de linhas em todos os conjuntos de dados em ambos os canais. Quando o número de linhas excede o limite, o trabalho falha com um erro de validação.
+ Quando o comprimento da entrada ou saída de uma linha no conjunto de dados excede o limite definido no contexto do modelo de linguagem, ele é automaticamente truncado. Se mais de 60% das linhas no conjunto de dados estiverem truncadas, seja na entrada ou na saída, o Autopilot falhará no trabalho com um erro de validação.

A tabela a seguir apresenta esses limites para cada modelo.


| JumpStart ID do modelo | `BaseModelName` na solicitação de API | Limite de linhas | Limite de comprimento do contexto | 
| --- | --- | --- | --- | 
| huggingface-textgeneration-dolly-v2-3b-bf16 | Dolly3B | 10.000 linhas | 1.024 tokens | 
| huggingface-textgeneration-dolly-v2-7b-bf16 | Dolly7B | 10.000 linhas | 1.024 tokens | 
| huggingface-textgeneration-dolly-v2-12b-bf16 | Dolly12B | 10.000 linhas | 1.024 tokens | 
| huggingface-llm-falcon-7b-bf16 | Falcon7B | 1.000 linhas | 1.024 tokens | 
| huggingface-llm-falcon-7b-instruct-bf16 | Falcon7BInstruct | 1.000 linhas | 1.024 tokens | 
| huggingface-llm-falcon-40b-bf16 | Falcon40B | 10.000 linhas | 1.024 tokens | 
| huggingface-llm-falcon-40b-instruct-bf16 | Falcon40BInstruct | 10.000 linhas | 1.024 tokens | 
| huggingface-text2text-flan-t5-large | FlanT5L | 10.000 linhas | 1.024 tokens | 
| huggingface-text2text-flan-t5-xl | FlanT5XL | 10.000 linhas | 1.024 tokens | 
| huggingface-text2text-flan-t5-xxll | FlanT5XXL | 10.000 linhas | 1.024 tokens | 
| meta-textgeneration-llama-2-7b | Llama2-7B | 10.000 linhas | 2.048 tokens | 
| meta-textgeneration-llama-2-7b-f | Llama2-7BChat | 10.000 linhas | 2.048 tokens | 
| meta-textgeneration-llama-2-13b | Llama2-13B | 7.000 linhas | 2.048 tokens | 
| meta-textgeneration-llama-2-13b-f | Llama2-13BChat | 7.000 linhas | 2.048 tokens | 
| huggingface-llm-mistral-7b | Mistral7B | 10.000 linhas | 2.048 tokens | 
| huggingface-llm-mistral-7b-instruct | Mistral7BInstruct | 10.000 linhas | 2.048 tokens | 
| huggingface-textgeneration1-mpt-7b-bf16 | MPT7B | 10.000 linhas | 1.024 tokens | 
| huggingface-textgeneration1-mpt-7b-instruct-bf16 | MPT7BInstruct | 10.000 linhas | 1.024 tokens | 

# Hiperparâmetros para otimizar o processo de aprendizado de seus modelos de geração de texto
<a name="autopilot-llms-finetuning-hyperparameters"></a>

Você pode otimizar o processo de aprendizado do seu modelo básico ajustando qualquer combinação dos seguintes hiperparâmetros: Esses parâmetros já estão disponíveis para todos os modelos.
+ **Contagem de Época**: o hiperparâmetro `epochCount` determina quantas vezes o modelo passa por todo o conjunto de dados de treinamento. Ela influencia a duração do treinamento e pode evitar o sobreajuste quando configurada adequadamente. Um grande número de épocas pode aumentar o runtime geral dos trabalhos de ajuste. Recomendamos definir um grande `MaxAutoMLJobRuntimeInSeconds` dentro do `CompletionCriteria` de `[TextGenerationJobConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_TextGenerationJobConfig.html)` para evitar que os trabalhos de ajuste sejam interrompidos prematuramente.
+ **Tamanho do Lote**: o hiperparâmetro `batchSize` define o número de amostras de dados usadas em cada iteração do treinamento. Isso pode afetar a velocidade de convergência e o uso da memória. Com um lote grande, o risco de erros de falta de memória (OOM) aumenta, o que pode surgir como um erro interno do servidor no Autopilot. Para verificar esse erro, verifique o grupo de logs `/aws/sagemaker/TrainingJobs` dos trabalhos de treinamento iniciados pelo trabalho do Autopilot. Você pode acessar esses CloudWatch logins no console AWS de gerenciamento. Escolha **Logs** e depois escolha `/aws/sagemaker/TrainingJobs` **grupo de logs**. Para corrigir erros do OOM, reduza o tamanho do lote.

  Recomendamos começar com um tamanho de lote de 1 e aumentá-lo incrementalmente até surgir algum erro por falta de memória. Como referência, 10 épocas normalmente levam até 72h para serem concluídas.
+ **Taxa de Aprendizado**: o hiperparâmetro `learningRate` controla o tamanho da etapa na qual os parâmetros do modelo são atualizados durante o treinamento. Determina a rapidez ou a lentidão os parâmetros do modelo são atualizados durante o treinamento. Uma alta taxa de aprendizado significa que os parâmetros são atualizados em uma etapa grande, o que pode levar a uma convergência mais rápida, no entanto, também pode fazer com que o processo de otimização ultrapasse a solução ideal e torne-se instável. Uma taxa de aprendizado baixa significa que os parâmetros são atualizados em etapas pequenas, o que pode levar a uma convergência mais estável, no entanto, ao custo de um aprendizado mais lento.
+ **Etapas de aquecimento da taxa de aprendizado**: O hiperparâmetro `learningRateWarmupSteps` especifica o número de etapas de treinamento nas quais a taxa de aprendizado aumenta gradualmente antes de atingir sua meta ou valor máximo. Isso ajuda o modelo a convergir com mais eficiência e evitar problemas como divergência ou convergência lenta que podem surgir com uma taxa de aprendizado inicialmente alta.

Para saber como ajustar os hiperparâmetros do experimento de ajuste no Autopilot e descobrir seus valores possíveis, consulte [Como definir hiperparâmetros para otimizar o processo de aprendizado de um modelo](autopilot-create-experiment-finetune-llms.md#autopilot-llms-finetuning-set-hyperparameters).

# Métricas para ajustar modelos de linguagem grandes no Autopilot
<a name="autopilot-llms-finetuning-metrics"></a>

A seção a seguir descreve as métricas que você pode usar para entender seus modelos de linguagem grandes e ajustados (). LLMs Usando seu conjunto de dados, o Autopilot ajusta diretamente seu LLM alvo para aprimorar uma métrica objetiva padrão, a perda de entropia cruzada.

A perda de entropia cruzada é uma métrica amplamente usada para avaliar a dissimilaridade entre a distribuição de probabilidade prevista e a distribuição real das palavras nos dados de treinamento. Ao minimizar a perda de entropia cruzada, o modelo aprende a fazer predições mais precisas e contextualmente relevantes, principalmente em tarefas relacionadas à geração de texto.

Depois de ajustar um LLM, você pode avaliar a qualidade do texto gerado usando uma variedade de pontuações do ROUGE. Além disso, você pode analisar as perdas de treinamento e validação de perplexidade e entropia cruzada como parte do processo de avaliação.
+ A perda de perplexidade mede o quão bem o modelo pode prever a próxima palavra em uma sequência de texto, com valores mais baixos indicando uma melhor compreensão do idioma e do contexto. 
+ O Recall-Oriented Understudy for Gisting Evaluation (ROUGE) é um conjunto de métricas usadas no campo do processamento de linguagem natural (PLN) e de machine learning para avaliar a qualidade do texto gerado por máquina, como resumo de texto ou geração de texto. Ele avalia principalmente as semelhanças entre o texto gerado e o texto de referência da verdade básica (escrito por humanos) de um conjunto de dados de validação. As medidas do ROUGE são projetadas para avaliar vários aspectos da similaridade de texto, incluindo a precisão e a recordação de n-gramas (sequências contíguas de palavras) nos textos gerados pelo sistema e de referência. O objetivo é avaliar o quão bem um modelo captura as informações presentes no texto de referência.

  Existem várias variantes das métricas do ROUGE, dependendo do tipo de n-gramas usados e dos aspectos específicos da qualidade do texto em avaliação.

  A lista a seguir contém o nome e a descrição das métricas do ROUGE disponíveis após o ajuste de grandes modelos de linguagem no Autopilot.  
**`ROUGE-1`, `ROUGE-2`**  
ROUGE-N, a métrica principal ROUGE, mede a sobreposição de n-gramas entre os textos gerados pelo sistema e os textos de referência. ROUGE-N pode ser ajustado para diferentes valores de `n` (aqui `1` ou `2`) para avaliar o quão bem o texto gerado pelo sistema captura os n-gramas do texto de referência.  
**`ROUGE-L`**  
ROUGE-L (ROUGE-Longest Common Subsequence) calcula a maior subsequência comum entre o texto gerado pelo sistema e o texto de referência. Essa variante considera a ordem das palavras, além da sobreposição de conteúdo.  
**`ROUGE-L-Sum`**  
ROUGE-L-SUM (Longest Common Subsequence for Summarization) foi projetado para a avaliação de sistemas de resumo de texto. Ele se concentra em medir a maior subsequência comum entre o resumo gerado pela máquina e o resumo de referência. ROUGE-L-SUM leva em consideração a ordem das palavras no texto, o que é importante nas tarefas de resumo do texto.

# Implantação e predições de modelo do Autopilot
<a name="autopilot-llms-finetuning-deploy-models"></a>

Depois de ajustar um grande modelo de linguagem (LLM), você pode implantar o modelo para geração de texto em tempo real configurando um endpoint para obter predições interativas.

**nota**  
Recomendamos executar trabalhos de inferência em tempo real `ml.g5.12xlarge` para obter melhores performances. Como alternativa, as instâncias `ml.g5.8xlarge` são adequadas para tarefas de geração de texto Falcon-7B-Instruct e MPT-7B-Instruct.  
Você pode encontrar as especificidades dessas instâncias na categoria [Computação acelerada](https://aws.amazon.com/ec2/instance-types/) na seleção de tipos de instância fornecidos pelo Amazon EC2.

## Geração de texto em tempo real
<a name="autopilot-llms-finetuning-realtime"></a>

Você pode usar SageMaker APIs para implantar manualmente seu modelo ajustado em um endpoint de [inferência em tempo real do SageMaker AI Hosting e, em seguida, começar a fazer previsões invocando o endpoint](https://docs.aws.amazon.com/sagemaker/latest/dg/realtime-endpoints.html) da seguinte maneira.

**nota**  
Como alternativa, você pode escolher a opção de implantação automática o criar seu experimento de ajuste fino no Autopilot. Para obter informações sobre como configurar a implantação automática de modelos, consulte [Como habilitar a implantação automática](autopilot-create-experiment-finetune-llms.md#autopilot-llms-finetuning-auto-model-deployment).   
Você também pode usar o SDK do SageMaker Python e a `JumpStartModel` classe para realizar inferências com modelos ajustados pelo Autopilot. Isso pode ser feito especificando um local personalizado para o artefato do modelo no Amazon S3. Para obter informações sobre como definir seu modelo como JumpStart modelo e implantar seu modelo para inferência, consulte [Implantação de baixo código com](https://sagemaker.readthedocs.io/en/stable/overview.html#deploy-a-pre-trained-model-directly-to-a-sagemaker-endpoint) a classe. JumpStartModel 

1. **Obtenha as definições do contêiner de inferência candidato**

   Você pode encontrar o `InferenceContainerDefinitions` interior do `BestCandidate` objeto recuperado da resposta à chamada da API [DescribeAutoMLJobV2](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJobV2.html#API_DescribeAutoMLJobV2_ResponseSyntax). Uma definição de contêiner para inferência refere-se ao ambiente em contêineres projetado para implantar e executar seu modelo treinado para fazer predições.

   O exemplo de AWS CLI comando a seguir usa a API [DescribeAutoMLJobV2](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeAutoMLJobV2.html) para obter as definições de contêiner recomendadas para o nome do seu trabalho.

   ```
   aws sagemaker describe-auto-ml-job-v2 --auto-ml-job-name job-name --region region
   ```

1. **Crie um modelo de SageMaker IA**

   Use as definições de contêiner da etapa anterior para criar um modelo de SageMaker IA usando a [CreateModel](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API. Veja o AWS CLI comando a seguir como exemplo. Use o `CandidateName` para o nome do modelo.

   ```
   aws sagemaker create-model --model-name '<your-candidate-name>' \
                       --primary-container '<container-definition' \
                       --execution-role-arn '<execution-role-arn>' --region '<region>
   ```

1. **Criar uma configuração de endpoint**

   O exemplo de AWS CLI comando a seguir usa a [CreateEndpointConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpointConfig.html)API para criar uma configuração de endpoint.
**nota**  
Para evitar que a criação do endpoint atinja o tempo limite devido a um longo download do modelo, recomendamos configurar `ModelDataDownloadTimeoutInSeconds = 3600` e `ContainerStartupHealthCheckTimeoutInSeconds = 3600`.

   ```
   aws sagemaker create-endpoint-config --endpoint-config-name '<your-endpoint-config-name>' \
                       --production-variants '<list-of-production-variants>' ModelDataDownloadTimeoutInSeconds=3600 ContainerStartupHealthCheckTimeoutInSeconds=3600 \
                       --region '<region>'
   ```

1. **Criar o endpoint** 

   O AWS CLI exemplo a seguir usa a [CreateEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API para criar o endpoint.

   ```
   aws sagemaker create-endpoint --endpoint-name '<your-endpoint-name>' \
                       --endpoint-config-name '<endpoint-config-name-you-just-created>' \
                       --region '<region>'
   ```

   Verifique o progresso da implantação do seu endpoint usando a [DescribeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DescribeEndpoint.html)API. Veja o AWS CLI comando a seguir como exemplo.

   ```
   aws sagemaker describe-endpoint —endpoint-name '<endpoint-name>' —region <region>
   ```

   Depois que `EndpointStatus` muda para `InService`, o endpoint está pronto para ser usado para inferência em tempo real.

1. **Invocar o endpoint** 

   O comando a seguir invoca o endpoint para inferência em tempo real. Seu prompt precisa ser codificado em bytes.
**nota**  
O formato do seu prompt de entrada depende do modelo de linguagem. Para obter mais informações sobre o formato de promtps de geração de texto, consulte [Formato de solicitação para inferência em tempo real de modelos de geração de texto](#autopilot-llms-finetuning-realtime-prompt-examples). 

   ```
   aws sagemaker invoke-endpoint --endpoint-name '<endpoint-name>' \ 
                     --region '<region>' --body '<your-promt-in-bytes>' [--content-type] 'application/json' <outfile>
   ```

## Formato de solicitação para inferência em tempo real de modelos de geração de texto
<a name="autopilot-llms-finetuning-realtime-prompt-examples"></a>

Diferentes modelos de linguagem grande (LLMs) podem ter dependências específicas de software, ambientes de execução e requisitos de hardware que influenciam o contêiner recomendado pelo Autopilot para hospedar o modelo para inferência. Adicionalmente, cada modelo determina o formato de dados de entrada necessário e o formato esperado para predições e resultados.

Aqui estão exemplos de entradas para alguns modelos e contêineres recomendados.
+ Para modelos Falcon com o contêiner `huggingface-pytorch-tgi-inference:2.0.1-tgi1.0.3-gpu-py39-cu118-ubuntu20.04` recomendado:

  ```
  payload = {
      "inputs": "Large language model fine-tuning is defined as",
      "parameters": {
          "do_sample": false,
          "top_p": 0.9,
          "temperature": 0.1,
          "max_new_tokens": 128,
          "stop": ["<|endoftext|>", "</s>"]
      }
  }
  ```
+ Para outros modelos com o contêiner `djl-inference:0.22.1-fastertransformer5.3.0-cu118` recomendado:

  ```
  payload= {
      "text_inputs": "Large language model fine-tuning is defined as"
  }
  ```