Startseite>Programmierbezogen>Anderer Quellcode
Herunterladen

lama.cpp

Roadmap / Projektstatus / Manifest / ggml

Inferenz des LLaMA-Modells von Meta (und anderer) in reinem C/C++

Aktuelle API-Änderungen

  • Änderungsprotokoll für libllama -API

  • Änderungsprotokoll für llama-server REST-API

Heiße Themen

  • Wir stellen vor: GGUF-my-LoRA #10123

  • Hugging Face Inference Endpoints unterstützen jetzt GGUF sofort! #9669

  • Hugging Face GGUF-Herausgeber: Diskussion | Werkzeug

Beschreibung

Das Hauptziel von llama.cpp besteht darin, LLM-Inferenz mit minimalem Setup und modernster Leistung auf einer Vielzahl von Hardware zu ermöglichen – lokal und in der Cloud.

  • Einfache C/C++-Implementierung ohne Abhängigkeiten

  • Apple Silicon ist ein erstklassiger Bürger – optimiert durch ARM NEON-, Accelerate- und Metal-Frameworks

  • AVX-, AVX2-, AVX512- und AMX-Unterstützung für x86-Architekturen

  • 1,5-Bit-, 2-Bit-, 3-Bit-, 4-Bit-, 5-Bit-, 6-Bit- und 8-Bit-Ganzzahlquantisierung für schnellere Inferenz und reduzierten Speicherverbrauch

  • Benutzerdefinierte CUDA-Kernel zum Ausführen von LLMs auf NVIDIA-GPUs (Unterstützung für AMD-GPUs über HIP und Moore Threads MTT-GPUs über MUSA)

  • Vulkan- und SYCL-Backend-Unterstützung

  • CPU+GPU-Hybrid-Inferenz zur teilweisen Beschleunigung von Modellen, die größer als die gesamte VRAM-Kapazität sind

Seit seiner Gründung hat sich das Projekt dank vieler Beiträge erheblich verbessert. Es ist der wichtigste Spielplatz für die Entwicklung neuer Funktionen für die ggml-Bibliothek.

Unterstützte Modelle:

Typischerweise werden auch Feinabstimmungen der unten aufgeführten Basismodelle unterstützt.

  • LLaMA ?

  • LLaMA 2 ??

  • LLaMA 3 ???

  • Mistral 7B

  • Mixtral MoE

  • DBRX

  • Falke

  • Chinesisches LLaMA/Alpaka und Chinesisches LLaMA-2/Alpaka-2

  • Vigogne (Französisch)

  • BERT

  • Koala

  • Baichuan 1 & 2 + Ableitungen

  • Aquila 1 & 2

  • Starcoder-Modelle

  • Refact

  • MPT

  • Blühen

  • Yi-Modelle

  • StableLM-Modelle

  • Deepseek-Modelle

  • Qwen-Modelle

  • PLaMo-13B

  • Phi-Modelle

  • GPT-2

  • Orion 14B

  • PraktikantLM2

  • CodeShell

  • Gemma

  • Mamba

  • Grok-1

  • Xverse

  • Command-R-Modelle

  • Seelöwe

  • GritLM-7B + GritLM-8x7B

  • OLMo

  • OLMoE

  • Granitmodelle

  • GPT-NeoX + Pythia

  • Schneeflocke-Arktis-MoE

  • Smaug

  • Poro 34B

  • Bitnet b1.58-Modelle

  • Flan T5

  • Offene Elm-Modelle

  • ChatGLM3-6b + ChatGLM4-9b

  • SmolLM

  • EXAONE-3.0-7.8B-Anleitung

  • FalconMamba-Modelle

  • Jais

  • Bielik-11B-v2.3

  • RWKV-6

(Anleitung zur Unterstützung weiterer Modelle: HOWTO-add-model.md)

Multimodale Modelle:

  • LLaVA 1.5-Modelle, LLaVA 1.6-Modelle

  • BakLLaVA

  • Obsidian

  • TeilenGPT4V

  • MobileVLM 1.7B/3B-Modelle

  • Yi-VL

  • Mini-CPM

  • Mondtraum

  • Hase

