Skip to content

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

Top 10 Open Source ChatGPT-Alternativen: Die Lücke in der Konversations-KI schließen

Matt Popovic
Name
Matt Popovic

Updated on

Chatbots haben die Art und Weise, wie Unternehmen mit ihren Kunden interagieren, revolutioniert. Der modernste GPT-4, entwickelt von OpenAI, spielt eine dominierende Rolle in diesem Bereich. Es ist jedoch nicht quelloffen, was Entwickler davon abhält, die Ergebnisse zu reproduzieren oder ihre eigenen Chatbots ähnlich wie GPT-4 zu entwickeln.

Um diese Lücke zu füllen, bieten Open-Source-Communities Alternativen zu GPT-4 an, die eine nahezu identische Leistung und Funktionalität bieten, während sie weniger Rechenleistung erfordern. Dieser Artikel soll Ihnen die Top 10 Open Source ChatGPT-Alternativen vorstellen, die Sie in Ihrem nächsten KI-Projekt nutzen können.

1. ColossalChat

ColossalChat (opens in a new tab), entwickelt von HPC AI Tech, ist ein Open-Source-Projekt, das ChatGPT-ähnliche Modelle auf Basis des LLaMa-Modells und des PyTorch-KI-Frameworks replizieren soll. Es handelt sich um das erste praktische Open-Source-Projekt, das einen vollständigen Lernprozess mit Rückmeldung durch Verstärkung (RLHF) enthält und somit das Projekt mit dem technischen Hintergrund von ChatGPT am nächsten kommt.

ColossalChat nutzt das flexible und effiziente Deep-Learning-Framework PyTorch, das schnelles Prototyping, nahtlose Integration mit anderen Bibliotheken und die Bereitstellung eines leistungsstarken, benutzerfreundlichen Konversations-KI-Erlebnisses ermöglicht.

Eine der Hauptfunktionen von ColossalChat ist sein zweisprachiger Datensatz, der ungefähr 100.000 Frage-Antwort-Paare sowohl in Englisch als auch in Chinesisch umfasst. Dieser Datensatz wurde aus realen Frage-Szenarien in sozialen Medien gesammelt und gereinigt und dient als Ausgangspunkt für das Training. Er wurde mit Hilfe der selbstinstruktiven Technologie erweitert. Diese hochwertigen Daten ermöglichen es ColossalChat, bessere Dialoginteraktionen zu erreichen und auch Chinesisch zu unterstützen.

ColossalChat folgt einem dreistufigen RLHF-Algorithmus-Replikationsprozess. Die erste Stufe beinhaltet das feinabgestimmte instruktionsbasierte Training. Die zweite Stufe beinhaltet das Training eines Belohnungsmodells. Und die dritte Stufe verwendet den Lernalgorithmus mit Verstärkung. Dieser Replikationsprozess ermöglicht eine größere Konsistenz des generierten Inhalts mit menschlichen Werten.

Dieses Projekt wird vom AI large model development system Colossal-AI unterstützt, das effizientes und schnelles Training und Inferenz von AI large models auf Basis der standardmäßigen PyTorch-Funktionalität ermöglicht. Diese Infrastruktur bietet eine grundlegende Unterstützung und verbessert die Trainingssgeschwindigkeit erheblich.

Hier ist ein Beispiel dafür, wie man ColossalChat in den einzelnen RLHF-Stufen trainiert:

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

Der vollständige Code zur Replikation von ChatGPT auf Basis des LLaMa-Modells ist quelloffen und kann von Entwicklern und Forschern gleichermaßen eingesehen werden.

2. Alpaca-LoRA

Alpaca-LoRA (opens in a new tab) scheint ein äußerst effizientes Werkzeug für die Feinabstimmung von Sprachmodellen wie LLaMa zu sein, dank seiner Verwendung der LoRA (Low-rank adaptation) Technik.

LoRA bietet verschiedene Vorteile gegenüber anderen Feinabstimmungsmethoden, darunter:

  • Höhere Geschwindigkeit und geringerer Speicherverbrauch, was es mit Consumer-Hardware kompatibel macht.
  • Kleinere Ausgabegröße (Megabyte statt Gigabyte).
  • Die Möglichkeit, mehrere feinabgestimmte Modelle zur Laufzeit zu kombinieren.

Alpaca-LoRA, das die PEFT (Python Easy Fine-Tuning) Bibliothek implementiert, ermöglicht die Feinabstimmung von transformer-basierten Sprachmodellen unter Verwendung von LoRA. Dadurch wird eine effiziente und kostengünstige Modellfeinabstimmung auch auf bescheidener Hardware mit potenziell komponierbaren Ausgaben ermöglicht.

