本文地址：blog.lucien.ink/archives/552

将下列代码保存为 install.sh，然后 bash install.sh。

#!/usr/bin/env bash
set -e
wget 'https://github.mirrors.lucien.ink/https://github.com/adnanh/webhook/releases/download/2.8.2/webhook-linux-amd64.tar.gz'
tar -xzvf webhook-linux-amd64.tar.gz
mv webhook-linux-amd64 /usr/local/
cat << EOF > /etc/systemd/system/webhook.service
[Unit]
Description=Webhook server
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/webhook-linux-amd64/webhook \
  -nopanic \
  -hooks /etc/webhook/hooks.yaml \
  -hotreload \
  -logfile /var/log/webhook/webhook.log \
  -port 9000
Restart=on-failure
User=root
Group=root

[Install]
WantedBy=multi-user.target
EOF
systemctl enable webhook
mkdir -p /etc/webhook/scripts
cat << EOF > /etc/webhook/hooks.yaml
- id: test
  execute-command: "/etc/webhook/scripts/test.sh"
  command-working-directory: "/root/"
  trigger-rule:
    match:
      type: value
      value: Bearer change-this
      parameter:
        source: header
        name: Authorization
EOF
cat << EOF > /etc/webhook/scripts/test.sh
#!/usr/bin/env sh
echo foo > bar
EOF
chmod +x /etc/webhook/scripts/test.sh
mkdir -p /var/log/webhook
systemctl start webhook
curl 'http://localhost:9000/hooks/test' -H 'Authorization: Bearer change-this'

本文地址：blog.lucien.ink/archives/551

在这里记录一下我自己的 zsh 配置。

mkdir -p "${HOME}/.local"
cd "${HOME}/.local"

git clone https://github.com/zsh-users/zsh-syntax-highlighting.git --depth=1 -b master
git clone https://github.com/zsh-users/zsh-autosuggestions.git --depth=1 -b master
git clone https://github.com/romkatv/powerlevel10k.git  --depth=1 -b master

cat << EOF >> ~/.zshrc
source "${HOME}/.local/zsh-autosuggestions/zsh-autosuggestions.zsh"
source "${HOME}/.local/zsh-syntax-highlighting/zsh-syntax-highlighting.zsh"
source "${HOME}/.local/powerlevel10k/powerlevel10k.zsh-theme"
EOF

本文地址：blog.lucien.ink/archives/548

本章节将介绍在面向深度学习时，推荐安装的系统以及对应的安装选项。

系统选择

目前主流操作系统有 Linux、macOS、Winodws，如果不考虑日常当作个人电脑来使用的话，强烈建议使用 无图形化界面 的 Linux，因为图形化界面会占用一定的显存（虽然也有不占用显存且同样拥有图形化的方法，这不在本文的讨论范围）。

接下来就是 Linux 发行版的选择，大部分企业（包括 NVIDIA 自己）会选择 Ubuntu，因为内置的东西多，笔者在这里不选择 Ubuntu，也是因为它内置的东西太多了，比如 snap 和 systemd-resolved。

基于笔者的实践经验，推荐使用 Debian 作为操作系统，因为它足够精简，而基于这般精简，也不会在后续使用上产生任何额外的复杂，且行为都足够可控，故在本文包括后续的一系列文章中，都会使用 Debian 作为演示操作系统。

下载安装包

在这里特意注明下 Debian 的下载地址，以免大家被百度的广告误导：Installing Debian via the Internet。

安装系统

启动页面

语言

在这里 强烈不推荐 选择中文，除非你准备好应对各种因中文字符而产生的问题。

地区

美国或中国都可以，这会影响到安装完成后的时区：

• 可以在这里先选择 United States 然后进入系统后再更改。
• 也可以直接去 other 里找 Asia 然后 China。

编码

一律选 en_US.UTF-8，可以规避很多潜在的问题。

键盘布局

主机名 & 域名

如果只是单台服务器的话，这里随便填就好。
如果打算组建集群，这里就直接起个 node-0 之类的遍于自己区分的名字就好。

设定用户 & 密码

硬盘分区

推荐直接用一整块硬盘，不启用 LVM 和加密。

配置 apt

在这里选择国内的镜像，否则会很慢。

是否参与数据采集

选择预装软件

在这里只选择 SSH 和基础工具就好，没有特殊需求不建议勾选图形化界面（Debian desktop environment）。

安装引导

重启进入系统

