Skip to content

lab2.dev is launched! Build python web apps with plain English, no code required.

Top 10 Alternativas de ChatGPT de Código Abierto: Acortando la Brecha en la IA Conversacional

Matt Popovic
Name
Matt Popovic

Updated on

Los chatbots han revolucionado la forma en que las empresas interactúan con sus clientes. El GPT-4 de vanguardia, desarrollado por OpenAI, es un jugador dominante en este espacio. Sin embargo, no es de código abierto, lo que limita a los desarrolladores a reproducir los resultados o desarrollar sus propios chatbots similares a GPT-4.

Para llenar este vacío, las comunidades de código abierto han comenzado a ofrecer alternativas a GPT-4 que ofrecen un rendimiento y funcionalidad casi idénticos al tiempo que requieren menos potencia computacional. Este artículo tiene como objetivo presentarte las principales 10 alternativas de ChatGPT de código abierto que puedes utilizar en tu próximo proyecto de IA.

1. ColossalChat

ColossalChat (opens in a new tab), desarrollado por HPC AI Tech, es un proyecto de código abierto diseñado para replicar modelos similares a ChatGPT basados en el modelo LLaMa y el marco de inteligencia artificial PyTorch. Es el primer proyecto de código abierto práctico que incluye un proceso completo de aprendizaje por refuerzo a partir de la retroalimentación humana (RLHF), lo que lo convierte en el proyecto más cercano a la ruta técnica original de ChatGPT.

ColossalChat aprovecha el marco flexible y eficiente de aprendizaje profundo de PyTorch, que permite un prototipado rápido, una integración sin problemas con otras bibliotecas y la entrega de una experiencia de IA conversacional de alto rendimiento y fácil de usar.

Una de las características clave de ColossalChat es su conjunto de datos bilingüe que comprende aproximadamente 100,000 pares de preguntas y respuestas tanto en inglés como en chino. Este conjunto de datos se recolectó y limpió a partir de escenarios reales de preguntas en plataformas de redes sociales y sirve como conjunto de datos inicial. Se amplió utilizando la tecnología de autoinstrucción. Estos datos de alta calidad permiten que ColossalChat logre interacciones de diálogo mejores y también admita el idioma chino.

ColossalChat sigue un proceso de replicación de algoritmo RLHF de tres etapas. La primera etapa implica un ajuste fino supervisado instructivo. La segunda etapa implica el entrenamiento de un modelo de recompensa. Y la tercera etapa utiliza el algoritmo de aprendizaje por refuerzo. Este proceso de replicación permite una mayor consistencia del contenido generado con los valores humanos.

Este proyecto cuenta con el apoyo del sistema de desarrollo de modelos grandes de IA Colossal-AI, que puede implementar y desplegar de manera eficiente y rápida el entrenamiento e inferencia de modelos grandes de IA basados en la funcionalidad predeterminada de PyTorch. Esta infraestructura proporciona un soporte fundamental y mejora significativamente la velocidad de entrenamiento.

Aquí tienes un ejemplo de cómo entrenar ColossalChat en cada etapa RLHF:

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

Se ha abierto el código completo para replicar ChatGPT basado en el modelo LLaMa y puede ser accedido por desarrolladores e investigadores por igual.

2. Alpaca-LoRA

Alpaca-LoRA (opens in a new tab) parece ser una herramienta altamente eficiente para el ajuste fino de modelos de lenguaje como LLaMa, gracias a su uso de la técnica LoRA (Adaptación de rango bajo).

LoRA ofrece múltiples beneficios sobre otros métodos de ajuste fino, incluyendo:

  • Mayor velocidad y menor consumo de memoria, lo que lo hace compatible con hardware de consumo.
  • Menor tamaño de salida (megabytes en lugar de gigabytes).
  • La capacidad de combinar múltiples modelos ajustados durante el tiempo de ejecución.

Alpaca-LoRA, que implementa la biblioteca PEFT (Python Easy Fine-Tuning), permite el ajuste fino de modelos de lenguaje basados en transformers usando LoRA. Esto conduce a un ajuste fino del modelo eficiente y económico incluso en hardware modesto, con salidas potencialmente componibles.

Los pasos para ajustar finamente LLaMa usando Alpaca-LoRA son los siguientes:

Prerrequisitos

Antes de comenzar, asegúrate de tener acceso a una máquina con GPU. Incluso las GPU de baja especificación como una NVIDIA T4 o GPU de consumo como una 4090 son adecuadas debido a la eficiencia de LoRA. Además, necesitas los pesos para LLaMa, que aún no están disponibles públicamente. Puedes solicitar el acceso a través del formulario de investigación de Meta.

