12 alternativas gratuitas e de código aberto ao ChatGPT

Se você está interessado em criar seu próprio clone do ChatGPT, mas prefere alternativas gratuitas e de código aberto, você veio ao lugar certo. Neste artigo, exploraremos 12 alternativas ao ChatGPT que você pode usar para criar seu próprio modelo de chatbot sem ter que gastar dinheiro.

Vantagens de alternativas gratuitas e de código aberto ao ChatGPT

Antes de mergulharmos nas alternativas específicas, é importante entender as vantagens de usar modelos de linguagem de código aberto em comparação com o ChatGPT.

1. Privacidade de dados. Muitas empresas desejam manter o controle de seus dados e não querem dar acesso a terceiros.
2. Personalização. Alternativas de código aberto permitem que os desenvolvedores treinem modelos de linguagem personalizados usando seus próprios dados e apliquem filtros em certos tópicos, se necessário.
3. Acessibilidade de custo. Modelos GPT de código aberto permitem que você treine modelos de linguagem sofisticados sem se preocupar com hardware caro.
4. Democratização da IA. O uso de modelos de código aberto abre caminho para pesquisas adicionais que podem ser usadas para resolver problemas do mundo real.

Agora que esclarecemos os benefícios, vamos examinar as alternativas gratuitas e de código aberto ao ChatGPT.

1. Llama

Introdução ao Llama

Llama significa Large Language Model Meta AI. É um modelo que inclui uma gama de tamanhos de 7 bilhões a 65 bilhões de parâmetros. Pesquisadores da Meta AI focaram em melhorar o desempenho do modelo aumentando o volume de dados de treinamento, em vez do número de parâmetros. Eles afirmaram que o modelo de 13 bilhões de parâmetros superou o modelo GPT-3 de 175 bilhões de parâmetros. Llama usa a arquitetura transformer e foi treinado em 1,4 trilhão de tokens extraídos de scraping da web do Wikipedia, GitHub, Stack Exchange, livros do Project Gutenberg e artigos científicos do ArXiv.

Código Python para Llama

# Installa il pacchetto
pip install llama-cpp-python

from llama_cpp import Llama
llm = Llama(model_path="./models/7B/ggml-model.bin")
output = llm("Q: Elenco dei pianeti del sistema solare? A: ", max_tokens=128, stop=["Q:", "\\n"], echo=True)
print(output)

2. Llama 2

O que há de novo no Llama 2

Existem algumas diferenças chave entre Llama 2 e Llama:

• Training data: Llama 2 foi treinado em 40% mais tokens do que Llama, totalizando 2 trilhões de tokens. Isso lhe dá uma base de conhecimento mais ampla e permite que ele gere respostas mais precisas.
• Dimensioni del modello: Llama 2 está disponível em três tamanhos: 7 bilhões de parâmetros, 13 bilhões de parâmetros e 70 bilhões de parâmetros. Enquanto o tamanho máximo de Llama é de 65 bilhões de parâmetros.
• Ottimizzazione della chat: Llama 2-Chat é uma versão especializada do Llama 2 otimizada para conversas bidirecionais. Foi treinado em um conjunto de dados de conversas humanas, o que lhe permite gerar respostas mais naturais e envolventes.
• Sicurezza e mitigazione dei pregiudizi: Llama 2 foi treinado com foco especial em segurança e mitigação de preconceitos. Isso significa que é menos provável que gere conteúdo tóxico ou prejudicial.
• Open source: Llama 2 é de código aberto, o que significa que qualquer pessoa pode usá-lo para fins de pesquisa ou comerciais, ao contrário do Llama, que não pode ser usado para fins comerciais.

Código Python para Llama 2

Para executar o modelo Llama2 de 7 bilhões de parâmetros, aqui está o código de referência:

%cd /content
!apt-get -y install -qq aria2

!git clone -b v1.3 https://github.com/camenduru/text-generation-webui
%cd /content/text-generation-webui
!pip install -r requirements.txt
!pip install -U gradio==3.28.3

!mkdir /content/text-generation-webui/repositories
%cd /content/text-generation-webui/repositories
!git clone -b v1.2 https://github.com/camenduru/GPTQ-for-LLaMa.git
%cd GPTQ-for-LLaMa
!python setup_cuda.py install

