llama.cpp Mac版本llama

骆驼.cpp

路线图/宣言/ ggml

纯C/C++中LLaMA模型的推理

热点话题：

简单的网络聊天示例：#1998 k-quants 现在支持 64 的超级块大小 super-block size of 64:：#2001 新路线图： https: //github.com/users/ggerganov/projects/7 Azure CI 头脑风暴：#1985 p1：基于 LLM 的边缘代码补全引擎：ggml-org/p1#1

描述

主要目标llama.cpp是在 MacBook 上使用 4 位整数量化运行 LLaMA 模型

无依赖关系的纯 C/C++ 实现 Apple 芯片一等公民 - 通过 ARM NEON、Accelerate 和 Metal 框架进行优化对 x86 架构的 AVX、AVX2 和 AVX512 支持混合F16/F32精度支持 4 位、5 位和 8 位整数量化 BLAS支持 OpenBLAS/Apple BLAS/ARM Performance Lib/ATLAS/BLIS/Intel MKL/NVHPC/ACML/SCSL/SGIMATH等 cuBLAS 和 CLBlast 支持

最初的实现在一个晚上就被黑客入侵llama.cpp了。从那时起，由于许多贡献，该项目有了显着改进。该项目用于教育目的，并作为开发ggml库新功能的主要平台。

支持的平台：

苹果系统 Linux Windows（通过 CMake）码头工人

支持型号：

Bindings:

Supported models:

LLaMA Alpaca GPT4All Chinese LLaMA / Alpaca Vigogne (French) Vicuna Koala OpenBuddy 编辑 (Multilingual) Pygmalion 7B / Metharme 7B WizardLM Baichuan-7B and its derivations (such as baichuan-7b-sft) Python: abetlen/llama-cpp-python Go: go-skynet/go-llama.cpp Node.js: hlhr202/llama-node Ruby: yoshoku/llama_cpp.rb C#/.NET: SciSharp/LLamaSharp Scala 3: donderom/llm4s

用户界面：

nat/开放游乐场 nat/openplayground oobabooga/文本生成-webui

以下是使用 LLaMA-7B 的典型运行：

make -j && ./main -m ./models/7B/ggml-model-q4_0.bin -p "Building a website can be done in 10 simple steps:" -n 512
I llama.cpp build info:
I UNAME_S:  Darwin
I UNAME_P:  arm
I UNAME_M:  arm64
I CFLAGS:   -I.              -O3 -DNDEBUG -std=c11   -fPIC -pthread -DGGML_USE_ACCELERATE
I CXXFLAGS: -I. -I./examples -O3 -DNDEBUG -std=c++11 -fPIC -pthread
I LDFLAGS:   -framework Accelerate
I CC:       Apple clang version 14.0.0 (clang-1400.0.29.202)
I CXX:      Apple clang version 14.0.0 (clang-1400.0.29.202)

