Skip to content

Principais 10 Alternativas de Código Aberto ao ChatGPT: Superando as Limitações na IA Conversacional

Os chatbots revolucionaram a forma como as empresas interagem com seus clientes. O estado-da-arte GPT-4, desenvolvido pela OpenAI, é um dos principais modelos nesse campo. No entanto, ele não é de código aberto, o que restringe os desenvolvedores de reproduzirem os resultados ou desenvolverem seus próprios chatbots semelhantes ao GPT-4.

Para preencher essa lacuna, comunidades de código aberto começaram a oferecer alternativas ao GPT-4 que oferecem desempenho e funcionalidade quase idênticos, ao mesmo tempo em que exigem menos poder computacional. Este artigo tem como objetivo apresentar as 10 principais alternativas de código aberto ao ChatGPT que você pode utilizar em seu próximo projeto de IA.

1. ColossalChat

ColossalChat (opens in a new tab), desenvolvido pela HPC AI Tech, é um projeto de código aberto projetado para replicar modelos semelhantes ao ChatGPT com base no modelo LLaMa e no framework de IA PyTorch. É o primeiro projeto de código aberto prático que inclui um processo completo de Aprendizado por Reforço a partir de Feedback Humano (RLHF), tornando-o o projeto mais próximo da rota técnica original do ChatGPT.

O ColossalChat aproveita o framework flexível e eficiente de deep learning do PyTorch, que permite prototipagem rápida, integração perfeita com outras bibliotecas e oferece uma experiência de IA conversacional de alto desempenho e fácil utilização.

Uma das principais características do ColossalChat é o seu conjunto de dados bilíngue, que compreende aproximadamente 100.000 pares de perguntas e respostas em inglês e chinês. Esse conjunto de dados foi coletado e limpo a partir de cenários reais de perguntas em plataformas de mídia social e serve como conjunto de dados inicial. Ele foi expandido usando a tecnologia de autoinstrução. Esses dados de alta qualidade permitem que o ColossalChat alcance interações de diálogo melhores e também ofereça suporte ao chinês.

O ColossalChat segue um processo de replicação em três etapas do algoritmo RLHF. A primeira etapa envolve o ajuste fino instruído supervisionado. A segunda etapa envolve o treinamento de um modelo de recompensa. E a terceira etapa usa o algoritmo de aprendizado por reforço. Esse processo de replicação permite uma maior consistência do conteúdo gerado com os valores humanos.

Este projeto é suportado pelo sistema de desenvolvimento de modelos grandes de IA Colossal-AI, que pode implantar de forma eficiente e rápida o treinamento e inferência de modelos grandes de IA com base na funcionalidade padrão do PyTorch. Essa infraestrutura fornece suporte fundamental e melhora significativamente a velocidade de treinamento.

Aqui está um exemplo de como treinar o ColossalChat em cada etapa do RLHF:

# Treinamento com 4 servidores GPU
colossalai run — nproc_per_node=4 train_sft.py \
— pretrain “/caminho/para/LLaMa-7B/\
— model ‘llama’ \
— strategy colossalai_zero2 \
— log_interval 10 \
— save_path /caminho/para/Coati-7B \
— dataset /caminho/para/data.json \
— batch_size 4 \
— accimulation_steps 8 \
— lr 2e-5
 
# Treinamento com 4 servidores GPU
colossalai run — nproc_per_node=4 train_reward_model.py \
— pretrain “/caminho/para/LLaMa-7B/\
— model ‘llama’ \
— strategy colossalai_zero2 \
— dataset /caminho/para/conjunto_de_dados
 
# Treinamento com 8 servidores GPU
colossalai run — nproc_per_node=8 train_prompts.py prompts.csv \
— strategy colossalai_zero2 \
— pretrain “/caminho/para/Coati-7B” \
— model ‘llama’ \
— pretrain_dataset /caminho/para/conjunto_de_dados

O código completo para replicar o ChatGPT com base no modelo LLaMa é de código aberto e pode ser acessado tanto por desenvolvedores quanto por pesquisadores.

2. Alpaca-LoRA

Alpaca-LoRA (opens in a new tab) parece ser uma ferramenta altamente eficiente para ajuste fino de modelos de linguagem, como o LLaMa, graças ao uso da técnica LoRA (Low-rank adaptation).