本文地址：blog.lucien.ink/archives/547
本文主要参考自：自建Docker 镜像/源加速的方法

1. 简介

最近 Docker Hub 被禁一事引起了不小的波动，在这里简单讲下在这之后应该如何访问公开的 Docker Hub。

2. Cloudflare

2.1 搭建

搭建的前提是有一个在 Cloudflare 中被管理的域名，此处不展开介绍，在这里假设这个域名是 your-domain.com。

2.1.1 创建 Worker

点击页面左侧的 Workers & Pages，创建一个 Worker，填入以下内容。请注意将 your-domain.com 替换为你自己的域名。

'use strict'

const hub_host = 'registry-1.docker.io'
const auth_url = 'https://auth.docker.io'
const workers_url = 'https://your-domain.com'
/**
 * static files (404.html, sw.js, conf.js)
 */

/** @type {RequestInit} */
const PREFLIGHT_INIT = {
    status: 204,
    headers: new Headers({
        'access-control-allow-origin': '*',
        'access-control-allow-methods': 'GET,POST,PUT,PATCH,TRACE,DELETE,HEAD,OPTIONS',
        'access-control-max-age': '1728000',
    }),
}

/**
 * @param {any} body
 * @param {number} status
 * @param {Object<string, string>} headers
 */
function makeRes(body, status = 200, headers = {}) {
    headers['access-control-allow-origin'] = '*'
    return new Response(body, {status, headers})
}


/**
 * @param {string} urlStr
 */
function newUrl(urlStr) {
    try {
        return new URL(urlStr)
    } catch (err) {
        return null
    }
}


addEventListener('fetch', e => {
    const ret = fetchHandler(e)
        .catch(err => makeRes('cfworker error:\n' + err.stack, 502))
    e.respondWith(ret)
})


/**
 * @param {FetchEvent} e
 */
async function fetchHandler(e) {
    const getReqHeader = (key) => e.request.headers.get(key);
    let url = new URL(e.request.url);
    if (url.pathname === '/token') {
        let token_parameter = {
            headers: {
                'Host': 'auth.docker.io',
                'User-Agent': getReqHeader("User-Agent"),
                'Accept': getReqHeader("Accept"),
                'Accept-Language': getReqHeader("Accept-Language"),
                'Accept-Encoding': getReqHeader("Accept-Encoding"),
                'Connection': 'keep-alive',
                'Cache-Control': 'max-age=0'
            }
        };
        let token_url = auth_url + url.pathname + url.search
        return fetch(new Request(token_url, e.request), token_parameter)
    }

    url.hostname = hub_host;

    let parameter = {
        headers: {
            'Host': hub_host,
            'User-Agent': getReqHeader("User-Agent"),
            'Accept': getReqHeader("Accept"),
            'Accept-Language': getReqHeader("Accept-Language"),
            'Accept-Encoding': getReqHeader("Accept-Encoding"),
            'Connection': 'keep-alive',
            'Cache-Control': 'max-age=0'
        },
        cacheTtl: 3600
    };

    if (e.request.headers.has("Authorization")) {
        parameter.headers.Authorization = getReqHeader("Authorization");
    }

    let original_response = await fetch(new Request(url, e.request), parameter)
    let original_response_clone = original_response.clone();
    let original_text = original_response_clone.body;
    let response_headers = original_response.headers;
    let new_response_headers = new Headers(response_headers);
    let status = original_response.status;

    if (new_response_headers.get("Www-Authenticate")) {
        let auth = new_response_headers.get("Www-Authenticate");
        let re = new RegExp(auth_url, 'g');
        new_response_headers.set("Www-Authenticate", response_headers.get("Www-Authenticate").replace(re, workers_url));
    }

    if (new_response_headers.get("Location")) {
        return httpHandler(e.request, new_response_headers.get("Location"))
    }

    return new Response(original_text, {
        status,
        headers: new_response_headers
    })
}

/**
 * @param {Request} req
 * @param {string} pathname
 */
function httpHandler(req, pathname) {
    const reqHdrRaw = req.headers
    // preflight
    if (req.method === 'OPTIONS' &&
        reqHdrRaw.has('access-control-request-headers')
    ) {
        return new Response(null, PREFLIGHT_INIT)
    }
    let rawLen = ''
    const reqHdrNew = new Headers(reqHdrRaw)
    const refer = reqHdrNew.get('referer')
    let urlStr = pathname
    const urlObj = newUrl(urlStr)
    /** @type {RequestInit} */
    const reqInit = {
        method: req.method,
        headers: reqHdrNew,
        redirect: 'follow',
        body: req.body
    }
    return proxy(urlObj, reqInit, rawLen, 0)
}


