大模型开源生态

说明

• 📝 - arXiv
• 😺 - GitHub
• 🤗 - [Hugging Face][HuggingFace]
• 🇨🇳🤗 - [ModelScope][ModelScope]
• 📜 - Documentation

🏆 排行榜

Leaderboard

LLM 排行榜

Open LLM Leaderboard

LMSYS Chatbot Arena Leaderboard

AlpacaEval Leaderboard

OpenCompass LLM Leaderboard

YALL - Yet Another LLM Leaderboard

其它排行榜

嵌入模型

• Massive Text Embedding Benchmark (MTEB) Leaderboard

编码大模型

• Big Code Models Leaderboard
• Coding LLMs Leaderboard

多模态大模型

• OpenCompass 多模态评测榜单

Chat LLM 排行榜

Pretrained LLM 排行榜

指标

• Average: 模型在多个任务上的平均表现。在评估LLM时，通常会在多个不同的任务或数据集上测试模型，然后计算这些任务的平均得分，以得到一个综合的性能指标。
• ARC (AI2 Reasoning Challenge): 一个用于评估模型在复杂推理任务上的表现的基准。它包含了多种类型的逻辑和数学问题，旨在测试模型的推理能力，包括数量推理、物理推理和抽象推理等。
• HellaSwag: 一个多步推理任务，要求模型预测给定情境的后续事件。这个任务测试了模型对常识、因果关系和事件连贯性的理解能力。
• MMLU (Massive Multitask Language Understanding): 一个大规模的多任务语言理解基准，它包含了多种类型的自然语言处理任务，如情感分析、文本分类、问答等。这个指标旨在评估模型在处理多样化语言任务时的泛化能力。
• TruthfulQA: 一个评估模型在常识问答任务上的表现的基准。它特别关注模型在回答需要外部知识的问题时的准确性和可靠性，以及模型在面对错误信息时的抗干扰能力。
• Winogrande: 一个阅读理解任务，它包含了需要模型理解文本中的指代消歧和常识推理的问题。这个任务旨在测试模型在理解复杂文本和进行逻辑推理方面的能力。
• GSM8K: 一个数学问题解答任务，它包含了多种类型的数学问题，要求模型展示其数学推理和计算能力。这个指标评估模型在处理数学概念和执行数学运算方面的表现。

LLM 安全排行榜

LLM Safety Leaderboard

涵盖了 8 个可信度评估维度

• Non-toxicity（非毒性）
• Non-Stereotype（非刻板印象）
• AdvGLUE++
• OoD
• Adv Demo
• Privacy（隐私）
• Ethics（伦理）
• Fairness（公平性）

LLM 企业场景排行榜

Enterprise Scenarios leaderboard

本排行榜旨在评估语言模型在企业现实用例中的性能。目前已支持 6 类任务

• 金融
• 法律保密
• 创意写作
• 客服对话
• 毒性
• 企业 PII

🤖 大模型时代的 AI 社区

🤗                    🇨🇳🤗

[HuggingFace][HuggingFace] [ModelScope][ModelScope]

HuggingFace 下载模型

❶ 安装 huggingface-cli

pip install "huggingface_hub[cli]"

❷ 下载模型

mkdir vicuna-7b-v1.5
huggingface-cli download lmsys/vicuna-7b-v1.5 \
    --local-dir vicuna-7b-v1.5 \
    --local-dir-use-symlinks False

使用脚本下载 HuggingFace 的模型

❶ 编写下载模型脚本 download.py

from huggingface_hub import snapshot_download
snapshot_download(repo_id="lmsys/vicuna-7b-v1.5", 
                  local_dir="vicuna-7b-v1.5",
                  local_dir_use_symlinks=False, 
                  revision="main")

❷ 下载模型

mkdir vicuna-7b-v1.5
python download.py

ModelScope 下载模型

使用Git下载模型

# 公开模型下载
sudo apt-get install git-lfs
git clone https://www.modelscope.cn/<namespace>/<model-name>.git
# 例如: git clone https://www.modelscope.cn/damo/ofa_image-caption_coco_large_en.git

使用脚本下载 ModelScope 的模型

❶ 安装 modelscope

pip install modelscope

❷ 编写下载模型脚本 download.py

from modelscope import snapshot_download
snapshot_download("qwen/Qwen1.5-7B-Chat", 
                  cache_dir="Qwen1.5-7B-Chat")

❸ 下载模型

python download.py

✅ 模型格式

Safetensors

ML Safer For All

文件格式

对比

安全

执行任意代码的风险

import pickle
import os

# 定义一个恶意对象，它的 __reduce__ 方法会执行系统命令
class MaliciousObject:
    def __reduce__(self):
        return (os.system, ("echo '这是一个恶意命令'",))

# 序列化恶意对象到 pickle 文件
with open('malicious_pickle.pkl', 'wb') as f:
    pickle.dump(MaliciousObject(), f)

# 反序列化并执行该对象，这将执行 os.system 命令
with open('malicious_pickle.pkl', 'rb') as f:
    malicious_instance = pickle.load(f)

后门风险

# 定义一个包含后门的类
class BackdooredClass:
    def __init__(self):
        print("埋下后门。")

    def trigger_backdoor(self):
        print("后门被触发！执行恶意操作...")

# 序列化后门类实例到 pickle 文件
with open('backdoored_pickle.pkl', 'wb') as f:
    pickle.dump(BackdooredClass(), f)

# 反序列化后门对象
with open('backdoored_pickle.pkl', 'rb') as f:
    backdoor_instance = pickle.load(f)

# 如果调用 trigger_backdoor 方法，后门将被触发
backdoor_instance.trigger_backdoor()

GGUF

快速、量化、跨平台

GGUF 介绍

GGUF 格式的设计目标是实现大型模型的民主化，即使在没有高性能计算资源的情况下，也能够在 CPU 上进行快速推理。GGUF 是一种二进制格式，通过内存映射技术快速加载模型。它是 GGML、GGMF 和 GGJT 的后继文件格式，通过包含加载模型所需的所有信息来确保明确性。 它还被设计为可扩展的，以便可以在不破坏兼容性的情况下将新信息添加到模型中。

• GGML（无版本）：基线格式，没有版本控制或对齐。
• GGMF（版本化）：与 GGML 相同，但具有版本化。
• GGJT：对齐张量以允许与需要对齐的 mmap 一起使用。 v1、v2 和 v3 相同，但后面的版本使用与以前版本不兼容的不同量化方案。