Paso 1: Clonar el repositorio de Alpaca-LoRA

Clona el repositorio de Alpaca-LoRA que incluye soporte para Cog (una herramienta utilizada para empaquetar modelos de aprendizaje automático en contenedores). Utiliza los siguientes comandos:

Por favor, proporciona la traducción al español de este archivo markdown sin traducir el código incorporado: git clone https://github.com/daanelson/alpaca-lora
cd alpaca-lora

Paso 2: Instalar Cog

A continuación, instala Cog con los siguientes 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

Paso 3: Obtener los pesos de LLaMa

Coloca tus pesos descargados en una carpeta llamada 'unconverted-weights'. La estructura del directorio debe verse así:

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

Convierte los pesos de un punto de control de PyTorch a un formato compatible con transformers utilizando el siguiente comando:

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

La estructura final de tu directorio debe verse así:

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

Paso 4: Ajustar el modelo

Si tienes una GPU con más memoria, puedes aumentar MICRO_BATCH_SIZE a 32 o 64 en finetune.py. Si tienes tu propio conjunto de datos de ajuste, edita DATA_PATH en finetune.py para que apunte a tu propio conjunto de datos. Asegúrate de que tenga el mismo formato que alpaca_data_cleaned.json.

Ejecuta el script de ajuste fino:

cog run python finetune.py

El ajuste fino puede tardar alrededor de 3,5 horas en una GPU A100 de 40 GB. Puede llevar más tiempo para las GPU con menos capacidad de procesamiento.

Paso 5: Ejecutar el modelo con Cog

Finalmente, puedes ejecutar el modelo utilizando Cog. Por ejemplo:

$ cog predict -i prompt="Dime algo sobre las alpacas."

La respuesta será una salida informativa sobre las alpacas, demostrando el éxito del ajuste fino de tu modelo de LLaMa.

3. Vicuna-13B

Como parte de FastChat, Vicuna utiliza una arquitectura basada en transformers, similar a los modelos GPT, y se ajusta fino en conjuntos de datos de conversación de ShareGPT.com. Ofrece aproximadamente el 90% del rendimiento de ChatGPT, proporcionando una alternativa accesible y rentable. A pesar del rendimiento inferior, Vicuna se destaca por su excelente capacidad de personalización y adaptabilidad a una amplia gama de tareas.

Para obtener más detalles sobre cómo utilizarlo, consulta nuestro artículo detallado sobre Vicuna-13B.

4. GPT4ALL

El equipo de Nomic AI ofrece un chatbot llamado GPT4ALL basado en datos seleccionados y curados, como problemas de palabras, código, historias, ilustraciones y diálogos de varios turnos. Aunque utiliza LLaMa para una aceleración de ML de baja latencia como GPT-4, la fortaleza de GPT4ALL radica en su conjunto de datos diverso y su capacidad de adaptación a diversas tareas.

Aquí tienes un ejemplo de GPT4ALL en acción:

Para obtener más detalles sobre cómo utilizarlo, consulta nuestro artículo detallado sobre GPT4ALL.

5. Raven RWKV

El RWKV (opens in a new tab) (Raven RWKV) es un modelo más reciente, hasta mi fecha límite de conocimiento en septiembre de 2021. Sin embargo, en función de la información que proporcionaste, aquí tienes una guía general paso a paso sobre cómo utilizarlo, junto con algunos fragmentos de código:

Primero, deberás instalar el paquete necesario. El paquete RWKV se encuentra alojado en PyPI y puedes instalarlo utilizando pip:

pip install rwkv

Luego, deberás importar el modelo desde el paquete:

from rwkv.model import RWKV

A continuación, instanciarás el modelo. Esto implica especificar la ruta del modelo y la estrategia que se utilizará:

model = RWKV(model='/ruta/a/tu/modelo', strategy='cuda fp16')

Esto crea una instancia del modelo que se puede utilizar para la inferencia.

A continuación, utilizarás el método forward del modelo para realizar la inferencia. Este método toma dos parámetros: los tokens de entrada y el estado. Para la ejecución inicial, puedes establecer el estado en None:

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

Luego puedes imprimir la salida del modelo:

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

Luego, para ejecuciones posteriores, puedes proporcionar el estado de la ejecución 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())

Esta guía paso a paso muestra el uso básico del modelo RWKV para inferencia. Es importante tener en cuenta que los pasos específicos pueden variar dependiendo de la tarea, los pesos de modelo específicos utilizados y otros factores. Consulta la documentación oficial para obtener la información más precisa.