Bindungen:

  • Python: abetlen/llama-cpp-python

  • Gehen Sie zu: go-skynet/go-llama.cpp

  • Node.js: withcatai/node-llama-cpp

  • JS/TS (llama.cpp-Server-Client): lgrammel/modelfusion

  • JS/TS (Programmable Prompt Engine CLI): offline-ai/cli

  • JavaScript/Wasm (funktioniert im Browser): tangledgroup/llama-cpp-wasm

  • Typescript/Wasm (schönere API, verfügbar auf npm): ngxson/wllama

  • Ruby: yoshoku/llama_cpp.rb

  • Rust (weitere Funktionen): edgenai/llama_cpp-rs

  • Rust (schönere API): mdrokz/rust-llama.cpp

  • Rust (direktere Bindungen): Utilityai/llama-cpp-rs

  • C#/.NET: SciSharp/LLamaSharp

  • C#/VB.NET (mehr Funktionen – Community-Lizenz): LM-Kit.NET

  • Scala 3: donderom/llm4s

  • Clojure: phronmophobic/llama.clj

  • Native reagieren: mybigday/llama.rn

  • Java: kherud/java-llama.cpp

  • Zig: deins/llama.cpp.zig

  • Flutter/Dart: netdur/llama_cpp_dart

  • PHP (API-Bindungen und Funktionen, die auf llama.cpp basieren): distancemagic/resonance (mehr Informationen)

  • Guile-Schema: guile_llama_cpp

  • Swift srgtuszy/llama-cpp-swift

  • Swift ShenghaiWang/SwiftLlama

Benutzeroberfläche:

Sofern nicht anders angegeben, handelt es sich bei diesen Projekten um Open-Source-Projekte mit freizügiger Lizenzierung:

  • MindWorkAI/AI-Studio (FSL-1.1-MIT)

  • iohub/collama

  • janhq/jan (AGPL)

  • nat/offener Spielplatz

  • Faraday (proprietär)

  • LMStudio (proprietär)

  • Layla (proprietär)

  • Ramalama (MIT)

  • LocalAI (MIT)

  • LostRuins/koboldcpp (AGPL)

  • Mozilla-Ocho/llamafile

  • nomic-ai/gpt4all

  • Ollama/Ollama

  • oobabooga/text-generation-webui (AGPL)

  • psugihara/FreeChat

  • cztomsik/ava (MIT)

  • ptsochantaris/emeltal

  • Pythons/Tenere (AGPL)

  • RAGNA Desktop (proprietär)

  • RecurseChat (proprietär)

  • semperai/amica

  • mitcatai/catai

  • Mobile-Künstliche-Intelligenz/Dienstmädchen (MIT)

  • Msty (proprietär)

  • LLMFarm (MIT)

  • KanTV (Apachev2.0 oder höher)

  • Punkt (GPL)

  • MindMac (proprietär)

  • KodiBot (GPL)

  • eva (MIT)

  • AI Sublime Text-Plugin (MIT)

  • AIKit (MIT)

  • LARS – Die LLM & Advanced Referencing Solution (AGPL)

  • LLMUnity (MIT)

  • Lama-Assistent (GPL)

  • PocketPal AI – Eine iOS- und Android-App (MIT)

(Damit ein Projekt hier aufgeführt wird, sollte klar angegeben werden, dass es von llama.cpp abhängt.)

Werkzeuge:

  • akx/ggify – Laden Sie PyTorch-Modelle vom HuggingFace Hub herunter und konvertieren Sie sie in GGML

  • akx/ollama-dl – Laden Sie Modelle aus der Ollama-Bibliothek herunter, um sie direkt mit llama.cpp zu verwenden

  • crashr/gppm – Starten Sie llama.cpp-Instanzen mit NVIDIA Tesla P40- oder P100-GPUs mit reduziertem Stromverbrauch im Leerlauf

  • gpustack/gguf-parser – Überprüfen/überprüfen Sie die GGUF-Datei und schätzen Sie die Speichernutzung

  • Styled Lines (proprietär lizenzierter, asynchroner Wrapper des Inferenzteils für die Spieleentwicklung in Unity3d mit vorgefertigten Wrappern für Mobil- und Webplattformen und einem Modellbeispiel)