文件格式

HuggingFace GGUF

过滤 Hugging Face 上所有的 GGUF 模型。

HuggingFace TheBloke

TheBloke 上面有大量的大型语言模型，每个模型都有 GGUF、GPTQ、AWQ 等量化方法量化的模型。

• GGUF 有 2, 3, 4, 5, 6 和 8 位的量化模型。

量化方法

Llama2 量化性能

WikiText 数据集

困惑度越小越好
评价语言模型好坏

Perplexity（困惑度）与 model size（模型大小）的关系

模型量化

❶ 构建 [llama.cpp][llama.cpp]

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

make -j

pip install -r requirements.txt

❷ 量化为 GGUF 模型

python convert.py vicuna-7b-v1.5 \
    --outfile vicuna-7b-v1.5.gguf \
    --outtype q8_0

模型下载

REPO_ID=TheBloke/Llama-2-7B-Chat-GGUF
FILENAME=llama-2-7b-chat.Q4_K_M.gguf

huggingface-cli

pip install "huggingface_hub[cli]"

huggingface-cli download ${REPO_ID} ${FILENAME} \
    --local-dir . --local-dir-use-symlinks False

wget

wget https://huggingface.co/${REPO_ID}/resolve/main/${FILENAME}\?download\=true -O ${FILENAME}

✅ Embedding Model

Embedding 概述

嵌入是将概念转换为数字序列的数值表示，这使得计算机能够轻松理解这些概念之间的关系。文本嵌入衡量文本字符串的相关性。将任意文本映射为低维稠密向量，可以用于检索、排序、分类、聚类或语义匹配等任务。

Embedding 的应用

• 搜索（结果按与查询字符串的相关性排名）
• 聚类（文本字符串按相似性分组）
• 推荐（推荐具有相关文本字符串的项目）
• 异常检测（识别出相关性很小的异常值）
• 多样性测量（分析相似性分布）
• 分类（文本字符串按最相似的标签进行分类）

中文 Embedding 模型

🥇 MTEB 排行榜提供了各种任务中最佳文本嵌入模型的整体概览，可以帮助您找到适合各种任务的最佳嵌入模型！

MTEB Leaderboard（排行榜）

• MTEB (Massive Text Embedding Benchmark)
• C-MTEB (Chinese Massive Text Embedding Benchmark)

LangChain 调用 HuggingFace（一）

模型文件中【有】 modules.json

from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(
    model_name='BAAI/bge-base-zh', 
    cache_folder='models/embeddings/', 
    encode_kwargs={'normalize_embeddings': True}
)

LangChain 调用 HuggingFace（二）

模型文件中【没有】 modules.json

❶ 下载 需要先下载模型文件，然后再使用本地缓存加载模型，这样才能不依赖网络。

HuggingFaceEmbeddings(
    model_name='infgrad/stella-base-zh-v2', 
    cache_folder='models/embeddings/'
)

❷ 使用

from langchain.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings(
    model_name='models/embeddings/infgrad_stella-base-zh-v2', 
    encode_kwargs={'normalize_embeddings': True}
)

文本图片 Embedding 模型（一）

openai/clip-vit-base-patch32

from transformers import CLIPProcessor, CLIPModel

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32", cache_dir='cache', local_files_only=True)
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32", cache_dir='cache', local_files_only=True)

def get_image_features(image_path: str):
    image = Image.open(image_path).convert("RGB")
    inputs = processor(images=image, return_tensors="pt", padding=True, truncation=True)
    features = model.get_image_features(**inputs)
    features = features / features.norm(dim=-1, keepdim=True)
    return features.tolist()[0]

def get_text_features(text: str):
    inputs = processor(text=text, return_tensors="pt", padding=True)
    features = model.get_text_features(**inputs)
    features /= features.norm(dim=-1, keepdim=True)
    return features.tolist()[0]

文本图片 Embedding 模型（二）

OFA-Sys/chinese-clip-vit-base-patch16 - 支持中文

from transformers import ChineseCLIPProcessor, ChineseCLIPModel

model = ChineseCLIPModel.from_pretrained(
    "OFA-Sys/chinese-clip-vit-base-patch16", 
    cache_dir='cache', 
    local_files_only=True)
processor = ChineseCLIPProcessor.from_pretrained(
    "OFA-Sys/chinese-clip-vit-base-patch16", 
    cache_dir='cache', 
    local_files_only=True)

文本嵌入数据集

BAAI-MTP (Massive Text Pairs)

M3E 数据集

文本嵌入训练

FlagEmbedding

您可以按照示例在本地数据上微调嵌入模型。

微调 M3E

文本嵌入评估

MTEB (Massive Text Embedding Benchmark)

C-MTEB (Chinese Massive Text Embedding Benchmark)

✅ 本地部署

聊天机器人

llama.cpp

Apple 芯片

• ARM NEON Metal

x86 架构

• AVX AVX2 AVX512

混合 F16 / F32 精度

整数量化

• [2, 3, 4, 5, 6, 8]bits

后端支持

• CUDA Metal OpenCL GPU

构建

❶ 克隆 [llama.cpp][llama.cpp] 仓库

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

❷ make

make -j

❸ 安装依赖

pip install -r requirements.txt

从 TheBloke 下载已转换和量化的 Meta Llama 2 模型

• Llama 2 7B base
• Llama 2 13B base
• Llama 2 70B base
• Llama 2 7B chat
• Llama 2 13B chat
• Llama 2 70B chat

聊天

./main -n 1000 -e -m llama-2-7b-chat.Q4_K_M.gguf -p "糖果的制作步骤"

 糖果的制作步骤

1. 选择优质的糖果：选择高质量的糖果，可以增加糖果的精度和烘培质地。
2. 将糖果隔开：将糖果按照大小和形状分成不同的颜色，这样可以更好地控制糖果的掉落速度和坍塌情况。
3. 淋上糖果：将糖果淋在板子上，确保每个糖果都够好地淋在板子上，这样可以减少糖果的落塌和损坏。
4. 均匀分配：将糖果均匀分配到板子上，确保每个糖果都有相同的大小和形状，这样可以更好地控制糖果的掉落速度和坍塌情况。
5. 烘培：将淋上的糖果晒在烘培机中，设置正确的时间和温度，以便糖果能够完全烘培。
6. 冻结：将烘培后的糖果冻结在冰箱中，以便保存和使用。
7. 预览：可以通过检查糖果的颜色、形状和质地来预览糖果的制作结果。
8. 修正：如果发现糖果的颜色或形状不匹配，可以通过修正糖果的烘培时间和温度来实现修正。

