llama.cpp: Schreiben eines einfachen C++-Inferenzprogramms für GGUF-LLM-Modelle

Erkundung der Interna von llama.cpp und eines grundlegenden Chat-Programmablaufs

This tutorial will guide you through the process of building a simple C++ program that performs inference on GGUF LLM models using the llama.cpp framework. We will cover the essential steps involved in loading the model, performing inference, and displaying the results. The code for this tutorial can be found here.

Dieses Tutorial führt Sie durch den Prozess der Erstellung eines einfachen C++-Programms, das mithilfe des llama.cpp-Frameworks Rückschlüsse auf GGUF-LLM-Modelle durchführt. Wir werden die wesentlichen Schritte behandeln, die zum Laden des Modells, zum Durchführen von Inferenzen und zum Anzeigen der Ergebnisse erforderlich sind. Den Code für dieses Tutorial finden Sie hier.

Prerequisites

Voraussetzungen

To follow along with this tutorial, you will need the following:

Um diesem Tutorial folgen zu können, benötigen Sie Folgendes:

A Linux-based operating system (native or WSL)

Ein Linux-basiertes Betriebssystem (nativ oder WSL)

CMake installed

CMake installiert

GNU/clang toolchain installed

GNU/clang-Toolchain installiert

Step 1: Setting Up the Project

Schritt 1: Einrichten des Projekts

Let's start by setting up our project. We will be building a C/C++ program that uses llama.cpp to perform inference on GGUF LLM models.

Beginnen wir mit der Einrichtung unseres Projekts. Wir werden ein C/C++-Programm erstellen, das llama.cpp verwendet, um Rückschlüsse auf GGUF-LLM-Modelle zu ziehen.

Create a new project directory, let's call it smol_chat.

Erstellen Sie ein neues Projektverzeichnis, nennen wir es smol_chat.

Within the project directory, let's clone the llama.cpp repository into a subdirectory called externals. This will give us access to the llama.cpp source code and headers.

Klonen wir im Projektverzeichnis das Repository „llama.cpp“ in ein Unterverzeichnis namens „externals“. Dadurch erhalten wir Zugriff auf den Quellcode und die Header von llama.cpp.

mkdir -p externals

mkdir -p Externals

cd externals

CD-Externe

git clone https://github.com/georgigerganov/llama.cpp.git

Git-Klon https://github.com/georgigerganov/llama.cpp.git

cd ..

CD ..

Step 2: Configuring CMake

Schritt 2: CMake konfigurieren

Now, let's configure our project to use CMake. This will allow us to easily compile and link our C/C++ code with the llama.cpp library.

Jetzt konfigurieren wir unser Projekt für die Verwendung von CMake. Dadurch können wir unseren C/C++-Code einfach kompilieren und mit der Bibliothek llama.cpp verknüpfen.

Create a CMakeLists.txt file in the project directory.

Erstellen Sie eine CMakeLists.txt-Datei im Projektverzeichnis.

In the CMakeLists.txt file, add the following code:

Fügen Sie in der Datei CMakeLists.txt den folgenden Code hinzu:

cmake_minimum_required(VERSION 3.10)

project(smol_chat)

Projekt(smol_chat)

set(CMAKE_CXX_STANDARD 20)

set(CMAKE_CXX_STANDARD_REQUIRED ON)

add_executable(smol_chat main.cpp)

target_include_directories(smol_chat PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})

target_link_libraries(smol_chat llama.cpp)

This code specifies the minimum CMake version, sets the C++ standard and standard flag, adds an executable named smol_chat, includes headers from the current source directory, and links the llama.cpp shared library to our executable.

Dieser Code gibt die CMake-Mindestversion an, legt den C++-Standard und das Standard-Flag fest, fügt eine ausführbare Datei namens smol_chat hinzu, schließt Header aus dem aktuellen Quellverzeichnis ein und verknüpft die gemeinsam genutzte Bibliothek llama.cpp mit unserer ausführbaren Datei.

Step 3: Defining the LLM Interface

Schritt 3: Definieren der LLM-Schnittstelle