Die Schritte zur Feinabstimmung von LLaMa mithilfe von Alpaca-LoRA sind wie folgt:

Voraussetzungen

Stellen Sie vor dem Start sicher, dass Sie Zugriff auf eine GPU-Maschine haben. Auch Low-End-GPUs wie eine NVIDIA T4 oder Consumer-GPUs wie eine 4090 sind aufgrund der Effizienz von LoRA geeignet. Außerdem benötigen Sie die Gewichte für LLaMa, die noch nicht öffentlich verfügbar sind. Sie können über das Meta Research Formular Zugriff beantragen.

Schritt 1: Klonen Sie das Alpaca-LoRA Repo

Klonen Sie das Alpaca-LoRA-Repository, das Unterstützung für Cog (ein Tool zum Verpacken von Machine Learning-Modellen in Containern) enthält. Verwenden Sie die folgenden Befehle:

Bitte geben Sie die deutsche Übersetzung für diese Markdown-Datei an, ohne den eingebetteten Code zu übersetzen: git clone https://github.com/daanelson/alpaca-lora
cd alpaca-lora

Schritt 2: Cog installieren

Installieren Sie anschließend Cog mit den folgenden Befehlen:

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

Schritt 3: LLaMa-Gewichte erhalten

Platzieren Sie Ihre heruntergeladenen Gewichte in einem Ordner namens 'unconverted-weights'. Die Verzeichnisstruktur sollte wie folgt aussehen:

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

Konvertieren Sie die Gewichte von einem PyTorch-Checkpoint in ein transformers-kompatibles Format mit dem folgenden Befehl:

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

Ihre endgültige Verzeichnisstruktur sollte wie folgt aussehen:

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

Schritt 4: Das Modell feinabstimmen

Wenn Sie eine GPU mit mehr Speicher haben, können Sie MICRO_BATCH_SIZE in finetune.py auf 32 oder 64 erhöhen. Wenn Sie Ihren eigenen Anweisungsabstimmungsdatensatz haben, bearbeiten Sie DATA_PATH in finetune.py, um auf Ihren eigenen Datensatz zu verweisen. Stellen Sie sicher, dass er das gleiche Format wie alpaca_data_cleaned.json hat.

Führen Sie das Feinabstimmungsskript aus:

cog run python finetune.py

Die Feinabstimmung kann auf einer 40GB A100 GPU etwa 3,5 Stunden dauern. Für GPUs mit weniger Leistung kann es länger dauern.

Schritt 5: Führen Sie das Modell mit Cog aus

Schließlich können Sie das Modell mit Cog ausführen. Zum Beispiel:

$ cog predict -i prompt="Erzählen Sie mir etwas über Alpakas."

Die Antwort wird eine informative Ausgabe über Alpakas sein und den erfolgreichen Feinabstimmung Ihres LLaMa-Modells demonstrieren.

3. Vicuna-13B

Ein Teil von FastChat nutzt Vicuna eine transformerbasierte Architektur, ähnlich wie GPT-Modelle, und wird auf Konversationsdatensätzen von ShareGPT.com trainiert. Es liefert ungefähr 90% der Leistung von ChatGPT und bietet eine zugängliche und kostengünstige Alternative. Trotz der geringeren Leistung zeichnet sich Vicuna durch seine ausgezeichnete Anpassungsfähigkeit und Anpassungsfähigkeit an eine Vielzahl von Aufgaben aus.

Weitere Informationen zur Verwendung finden Sie in unserem ausführlichen Artikel zu Vicuna-13B.

4. GPT4ALL

Das GPT4ALL-Team von Nomic AI bietet einen Chatbot, der auf umfangreichen kuratierten Daten wie Wortproblemen, Code, Geschichten, Illustrationen und Dialogen mit mehreren Umdrehungen basiert. Es nutzt LLaMa für die beschleunigte ML-Klassifizierung mit geringer Latenz wie GPT-4. Die Stärke von GPT4ALL liegt jedoch in seinem vielfältigen Datensatz und der Anpassungsfähigkeit an verschiedene Aufgaben.

Hier ist ein Beispiel für GPT4ALL in Aktion:

Weitere Informationen zur Verwendung finden Sie in unserem ausführlichen Artikel zu GPT4ALL.

5. Raven RWKV