llama-cpp-python

使用 Metal (MPS) 进行安装

CMAKE_ARGS="-DLLAMA_METAL=on" pip install llama-cpp-python
pip install fastapi uvicorn sse-starlette pydantic-settings starlette-context

兼容 OpenAI Web Server

python -m llama_cpp.server --model llama-2-7b-chat.Q4_K_M.gguf --model_alias Llama-2-7B-chat

--model MODEL     The path to the model to use for generating completions. (default: PydanticUndefined)
--model_alias MODEL_ALIAS The alias of the model to use for generating completions.
--n_ctx N_CTX     The context size. (default: 2048)
--host HOST       Listen address (default: localhost)
--port PORT       Listen port (default: 8000)

OpenAPI 文档

• POST /v1/completions
• POST /v1/embeddings
• POST /v1/chat/completions
• GET   /v1/models

更多功能

• Local Copilot replacement
• Function Calling support
• Vision API support

curl 调用 API

POST /v1/completions

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "prompt": "中国的首都是？",
        "temperature": 0.3
    }'

POST /v1/chat/completions

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{ 
        "messages": [ 
            { "role": "user", "content": "中国的首都是？" }
        ]
    }'

GPT4All

GPT4All

下载模型

聊天

基于目录构建本地文档集合

英文 Embedding Model

服务 ❶ 启用 API 服务器

服务 ❷ 打开服务聊天窗口

服务 ❸ 使用 OpenAI API 调用本地服务

import openai

openai.api_base = "http://localhost:4891/v1"
openai.api_key = "EMPTY"

prompt = "你是谁？"
model = "mistral-7b-openorca"

response = openai.Completion.create(
    model=model,
    prompt=prompt,
    max_tokens=50,
    temperature=0.28,
    top_p=0.95,
    n=1,
    echo=True,
    stream=False
)

print(response)
print(response.choices[0].text)

服务 ❹ 调用 API 后的聊天窗口

服务 ❺ 选择本地文档集合

服务 ❻ 使用 OpenAI API 调用本地服务

import openai

openai.api_base = "http://localhost:4891/v1"
openai.api_key = "EMPTY"

prompt = "每月补卡次数"
model = "mistral-7b-openorca"

response = openai.Completion.create(
    model=model,
    prompt=prompt,
    max_tokens=50,
    temperature=0.28,
    top_p=0.95,
    n=1,
    echo=True,
    stream=False
)

print(response)
print(response.choices[0].text)

服务 ❼ 调用 API 后的聊天窗口

Ollama

Ollama

在本地运行大型语言模型。它将模型权重、配置和数据捆绑到一个包中，由 Modelfile 定义。

下载

安装

命令行访问

ollama run llama2

API 访问

curl http://localhost:11434/api/generate -d '{
  "model": "llama2",
  "prompt": "Why is the sky blue?",
  "stream": false
}'

Ollama 的使用

Large language model runner

Usage:
  ollama [flags]
  ollama [command]

Available Commands:
  serve       Start ollama
  create      Create a model from a Modelfile
  show        Show information for a model
  run         Run a model
  pull        Pull a model from a registry
  push        Push a model to a registry
  list        List models
  cp          Copy a model
  rm          Remove a model
  help        Help about any command

OpenAI API Server

ollama cp qwen:14b gpt-3.5-turbo          # 模型别名
ollama serve                              # default "127.0.0.1:11434"
# OLLAMA_HOST=127.0.0.1:8000 ollama serve

curl http://localhost:11434/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "gpt-3.5-turbo",
        "messages": [
            {
                "role": "user",
                "content": "Hello!"
            }
        ]
    }'

• OpenAI compatibility

模型库

Llama 2

👉 下载模型

ollama pull llama2

Llama 2 版本化

使用 Modelfile 创建模型

这里使用了本地的 GGUF 模型进行构建。

❶ Modelfile

From ./TheBloke/Llama-2-7B-chat-GGUF/llama-2-7b-chat.Q4_K_M.gguf

# sets the temperature to 1 [higher is more creative, lower is more coherent]
PARAMETER temperature 1
# sets the context window size to 4096, this controls how many tokens the LLM can use as context to generate the next token
PARAMETER num_ctx 4096

# sets a custom system message to specify the behavior of the chat assistant
SYSTEM You are Mario from super mario bros, acting as an assistant.

❷ 构建模型

ollama create llama2-7b-chat -f Modelfile

Ollama
Web UI

❶ 部署

docker run -d -p 3000:8080 --name ollama-webui \
    --add-host=host.docker.internal:host-gateway \
    --restart always ollama-webui

❷ 访问 http://localhost:3000

LM Studio

LM Studio

发现、下载和运行本地 LLM

聊天

底部 ▼ 推理性能

OpenAI API Server

chat/completions

curl http://localhost:1234/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{ 
        "messages": [ 
            { "role": "system", "content": "Always answer in rhymes." },
            { "role": "user", "content": "Introduce yourself." }
        ], 
        "temperature": 0.7, 
        "max_tokens": -1,
        "stream": false
    }'

llamafile

llamafile

允许您使用单个文件分发和运行 LLM，让用户更容易访问开源大型语言模型。

将 LLM 的所有复杂性压缩为一个可在大多数计算机上本地运行的可执行文件（称为“llamafile”），无需安装。

Server llamafile

❶ 下载 LLaVA（Large Language and Vision Assistant）模型

wget https://huggingface.co/jartine/llava-v1.5-7B-GGUF/resolve/main/llava-v1.5-7b-q4-server.llamafile\?download\=true \
    -O llava-v1.5-7b-q4-server.llamafile

❷ 增加执行权限

chmod +x llava-v1.5-7b-q4-server.llamafile

❸ 启动服务

./llava-v1.5-7b-q4-server.llamafile

您的浏览器应该自动打开

https://localhost:8080

并显示聊天界面 👉

使用图片和文字聊天

将 llamafile 与外部权重一起使用

❶ 下载 llamafile-server

wget https://github.com/Mozilla-Ocho/llamafile/releases/download/0.2.1/llamafile-server-0.2.1 \
    -O llamafile-server
chmod +x llamafile-server

❷ 下载 GGUF 模型