O LoRA oferece várias vantagens em relação a outros métodos de ajuste fino, incluindo:

  • Maior velocidade e menor consumo de memória, tornando-o compatível com hardware de consumo.
  • Tamanho de saída menor (megabytes em vez de gigabytes).
  • Capacidade de combinar vários modelos ajustados durante a execução.

O Alpaca-LoRA, que implementa a biblioteca PEFT (Python Easy Fine-Tuning), permite o ajuste fino de modelos de linguagem baseados em transformadores usando LoRA. Isso leva a um ajuste fino eficiente e econômico do modelo, mesmo em hardware modesto, com saídas potencialmente componíveis.

Os passos para ajustar fino o LLaMa usando o Alpaca-LoRA são os seguintes:

Pré-requisitos

Antes de começar, certifique-se de ter acesso a uma máquina com GPU. Mesmo GPUs de baixa especificação, como um NVIDIA T4, ou GPUs de consumo, como uma 4090, são adequados devido à eficiência do LoRA. Além disso, você precisa dos pesos para o LLaMa, que ainda não estão disponíveis publicamente. Você pode solicitar acesso por meio do formulário Meta Research.

Etapa 1: Clonar o repositório Alpaca-LoRA

Clone o repositório do Alpaca-LoRA que inclui suporte para o Cog (uma ferramenta usada para empacotar modelos de aprendizado de máquina em contêineres). Use os seguintes comandos:

git clone https://github.com/daanelson/alpaca-lora
cd alpaca-lora

Etapa 2: Instalar o Cog

Em seguida, instale o Cog com os seguintes comandos:

sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)"
sudo chmod +x /usr/local/bin/cog

Etapa 3: Obter os pesos do LLaMa

Coloque os pesos baixados em uma pasta chamada 'unconverted-weights'. A estrutura do diretório deve ser assim:

unconverted-weights
├── 7B
│   ├── checklist.chk
│   ├── consolidated.00.pth
│   └── params.json
├── tokenizer.model
└── tokenizer_checklist.chk

Converta os pesos de um checkpoint PyTorch para um formato compatível com o transformers usando o seguinte comando:

cog run python -m transformers.models.llama.convert_llama_weights_to_hf \
  --input_dir unconverted-weights \
  --model_size 7B \
  --output_dir weights

Sua estrutura final de diretório deve ser assim:

weights
├── llama-7b
└── tokenizermdki

Etapa 4: Ajustar fino o modelo

Se você tiver uma GPU com mais memória, pode aumentar o

MICRO_BATCH_SIZE para 32 ou 64 no arquivo finetune.py. Se você tiver seu próprio conjunto de dados de ajuste de instrução, edite o DATA_PATH no arquivo finetune.py para apontar para o seu próprio conjunto de dados. Certifique-se de que ele tenha o mesmo formato que alpaca_data_cleaned.json.

Execute o script de ajuste fino:

cog run python finetune.py

O ajuste fino pode levar cerca de 3,5 horas em uma GPU A100 de 40GB. Pode levar mais tempo para GPUs com menos poder de processamento.

Etapa 5: Executar o modelo com o Cog

Por fim, você pode executar o modelo usando o Cog. Por exemplo:

$ cog predict -i prompt="Diga-me algo sobre as alpacas."

A resposta será uma saída informativa sobre as alpacas, demonstrando o ajuste fino bem-sucedido do seu modelo LLaMa.

3. Vicuna-13B

Parte do FastChat, o Vicuna aproveita uma arquitetura baseada em transformadores, semelhante aos modelos GPT, e é ajustado com base em conjuntos de dados conversacionais do ShareGPT.com. Ele oferece aproximadamente 90% do desempenho do ChatGPT, fornecendo uma alternativa acessível e econômica. Apesar do desempenho inferior, o Vicuna se destaca devido à sua excelente capacidade de personalização e adaptabilidade a uma ampla variedade de tarefas.

Para mais detalhes sobre como usá-lo, consulte nosso artigo detalhado sobre Vicuna-13B.

4. GPT4ALL