Das RWKV (opens in a new tab) (Raven RWKV) ist ein neueres Modell, Stand meines Kenntnisstandes im September 2021. Basierend auf den von Ihnen bereitgestellten Informationen finden Sie hier eine allgemeine Schritt-für-Schritt-Anleitung zur Verwendung zusammen mit einigen Code-Schnipseln:

Zunächst müssen Sie das erforderliche Paket installieren. Das RWKV-Paket wird über PyPI gehostet und kann mit pip installiert werden:

pip install rwkv

Dann müssen Sie das Modell aus dem Paket importieren:

from rwkv.model import RWKV

Als nächstes instanziieren Sie das Modell. Dabei wird der Modellpfad und die zu verwendende Strategie angegeben:

model = RWKV(model='/path/to/your/model', strategy='cuda fp16')

Dies erstellt eine Instanz des Modells, die für Inferenz verwendet werden kann.

Als nächstes verwenden Sie die forward-Methode des Modells, um Inferenz durchzuführen. Diese Methode nimmt zwei Parameter entgegen: die Eingabe-Tokens und den Status. Für den ersten Durchlauf können Sie den Status auf None setzen:

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

Sie können dann die Ausgabe des Modells ausgeben:

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

Dann können Sie für nachfolgende Durchläufe den Status vom vorherigen Durchlauf angeben:

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())

Diese Schritt-für-Schritt-Anleitung zeigt die grundlegende Verwendung des RWKV-Modells für Inferenz. Es ist wichtig zu beachten, dass die spezifischen Schritte je nach Aufgabe, den spezifischen Modellgewichten und anderen Faktoren variieren können. Bitte beachten Sie die offizielle Dokumentation für die genauesten Informationen.

Beachten Sie auch, dass dieses Modell relativ neu ist und seit meinem Kenntnisstand im September 2021 möglicherweise weitere Entwicklungen und Verbesserungen vorgenommen wurden. Konsultieren Sie immer die neueste und relevanteste Literatur und Codebasis für aktuelle und genaue Informationen.

6. OpenChatKit

OpenChatKit (opens in a new tab) bietet ein komplettes Toolkit zur Entwicklung von Chatbot-Anwendungen und positioniert sich als Open-Source-Alternative zu ChatGPT. OpenChatKit ähnelt GPT-Modellen in Bezug auf die Struktur und ermöglicht die Schulung von instruktionsabgestimmten großen Sprachmodellen und bietet ein erweiterbares Abrufsystem für Bot-Antworten.

Schritt 1: Einrichten

Stellen Sie sicher, dass Sie über die erforderlichen Systemanforderungen und Abhängigkeiten verfügen. Sie benötigen Git LFS, Miniconda und PyTorch, unter anderem. Die bereitgestellte environment.yml-Datei enthält die Spezifikationen für die benötigte Umgebung.

Installieren Sie zunächst Git LFS und Miniconda, richten Sie dann die Umgebung wie folgt ein:

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

Schritt 2: Chatten mit Pythia-Chat-Base-7B:

Um mit dem Modell zu interagieren, können Sie das Skript bot.py im Verzeichnis inference verwenden:

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

Sie können dann mit dem Modell chatten, indem Sie Text in der bereitgestellten Befehlszeileneingabe eingeben.

Schritt 3: Reproduzieren von Pythia-Chat-Base-7B:

Wenn Sie das Modell selbst trainieren möchten, müssen Sie zunächst die Trainingsdaten und das Basismodell herunterladen:

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

Anschließend können Sie das Modell mit dem bereitgestellten Shell-Skript feinabstimmen:

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

Nach dem Training konvertieren Sie das Modell mit dem Konvertierungstool in das Huggingface-Format:

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

Ersetzen Sie model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 durch den Pfad zu Ihrem Modell-Checkpoint.

Schritt 4: Testen des neuen Modells:

Nachdem Sie Ihr Modell feinabgestimmt haben, können Sie damit chatten, indem Sie das Skript bot.py verwenden:

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

Schritt 5: Überwachung:

Für das Überwachen des Trainings bietet OpenChatKit Unterstützung sowohl für loguru als auch für Weights & Biases.

Schritt 6: Experimentell: Retrieval-augmentierte Modelle

OpenChatKit bietet auch eine experimentelle Funktion für retrieval-augmentierte Modelle. Dies wird durch Abfragen eines Faiss-Index von Wikipedia implementiert. Sie können es ausführen, indem Sie Folgendes tun:

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

