大模型应用

llama.cpp

作者头像
项目作者ggerganov

LLM inference in C/C++

llama.cpp 预览图

llama.cpp 介绍

了解项目的详细信息和使用方法

描述

llama.cpp 的主要目标是通过最少的设置和最先进的性能在各种硬件上(本地和云端)进行大语言模型(LLM)推理。

  • 纯 C/C++ 实现,无任何依赖
  • Apple Silicon 是一等公民 - 通过 ARM NEON,Accelerate 和 Metal 框架优化
  • 支持 x86 架构的 AVX、AVX2 和 AVX512
  • 支持 1.5 位、2 位、3 位、4 位、5 位、6 位和 8 位整数量化,以加速推理并减少内存使用
  • 为 NVIDIA GPU 运行 LLMs 的自定义 CUDA 内核(通过 HIP 支持 AMD GPU)
  • 支持 Vulkan、SYCL 和(部分)OpenCL 后端
  • CPU+GPU 混合推理以部分加速大于总 VRAM 容量的模型

初始 以来,该项目得到了显著改进,感谢众多贡献者。这是为 ggml 库开发新功能的主要试验场。

支持的平台:

  • Mac OS
  • Linux
  • Windows(通过 CMake)
  • Docker
  • FreeBSD

支持的模型:

通常也支持以下基础模型的微调版。

(支持更多模型的说明:HOWTO-add-model.md

多模态模型:

HTTP服务器

llama.cpp web server 是一个轻量级的 OpenAI API 兼容 HTTP 服务器,可以用于本地模型并轻松连接到现有客户端。

绑定:

ama.rn)

用户界面:

除非另有说明,这些项目均为开源且许可证宽松:

(要在此处列出项目,需明确声明其依赖于 llama.cpp)


以下是在 M2 Ultra 上使用 LLaMA v2 13B 的典型运行:

bash
1$ make -j && ./main -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 2I llama.cpp build info: 3I UNAME_S: Darwin 4I UNAME_P: arm 5I UNAME_M: arm64 6I 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 7I 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 8I LDFLAGS: -framework Accelerate 9I CC: Apple clang version 14.0.3 (clang-1403.0.22.14.1) 10I CXX: Apple clang version 14.0.3 (clang-1403.0.22.14.1) 11 12make: Nothing to be done for `default'. 13main: build = 1041 (cf658ad) 14main: seed = 1692823051 15llama_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)) 16llama_model_loader: - type f32: 81 tensors 17llama_model_loader: - type q4_0: 281 tensors 18llama_model_loader: - type q6_K: 1 tensors 19llm_load_print_meta: format = GGUF V1 (latest) 20llm_load_print_meta: arch = llama 21llm_load_print_meta: vocab type = SPM 22llm_load_print_meta: n_vocab = 32000 23llm_load_print_meta: n_merges = 0 24llm_load_print_meta: n_ctx_train = 4096 25llm_load_print_meta: n_ctx = 512 26llm_load_print_meta: n_embd = 5120 27llm_load_print_meta: n_head = 40 28llm_load_print_meta: n_head_kv = 40 29llm_load_print_meta: n_layer = 40 30llm_load_print_meta: n_rot = 128 31llm_load_print_meta: n_gqa = 1 32llm_load_print_meta: f_norm_eps = 1.0e-05 33llm_load_print_meta: f_norm_rms_eps = 1.0e-05 34llm_load_print_meta: n_ff = 13824 35llm_load_print_meta: freq_base = 10000.0 36llm_load_print_meta: freq_scale = 1 37llm_load_print_meta: model type = 13B 38llm_load_print_meta: model ftype = mostly Q4_0 39llm_load_print_meta: model size = 13.02 B 40llm_load_print_meta: general.name = LLaMA v2 41llm_load_print_meta: BOS token = 1 '<s>' 42llm_load_print_meta: EOS token = 2 '</s>' 43llm_load_print_meta: UNK token = 0 '<unk>' 44llm_load_print_meta: LF token = 13 '<0x0A>' 45llm_load_tensors: ggml ctx size = 0.11 MB 46llm_load_tensors: mem required = 7024.01 MB (+ 400.00 MB per state) 47................................................................................................... 48llama_new_context_with_model: kv self size = 400.00 MB 49llama_new_context_with_model: compute buffer total size = 75.41 MB 50 51system_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 | 52sampling: 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 53generate: n_ctx = 512, n_batch = 512, n_predict = 400, n_keep = 0 54 55 Building a website can be done in 10 simple steps: 56Step 1: Find the right website platform. 57Step 2: Choose your domain name and hosting plan. 58Step 3: Design your website layout. 59Step 4: Write your website content and add images. 60Step 5: Install security features to protect your site from hackers or spammers 61Step 6: Test your website on multiple browsers, mobile devices, operating 62 63 systems etc… 64Step 7: Test it again with people who are not related to you personally – friends or family members will work just fine! 65Step 8: Start marketing and promoting the website via social media channels or paid ads 66Step 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… 67Step 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! 68How does a Website Work? 69A 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! 70The 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. 71How to 72llama_print_timings: load time = 576.45 ms 73llama_print_timings: sample time = 283.10 ms / 400 runs ( 0.71 ms per token, 1412.91 tokens per second) 74llama_print_timings: prompt eval time = 599.83 ms / 19 tokens ( 31.57 ms per token, 31.68 tokens per second) 75llama_print_timings: eval time = 24513.59 ms / 399 runs ( 61.44 ms per token, 16.28 tokens per second) 76llama_print_timings: total time = 25431.49 ms

以下是在 M1 Pro MacBook 上同时运行 LLaMA-7B 和 whisper.cpp 的另一个演示:

https://user-images.githubusercontent.com/1991296/224442907-7693d4be-acaa-4e01-8b4f-add84093ffff.mp4

用法

以下是大多数支持模型的端到端二进制构建和模型转换步骤。

获取代码

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

构建

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

  • 使用 make

    • 在 Linux 或 MacOS 上:

      bash
      1make

      注意:对于 Debug 构建,运行 make LLAMA_DEBUG=1

    • 在 Windows 上:

      1. 下载最新的 w64devkit 的 Fortran 版本。
      2. 在您的 PC 上解压 w64devkit
      3. 运行 w64devkit.exe
      4. 使用 cd 命令到达 llama.cpp 文件夹。
      5. 从这里您可以运行:
        bash
        1make
  • 使用 CMake

    bash
    1cmake -B build 2cmake --build build --config Release

    注意:对于 Debug 构建,有两种情况:

    • 单配置生成器(例如默认的 = Unix Makefiles; 请注意它们只忽略 --config 标志):

      bash
      1cmake -B build -DCMAKE_BUILD_TYPE=Debug 2cmake --build build
    • 多配置生成器(-G 参数设置为 Visual Studio,XCode...):

      bash
      1cmake -B build -G "Xcode" 2cmake --build build --config Debug
  • 使用 Zig(版本 0.11 或更高版本):

    使用标准构建参数可以实现优化级别和 CPU 特性的构建,例如 AVX2、FMA、F16C,还可以交叉编译到其他操作系统和架构:

    bash
    1zig build -Doptimize=ReleaseFast -Dtarget=x86_64-windows-gnu -Dcpu=x86_64+avx2+fma+f16c

    zig targets 命令将为您提供有效的选项。

  • 使用 gmake(FreeBSD):

    1. 安装并激活 FreeBSD 中的 DRM

    2. 将您的用户添加到 video

    3. 安装编译依赖项。

      bash
      1sudo pkg install gmake automake autoconf pkgconf llvm15 clinfo clover \ 2 opencl clblast openblas 3 4gmake CC=/usr/local/bin/clang15 CXX=/usr/local/bin/clang++15 -j4

    注意:使用这些软件包,您可以在 FreeBSD 上构建支持 OPENBLAS 和 CLBLAST 的 llama.cpp。请阅读下面的文档以了解如何使用并激活这些选项。

Metal 构建

在 MacOS 上,默认启用 Metal。使用 Metal 使计算在 GPU 上运行。 在编译时使用 LLAMA_NO_METAL=1 标志或 LLAMA_METAL=OFF cmake 选项可以禁用 Metal 构建。

当使用 Metal 支持构建时,您可以使用 --n-gpu-layers|-ngl 0 命令行参数显式禁用 GPU 推理。

BLAS 构建

使用 BLAS 支持构建程序可能会在使用大于 32(默认 512)的批处理大小时在提示处理方面带来一些性能提升。仅使用 CPU 的 BLAS 实现不影响正常的生成性能。我们可能会在涉及 GPU 的 BLAS 实现(例如 cuBLAS、hipBLAS 和 CLBlast)中看到生成性能提升。目前有几种不同的 BLAS 实现可用于构建和使用:

  • Accelerate 框架:

    仅在 Mac 电脑上可用,默认启用。您可以按照正常的构建说明进行构建。

  • OpenBLAS:

    仅使用 CPU 提供 BLAS 加速。确保您的机器上已安装 OpenBLAS。

    • 使用 make

      • 在 Linux 上:

        bash
        1make LLAMA_OPENBLAS=1
      • 在 Windows 上:

        1. 下载最新的 w64devkit 的 Fortran 版本。

        2. 下载最新版本的 Windows 版 OpenBLAS

        3. 在您的 PC 上解压 w64devkit

        4. 从刚刚下载的 OpenBLAS zip 中,将位于 lib 文件夹内的 libopenblas.a 复制到 w64devkit\x86_64-w64-mingw32\lib 内。

        5. 从相同的 OpenBLAS zip 中,将 include 文件夹的内容复制到 w64devkit\x86_64-w64-mingw32\include 内。

        6. 运行 w64devkit.exe

        7. 使用 cd 命令到达 llama.cpp 文件夹。

        8. 从这里您可以运行:

          bash
          1make LLAMA_OPENBLAS=1
    • 在 Linux 上使用 CMake

      bash
      1cmake -B build -DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=OpenBLAS 2cmake --build build --config Release
  • BLIS

    详情请参阅 BLIS.md

  • SYCL

    SYCL 是一种更高级的编程模型,用于提高在各种硬件加速器上的编程生产力。

    基于 SYCL 的 llama.cpp 用于支持 Intel GPU(数据中心 Max 系列、Flex 系列、Arc 系列、内置 GPU 和 iGPU)。

    详细信息请参阅 llama.cpp for SYCL

  • Intel oneMKL

    通过 oneAPI 编译器进行构建将使 avx_vnni 指令集在不支持 avx512 和 avx512_vnni 的 Intel 处理器上可用。请注意,此构建配置 不支持 Intel GPU。有关 Intel GPU 支持,请参阅 llama.cpp for SYCL

    • 使用手动 oneAPI 安装: 默认情况下,LLAMA_BLAS_VENDOR 设置为 Generic,因此如果您已经获取 Intel 环境脚本并在 cmake 中分配 -DLLAMA_BLAS=ON,则会自动选择 Blas 的 mkl 版本。否则,请安装 oneAPI 并按以下步骤操作:

      bash
      1source /opt/intel/oneapi/setvars.sh # 如果在 oneapi-basekit docker 镜像中,可以跳过此步骤,仅在手动安装时需要 2cmake -B build -DLLAMA_BLAS=ON -DLLAMA_BLAS_VENDOR=Intel10_64lp -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DLLAMA_NATIVE=ON 3cmake --build build --config Release
    • 使用 oneAPI docker 镜像: 如果您不想手动获取环境变量并安装 oneAPI,还可以使用 Intel docker 容器进行构建:oneAPI-basekit。然后,可以使用上述命令。

    有关更多信息,请参阅 优化和运行 LLaMA2 在 Intel® CPU 上

  • CUDA

    这通过您的 Nvidia GPU 的 CUDA 核心提供 GPU 加速。确保已安装 CUDA 工具包。可以从您的 Linux 发行版的包管理器下载(例如 apt install nvidia-cuda-toolkit)或从此处下载:CUDA 工具包

    对于 Jetson 用户,如果您有 Jetson Orin,可以尝试此:官方支持。如果您使用的是旧型号(nano/TX2),则需要在编译前进行一些额外操作。

    • 使用 make

      bash
      1make LLAMA_CUDA=1
    • 使用 CMake

      bash
      1cmake -B build -DLLAMA_CUDA=ON 2cmake --build build --config Release

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

选项合法值默认值描述
LLAMA_CUDA_FORCE_DMMV布尔值false强制使用反量化 + 矩阵向量乘法内核,而不是使用在量化数据上进行矩阵向量乘法的内核。默认情况下,决定是基于计算能力的(MMVQ 用于 6.1/Pascal/GTX 1000 或更高)。不影响 k-quants。
LLAMA_CUDA_DMMV_X正整数 >= 3232CUDA 反量化 + 矩阵向量乘法内核每次迭代处理的 x 方向的值数量。增加此值可以提高快速 GPU 上的性能。强烈建议使用 2 的幂。不影响 k-quants。
LLAMA_CUDA_MMV_Y正整数1CUDA 矩阵向量乘法内核在 y 方向的块大小。增加此值可以提高快速 GPU 上的性能。推荐使用 2 的幂。
LLAMA_CUDA_F16布尔值false如果启用,对 CUDA 反量化 + 矩阵向量乘法内核和 q4_1 和 q5_1 矩阵矩阵乘法内核使用半精度浮点运算。可以提高相对较新 GPU 上的性能。
LLAMA_CUDA_KQUANTS_ITER1 或 22Q2_K 和 Q6_K 量化格式每次迭代和每个 CUDA 线程处理的值数量。将此值设置为 1 可以提高慢速 GPU 上的性能。
LLAMA_CUDA_PEER_MAX_BATCH_SIZE正整数128启用多个 GPU 之间对等访问的最大批处理大小。对等访问需要 Linux 或 NVLink。当使用 NVLink 时,为较大的批处理大小启用对等访问可能有利。
  • hipBLAS

    这在 HIP 支持的 AMD GPU 上提供 BLAS 加速。 确保已安装 ROCm。 您可以从您的 Linux 发行版的包管理器下载,也可以从此处下载:ROCm 快速入门(Linux)

    • 使用 make

      bash
      1make LLAMA_HIPBLAS=1
    • 在 Linux 上使用 CMake(假设兼容 gfx1030 的 AMD GPU):

      bash
      1HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -R)" \ 2 cmake -S . -B build -DLLAMA_HIPBLAS=ON -DAMDGPU_TARGETS=gfx1030 -DCMAKE_BUILD_TYPE=Release \ 3 && cmake --build build --config Release -- -j 16

      在 Linux 上,还可以通过设置 -DLLAMA_HIP_UMA=ON 使用统一内存架构(UMA)在 CPU 和集成 GPU 之间共享主内存。 但是,这会降低非集成 GPU 的性能(但可以启用与集成 GPU 的协作)。

      请注意,如果出现以下错误:

      clang: error: cannot find ROCm device library; provide its path via '--rocm-path' or '--rocm-device-lib-path', or pass '-nogpulib' to build without ROCm device library
      

      尝试在 HIP_PATH 下搜索包含 oclc_abi_version_400.bc 文件的目录。然后,将以下内容添加到命令的开头:HIP_DEVICE_LIB_PATH=<directory-you-just-found>,如下所示:

      bash
      1HIPCXX="$(hipconfig -l)/clang" HIP_PATH="$(hipconfig -p)" \ 2HIP_DEVICE_LIB_PATH=<directory-you-just-found> \ 3 cmake -S . -B build -DLLAMA_HIPBLAS=ON -DAMDGPU_TARGETS=gfx1030 -DCMAKE_BUILD_TYPE=Release \ 4 && cmake --build build -- -j 16
    • 使用 make(以 gfx1030 为目标,使用 16 个 CPU 线程进行构建):

      bash
      1make -j16 LLAMA_HIPBLAS=1 LLAMA_HIP_UMA=1 AMDGPU_TARGETS=gfx1030
    • 在 Windows 上使用 CMake(使用 x64 Native Tools Command Prompt for VS,假设兼容 gfx1100 的 AMD GPU):

      bash
      1set PATH=%HIP_PATH%\bin;%PATH% 2cmake -S . -B build -G Ninja -DAMDGPU_TARGETS=gfx1100 -DLLAMA_HIPBLAS=ON -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++ -DCMAKE_BUILD_TYPE=Release 3cmake --build build

      确保 AMDGPU_TARGETS 设置为要编译的 GPU 架构。上述示例使用 gfx1100,对应于 Radeon RX 7900XTX/XT/GRE。您可以在此处找到目标列表:这里 通过将 rocminfo | grep gfx | head -1 | awk '{print $2}' 命令输出的最重要版本信息与处理器列表匹配,可以找到您的 GPU 版本字符串,例如 gfx1035 映射到 gfx1030

    可以使用环境变量 HIP_VISIBLE_DEVICES 指定将使用哪个 GPU。如果您的 GPU 未正式支持,您可以使用环境变量 [HSA_OVERRIDE_GFX_VERSION] 将其设置为类似的 GPU,例如 RDNA2(例如 gfx1030、gfx1031 或 gfx1035)上的 10.3.0 或 RDNA3 上的 11.0.0。 还可以使用以下编译选项调整性能(是的,它们引用 CUDA,而不是 HIP,因为它使用与上述 cuBLAS 版本相同的代码):

| 选项 | 合法值 | 默认值 | 描述 | | ----------------------- | --------- | --- | -------------------------------------------------------------------------------- | --- | | LLAMA_CUDA_DMMV_X | 正整数 >= 32 | 32 | HIP 反量化 + 矩阵向量乘法内核每次迭代处理的 x 方向的值数量。增加此值可以提高快速 GPU 上的性能。强烈建议使用 2 的幂。不影响 k-quants。 |
| LLAMA_CUDA_MMV_Y | 正整数 | 1 | HIP 矩阵向量乘法内核在 y 方向的块大小。增加此值可以提高快速 GPU 上的性能。推荐使用 2 的幂。不影响 k-quants。 |
| LLAMA_CUDA_KQUANTS_ITER | 1 或 2 | 2 | Q2_K 和 Q6_K 量化格式每次迭代和每个 HIP 线程处理的值数量。将此值设置为 1 可以提高慢速 GPU 上的性能。 |

  • CLBlast

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

    您需要 OpenCL SDK

    • 对于 Ubuntu、Debian 和 Fedora 可能需要 opencl-headersocl-icd 软件包。

    • 对于 Windows,可以在 OpenCL Releases 页面上找到预构建的 SDK。

    • 从源代码安装 OpenCL SDK

      sh
      1git clone --recurse-submodules https://github.com/KhronosGroup/OpenCL-SDK.git 2cd OpenCL-SDK 3cmake -B build -DBUILD_DOCS=OFF \ 4 -DBUILD_EXAMPLES=OFF \ 5 -DBUILD_TESTING=OFF \ 6 -DOPENCL_SDK_BUILD_SAMPLES=OFF \ 7 -DOPENCL_SDK_TEST_SAMPLES=OFF 8cmake --build build 9cmake --install build --prefix /some/path
安装 CLBlast

可以在 CLBlast Releases 页面上找到预构建的 CLBlast 二进制文件。对于 Unix 变体,可能也可以在您的操作系统的软件包中找到。

Linux 包装: Fedora Linux:

bash
1sudo dnf install clblast

或者,您可以从源代码构建。

Window源码安装:

cmd
1set OPENCL_SDK_ROOT="C:/OpenCL-SDK-v2023.04.17-Win-x64" 2git clone https://github.com/CNugteren/CLBlast.git 3cd CLBlast 4cmake -B build -DBUILD_SHARED_LIBS=OFF -DOVERRIDE_MSVC_FLAGS_TO_MT=OFF -DTUNERS=OFF -DOPENCL_ROOT=%OPENCL_SDK_ROOT% -G "Visual Studio 17 2022" -A x64 5cmake --build build --config Release 6cmake --install build --prefix C:/CLBlast

(注意:--config Release 在构建时是默认值,仅在 Visual Studio 构建或多配置 Ninja 构建时相关)

Linux源码安装:

sh
1git clone https://github.com/CNugteren/CLBlast.git 2cd CLBlast 3cmake -B build -DBUILD_SHARED_LIBS=OFF -DTUNERS=OFF 4cmake --build build --config Release 5cmake --install build --prefix /some/path

其中 /some/path 是将安装构建库的位置(默认是 /usr/local)。

使用 CLBlast 构建 Llama
  • 使用 make 构建:
    sh
    1make LLAMA_CLBLAST=1
  • CMake(Unix):
    sh
    1cmake -B build -DLLAMA_CLBLAST=ON -DCLBlast_DIR=/some/path 2cmake --build build --config Release
  • CMake(Windows):
    cmd
    1set CL_BLAST_CMAKE_PKG="C:/CLBlast/lib/cmake/CLBlast" 2git clone https://github.com/ggerganov/llama.cpp 3cd llama.cpp 4cmake -B build -DBUILD_SHARED_LIBS=OFF -DLLAMA_CLBLAST=ON -DCMAKE_PREFIX_PATH=%CL_BLAST_CMAKE_PKG% -G "Visual Studio 17 2022" -A x64 5cmake --build build --config Release 6cmake --install build --prefix C:/LlamaCPP
使用 CLBlast 运行 Llama

CLBlast 构建支持与 CUDA 版本相同的 --gpu-layers|-ngl

要选择正确的平台(驱动程序)和设备(GPU),可以使用环境变量 GGML_OPENCL_PLATFORMGGML_OPENCL_DEVICE。 选择可以是数字(从 0 开始)或要搜索的文本字符串:

sh
1GGML_OPENCL_PLATFORM=1 ./main ... 2GGML_OPENCL_DEVICE=2 ./main ... 3GGML_OPENCL_PLATFORM=Intel ./main ... 4GGML_OPENCL_PLATFORM=AMD GGML_OPENCL_DEVICE=1 ./main ...

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

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

  • Vulkan

    使用 docker

    您不需要安装 Vulkan SDK。它将在容器内安装。

    sh
    1# 构建镜像 2docker build -t llama-cpp-vulkan -f .devops/main-vulkan.Dockerfile . 3 4# 然后,使用它: 5docker run -it --rm -v "$(pwd):/app:Z" --device /dev/dri/renderD128:/dev/dri/renderD128 --device /dev/dri/card1:/dev/dri/card1 llama-cpp-vulkan -m "/app/models/YOUR_MODEL_FILE" -p "Building a website can be done in 10 simple steps:" -n 400 -e -ngl 33

    不使用 docker

    首先,您需要确保已安装 Vulkan SDK

    例如,在 Ubuntu 22.04(jammy)上,使用以下命令:

    bash
    1wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | apt-key add - 2wget -qO /etc/apt/sources.list.d/lunarg-vulkan-jammy.list https://packages.lunarg.com/vulkan/lunarg-vulkan-jammy.list 3apt update -y 4apt-get install -y vulkan-sdk 5# 要验证安装,请使用以下命令: 6vulkaninfo

    或者,您的包管理器可能能够提供适当的库。例如,对于 Ubuntu 22.04,您可以安装 libvulkan-dev

    然后,使用以下 cmake 命令构建 llama.cpp:

    bash
    1cmake -B build -DLLAMA_VULKAN=1 2cmake --build build --config Release 3# 测试输出二进制文件(使用 "-ngl 33" 将所有层卸载到 GPU) 4./bin/main -m "PATH_TO_MODEL" -p "Hi you how are you" -n 50 -e -ngl 33 -t 4 5 6# 您应该在输出中看到,ggml_vulkan 检测到了您的 GPU。例如: 7# ggml_vulkan: Using Intel(R) Graphics (ADL GT2) | uma: 1 | fp16: 1 | warp size: 32

准备和量化

[!注意] 您也可以使用 Hugging Face 上的 GGUF-my-repo 空间在无需设置的情况下量化您的模型权重。它每 6 小时从 llama.cpp 主分支同步一次。

要获取官方的 LLaMA 2 权重,请参阅 获取和使用 Facebook LLaMA 2 模型 部分。Hugging Face 上还有大量预量化的 gguf 模型可供选择。

注意:convert.py 不支持 LLaMA 3,您可以使用 convert-hf-to-gguf.py 处理从 Hugging Face 下载的 LLaMA 3。

bash
1# 获取官方 LLaMA 模型权重并将其放置在 ./models 中 2ls ./models 3llama-2-7b tokenizer_checklist.chk tokenizer.model 4# [可选] 对于使用 BPE 分词器的模型 5ls ./models 6<包含权重和分词器 json 的文件夹> vocab.json 7# [可选] 对于 PyTorch .bin 模型,如 Mistral-7B 8 9 10ls ./models 11<包含权重和分词器 json 的文件夹> 12 13# 安装 Python 依赖项 14python3 -m pip install -r requirements.txt 15 16# 将模型转换为 ggml FP16 格式 17python3 convert.py models/mymodel/ 18 19# [可选] 对于使用 BPE 分词器的模型 20python convert.py models/mymodel/ --vocab-type bpe 21 22# 将模型量化为 4 位(使用 Q4_K_M 方法) 23./quantize ./models/mymodel/ggml-model-f16.gguf ./models/mymodel/ggml-model-Q4_K_M.gguf Q4_K_M 24 25# 更新 gguf 文件类型到最新版本,如果旧版本不再支持 26./quantize ./models/mymodel/ggml-model-Q4_K_M.gguf ./models/mymodel/ggml-model-Q4_K_M-v2.gguf COPY

运行量化模型

bash
1# 启动 gguf 模型的推理 2./main -m ./models/mymodel/ggml-model-Q4_K_M.gguf -n 128

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

在 Windows 上运行预构建二进制文件

您可以在发布页面上找到预构建的 Windows 二进制文件。

只需下载并解压所选的最新 zip 包:(例如 llama-b1380-bin-win-avx2-x64.zip

从解压缩的文件夹中,在此处打开一个终端/cmd 窗口并放置预转换的 .gguf 模型文件。像这样测试 main 示例:

bash
1.\main -m llama-2-7b.Q4_0.gguf -n 128

内存/磁盘要求

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

模型原始大小量化大小(Q4_0)
7B13 GB3.9 GB
13B24 GB7.8 GB
30B60 GB19.5 GB
65B120 GB38.5 GB

量化

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

(已过时)

模型衡量标准F16Q4_0Q4_1Q5_0Q5_1Q8_0
7B困惑度5.90666.15656.09125.98625.94815.9070
7B文件大小13.0G3.5G3.9G4.3G4.7G6.7G
7Bms/tok @ 第4个1275554768372
7Bms/tok @ 第8个1224345525667
7B位/权重16.04.55.05.56.08.5
13B困惑度5.25435.38605.36085.28565.27065.2548
13B文件大小25.0G6.8G7.6G8.3G9.1G13G
13Bms/tok @ 第4个-103105148160131
13Bms/tok @ 第8个-738298105128
13B位/权重16.04.55.05.56.08.5

困惑度(衡量模型质量)

您可以使用 perplexity 示例来衡量给定提示的困惑度(困惑度越低越好)。 有关更多信息,请参阅 https://huggingface.co/docs/transformers/perplexity

上述表中的困惑度测量是针对 wikitext2 测试数据集(https://paperswithcode.com/dataset/wikitext-2),上下文长度为 512。 每个令牌的时间在具有 32GB RAM 的 MacBook M1 Pro 上使用 4 和 8 个线程进行测量。

如何运行

  1. 下载/解压:https://huggingface.co/datasets/ggml-org/ci/resolve/main/wikitext-2-raw-v1.zip
  2. 运行 ./perplexity -m models/7B/ggml-model-q4_0.gguf -f wiki.test.raw
  3. 输出:
bash
1perplexity : calculating perplexity over 655 chunks 224.43 seconds per pass - ETA 4.45 hours 3[1]4.5970,[2]5.1807,[3]6.0382,...

大约 4.45 小时后,您将得到最终的困惑度。

互动模式

如果您想要更像 ChatGPT 的体验,可以通过传递 -i 作为参数来运行互动模式。 在此模式下,您可以随时通过按 Ctrl+C 中断生成并输入一行或多行文本,这些文本将转换为令牌并附加到当前上下文。您还可以使用参数 -r "reverse prompt string" 指定 反向提示。这将导致每当生成过程中遇到反向提示字符串的确切令牌时,提示用户输入。一个典型的用法是使用一个提示,使 LLaMA 模仿多个用户之间的聊天,例如

Alice 和 Bob,并传递 -r "Alice:"

以下是一个少样本交互的示例,使用以下命令调用

bash
1# 默认参数使用 7B 模型 2./examples/chat.sh 3 4# 使用 13B 模型的高级聊天 5./examples/chat-13B.sh 6 7# 使用 13B 模型的自定义参数 8./main -m ./models/13B/ggml-model-q4_0.gguf -n 256 --repeat_penalty 1.0 --color -i -r "User:" -f prompts/chat-with-bob.txt

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

image

持久交互

可以通过利用 --prompt-cache--prompt-cache-all 保存和恢复提示、用户输入和模型生成的内容。./examples/chat-persistent.sh 脚本展示了这一点,支持长时间运行的、可恢复的聊天会话。要使用此示例,您必须提供一个文件来缓存初始聊天提示和一个目录来保存聊天会话,还可以选择提供与 chat-13B.sh 相同的变量。相同的提示缓存可以重复用于新的聊天会话。请注意,提示缓存和聊天目录与初始提示(PROMPT_TEMPLATE)和模型文件相关。

bash
1# 开始新的聊天 2PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh 3 4# 恢复该聊天 5PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/default ./examples/chat-persistent.sh 6 7# 使用相同的提示/模型开始不同的聊天 8PROMPT_CACHE_FILE=chat.prompt.bin CHAT_SAVE_DIR=./chat/another ./examples/chat-persistent.sh 9 10# 不同的提示缓存用于不同的提示/模型 11PROMPT_TEMPLATE=./prompts/chat-with-bob.txt PROMPT_CACHE_FILE=bob.prompt.bin \ 12 CHAT_SAVE_DIR=./chat/bob ./examples/chat-persistent.sh

使用语法进行受约束的输出

llama.cpp 支持使用语法约束模型输出。例如,您可以强制模型仅输出 JSON:

bash
1./main -m ./models/13B/ggml-model-q4_0.gguf -n 256 --grammar-file grammars/json.gbnf -p 'Request: schedule a call at 8pm; Command:'

grammars/ 文件夹包含一些示例语法。要编写自己的语法,请查看 GBNF 指南

要编写更复杂的 JSON 语法,您还可以查看 https://grammar.intrinsiclabs.ai/,这是一个浏览器应用程序,可让您编写 TypeScript 接口并将其编译为 GBNF 语法,然后可以保存以供本地使用。请注意,该应用程序由社区成员构建和维护,请在 其仓库 上提交任何问题或功能请求,而不是在此处。

指令模式

  1. 首先,下载并将 ggml 模型放入 ./models 文件夹
  2. 像这样运行 main 工具:
bash
1./examples/alpaca.sh

示例运行:

bash
1== 运行在互动模式下。 == 2 - 随时按 Ctrl+C 打断。 3 - 按回车键返回控制到 LLaMA。 4 - 如果您想提交另一行输入,请在输入末尾加上 '\'5 6 以下是一个描述任务的指令。编写一个适当完成请求的响应。 7 8> 英语字母表有多少个字母? 9英语字母表有 26 个字母。 10> 阿姆斯特丹最常见的交通方式是什么? 11大多数人(54%)使用公共交通工具。这包括公交车、有轨电车和地铁,城市内有 100 多条线路,使游客和当地居民可以轻松地在城市中导航和通勤。 12> 列出 5 个以 "ca" 开头的单词。 13cadaver、cauliflower、cabbage(蔬菜)、catalpa(树)和 Cailleach。 14>

获取和使用 Facebook LLaMA 2 模型

开创性论文和模型背景

如果您的问题与模型生成质量有关,请至少浏览以下链接和论文以了解 LLaMA 模型的局限性。这在选择合适的模型大小以及欣赏 LLaMA 模型和 ChatGPT 之间的显著和细微差异时尤为重要:

安卓

使用 Termux 在安卓上构建

Termux 是在安卓设备上执行 llama.cpp 的一种方法(无需 root)。

apt update && apt upgrade -y
apt install git make cmake

建议将您的模型移动到 ~/ 目录中以获得最佳性能:

cd storage/downloads
mv model.gguf ~/

获取代码 & 按照 Linux 构建说明 构建 llama.cpp

使用 Android NDK 构建项目

获取 Android NDK,然后使用 CMake 进行构建。

在您的计算机上执行以下命令以避免将 NDK 下载到您的手机上。或者,您也可以在 Termux 中执行这些命令:

$ 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

在您的设备上安装 termux 并运行 termux-setup-storage 以获取对 SD 卡的访问权限(如果是 Android 11+,则运行该命令两次)。

最后,将这些构建的 llama 二进制文件和模型文件复制到您的设备存储中。由于 Android sdcard 中的文件权限无法更改,您可以将可执行文件复制到 /data/data/com.termux/files/home/bin 路径,然后在 Termux 中执行以下命令以添加可执行权限:

(假设您已使用 adb push 将构建的可执行文件推送到 /sdcard/llama.cpp/bin 路径)

$cp -r /sdcard/llama.cpp/bin /data/data/com.termux/files/home/
$cd /data/data/com.termux/files/home/bin
$chmod +x ./*

下载模型 llama-2-7b-chat.Q4_K_M.gguf,并将其推送到 /sdcard/llama.cpp/,然后将其移动到 /data/data/com.termux/files/home/model/

$mv /sdcard/llama.cpp/llama-2-7b-chat.Q4_K_M.gguf /data/data/com.termux/files/home/model/

现在,您可以开始聊天:

$cd /data/data/com.termux/files/home/bin
$./main -m ../model/llama-2-7b-chat.Q4_K_M.gguf -n 128 -cml

以下是在 Pixel 5 手机上运行的交互式会话演示:

https://user-images.githubusercontent.com/271616/225014776-1d567049-ad71-4ef2-b050-55b0b3b9274c.mp4

Docker

先决条件

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

镜像

我们为此项目提供了三个 Docker 镜像:

  1. ghcr.io/ggerganov/llama.cpp:full:此镜像包括主可执行文件和将 LLaMA 模型转换为 ggml 并转换为 4 位量化的工具。(平台:linux/amd64linux/arm64
  2. ghcr.io/ggerganov/llama.cpp:light:此镜像仅包括主可执行文件。(平台:linux/amd64linux/arm64
  3. ghcr.io/ggerganov/llama.cpp:server:此镜像仅包括服务器可执行文件。(平台:linux/amd64linux/arm64

此外,还有以下类似于上述的镜像:

  • ghcr.io/ggerganov/llama.cpp:full-cuda:与 full 相同,但编译时支持 CUDA。(平台:linux/amd64
  • ghcr.io/ggerganov/llama.cpp:light-cuda:与 light 相同,但编译时支持 CUDA。(平台:linux/amd64
  • ghcr.io/ggerganov/llama.cpp:server-cuda:与 server 相同,但编译时支持 CUDA。(平台:linux/amd64
  • ghcr.io/ggerganov/llama.cpp:full-rocm:与 full 相同,但编译时支持 ROCm。(平台:linux/amd64linux/arm64
  • ghcr.io/ggerganov/llama.cpp:light-rocm:与 light 相同,但编译时支持 ROCm。(平台:linux/amd64linux/arm64
  • ghcr.io/ggerganov/llama.cpp:server-rocm:与 server 相同,但编译时支持 ROCm。(平台:linux/amd64linux/arm64

GPU 支持的镜像目前尚未通过 CI 进行测试,除非进行构建。它们未根据 .devops/ 中定义的 Dockerfiles 和 .github/workflows/docker.yml 中定义的 GitHub Action 进行任何变更。如果您需要不同的设置(例如,不同的 CUDA 或 ROCm 库,目前需要在本地构建镜像)。

用法

在本地构建后,使用方式与非 CUDA 示例相似,但需要添加 --gpus 标志。您还需要使用 --n-gpu-layers 标志。

bash
1docker run --gpus all -v /path/to/models:/models local/llama.cpp:full-cuda --run -m /models/7B/ggml-model-q4_0.gguf -p "Building a website can be done in 10 simple steps:" -n 512 --n-gpu-layers 1 2docker run --gpus all -v /path/to/models:/models local/llama.cpp:light-cuda -m /models/7B/ggml-model-q4_0.gguf -p "Building a website can be done in 10 simple steps:" -n 512 --n-gpu-layers 1 3docker run --gpus all -v /path/to/models:/models local/llama.cpp:server-cuda -m /models/7B/ggml-model-q4_0.gguf --port 8000 --host 0.0.0.0 -n 512 --n-gpu-layers 1
Stars
74.1k
Forks
10.7k
Watch
571
版本 b4705
MIT License
更新于 2025年2月13日
ggml, llama
免责声明:本站大资源来自网络收集整理,小部分资源来自原创,如有侵权等,请联系处理。

相关项目

探索更多类似的开源项目