O GPT4ALL da equipe Nomic AI oferece um chatbot construído com base em um extenso conjunto de dados curados, como problemas de palavras, código, histórias, ilustrações e diálogos de várias etapas. Embora utilize o LLaMa para aceleração de ML de baixa latência, assim como o GPT-4, a força do GPT4ALL reside em seu conjunto de dados diversificado e adaptabilidade a várias tarefas. Aqui está um exemplo de GPT4ALL em ação:

Para mais detalhes sobre como usá-lo, consulte nosso artigo detalhado sobre GPT4ALL.

5. Raven RWKV

O RWKV (opens in a new tab) (Raven RWKV) é um modelo mais recente, com base no meu conhecimento até setembro de 2021. No entanto, com base nas informações fornecidas, aqui está um guia geral passo a passo sobre como usá-lo, juntamente com alguns trechos de código:

Primeiro, você precisará instalar o pacote necessário. O pacote RWKV está hospedado no PyPI e você pode instalá-lo usando o pip:

pip install rwkv

Em seguida, você precisará importar o modelo do pacote:

from rwkv.model import RWKV

Depois, você instanciará o modelo. Isso envolve especificar o caminho do modelo e a estratégia a ser usada:

model =
 
 RWKV(model='/caminho/para/seu/modelo', strategy='cuda fp16')

Isso cria uma instância do modelo que pode ser usada para inferência.

A seguir, você usará o método forward do modelo para realizar a inferência. Esse método recebe dois parâmetros: os tokens de entrada e o estado. Para a primeira execução, você pode definir o estado como None:

out, state = model.forward([187, 510, 1563, 310, 247], None)

Você pode então imprimir a saída do modelo:

print(out.detach().cpu().numpy())

Em seguida, para execuções subsequentes, você pode fornecer o estado da execução anterior:

out, state = model.forward([187, 510], None)
out, state = model.forward([1563], state)
out, state = model.forward([310, 247], state)
print(out.detach().cpu().numpy())

Este guia passo a passo mostra o uso básico do modelo RWKV para inferência. É importante observar que as etapas específicas podem variar dependendo da tarefa, dos pesos específicos do modelo sendo usados e de outros fatores. Consulte a documentação oficial para obter informações mais precisas.

Além disso, lembre-se de que esse modelo é relativamente novo, e podem ter ocorrido desenvolvimentos e melhorias desde o meu conhecimento até setembro de 2021. Sempre consulte a literatura e a base de código mais recentes e relevantes para obter informações atualizadas e precisas.

6. OpenChatKit

OpenChatKit (opens in a new tab) fornece um conjunto completo de ferramentas para o desenvolvimento de aplicativos de chatbot, posicionando-se como uma alternativa de código aberto ao ChatGPT. Embora seja semelhante aos modelos GPT em termos de estrutura, o OpenChatKit aprimora a personalização, permitindo o treinamento de modelos de linguagem grandes ajustados à instrução e oferecendo um sistema de recuperação extensível para respostas do bot.

Etapa 1: Configuração

Verifique se você tem os requisitos de sistema e dependências necessárias. Você precisará do Git LFS, Miniconda e PyTorch, entre outros. O arquivo environment.yml fornecido contém as especificações do ambiente necessário.

Primeiro, instale o Git LFS e o Miniconda, em seguida, configure o ambiente da seguinte maneira:

git lfs install
conda install mamba -n base -c conda-forge
mamba env create -f environment.yml 
conda activate OpenChatKit

Etapa 2: Conversando com Pythia-Chat-Base-7B:

Para interagir com o modelo, você pode usar o script bot.py localizado no diretório inference:

python inference/bot.py --model togethercomputer/Pythia-Chat-Base-7B

Em seguida, você pode conversar com o modelo digitando texto no prompt da linha de comando fornecido.

Etapa 3: Reproduzindo Pythia-Chat-Base-7B:

Se você deseja treinar o modelo por conta própria, primeiro precisará baixar os dados de treinamento e o modelo base:

python data/OIG/prepare.py
python pretrained/Pythia-6.9B-deduped/prepare.py

Em seguida, você pode ajustar o modelo usando o script de shell fornecido:

bash training/finetune_Pythia-Chat-Base-7B.sh

Após o treinamento, converta o modelo para o formato Huggingface usando a ferramenta de conversão:

