---
title: 大模型
date: 2025-02-18 10:06:57
tags: [AI, 大模型, Ollama, LLM]
categories: [AI, 大模型]
---

# Ollama

## 1. 安装

首先需要下载并安装Ollama，这是运行模型的基础环境。



![image-20250218102658870](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250218102658870.png)

## 2. 下载模型

打开命令行终端，根据需要运行以下命令之一来下载对应版本的模型：

![image-20250218104847668](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250218104847668.png)

以DeepSeek为例：

7B 版本（推荐显存 8G）:

```bash
ollama pull deepseek-coder:7b
```

8B 版本（推荐显存 8G）:

```bash
ollama run huihui_ai/deepseek-r1-abliterated:8b
```

14B 版本（推荐显存 12G）:

```BASH
ollama run huihui_ai/deepseek-r1-abliterated:14b
```

32B 版本（推荐显存 32G）:

```bash
ollama run huihui_ai/deepseek-r1-abliterated:32b
```

70B 版本（需要高端显卡支持）:

```bash
ollama run huihui_ai/deepseek-r1-abliterated:70b
```

## 3. Ollama 常用命令

在使用 Ollama 时，以下是一些常用的命令操作：

```bash
# 启动 Ollama 服务
ollama serve

# 从 Modelfile 创建模型
ollama create <模型名称>

# 显示模型信息
ollama show <模型名称>

# 运行模型
ollama run <模型名称>

# 停止运行中的模型
ollama stop <模型名称>

# 从仓库拉取模型
ollama pull <模型名称>

# 推送模型到仓库
ollama push <模型名称>

# 列出所有已安装的模型
ollama list

# 列出正在运行的模型
ollama ps

# 复制模型
ollama cp <源模型> <目标模型>

# 删除模型
ollama rm <模型名称>

# 显示模型文件
ollama show --modelfile <模型名称>
```

## 4. Ollama模型存储目录

- macOS: `~/.ollama/models`
- Linux: `/usr/share/ollama/.ollama/models`
- Windows: `C:\Users\%username%\.ollama\models`

### 如何将它们设置为不同的位置？

如果需要使用不同的目录，可以将环境变量 `OLLAMA_MODELS` 设置为你选择的目录。

> 注意：在 Linux 上使用标准安装程序时，`ollama` 用户需要对指定目录有读写权限。要将目录分配给 `ollama` 用户，请运行 `sudo chown -R ollama:ollama <directory>`.