!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/raw/main/config.json -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o config.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/raw/main/generation_config.json -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o generation_config.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/raw/main/special_tokens_map.json -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o special_tokens_map.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/resolve/main/tokenizer.model -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o tokenizer.model
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/raw/main/tokenizer_config.json -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o tokenizer_config.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-7b-Chat-GPTQ/resolve/main/gptq_model-4bit-128g.safetensors -d /content/text-generation-webui/models/Llama-2-7b-Chat-GPTQ -o gptq_model-4bit-128g.safetensors

%cd /content/text-generation-webui
!python server.py --share --chat --wbits 4 --groupsize 128 --model_type llama

Para o modelo Llama2 de 13 bilhões de parâmetros, você pode consultar o seguinte código:

%cd /content
!apt-get -y install -qq aria2

!git clone -b v1.8 https://github.com/camenduru/text-generation-webui
%cd /content/text-generation-webui
!pip install -r requirements.txt

!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/resolve/main/model-00001-of-00003.safetensors -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o model-00001-of-00003.safetensors
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/resolve/main/model-00002-of-00003.safetensors -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o model-00002-of-00003.safetensors
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/resolve/main/model-00003-of-00003.safetensors -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o model-00003-of-00003.safetensors
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/raw/main/model.safetensors.index.json -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o model.safetensors.index.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/raw/main/special_tokens_map.json -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o special_tokens_map.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/resolve/main/tokenizer.model -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o tokenizer.model
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/raw/main/tokenizer_config.json -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o tokenizer_config.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/raw/main/config.json -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o config.json
!aria2c --console-log-level=error -c -x 16 -s 16 -k 1M https://huggingface.co/4bit/Llama-2-13b-chat-hf/raw/main/generation_config.json -d /content/text-generation-webui/models/Llama-2-13b-chat-hf -o generation_config.json

%cd /content/text-generation-webui
!python server.py --share --chat --load-in-8bit --model /content/text-generation-webui/models/Llama-2-13b-chat-hf

3. Alpaca

Introdução ao Alpaca

Uma equipe de pesquisadores da Universidade de Stanford desenvolveu um modelo de linguagem de código aberto chamado Alpaca. Ele é baseado no grande modelo de linguagem da Meta chamado Llama. A equipe usou a API GPT da OpenAI (text-davinci-003) para aprimorar o modelo Llama de 7 bilhões de parâmetros. O objetivo da equipe é disponibilizar a IA gratuitamente para que os acadêmicos possam realizar mais pesquisas sem ter que se preocupar com hardware caro para executar esses algoritmos intensivos em memória. Embora esses modelos de código aberto não estejam disponíveis para uso comercial, as pequenas empresas ainda podem usá-los para criar seus próprios chatbots.

Como o Alpaca funciona

A equipe de Stanford iniciou sua pesquisa com o menor modelo de linguagem entre os Llama, que é o modelo Llama de 7 bilhões de parâmetros, e o pré-treinou com 1 trilhão de tokens. Eles começaram com 175 pares de instruções-resposta escritas por humanos do conjunto de sementes de auto-instrução. Eles então usaram a API do ChatGPT para pedir ao ChatGPT que gerasse instruções adicionais usando o conjunto de sementes. Dessa forma, eles obtiveram cerca de 52.000 conversas de exemplo, que usaram para refinar ainda mais o modelo Llama usando o framework de treinamento do Hugging Face.

O Llama está disponível em vários tamanhos: modelos de 7B, 13B, 30B e 65B parâmetros. O Alpaca também foi estendido para modelos de 13B, 30B e 65B.

Desempenho do Alpaca

O modelo Alpaca foi testado em comparação com o ChatGPT em tarefas como criação de e-mails, mídias sociais e ferramentas de produtividade, e o Alpaca venceu 90 vezes enquanto o ChatGPT venceu 89 vezes. O modelo pode ser usado no mundo real para vários propósitos. Será de grande ajuda para pesquisadores na área de IA ética e segurança cibernética, como na detecção de golpes e phishing.

Limitações do Alpaca