mkdir huggingface_models
python tools/convert_to_hf_gptneox.py \
   --config-name EleutherAI/pythia-6.9b-deduped \
   --ckpt-path model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 \
   --save-path huggingface_models/Pythia-Chat-Base-7B \
   --n-stages 4 \
   --n-layer-per-stage 8 \
   --fp16

Substitua model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 pelo caminho para o ponto de verificação do seu modelo.

Etapa 4: Testando o novo modelo:

Depois de ajustar o seu modelo, você pode conversar com ele usando o script bot.py:

python inference/bot.py --model ./huggingface_models/Pythia-Chat-Base-7B

Etapa 5: Monitoramento:

Para monitorar o treinamento, o OpenChatKit oferece suporte tanto ao loguru quanto ao Weights & Biases.

Etapa 6: Experimental: Modelos com Recuperação Aprimorada

O OpenChatKit também oferece um recurso experimental para modelos com recuperação aprimorada. Isso é implementado consultando um índice Faiss da Wikipedia. Você pode executá-lo da seguinte forma:

python data/wikipedia-3sentence-level-retrieval-index/prepare.py
python inference/bot.py --retrieval

Consulte a documentação oficial do OpenChatKit para obter informações mais detalhadas e precisas. Essas etapas são baseadas nas informações fornecidas.

7. OPT

OPT (opens in a new tab) (Open Pre-trained Transformer) Language Models apresentam habilidades excepcionais em aprendizado sem supervisão e com poucas amostras, além de análise de viés estereotípico, embora não correspondam à qualidade do ChatGPT. Esses modelos são transformadores apenas decodificadores, o que significa que eles geram texto autoregressivamente da esquerda para a direita, semelhante à abordagem dos modelos GPT.

Aqui está uma quebra de etapas mais detalhada sobre como você pode usar os modelos OPT para cada uma dessas tarefas:

Etapa 1: Geração de Texto

Para usar um modelo OPT para geração de texto, você primeiro precisa carregá-lo em um pipeline. Aqui está um exemplo usando a biblioteca Transformers da Hugging Face:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")

Depois de configurar o pipeline, você pode gerar texto da seguinte maneira:

print(generator("Olá, eu sou um", max_length=50)[0]['generated_text'])

Isso imprimirá um texto que começa com "Olá, eu sou um" e continua por até 50 tokens.

Etapa 2: Aprendizado sem Supervisão

O aprendizado sem supervisão envolve aplicar o modelo a tarefas para as quais ele não foi especificamente treinado. Por exemplo, você pode usá-lo para classificação de texto sem a necessidade de treinamento adicional. Veja como fazer isso:

from transformers import pipeline
 
classifier = pipeline("text-classification", model="facebook/opt-350m")
print(classifier("Eu adoro dias ensolarados.", ["clima", "emoção"]))

Isso classificará a frase "Eu adoro dias ensolarados." em termos de "clima" e "emoção" e imprimirá as probabilidades.

Etapa 3: Aprendizado com Poucas Amostras

O aprendizado com poucas amostras envolve fornecer um pequeno número de exemplos para ajudar o modelo a entender a tarefa. Por exemplo, se você quiser que o modelo traduza inglês para francês, pode fornecer algumas traduções de exemplo:

from transformers import pipeline
 
translator = pipeline('translation', model="facebook/opt-350m")
 
exemplos = [
    {"Inglês": "Hello", "Francês": "Bonjour"},
    {"Inglês": "Goodbye", "Francês": "Au revoir"},
]
 
translator.set_examples(exemplos)
 
print(translator("Bom dia"))

Observe que este exemplo é simplificado para fins ilustrativos. O uso real pode ser um pouco mais complicado e exigir uma configuração mais sofisticada.

Etapa 4: Análise de Viés Estereotípico

Você pode usar o modelo OPT para analisar os vieses estereotípicos presentes no texto gerado por ele. Aqui está um exemplo:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")
 
prompt_feminino = "A mulher trabalhou como"
prompt_masculino = "O homem trabalhou como"
 
saida_feminino = generator(prompt_feminino, num_return_sequences=5)
saida_masculino = generator(prompt_masculino, num_return_sequences=5)
 
print("Saídas do prompt feminino:")
for saida in saida_feminino:
    print(saida['generated_text'])
 
print("Saídas do prompt masculino:")
for saida in saida_masculino:
    print(saida['generated_text'])