/**
 *
 * @param {URL} urlObj
 * @param {RequestInit} reqInit
 */
async function proxy(urlObj, reqInit, rawLen) {
    const res = await fetch(urlObj.href, reqInit)
    const resHdrOld = res.headers
    const resHdrNew = new Headers(resHdrOld)

    // verify
    if (rawLen) {
        const newLen = resHdrOld.get('content-length') || ''
        const badLen = (rawLen !== newLen)

        if (badLen) {
            return makeRes(res.body, 400, {
                '--error': `bad len: ${newLen}, except: ${rawLen}`,
                'access-control-expose-headers': '--error',
            })
        }
    }
    const status = res.status
    resHdrNew.set('access-control-expose-headers', '*')
    resHdrNew.set('access-control-allow-origin', '*')
    resHdrNew.set('Cache-Control', 'max-age=1500')

    resHdrNew.delete('content-security-policy')
    resHdrNew.delete('content-security-policy-report-only')
    resHdrNew.delete('clear-site-data')

    return new Response(res.body, {
        status,
        headers: resHdrNew
    })
}

2.1.2 添加域名

进入创建好的 Worker 的配置页面，在 Settings Tab 中选择 Triggers，点击 Add Custom Domain，添加 your-domain.com。

2.2 使用

2.2.1 配置为镜像

在 /etc/docker/daemon.json 加入以下内容：

{
  "registry-mirrors": [
    "https://your-domain.com"
  ]
}

然后重启 docker：systemctl restart docker

随后就能像往常一样直接 pull 了：

docker pull busybox:latest
docker pull mysql/mysql-server:latest

2.2.2 直接使用

docker pull your-domain.com/library/busybox:latest
docker pull your-domain.com/mysql/mysql-server:latest

3. 使用 registry

首先你需要一个能正常访问 Docker Hub 的机器，并在那台机器上正常安装 Docker。

3.1 搭建

找一个文件夹，编辑 compose.yml 文件，填入以下内容：

services:
  registry:
    image: registry:2
    ports:
      - "5000:5000"
    environment:
      REGISTRY_PROXY_REMOTEURL: https://registry-1.docker.io  # 上游源
      REGISTRY_STORAGE_CACHE_BLOBDESCRIPTOR: inmemory # 内存缓存，去掉本行以直接使用硬盘
    volumes:
      - ./data:/var/lib/registry

然后执行 docker compose up -d 即可。

3.2 使用

使用方法同上。

本文地址：blog.lucien.ink/archives/546

一直以来模型推理成本对于想要使用大模型却又注重隐私的用户来说都是个难题，今天在这里探讨一下如何用尽可能低的成本去获得尽可能高的模型性能。

曾经尝试过用 Tesla P4（目前市场价 300 元，7.5G 显存）使用 vllm 去跑 GPTQ 量化版本的 Qwen 7B，提示显卡太旧无法支持 GPTQ，后来这张卡就被我拉去跑 Stable Diffusion 了。

现如今 Qwen1.5 问世，同时 Qwen 团队也放出了 gguf 格式的模型，从 0.5B 至 72B 都有，甚至从 q2_k 到 q8_0 都有，还很贴心的放了 模型大小 与 量化方法 的困惑度矩阵，这令我狠狠地心动了，果断掏出我的 P4 再战一回。

在这篇文章中，我将借助 llama.cpp 采用 GPU + CPU 混合计算的形式，使用 Tesla P4 来推理 Qwen1.5-14B-Chat，支持 2048 上下文并且达到 11 tokens/s 左右的速度。

部署

运行环境参考之前写的 Debian 下 CUDA 生产环境配置笔记，不赘述。在这里简述下电脑配置：CPU i3-12100、8G RAM DDR4、Tesla P4（7.5GB 显存）。

再次强调下，最便宜的就是这张显卡了，市场价 300 块。

下载模型文件

前往 Qwen1.5-14B-Chat-GGUF/files 选择心仪的量化模型。

在这里选择的是 qwen1_5-14b-chat-q2_k.gguf，虽然是 q2_k 量化，但其在维基百科数据集上的困惑度仍旧是小于 fp16 的 7B，所以其实际表现 可能 是要更好。