wget https://huggingface.co/TheBloke/blossom-v3-baichuan2-7B-GGUF/resolve/main/blossom-v3-baichuan2-7b.Q4_0.gguf\?download\=true \
    -O blossom-v3-baichuan2-7b.Q4_0.gguf

❸ 启动服务

./llamafile-server -m blossom-v3-baichuan2-7b.Q4_0.gguf

[Chatbox][Chatbox]

设置

聊天

✅ 部署

[vLLM][vLLM]

高吞吐量、内存高效

推理引擎

安装

# (Optional) Create a new conda environment.
conda create -n vllm python=3.9 -y
conda activate vllm

# Install vLLM with CUDA 12.1.
pip install vllm

# Install Flash Attention
MAX_JOBS=4 pip -q install flash-attn --no-build-isolation

• Installation

启动兼容 OpenAI Server

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-7B-Chat

• --host 主机，默认值：0.0.0.0
• --port 端口，默认值：8000
• --served-model-name SERVED_MODEL_NAME 模型别名，如：gpt-3.5-turbo
• --quantization {awq,gptq,squeezellm,None}
• --tensor-parallel-size 张量并行副本的数量，设置为 GPU 数量。默认值：1。
• --dtype {auto,half,float16,bfloat16,float,float32}
• --gpu-memory-utilization 模型执行器的 GPU 内存占比，默认值：0.9。
• --max-model-len 模型上下文长度。

Qwen/Qwen1.5-7B-Chat

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-7B-Chat \
    --served-model-name gpt-3.5-turbo \
    --tensor-parallel-size 2 \
    --dtype=half \
    --max-model-len 14000

• 使用 1 张 T4 卡会出现错误：torch.cuda.OutOfMemoryError: CUDA out of memory.
• --dtype=half T4 不支持 bfloat16，需要使用 float16。T4 GPU 的计算能力（compute capability）为 7.5，而 bfloat16 数据类型仅支持在计算能力至少为 8.0 的 GPU 上。
• 使用 --max-model-len 参数来调整模型上下文长度，最多只能设置为 14000。

GPTQ

Qwen/Qwen1.5-7B-Chat-GPTQ-Int4

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-7B-Chat-GPTQ-Int4 \
    --served-model-name gpt-3.5-turbo \
    --quantization gptq \
    --tensor-parallel-size 2 \
    --dtype=half \
    --gpu-memory-utilization 0.95

• 可以使用环境变量 CUDA_VISIBLE_DEVICES=2,3 来指定使用的 GPU。
• --gpu-memory-utilization 默认为 0.9，这里因为 Qwen1.5 的上下文为 32k，0.9 不能满足，可以通过 --max-model-len 参数来调整模型上下文长度。

AWQ

Qwen/Qwen1.5-7B-Chat-AWQ

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-7B-Chat-AWQ \
    --served-model-name gpt-3.5-turbo \
    --quantization awq \
    --tensor-parallel-size 2 \
    --dtype=half \
    --max-model-len 16384

• --max-model-len 减小模型上下文长度。

Qwen1.5-14B-Chat 量化模型

Qwen1.5-14B-Chat-GPTQ-Int4

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-14B-Chat-GPTQ-Int4 \
    --quantization gptq \
    --max-model-len 2048

Qwen1.5-14B-Chat-AWQ

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen1.5-14B-Chat-AWQ \
    --quantization awq \
    --max-model-len 2048

• 使用 --tensor-parallel-size 参数设置不能大于 1 的值。否则出现错误：ValueError: The input size is not aligned with the quantized weight shape. This can be caused by too large tensor parallel size.
• 1 张 T4 卡最多只能设置 2k 的模型上下文长度。

Qwen1.5-32B-Chat-GPTQ-Int4（调整 PyTorch 的内存分配策略，T4:2）

PYTORCH_CUDA_ALLOC_CONF=max_split_size_mb:64 \
python -m vllm.entrypoints.openai.api_server \
    --model Qwen1.5-32B-Chat-GPTQ-Int4 \
    --served-model-name gpt-3.5-turbo \
    --quantization gptq \
    --gpu-memory-utilization 0.95 \
    --tensor-parallel-size 2 \
    --max-model-len 7000

• 调整 PyTorch 的内存分配策略：通过环境变量 PYTORCH_CUDA_ALLOC_CONF 设置 max_split_size_mb 参数来调整 PyTorch 的内存分配策略，以避免内存碎片化。
• --max-model-len 7000

Qwen1.5-32B-Chat-GPTQ-Int4（eager 模式运行，T4:2）

python -m vllm.entrypoints.openai.api_server \
    --model Qwen1.5-32B-Chat-GPTQ-Int4 \
    --served-model-name gpt-3.5-turbo \
    --quantization gptq \
    --gpu-memory-utilization 0.95 \
    --tensor-parallel-size 2 \
    --max-model-len 12000 \
    --enforce-eager

• 在 eager 模式下，模型的计算会立即执行，而不会被编译为 CUDA graphs。
• --max-model-len 12000

❌ PYTORCH_CUDA_ALLOC_CONF 和 enforce-eager 同时设置没有得到增益

Qwen1.5-32B-Chat-GPTQ-Int4（T4:4）

python -m vllm.entrypoints.openai.api_server \
    --model Qwen1.5-32B-Chat-GPTQ-Int4 \
    --served-model-name gpt-3.5-turbo \
    --quantization gptq \
    --tensor-parallel-size 4

访问服务

• model 参数必须要设置。

Completions

curl http://localhost:8000/v1/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen1.5-7B-Chat",
        "prompt": "天空为什么是蓝色的？",
        "max_tokens": 500,
        "temperature": 0.7
    }'

Chat Completions

curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen1.5-7B-Chat",
        "messages": [
            {"role": "system", "content": "你是一个有用的助手。"},
            {"role": "user", "content": "天空为什么是蓝色的？"}
        ],
        "max-tokens": 500,
        "temperature": 0.7
    }'

总结

• 👍 推荐使用 Chat Completions API。
• Completions API 会出现生成回答的内容后继续生成不相关的内容。
  • 天空为什么是蓝色的，这是一个常见的科学问题，其答案涉及到光的散射和大气的组成。......\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
  • 天空为什么是蓝色的这个问题涉及到光学原理，主要是光的散射机制。......E. 胎先露下降 答案：D边缘性龈炎的临床表现不包括(所属章节：第五章 ，难度：2)
  • 解析：太阳光是由红、橙、黄、绿、蓝、靛、紫七种颜色的光组成，以红光波长最长，紫光波长最短。......可能需要一定的网络知识基础和 C++ 编程经验。
  • 有可能是模型的问题，训练数据集格式与 Completions 不一致。
  • 有可能是 vLLM 服务的问题，未能正确识别结束符。