Assim como a versão comercial do ChatGPT, o Alpaca também apresenta limitações semelhantes, como alucinações, toxicidade e vieses. Em outras palavras, ele pode ser usado para gerar texto que espalha desinformação, racismo e ódio contra seções vulneráveis da sociedade.

Requisitos de memória do Alpaca

O Alpaca não pode ser executado em CPUs, requer uma GPU. Para os modelos de 7B e 13B, uma única GPU com 12 GB de RAM é suficiente. Para o modelo de 30B, recursos de sistema adicionais são necessários.

Código Python para Alpaca

Aqui está um código de referência para o Alpaca. É um aplicativo de bate-papo que usa o modelo Alpaca 7B:

import sys
sys.path.append("/usr/local/lib/python3.9/site-packages")

!nvidia-smi

!git clone https://github.com/deepanshu88/Alpaca-LoRA-Serve.git

%cd Alpaca-LoRA-Serve
!python3.9 -m pip install -r requirements.txt

base_model = 'decapoda-research/llama-7b-hf'
finetuned_model = 'tloen/alpaca-lora-7b'

!python3.9 app.py --base_url $base_model --ft_ckpt_url $finetuned_model --share

Saída do Alpaca

Abaixo está um exemplo de saída do Alpaca em resposta a duas perguntas relativamente simples. Uma pergunta é sobre um tópico genérico e a outra sobre codificação. O Alpaca responde corretamente a ambas as perguntas.

4. GPT4All

Introdução ao GPT4All

A equipe da Nomic AI se inspirou no Alpaca e usou a API GPT-3.5-Turbo da OpenAI para coletar cerca de 800.000 pares de prompt-resposta a fim de criar 430.000 prompts no estilo de assistente e gerações, incluindo códigos, diálogos e narrativas. Os 800.000 pares são cerca de 16 vezes maiores que o Alpaca. O interessante sobre este modelo é que ele pode ser executado em CPUs, não requer uma GPU. Assim como o Alpaca, ele também é de código aberto, o que significa que você pode usá-lo para fins comerciais e pode executá-lo facilmente em seu computador.

Como o GPT4All funciona

Ele funciona de maneira semelhante ao Alpaca e é baseado em um modelo Llama de 7 bilhões de parâmetros. A equipe treinou modelos Llama de 7B e o modelo final foi treinado em 437.605 prompts no estilo de assistente pós-processados.

Desempenho do GPT4All

No processamento de linguagem natural, a perplexidade é usada para avaliar a qualidade dos modelos de linguagem. Ela mede o quão surpreso um modelo de linguagem ficaria ao ver uma nova sequência de palavras que nunca encontrou antes, com base em seus dados de treinamento. Um valor de perplexidade menor indica que o modelo de linguagem é melhor em prever a próxima palavra em uma sequência e, portanto, é mais preciso. A equipe da Nomic AI afirma que seus modelos têm menor perplexidade em comparação com o Alpaca. No entanto, a precisão real depende do tipo de prompt que você usa. O Alpaca pode ter melhor precisão em alguns casos.

Requisitos de memória do GPT4All

Pode ser executado em uma CPU com 8 GB de RAM. Se você tem um laptop com 4 GB de RAM, talvez seja hora de fazer um upgrade para pelo menos 8 GB.

Código Python para GPT4All

Aqui está um código de referência para GPT4All. Você pode usá-lo como referência, modificá-lo de acordo com suas necessidades ou executá-lo como está. É totalmente a seu critério decidir como usar o código para melhor atender às suas necessidades.

# Clone il repository Git
!git clone --recurse-submodules https://github.com/nomic-ai/gpt4all.git

# Installa i pacchetti richiesti
cd /content/gpt4all
!python -m pip install -r requirements.txt

cd transformers
!pip install -e .

cd ../peft
!pip install -e .

# Avvia l'addestramento
!accelerate launch --dynamo_backend=inductor --num_processes=8 --num_machines=1 --machine_rank=0 --deepspeed_multinode_launcher standard --mixed_precision=bf16 --use_deepspeed --deepspeed_config_file=configs/deepspeed/ds_config.json train.py --config configs/train/finetune.yaml

# Scarica il checkpoint del modello GPT4All
cd /content/gpt4all/chat
!wget https://the-eye.eu/public/AI/models/nomic-ai/gpt4all/gpt4all-lora-quantized.bin