使用 docker compose 部署

LLaMA.cpp HTTP Server

这 3 个参数会直接决定模型能不能跑起来，以及跑起来的效果，在这里我直接放出适用于 Tesla P4 的参数，可以直接抄作业：

• --n-gpu-layers 40 代表有 40 层模型将被加载进 VRAM（14B-Chat 总共有 41 层）。
• -c 2048 代表模型总上下文长度（模型本身支持 32K，但在这里限定 2K）。
• --batch-size 256 代表在处理 Prompt 时的 batch size，比如你的 prompt 拥有 768 个 token，那么就会被分为 3 个 batch 去 inferece。这个数值默认是 512，在这里为了节省显存，调整为 256（会拖慢服务处理 prompt 的速度）。

其它的参数官方文档写的较为清晰，有啥不明白的直接 --help 一下就行，在这里直接贴出 compose.yml 文件，不赘述。

version: "3"

services:
  qwen2-llama-cpp:
    container_name: qwen2-llama-cpp
    image: ghcr.io/ggerganov/llama.cpp:server-cuda
    volumes:
      - /mnt/nas/huggingface/model/nlp/Qwen/Qwen1.5-14B-Chat-GGUF/qwen1_5-14b-chat-q2_k.gguf:/model.gguf:ro
    command: "-m /model.gguf --host 0.0.0.0 --port 8000 --n-gpu-layers 40 -c 2048 --batch-size 256 --threads 4 --alias this_is_a_model_name --api-key this_is_a_api_key"
    shm_size: 8GB
    restart: always
    ports:
      - 8000:8000
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              device_ids: ["0"]
              capabilities: [gpu]

调用

llama.cpp 官方支持了非常多样化的 API 调用形式，为了缩短篇幅，在这里我只列举 OpenAI API 格式的调用，因为围绕 OpenAI API 的社区产品会更加多样化一些。

from openai import OpenAI

client = OpenAI(base_url="http://192.168.1.2:8000/v1", api_key="this_is_a_api_key")

stream = client.chat.completions.create(
    model="this_is_a_model_name",
    messages=[{"role": "user", "content": "给我讲一个故事。"}],
    stream=True,
)
for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="", flush=True)

推理速度

在这里简单测试一下推理速度：

视频：用 300 元的显卡推理 Qwen1.5-14B 效果展示

总结

本文探索了如何使用一张 300 元的显卡借助 llama.cpp 来推理 Qwen1.5-14B-Chat 的 q2_k 量化模型，获得不慢的推理速度与不俗的性能表现。

值得注意的是，可以观察到视频中在 predict 期间，GPU 计算的利用率是没有达到 100% 的，原因是因为我们将一部分计算交给了 CPU，数据交换以及 CPU 运算增大了 GPU 的数据等待时间。

解决这个问题也有几个改进点：

1. 换用性能更强的 CPU
2. 换用带宽更高的 RAM
3. 将所有模型都进 VRAM
   3.1 换用更小的上下文长度，比如 1024
   3.2 换用更大的显存

从工业的角度讲，Tesla P4 可能是目前市面上能买到的 价格/显存 性价比较高的一款显卡了，8 张 P4（2400 元，60G 显存，600W 功耗）能推理精度较高的 72B 的模型，如果不在意功耗的话，配合退役的服务器能将整机成本控制在 3000 元左右，对于工业上自建推理服务还算一个不错的选择。

但其缺点也较为明显，主要来自于其年代久远，sm 版本较低、不支持 GPTQ 等依赖新 op 的 方法、不支持 bf16 等等。得益于 llama.cpp 这样的项目存在，这张卡才能在现如今的深度学习环境下焕发新春。

相关资料

1. llama.cpp
2. Debian 下 CUDA 生产环境配置笔记
3. modelscope.cn/qwen/Qwen1.5-14B-Chat-GGUF

本文地址：blog.lucien.ink/archives/545

最近学会了用 WireGuard 来打洞，在此记录一下以备忘。

概述

cd /etc/wireguard
wg genkey > private && chmod 600 private
wg pubkey < private > public && chmod 600 public

将配置文件写在 /etc/wireguard/${name}.conf 中，可全局通过 wg-quick [up/down] ${name} 来进行启停，配置文档详见：Quick Start - WireGuard。

如果需要作为常驻服务，更推荐使用 systemctl [enable/disable/start/stop] wg-quick@${name}.service 来进行管理。