模型部署参数及性能（🚀 GPTQ > AWQ）

• 灰色代表是默认值，可以不设置。

[FastChat][FastChat]

训练、服务、评估

兼容 OpenAI Server 的分布式多模型服务系统

安装

# 克隆仓库
git clone https://github.com/lm-sys/FastChat
cd FastChat

# 创建虚拟环境
python -m venv env
source env/bin/activate

# 安装
pip install --upgrade pip
pip install -e ".[model_worker,webui]"

# Install Flash Attention (T4 GPU )
MAX_JOBS=4 pip -q install flash-attn --no-build-isolation

启动服务 Controller

python -m fastchat.serve.controller

启动服务 OpenAI API Server

python -m fastchat.serve.openai_api_server --port 8000

启动服务 Model Worker (LLM)

设置 Apple 设备 MPS (Metal Performance Shaders)

Qwen/Qwen-7B-Chat

python -m fastchat.serve.model_worker \
  --model-path Qwen/Qwen-7B-Chat --port 21002 \
  --worker-address http://localhost:21002 \
  --model-names Qwen-7B-Chat,gpt-3.5-turbo \
  --device mps

deepseek-ai/deepseek-llm-7b-chat

python -m fastchat.serve.model_worker \
  --model-path deepseek-ai/deepseek-llm-7b-chat --port 21003 \
  --worker-address http://localhost:21003 \
  --device mps

启动服务 vLLM Worker (LLM)

python -m fastchat.serve.vllm_worker \
  --model-path Qwen/Qwen-7B-Chat \
  --model-names gpt-3.5-turbo \
  --tensor-parallel-size 4

启动服务 Model Worker (Embedding Model)

BAAI/bge-base-zh-v1.5

python -m fastchat.serve.model_worker \
    --model-path BAAI/bge-base-zh-v1.5 --port 21100 \
    --worker-address http://localhost:21100 \
    --model-names bge-base-zh,text-embedding-ada-002 \
    --device mps

Web Server

                         python -m fastchat.serve.gradio_web_server --port 8001

Chatbot Arena

                                 python -m fastchat.serve.gradio_web_server_multi --port 8002

速度测试

Xinference

分布式推理框架

部署 LLM

配置 Chatbox

🍏 MLX

Apple Silicon

ML Array Framework

MLX 介绍

MLX 是一个为 Apple Silicon 芯片上的机器学习研究设计的 array 框架，由 Apple 机器学习研究团队提供。

• 熟悉的 API：MLX 拥有一个与 NumPy 紧密对应的 Python API。MLX 还拥有功能齐全的 C++、C 和 Swift API，这些 API 也紧密地反映了 Python API。MLX 拥有更高级别的包，如 mlx.nn 和 mlx.optimizers，它们的 API 紧密跟随 PyTorch，以简化构建更复杂模型的过程。
• 统一内存：MLX 与其他框架的一个显著区别在于其统一内存模型。MLX 中的数组存在于共享内存中。可以在任何支持的设备类型上执行 MLX 数组的操作，无需数据传输。
• MLX 的设计受到了像 NumPy、PyTorch、Jax 和 ArrayFire 这样的框架的启发。

安装

• pip

pip install mlx
pip install mlx-lm

• conda

conda install -c conda-forge mlx
conda install -c conda-forge mlx-lm

pip install sentence_transformers   # Mistral requires
pip install jinja2                  # Mistral requires
pip install tiktoken                # Qwen requires

生成

• Mistral-7B-Instruct-v0.2

python -m mlx_lm.generate \
    --model mistralai/Mistral-7B-Instruct-v0.2 \
    --prompt "Why is the sky blue?" \
    --max-tokens 500

==========
Prompt: <s>[INST] Why is the sky blue? [/INST]
The sky appears blue due to a phenomenon called Rayleigh scattering. As sunlight reaches Earth's atmosphere, 
it interacts with molecules and particles in the air, causing the scattering of light. Blue light has a 
shorter wavelength and gets scattered more easily than other colors, such as red or yellow, which have longer 
wavelengths. As a result, when we look up at the sky, we predominantly see the blue light that has been 
scattered, giving the sky its familiar blue hue. However, the color of the sky can change depending on the 
time of day, weather conditions, and location, as other factors can influence the type and amount of particles 
in the atmosphere that scatter light.
==========
Prompt: 34.115 tokens-per-sec
Generation: 19.374 tokens-per-sec

• Qwen-7B-Chat

python -m mlx_lm.generate \
    --model Qwen/Qwen-7B-Chat \
    --prompt "Why is the sky blue?" \
    --trust-remote-code \
    --eos-token "<|endoftext|>" \
    --max-tokens 500

对于某些模型（例如 Qwen 和 plamo），分词器要求您启用 trust_remote_code 选项，信任终端中的远程代码。

对于 Qwen 模型，您还必须指定 eos_token。 您可以通过在命令行中传递 --eos-token "<|endoftext|>" 来完成此操作。

量化

• 4-bit

python -m mlx_lm.convert \
    --hf-path mistralai/Mistral-7B-Instruct-v0.2 \
    --quantize

量化后保存到 mlx_model 目录，可以使用参数 --mlx-path 指定保存目录。

mlx_model
├── config.json
├── model.safetensors
├── model.safetensors.index.json
├── special_tokens_map.json
├── tokenizer.json
├── tokenizer.model
└── tokenizer_config.json

量化

• float16

python -m mlx_lm.convert \
    --hf-path mistralai/Mistral-7B-Instruct-v0.2 \
    --mlx-path Mistral-7B-Instruct-v0.2-float16 \
    --dtype float16

量化后的模型可以使用 mlx_lm.generate 运行。

python -m mlx_lm.generate \
    --model mlx_model \
    --prompt "Why is the sky blue?"

速度测试

数据集 WikiSQL

样本格式