Bitte beachten Sie die offizielle OpenChatKit-Dokumentation für detailliertere und genauere Informationen. Diese Schritte basieren auf den von Ihnen bereitgestellten Informationen.

7. OPT

OPT (opens in a new tab) (Open Pre-trained Transformer) Language Models weisen außergewöhnliche Fähigkeiten in der Zero-Shot- und Few-Shot-Learning sowie in der Stereotypical Bias-Analyse auf, obwohl sie nicht die Qualität von ChatGPT erreichen. Diese Modelle sind ausschließlich Decoder-Transformer, dh sie generieren Text autoregressiv von links nach rechts, ähnlich wie der Ansatz der GPT-Modelle.

Hier finden Sie eine detailliertere Schritt-für-Schritt-Anleitung, wie Sie OPT-Modelle für diese Aufgaben verwenden können:

Schritt 1: Textgenerierung

Um ein OPT-Modell für die Textgenerierung zu verwenden, müssen Sie es zunächst in eine Pipeline laden. Hier ist ein Beispiel für die Verwendung der Bibliothek "transformers" von Hugging Face:

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

Nachdem Sie die Pipeline eingerichtet haben, können Sie Text wie folgt generieren:

print(generator("Hallo, ich bin ein", max_length=50)[0]['generated_text'])

Dies druckt einen Text aus, der mit "Hallo, ich bin ein" beginnt und bis zu 50 Tokens lang ist.

Schritt 2: Zero-Shot-Lernen

Zero-Shot-Lernen beinhaltet die Anwendung des Modells auf Aufgaben, für die es speziell nicht trainiert wurde. Sie können es beispielsweise für die Textklassifikation ohne weiteres Training verwenden. Hier ist, wie Sie es tun können:

from transformers import pipeline
 
classifier = pipeline("text-classification", model="facebook/opt-350m")
print(classifier("Ich liebe sonnige Tage.", ["Wetter", "Emotion"]))

Dies klassifiziert den Satz "Ich liebe sonnige Tage." in Bezug auf "Wetter" und "Emotion" und gibt die Wahrscheinlichkeiten aus.

Schritt 3: Few-Shot-Learning

Few-Shot-Learning beinhaltet die Bereitstellung einer kleinen Anzahl von Beispielen, um dem Modell bei der Aufgabenerkennung zu helfen. Wenn Sie beispielsweise möchten, dass das Modell Englisch ins Französische übersetzt, können Sie ein paar Beispiele für Übersetzungen bereitstellen:

from transformers import pipeline
 
translator = pipeline('translation', model="facebook/opt-350m")
 
beispiele = [
    {"Englisch": "Hallo", "Französisch": "Bonjour"},
    {"Englisch": "Auf Wiedersehen", "Französisch": "Au revoir"},
]
 
translator.set_examples(beispiele)
 
print(translator("Guten Morgen"))

Bitte beachten Sie, dass dieses Beispiel vereinfacht ist, um es zu veranschaulichen. Die tatsächliche Verwendung könnte etwas komplexer sein und eine anspruchsvollere Einrichtung erfordern.

Schritt 4: Analyse von Stereotypical Bias

Sie können das OPT-Modell verwenden, um die stereotypischen Vorurteile zu analysieren, die in seinem generierten Text vorhanden sind. Hier ist ein Beispiel:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")
 
weiblicher_prompt = "Die Frau arbeitete als"
männlicher_prompt = "Der Mann arbeitete als"
 
weibliche_ausgabe = generator(weiblicher_prompt, num_return_sequences=5)
männliche_ausgabe = generator(männlicher_prompt, num_return_sequences=5)
 
print("Ausgaben für weiblichen Prompt:")
for ausgabe in weibliche_ausgabe:
    print(ausgabe['generated_text'])
 
print("Ausgaben für männlichen Prompt:")
for ausgabe in männliche_ausgabe:
    print(ausgabe['generated_text'])

Dies druckt 5 generierte Sequenzen für jeden Prompt aus, die analysiert werden können, um mögliche Vorurteile festzustellen. Beachten Sie, dass eine solche Analyse eine komplexe Aufgabe sein kann und fortschrittliche Natural Language Processing (NLP)-Techniken erfordern kann.

Bitte beachten Sie, dass Sie je nach den spezifischen OPT-Modellen, die im Hugging Face Model Hub verfügbar sind, die Modellnamen anpassen müssen. Außerdem existieren zum Zeitpunkt meines Wissensstandes im September 2021 möglicherweise einige Funktionen wie translator.set_examples(examples) nicht in der Transformers-Bibliothek. Sie wurden jedoch gegeben, um ein konzeptionelles Beispiel zu zeigen.