懒人脚本

在服务端，我们执行：

#!/usr/bin/env sh
CONFIG_NAME="wg"

SERVER_PRIVATE_KEY="$(cat private)"
SERVER_INTERNAL_IP="192.168.1.2"
SERVER_PORT="10086"

CLIENT_PUBLIC_KEY="this_is_a_public_key_copy_from_your_client"
CLIENT_INTERNAL_IP="192.168.1.3"

cat << EOF > "/etc/wireguard/${CONFIG_NAME}.conf"
[Interface]
PrivateKey = ${SERVER_PRIVATE_KEY}
Address = ${SERVER_INTERNAL_IP}/24
ListenPort = ${SERVER_PORT}

[Peer]
PublicKey = ${CLIENT_PUBLIC_KEY}
AllowedIPs = ${CLIENT_INTERNAL_IP}/24
PersistentKeepalive = 25
EOF

systemctl enable "wg-quick@${CONFIG_NAME}.service"
systemctl start "wg-quick@${CONFIG_NAME}.service"

在客户端，我们执行：

#!/usr/bin/env sh
CONFIG_NAME="wg"

SERVER_PUBLIC_IP="server_public_ip_or_domain"
SERVER_PORT="10086"
SERVER_PUBLIC_KEY="this_is_a_public_key_copy_from_your_server"
SERVER_INTERNAL_IP="192.168.1.2"

CLIENT_PRIVATE_KEY="$(cat private)"
CLIENT_INTERNAL_IP="192.168.1.3"

cat << EOF > "/etc/wireguard/${CONFIG_NAME}.conf"
[Interface]
PrivateKey = ${CLIENT_PRIVATE_KEY}
Address = ${CLIENT_INTERNAL_IP}/24

# aliyun
[Peer]
Endpoint = ${SERVER_PUBLIC_IP}:${SERVER_PORT}
PublicKey = ${SERVER_PUBLIC_KEY}
AllowedIPs = ${SERVER_INTERNAL_IP}/24
PersistentKeepalive = 25
EOF

systemctl enable "wg-quick@${CONFIG_NAME}.service"
systemctl start "wg-quick@${CONFIG_NAME}.service"

Reference

• Quick Start - WireGuard
• WireGuard 教程：WireGuard 的搭建使用与配置详解

本文地址：blog.lucien.ink/archives/544

Pip

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

Conda

channels:
  - defaults
show_channel_urls: true
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  deepmodeling: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud/

brew

过于复杂，参考 Homebrew / Linuxbrew 镜像使用帮助 与 Homebrew-bottles 镜像使用帮助。

APT

Debian

Debian 软件仓库镜像使用帮助

Ubuntu

Ubuntu 软件仓库镜像使用帮助

docker

export DOWNLOAD_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce"
wget -O- https://get.docker.com/ | bash

Proxmox

Proxmox 软件仓库镜像使用帮助

本文地址：blog.lucien.ink/archives/543

Ubuntu 22.04 LTS 在安装过程中默认只使用 100G 的硬盘，执行以下命令即可扩容：

$ df -h
Filesystem                         Size  Used Avail Use% Mounted on
/dev/mapper/ubuntu--vg-ubuntu--lv  100G   11G  89G   11% /

$ lvdisplay
  --- Logical volume ---
  LV Path                /dev/ubuntu-vg/ubuntu-lv
  LV Name                ubuntu-lv
  VG Name                ubuntu-vg
  LV Write Access        read/write
  LV Creation host, time ubuntu-server, 2023-10-11 10:53:11 +0000
  LV Status              available
  # open                 1
  LV Size                100 GB
  Segments               1
  Allocation             inherit
  Read ahead sectors     auto
  - currently set to     512
  Block device           253:0

$ lvextend -l +100%FREE /dev/ubuntu-vg/ubuntu-lv

$ resize2fs /dev/ubuntu-vg/ubuntu-lv

$ df -h
Filesystem                         Size  Used Avail Use% Mounted on
/dev/mapper/ubuntu--vg-ubuntu--lv  3.5T   11G  3.3T   1% /

本文地址：blog.lucien.ink/archives/542

发现每次执行 nvidia-smi 都特别慢，发现是需要 nvidia-persistenced 常驻才可以，这个并不会在安装完驱动之后自动配置，需要手动设置一个自启。

cat <<EOF >> /etc/systemd/system/nvidia-persistenced.service
[Unit]
Description=NVIDIA Persistence Daemon
Wants=syslog.target

