Platform For AI:Solução de reconhecimento de intenção baseada em LLM

Reconhecimento de intenção

O reconhecimento de intenção permite que um agente de IA compreenda as solicitações do usuário em linguagem natural e, em seguida, execute as ações correspondentes ou forneça informações relevantes. É um componente fundamental dos sistemas interativos inteligentes. Atualmente, a tecnologia de reconhecimento de intenção baseada em modelos de linguagem de grande porte (LLM) é amplamente utilizada no mercado.

Casos de uso

• Em assistentes de voz inteligentes, os usuários interagem com o assistente por meio de comandos de voz simples. Por exemplo, se um usuário disser "Quero ouvir música", o sistema precisa identificar com precisão a intenção de tocar música e, então, executar a ação correspondente.

• Em cenários de atendimento ao cliente inteligente, o desafio é processar diversas solicitações dos clientes e direcioná-las com precisão para os fluxos de trabalho corretos, como devoluções, trocas ou reclamações. Por exemplo, em uma plataforma de e-commerce, um usuário pode dizer: "O produto que recebi está com defeito. Quero devolvê-lo." Nesse caso, o sistema de reconhecimento de intenção baseado em LLM deve capturar rapidamente a intenção do usuário como "devolução", acionar automaticamente o processo de devolução e orientar o usuário nas etapas subsequentes.

Fluxo de trabalho

1. Preparar dados de treinamento

   Prepare um conjunto de dados de treinamento para o seu cenário de negócios específico, seguindo o formato de dados e a estratégia de preparação especificados. Como alternativa, prepare seus dados de negócios e use o iTAG para rotular os dados brutos. Exporte os resultados rotulados e converta-os para um formato compatível com o PAI-QuickStart para o treinamento do modelo.

2. Treinar o modelo e realizar a avaliação offline

   No QuickStart, treine o modelo com base no Qwen1.5-1.8B-Chat. Após o treinamento, realize uma avaliação offline.

3. Implantar e invocar o serviço do modelo

   Se os resultados da avaliação forem satisfatórios, use o QuickStart para implantar o modelo treinado como um serviço online do EAS.

Estratégias de preparação de dados

Para melhorar a eficácia e a estabilidade do treinamento do modelo, siga estas estratégias ao preparar seus dados:

• Para cenários de reconhecimento de intenção única, garanta que cada categoria de intenção tenha pelo menos 50 a 100 exemplos rotulados. Se os resultados do ajuste fino do modelo não forem satisfatórios, considere aumentar a quantidade de dados rotulados. Além disso, mantenha os dados equilibrados entre as categorias de intenção. Evite ter uma categoria com significativamente mais dados que as outras.

• Em cenários de múltiplas intenções ou diálogos de múltiplas rodadas, utilize pelo menos 20% a mais de dados rotulados em comparação com os cenários de intenção única. Além disso, qualquer intenção usada em cenários de múltiplas intenções ou múltiplas rodadas também deve estar definida nos seus dados de intenção única.

• As descrições de intenção devem abranger uma ampla variedade de formulações e cenários.

Formato dos dados

Os dados de treinamento devem ser um arquivo json contendo os campos instruction e output. O campo instruction contém a instrução de entrada, e o campo output contém a intenção prevista pelo modelo com seus parâmetros-chave. Os exemplos a seguir mostram os dados de treinamento para diferentes cenários de reconhecimento de intenção.

• Para cenários de reconhecimento de intenção única, prepare dados específicos do negócio para fazer o ajuste fino de um modelo de linguagem de grande porte (LLM). Por exemplo, os dados a seguir são uma amostra de treinamento para um diálogo de rodada única em um cenário de casa inteligente:

  [
      {
          "instruction": "I want to listen to music",
          "output": "play_music()"
      },
      {
          "instruction": "It's too loud, turn the volume down",
          "output": "volume_down()"
      },
      {
          "instruction": "I don't want to listen anymore, turn it off",
          "output": "music_exit()"
      },
      {
          "instruction": "I want to travel to Hangzhou, help me check the weather forecast",
          "output": "weather_search(China (Hangzhou))"
      },
  ]