8. Flan-T5-XXL

Flan-T5-XXL (opens in a new tab) ist eine Sammlung feinabgestimmter T5-Modelle, die auf einer umfangreichen Zusammenstellung von Anweisungsdatensätzen trainiert wurden. Diese Modelle, obwohl sie nicht auf der Transformer-Architektur wie GPT-Modelle basieren, weisen eine signifikant verbesserte Leistung in verschiedenen Modellklassen wie PaLM, T5 und U-PaLM auf.

Um Flan-T5-XXL zu verwenden, können Sie die folgende Beispielverwendungsanleitung befolgen:

# Angenommen, Sie haben das Flan-T5-XXL-Repository bereits geklont und die Umgebung eingerichtet
 
from flan_t5_xx1 import FlanT5XXL
 
# Initialisieren Sie das Flan-T5-XXL-Modell
model = FlanT5XXL()
 
# Beispielhafte Verwendung: Anweisungen für eine Aufgabe generieren
task_input = "Wie backe ich einen Kuchen"
instructions = model.generate_instructions(task_input)
print(instructions)

In diesem Beispiel wird gezeigt, wie man Anweisungen für eine gegebene Aufgabe mit dem Flan-T5-XXL-Modell generieren kann. Die Variable task_input enthält die Aufgabenbeschreibung und die Methode generate_instructions() generiert die entsprechenden Anweisungen.

Bitte beachten Sie, dass der obige Code-Ausschnitt voraussetzt, dass Sie das Flan-T5-XXL-Repository bereits geklont und die erforderlichen Abhängigkeiten eingerichtet haben.

Flan-T5-XXL bietet einen modularen und zusammensetzbaren Rahmen für das Training und die Bewertung von Sequenzmodellen mit Schwerpunkt auf sprachbezogenen Aufgaben. Es wird unter Verwendung von JAX und Flax implementiert und basiert auf dem T5-Codebase. Flan-T5-XXL bietet ein hohes Maß an Konfigurierbarkeit und Self-Service-Fähigkeiten, mit denen Forscher Sequenzmodelle in verschiedenen Dimensionen trainieren und bewerten können.

Es ist wichtig, sich auf die offizielle Dokumentation und die bereitgestellten Beispiele von Flan-T5-XXL zu beziehen, um ein umfassendes Verständnis der verfügbaren Funktionalitäten und deren effektive Nutzung zu erlangen.

Ein Beispiel für die Verwendung von Flan-T5-XXL könnte wie folgt aussehen:

from flan import FlanT5
 
# Modell initialisieren
flan_model = FlanT5()
 
# Antwort generieren
response = flan_model.generate("Übersetze diesen Text ins Französische.")
print(response)

9. Baize

Baize (opens in a new tab) ist ein Open-Source-Chatmodell, das mit LoRA trainiert wurde. Es enthält 100.000 selbstgenerierte Dialoge von ChatGPT und nutzt die Daten von Alpaca für eine verbesserte Leistung. Modelle unterschiedlicher Größe wie 7B, 13B und 30B wurden veröffentlicht.

Um mit Baize über die CLI und API von Fastchat zu interagieren, befolgen Sie diese Schritte:

  1. Fastchat installieren:
pip install git+https://github.com/huggingface/peft.git
pip install git+https://github.com/lm-sys/FastChat.git
  1. Baizes LoRA-Gewichte zusammenführen (nur V1-Modelle):
python3 -m fastchat.model.apply_lora --base huggyllama/llama-7b --target ./model_weights/baize-7b --lora project-baize/baize-lora-7B
  1. Die CLI ausführen:
python -m fastchat.serve.cli --model-path ./model_weights/baize-7b

Baize kann auch mit der OpenAI API oder der Hugging Face API verwendet werden.

Für die Baize-Demo können Sie sie lokal ausführen, indem Sie diesen Schritten folgen:

  1. Erforderliche Pakete installieren:
cd demo
pip install -r requirements.txt
  1. Das Modell lokal hosten:
# Für V1-Modelle
base_model=huggyllama/llama-7b
lora_model=project-baize/baize-lora-7B
python app.py $base_model $lora_model
 
# Für V2-Modelle
base_model=project-baize/baize-v2-7b
python app.py $base_model None

Die Baize-Demo enthält eine benutzerfreundliche Gradio-Oberfläche zum Chatten.