Isso imprimirá 5 sequências geradas para cada prompt, e você pode analisá-las em busca de possíveis vieses. Esteja ciente de que essa análise pode ser uma tarefa complexa e pode exigir técnicas avançadas de processamento de linguagem natural (NLP).

Lembre-se de que você pode precisar ajustar os nomes dos modelos dependendo dos modelos OPT específicos disponíveis no Hugging Face Model Hub. Além disso, a partir do meu conhecimento até setembro de 2021, algumas funções como translator.set_examples(examples) podem não existir na biblioteca Transformers. Elas foram fornecidas como exemplo conceitual.

8. Flan-T5-XXL

Flan-T5-XXL (opens in a new tab) é uma coleção de modelos T5 ajustados que foram treinados em uma vasta compilação de conjuntos de dados instrucionais. Esses modelos, embora não se baseiem na arquitetura de transformer como os modelos GPT, apresentam desempenho significativamente aprimorado em várias classes de modelos, incluindo PaLM, T5 e U-PaLM.

Para usar o Flan-T5-XXL, você pode seguir o guia de uso de exemplo abaixo:

# Supondo que você já tenha clonado o repositório Flan-T5-XXL e configurado o ambiente
 
from flan_t5_xx1 import FlanT5XXL
 
# Inicialize o modelo Flan-T5-XXL
model = FlanT5XXL()
 
# Exemplo de uso: Gerar instruções para uma tarefa
entrada_tarefa = "Como assar um bolo"
instrucoes = model.generate_instructions(entrada_tarefa)
print(instrucoes)

Esse exemplo demonstra como você pode gerar instruções para uma determinada tarefa usando o modelo Flan-T5-XXL. A variável entrada_tarefa contém a descrição da tarefa, e o método generate_instructions() gera as instruções correspondentes.

Observe que o trecho de código acima pressupõe que você já tenha clonado o repositório Flan-T5-XXL e configurado as dependências necessárias.

O Flan-T5-XXL fornece uma estrutura modular e componível para treinar e avaliar modelos de sequência, com foco em tarefas de linguagem. Ele é implementado usando JAX e Flax, com base no código do T5. O Flan-T5-XXL oferece um alto nível de configurabilidade e capacidades de autoatendimento, permitindo que pesquisadores treinem e avaliem modelos de sequência em diferentes escalas.

É importante consultar a documentação oficial e os exemplos fornecidos pelo Flan-T5-XXL para entender de forma abrangente as funcionalidades disponíveis e como usá-las de forma eficaz.

Um exemplo de uso do Flan-T5-XXL pode ser o seguinte:

from flan import FlanT5
 
# Inicializar o modelo
modelo_flan = FlanT5()
 
# Gerar resposta
resposta = modelo_flan.generate("Traduza este texto para francês.")
print(resposta)

9. Baize

Baize (opens in a new tab) é um modelo de chat de código aberto treinado com LoRA. Ele incorpora 100 mil diálogos autogerados do ChatGPT e utiliza dados do Alpaca para um desempenho aprimorado. Modelos com diferentes tamanhos, como 7B, 13B e 30B, foram lançados.

Para interagir com o Baize usando a CLI (Interface de Linha de Comando) e a API do Fastchat, siga estas etapas:

  1. Instale o Fastchat:
pip install git+https://github.com/huggingface/peft.git
pip install git+https://github.com/lm-sys/FastChat.git
 
 
  1. Combine os pesos LoRA do Baize (apenas para modelos V1):
python3 -m fastchat.model.apply_lora --base huggyllama/llama-7b --target ./model_weights/baize-7b --lora project-baize/baize-lora-7B
  1. Execute a CLI:
python -m fastchat.serve.cli --model-path ./model_weights/baize-7b

O Baize também pode ser usado com a API do OpenAI ou da Hugging Face.

Para o demo do Baize, você pode executá-lo localmente seguindo estas etapas:

  1. Instale os pacotes necessários:
cd demo
pip install -r requirements.txt
  1. Hospede o modelo localmente:
# Para modelos V1
base_model=huggyllama/llama-7b
lora_model=project-baize/baize-lora-7B
python app.py $base_model $lora_model
 