• Para cenários de múltiplas intenções ou diálogos de múltiplas rodadas, a intenção do usuário pode ser expressa ao longo de várias rodadas de conversa. Nesses casos, prepare dados de diálogo de múltiplas rodadas e rotule as entradas do usuário de todas as rodadas relevantes. Por exemplo, considere este diálogo de múltiplas rodadas com um assistente de voz:

  User: I want to listen to music.
  Assistant: What type of music?
  User: Play some *** music for me.
  Assistant: play_music(***)

  Os dados de treinamento correspondentes para este diálogo de múltiplas rodadas são formatados da seguinte maneira:

  [
      {
          "instruction": "I want to listen to music. Play some *** music for me.",
          "output": "play_music(***)"
      }
  ]

Treinar um modelo em diálogos de múltiplas rodadas aumenta significativamente o comprimento da entrada, e esses cenários são menos comuns na prática. Considere o treinamento de diálogo de múltiplas rodadas apenas se o reconhecimento de intenção de rodada única não atender às suas necessidades de negócios. Esta solução usa um exemplo de diálogo de rodada única para demonstrar o processo.

Usar o PAI-iTAG para rotular dados

Como alternativa, use a plataforma PAI-iTAG para rotular dados e gerar um conjunto de dados de treinamento no formato necessário.

1. Registre os dados a serem rotulados no iTAG como um conjunto de dados do PAI.

   1. Prepare um arquivo de dados no formato de manifesto de acordo com as estratégias de preparação de dados. O exemplo a seguir ilustra esse formato.

      {"data":{"instruction": "I want to listen to music"}}
      {"data":{"instruction": "It's too loud, turn the volume down"}}
      {"data":{"instruction": "I don't want to listen anymore, turn it off"}}
      {"data":{"instruction": "I want to travel to Hangzhou, help me check the weather forecast"}}

   2. Acesse a página AI Asset Management > Datasets, selecione o workspace de destino e clique em acesse Dataset.

   3. Clique em Create Dataset e configure os seguintes parâmetros-chave. Para detalhes sobre outros parâmetros, consulte crie e gerencie datasets.

      Parâmetro	Descrição
      Storage Type	Selecione Alibaba Cloud Object Storage Service (OSS).
      Import Format	Selecione File.
      OSS Path	Selecione um diretório do OSS existente e faça o upload do arquivo de manifesto preparado seguindo estas etapas: Clique no ícone . Na caixa de diálogo Select OSS file, clique em Upload File. Clique em Browse Local Files ou Drag and Drop File to Upload e, em seguida, faça o upload do arquivo de manifesto conforme solicitado.

2. Acesse a página Data Preparation > iTAG, clique em Go to Management Page e, em seguida, mude para a aba Template Management.

3. Clique em Create Template, selecione Custom Template > Basic Templates e clique em Edit. Após configurar os parâmetros, clique em Save Template Name. A tabela a seguir descreve as configurações-chave. Para mais informações sobre outras configurações, consulte template management.

   Configuração	Descrição
   Área da tela do modelo básico	Selecione Text e clique em Generate Content Card. Clique na área de texto. Na caixa de diálogo Import Dataset, selecione um conjunto de dados existente. Em seguida, na área Basic Template Configuration à direita, selecione Dataset Field Name > instruction.
   Área de resposta do modelo básico	Selecione Input Field e clique em Generate Title Card. Depois, altere o Title para output.

4. No painel de navegação à esquerda, escolha Management Center > Task Management. Na aba Task Management, clique em Create Task. Na página crie Annotation Task, configure os parâmetros e clique em Create. A tabela a seguir descreve os parâmetros-chave. Para detalhes sobre outros parâmetros, consulte crie a labeling task.

   Parâmetro	Descrição
   Input data set	Selecione o conjunto de dados criado na etapa anterior. Nota Certifique-se de que os dados de entrada correspondam ao modelo que você está usando.
   Template Type	Selecione Custom Template e escolha o modelo criado na lista suspensa.

5. Após a criação da tarefa, comece a rotular os dados. Para mais informações, consulte Process labeling tasks.