Además, recuerda que este modelo es relativamente nuevo, y desde mi fecha límite de conocimiento en septiembre de 2021, es posible que se hayan realizado desarrollos y mejoras adicionales. Siempre consulta la literatura y el código más reciente y relevante para obtener información actualizada y precisa.

6. OpenChatKit

OpenChatKit (opens in a new tab) proporciona un conjunto de herramientas completo para el desarrollo de aplicaciones de chatbot, posicionándose como una alternativa de código abierto a ChatGPT. Si bien es similar a los modelos GPT en términos de estructura, OpenChatKit mejora la personalización al permitir el entrenamiento de grandes modelos de lenguaje optimizados para instrucciones y ofrecer un sistema de recuperación extensible para las respuestas de los bots.

Paso 1: Configuración

Asegúrate de tener los requisitos del sistema y las dependencias necesarias. Necesitarás Git LFS, Miniconda, PyTorch y otros. El archivo environment.yml proporcionado contiene las especificaciones del entorno necesario.

Primero, instala Git LFS y Miniconda, luego configura el entorno de la siguiente manera:

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

Paso 2: Chatear con Pythia-Chat-Base-7B:

Para interactuar con el modelo, puedes utilizar el script bot.py ubicado en el directorio inference:

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

Luego puedes chatear con el modelo ingresando texto en el indicador de línea de comandos proporcionado.

Paso 3: Reproduciendo Pythia-Chat-Base-7B:

Si deseas entrenar el modelo tú mismo, primero debes descargar los datos de entrenamiento y el modelo base:

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

Luego, puedes ajustar el modelo utilizando el script de shell proporcionado:

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

Después de entrenar, convierte el modelo al formato de Huggingface utilizando la herramienta de conversión:

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

Reemplaza model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 con la ruta de tu punto de control del modelo.

Paso 4: Probando el nuevo modelo:

Una vez que hayas ajustado tu modelo, puedes chatear con él utilizando el script bot.py:

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

Paso 5. Monitoreo:

Para monitorear el entrenamiento, OpenChatKit proporciona soporte tanto para loguru como para Weights & Biases.

Paso 6. Experimental: Modelos con Recuperación Incrementada

OpenChatKit también proporciona una función experimental para modelos con recuperación incrementada. Esto se implementa consultando un índice Faiss de Wikipedia. Puedes ejecutarlo de la siguiente manera:

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

Por favor, consulta la documentación oficial de OpenChatKit para obtener información más detallada y precisa. Estos pasos se basan en la información que proporcionaste.

7. OPT

OPT (opens in a new tab) (Open Pre-trained Transformer) Los modelos de lenguaje exhiben habilidades excepcionales en el aprendizaje sin muestra y con pocas muestras, y en análisis de sesgos estereotipados, aunque no alcanzan la calidad de ChatGPT. Estos modelos son transformers de solo decodificador, lo que significa que generan texto de forma autoregresiva de izquierda a derecha, similar al enfoque de los modelos GPT.

Aquí tienes un desglose paso a paso más detallado sobre cómo puedes usar los modelos OPT para cada una de estas tareas:

Paso 1: Generación de Texto

Para usar un modelo OPT para la generación de texto, primero debes cargarlo en un pipeline. Aquí tienes un ejemplo utilizando la biblioteca transformers de Hugging Face:

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

Una vez que hayas configurado el pipeline, puedes generar texto de la siguiente manera:

print(generator("Hola, soy un", max_length=50)[0]['generated_text'])

Esto imprimirá un texto que comienza con "Hola, soy un" y continúa hasta 50 tokens.

Paso 2. Aprendizaje sin muestra

El aprendizaje sin muestra implica aplicar el modelo a tareas para las que no fue específicamente entrenado. Por ejemplo, puedes usarlo para clasificación de texto sin necesidad de más entrenamiento. Así es como puedes hacerlo:

from transformers import pipeline
 
classifier = pipeline("text-classification", model="facebook/opt-350m")
print(classifier("Me encantan los días soleados.", ["clima", "emoción"]))

Esto clasificará la frase "Me encantan los días soleados." en términos de "clima" y "emoción" e imprimirá las probabilidades.

Paso 3: Aprendizaje con pocas muestras

El aprendizaje con pocas muestras implica proporcionar un pequeño número de ejemplos para ayudar al modelo a comprender la tarea. Por ejemplo, si quieres que el modelo traduzca del inglés al francés, puedes proporcionar algunas traducciones de ejemplo:

from transformers import pipeline
 
translator = pipeline('translation', model="facebook/opt-350m")
 
ejemplos = [
    {"Inglés": "Hola", "Francés": "Bonjour"},
    {"Inglés": "Adiós", "Francés": "Au revoir"},
]
 
translator.set_examples(ejemplos)
 
print(translator("Buenos días"))

Ten en cuenta que este ejemplo se simplifica para fines de ilustración. El uso real podría ser un poco más complicado y requerir una configuración más sofisticada.

Paso 4: Análisis de sesgos estereotipados

Puedes usar el modelo OPT para analizar los sesgos estereotipados presentes en el texto que genera. Aquí tienes un ejemplo:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")
 
promesa_femenina = "La mujer trabajaba como"
promesa_masculina = "El hombre trabajaba como"
 
resultado_femenino = generator(promesa_femenina, num_return_sequences=5)
resultado_masculino = generator(promesa_masculina, num_return_sequences=5)
 
print("Resultados de la promesa femenina:")
for resultado in resultado_femenino:
    print(resultado['generated_text'])
 
print("Resultados de la promesa masculina:")
for resultado in resultado_masculino:
    print(resultado['generated_text'])

Esto imprimirá 5 secuencias generadas para cada promesa, y puedes analizarlas en busca de posibles sesgos. Ten en cuenta que este tipo de análisis puede ser una tarea compleja y puede requerir técnicas avanzadas de procesamiento del lenguaje natural (NLP).

Recuerda que es posible que debas ajustar los nombres de los modelos en función de los modelos OPT específicos disponibles en el Hugging Face Model Hub. Además, hasta mi fecha límite de conocimiento en septiembre de 2021, algunas de las funciones como translator.set_examples(ejemplos) pueden no existir en la biblioteca Transformers. Se proporcionó para mostrar un ejemplo conceptual.

8. Flan-T5-XXL

Flan-T5-XXL (opens in a new tab) es una colección de modelos T5 ajustados finamente que se han entrenado con una amplia compilación de conjuntos de datos instructivos. Estos modelos, aunque no se basan en la arquitectura de transformers como los modelos GPT, muestran un rendimiento significativamente mejorado en diversas clases de modelos, que incluyen PaLM, T5 y U-PaLM.

Para usar Flan-T5-XXL, puedes seguir la guía de uso de muestra a continuación:

# Suponiendo que ya has clonado el repositorio Flan-T5-XXL y has configurado el entorno
 
from flan_t5_xx1 import FlanT5XXL
 
# Inicializa el modelo Flan-T5-XXL
modelo = FlanT5XXL()
 
# Ejemplo de uso: Generar instrucciones para una tarea
entrada_tarea = "Cómo hornear un pastel"
instrucciones = modelo.generate_instructions(entrada_tarea)
print(instrucciones)
Este ejemplo demuestra cómo generar instrucciones para una tarea específica utilizando el modelo Flan-T5-XXL. La variable `task_input` contiene la descripción de la tarea y el método `generate_instructions()` genera las instrucciones correspondientes.
 
Es importante tener en cuenta que el fragmento de código anterior asume que ya has clonado el repositorio de Flan-T5-XXL y has configurado las dependencias necesarias.
 
Flan-T5-XXL proporciona un marco modular y componible para entrenar y evaluar modelos de secuencia, con un enfoque en tareas de lenguaje. Está implementado utilizando JAX y Flax, basado en el código base de T5. Flan-T5-XXL ofrece un alto nivel de configurabilidad y capacidades de autoservicio, permitiendo a los investigadores entrenar y evaluar modelos de secuencia a diferentes escalas.
 
Es importante consultar la documentación oficial y los ejemplos proporcionados por Flan-T5-XXL para comprender de manera exhaustiva las funcionalidades disponibles y cómo utilizarlas de manera efectiva.
 
Un ejemplo de uso de Flan-T5-XXL podría ser el siguiente:
 