[Service]
Type=forking
ExecStart=/usr/bin/nvidia-persistenced
ExecStopPost=/bin/rm -rf /var/run/nvidia-persistenced

[Install]
WantedBy=multi-user.target
EOF

systemctl daemon-reload
systemctl start nvidia-persistenced
systemctl enable nvidia-persistenced

本文地址：blog.lucien.ink/archives/541

以 Debian 11 为例，主要用于备忘。

deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye main contrib non-free
deb https://mirrors.tuna.tsinghua.edu.cn/debian/ bullseye-updates main contrib non-free
deb https://mirrors.tuna.tsinghua.edu.cn/debian-security bullseye-security main contrib non-free

apt update && apt install vim curl wget git cifs-utils -y

export DOWNLOAD_URL="https://mirrors.tuna.tsinghua.edu.cn/docker-ce"
curl -fsSL https://get.docker.com/ | sh

pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

hostnamectl set-hostname your_host
hostname your_host
/etc/hosts

timedatectl set-timezone Asia/Shanghai

groupmod -g 3000 foo  # 添加用户组
adduser  # 添加用户
usermod -aG group_name user_name  # 将用户添加至组

本文地址：blog.lucien.ink/archives/538

本文用来收集各种和生成式模型相关的内容，由于 ChatGPT 是其代表，也是会被写入人类历史进程的一个名字，所以便用 ChatGPT 作为标题的一部分，以表示我对 OpenAI 团队由衷的敬佩。

2023-04-02 更新

• Improving Language Understanding by Generative Pre-Training (2018)

  • 介绍了 GPT 的结构和训练方式，文章提到未来可以继续拓展的几个方向。其中一个便是模型在 ZERO-SHOT 的设定下，模型的表现与堆叠的解码器层数有直接的正相关性。

• Language Models are Unsupervised Multitask Learners (2019)

  • 文章认为对单任务单领域的训练是模型缺乏泛化能力的主要原因，实践验证仅靠预训练 + 提示 + 预测就在8/9个任务里达到了SOTA。

• Language Models are Few-Shot Learners (2020)

  • 继续探索了在不对下游任务进行适配（模型结构不更改、参数不更新）的情况下，模型的表现。

• Training language models to follow instructions with human feedback (2022)

  • 探索了指示学习和基于人工反馈的强化学习训练，基本上约等于 ChatGPT。

• LoRA: Low-Rank Adaptation of Large Language Models (2021)

  • 提出通过训练一个低秩参数矩阵来进行模型微调，相较于直接微调整个模型，能在损失较少精度的情况下大幅降低训练成本。

• Self-Instruct: Aligning Language Model with Self Generated Instructions（2022）

  • 让模型尝试通过半监督的方式自己去生成指令样本，能取得不错的效果。

• LLaMA: Open and Efficient Foundation Language Models

  • 训练了从 7B 到 65B 的一组模型，全部贡献给开源社区，且 LLaMA-13B 在多数基准测试中优于 GPT-3(175B)。
  • 验证了公开数据集的可行性，以及小模型（相比 OpenAI 的规模）的潜力。
  • 开源模型地址：huggingface.co/decapoda-research

• Stanford Alpaca: An Instruction-following LLaMA Model

  • 花了 $500 去调用 OpenAI 的 text-davinci-003 并收集数据，然后用这些数据花了 $100 来微调 LLaMA-7B 模型，得到了一个效果还不错的模型，取名为 Alpaca，模型未开源。
  • 公开了生成数据的代码，以及对应的数据集：alpaca_data.json

• Guanaco: A Multilingual Instruction-Following Language Model Based on LLaMA 7B

  • 同样是对 LLaMA-7B 进行微调，不同的是在 alpaca_data.json 的基础上增加了对繁简体中文及日语的指令，共计 534530 条，数据集地址：Guanaco Dataset。

• Vicuna: An Open-Source Chatbot Impressing GPT-4 with 90%* ChatGPT Quality

  • 花了 $300 左右，使用 用户共享的数据 来对 LLaMA-13B 进行微调，可以在 GPT-4 的评测 下达到 ChatGPT 90% 的水平。
  • Demo: Vicuna Online Demo，源码：FastChat，暂未公开模型。
  • ShareGPT Github: [domeccleston/sharegpt]