6. Ao terminar de rotular os dados, exporte os resultados para um diretório do OSS. Para mais informações, consulte Export labeled data.

   O arquivo de manifesto de saída será semelhante ao exemplo a seguir. Para mais informações sobre o formato dos dados, consulte Overview of labeled data formats.

   {"data":{"instruction":"I want to listen to music","_itag_index":""},"label-1947839552568066048-system":{"fixedFlag":0,"results":[{"MarkResultId":"1947839554911772672","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"play_music()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236185165","MarkTime":"Wed Jul 23 10:03:05 CST 2025","UserMarkResultId":null,"IsNeedVoteJudge":false}],"abandonFlag":0},"label-1947839552568066048":{"results":[{"MarkResultId":"1947839554911772672","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"play_music()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236185165","MarkTime":"Wed Jul 23 10:03:05 CST 2025","UserMarkResultId":"1947839763671740416","IsNeedVoteJudge":false}]},"abandonFlag":0,"abandonRemark":null}
   {"data":{"instruction":"It's too loud, turn the volume down","_itag_index":""},"label-1947839552568066048-system":{"fixedFlag":0,"results":[{"MarkResultId":"1947839554891464704","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"volume_down()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236198979","MarkTime":"Wed Jul 23 10:03:19 CST 2025","UserMarkResultId":null,"IsNeedVoteJudge":false}],"abandonFlag":0},"label-1947839552568066048":{"results":[{"MarkResultId":"1947839554891464704","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"volume_down()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236198979","MarkTime":"Wed Jul 23 10:03:19 CST 2025","UserMarkResultId":"1947839868520656896","IsNeedVoteJudge":false}]},"abandonFlag":0,"abandonRemark":null}
   {"data":{"instruction":"I don't want to listen anymore, turn it off","_itag_index":""},"label-1947839552568066048-system":{"fixedFlag":0,"results":[{"MarkResultId":"1947839554992373760","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"music_exit()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236212152","MarkTime":"Wed Jul 23 10:03:32 CST 2025","UserMarkResultId":null,"IsNeedVoteJudge":false}],"abandonFlag":0},"label-1947839552568066048":{"results":[{"MarkResultId":"1947839554992373760","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"music_exit()\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236212152","MarkTime":"Wed Jul 23 10:03:32 CST 2025","UserMarkResultId":"1947839936657285120","IsNeedVoteJudge":false}]},"abandonFlag":0,"abandonRemark":null}
   {"data":{"instruction":"I want to travel to Hangzhou, help me check the weather forecast","_itag_index":""},"label-1947839552568066048-system":{"fixedFlag":0,"results":[{"MarkResultId":"1947839554971426816","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"weather_search(China (Hangzhou))\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236218730","MarkTime":"Wed Jul 23 10:03:39 CST 2025","UserMarkResultId":null,"IsNeedVoteJudge":false}],"abandonFlag":0},"label-1947839552568066048":{"results":[{"MarkResultId":"1947839554971426816","MarkTitle":"Basic Template","MarkResult":"{\"tabId\":\"CommonExtensions\",\"annotations\":[{\"id\":null,\"labels\":{\"output\":\"weather_search(China (Hangzhou))\"},\"exif\":null}],\"type\":\"CommonExtensions\",\"version\":\"v2\"}","QuestionId":"CommonExtensions","ResultType":"OPEN_GROUP","Progress":null,"Version":"1753236218730","MarkTime":"Wed Jul 23 10:03:39 CST 2025","UserMarkResultId":"1947839975890939904","IsNeedVoteJudge":false}]},"abandonFlag":0,"abandonRemark":null}

7. Em um terminal, execute o seguinte script Python para converter o arquivo de manifesto dos dados rotulados no formato de dados de treinamento exigido pelo QuickStart.

   import json
   # Input and output file paths
   input_file_path = 'test_json.manifest'
   output_file_path = 'train.json'
   converted_data = []
   with open(input_file_path, 'r', encoding='utf-8') as file:
       for line in file:
           try:
               # Parse the JSON data from each line
               data = json.loads(line)
               # Extract the instruction
               instruction = data['data']['instruction']
               # Iterate through all keys that start with "label-"
               for key in data.keys():
                   if key.startswith('label-'):
                       # Extract MarkResult and parse its content
                       mark_result_str = data[key]['results'][0]['MarkResult']
                       mark_result = json.loads(mark_result_str)  # Parse the MarkResult string as JSON
                       # Extract labels["output"] from annotations
                       output = mark_result['annotations'][0]['labels']['output']
                       # Construct the new data structure
                       converted_data.append({
                           'instruction': instruction,
                           'output': output
                       })
                       break
           except Exception as e:
               print(f"Error processing line: {line.strip()}. Error: {e}")
   # Write the converted data to the output file
   with open(output_file_path, 'w', encoding='utf-8') as outfile:
       json.dump(converted_data, outfile, ensure_ascii=False, indent=4)
   print(f"Conversion completed. Output saved to {output_file_path}")
   

Treinar o modelo

O QuickStart oferece excelentes modelos pré-treinados da comunidade de IA de código aberto (source). Ele permite gerenciar todo o fluxo de trabalho de desenvolvimento do modelo — desde o treinamento e a implantação até a inferência — sem escrever nenhuma linha de código.

Este guia usa o modelo Qwen1.5-1.8B-Chat como exemplo para mostrar como treinar um modelo no QuickStart com seus dados de treinamento. Siga estas etapas:

1. Acesse a página home Model Gallery.

   1. Acesse o PAI console.

   2. No canto superior esquerdo, selecione uma região.

   3. No painel de navegação à esquerda, escolha Workspaces. Clique no workspace de destino.

   4. No painel de navegação à esquerda, escolha QuickStart > Model Gallery.

2. Na página do QuickStart, localize e clique no cartão do modelo Qwen1.5-1.8B-Chat na lista de modelos à direita.

3. Na página de detalhes do modelo, clique em Train no canto superior direito. No painel de configuração Train, configure os seguintes parâmetros-chave e deixe o restante com os valores padrão.

   Parâmetro		Descrição
   Training Mode		full-parameter fine-tuning: Este método consome muitos recursos e tempo, mas geralmente produz melhores resultados. Nota Modelos com menos parâmetros suportam ajuste fino de parâmetros completos. Escolha este método com base em seus requisitos específicos. QLoRA: Um método de ajuste fino leve que requer menos recursos e menos tempo de treinamento do que o ajuste fino de parâmetros completos, embora os resultados possam ser menos ideais. LoRA: Semelhante ao QLoRA, é um método de ajuste fino leve.
   Dataset	Training dataset	Siga estas etapas para selecionar seu conjunto de dados de treinamento. Na lista suspensa, selecione OSS file or directory. Clique no ícone Browse para selecionar seu diretório do OSS. Na caixa de diálogo Select OSS File, clique em Upload File, arraste e solte o arquivo do seu conjunto de dados de treinamento e, em seguida, clique em OK.
   Output Configuration	Model output path	Selecione um diretório do OSS para armazenar os arquivos de configuração e de modelo gerados pelo job de treinamento.
   	Tensorboard Output Path
   Hyperparameter Configuration		Para uma descrição detalhada de todos os hiperparâmetros, consulte Table 1. Hyperparameter reference. Use as seguintes estratégias para configurar os hiperparâmetros. Para as configurações recomendadas de hiperparâmetros-chave para diferentes métodos de treinamento, consulte Table 2. Recommended hyperparameter configurations. Certifique-se de configurar os hiperparâmetros com base no método de treinamento selecionado. global batch size = Number of GPUs per_device_train_batch_size gradient_accumulation_steps Para maximizar o desempenho do treinamento, priorize o aumento do número de GPUs e do per_device_train_batch_size. Normalmente, defina o global batch size para um valor entre 64 e 256. Se o seu conjunto de dados de treinamento for muito pequeno, use um valor menor. O comprimento da sequência (seq_length) pode ser ajustado com base no seu cenário específico. Por exemplo, se o comprimento máximo da sequência no seu conjunto de dados for 50, defina o comprimento da sequência como 64, que tipicamente é uma potência de 2. Se a perda de treinamento diminuir muito lentamente ou não convergir, considere aumentar a taxa de aprendizado (learning_rate). Além disso, garanta a qualidade dos seus dados de treinamento.

   Tabela 1. Hiperparâmetros

   Parâmetro	Tipo	Descrição	Padrão
   learning_rate	FLOAT	A taxa de aprendizado para o treinamento do modelo.	5e-5
   num_train_epochs	INT	O número de épocas de treinamento.	1
   per_device_train_batch_size	INT	O tamanho do lote de treinamento para cada gpu.	1
   seq_length	INT	O comprimento máximo da sequência para as entradas do modelo.	128
   lora_dim	INT	A dimensão do LoRA. Quando lora_dim > 0, utiliza-se o ajuste fino leve com LoRA ou QLoRA.	32
   lora_alpha	INT	O fator de escala do LoRA. Este parâmetro tem efeito no ajuste fino leve com LoRA ou QLoRA quando lora_dim > 0.	32
   load_in_4bit	BOOL	Se true, carrega o modelo base em precisão de 4 bits. Isso habilita o QLoRA de 4 bits quando lora_dim > 0 e load_in_8bit é false.	false
   load_in_8bit	BOOL	Se true, carrega o modelo base em precisão de 8 bits. Isso habilita o QLoRA de 8 bits quando lora_dim > 0 e load_in_4bit é false.	false
   gradient_accumulation_steps	INT	O número de etapas de acumulação de gradiente.	8
   apply_chat_template	BOOL	Especifica se o algoritmo adiciona o Chat Template padrão do modelo aos dados de treinamento. Para modelos da série Qwen1.5, o formato é o seguinte: Pergunta: <|im_start|>user\n + instruction + <|im_end|>\n Resposta: <|im_start|>assistant\n + output + <|im_end|>\n	true
   system_prompt	STRING	O prompt do sistema padrão para o treinamento do modelo. Este parâmetro tem efeito quando apply_chat_template é definido como true. Ao treinar modelos da série Qwen1.5, configure um system_prompt personalizado para atribuir uma função específica ao modelo de linguagem de grande porte. O algoritmo expande automaticamente os dados de treinamento, portanto, você não precisa gerenciar os detalhes. Por exemplo, se você definir system_prompt como "You are an expert in intent recognition. You can identify the user's intent from their question and return the corresponding function calling and parameters." Para a seguinte amostra de treinamento: [ { "instruction": "I want to listen to music", "output": "play_music()" } ] Os dados reais usados para o treinamento são formatados da seguinte maneira: <|im_start|>system\nYou are an expert in intent recognition. You can identify the user's intent from their question and return the corresponding function calling and parameters<|im_end|>\n<|im_start|>user\nI want to listen to music<|im_end|>\n<|im_start|>assistant\nplay_music()<|im_end|>\n	You are a helpful assistant

   Tabela 2. Hiperparâmetros recomendados

   Parâmetro	Ajuste fino de parâmetros completos	LoRA/QLoRA
   learning_rate	5e-6, 5e-5	3e-4
   global batch size	256	256
   seq_length	256	256
   num_train_epochs	3	5
   lora_dim	0	64
   lora_alpha	0	16
   load_in_4bit	false	true/false
   load_in_8bit	false	true/false

4. Clique em Fine-tune e, em seguida, clique em OK na caixa de diálogo Billing Notification.

   O sistema redireciona você automaticamente para a página de detalhes do job de treinamento. Após a criação do job, seu status muda para Running. A página exibe o progresso do job em várias etapas: Creating, Preparing Environment e Running. Informações básicas são exibidas, incluindo o modelo pré-treinado qwen1.5-1.8b-chat, o método de treinamento SFT supervised fine-tuning: LoRA e a categoria do job Generative AI / large language model. Você pode visualizar detalhes como caminhos de entrada, caminhos de saída e configurações de hiperparâmetros nas abas Task Details, Task Log e Task Monitoring.

Avaliar o modelo

Após a conclusão do treinamento, avalie o desempenho do modelo execute um script Python em um terminal.

1. Prepare um arquivo de dados de avaliação chamado testdata.json. O exemplo a seguir ilustra esse formato:

   [
       {
           "instruction": "Who sings the song 'Ten Years'?",
           "output": "music_query_player(Ten Years)"
       },
       {
           "instruction": "What's the weather like in Hangzhou today?",
           "output": "weather_search(Hangzhou)"
       }
   ]

2. Execute o seguinte script Python em um terminal e execute o modelo offline.

   #encoding=utf-8
   from transformers import AutoModelForCausalLM, AutoTokenizer
   import json
   from tqdm import tqdm
   device = "cuda" # the device to load the model onto
   # Modify the model path
   model_name = '/mnt/workspace/model/qwen14b-lora-3e4-256-train/'
   print(model_name)
   model = AutoModelForCausalLM.from_pretrained(
       model_name,
       torch_dtype="auto",
       device_map="auto"
   )
   tokenizer = AutoTokenizer.from_pretrained(model_name)
   count = 0
   ecount = 0
   # Modify the training data path
   test_data = json.load(open('/mnt/workspace/data/testdata.json'))
   system_prompt = 'You are an expert in intent recognition. You can identify the user\'s intent from their question and return the corresponding function calling and parameters.'
   for i in tqdm(test_data[:]):
       prompt = '<|im_start|>system\n' + system_prompt + '<|im_end|>\n<|im_start|>user\n' + i['instruction'] + '<|im_end|>\n<|im_start|>assistant\n'
       gold = i['output']
       gold = gold.split(';')[0] if ';' in gold else gold
       model_inputs = tokenizer([prompt], return_tensors="pt").to(device)
       generated_ids = model.generate(
           model_inputs.input_ids,
           max_new_tokens=64,
           pad_token_id=tokenizer.eos_token_id,
           eos_token_id=tokenizer.eos_token_id,
           do_sample=False
       )
       generated_ids = [
           output_ids[len(input_ids):] for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids)
       ]
       pred = tokenizer.batch_decode(generated_ids, skip_special_tokens=True)[0]
       if gold.split('(')[0] == pred.split('(')[0]:
           count += 1
           gold_list = set(gold.strip()[:-1].split('(')[1].split(','))
           pred_list = set(pred.strip()[:-1].split('(')[1].split(','))
           if gold_list == pred_list:
               ecount += 1
       else:
           pass
   print("Intent recognition accuracy:", count/len(test_data))
   print("Parameter recognition accuracy:", ecount/len(test_data))

   Nota

   Se a execução do código retornar a mensagem Using low_cpu_mem_usage=True or a device_map requires Accelerate: pip install accelerate, execute pip install accelerate e instale a dependência necessária.