Dies sind vereinfachte Beispielscodes. Für genauere Anweisungen und Optionen, konsultieren Sie bitte die Dokumentation des Baize-Projekts.

10. Koala

Koala (opens in a new tab) ist ein KI-Dialogmodell, das durch Feinabstimmung von LLaMA auf einem aus dem Web gesammelten Dataset für Dialoge trainiert wurde. Es übertrifft die Leistung von Alpaca und zeigt vergleichbare Ergebnisse wie ChatGPT in verschiedenen Szenarien. Eine der Hauptvorteile von Koala ist die umfangreiche Anpassungsfähigkeit und Anpassungsfähigkeit, die durch den verfügbaren Trainingscode, öffentliche Gewichte und einen Dialogfeinstimmer ermöglicht wird.

Im Kontext des Aufbaus eines 100% kostenlosen persönlichen "ChatGPT"-Bots mit Koala können Sie das bereitgestellte Colab-Notebook verwenden. Hier ist ein Überblick über den Prozess:

Schritt 1: Zugriff auf das Koala-Colab-Notebook

Ein vorab konfiguriertes Notebook von einem Machine Learning-Experten namens Sam Witteveen steht zur Verfügung, um das Koala-Modell auszuführen. Sie können das Notebook [hier](Link zum Notebook) finden. Kopieren Sie das Notebook in Ihr eigenes Google Drive.

Schritt 2: Das Notebook ausführen

Sobald Sie das Notebook in Ihrem Google Drive haben, können Sie es ausführen. Das Notebook beginnt mit der Installation der erforderlichen Module und deren Import. Anschließend lädt es das vorab trainierte Modell samwit/koala-7b unter Verwendung des LlamaTokenizer und LlamaForCausalLM aus der transformers-Bibliothek. Das Modell wird im 8-Bit-Modus geladen, was die Kompatibilität mit kostengünstigen GPUs ermöglicht.

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',
)

Schritt 3: Die Textgenerierungspipeline einrichten

Das Notebook richtet eine Pipeline für die Textgenerierung unter Verwendung der Hugging Face Pipeline-Methode ein. Parameter wie maximale Länge, Temperatur und Wiederholungsstrafung werden definiert. Zusätzlich wird eine Hilfsfunktion namens wrap_text_preserve_newlines() bereitgestellt, um das Erscheinungsbild des generierten Textes zu verbessern.

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):
    # Den Eingabetext anhand von Zeilenumbruchzeichen in Zeilen aufteilen
    lines = text.split('\n')
 
    # Jede Zeile einzeln umschlagen
    wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
 
    # Die umschlagenen Zeilen mit Zeilenumbruchzeichen wieder zusammenfügen
    wrapped_text = '\n'.join(wrapped_lines)
 
    return wrapped_text

Schritt 4: Dialoge führen

Das Notebook stellt Beispiele für Dialoge mit Anfangsantwortkonversationen unter Verwendung der pipe()-Methode aus der Hugging Face-Bibliothek zur Verfügung. Es ist wichtig zu beachten, dass der Erfolg des Modells stark davon abhängt, geeignete Prompts am Anfang jeder Konversation zu verwenden. Das Notebook schlägt vor, einen Prompt zu verwenden, der mit "BEGINNING OF CONVERSATION: USER:" beginnt, um die gewünschte Logik zu aktivieren. Sie sind eingeladen, mit verschiedenen Prompts und Parametern zu experimentieren, um die Reaktionen des Modells zu beobachten.

Insgesamt erweist sich Koala als vielversprechende Alternative zu größeren Sprachmodellen wie GPT-3. Durch eine sorgfältige Kuratierung der Trainingsdaten kann selbst ein kleineres Modell beeindruckende Leistungen erbringen. Das Koala-Team und Community-Experten haben es einfach gemacht, auf das Modell über die Online-Demo und das bereitgestellte Google Colab-Notebook zuzugreifen und damit zu experimentieren. Egal, ob Sie einen Chatbot entwickeln oder LLM-Forschung betreiben möchten, ohne Modellnutzungskosten zu verursachen, Koala ist eine ausgezeichnete Wahl.

## Fazit

Die Open-Source-Landschaft ist reich an Alternativen zu ChatGPT, die jeweils einzigartige Möglichkeiten bieten. Ob Sie ein KI-Enthusiast, Forscher oder Entwickler sind, diese Tools können Ihnen helfen, Ihre eigenen Konversationsmodelle aufzubauen und zu optimieren. Also los, tauchen Sie ein in die Welt der Open-Source-Konversations-KI.