Infrastruktur:

  • Paddler – Stateful Load Balancer, maßgeschneidert für llama.cpp

  • GPUStack – GPU-Cluster für die Ausführung von LLMs verwalten

  • llama_cpp_canister – llama.cpp als intelligenter Vertrag auf dem Internetcomputer unter Verwendung von WebAssembly

Spiele:

  • Lucy's Labyrinth – Ein einfaches Labyrinthspiel, bei dem von einem KI-Modell gesteuerte Agenten versuchen, Sie auszutricksen.

Demo

Typischer Lauf mit LLaMA v2 13B auf M2 Ultra 
$ make -j && ./llama-cli -m models/llama-13b-v2/ggml-model-q4_0.gguf -p "Building a website can be done in 10 simple steps:nStep 1:" -n 400 -e
I llama.cpp build info:
I UNAME_S:  Darwin
I UNAME_P:  arm
I UNAME_M:  arm64
I CFLAGS:   -I.            -O3 -std=c11   -fPIC -DNDEBUG -Wall -Wextra -Wpedantic -Wcast-qual -Wdouble-promotion -Wshadow -Wstrict-prototypes -Wpointer-arith -Wmissing-prototypes -pthread -DGGML_USE_K_QUANTS -DGGML_USE_ACCELERATE
I CXXFLAGS: -I. -I./common -O3 -std=c++11 -fPIC -DNDEBUG -Wall -Wextra -Wpedantic -Wcast-qual -Wno-unused-function -Wno-multichar -pthread -DGGML_USE_K_QUANTS
I LDFLAGS:   -framework Accelerate
I CC:       Apple clang version 14.0.3 (clang-1403.0.22.14.1)
I CXX:      Apple clang version 14.0.3 (clang-1403.0.22.14.1)