• BELLE: Be Everyone's Large Language model Engine

  • 来自 链家 的技术团队，提供了训练代码、数据、模型，包含一些中文改进。HuggingFace 主页：BelleGroup

• Chinese-Vicuna: A Chinese Instruction-following LLaMA-based Model

  • 在 LLaMA 的基础上使用 BELLE 和 Guanaco 训练了 lora，提供了代码和训练过的 Lora。HuggingFace 主页：Chinese-Vicuna

暂时先收集这些，总结下来就一句话：OpenAI 不够体面，开源社区帮他体面。以及作为马后炮，我认为在对 GPT 现代化改进的加持下，于多数日常任务来说，10B 左右的规模应该是足够的。

2023-04-04 更新

• 今天 vicuna 放出了他们的模型：lmsys/vicuna-13b-delta-v0

2023-04-06 更新

• Koala: A Dialogue Model for Academic Research

  • 主要是使用 EasyLM 提升了训练速度，使用 8 张 A100 完成两轮 epoch 只需要 6 个小时，大大降低了训练成本。评测效果优于 Alpaca，达到 ChatGPT 50% 的性能。

2023-04-09 更新

• 链家放出了 13B 的模型：BelleGroup/BELLE-LLAMA-13B-2M

  • 同时还放出了更多的数据集
• 一个跟进 LLM 的 Repo：Awesome-LLM: a curated list of Large Language Model

2023-04-22 更新

当前的开源社区大致有 3 个方向：

1. 复现 ChatGPT 的效果
2. 加速（模型轻量化、更底层的训练/推理加速）
3. 应用（插件、Auto-GPT、ViedoChat、提示魔法）

• Auto-GPT: An Autonomous GPT-4 Experiment

  • 会上网、使用工具，能根据人类给出的任务，自己定目标、思考、执行。
  • 在线 DEMO：AgentGPT

• MiniGPT-4: Enhancing Vision-language Understanding with Advanced Large Language Models

  • 用小模型复现了 GPT-4 的多模态能力，已开源
  • 项目主页：MiniGPT-4
  • 模型：Vision-CAIR/MiniGPT-4

• Generative Agents: Interactive Simulacra of Human Behavior

  • 令若干个独立的基于 GPT 的 Agent “生活”在一起，会产生很多类似人类的社会行为
  • DEMO 在国内打不开，在这里只放出论文

• ChatGPT 中文指南

  • 这是一个很早以前就有的项目，只是每次都得根据回忆去重新搜出来，不如就直接记在这里

• 复旦大学的 MOSS

  • 昨天（4 月 22 日）刚刚开源，给出了模型、数据、代码
  • 并且 MOSS 支持插件，如科学计算、上网、绘图，据我了解这是开源社区的首次支持
  • 关于插件如何使用，可参考这里：plugin模型，有用python代码写的使用例子吗？而非只是动态图片，截止到写下这行文字，作者还没有实际测试过。

2023-04-23 更新

• Awesome ChatGPT Prompts

  • ChatGPT 中文指南 的英文版本

• ChatGPT 学术优化

  • 科研工作专用ChatGPT/GLM拓展，特别优化学术Paper润色体验，模块化设计支持自定义快捷按钮&函数插件，支持代码块表格显示，Tex公式双显示，新增Python和C++项目剖析&自译解功能，PDF/LaTex论文翻译&总结功能，支持并行问询多种LLM模型，支持gpt-3.5/gpt-4/chatglm

• Chat with any PDF

  • 可以将 PDF GPT 作为上下文，然后可以问他任何问题，比如摘要、理解、建议等。

本文地址：blog.lucien.ink/archives/537

访问 OpenWRT Download Server，找到自己的架构，以 x86_64 为例：

1. 在 /etc/opkg/customfeeds.conf 中添加 src/gz openwrt_kiddin9 https://op.supes.top/packages/x86_64
2. 注释或删掉 /etc/opkg.conf 中的 option check_signature
3. 执行 opkg update
4. 执行 opkg install luci-app-passwall

本文地址：blog.lucien.ink/archives/535

官网原生的 overlay 只有 100M，不够用。本文只讨论新安装的情形，已安装扩容的场景在本文不涉及。

步骤

假设从官网下载的文件名为 openwrt-22.03.2-x86-64-generic-squashfs-combined.img.gz。

