Os modelos Quen 2 da Alibaba são os mais recentes e avançados modelos de linguagem de código aberto, oferecendo capacidades impressionantes em uma ampla gama de tarefas. Esses modelos variam de 500 milhões a 72 bilhões de parâmetros, com os modelos maiores suportando até 128.000 tokens - uma melhoria significativa em relação ao limite de 8.000 tokens do GPT-3.

Uma das principais características do Quen 2 é seu forte desempenho em codificação e matemática, bem como sua capacidade de lidar com o entendimento de contexto longo - crucial para aplicações do mundo real. Além disso, os modelos oferecem suporte a um conjunto diversificado de idiomas, incluindo um foco em idiomas do Oriente Médio e do Sudeste Asiático, o que é uma mudança bem-vinda em relação ao foco centrado em idiomas ocidentais de muitos outros modelos.

Para aproveitar o poder do Quen 2, podemos usar a estrutura do Quen Agent, que fornece acesso a um assistente de navegador integrado, um interpretador de código e a capacidade de criar assistentes personalizados. Isso nos permite construir agentes autônomos que podem planejar, executar e adaptar suas ações com base na tarefa em questão.

Nesta seção, exploraremos como usar o Quen Agent para criar um agente personalizado de geração de imagens. O agente será capaz de gerar imagens com base na entrada do usuário, baixar as imagens geradas e até mesmo atualizar seu próprio código se encontrar algum problema. Ao combinar o poderoso entendimento da linguagem do Quen 2 com as capacidades de planejamento e execução do Quen Agent, podemos criar agentes verdadeiramente autônomos e capazes de lidar com uma ampla gama de tarefas.

A chamada de função e os agentes são dois conceitos distintos no mundo dos modelos de linguagem de grande porte (LLMs). Aqui está uma explicação concisa das diferenças entre os dois:

Chamada de Função (Uso de Ferramentas):

• A chamada de função, ou uso de ferramentas, permite que o LLM interaja com o mundo externo acessando APIs ou funções externas.
• O LLM determina qual função usar com base na entrada do usuário, gera os inputs necessários para a função e retorna os resultados ao usuário.
• No entanto, o próprio LLM não pode executar a chamada de função; o usuário ou um sistema separado deve fazer a chamada de função real e retornar os resultados ao LLM.

Agentes:

• Os agentes são instâncias mais sofisticadas de LLMs que têm acesso a um conjunto de ferramentas, assim como na chamada de função.
• Os agentes também podem realizar planejamento, decompor tarefas em sub-objetivos e executar ações usando as ferramentas disponíveis.
• Os agentes têm acesso à memória de curto e longo prazo, permitindo que eles acompanhem seu progresso e planejem seus próximos passos de acordo.
• Os agentes são fundamentais para tornar os LLMs realmente úteis em aplicações do mundo real, pois podem executar tarefas complexas de forma autônoma.

Em resumo, a chamada de função é uma interação mais limitada em que o LLM pode apenas gerar os inputs necessários para uma função, enquanto os agentes têm a capacidade de planejar, executar e adaptar suas ações para alcançar um resultado desejado.

Para começar com os agentes Qwen, usaremos a versão de 72 bilhões do Qwen 2 e a executaremos localmente usando o AMA. Você também pode usar sua API externa, mas para usar o Qwen Agent, temos duas opções:

1. Instale o pacote usando o pip como um pacote Python independente.
2. Clone o repositório e execute a instalação localmente se você quiser a versão de desenvolvimento mais recente.

Eu vou executá-lo localmente usando o AMA. Primeiro, inicie um servidor AMA e use o comando olama Run Qwen 272 billion. Isso baixará o AMA e o modelo, o que pode levar algum tempo, dependendo da sua velocidade de internet.

Em seguida, crie um ambiente virtual usando o conda e ative-o:

conda create -n qwen python=3.10
conda activate qwen

Agora, instale o pacote Qwen Agent usando o pip:

pip install qwen-agent

Vamos começar com a chamada de função. O modelo precisa escolher a função a ser usada, descobrir os inputs e passá-los para um interpretador Python. O interpretador executará a função, obterá a resposta e a enviará de volta ao LLM.

Aqui está um exemplo de chamada de função para obter o clima atual:

# Crie a instância do LLM
llm = QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1")

# Mensagem do usuário
mensagem_usuario = "Como está o clima atual em Paris?"

# Definir a função
chamada_funcao = {
    "description": "Obter o clima atual para um determinado local",
    "function": "get_weather",
    "arguments": {
        "location": "Paris",
        "unit": "celsius"
    }
}

# Chamar o LLM e executar a função
resposta = llm.call_with_function(mensagem_usuario, [chamada_funcao])
print(resposta)

Isso gerará as informações climáticas atuais de Paris e as retornará ao LLM.

Agora, vamos ver um exemplo de uso do Qwen Agent. Criaremos um agente personalizado que pode gerar imagens e baixá-las em uma pasta local. O agente usará uma ferramenta personalizada para geração de imagens e o interpretador de código para executar o código necessário.

from qwen_agent import Assistant, CodeInterpreter, CustomTool

# Definir a ferramenta personalizada de geração de imagens
class MyImageGeneration(CustomTool):
    def __init__(self):
        self.description = "Gerar imagens com base na entrada do usuário usando a API da Pollinations.AI."

    def run(self, args):
        # Gerar a imagem usando a API
        url_imagem = gerar_imagem(args["prompt"])
        
        # Baixar a imagem para uma pasta local
        baixar_imagem(url_imagem, "imagens")

        return "Imagem gerada e salva na pasta 'imagens'."

# Criar o agente
agente = Assistant(
    llm=QwenLLM(base_api="http://localhost:8000/v1", model_name="qwen-2-72b", version="v1"),
    tools=[MyImageGeneration(), CodeInterpreter()]
)

# Pedir ao agente para gerar uma imagem
agente.run("Crie uma imagem de uma lhama usando óculos de sol.")

Esse agente usará a ferramenta personalizada de geração de imagens para criar a imagem, baixá-la para a pasta "imagens" e retornar o resultado.

Finalmente, vamos examinar o impacto da quantização no desempenho dos modelos Qwen. A equipe do Qwen forneceu avaliações detalhadas sobre as métricas MML, C-Evolve e I-Evolve para diferentes níveis de quantização.

Os resultados mostram que, para modelos maiores (72 bilhões), a diferença entre a quantização de 16 bits e 8 bits não é significativa, mas a quantização de 4 bits pode ter um impacto mais perceptível no desempenho. Para modelos menores (0,5 bilhão), as diferenças são mais pronunciadas, com a quantização de 4 bits mostrando uma queda de 5 pontos na pontuação média.

Em geral, é recomendado usar pelo menos a quantização de 8 bits ou 16 bits para implantações de produção, pois a quantização de 4 bits pode ter um impacto mais significativo no desempenho do modelo, especialmente para modelos menores.