# Para modelos V2
base_model=project-baize/baize-v2-7b
python app.py $base_model None

O demo do Baize fornece uma interface Gradio amigável ao usuário para conversar.

Esses são exemplos de códigos simplificados. Para obter instruções e opções mais detalhadas, consulte a documentação do projeto Baize.

10. Koala

Koala (opens in a new tab) é um modelo de diálogo de IA treinado por meio do ajuste fino do LLaMa em um conjunto de dados de diálogo coletado da web. Ele supera o desempenho do Alpaca e demonstra resultados comparáveis ao ChatGPT em vários cenários. Uma das principais vantagens do Koala é sua ampla personalização e adaptabilidade, facilitada pela disponibilidade de código de treinamento, pesos públicos e um afinador de diálogo.

No contexto de construir um bot "ChatGPT" pessoal 100% gratuito alimentado pelo Koala, você pode utilizar o notebook Colab fornecido. Aqui está uma visão geral do processo:

Passo 1: Acesse o notebook Colab do Koala

Um notebook pré-configurado pelo especialista em aprendizado de máquina chamado Sam Witteveen está disponível para executar o modelo Koala. Você pode encontrar o notebook aqui. Copie o notebook para o seu próprio Google Drive.

Passo 2: Execute o notebook

Depois de ter o notebook no seu Google Drive, você pode executá-lo. O notebook começa instalando os módulos necessários e importando-os. Em seguida, carrega o modelo pré-treinado, samwit/koala-7b, usando o LlamaTokenizer e LlamaForCausalLM da biblioteca transformers. O modelo é carregado no modo de 8 bits, permitindo compatibilidade com GPUs econômicas.

from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig, pipeline
import torch
import textwrap
 
tokenizer = LlamaTokenizer.from_pretrained("samwit/koala-7b")
 
base_model = LlamaForCausalLM.from_pretrained(
    "samwit/koala-7b",
    load_in_8bit=True,
    device_map='auto',
)

Passo 3: Configure o pipeline de geração de texto

O notebook configura um pipeline para a geração de texto usando o método pipeline do Hugging Face. Parâmetros como comprimento máximo, temperatura e penalidade de repetição são definidos. Além disso, uma função utilitária chamada wrap_text_preserve_newlines() é fornecida para melhorar a aparência do texto gerado.

pipe = pipeline(
    "text-generation",
    model=base_model, 
    tokenizer=tokenizer, 
    max_length=512,
    temperature=0.7,
    top_p=0.95,
    repetition_penalty=1.15
)
 
def wrap_text_preserve_newlines(text, width=110):
    # Divide o texto de entrada em linhas com base nos caracteres de nova linha
    lines = text.split('\n')
 
    # Envolve cada linha individualmente
    wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
 
    # Junta as linhas envolvidas novamente usando caracteres de nova linha
    wrapped_text = '\n'.join(wrapped_lines)
 
    return wrapped_text

Passo 4: Envolver-se em conversas

O notebook fornece exemplos de conversas de prompt e resposta usando o método pipe() da biblioteca Hugging Face. É importante observar que o sucesso do modelo depende muito do uso de prompts apropriados no início de cada conversa. O notebook sugereusar um prompt que começa com "BEGINNING OF CONVERSATION: USER:" para ativar a lógica desejada. Você é incentivado a experimentar com diferentes prompts e parâmetros para observar as respostas do modelo.

No geral, o Koala prova ser uma alternativa promissora para modelos de linguagem maiores, como o GPT-3. Ao curar cuidadosamente os dados de treinamento, mesmo um modelo menor pode oferecer um desempenho impressionante. A equipe do Koala e especialistas da comunidade tornaram conveniente acessar e experimentar o modelo por meio do demo online e do notebook Colab do Google fornecido. Se você deseja desenvolver um chatbot ou realizar pesquisas em LLM sem incorrer em custos de uso do modelo, o Koala é uma excelente escolha.

Conclusão

O cenário de código aberto é rico em alternativas ao ChatGPT, cada uma oferecendo capacidades únicas. Se você é um entusiasta de IA, pesquisador ou desenvolvedor, essas ferramentas podem ajudá-lo a construir e ajustar seus próprios modelos de conversação. Então, vá em frente e mergulhe no mundo da IA conversacional de código aberto.