```python
from flan import FlanT5
 
# Inicializar modelo
flan_model = FlanT5()
 
# Generar respuesta
respuesta = flan_model.generate("Traduce este texto al francés.")
print(respuesta)

9. Baize

Baize (opens in a new tab) es un modelo de chat de código abierto entrenado con LoRA. Incorpora 100k diálogos autogenerados de ChatGPT y utiliza los datos de Alpaca para mejorar el rendimiento. Se han lanzado modelos con diferentes tamaños, como 7B, 13B y 30B.

Para interactuar con Baize utilizando la CLI (Interfaz de línea de comandos) y la API de Fastchat, sigue estos pasos:

  1. Instala Fastchat:
pip install git+https://github.com/huggingface/peft.git
pip install git+https://github.com/lm-sys/FastChat.git
  1. Fusiona los pesos de LoRA de Baize (solo modelos V1):
python3 -m fastchat.model.apply_lora --base huggyllama/llama-7b --target ./model_weights/baize-7b --lora project-baize/baize-lora-7B
  1. Ejecuta la CLI:
python -m fastchat.serve.cli --model-path ./model_weights/baize-7b

Baize también se puede utilizar con el API de OpenAI o el API de Hugging Face.

Para la demostración de Baize, puedes ejecutarla localmente siguiendo estos pasos:

  1. Instala los paquetes necesarios:
cd demo
pip install -r requirements.txt
  1. Hospeda el 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

La demostración de Baize proporciona una interfaz Gradio fácil de usar para chatear.

Estos son ejemplos de código simplificados. Para obtener instrucciones y opciones más detalladas, consulta la documentación del proyecto Baize.

10. Koala

Koala (opens in a new tab) es un modelo de diálogo de IA entrenado mediante ajuste fino de LLaMA en un conjunto de datos de diálogos recopilados de la web. Supera el rendimiento de Alpaca y muestra resultados comparables a ChatGPT en varios escenarios. Una de las principales ventajas de Koala es su amplia personalización y adaptabilidad, facilitada por la disponibilidad del código de entrenamiento, pesos públicos y un afinador de diálogos.

En el contexto de construir un bot "ChatGPT" personal totalmente gratuito impulsado por Koala, puedes utilizar el cuaderno de Colab proporcionado. Aquí tienes una descripción general del proceso:

Paso 1: Accede al cuaderno de Colab de Koala

Hay un cuaderno preconfigurado realizado por un experto en aprendizaje automático llamado Sam Witteveen para ejecutar el modelo Koala. Puedes encontrar el cuaderno aquí. Copia el cuaderno en tu propio Google Drive.

Paso 2: Ejecuta el cuaderno

Una vez que tengas el cuaderno en tu Google Drive, puedes ejecutarlo. El cuaderno comienza instalando los módulos necesarios e importándolos. A continuación, carga el modelo preentrenado, samwit/koala-7b, utilizando LlamaTokenizer y LlamaForCausalLM de la biblioteca transformers. El modelo se carga en modo de 8 bits, lo que permite la compatibilidad con 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',
)

Paso 3: Configura el pipeline de generación de texto

El cuaderno configura un pipeline para la generación de texto utilizando el método pipeline de Hugging Face. Se definen parámetros como la longitud máxima, la temperatura y la penalización por repetición. Además, se proporciona una función de utilidad llamada wrap_text_preserve_newlines() para mejorar la apariencia del texto generado.

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 el texto de entrada en líneas basadas en los caracteres de salto de línea
    lines = text.split('\n')
 
    # Envuelve cada línea individualmente
    wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
 
    # Une las líneas envueltas nuevamente usando caracteres de salto de línea
    wrapped_text = '\n'.join(wrapped_lines)
 
    return wrapped_text

Paso 4: Participa en conversaciones

El cuaderno proporciona ejemplos de conversaciones de pregunta-respuesta utilizando el método pipe() de la biblioteca Hugging Face. Es importante tener en cuenta que el éxito del modelo depende en gran medida de usar indicaciones adecuadas al principio de cada conversación. El cuaderno sugiere usar una indicación que comience con "BEGINNING OF CONVERSATION: USER:" para activar la lógica deseada. Te animamos a experimentar con diferentes indicaciones y parámetros para observar las respuestas del modelo. En general, Koala demuestra ser una alternativa prometedora a los modelos de lenguaje más grandes como GPT-3. Al curar cuidadosamente los datos de entrenamiento, incluso un modelo más pequeño puede ofrecer un rendimiento impresionante. El equipo de Koala y los expertos de la comunidad han facilitado el acceso y experimentación con el modelo a través de la demostración en línea y la libreta de Google Colab proporcionada. Ya sea que su objetivo sea desarrollar un chatbot o realizar investigación de LLM sin incurrir en costos de uso del modelo, Koala es una excelente elección.

Conclusión

El panorama de código abierto está lleno de alternativas a ChatGPT, cada una ofreciendo capacidades únicas. Ya sea que seas un entusiasta de la IA, un investigador o un desarrollador, estas herramientas pueden ayudarte a construir y afinar tus propios modelos de conversación. Así que adelante, sumérgete en el mundo de la IA conversacional de código abierto.