# Esegui il sistema di conversazione
!./gpt4all-lora-quantized-linux-x86

Se você estiver executando o código em uma máquina local que usa um sistema operacional diferente do Linux, use os comandos a seguir em vez disso:

Windows (PowerShell): ./gpt4all-lora-quantized-win64.exe Mac (M1): ./gpt4all-lora-quantized-OSX-m1 Mac (Intel): ./gpt4all-lora-quantized-OSX-intel

Saída do GPT4All

O GPT4All não conseguiu responder corretamente a uma pergunta sobre codificação. Este é apenas um exemplo e não podemos julgar a precisão do modelo com base em um único caso. Ele pode funcionar bem em outros prompts, então a precisão do modelo depende de como você o usa. Além disso, quando o executei novamente após 2 dias, ele funcionou bem para perguntas sobre codificação. Parece que eles refinaram ainda mais o modelo.

Solução de problemas do GPT4All

Se você encontrar problemas com a versão distribuída que não possui NCCL, pode ser porque o CUDA não está instalado em seu computador.

Alguns usuários relataram erros estranhos na plataforma Windows 10/11. Como último recurso, você pode instalar o Subsistema do Windows para Linux, que permite instalar uma distribuição Linux em seu computador Windows e seguir o código acima.

5. GPT4All-J

Este modelo tem um nome semelhante ao anterior, mas a diferença é que ambos os modelos são da mesma equipe da Nomic AI. A única mudança é que agora ele foi treinado em GPT-J em vez de Llama. A vantagem de treiná-lo em GPT-J é que GPT4All-J agora é licenciado sob Apache-2, o que significa que você pode usá-lo para fins comerciais e executá-lo facilmente em seu computador.

6. Dolly 2

A equipe da Databricks construiu um modelo de linguagem com base no modelo Pythia da EleutherAI, posteriormente refinado em cerca de 15.000 instruções retiradas de um corpus. Está disponível em três tamanhos: 12B, 7B e 3B parâmetros.

Requisitos de memória do Dolly 2

Requer uma GPU com cerca de 10 GB de RAM para o modelo de 7B com quantização de 8 bits. Para o modelo de 12B, pelo menos 18 GB de VRAM da GPU são necessários.

Código Python para Dolly 2

Aqui está um código de referência para Dolly 2. Você pode usá-lo como referência para acessar o código Python e uma descrição detalhada do modelo Dolly.

7. Vicuna

Introdução ao Vicuna

Uma equipe de pesquisadores da UC Berkeley, CMU, Stanford e UC San Diego desenvolveu este modelo. Foi refinado em Llama usando um conjunto de dados de chat extraído do site ShareGPT. Os pesquisadores afirmam que o modelo atingiu mais de 90% da qualidade do ChatGPT-4 da OpenAI. Vale a pena notar que seu desempenho é quase igual ao do Bard. Eles usaram o programa de treinamento do Alpaca e melhoraram ainda mais dois aspectos: conversas multirreunidas e sequências longas.

Código Python para Vicuna

Você pode consultar este post – Guia detalhado do Vicuna para acessar o código Python e uma descrição detalhada do modelo Vicuna.

8. StableVicuna

Introdução ao StableVicuna

A Stability AI lançou o StableVicuna, uma versão refinada do modelo Vicuna de 13B. Para melhorar o modelo Vicuna, eles o treinaram ainda mais usando fine-tuning supervisionado (SFT). Eles usaram três conjuntos de dados diferentes para treiná-lo:

• OpenAssistant Conversations Dataset, que contém 161.443 mensagens de conversação humana em 35 idiomas diferentes.
• GPT4All Prompt Generations, que é um conjunto de dados de 437.605 prompts e respostas geradas pelo GPT-3.5.
• Alpaca, que é um conjunto de dados de 52.000 prompts e respostas geradas pelo modelo text-davinci-003.

Eles usaram trlx para treinar um modelo de recompensa. Este modelo foi configurado usando seu modelo SFT adicional. O modelo de recompensa foi treinado usando três conjuntos de dados com preferências humanas:

• OpenAssistant Conversations Dataset com 7.213 amostras de preferência.
• Anthropic HH-RLHF com 160.800 rótulos de pessoas expressando o que pensam sobre a utilidade ou inofensividade dos assistentes de IA.
• Stanford Human Preferences com 348.718 preferências humanas em respostas a perguntas ou instruções em várias áreas, como culinária ou filosofia.

Finalmente, o modelo SFT foi treinado usando RLHF com trlX através de um processo chamado Proximal Policy Optimization. É assim que StableVicuna foi criado.

Requisitos de memória do StableVicuna

Para executar o modelo GPTQ StableVicuna de 4 bits, é necessária cerca de 10 GB de VRAM da GPU.

Problemas de desempenho do StableVicuna

A Stability AI afirma que este modelo é uma melhoria em relação ao modelo Vicuna original, mas muitas pessoas relataram o contrário. Este modelo “alucina” mais do que o modelo original, produzindo piores respostas. Em outras palavras, o modelo gera saídas imprecisas que não correspondem à pergunta. Como esses modelos foram recém-lançados, uma avaliação rigorosa ainda é necessária. É possível que este modelo possa ter um desempenho melhor em algumas tarefas, mas muito pior em outras.

Código Python para StableVicuna

Podemos executar o modelo usando o Text Generation WebUI, que facilita a execução do modelo LLM de código aberto. O código a seguir executa uma quantização de 4 bits que reduz os requisitos de memória do modelo e torna possível executá-lo com menos VRAM.

%cd /content
!apt-get -y install -qq aria2

!git clone -b v1

Introdução ao Alpaca GPT-4

Alpaca GPT-4 é um modelo de linguagem desenvolvido pela OpenAI. É uma versão aprimorada do modelo Alpaca que usa 10 trilhões de tokens para treinamento. O Alpaca GPT-4 é conhecido por sua capacidade de gerar textos de alta qualidade e respostas coerentes.

Código Python para Alpaca GPT-4

No momento, a OpenAI não lançou o código ou o modelo pré-treinado para o Alpaca GPT-4. No entanto, você pode usar outras alternativas gratuitas e de código aberto listadas neste artigo para criar seu próprio chatbot.

10. Cerebras-GPT

Introdução ao Cerebras-GPT

Cerebras-GPT é um modelo de linguagem desenvolvido pela empresa de inteligência artificial Cerebras. Ele usa a tecnologia de processamento paralelo do chip Cerebras para treinar modelos de linguagem grandes. O Cerebras-GPT é conhecido por seu desempenho de ponta e sua capacidade de processar grandes quantidades de dados de forma eficiente.

Requisitos de memória do Cerebras-GPT

O Cerebras-GPT requer uma GPU com grande quantidade de memória VRAM, preferencialmente 32 GB ou mais, para executar modelos de linguagem grandes.

Código Python para Cerebras-GPT

No momento, a Cerebras não lançou o código ou o modelo pré-treinado para o Cerebras-GPT. No entanto, você pode usar alternativas gratuitas e de código aberto listadas neste artigo para criar seu próprio chatbot.

11. GPT-J 6B

Introdução ao GPT-J 6B

GPT-J 6B é um modelo de linguagem grande desenvolvido pela EleutherAI. Foi treinado em 6 bilhões de parâmetros usando técnicas avançadas de aprendizado de máquina. O GPT-J 6B é conhecido por sua capacidade de gerar textos coerentes e de alta qualidade em uma ampla variedade de tópicos.

Código Python para GPT-J 6B

No momento, a EleutherAI não lançou o código ou o modelo pré-treinado para o GPT-J 6B. No entanto, você pode usar alternativas gratuitas e de código aberto listadas neste artigo para criar seu próprio chatbot.

12. Modelo OpenChatKit

Introdução ao Modelo OpenChatKit

OpenChatKit Model é um modelo de chatbot open source desenvolvido pela OpenAI. Ele é baseado na arquitetura transformer e pode ser usado para criar chatbots com respostas coerentes e de alta qualidade.

Código Python para o Modelo OpenChatKit

No momento, a OpenAI não lançou o código ou o modelo pré-treinado para o Modelo OpenChatKit. No entanto, você pode usar alternativas gratuitas e de código aberto listadas neste artigo para criar seu próprio chatbot.