Implantar o serviço do modelo

Se os resultados da avaliação do modelo atenderem às suas expectativas, implante o modelo como um serviço online do EAS.

1. Na página Task details, clique em Deploy no canto superior direito. O sistema preenche previamente as informações básicas e de recursos. Para Deployment Method, selecione vLLM accelerated deployment. modifique essas configurações conforme necessário. Após configurar os parâmetros, clique em Deploy.

2. Na caixa de diálogo Billing Notification, clique em OK.

   O sistema redireciona você automaticamente para a página da tarefa de implantação. Quando o Status mudar para Running, a implantação será bem-sucedida.

Invocar o serviço do modelo

O exemplo a seguir mostra como chamar a api a partir de um cliente:

1. Obtenha o endpoint e o token.

   1. Na página Service details, na seção Basic Information, clique em View Endpoint Information.

   2. Na caixa de diálogo Invocation Information, localize o endpoint e o token e salve-os localmente.

2. O exemplo a seguir é um código para uma vLLM accelerated deployment. Execute este código em um terminal para invocar o serviço.

   from openai import OpenAI
   ##### API Configuration #####
   openai_api_key = "<YOUR_EAS_SERVICE_TOKEN>"
   openai_api_base = "<YOUR_EAS_SERVICE_ENDPOINT>/v1/"
   client = OpenAI(
       api_key=openai_api_key,
       base_url=openai_api_base,
   )
   models = client.models.list()
   model = models.data[0].id
   print(model)
   def main():
       stream = True
       chat_completion = client.chat.completions.create(
           messages=[
                {
                   "role": "system",
                   "content": [
                       {
                           "type": "text",
                           "text": "You are an expert in intent recognition. You can identify the user's intent based on their question and return the corresponding intent and parameters.",
                       }
                   ],
               },
               {
                   "role": "user",
                   "content": [
                       {
                           "type": "text",
                           "text": "I want to listen to music",
                       }
                   ],
               }
           ],
           model=model,
           max_completion_tokens=2048,
           stream=stream,
       )
       if stream:
           for chunk in chat_completion:
               print(chunk.choices[0].delta.content, end="")
       else:
           result = chat_completion.choices[0].message.content
           print(result)
   if __name__ == "__main__":
       main()
   

   Onde:

   • <YOUR_EAS_SERVICE_ENDPOINT>: Substitua pelo endpoint do seu serviço.

   • <YOUR_EAS_SERVICE_TOKEN>: Substitua pelo token do seu serviço.