{"text": "table: <table_name>
columns: <column_name1>, <column_name2>, <column_name3>
Q: <question>
A: SELECT <column_name2> FROM <table_name> WHERE <>"}

样本示例

{"text": "table: 1-1000181-1\n
columns: State/territory, Text/background colour, Format, Current slogan, Current series, Notes\n
Q: What is the current series where the new series began in June 2011?\n
A: SELECT Current series FROM 1-1000181-1 WHERE Notes = 'New series began in June 2011'"}

上面的示例是一行数据，使用 JSONL 格式存储。

微调（LoRA / QLoRA）

python -m mlx_lm.lora \
    --model mistralai/Mistral-7B-v0.1 \
    --train \
    --data <path_to_data> \
    --iters 600

默认适配器权重保存在 adapters.npz 文件中。您可以使用 --adapter-file 指定输出位置。

数据目录中应该包含 train.jsonl 和 valid.jsonl 文件。

评估

python -m mlx_lm.lora \
    --model mistralai/Mistral-7B-v0.1 \
    --adapter-file adapters.npz \
    --data <path_to_data> \
    --test

计算测试集困惑度。

数据目录中应该包含 test.jsonl 文件。

使用微调模型生成

python -m mlx_lm.generate \
    --model mistralai/Mistral-7B-v0.1 \
    --adapter-file adapters.npz \
    --prompt "Why is the sky blue?"

融合

python -m mlx_lm.fuse \
    --model mistralai/Mistral-7B-v0.1 \
    --adapter-file adapters.npz \
    --save-path fused_model

HTTP 服务

python -m mlx_lm.server \
    --model mistralai/Mistral-7B-Instruct-v0.2

• --host HOST Host for the HTTP server (default: 127.0.0.1)
• --port PORT Port for the HTTP server (default: 8080)
• --adapter-file ADAPTER_FILE

访问模型服务

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
     "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Why is the sky blue?"}
     ],
     "temperature": 0.7,
     "max_tokens": 250
   }'

• HTTP Model Server

微调 Text2SQL 模型

微调方法：LoRA QLoRA

基础模型：mistralai/Mistral-7B-v0.1

微调后的模型：mlx-community/Mistral-7B-v0.1-LoRA-Text2SQL

微调过程

微调模型数据

• LoRA 微调万分之 2.35 模型参数（1.704M / 7243.436M * 10000）。
• QLoRA 微调万分之 13.70 模型参数（1.704M / 1244.041M * 10000）。

评估微调的模型

基于测试集计算困惑度（PPL）和交叉熵损失（Loss）。

• 困惑度（Perplexity, PPL）越低，表示模型对数据的预测越准确。
• 交叉熵损失（Loss）低意味着模型的预测分布与真实分布更接近，反映了模型预测的准确性和可靠性。

微调的模型性能

• 🚀 Generation Tokens/S QLoRA 是 LoRA 的 1.79 倍
• 🚀 Prompt Tokens/S QLoRA 是 LoRA 的 6.87 倍

文本生成 SQL

查询王军建的姓名、年龄、学校信息。

Prompt: table: students
columns: Name, Age, School, Grade, Height, Weight
Q: Query Wang Junjian’s name, age, and school information.
A: 

SELECT Name, Age, School FROM students WHERE Name = 'Wang Junjian'

查询姓名，年龄，学校，年级等信息，条件为姓名等于王军建且年龄小于 20 岁。

"table: students
columns: Name, Age, School, Grade, Height, Weight
Q: Query information such as name, age, school, grade, etc. The condition is 
that the name is equal to Wang Junjian and the age is less than 20 years old.
A: "

SELECT Name, Age, School, Grade 
FROM students 
WHERE Name = 'Wang Junjian' AND Age < 20

统计一下九年级有多少学生（九年级的值是9th）。

table: students
columns: Name, Age, School, Grade, Height, Weight
Q: Count how many students there are in ninth grade.
（The value for ninth grade is 9th.）
A: "

SELECT COUNT(*) FROM students WHERE Grade = '9th'

微调经验

• 有 几百 条数据就可以微调，这里数据集使用了 1000 条。
• step 300 - 500 即可。
• 数据集的格式要根据基础模型的输入格式进行调整。
  • Mistral-7B-v0.1 <s>{q}\n{a}</s>
  • deepseek-coder-7b-instruct-v1.5 <｜begin▁of▁sentence｜>{q}\n{a}<｜end▁of▁sentence｜>
  • TinyLlama-1.1B-Chat-v1.0 <|user|>\n{q}</s>\n<|assistant|>\n{a}
• LoRA 和 QLoRA 的训练时间和内存占用相差不大。
• QLoRA 比 LoRA 微调难。
• QLoRA 的生成速度是 LoRA 的 6 倍多，但模型大小和内存占用都比 LoRA 小。

LLaMA Factory

轻松、高效的 LLM 微调

微调 Llama-2-7b-chat

使用微调的模型聊天

Llama2 会说中文了

MFTCoder

高精度、高效率

多任务 LLM 微调框架

ChatGLM-6B 微调

ChatGLM-6B

• 智谱 AI 和清华大学 KEG 实验室联合发布
• 开源的 62亿 参数、支持中英双语的对话语言模型
• 对话长度支持 8K - 32K
• INT4 量化级别下最低只需 6GB 显存
• 支持 P-tuning v2 的高效参数微调

ChatGLM 系列

P-Tuning v2

• 仅调整 0.1%-3% 的参数，可以达到 100亿 参数模型微调的性能。
  • ChatGLM-6B (13G)
  • P-Tuning v2 (339M)
  • 调整 2.6% 的参数
• 将可训练的连续提示添加到每层的输入中。

数据集

• 电力安全工作规程考试题库
• 考题类型：单选题、多选题、判断题
• 考题数量：7279

训练集数据：

[
  {
    "content": "雷雨天气，需要巡视室外高压设备时，应穿( )，并不准靠近避雷器和避雷针。选项：A. 雨鞋;B. 绝缘靴;C. 橡胶鞋;D. 绝缘鞋;答：",
    "summary": "B. 绝缘靴"
  },
  {
    "content": "在同一电气连接部分用同一张工作票依次在几个工作地点转移工作时，工作负责人应向作业人员交待( )。选项：A. 带电范围;B. 安全措施;C. 检修方案;D. 注意事项;答：",
    "summary": "A. 带电范围;B. 安全措施;D. 注意事项"
  },
  {
    "content": "低压配电装置和低压导线上进行带电工作，使用有绝缘柄的工具时，其外裸的导电部位应采取绝缘措施，防止操作时相间或相对地短路。选项：A. 正确;B. 错误;答：",
    "summary": "A. 正确"
  }
]

训练

bash train.sh

训练损失

代码：绘制训练损失图

import json
import matplotlib.pyplot as plt