make: Nothing to be done for `default'.
main: seed = 1678486056
llama_model_load: loading model from './models/7B/ggml-model-q4_0.bin' - please wait ...
llama_model_load: n_vocab = 32000
llama_model_load: n_ctx   = 512
llama_model_load: n_embd  = 4096
llama_model_load: n_mult  = 256
llama_model_load: n_head  = 32
llama_model_load: n_layer = 32
llama_model_load: n_rot   = 128
llama_model_load: f16     = 2
llama_model_load: n_ff    = 11008
llama_model_load: ggml ctx size = 4529.34 MB
llama_model_load: memory_size =   512.00 MB, n_mem = 16384
llama_model_load: .................................... done
llama_model_load: model size =  4017.27 MB / num tensors = 291

main: prompt: 'Building a website can be done in 10 simple steps:'
main: number of tokens in prompt = 15
     1 -> ''
  8893 -> 'Build'
   292 -> 'ing'
   263 -> ' a'
  4700 -> ' website'
   508 -> ' can'
   367 -> ' be'
  2309 -> ' done'
   297 -> ' in'
 29871 -> ' '
 29896 -> '1'
 29900 -> '0'
  2560 -> ' simple'
  6576 -> ' steps'
 29901 -> ':'

sampling parameters: temp = 0.800000, top_k = 40, top_p = 0.950000


Building a website can be done in 10 simple steps:
1) Select a domain name and web hosting plan
2) Complete a sitemap
3) List your products
4) Write product descriptions
5) Create a user account
6) Build the template
7) Start building the website
8) Advertise the website
9) Provide email support
10) Submit the website to search engines
A website is a collection of web pages that are formatted with HTML. HTML is the code that defines what the website looks like and how it behaves.
The HTML code is formatted into a template or a format. Once this is done, it is displayed on the user's browser.
The web pages are stored in a web server. The web server is also called a host. When the website is accessed, it is retrieved from the server and displayed on the user's computer.
A website is known as a website when it is hosted. This means that it is displayed on a host. The host is usually a web server.
A website can be displayed on different browsers. The browsers are basically the software that renders the website on the user's screen.
A website can also be viewed on different devices such as desktops, tablets and smartphones.
Hence, to have a website displayed on a browser, the website must be hosted.
A domain name is an address of a website. It is the name of the website.
The website is known as a website when it is hosted. This means that it is displayed on a host. The host is usually a web server.
A website can be displayed on different browsers. The browsers are basically the software that renders the website on the user’s screen.
A website can also be viewed on different devices such as desktops, tablets and smartphones. Hence, to have a website displayed on a browser, the website must be hosted.
A domain name is an address of a website. It is the name of the website.
A website is an address of a website. It is a collection of web pages that are formatted with HTML. HTML is the code that defines what the website looks like and how it behaves.
The HTML code is formatted into a template or a format. Once this is done, it is displayed on the user’s browser.
A website is known as a website when it is hosted

main: mem per token = 14434244 bytes
main:     load time =  1332.48 ms
main:   sample time =  1081.40 ms
main:  predict time = 31378.77 ms / 61.41 ms per token
main:    total time = 34036.74 ms

这是在单台 M1 Pro MacBook 上运行 LLaMA-7B 和tweet.cpp的另一个演示：

耳语骆驼-lq.mp4

用法

以下是 LLaMA-7B 模型的步骤。

获取代码

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

建造

为了构建 llama.cpp，您有三种不同的选择。

使用make：

在 Linux 或 MacOS 上：

make

在 Windows 上：

下载w64devkit的最新 Fortran 版本。 w64devkit在您的电脑上提取。跑w64devkit.exe。使用cd命令访问该llama.cpp文件夹。从这里你可以运行：

make

使用CMake：

mkdir build
cd build
cmake ..
cmake --build . --config Release

使用Zig：

zig build -Doptimize=ReleaseFast

metal建造

使用 Metal 允许在 Apple 设备的 GPU 上执行计算：

使用make：

LLAMA_METAL=1 make

使用CMake：

mkdir build-metal
cd build-metal
cmake -DLLAMA_METAL=ON ..
cmake --build . --config Release

--gpu-layers|-ngl当使用 Metal 支持构建时，您可以使用命令行参数启用 GPU 推理。任何大于 0 的值都会将计算负载转移到 GPU。例如：

./main -m ./models/7B/ggml-model-q4_0.bin -n 128 -ngl 1

MPI 构建

MPI 允许您将计算分布到机器集群上。由于 LLM 预测的串行性质，这不会产生任何端到端加速，但它可以让您运行比单机 RAM 更大的模型。

首先，您需要在系统上安装 MPI 库。两个最流行（唯一？）的选项是MPICH和OpenMPI。两者都可以使用包管理器（apt、Homebrew、MacPorts 等）进行安装。

接下来，您需要LLAMA_MPI在所有机器上构建项目并将其设置为 true；如果您使用进行构建make，您还需要指定一个支持 MPI 的编译器（当使用 CMake 进行构建时，这是自动配置的）：

使用make：

make CC=mpicc CXX=mpicxx LLAMA_MPI=1

使用CMake：

cmake -S . -B build -DLLAMA_MPI=ON

程序构建完成后，下载/转换集群中所有机器上的权重。所有机器上权重和程序的路径应该相同。

接下来，确保从主主机对每台计算机进行无密码 SSH 访问，并创建一个hostfile包含主机名及其相对“权重”（插槽）的列表。如果要使用 localhost 进行计算，请使用其本地子网 IP 地址，而不是环回地址或“localhost”。

这是一个主机文件示例：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>192.168.0.1:2
malvolio.local:1
</code></span></span></span></span>

上面的代码会将计算分布到第一台主机上的 2 个进程和第二台主机上的 1 个进程。每个进程将使用大致相同数量的 RAM。尽量保持这些数字较小，因为进程间（主机内）通信的成本很高。

最后，您准备好使用以下命令运行计算mpirun：

mpirun -hostfile hostfile -n 3 ./main -m ./models/7B/ggml-model-q4_0.bin -n 128

BLAS构建

使用 BLAS 支持构建程序可能会导致使用大于 32 的批处理大小（默认值为 512）进行提示处理时的一些性能改进。BLAS不会影响正常的发电性能。目前它有三种不同的实现：

加速框架：

此功能仅适用于 Mac PC，并且默认启用。您可以使用正常的说明进行构建。

打开BLAS：

这仅使用 CPU 即可提供 BLAS 加速。确保您的计算机上安装了 OpenBLAS。

使用make：

在 Linux 上：

make LLAMA_OPENBLAS=1

在 Windows 上：

下载w64devkit的最新 Fortran 版本。

下载适用于 Windows 的最新版本的OpenBLAS。

w64devkit在您的电脑上提取。

从您刚刚下载的 OpenBLAS zip 副本中libopenblas.a，位于lib文件夹内的w64devkit\x86_64-w64-mingw32\lib.

include从同一个 OpenBLAS zip 复制其中文件夹的内容w64devkit\x86_64-w64-mingw32\include。

跑w64devkit.exe。

使用cd命令访问该llama.cpp文件夹。

从这里你可以运行：

make LLAMA_OPENBLAS=1

CMake在 Linux 上使用：

mkdir build
cd build
cmake .. -DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS
cmake --build . --config Release

BLIS

检查BLIS.md了解更多信息。

英特尔MKL

默认情况下，LLAMA_BLAS_VENDOR设置为Generic，因此如果您已经获取了 intel 环境脚本并-DLLAMA_BLAS=ON在 cmake 中进行了分配，则将自动选择 Blas 的 mkl 版本。您还可以通过以下方式指定：

mkdir build
cd build
cmake .. -DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=Intel10_64lp -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx
cmake --build . --config Release

CuBLAS库布拉斯

这使用 Nvidia GPU 的 CUDA 核心提供 BLAS 加速。确保已安装 CUDA 工具包。您可以从 Linux 发行版的包管理器或此处下载它：CUDA Toolkit。

使用make：

make LLAMA_CUBLAS=1

使用CMake：

mkdir build
cd build
cmake .. -DLLAMA_CUBLAS=ON
cmake --build . --config Release

环境变量CUDA_VISIBLE_DEVICES可用于指定将使用哪个 GPU。以下编译选项也可用于调整性能：

选项法律价值默认描述 LLAMA_CUDA_FORCE_DMMV 布尔值错误的强制使用反量化+矩阵向量乘法内核，而不是使用对量化数据进行矩阵向量乘法的内核。默认情况下，该决定是根据计算能力做出的（7.0/Turing/RTX 2000 或更高版本的 MMVQ）。不影响 k 量子。 LLAMA_CUDA_DMMV_X 正整数 >= 32 32 每次迭代由 CUDA 反量化 + 矩阵向量乘法内核处理的 x 方向值的数量。增加该值可以提高快速 GPU 的性能。强烈推荐2的幂。不影响 k 量子。 LLAMA_CUDA_MMV_Y 正整数 1 CUDA mul mat vec 内核在 y 方向上的块大小。增加该值可以提高快速 GPU 的性能。建议使用 2 的幂。不影响 k 量子。 LLAMA_CUDA_DMMV_F16 布尔值错误的如果启用，则对 CUDA 反量化 + mul mat vec 内核使用半精度浮点算法。可以提高相对较新的 GPU 的性能。 LLAMA_CUDA_KQUANTS_ITER 1 或 2 2 Q2_K 和 Q6_K 量化格式的每次迭代和每个 CUDA 线程处理的值的数量。将此值设置为 1 可以提高慢速 GPU 的性能。

CLB爆炸

OpenCL 加速由CLBlast项目的矩阵乘法内核和可在 GPU 上生成令牌的 ggml 自定义内核提供。

您将需要OpenCL SDK。

对于 Ubuntu 或 Debian，可能需要这些opencl-headers软件包ocl-icd。

从源代码安装 OpenCL SDK

安装 CLBlast：它可以在您的操作系统的软件包中找到。

如果没有，则从源安装：

建筑：

使用 make 构建：

make LLAMA_CLBLAST=1

CMake：

mkdir build
cd build
cmake .. -DLLAMA_CLBLAST=ON -DCLBlast_dir=/some/path
cmake --build . --config Release

跑步：

CLBlast 版本支持--gpu-layers|-ngl与 CUDA 版本一样的功能。

要选择正确的平台（驱动程序）和设备（GPU），您可以使用环境变量GGML_OPENCL_PLATFORM和GGML_OPENCL_DEVICE. 选择可以是数字（从 0 开始）或要搜索的文本字符串：

GGML_OPENCL_PLATFORM=1 ./main ...
GGML_OPENCL_DEVICE=2 ./main ...
GGML_OPENCL_PLATFORM=Intel ./main ...
GGML_OPENCL_PLATFORM=AMD GGML_OPENCL_DEVICE=1 ./main ...

默认行为是查找第一个 GPU 设备，但例如，当它是笔记本电脑上的集成 GPU 时，选择器就很有用。如果需要，还可以使用这些变量选择基于 CPU 的驱动程序。

clinfo -l您可以通过命令等获取平台和设备列表。

准备数据并运行

# obtain the original LLaMA model weights and place them in ./models
ls ./models
65B 30B 13B 7B tokenizer_checklist.chk tokenizer.model

# install Python dependencies
python3 -m pip install -r requirements.txt

# convert the 7B model to ggml FP16 format
python3 convert.py models/7B/

# quantize the model to 4-bits (using q4_0 method)
./quantize ./models/7B/ggml-model-f16.bin ./models/7B/ggml-model-q4_0.bin q4_0

# run the inference
./main -m ./models/7B/ggml-model-q4_0.bin -n 128

运行较大的模型时，请确保有足够的磁盘空间来存储所有中间文件。

内存/磁盘要求

由于模型当前已完全加载到内存中，因此您将需要足够的磁盘空间来保存它们，并需要足够的 RAM 来加载它们。目前，内存和磁盘要求是相同的。

模型原始尺寸量化大小（4 位） 7B 13GB 3.9GB 13B 24GB 7.8GB 30B 60GB 19.5GB 65B 120GB 38.5GB

量化

支持多种量化方法。它们的不同之处在于生成的模型磁盘大小和推理速度。

模型措施 F16 Q4_0 Q4_1 Q5_0 Q5_1 Q8_0 7B 困惑 5.9066 6.1565 6.0912 5.9862 5.9481 5.9070 7B 文件大小 13.0G 3.5G 3.9G 4.3G 4.7G 6.7G 7B ms/tok @ 4th 127 55 54 76 83 72 7B ms/tok @ 8th 122 43 45 52 56 67 7B 位数/重量 16.0 4.5 5.0 5.5 6.0 8.5 13B 困惑 5.2543 5.3860 5.3608 5.2856 5.2706 5.2548 13B 文件大小 25.0G 6.8G 7.6G 8.3G 9.1G 13G 13B ms/tok @ 4th - 103 105 148 160 131 13B ms/tok @ 8th - 73 82 98 105 128 13B 位数/重量 16.0 4.5 5.0 5.5 6.0 8.5

困惑度（衡量模型质量）

您可以使用该perplexity示例来测量给定提示的困惑度（困惑度越低越好）。有关更多信息，请参阅Perplexity of fixed-length models。

上表中的困惑度测量是针对wikitext2测试数据集 ( WikiText-2 Dataset | Papers With Code ) 进行的，上下文长度为 512。每个令牌的时间是在 MacBook M1 Pro 32GB RAM 上使用 4 和8 个线程。

交互模式

如果您想要更像 ChatGPT 的体验，可以通过传递-i参数以交互模式运行。在此模式下，您始终可以通过按 Ctrl+C 并输入一行或多行文本来中断生成，这些文本将被转换为标记并附加到当前上下文。您还可以使用参数指定反向提示-r "reverse prompt string"。这将导致每当在生成过程中遇到反向提示字符串的确切标记时就会提示用户输入。典型的用途是使用一个提示，让 LLaMa 模拟多个用户（例如 Alice 和 Bob）之间的聊天，并传递-r "Alice:"。

这是使用命令调用的几次交互的示例

# default arguments using a 7B model
./examples/chat.sh

# advanced chat with a 13B model
./examples/chat-13B.sh

# custom arguments using a 13B model
./main -m ./models/13B/ggml-model-q4_0.bin -n 256 --repeat_penalty 1.0 --color -i -r "User:" -f prompts/chat-with-bob.txt

请注意使用来--color区分用户输入和生成的文本。其他参数在示例程序的自述文件中有更详细的解释main。

持续互动

通过利用和，可以在调用之间保存和恢复提示、用户./main输入--prompt-cache和模型生成--prompt-cache-all。该./examples/chat-persistent.sh脚本通过对长时间运行、可恢复的聊天会话的支持来演示这一点。要使用此示例，您必须提供一个文件来缓存初始聊天提示和一个目录来保存聊天会话，并且可以选择提供与chat-13B.sh. 新的聊天会话可以重复使用相同的提示缓存。请注意，提示缓存和聊天目录都与初始提示 ( PROMPT_TEMPLATE) 和模型文件相关联。

# Start a new chat
PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh

# Resume that chat
PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh

# Start a different chat with the same prompt/model
PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh

# Different prompt cache for different prompt/model
PROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob.prompt.bin \
    CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh

羊驼教学模式

首先将羊驼模型下载到文件夹ggml中./models main像这样运行该工具：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>./examples/alpaca.sh
</code></span></span></span></span>

示例运行：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>== Running in interactive mode. ==
 - Press Ctrl+C to interject at any time.
 - Press Return to return control to LLaMa.
 - If you want to submit another line, end your input in '\'.

 Below is an instruction that describes a task. Write a response that appropriately completes the request.

> How many letters are there in the English alphabet?
There 26 letters in the English Alphabet
> What is the most common way of transportation in Amsterdam?
The majority (54%) are using public transit. This includes buses, trams and metros with over 100 lines throughout the city which make it very accessible for tourists to navigate around town as well as locals who commute by tram or metro on a daily basis
> List 5 words that start with "ca".
cadaver, cauliflower, cabbage (vegetable), catalpa (tree) and Cailleach.
>
</code></span></span></span></span>

使用OpenLLaMA

OpenLLaMA 是 Meta 原始 LLaMA 模型的公开许可复制品。它使用相同的架构，并且是原始 LLaMA 权重的直接替代品。

从 Hugging Face下载3B、7B或13B模型。使用以下命令将模型转换为 ggml FP16 格式python convert.py <path to OpenLLaMA directory>

使用GPT4All

从LLaMA模型中获取tokenizer.model文件并将其放入models 从羊驼模型中获取added_tokens.json文件并将其放入models 从GPT4All模型中获取gpt4all-lora-quantized.bin文件并将其放入models/gpt4all-7B ggml它以现已废弃的旧格式分发您必须使用以下命令将其转换为新格式convert.py：

python3 convert.py models/gpt4all-7B/gpt4all-lora-quantized.bin

您现在可以models/gpt4all-7B/ggml-model-q4_0.bin像使用所有其他模型一样使用新生成的模型

尚不支持较新的 GPT4All-J 型号！

使用皮格马利翁 7B 和 Metharme 7B

获取LLaMA 权重获取Pygmalion 7B或Metharme 7B XOR 编码权重使用最新的 HF 转换脚本转换 LLaMA 模型通过运行xor_codec脚本将 XOR 文件与转换后的 LLaMA 权重合并使用此存储库中的脚本转换为ggml格式convert.py：

python3 convert.py pygmalion-7b/ --outtype q4_1

Pygmalion 7B 和 Metharme 7B 权重以bfloat16精度保存。如果您希望转换为ggml而不进行量化，请指定--outtypeasf32而不是f16。

获取Facebook LLaMA原始模型和Stanford Alpaca模型数据

在任何情况下，IPFS、磁力链接或任何其他模型下载链接都不应在此存储库中的任何位置共享，包括在问题、讨论或拉取请求中。它们将被立即删除。 LLaMA 模型由 Facebook 正式分发，永远不会通过此存储库提供。如果您需要请求访问模型数据，请参阅Facebook 的 LLaMA 存储库。

验证模型文件

在创建与模型文件相关的问题之前，请验证所有下载的模型文件的sha256 校验和，以确认您拥有正确的模型数据文件。

以下 python 脚本将验证您的自安装./models子目录中是否具有所有可能的最新文件：

# run the verification script
python3 .\scripts\verify-checksum-models.py

在 Linux 或 macOS 上，还可以运行以下命令来验证您的自安装./models子目录中是否拥有所有可能的最新文件：在 Linux 上：sha256sum --ignore-missing -c SHA256SUMS 在 macOS 上：shasum -a 256 --ignore-missing -c SHA256SUMS

开创性论文和模型背景

如果您的问题在于模型生成质量，那么请至少扫描以下链接和论文以了解 LLaMA 模型的局限性。当选择合适的模型大小并了解 LLaMA 模型和 ChatGPT 之间的显着和细微差异时，这一点尤其重要：

骆驼： LLaMA 简介：一个具有 650 亿参数的基础大型语言模型 LLaMA：开放高效的基础语言模型 GPT-3 语言模型是小样本学习者 GPT-3.5 / InstructGPT / ChatGPT：调整语言模型以遵循指令训练语言模型遵循人类反馈的指令

如何跑

下载/解压：https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-2-raw-v1.zip ?ref=salesforce-research 跑步./perplexity -m models/7B/ggml-model-q4_0.bin -f wiki.test.raw 输出：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>perplexity : calculating perplexity over 655 chunks
24.43 seconds per pass - ETA 4.45 hours
[1]4.5970,[2]5.1807,[3]6.0382,...
</code></span></span></span></span>

4.45小时后，你将面临最后的困惑。

安卓

使用 Android NDK 构建项目

您可以使用termuxllama.cpp轻松在 Android 设备上运行。

首先，安装 termux 的必需软件包：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>pkg install clang wget git cmake
</code></span></span></span></span>

其次，获取Android NDK，然后使用 CMake 进行构建：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>$ mkdir build-android
$ cd build-android
$ export NDK=<your_ndk_directory>
$ cmake -DCMAKE_TOOLCHAIN_FILE=$NDK/build/cmake/android.toolchain.cmake -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-23 -DCMAKE_C_FLAGS=-march=armv8.4a+dotprod ..
$ make
</code></span></span></span></span>

在您的设备上安装termux并运行termux-setup-storage以访问您的 SD 卡。最后，将llama二进制文件和模型文件复制到您的设备存储中。以下是在 Pixel 5 手机上运行的交互式会话的演示：

骆驼互动2.mp4

使用 Termux (F-Droid) 构建项目

F-Droid 的 Termux 提供了在 Android 设备上执行项目的替代途径。这种方法使您能够直接在终端内构建项目，无需 root 设备或 SD 卡。

下面概述了使用 OpenBLAS 和 CLBlast 安装项目的指令。这种组合专为在配备 GPU 的最新设备上提供最佳性能而设计。

如果您选择使用 OpenBLAS，则需要安装相应的软件包。

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>apt install libopenblas
</code></span></span></span></span>

随后，如果您决定合并 CLBlast，您首先需要安装必需的 OpenCL 软件包：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>apt install ocl-icd opencl-headers opencl-clhpp clinfo
</code></span></span></span></span>

为了编译 CLBlast，您需要首先克隆相应的 Git 存储库，可以在以下 URL 中找到该存储库： https: //github.com/CNugteren/CLBlast。除此之外，将此存储库克隆到您的主目录中。完成此操作后，导航到 CLBlast 文件夹并执行下面详述的命令：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>cmake .
make
cp libclblast.so* $PREFIX/lib
cp ./include/clblast.h ../llama.cpp
</code></span></span></span></span>

按照前面的步骤操作，导航到 LlamaCpp 目录。要使用 OpenBLAS 和 CLBlast 对其进行编译，请执行以下命令：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>cp /data/data/com.termux/files/usr/include/openblas/cblas.h .
cp /data/data/com.termux/files/usr/include/openblas/openblas_config.h .
make LLAMA_CLBLAST=1 //(sometimes you need to run this command twice)
</code></span></span></span></span>

完成上述步骤后，您将成功编译该项目。要使用 CLBlast 运行它，需要进行一些细微的调整：必须发出一条命令来将操作定向到设备的物理 GPU，而不是虚拟 GPU。必要的命令详述如下：

<span style="color:#1f2328"><span style="background-color:#ffffff"><span style="color:var(--fgColor-default, var(--color-fg-default))"><span style="background-color:var(--bgColor-muted, var(--color-canvas-subtle))"><code>GGML_OPENCL_PLATFORM=0
GGML_OPENCL_DEVICE=0
export LD_LIBRARY_PATH=/vendor/lib64:$LD_LIBRARY_PATH
</code></span></span></span></span>

（注意：某些 Android 设备，如 Zenfone 8，需要以下命令 - “export LD_LIBRARY_PATH=/system/vendor/lib64:$LD_LIBRARY_PATH”。来源：https: //www.reddit.com/r/termux/comments /kc3ynp/opencl_working_in_termux_more_in_comments/）

为了轻松快速地重新执行，请考虑将最后一部分记录在 .sh 脚本文件中。这将使您能够以最小的麻烦重新运行该过程。

将所需的模型放入~/llama.cpp/models/目录中并执行./main (...)脚本。

码头工人

先决条件

Docker 必须在您的系统上安装并运行。创建一个文件夹来存储大模型和中间文件（例如/llama/models）

图片

我们有两个可用于该项目的 Docker 镜像：

ghcr.io/ggerganov/llama.cpp:full：该映像包括主可执行文件和将 LLaMA 模型转换为 ggml 并转换为 4 位量化的工具。 ghcr.io/ggerganov/llama.cpp:light：该映像仅包含主可执行文件。

用法

下载模型、将其转换为 ggml 并优化它们的最简单方法是使用 --all-in-one 命令，其中包含完整的 docker 映像。

将下面的内容替换/path/to/models为您下载模型的实际路径。

docker run -v /path/to/models:/models ghcr.io/ggerganov/llama.cpp:full --all-in-one "/models/" 7B

完成后，您就可以开始玩了！

docker run -v /path/to/models:/models ghcr.io/ggerganov/llama.cpp:full --run -m /models/7B/ggml-model-q4_0.bin -p "Building a website can be done in 10 simple steps:" -n 512

或使用浅色图像：

docker run -v /path/to/models:/models ghcr.io/ggerganov/llama.cpp:light -m /models/7B/ggml-model-q4_0.bin -p "Building a website can be done in 10 simple steps:" -n 512

Docker 与 CUDA

假设在 Linux 上正确安装了nvidia-container-toolkit，或者正在使用支持 GPU 的云，则cuBLAS应该可以在容器内访问。

本地建设

docker build -t local/llama.cpp:full-cuda -f .devops/full-cuda.Dockerfile .
docker build -t local/llama.cpp:light-cuda -f .devops/main-cuda.Dockerfile .

您可能需要传入一些不同的ARGS，具体取决于容器主机支持的 CUDA 环境以及 GPU 架构。

默认值是：

CUDA_VERSION设置11.7.1 CUDA_DOCKER_ARCH设置all

生成的图像与非 CUDA 图像基本相同：

local/llama.cpp:full-cuda：该映像包括主可执行文件和将 LLaMA 模型转换为 ggml 并转换为 4 位量化的工具。 local/llama.cpp:light-cuda：该映像仅包含主可执行文件。

用法

本地构建后，用法与非 CUDA 示例类似，但您需要添加该--gpus标志。您还需要使用该--n-gpu-layers标志。

docker run --gpus all -v /path/to/models:/models local/llama.cpp:full-cuda --run -m /models/7B/ggml-model-q4_0.bin -p "Building a website can be done in 10 simple steps:" -n 512 --n-gpu-layers 1
docker run --gpus all -v /path/to/models:/models local/llama.cpp:light-cuda -m /models/7B/ggml-model-q4_0.bin -p "Building a website can be done in 10 simple steps:" -n 512 --n-gpu-layers 1

贡献

贡献者可以打开 PR 协作者可以推送到llama.cpp存储库中的分支并将 PR 合并到master分支中将根据贡献邀请合作者非常感谢任何有关管理问题和 PR 的帮助！请务必阅读以下内容：边缘推理为那些感兴趣的人提供一些背景故事：Changelog podcast

编码指南

避免添加第三方依赖项、额外文件、额外标头等。始终考虑与其他操作系统和架构的交叉兼容性避免花哨的现代 STL 结构，使用基本for循环，避免模板，保持简单代码风格没有严格的规则，但尽量遵循代码中的模式（缩进、空格等）。垂直对齐使内容更具可读性并且更易于批量编辑清理所有尾随空格，使用 4 个空格进行缩进，同一行使用括号void * ptr，,int & a 请参阅良好的第一期，了解适合首次贡献的任务

文档

主要的服务器嵌入输入危险 BLIS