# 解压
gzip -kd openwrt-22.03.2-x86-64-generic-squashfs-combined.img.gz
# 重命名，方便操作
mv openwrt-22.03.2-x86-64-generic-squashfs-combined.img op.img
# 在尾部增加 4096M
dd if=/dev/zero bs=1M count=4096 >> op.img
# 进入分区工具
parted op.img

在 parted 的 console 里执行：

print # 打印当前分区
resizepart 2 100% # 将剩余空间分配给分区 2
print # 再次打印分区
qiut # 退出

参考文章

1. 软路由探索之旅 篇三：给openwrt扩容overlay 3月30日更新

最近整了张 Tesla P4，由于是半高卡，索性就直接将其塞进了我的 NAS 里，试图将原来用 onnx 跑在 CPU 上的模型迁移至 GPU 上，遇到了些许问题，在此记录下。

本文地址：blog.lucien.ink/archives/534

0. 前言

由于是用于生产环境，我的所有服务（包含本次要迁移的模型）都是容器化运行的，所以我这次也是考虑用 NVIDIA Docker 2 来进行生产部署。

我的操作系统是 Debian 11 x64，运行在 i3-12100 上。

对本篇文章的读者，我在这里假定你已装好 Docker，若没有，可以参考 Docker 入门手记。

1. 环境部署

1.1 下载驱动

前往 Official Drivers | NVIDIA 下载 Tesla P4 的驱动，CUDA Toolkit 记得不要选 Any，否则会给你一个十分旧的驱动，会影响 nvidia docker (CUDA >= 11.6) 的安装。

由于实际运行是在 docker 内，所以在稳定的前提下，宿主机的 CUDA 版本是越新越好，在这里我选择 CUDA 12.0 版本。

1.2 系统准备

1.2.1 禁用 Nouveau

这一步是必要的，因为 Nouveau 也是 NVIDIA GPU 的驱动程序，参考 nouveau - 維基百科。

1. 创建文件

touch /etc/modprobe.d/blacklist-nouveau.conf

2. 在文件中写入以下内容：

blacklist nouveau
options nouveau modeset=0

3. 重新生成 kernel initramfs

update-initramfs -u

4. 重启

reboot

1.2.2 安装编译环境

参考 Nvidia unable to find kernel source tree

apt install linux-headers-`uname -r` build-essential

1.3 安装驱动

直接 chmod +x 然后运行驱动安装程序即可，不赘述。

1.4 安装 NVIDIA Docker

据我观察，NVIDIA Docker 2 类似是 Docker 的一个插件，让原生的 Docker 可以调用 NVIDIA Driver。

1.4.1 添加源

distribution=$(. /etc/os-release;echo $ID$VERSION_ID) \
      && curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg \
      && curl -s -L https://nvidia.github.io/libnvidia-container/$distribution/libnvidia-container.list | \
            sed 's#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g' | \
            tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

1.4.2 安装

apt update
apt install -y nvidia-docker2
systemctl restart docker

1.4.3 测试

docker run --rm --gpus all nvidia/cuda:11.6.2-base-ubuntu20.04 nvidia-smi

如果能看到 nvidia-smi 的内容，则代表安装成功了。

3. 参考文档

• Installation Guide - NVIDIA Cloud Native Technologies

Windows 删除恢复分区

本文地址：blog.lucien.ink/archives/533

目前不论是 Windows 10 还是 Windows 11，在安装完成后在 C 盘的后面都会有一个恢复分区，在虚拟机场景下，需要对硬盘进行扩容时，这个恢复分区会使得分区不连续，导致无法直接将容量扩展至 C 盘中，所以需要在扩容前删掉这个分区。

什么是恢复分区

在查看了一些资料后，用一句话来讲，就是个 Windows PE，可被 Windows 引导镜像所代替。

以及在查询了 微软社区 的后，我得出的结论是：“删除这个分区不会有任何影响”。

怎么删除

很多小伙伴进入到系统自带的 磁盘管理 中会发现这个恢复分区是受保护的，没有办法直接用 GUI 的形式删除。

在查阅了资料后，按照 这篇文章 可以成功地删掉这个分区，步骤如下：

1. 右键点击 开始 菜单，并选择 Windows Powershell（管理员）
2. 输入 diskpart，然后输入 list disk
3. 输入 select disk #（# 是恢复分区所在硬盘的编号）
4. 输入 list partition
5. 输入 select partition #（# 是恢复分区所在分区的编号）
6. 输入 delete partition override

执行完以上步骤之后，回到 磁盘管理 中，你会发现恢复分区已经被成功删除。