# 读取 JSON 数据
with open('angui_trainer_state.json', 'r') as f:
    data = json.load(f)

# 提取 loss 和 step 数据
losses = []
steps = []
for item in data['log_history']:
    if 'loss' in item and 'step' in item:
        losses.append(item['loss'])
        steps.append(item['step'])

# 绘制图形
plt.figure(figsize=(14, 6))
plt.plot(steps, losses)
plt.xlabel('Step')
plt.ylabel('Loss')
plt.title('Training Loss')
plt.savefig('angui-training-loss.png', dpi=100, bbox_inches='tight', pad_inches=0.2)
plt.show()

评估

sh evaluate.sh

• predict_bleu-4 = 7.8867
• predict_rouge-1 = 31.1265
• predict_rouge-2 = 7.0495
• predict_rouge-l = 24.8459

[BLEU][BLEU] 一种基于精确度的相似度量方法，用于分析候选译文中有多少 n 元词组出现在参考译文中（就是在判断两个句子的相似程度） [ROUGE][ROUGE] 一种基于召回率的相似性度量方法，主要考察参考译文的充分性和忠实性，无法评价参考译文的流畅度，它跟 BLEU 的计算方式几乎一模一样，但是 n-gram 词组是从参考译文中产生的。

安规问答机器人

🙋: 高压设备发生接地时，室外人员应距离故障点( )m以外。 选项：A. 2; B. 4; C. 6; D. 8; 🤖: D. 8

🙋: 高压设备发生接地时，室外人员应距离故障点( )m以外。 选项：A. 8; B. 6; C. 4; D. 2; 🤖: A. 8

🙋: 表示设备断开和允许进入间隔的信号、经常接入的电压表等，如果指示有电，在排除异常情况前，禁止在设备上工作。 选项：A. 正确; B. 错误; 🤖: A. 正确

🙋: 值班调控人员或线路工作许可人应将线路停电检修的工作班组数目、( )做好记录。 选项：A. 工作班成员姓名; B. 工作负责人姓名; C. 工作地点; D. 工作任务; 🤖: B. 工作负责人姓名； C. 工作地点； D. 工作任务

学习率（Learning Rate）

微调经验

❶ 数据集

• 数据集使用 [JSON Lines][JSON-Lines] 文本格式，每行是一个 JSON 对象，包含 content 和 summary 两个字段。

  {"content": "高压设备发生接地时，室内人员应距离故障点( )m以外。选项：A. 1;B. 2;C. 3;D. 4;", "summary": "D. 4"}
  {"content": "使用金属外壳的电气工具时应戴( )。选项：A. 线手套;B. 绝缘手套;C. 口罩;D. 护目眼镜;", "summary": "B. 绝缘手套"}
  {"content": "设备通电前，应验证供电线缆( )。选项：A. 输入电流;B. 负载;C. 极性;D. 输入电压;", "summary": "C. 极性;D. 输入电压"}
  {"content": "在电力通信系统上工作，保证安全的技术措施有( )。选项：A. 停电;B. 验电;C. 授权;D. 验证;", "summary": "C. 授权;D. 验证"}
  {"content": "高压电气设备都应安装完善的防误操作闭锁装置。选项：A. 正确;B. 错误;", "summary": "A. 正确"}
  {"content": "在带电作业过程中如设备突然停电，作业人员可转为停电作业。选项：A. 正确;B. 错误;", "summary": "B. 错误"}
  

• 生成数据集时，需要回答的位置使用 ___, ( ), [ ] 等标记都可以，主要是让模型知道那是需要回答的位置即可。

❷ 推理参数

• temperature=0.1
  • 采样温度，控制输出的随机性，必须为正数
  • 取值范围是：(0.0,1.0]，不能等于 0,默认值为 0.95
  • 值越大，会使输出更随机，更具创造性；值越小，输出会更加稳定或确定
• top_p=0.9
  • 用温度取样的另一种方法，称为核取样
  • 取值范围是：(0.0, 1.0) 开区间，不能等于 0 或 1，默认值为 0.7
  • 模型考虑具有 top_p 概率质量 tokens 的结果
  • 例如：0.1 意味着模型解码器只考虑从前 10% 的概率的候选集中取 tokens
• 建议您根据应用场景调整 top_p 或 temperature 参数，但不要同时调整两个参数
• 不能使用多轮会话模式推理，多余的上下文信息导致模型无法正确回答问题。

❸ 训练参数

• 训练参数 max_steps 的设置，Epoch 一般设置 3-5。

                                       Epoch * 训练集大小
  max_steps = ----------------------------------------------------------------------
              per_device_train_batch_size * num_device * gradient_accumulation_steps
  

• 提示长度（Prompt Length） pre_seq_len 的设置。
  • 简单的分类任务更喜欢较短的提示（少于 20）；
  • 比较难的序列标记任务更喜欢较长的提示（大约 100）。
• 学习率 learning_rate 的设置，1e-3 是个不错的开始，太大容易丢失模型的知识，太小需要训练时间又太长。
• 根据您的数据集中的最大输入长度和输出长度调整训练参数 max_source_length 和 max_target_length。

✅ 智能编码助手

代码模型排行榜

Tabby (Apple Silicon)

安装 Tabby

brew install tabbyml/tabby/tabby

运行 Tabby 服务

tabby serve --model TabbyML/DeepseekCoder-1.3B \
            --device metal

Tabby (Docker)

docker run -d --gpus all --name tabby \
    -p 8080:8080 \
    -v ~/.tabby:/data tabbyml/tabby \
    serve --model TabbyML/DeepseekCoder-1.3B \
    --device cuda

JetBrains IDEs

CodeGPT 安装

CodeGPT 菜单

      参数配置 👉

模型 (DeepSeek Coder-7B)

模型 (Llama 2-7B)

                                📌

模型 (gpt-3.5-turbo)

模型 (gpt-4-32k)

生成代码

生成测试

修改 Bug & 优化

代码翻译

Tabby 安装

Tabby 设置

Tabby 代码生成

CodeGPT AI 聊天

✅ 文本生成图像

Stable Diffusion

安装

git clone https://github.com/ml-explore/mlx-examples
cd mlx-examples/stable_diffusion

pip install -r requirements.txt

推理

python txt2image.py \
    "A photo of an astronaut riding a horse on Mars." \
    --n_images 4 --n_rows 2

✅ 语音识别

[whisper.cpp][whisper.cpp]

• 多语言语音识别
• 语音翻译
• 语言识别