请参考[上面的部分](https://ollama.readthedocs.io/faq/#how-do-i-configure-ollama-server)了解如何在你的平台上设置环境变量。

![image-20250218132430850](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250218132430850.png)

## 5. WSL中Ollama使用Windows中的

```shell
# 编辑环境变量
vim /etc/profile

# 文件末尾添加
export PATH="$PATH:/mnt/c/Program Files/Ollama"
alias ollama='ollama.exe'
```

# nvidia

## cuda-toolkit



### 下载 **CUDA Toolkit Installer**

#### AlmaLinux

```shell
wget https://developer.download.nvidia.com/compute/cuda/12.8.1/local_installers/cuda-repo-rhel9-12-8-local-12.8.1_570.124.06-1.x86_64.rpm
sudo rpm -i cuda-repo-rhel9-12-8-local-12.8.1_570.124.06-1.x86_64.rpm
sudo dnf clean all
sudo dnf -y install cuda-toolkit-12-8
```

#### Ubuntu

```shell
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2404/x86_64/cuda-ubuntu2404.pin
sudo mv cuda-ubuntu2404.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/12.9.1/local_installers/cuda-repo-ubuntu2404-12-9-local_12.9.1-575.57.08-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu2404-12-9-local_12.9.1-575.57.08-1_amd64.deb
sudo cp /var/cuda-repo-ubuntu2404-12-9-local/cuda-*-keyring.gpg /usr/share/keyrings/
sudo apt-get update
sudo apt-get -y install cuda-toolkit-12-9
```

### 安装 **Driver Installer**

#### 专有驱动

```shell
sudo apt-get install -y cuda-drivers
```

安装好后，需重启系统才可应用上。

```shell
sudo reboot
```

### 配置环境变量

```shell
vim ~/.bashrc

# 文件末尾添加
# cuda 10.2
export CUDA_HOME=/usr/local/cuda
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64
export PATH=$PATH:$CUDA_HOME/bin
```

## NVIDIA Container Toolkit

### 下载

#### With `apt`: Ubuntu, Debian

国内镜像源安装：

```shell
curl -fsSL https://mirrors.ustc.edu.cn/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg

curl -s -L https://mirrors.ustc.edu.cn/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
sed 's#deb https://nvidia.github.io#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://mirrors.ustc.edu.cn#g' | \
sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list

sudo apt-get update

sudo apt-get install -y nvidia-container-toolkit

nvidia-container-cli --version

sudo systemctl restart docker
```



## nvidia-smi

> nvidia-smi是nvidia 的系统管理界面 ，其中smi是System management interface的缩写，它可以收集各种级别的信息，查看显存使用情况。此外, 可以启用和禁用 GPU 配置选项 (如 ECC 内存功能)。

```shell
nvidia-smi

+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 570.86.09              Driver Version: 571.96         CUDA Version: 12.8     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA RTX 4000 Ada Gene...    On  |   00000000:01:00.0 Off |                  Off |
| N/A   50C    P8              7W /   85W |    4970MiB /  12282MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI              PID   Type   Process name                        GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|    0   N/A  N/A           16221      C   /python3.12                           N/A      |
+-----------------------------------------------------------------------------------------+

```

解释相关参数含义：

GPU：本机中的GPU编号

Name：GPU 类型

Persistence-M：

Fan：风扇转速

Temp：温度，单位摄氏度

Perf：表征性能状态，从P0到P12，P0表示最大性能，P12表示状态最小性能

Pwr:Usage/Cap：能耗表示

Bus-Id：涉及GPU总线的相关信息；

Disp.A：Display Active，表示GPU的显示是否初始化

Memory-Usage：显存使用率

Volatile GPU-Util：浮动的GPU利用率

Uncorr. ECC：关于ECC的东西

Compute M.：计算模式

Processes 显示每块GPU上每个进程所使用的显存情况。

### 持续监控

```shell
# 使用 watch 命令，它可以定时执行指定的命令并刷新输出。例如，每隔 1 秒刷新一次 GPU 状态，可以使用以下命令
watch -n 1 nvidia-smi
```

## nvidia-smi -L

```shell
#  列出所有可用的 NVIDIA 设备
nvidia-smi -L
GPU 0: NVIDIA RTX 4000 Ada Generation Laptop GPU (UUID: GPU-9856f99a-c32c-fe63-b2ad-7bdee2b12291)
```

# ModelScope

## 模型下载

### 安装

```shell
pip install modelscope
```

### 命令行下载

```shell
# 下载完整模型库
modelscope download --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B
# 下载单个文件到指定本地文件夹（以下载README.md到当前路径下“dir”目录为例）
modelscope download --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B README.md --local_dir ./dir
```

#### 指定下载单个文件(以'tokenizer.json'文件为例)

```
modelscope download --model 'Qwen/Qwen2-7b' tokenizer.json
```

#### 指定下载多个个文件

```
modelscope download --model 'Qwen/Qwen2-7b' tokenizer.json config.json
```

#### 指定下载某些文件

```
modelscope download --model 'Qwen/Qwen2-7b' --include '*.safetensors'
```

#### 过滤指定文件

```
modelscope download --model 'Qwen/Qwen2-7b' --exclude '*.safetensors'
```

#### 指定下载cache_dir

```
modelscope download --model 'Qwen/Qwen2-7b' --include '*.json' --cache_dir './cache_dir'
```

模型文件将被下载到`'cache_dir/Qwen/Qwen2-7b'`。

#### 指定下载local_dir

```
modelscope download --model 'Qwen/Qwen2-7b' --include '*.json' --local_dir './local_dir'
```

模型文件将被下载到`'./local_dir'`。

如果`cache_dir`和`local_dir`参数同时被指定，`local_dir`优先级高，`cache_dir`将被忽略。

### 环境变量配置

#### 默认下载目录

指定`modelscope`默认下载目录为`/AI/modelscope/hub`

```bash
echo 'export MODELSCOPE_CACHE=/AI/modelscope/hub' >> ~/.bashrc
```

# hugging face

## 模型下载

### 安装

`conda` 创建虚拟环境

```bash
conda create -n hf-mirror python=3.12
```

`conda` 激活虚拟环境

```bash
conda activate hf-mirror
```

安装包

```bash
pip install -U "huggingface_hub"
```

### 命令行下载

### Download a single file

```bash
hf download cyankiwi/Nemotron-Orchestrator-8B-AWQ-8bit --local-dir /AI/hf/models/cyankiwi/Nemotron-Orchestrator-8B-AWQ-8bit
```

-

# Code-forge

![在这里插入图片描述](https://rustfs.wenyongdalucky.club:443/hexo/cf0364a3ad694f1d8ac6ba97e005c238.png)

**先说结论（适用于企业/商用环境）**

- **Anaconda（defaults 源）不能免费商用**：在公司/商业场景下使用 Anaconda 的默认源通常需要付费许可。
- **Miniconda + conda-forge 能用，但要彻底移除 defaults，并避免在 base 开发**：否则仍可能触发 Anaconda 许可风险。
- **最稳妥方案：Miniforge + conda-forge**：安装即默认使用 conda-forge，规避 defaults，合规且轻量。

> 简单理解：不是“conda 这款工具”收费，而是“使用 Anaconda/Defaults 源的二进制分发”涉及商业许可；改用 **conda-forge** 社区源即可规避许可问题。

## 彻底卸载现有 Anaconda/Miniconda

> 目标：清掉默认源、配置与 shell 残留，避免后续“误连 defaults”。

1. 查看 conda 安装路径（含各环境）

    ```bash
    conda info --base
    ```

2. 删除用户侧配置与缓存

    ```bash
    rm -rf ~/.condarc ~/.conda ~/.continuum
    ```

3. 清理 shell 初始化残留

    在 `~/.bashrc`、`~/.bash_profile`、`~/.zshrc` 中搜索并删除与 `conda init`、`anaconda` 相关的初始化片段，保存后重新加载：

    ```bash
    source ~/.zshrc # 或 source ~/.bashrc
    ```

1. Windows 清理（如之前安装过 Anaconda/Miniconda）

    - 通过“应用和功能”卸载 Anaconda/Miniconda。
    - 删除用户目录：`C:\\Users\\<你的用户名>\\.conda`、`C:\\Users\\<你的用户名>\\.continuum`、`C:\\Users\\<你的用户名>\\.condarc`（若存在）。
    - 检查“环境变量”中与 Anaconda/Miniconda 相关的 Path 条目并移除。

## 安装 Miniforge

> Miniforge 默认只使用 conda-forge，装好即合规、可商用。

- 发布页（选择你的平台与架构）：
  `https://github.com/conda-forge/miniforge/releases`

### macOS/Linux检查

```bash
conda list --show-channel-urls | grep -v "^#" | awk '{print $4}' | sort | uniq -c
```

![image-20251202155105034](https://rustfs.wenyongdalucky.club:443/hexo/image-20251202155105034.png)

### Windows检查

```powershell
conda list --show-channel-urls | Where-Object {
$_ -notmatch '^#'
} | ForEach-Object {
($_ -split '\s+')[3]
} | Sort-Object | Group-Object | Select-Object Count,Name
```

![image-20251202155140771](https://rustfs.wenyongdalucky.club:443/hexo/image-20251202155140771.png)

到这里，「Miniforge」+「conda-forge」的安装就`已经完成了`！因为「Miniforge」`默认的就是「conda-forge」源`。

## 将通道固定为 conda-forge（严格优先）

> 如果你此前用过 Miniconda，请务必执行本小节以彻底规避 defaults。

```bash
# 移除 defaults（如不存在会提示，无妨）
conda config --remove channels defaults || true
# 仅使用 conda-forge，并设置严格优先级
conda config --add channels conda-forge
conda config --set channel_priority strict
# 查看当前配置
conda config --show | sed -n '/channels:/,/^$/p'
```

建议：不要在 `base` 环境中开发，创建独立环境更干净：

```bash
conda create -n ai python=3.11 -y
conda activate ai
```

## 验证是否仍引用 Anaconda 源

> 下面的命令会统计当前环境中每个包来自哪个 channel，方便确认是否“纯 conda-forge”。

macOS/Linux：

```bash
conda list --show-channel-urls | grep -v "^#" | awk '{print $4}' | sort | uniq -c
```

Windows：

```powershell
conda list --show-channel-urls | Where-Object {
$_ -notmatch '^#'
} | ForEach-Object {
($_ -split '\s+')[3]
} | Sort-Object | Group-Object | Select-Object Count,Name
```

若输出仅包含 `conda-forge`，说明你的环境是合规的；若还出现 `defaults`/`anaconda`，请返回第三节重新清理并创建新环境。

## 常见问题（FAQ）

- Q：Miniconda + conda-forge 能不能商用？
  A：可以，但务必移除 `defaults`，并新建环境后再安装依赖。历史 `base` 或旧环境中若残留来自 `defaults` 的包，仍可能存在许可风险。更稳妥的做法是直接使用 **Miniforge**。

- Q：为什么不在 base 环境开发？
  A：base 常被用于初始化与管理，历史上最容易“混入” defaults 包。独立环境可保证依赖与渠道的可控性与可复现性。

- Q：国内下载慢怎么办？
  A：可配置 conda-forge 的国内镜像（如清华镜像站），并保持 `channel_priority strict`，避免回落到 defaults。

- Q：已有项目如何迁移？
  A：导出依赖、切换通道、重建环境：

  ```bash
  conda env export --from-history > env.yml
  # 按第三节配置通道为 conda-forge 后
  conda env create -n ai-new -f env.yml
  conda activate ai-new
  ```

## 参考命令清单（便捷复用）

```bash
# 卸载相关（macOS/Linux）
conda info --base
rm -rf ~/.condarc ~/.conda ~/.continuum
# Miniforge 安装（示例）
curl -LO https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-MacOSX-arm64.sh
bash Miniforge3-MacOSX-arm64.sh -b -p $HOME/miniforge3
source "$HOME/miniforge3/bin/activate" && conda init zsh &&
exec $SHELL
# 仅使用 conda-forge（严格优先）
conda config --remove channels defaults || true
conda config --add channels conda-forge
conda config --set channel_priority strict
# 创建与使用环境
conda create -n ai python=3.11 -y
conda activate ai
```

# Anaconda

>

## 安装

### minicoda

[安装 Miniconda — Anaconda 文档](https://docs.anaconda.net.cn/miniconda/install/)

```shell
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash ~/Miniconda3-latest-Linux-x86_64.sh
source ~/.zshrc
```

## 常用命令

### 管理环境

1. 列出所有的环境
   ```shell
   conda env list
   ```



2. 查看conda下的包
   ```she
   conda list
   ```

3. 创建环境
   ```shell
   conda create -n env-name [list of package]
   ```

   -n env-name 是设置新建环境的名字，list of package 是可选项，选择要为该环境安装的包
   如果我们没有指定安装python的版本，conda会安装我们最初安装conda所装的那个版本的python
   若创建特定python版本的包环境，需键入

   ```shell
   conda create -n env-name python=3.6

4. 激活环境
   ```shell
   conda activate env-name
   ```

   切换到base环境
   ```shell
   conda activate base
   ```

5. 删除环境
   执行以下命令可以将该指定虚拟环境及其中所安装的包都删除。

   ```shell
   conda remove --name env_name --all
   ```

   如果只删除虚拟环境中的某个或者某些包则是：
   ```shell
   conda remove --name env_name  package_name
   ```




## 问题

1. conda激活[虚拟环境](https://so.csdn.net/so/search?q=虚拟环境&spm=1001.2101.3001.7020)，只显示环境名称，不再显示用户名和当前文件夹

   ```shell
   #在个人环境下修改
   conda activate gatkenv

   conda env config vars set PS1='($CONDA_DEFAULT_ENV)[\u@\h \W]$'
   #重启环境就ok了

   conda deactivate

   conda activate gatkenv

   #在所有的虚拟环境下修改，这个命令的意思是在~/.condarc下添加一行

   conda config --set env_prompt "({default_env})[\u@\h \W]$"

   #取消设置

   conda config --remove-key env_prompt
   ```



2. conda 安装后没有将conda置为默认

   ```shell
   Do you wish to update your shell profile to automatically initialize conda?
   This will activate conda on startup and change the command prompt when activated.
   If you'd prefer that conda's base environment not be activated on startup,
      run the following command when conda is activated:

   conda config --set auto_activate_base false

   You can undo this by running `conda init --reverse $SHELL`? [yes|no]
   [no] >>>

   You have chosen to not have conda modify your shell scripts at all.
   To activate conda's base environment in your current shell session:

   eval "$(/home/user/miniconda3/bin/conda shell.YOUR_SHELL_NAME hook)"

   To install conda's shell functions for easier access, first activate, then:

   conda init

   Thank you for installing Miniconda3!

   ```

   则执行以下shell

   ```shell
   # eval "$(/home/user/miniconda3/bin/conda shell.SHELL_NAME hook)"
   # bash 下
   eval "$(/home/user/miniconda3/bin/conda shell.bash hook)"
   conda init
   # zsh 下
   eval "$(/home/user/miniconda3/bin/conda shell.zsh hook)"
   conda init
   ```

3. conda和pip换镜像源

   修改conda，通过以下命令进行添加

   ```lua
   conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/free/
   conda config --add channels https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main/
   conda config --set show_channel_urls yes
   ```

   修改后可以通过以下命令查看：

   ```armasm
   conda info
   ```

   下载试试：如果两都能看到下载源，那么就更改成功。

   ```mipsasm
   conda install
   ```

   ##### Linux系统下:

   linux系统下要到用户的文件夹下新建目录.pip，并在目录新建配置文件pip.conf

   ```bash
   mkdir ~/.pip
   cd ~/.pip
   vi pip.conf
   ```

   编辑内容：

   ```ini
   [global]
   index-url=https://pypi.tuna.tsinghua.edu.cn/simple
   [install]
   trusted-host=pypi.tuna.tsinghua.edu.cn
   disable-pip-version-check = true
   timeout = 6000
   ```

   下载试试：

   ```bash
   pip install
   ```

# Jupyter Notebook

>

## 全局

### 安装

```shell
pip install jupyter
```

### 运行

```shell
jupyter notebook
# 若是root用户执行，会出现警告 Running as root is not recommended. Use --allow-root to bypass. 需在后面加上 --allow-root
jupyter notebook --allow-root
```

## Conda 虚拟环境

### 安装

#### 使用 nb_conda_kernels 添加所有环境

```bash
conda activate my-conda-env    # this is the environment for your project and code
conda install ipykernel
conda deactivate

conda activate base      # could be also some other environment
conda install nb_conda_kernels
jupyter notebook
```

#### 配置密码（适用于 Jupyter 7+ / JupyterLab 4+）

在 安装有 jupyter 包的终端中运行

```bash
jupyter server password
```

然后按提示输入并确认密码。
Jupyter 会自动将加密后的密码写入配置文件（通常是 `~/.jupyter/jupyter_server_config.json`）。

#### 生成并编辑配置文件

**生成配置文件**（如果还没有）：

```bash
jupyter notebook --generate-config
```

（对于新版本）：

```bash
jupyter server --generate-config
```

**编辑配置文件**（通常是 `~/.jupyter/jupyter_server_config.py` 或 `jupyter_notebook_config.py`）

```python
c = get_config()

# 允许远程访问
c.ServerApp.ip = '0.0.0.0'  # 注意：新版本用 ServerApp 而非 NotebookApp

# 禁用自动打开浏览器
c.ServerApp.open_browser = False

# 设置端口（可选）
c.ServerApp.port = 8888

# （可选）设置工作目录
c.ServerApp.root_dir = '/path/to/your/notebooks'

# （可选）允许通过 token 或密码登录（设了密码后 token 会失效）
c.ServerApp.token = ''  # 禁用 token（如果已设密码）
c.ServerApp.password_required = True
```

>  🔔注意：**Jupyter 新版本中 `NotebookApp` 已被 `ServerApp` 取代**，所以配置项要使用 `c.ServerApp.xxx`。

### 启动 Jupyter

```bash
jupyter notebook --ip=0.0.0.0 --port=5600 --no-browser
```

或直接：

```bash
jupyter lab --ip=0.0.0.0 --port=5600 --no-browser
```

### 注册服务

#### 创建 systemd 服务文件

创建服务文件（以用户 `user` 为例，替换为你的实际用户名）：

```bash
sudo vim /etc/systemd/system/jupyter-lab.service
```

内容如下（**关键：使用绝对路径 + conda run**）：

```ini
[Unit]
Description=Jupyter Lab Service
After=network.target

[Service]
Type=simple
User=user
WorkingDirectory=/home/user
Environment=PATH=/home/user/miniforge3/envs/jupyter-env/bin:/home/user/miniforge3/condabin:/usr/local/bin:/usr/bin:/bin
ExecStart=/home/user/miniforge3/envs/jupyter-env/bin/jupyter lab --ip=0.0.0.0 --port=7745 --no-browser
Restart=on-failure
RestartSec=5
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target
```

#### 重载 systemd 并启用服务

```bash
# 重载 systemd 配置
sudo systemctl daemon-reload

# 启动服务
sudo systemctl start jupyter-lab

# 设置开机自启
sudo systemctl enable jupyter-lab

# 查看状态和日志
sudo systemctl status jupyter-lab
journalctl -u jupyter-lab -f
```



# UV

**优点：**

- 极快的速度（比 pip 快 10-100 倍）
- 自动管理 Python 版本
- 内置虚拟环境管理
- 现代化工具，Rust 编写
- 无需单独安装 Python

## 安装

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

## 创建项目并自动安装 Python

```bash
uv init myproject
cd myproject
uv python install 3.12  # 自动下载安装 Python 3.12
uv venv  # 创建虚拟环境
source .venv/bin/activate
```

## 安装包（使用 pyproject.toml）

```bash
# 创建项目
uv init langchain-project
cd langchain-project

# 添加依赖
uv add langchain==1.0.0
uv add langchain-core==1.0.0
uv add langchain-community==1.0.0
uv add langchain-openai  # 可选
```



# UnSloth

# vLLM

## 安装

```shell
conda create -n vLLM python=3.12
conda activate vLLM
pip install vLLM

# FlashInfer is optional but required for specific functionalities such as sliding window attention with Gemma 2.
# For CUDA 12.4 & torch 2.4 to support sliding window attention for gemma 2 and llama 3.1 style rope
pip install flashinfer -i https://flashinfer.ai/whl/cu124/torch2.4
# For other CUDA & torch versions, please check https://docs.flashinfer.ai/installation.html
# 也可下载到本地
wget https://github.com/flashinfer-ai/flashinfer/releases/download/v0.2.5/flashinfer_python-0.2.5+cu124torch2.6-cp38-abi3-linux_x86_64.whl#sha256=43d767b912c0c43a04be99595e0123eab9385fc72530a2874b5fb08e3145c0be
pip install flashinfer_python-0.2.5+cu124torch2.6-cp38-abi3-linux_x86_64.whl --no-deps
```

## 部署

### deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B

```shell
CUDA_VISIBLE_DEVICES=0 vllm serve /mnt/e/modelscope/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B --port 8102 --max-model-len 2048 --api-key token-abc123
```

- CUDA_VISIBLE_DEVICES=0: 指定使用的 GPU 设备 ID。 0 表示使用第一块 GPU。如果您有多块 GPU，可以根据需要修改为其他 ID (例如 CUDA_VISIBLE_DEVICES=1,2 使用 GPU 1 和 GPU 2)。如果您只有一块 GPU，通常使用 0 即可。
- `/mnt/e/modelscope/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B`: **模型路径。** 请替换为您在步骤 2 中模型实际保存的路径。
- `--port 8102`: **服务端口号。** `8102` 是服务启动后监听的端口。您可以根据需要修改端口号，例如 `--port 8000`。在后续代码调用中，需要使用相同的端口号。
- --max-model-len 16384: 模型最大上下文长度。 16384 表示模型处理的最大输入序列长度。您可以根据您的 GPU 显存大小和需求调整此参数。对于 /mnt/e/modelscope/deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B 模型，16384 是一个较大的上下文长度。您可以尝试减小此值以减少显存占用，例如 --max-model-len 2048 或更小。
- **执行启动命令:** 在终端或命令提示符中执行上述 `vllm serve` 命令。
- **注意 GPU 显存:** 启动 vLLM 服务会占用 GPU 显存。请确保您的 GPU 显存足够运行模型。如果显存不足，可能会导致启动失败或运行缓慢。您可以尝试减小 `--max-model-len` 参数或使用更小规模的模型。

### Qwen/Qwen3-4B

```shell
vllm serve ~/modelscope/Qwen/Qwen3-4B --api-key token-abc123 --enable-reasoning --reasoning-parser deepseek_r1 --max_model_len=2048 --gpu_memory_utilization=0.85
```

#### supervisor

```conf
sudo vim vLLM-Qwen-Qwen3-4B.conf
[program:vLLM-Qwen-Qwen3-4B.conf]
command=zsh -c "source /home/user/miniconda3/bin/activate && source activate vLLM && vllm serve ~/modelscope/Qwen/Qwen3-4B --api-key token-abc123 --enable-reasoning --reasoning-parser deepseek_r1 --max_model_len=2048 --gpu_memory_utilization=0.85"
user=user
autostart=true
autorestart=true
stderr_logfile=/var/log/supervisor/vLLM-Qwen-Qwen3-4B/err.log
stdout_logfile=/var/log/supervisor/vLLM-Qwen-Qwen3-4B/out.log
stopasgroup=true
```

#### Docker

Docker Compose方式

```yaml
services:
  vllm:
    image: 'vllm/vllm-openai:latest'
    container_name: vllm-Qwen-Qwen3-8B-AWQ
    restart: always
    environment:
      - 'TZ:Asia/Shanghai'
      - 'VLLM_USE_MODELSCOPE:True'
      - 'HF_HUB_OFFLINE:1'
    ports:
      - '8000:8000'
    volumes:
      - /home/user/modelscope:/root/.cache/modelscope
      - /etc/localtime:/etc/localtime:ro
    # 启用 NVIDIA GPU 支持
    # 在 Docker Desktop 上，可能只需要 'gpu'，
    # 在 Linux 服务器上，通常是 'nvidia'
    # 你提供的命令行是 --runtime nvidia --gpus all
    # Docker Compose 对应的方式是：
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all # 或者指定具体的GPU数量，如 1, 2 等
              capabilities: [gpu] # 确保指定 GPU 能力
    # IPC 模式
    # ipc: host 允许容器与宿主机共享 IPC 命名空间，
    # 这在某些高性能场景下有用，例如共享内存。
    ipc: host
    # 容器启动时执行的命令和参数
    command:
      - --model
      - /root/.cache/modelscope/Qwen/Qwen3-8B-AWQ
      - --served_model_name
      - Qwen/Qwen3-4B # 你希望这个model暴露时的名称，如果不填默认为本地模型权重路径
      - --max_model_len
      - "8192" # 支持的最长上下文长度，根据显存大小自行匹配，注意这里需要是字符串
      # --api_key 参数在 vLLM 0.3.x 版本中可能不再是直接的命令行参数，
      # 而是通过环境变量 API_KEY 来设置的。
      # 我已将其移到 environment 部分。
      # 如果你的 vLLM 版本仍然支持命令行参数，请取消注释下一行：
      # - --api_key
      # - "<YOUR-API-KEY-HERE>"
      - --gpu_memory_utilization
      - "0.9"
      - --max-num-seqs
      - "128"
      - --api-key
      - token-abc123
      - --reasoning-parser
      - deepseek_r1
```



# LLama.cpp

> `llama.cpp`是一个基于纯`C/C++`实现的高性能大语言模型推理引擎，专为优化本地及云端部署而设计。其核心目标在于通过底层硬件加速和量化技术，实现在多样化硬件平台上的高效推理，同时保持低资源占用与易用性。

## 编译llama.cpp

首先从`Github`上下载`llama.cpp`的源码:

```text
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
```

`llama.cpp`支持多种硬件平台，可根据实际的硬件配置情况选择合适的编译参数进行编译，具体可以参考文档`docs/build.md`。

**安装CMAKE**

```shell
wget https://github.com/Kitware/CMake/releases/download/v4.0.0-rc4/cmake-4.0.0-rc4-linux-x86_64.sh
chmod -R 777 cmake-4.0.0-rc4-linux-x86_64.sh
./cmake-4.0.0-rc4-linux-x86_64.sh
mv cmake-4.0.0-rc4-linux-x86_64/ /usr/local/cmake
echo 'export PATH="/usr/local/cmake/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

sudo dnf install gcc-toolset-13-gcc gcc-toolset-13-gcc-c++
source /opt/rh/gcc-toolset-13/enable
```

**编译CPU版本**

```text
cmake -B build
cmake --build build --config Release -j 8
```

**编译GPU版本**

编译英伟达`GPU`版本需要先装好驱动和`CUDA`，然后执行下面的命令进行编译

```text
cmake -B build -DGGML_CUDA=ON -DGGML_CUDA_ENABLE_UNIFIED_MEMORY=1
cmake --build build --config Release -j 8
```

> 编译完成后，可执行文件和库文件被存放在`build/bin`目录下。

## 模型下载与转换

首先从魔搭社区下载模型：

```text
pip install modelscope
modelscope download --model deepseek-ai/DeepSeek-R1-Distill-Qwen-7B --local_dir DeepSeek-R1-Distill-Qwen-7B
```

下载好的模型是以`HuggingFace`的`safetensors`格式存放的，而`llama.cpp`使用的是`GGUF`格式，因此需要先要把模型转换为`GGUF`格式：

```text
# 安装python依赖库
pip install -r requirements.txt
# 转换模型
python convert_hf_to_gguf.py DeepSeek-R1-Distill-Qwen-7B/
```

转换成功后，在该目录下会生成一个`FP16`精度、`GGUF`格式的模型文件`DeepSeek-R1-Distill-Qwen-7B-F16.gguf`。

## 模型量化

`FP16`精度的模型跑起来可能会有点慢，我们可以对模型进行量化以提升推理速度。

`llama.cpp`主要采用了分块量化（`Block-wise Quantization`）和`K-Quantization`算法来实现模型压缩与加速，其核心策略包括以下关键技术：

1. **分块量化（Block-wise Quantization）**
   该方法将权重矩阵划分为固定大小的子块（如`32`或`64`元素为一组），每个子块独立进行量化。通过为每个子块分配独立的缩放因子（`Scale`）和零点（`Zero Point`），有效减少量化误差。例如，`Q4_K_M`表示每个权重用`4`比特存储，且子块内采用动态范围调整。
2. **K-Quantization（混合精度量化）**
   在子块内部进一步划分更小的单元（称为“超块”），根据数值分布动态选择量化参数。例如，`Q4_K_M`将超块拆分为多个子单元，每个子单元使用不同位数的缩放因子（如`6bit`的缩放因子和`4bit`的量化值），通过混合精度平衡精度与压缩率。
3. **重要性矩阵（Imatrix）优化**
   通过分析模型推理过程中各层激活值的重要性，动态调整量化策略。高重要性区域保留更高精度（如`FP16`），低重要性区域采用激进量化（如`Q2_K`），从而在整体模型性能损失可控的前提下实现高效压缩。
4. **量化类型分级策略**
   提供`Q2_K`至`Q8_K`等多种量化级别，其中字母后缀（如`_M`、`_S`）表示优化级别：
5. **Q4_K_M**：中等优化级别，平衡推理速度与精度（常用推荐）。
6. **Q5_K_S**：轻量化级别，侧重减少内存占用

典型场景下，`Q4_K_M`相比`FP16`模型可减少`70%`内存占用，推理速度提升`2-3`倍，同时保持`95%`以上的原始模型精度。实际部署时需根据硬件资源（如`GPU`显存容量）和任务需求（如生成文本长度）选择量化策略。

执行下面的命令可将`FP16`精度的模型采用`Q4_K_M`的量化策略进行量化：

```text
./build/bin/llama-quantize DeepSeek-R1-Distill-Qwen-7B/DeepSeek-R1-Distill-Qwen-7B-F16.gguf DeepSeek-R1-Distill-Qwen-7B/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf Q4_K_M
```

量化完成后，模型文件由`15.2G`减少到`4.7G`。

## 运行模型

模型量化完后，我们就可以运行模型来试试效果了。`llama.cpp`提供了多种运行模型的方式：

### 命令行方式

执行下面的命令就可以在命令行与模型进行对话了：

```text
./build/bin/llama-cli -m DeepSeek-R1-Distill-Qwen-7B/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf -cnv
```

### HTTP Server方式

由于模型是以`Markdown`格式输出内容，因此用命令行的方式看着不太方便。`llama.cpp`还提供`HTTP Server`的方式运行，交互性要好很多。

首先在终端执行命令

```text
./build/bin/llama-server -m DeepSeek-R1-Distill-Qwen-7B/DeepSeek-R1-Distill-Qwen-7B-Q4_K_M.gguf --port 8088
```

然后打开浏览器，输入地址`http://127.0.0.1:8088`就可以在网页上与模型进行交互了，非常方便！

# Ktransformers

安装



# LLaMA-Factory

> 可参考文章：[DeepSeek-R1-7B-Distill模型微调全过程记录，LLaMA_Factory训练自己的数据集，合并lora微调模型并量化为gguf，接入微信实现自动对话回复_微信_qq_53091149-DeepSeek技术社区](https://deepseek.csdn.net/67b84a893c9cd21f4cb9aab6.html#devmenu2)

## 安装

```shell
# 首先 conda创建环境
conda create -n LLaMA-Factory python=3.12
# 激活环境
conda activate LLaMA-Factory
# 从GitHub上拉去项目代码到当前目录下
git clone https://github.com/hiyouga/LLaMA-Factory.git
# 进入目录
cd LLaMA-Factory
# 安装所需依赖
pip install -e ".[torch,metrics]"
# 启动webui
python src/webui.py
```

## 微调

![image-20250320152454509](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250320152454509.png)

![image-20250320152533756](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250320152533756.png)

合并

![image-20250320152645802](https://markdownhexo.oss-cn-hangzhou.aliyuncs.com/img/image-20250320152645802.png)

# AutoAWQ量化

## 安装

```shell
conda create -n AutoAWQ python=3.12
conda activate AutoAWQ
pip install torch
pip install autoawq
```

## 脚本

默认AutoAWQ会从Huggingface上下载数据集mit-han-lab/pile-val-backup，会因为网络问题失败

需事先手动下载，通过modelscope

```shell
modelscope download --dataset mit-han-lab/pile-val-backup  --local_dir ~/modelscope/mit-han-lab/pile-val-backup
```

以`Qwen/Qwen3-4B`模型为例

```shell
from awq import AutoAWQForCausalLM
from transformers import AutoTokenizer
from datasets import load_dataset

# 加载本地数据集
def load_calib_data():
    data=load_dataset('/home/user/modelscope/mit-han-lab/pile-val-backup', split="validation")
    return [text for text in data["text"] if text.strip() != '' and len(text.split(' ')) > 20]

model_path = '/home/user/modelscope/Qwen/Qwen3-4B'
quant_path = '/home/user/modelscope/Qwen/Qwen3-4B-awq'
quant_config = { "zero_point": True, "q_group_size": 128, "w_bit": 4, "version": "GEMM" }


# Load model
# 加载模型


model = AutoAWQForCausalLM.from_pretrained(
    model_path, **{"low_cpu_mem_usage": True, "use_cache": False}
)
tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)


# Quantize
# 量化

calib_data=load_calib_data()
model.quantize(tokenizer, quant_config=quant_config, calib_data=calib_data)


# Save quantized model
# 保存量化模型


model.save_quantized(quant_path)
tokenizer.save_pretrained(quant_path)


print(f'Model is quantized and saved at "{quant_path}"')
```



# 大模型Dense、MoE 与 Hybrid-MoE 架构的比较

在大模型架构设计中，Dense（全连接）、MoE（混合专家）和Hybrid-MoE（混合式MoE）是三种主流的参数组织方式，它们在模型容量、计算效率和应用场景上存在显著差异。以下从核心原理、技术特点、优缺点及适用场景进行系统对比：

------

## **1. 核心原理对比**

| **架构类型**   | **核心思想**                                                                         | **典型模型**               |
| -------------- | ------------------------------------------------------------------------------------ | -------------------------- |
| **Dense**      | 所有参数对所有输入生效，每层神经元全连接，统一处理所有输入特征。                     | GPT-3、BERT、LLAMA         |
| **MoE**        | 将模型划分为多个“专家”（子网络），每个输入仅激活部分专家，通过路由机制动态分配任务。 | Switch Transformer、GShard |
| **Hybrid-MoE** | 混合Dense和MoE层：部分层全连接，部分层采用MoE结构，平衡计算效率和模型容量。          | DeepSeek-MoE、Google GLaM  |

------

## **2. 技术特点与性能对比**

| **维度**       | **Dense**                                           | **MoE**                                                           | **Hybrid-MoE**                            |
| -------------- | --------------------------------------------------- | ----------------------------------------------------------------- | ----------------------------------------- |
| **参数规模**   | 总参数量=激活参数量，随层数线性增长。               | 总参数量高（专家数×专家规模），但激活参数量低（仅激活部分专家）。 | 介于两者之间，MoE层数可控。               |
| **计算效率**   | 计算成本高（FLOPs与参数量正相关），适合小规模模型。 | 相同参数量下，FLOPs显著降低（仅激活部分专家）。                   | 通过调整MoE层比例，灵活平衡计算开销。     |
| **训练稳定性** | 收敛稳定，梯度传播路径简单。                        | 路由机制易导致专家负载不均衡，需复杂正则化。                      | 稳定性优于纯MoE，但仍需路由优化。         |
| **扩展性**     | 参数规模受硬件限制，千亿级后成本陡增。              | 可扩展至万亿参数（如GShard-1.6T），适合超大规模模型。             | 通过局部MoE化实现高效扩展，适配中等规模。 |
| **显存占用**   | 高（需存储全部参数梯度）。                          | 显存需求更高（专家参数独立存储）。                                | 显存介于两者之间，取决于MoE层占比。       |
| **应用场景**   | 通用任务、资源受限场景。                            | 超大规模预训练、多任务学习。                                      | 需平衡性能与成本的工业级应用。            |

------

## **3. 优缺点对比**

### **Dense架构**

- **优点**：
  - 结构简单，训练稳定性高。
  - 参数利用率最大化，适合小规模高精度任务。
- **缺点**：
  - 计算成本随参数量指数级增长，难以扩展至超大规模。
  - 显存占用高，限制单卡可训练模型规模。

### **MoE架构**

- **优点**：
  - 计算效率高，相同FLOPs下模型容量更大。
  - 支持万亿级参数扩展，适合分布式训练。
- **缺点**：
  - 路由机制复杂，易出现专家“坍缩”（部分专家未被激活）。
  - 显存和通信开销大，需定制化负载均衡策略。

### **Hybrid-MoE架构**

- **优点**：
  - 灵活性高，可通过调整MoE层位置平衡性能与成本。
  - 保留关键层的全连接特性，提升任务特定性能。
- **缺点**：
  - 需精心设计MoE层分布，调参成本较高。
  - 仍面临部分MoE的稳定性挑战。

------

## **4. 典型应用场景**

| **架构**       | **适用场景**                                                                        |
| -------------- | ----------------------------------------------------------------------------------- |
| **Dense**      | - 中小规模模型（<100B参数） - 对训练稳定性要求高的任务（如对话生成） - 边缘设备推理 |
| **MoE**        | - 超大规模预训练（>500B参数） - 多任务/多模态学习 - 云端高性能计算集群              |
| **Hybrid-MoE** | - 中等规模模型（100B-500B参数） - 需兼顾通用性与效率的工业场景 - 长文本处理任务     |

------

## **5. 技术选型建议**

- **选择Dense的条件**：
  - 资源有限（单卡训练/推理）。
  - 任务单一，无需极高模型容量。
  - 追求极简架构和稳定收敛。
- **选择MoE的条件**：
  - 追求极致模型性能（如AGI探索）。
  - 拥有大规模计算集群（千卡级）。
  - 多任务/多模态需求显著。
- **选择Hybrid-MoE的条件**：
  - 需平衡模型容量与计算成本。
  - 部分任务依赖全连接层的强表征能力（如逻辑推理）。
  - 希望渐进式扩展模型规模。

------

## **6. 未来发展方向**

1. **Dense架构优化**：
   - 参数高效微调（LoRA、Adapter）。
   - 动态稀疏激活（如微软的DeepSpeed-MoE）。
2. **MoE架构改进**：
   - 更智能的路由机制（如基于强化学习）。
   - 专家共享与分层MoE设计。
3. **Hybrid-MoE创新**：
   - 自动化MoE层分布搜索（NAS技术）。
   - 异构专家设计（不同专家结构适配不同任务）。

------

## **总结**

- **Dense**：简单可靠，适合资源受限场景，但扩展性差。
- **MoE**：计算高效，扩展性强，但工程复杂度高。
- **Hybrid-MoE**：折中方案，平衡性能与成本，需精细调优。

实际选型需结合**任务需求**、**硬件资源**和**工程能力**综合评估。对于大多数企业级应用，Hybrid-MoE可能是当前的最优解，而科研前沿更倾向于探索纯MoE的极限能力。

# Dify

## Dify 向量存储机制简述

在 Dify 中，文档数据（如知识库文档、FAQ、手册等）需要经过向量化处理，才能用于语义检索和问答增强。其核心处理流程如下图所示：

```
文档（原始文本）
   ↓
Embedding（由 OpenAI, Hugging Face, etc. 提供）
   ↓
向量（高维 float 数组）
   ↓
Vector Store（默认为 Weaviate）
   ↓
Dify 查询时执行语义检索，返回匹配片段
```

向量存储的作用

Dify 本身不负责存储嵌入向量，而是通过调用第三方向量数据库来管理这些向量。向量数据库的主要职责包括：

- 存储文本对应的向量数据（float 数组）
- 为每条向量建立索引，支持高效近似/精确搜索
- 提供语义检索 API（如 top-k 相似度查找）
- 支持元数据管理（如 document_id, source, tags 等）