Next, let's define a C++ class that will handle the high-level interactions with the LLM. This class will abstract away the low-level llama.cpp function calls and provide a convenient interface for performing inference.

Als Nächstes definieren wir eine C++-Klasse, die die Interaktionen auf hoher Ebene mit dem LLM abwickelt. Diese Klasse abstrahiert die Low-Level-Funktionsaufrufe von llama.cpp und stellt eine praktische Schnittstelle zum Durchführen von Inferenzen bereit.

In the project directory, create a header file called LLMInference.h.

Erstellen Sie im Projektverzeichnis eine Header-Datei mit dem Namen LLMInference.h.

In LLMInference.h, declare the following class:

Deklarieren Sie in LLMInference.h die folgende Klasse:

class LLMInference {

Klasse LLMInference {

public:

öffentlich:

LLMInference(const std::string& model_path);

LLMInference(const std::string& model_path);

~LLMInference();

~LLMInference();

void startCompletion(const std::string& query);

void startCompletion(const std::string& query);

std::string completeNext();

std::string CompleteNext();

private:

Privat:

llama_model llama_model_;

Flame_model Flame_model_;

llama_context llama_context_;

llama_context llama_context_;

llama_sampler llama_sampler_;

call_sampler call_sampler_;

std::vector _messages;

std::vector _messages;

std::vector _formattedMessages;

std::vector _formattedMessages;

std::vector _tokens;

std::vector _tokens;

llama_batch batch_;

llama_batch batch_;

};

This class has a public constructor that takes the path to the GGUF LLM model as an argument and a destructor that deallocates any dynamically-allocated objects. It also has two public member functions: startCompletion, which initiates the completion process for a given query, and completeNext, which fetches the next token in the LLM's response sequence.

Diese Klasse verfügt über einen öffentlichen Konstruktor, der den Pfad zum GGUF-LLM-Modell als Argument verwendet, und einen Destruktor, der alle dynamisch zugewiesenen Objekte freigibt. Es verfügt außerdem über zwei öffentliche Mitgliedsfunktionen: startCompletion, die den Abschlussprozess für eine bestimmte Abfrage initiiert, und completeNext, die das nächste Token in der Antwortsequenz des LLM abruft.

Step 4: Implementing LLM Inference Functions

Schritt 4: Implementierung von LLM-Inferenzfunktionen

Now, let's define the implementation for the LLMInference class in a file called LLMInference.cpp.

Definieren wir nun die Implementierung für die LLMInference-Klasse in einer Datei namens LLMInference.cpp.

In LLMInference.cpp, include the necessary headers and implement the class methods as follows:

Fügen Sie in LLMInference.cpp die erforderlichen Header ein und implementieren Sie die Klassenmethoden wie folgt:

#include "LLMInference.h"

#include „LLMInference.h“

#include "common.h"

#include „common.h“

#include

#enthalten

#include

#enthalten

#include

#enthalten

LLMInference::LLMInference(const std::string& model_path) {

LLMInference::LLMInference(const std::string& model_path) {

llama_load_model_from_file(&llama_model_, model_path.c_str(), llama_model_default_params());

llama_load_model_from_file(&llama_model_, model_path.c_str(), llama_model_default_params());

llama_new_context_with_model(&llama_context_, &llama_model_);

llama_new_context_with_model(&llama_context_, &llama_model_);

llama_sampler_init_temp(&llama_sampler_, 0.8f);

llama_sampler_init_temp(&llama_sampler_, 0.8f);

llama_sampler_init_min_p(&llama_sampler_, 0.0f);

call_sampler_init_min_p(&call_sampler_, 0.0f);

}

LLMInference::~LLMInference() {

for (auto& msg : _messages) {

for (auto& msg : _messages) {

std::free(msg.content);

std::free(msg.content);

}

}

llama_free_model(&llama_model_);

llama_free_model(&llama_model_);

llama_free_context(&llama_context_);

llama_free_context(&llama_context_);

}

void LLMInference::startCompletion(const std::string& query)

void LLMInference::startCompletion(const std::string& query)