编译 & 下载模型

编译

make

下载模型

bash ./models/download-ggml-model.sh base.en
bash ./models/download-ggml-model.sh base

功能

语音识别

./main -f samples/jfk.wav

语音识别（其它语言）

./main -m models/ggml-base.bin -f samples/chinese.wav -l auto

语音翻译到英文

./main -m models/ggml-base.bin -f samples/chinese.wav -l auto -tr

SeamlessM4T

大规模多语言和多模态

机器翻译

SeamlessM4T 支持的任务

• ASR: Automatic speech recognition for 96 languages.
• S2ST: Speech-to-Speech translation from 100 source speech languages into 35 target speech languages.
• S2TT: Speech-to-text translation from 100 source speech languages into 95 target text languages.
• T2ST: Text-to-Speech translation from 95 source text languages into 35 target speech languages.
• T2TT: Text-to-text translation (MT) from 95 source text languages into 95 target text languages.

搭建环境

git clone https://github.com/facebookresearch/seamless_communication
cd seamless_communication

conda create -n seamless-m4t python==3.10.9 -y
conda activate seamless-m4t

conda install -c conda-forge libsndfile==1.0.31 -y

pip install .
pip install gradio

设置环境变量

conda env config vars set PYTORCH_ENABLE_MPS_FALLBACK=1
conda env config vars set CHECKPOINTS_PATH=seamless-m4t-v2-large

命令行 m4t_predict

S2ST

m4t_predict <path_to_input_audio> --task s2st --tgt_lang <tgt_lang> --output_path <path_to_save_audio>

T2TT

m4t_predict <input_text> --task t2tt --tgt_lang <tgt_lang> --src_lang <src_lang>

T2ST

CHINESE_TEXT="荷兰发布了一份主题为“宣布即将对先进半导体制造设备采取的出口管制措施”的公告表示，鉴于技术的发展和地缘政治的背景，政府已经得出结论，有必要扩大现有的特定半导体制造设备的出口管制。"
m4t_predict $CHINESE_TEXT --task t2st --src_lang cmn --tgt_lang cmn --output_path chinese.wav

Web UI python demo/m4tv2/app.py http://127.0.0.1:7860

✅ 语音合成

Coqui TTS

Mozilla TTS

✅ 工具

LLM 速度测试

安装依赖

pip install typer
pip install openai==0.28

使用

Usage: llm-speed-test.py [OPTIONS]

Options:
  --api-base TEXT                 [default: http://127.0.0.1:8000/v1]
  --api-key TEXT                  [default: NULL]
  --prompt TEXT                   [default: 你是谁]
  --model TEXT                    [default: gpt-3.5-turbo]
  --max-tokens INTEGER            [default: 256]
  --temperature FLOAT             [default: 0.7]
  --top-p FLOAT                   [default: 0.95]

llm-speed-test.py

import time
import openai
import typer

app = typer.Typer()

@app.command()
def main(api_base: str = 'http://127.0.0.1:8000/v1',
         api_key: str = 'NULL',
         prompt: str = '你是谁',
         model: str = 'gpt-3.5-turbo',
         max_tokens: int = 256,
         temperature: float = 0.7,
         top_p: float = 0.95):
    openai.api_base = api_base
    openai.api_key = api_key

    begin_time = time.time()
    response = openai.Completion.create(
        model=model,
        prompt=prompt,
        max_tokens=max_tokens,
        temperature=temperature,
        top_p=top_p
    )
    end_time = time.time()

    text = response.choices[0].text
    prompt_tokens = response.usage.prompt_tokens
    total_tokens = response.usage.total_tokens
    completion_tokens = response.usage.completion_tokens

    print(f'🧑 {prompt}')
    print(f'🤖 {text}')
    print(f'🚀 每秒生成 Tokens: {completion_tokens/(end_time-begin_time):.2f} \t \
          合计 Tokens （{total_tokens}） = 输入 Tokens（{prompt_tokens}） + 输出 Tokens（{completion_tokens}）')
    print(f'🚀 每秒生成字符   : {len(text)/(end_time-begin_time):.2f} \t 合计生成字符（{len(text)}）')
    print(f'⏱️ 生成耗时: {(end_time-begin_time):.2f} 秒')

if __name__ == "__main__":
    app()

录制音频文件

• 打开 QuickTimePlayer
• 菜单：文件 ► 新建音频录制
• 录制
• 朗读
• 停止
• 保存（filename.m4a）

转换音频文件

m4a 转换 wav

ffmpeg -i filename.m4a -ar 16000 -ac 1 -c:a pcm_s16le filename.wav

tcpdump 监听网络端口

实时监听 8100 端口

sudo tcpdump -i any -A 'tcp port 8100 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)'

12:03:00.289264 IP 172.26.0.4.34572 > gpu1.8100: Flags [P.], seq 3010033875:3010035264, ack 2688150008, win 502, options [nop,nop,TS val 4185566950 ecr 2900078142], length 1389
E.....@.@.........!B.....ix..9.............
.z.....>POST /v1/chat/completions HTTP/1.1
{
  "model": "chatglm3-6b",
  "temperature": 0,
  "messages": [
    {
      "role": "user",
      "content": ".....................JSON......"
    }
  ],

显示非 ASCII 码（如：中文）-w -

sudo tcpdump -i any -A 'tcp port 8100 and (((ip[2:2] - ((ip[0]&0xf)<<2)) - ((tcp[12]&0xf0)>>2)) != 0)' -w -

      "content": "使用会议室生成JSON格式"

杀进程

sudo kill -9 $(pgrep -f fastchat)

• kill：这是一个用于发送信号到进程的命令。默认情况下，kill 命令发送的是 TERM（终止）信号，这会请求进程自行结束。
  • -9：这是一个信号的编号，代表 KILL 信号。KILL 信号会立即结束进程，进程无法忽略这个信号或者对其进行处理。因此，kill -9 通常只在其他方法无效时才使用。
• pgrep 命令用于查找匹配给定模式的进程的 PID（进程 ID）。
  • -f 选项表示匹配整个命令行，而不仅仅是命令名。

查看使用指定端口的进程详细信息

sudo lsof -i:11434

COMMAND   PID    USER   FD   TYPE             DEVICE SIZE/OFF NODE NAME
ollama  87159 junjian    3u  IPv4 0xa1cf5c146b53c033      0t0  TCP localhost:11434 (LISTEN)

谢 谢 ！