make: Nothing to be done for `default'.
main: build = 1041 (cf658ad)
main: seed  = 1692823051
llama_model_loader: loaded meta data with 16 key-value pairs and 363 tensors from models/llama-13b-v2/ggml-model-q4_0.gguf (version GGUF V1 (latest))
llama_model_loader: - type  f32:   81 tensors
llama_model_loader: - type q4_0:  281 tensors
llama_model_loader: - type q6_K:    1 tensors
llm_load_print_meta: format         = GGUF V1 (latest)
llm_load_print_meta: arch           = llama
llm_load_print_meta: vocab type     = SPM
llm_load_print_meta: n_vocab        = 32000
llm_load_print_meta: n_merges       = 0
llm_load_print_meta: n_ctx_train    = 4096
llm_load_print_meta: n_ctx          = 512
llm_load_print_meta: n_embd         = 5120
llm_load_print_meta: n_head         = 40
llm_load_print_meta: n_head_kv      = 40
llm_load_print_meta: n_layer        = 40
llm_load_print_meta: n_rot          = 128
llm_load_print_meta: n_gqa          = 1
llm_load_print_meta: f_norm_eps     = 1.0e-05
llm_load_print_meta: f_norm_rms_eps = 1.0e-05
llm_load_print_meta: n_ff           = 13824
llm_load_print_meta: freq_base      = 10000.0
llm_load_print_meta: freq_scale     = 1
llm_load_print_meta: model type     = 13B
llm_load_print_meta: model ftype    = mostly Q4_0
llm_load_print_meta: model size     = 13.02 B
llm_load_print_meta: general.name   = LLaMA v2
llm_load_print_meta: BOS token = 1 '<s>'
llm_load_print_meta: EOS token = 2 '</s>'
llm_load_print_meta: UNK token = 0 '<unk>'
llm_load_print_meta: LF token  = 13 '<0x0A>'
llm_load_tensors: ggml ctx size =    0.11 MB
llm_load_tensors: mem required  = 7024.01 MB (+  400.00 MB per state)
...................................................................................................
llama_new_context_with_model: kv self size  =  400.00 MB
llama_new_context_with_model: compute buffer total size =   75.41 MB

system_info: n_threads = 16 / 24 | AVX = 0 | AVX2 = 0 | AVX512 = 0 | AVX512_VBMI = 0 | AVX512_VNNI = 0 | FMA = 0 | NEON = 1 | ARM_FMA = 1 | F16C = 0 | FP16_VA = 1 | WASM_SIMD = 0 | BLAS = 1 | SSE3 = 0 | VSX = 0 |
sampling: repeat_last_n = 64, repeat_penalty = 1.100000, presence_penalty = 0.000000, frequency_penalty = 0.000000, top_k = 40, tfs_z = 1.000000, top_p = 0.950000, typical_p = 1.000000, temp = 0.800000, mirostat = 0, mirostat_lr = 0.100000, mirostat_ent = 5.000000
generate: n_ctx = 512, n_batch = 512, n_predict = 400, n_keep = 0


 Building a website can be done in 10 simple steps:
Step 1: Find the right website platform.
Step 2: Choose your domain name and hosting plan.
Step 3: Design your website layout.
Step 4: Write your website content and add images.
Step 5: Install security features to protect your site from hackers or spammers
Step 6: Test your website on multiple browsers, mobile devices, operating systems etc…
Step 7: Test it again with people who are not related to you personally – friends or family members will work just fine!
Step 8: Start marketing and promoting the website via social media channels or paid ads
Step 9: Analyze how many visitors have come to your site so far, what type of people visit more often than others (e.g., men vs women) etc…
Step 10: Continue to improve upon all aspects mentioned above by following trends in web design and staying up-to-date on new technologies that can enhance user experience even further!
How does a Website Work?
A website works by having pages, which are made of HTML code. This code tells your computer how to display the content on each page you visit – whether it’s an image or text file (like PDFs). In order for someone else’s browser not only be able but also want those same results when accessing any given URL; some additional steps need taken by way of programming scripts that will add functionality such as making links clickable!
The most common type is called static HTML pages because they remain unchanged over time unless modified manually (either through editing files directly or using an interface such as WordPress). They are usually served up via HTTP protocols – this means anyone can access them without having any special privileges like being part of a group who is allowed into restricted areas online; however, there may still exist some limitations depending upon where one lives geographically speaking.
How to
llama_print_timings:        load time =   576.45 ms
llama_print_timings:      sample time =   283.10 ms /   400 runs   (    0.71 ms per token,  1412.91 tokens per second)
llama_print_timings: prompt eval time =   599.83 ms /    19 tokens (   31.57 ms per token,    31.68 tokens per second)
llama_print_timings:        eval time = 24513.59 ms /   399 runs   (   61.44 ms per token,    16.28 tokens per second)
llama_print_timings:       total time = 25431.49 ms
Demo der Ausführung von LLaMA-7B und whisper.cpp auf einem einzelnen M1 Pro MacBook

Und hier ist eine weitere Demo zur Ausführung von LLaMA-7B und whisper.cpp auf einem einzelnen M1 Pro MacBook:

whisper-llama-lq.mp4

Verwendung

Hier sind die End-to-End-Binärerstellungs- und Modellkonvertierungsschritte für die meisten unterstützten Modelle.

Grundlegende Verwendung

Zuerst müssen Sie die Binärdatei erhalten. Es gibt verschiedene Methoden, denen Sie folgen können:

  • Methode 1: Klonen Sie dieses Repository und erstellen Sie es lokal. Sehen Sie sich an, wie es erstellt wird

  • Methode 2: Wenn Sie MacOS oder Linux verwenden, können Sie llama.cpp über brew, flox oder nix installieren

  • Methode 3: Verwenden Sie ein Docker-Image, siehe Dokumentation für Docker

  • Methode 4: Laden Sie vorgefertigte Binärdateien von Releases herunter

Mit diesem Befehl können Sie eine grundlegende Vervollständigung ausführen:

 llama-cli -m your_model.gguf -p "Ich glaube, der Sinn des Lebens ist" -n 128# Ausgabe:# Ich glaube, der Sinn des Lebens besteht darin, die eigene Wahrheit zu finden und danach zu leben. Für mich bedeutet das, mir selbst treu zu bleiben und meinen Leidenschaften zu folgen, auch wenn sie nicht mit den gesellschaftlichen Erwartungen übereinstimmen. Ich denke, das ist es, was ich an Yoga liebe – es ist nicht nur eine körperliche, sondern auch eine spirituelle Praxis. Es geht darum, sich mit sich selbst zu verbinden, auf die innere Stimme zu hören und die eigene einzigartige Reise zu würdigen.

Auf dieser Seite finden Sie eine vollständige Liste der Parameter.

Konversationsmodus

Wenn Sie ein eher ChatGPT-ähnliches Erlebnis wünschen, können Sie es im Konversationsmodus ausführen, indem Sie -cnv als Parameter übergeben:

 llama-cli -m your_model.gguf -p „Du bist ein hilfreicher Assistent“ -cnv# Ausgabe:# > Hallo, wer bist du?# Hallo! Ich bin Ihr hilfreicher Assistent! Ich bin ein KI-gestützter Chatbot, der Benutzer wie Sie unterstützen und mit Informationen versorgen soll. Ich bin hier, um Ihnen bei der Beantwortung Ihrer Fragen zu helfen, Ihnen Orientierung zu geben und Ihnen Unterstützung zu einem breiten Themenspektrum anzubieten. Ich bin eine freundliche und sachkundige KI und helfe Ihnen gerne bei allem, was Sie brauchen. Was geht Ihnen durch den Kopf und wie kann ich Ihnen heute helfen?## > Was ist 1+1?# Kinderleicht! Die Antwort auf 1+1 ist... 2!

Standardmäßig wird die Chat-Vorlage aus dem Eingabemodell übernommen. Wenn Sie eine andere Chat-Vorlage verwenden möchten, übergeben Sie --chat-template NAME als Parameter. Sehen Sie sich die Liste der unterstützten Vorlagen an

 ./llama-cli -m your_model.gguf -p „Du bist ein hilfreicher Assistent“ -cnv --chat-template chatml

Sie können auch Ihre eigene Vorlage über In-Prefix-, In-Suffix- und Reverse-Prompt-Parameter verwenden:

 ./llama-cli -m your_model.gguf -p „Sie sind ein hilfreicher Assistent“ -cnv --in-prefix 'Benutzer: ' --reverse-prompt 'Benutzer:'

Webserver

Der Webserver llama.cpp ist ein leichter, mit der OpenAI-API kompatibler HTTP-Server, der zur Bereitstellung lokaler Modelle und deren einfache Verbindung mit vorhandenen Clients verwendet werden kann.

Beispielverwendung:

 ./llama-server -m your_model.gguf --port 8080# Auf die grundlegende Web-Benutzeroberfläche kann über den Browser zugegriffen werden: http://localhost:8080# Chat-Abschlussendpunkt: http://localhost:8080/v1/chat/completions

Interaktiver Modus

Notiz

Wenn Sie eine einfache Nutzung bevorzugen, sollten Sie die Verwendung des Konversationsmodus anstelle des interaktiven Modus in Betracht ziehen

In diesem Modus können Sie die Generierung jederzeit unterbrechen, indem Sie Strg+C drücken und eine oder mehrere Textzeilen eingeben, die in Token umgewandelt und an den aktuellen Kontext angehängt werden. Sie können auch eine umgekehrte Eingabeaufforderung mit dem Parameter -r "reverse prompt string" angeben. Dies führt dazu, dass der Benutzer immer dann zur Eingabe aufgefordert wird, wenn bei der Generierung die genauen Token der umgekehrten Eingabeaufforderungszeichenfolge gefunden werden. Eine typische Verwendung besteht darin, eine Eingabeaufforderung zu verwenden, die LLaMA dazu bringt, einen Chat zwischen mehreren Benutzern, beispielsweise Alice und Bob, zu emulieren und -r "Alice:" zu übergeben.

Hier ist ein Beispiel für eine Interaktion mit wenigen Schüssen, die mit dem Befehl aufgerufen wird

 # Standardargumente mit einem 7B-Modell./examples/chat.sh# Erweiterter Chat mit einem 13B-Modell./examples/chat-13B.sh# Benutzerdefinierte Argumente mit einem 13B-Modell./llama-cli -m ./models/13B/ ggml-model-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -i -r "Benutzer:" -f prompts/chat-with-bob.txt

Beachten Sie die Verwendung von --color zur Unterscheidung zwischen Benutzereingaben und generiertem Text. Weitere Parameter werden in der README zum Beispielprogramm llama-cli genauer erklärt.

Bild

Anhaltende Interaktion

Die Eingabeaufforderung, Benutzereingaben und Modellgenerierungen können gespeichert und über Aufrufe von ./llama-cli hinweg fortgesetzt werden, indem --prompt-cache und --prompt-cache-all genutzt werden. Das Skript ./examples/chat-persistent.sh demonstriert dies mit der Unterstützung lang andauernder, fortsetzbarer Chatsitzungen. Um dieses Beispiel zu verwenden, müssen Sie eine Datei zum Zwischenspeichern der ersten Chat-Eingabeaufforderung und ein Verzeichnis zum Speichern der Chat-Sitzung bereitstellen und können optional dieselben Variablen wie chat-13B.sh bereitstellen. Derselbe Prompt-Cache kann für neue Chat-Sitzungen wiederverwendet werden. Beachten Sie, dass sowohl der Prompt-Cache als auch das Chat-Verzeichnis an den ersten Prompt ( PROMPT_TEMPLATE ) und die Modelldatei gebunden sind.

 # Starten Sie einen neuen ChatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh# Setzen Sie diesen fort chatPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat- persistent.sh# Starten Sie einen anderen Chat mit demselben prompt/modelPROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh# Unterschiedlicher Prompt-Cache für verschiedene prompt/modelPROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob. prompt.bin 
    CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh

Eingeschränkte Ausgabe mit Grammatiken

llama.cpp unterstützt Grammatiken, um die Modellausgabe einzuschränken. Sie können beispielsweise erzwingen, dass das Modell nur JSON ausgibt:

 ./llama-cli -m ./models/13B/ggml-model-q4_0.gguf -n 256 --grammar-file grammars/json.gbnf -p 'Anfrage: Planen Sie einen Anruf um 20 Uhr; Befehl:'

Der Ordner grammars/ enthält eine Handvoll Beispielgrammatiken. Um Ihr eigenes zu schreiben, schauen Sie sich den GBNF-Leitfaden an.

Wenn Sie komplexere JSON-Grammatiken erstellen möchten, können Sie sich auch https://grammar.intrinsiclabs.ai/ ansehen, eine Browser-App, mit der Sie TypeScript-Schnittstellen schreiben können, die zu GBNF-Grammatiken kompiliert werden, die Sie zur lokalen Verwendung speichern können. Beachten Sie, dass die App von Mitgliedern der Community erstellt und gepflegt wird. Bitte melden Sie alle Probleme oder FRs in ihrem Repo und nicht in diesem.

Bauen

Weitere Informationen finden Sie unter „Lama.cpp lokal erstellen“.

Unterstützte Backends

Backend Zielgeräte
Metall Apple Silicon
BLAS Alle
GLÜCKLICH Alle
SYCL Intel- und Nvidia-GPU
MUSA Moore Threads MTT-GPU
CUDA Nvidia-GPU
hipBLAS AMD-GPU
Vulkan GPU
KANN NPU aufsteigen

Werkzeuge

Vorbereiten und quantisieren

Notiz

Sie können den GGUF-my-repo-Bereich auf Hugging Face auch verwenden, um Ihre Modellgewichte ohne jegliche Einrichtung zu quantifizieren. Es wird alle 6 Stunden von llama.cpp main synchronisiert.

Um die offiziellen LLaMA 2-Gewichte zu erhalten, lesen Sie bitte den Abschnitt „Erhalten und Verwenden des Facebook-LLaMA-2-Modells“. Auf Hugging Face ist auch eine große Auswahl an vorquantisierten gguf -Modellen verfügbar.

Hinweis: convert.py wurde nach examples/convert_legacy_llama.py verschoben und sollte nur für Llama/Llama2/Mistral -Modelle und deren Derivate verwendet werden. LLaMA 3 wird nicht unterstützt. Sie können convert_hf_to_gguf.py mit LLaMA 3 verwenden, das Sie von Hugging Face heruntergeladen haben.

Um mehr über das Quantisierungsmodell zu erfahren, lesen Sie diese Dokumentation

Ratlosigkeit (Messung der Modellqualität)

Sie können das perplexity verwenden, um die Ratlosigkeit bei einer bestimmten Eingabeaufforderung zu messen (eine geringere Ratlosigkeit ist besser). Weitere Informationen finden Sie unter https://huggingface.co/docs/transformers/perplexity.

Um mehr darüber zu erfahren, wie Sie Perplexität mit llama.cpp messen können, lesen Sie diese Dokumentation

Mitwirken

  • Mitwirkende können PRs öffnen

  • Mitarbeiter können auf Zweige im llama.cpp -Repository pushen und PRs im master zusammenführen

  • Mitarbeiter werden auf der Grundlage ihrer Beiträge eingeladen

  • Jede Hilfe bei der Verwaltung von Problemen, PRs und Projekten ist sehr willkommen!

  • Für Aufgaben, die für Erstbeiträge geeignet sind, siehe gute Erstausgaben

  • Weitere Informationen finden Sie im CONTRIBUTING.md

  • Lesen Sie unbedingt Folgendes: Inferenz am Rande

  • Ein bisschen Hintergrundgeschichte für Interessierte: Changelog-Podcast

Andere Dokumentationen

  • Haupt (cli)

  • Server

  • Gefahr

  • GBNF-Grammatiken

Entwicklungsdokumentationen

  • Wie baut man

  • Läuft auf Docker

  • Bauen Sie auf Android auf

  • Fehlerbehebung bei der Leistung

  • GGML-Tipps und Tricks

Wegweisende Arbeiten und Hintergrundinformationen zu den Modellen

Wenn Ihr Problem mit der Qualität der Modellgenerierung zusammenhängt, scannen Sie bitte zumindest die folgenden Links und Dokumente, um die Einschränkungen von LLaMA-Modellen zu verstehen. Dies ist besonders wichtig, wenn Sie eine geeignete Modellgröße auswählen und sowohl die signifikanten als auch die subtilen Unterschiede zwischen LLaMA-Modellen und ChatGPT schätzen:

  • Lama:

    • Wir stellen LLaMA vor: Ein grundlegendes, großes Sprachmodell mit 65 Milliarden Parametern

    • LLaMA: Offene und effiziente Foundation-Language-Modelle

  • GPT-3

    • Sprachmodelle sind Few-Shot-Lernende

  • GPT-3.5 / InstructGPT / ChatGPT:

    • Sprachmodelle so ausrichten, dass sie Anweisungen befolgen

    • Sprachmodelle trainieren, um Anweisungen mit menschlichem Feedback zu befolgen

Expandieren
Zusätzliche Informationen
Ähnliche Anwendungen
Empfohlen für Sie
Ähnliche Nachrichten Alle