## API调用

登录这里：
https://console.volcengine.com/ark/region:ark+cn-beijing/endpoint?config=%7B%7D

注册后，创建DeepSeek R1 API接入点：

![image.png](/static/img/f7bd0508dac987671565f7b081c4efe6.image.webp)



接着Python就可以直接调用了：

```python
import os
from openai import OpenAI

client = OpenAI(
    api_key = "填写自己的key",
    base_url = "https://ark.cn-beijing.volces.com/api/v3",
)

# Non-streaming:
print("----- standard request -----")
completion = client.chat.completions.create(
    model = "ep-20250211175825-填写自己的模型名字",  # your model endpoint ID
    messages = [
        {"role": "system", "content": "你是豆包，是由字节跳动开发的 AI 人工智能助手"},
        {"role": "user", "content": "常见的十字花科植物有哪些？"},
    ],
)
print(completion.choices[0].message.content)

```

## OpenWebUI使用

安装：

```
docker run -d -p 8888:8080 \
  -v /root/ollama:/root/.ollama \
  -v /root/openwebui-test:/app/backend/data \
  --restart always -e HF_HUB_OFFLINE=1 \
  ghcr.io/open-webui/open-webui:ollama
```

增加这个函数到OpenWebUI：

```bash
"""
title: DeepSeek R1
author: zgccrui
description: 在OpwenWebUI中显示DeepSeek R1模型的思维链 - 仅支持0.5.6及以上版本
version: 1.2.6
licence: MIT
"""

import json
import httpx
import re
from typing import AsyncGenerator, Callable, Awaitable
from pydantic import BaseModel, Field
import asyncio


class Pipe:
    class Valves(BaseModel):
        DEEPSEEK_API_BASE_URL: str = Field(
            default="自己的baseurl",
            description="Base Url",
        )
        DEEPSEEK_API_KEY: str = Field(
            default="", description="用于身份验证的DeepSeek API密钥，可从控制台获取"
        )
        DEEPSEEK_API_MODEL: str = Field(
            default="deepseek-reasoner",
            description="API请求的模型名称，默认为 deepseek-reasoner ",
        )

    def __init__(self):
        self.valves = self.Valves()
        self.data_prefix = "data: "
        self.thinking = -1  # -1:未开始 0:思考中 1:已回答
        self.emitter = None

    def pipes(self):
        return [
            {
                "id": self.valves.DEEPSEEK_API_MODEL,
                "name": self.valves.DEEPSEEK_API_MODEL,
            }
        ]

    async def pipe(
        self, body: dict, __event_emitter__: Callable[[dict], Awaitable[None]] = None
    ) -> AsyncGenerator[str, None]:
        """主处理管道（已移除缓冲）"""
        self.thinking = -1
        self.emitter = __event_emitter__

        # 验证配置
        if not self.valves.DEEPSEEK_API_KEY:
            yield json.dumps({"error": "未配置API密钥"}, ensure_ascii=False)
            return

        # 准备请求参数
        headers = {
            "Authorization": f"Bearer {self.valves.DEEPSEEK_API_KEY}",
            "Content-Type": "application/json",
        }

        try:
            # 模型ID提取
            model_id = body["model"].split(".", 1)[-1]
            payload = {**body, "model": model_id}

            # 处理消息以防止连续的相同角色
            messages = payload["messages"]
            i = 0
            while i < len(messages) - 1:
                if messages[i]["role"] == messages[i + 1]["role"]:
                    # 插入具有替代角色的占位符消息
                    alternate_role = (
                        "assistant" if messages[i]["role"] == "user" else "user"
                    )
                    messages.insert(
                        i + 1,
                        {"role": alternate_role, "content": "[Unfinished thinking]"},
                    )
                i += 1

            # yield json.dumps(payload, ensure_ascii=False)

            # 发起API请求
            async with httpx.AsyncClient(http2=True) as client:
                async with client.stream(
                    "POST",
                    f"{self.valves.DEEPSEEK_API_BASE_URL}/chat/completions",
                    json=payload,
                    headers=headers,
                    timeout=300,
                ) as response:
                    # 错误处理
                    if response.status_code != 200:
                        error = await response.aread()
                        yield self._format_error(response.status_code, error)
                        return

                    # 流式处理响应
                    async for line in response.aiter_lines():
                        if not line.startswith(self.data_prefix):
                            continue

                        # 截取 JSON 字符串
                        json_str = line[len(self.data_prefix) :]

                        try:
                            data = json.loads(json_str)
                        except json.JSONDecodeError as e:
                            # 格式化错误信息，这里传入错误类型和详细原因（包括出错内容和异常信息）
                            error_detail = f"解析失败 - 内容：{json_str}，原因：{e}"
                            yield self._format_error("JSONDecodeError", error_detail)
                            return

                        choice = data.get("choices", [{}])[0]

                        # 结束条件判断
                        if choice.get("finish_reason"):
                            return

                        # 状态机处理
                        state_output = await self._update_thinking_state(
                            choice.get("delta", {})
                        )
                        if state_output:
                            yield state_output  # 直接发送状态标记
                            if state_output == "<think>":
                                yield "\n"

                        # 内容处理并立即发送
                        content = self._process_content(choice["delta"])
                        if content:
                            if content.startswith("<think>"):
                                match = re.match(r"^<think>", content)
                                if match:
                                    content = re.sub(r"^<think>", "", content)
                                    yield "<think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"

                            elif content.startswith("</think>"):
                                match = re.match(r"^</think>", content)
                                if match:
                                    content = re.sub(r"^</think>", "", content)
                                    yield "</think>"
                                    await asyncio.sleep(0.1)
                                    yield "\n"
                            yield content

        except Exception as e:
            yield self._format_exception(e)

    async def _update_thinking_state(self, delta: dict) -> str:
        """更新思考状态机（简化版）"""
        state_output = ""

        # 状态转换：未开始 -> 思考中
        if self.thinking == -1 and delta.get("reasoning_content"):
            self.thinking = 0
            state_output = "<think>"

        # 状态转换：思考中 -> 已回答
        elif (
            self.thinking == 0
            and not delta.get("reasoning_content")
            and delta.get("content")
        ):
            self.thinking = 1
            state_output = "\n</think>\n\n"

        return state_output

    def _process_content(self, delta: dict) -> str:
        """直接返回处理后的内容"""
        return delta.get("reasoning_content", "") or delta.get("content", "")

    def _format_error(self, status_code: int, error: bytes) -> str:
        """错误格式化保持不变"""
        try:
            err_msg = json.loads(error).get("message", error.decode(errors="ignore"))[
                :200
            ]
        except:
            err_msg = error.decode(errors="ignore")[:200]
        return json.dumps(
            {"error": f"HTTP {status_code}: {err_msg}"}, ensure_ascii=False
        )

    def _format_exception(self, e: Exception) -> str:
        """异常格式化保持不变"""
        err_type = type(e).__name__
        return json.dumps({"error": f"{err_type}: {str(e)}"}, ensure_ascii=False)

```

保存函数，配置函数参数：


![image.png](/static/img/da12b1b2235d9d6cfa4fe7ce8f5462a3.image.webp)

## 使用

可以自己修改一个模型名称便于认识，然后这个函数就可以显示出思考过程了。

![image.png](/static/img/b3fe3411c4f6fa3aaf6de917ef428f81.image.webp)

OpenWebUI使用DeepSeek R1满血版，DeepSeek R1 API调用

安装 Docker Compose 可以通过几种方式进行，最常见的是通过下载官方提供的二进制文件或者使用包管理器安装。以下是两种主要的方法：



### 方法一：通过下载二进制文件安装 Docker Compose

1. **下载最新版本的 Docker Compose**：
   
   首先，确定最新版本的 Docker Compose。你可以在 [GitHub Releases](https://github.com/docker/compose/releases) 页面找到最新版本。目前最新的稳定版本是 1.29.2（截至2021年）。

   使用以下命令下载：

   ```bash
   sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
   ```

2. **设置执行权限**：

   下载完成后，你需要为二进制文件设置执行权限：

   ```bash
   sudo chmod +x /usr/local/bin/docker-compose
   ```

3. **创建符号链接（可选）**：

   为了避免打字错误或者简化路径，可以创建一个符号链接到 `/usr/bin`：

   ```bash
   sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose
   ```

4. **验证安装**：

   最后，使用以下命令验证安装是否成功：

   ```bash
   docker-compose --version
   ```

### 方法二：通过包管理器安装 Docker Compose

如果你更喜欢通过包管理器来管理软件，可以使用 Python 的包管理工具 `pip` 来安装 Docker Compose。

1. **安装 pip**：

   首先，确保你已经安装了 `pip`。如果没有，可以使用以下命令来安装：

   ```bash
   sudo apt update
   sudo apt install -y python3-pip
   ```

2. **使用 pip 安装 Docker Compose**：

   使用 `pip` 安装 Docker Compose：

   ```bash
   sudo pip3 install docker-compose
   ```

3. **验证安装**：

   使用以下命令验证安装是否成功：

   ```bash
   docker-compose --version
   ```

### 方法三：通过官方 APT 源安装 Docker Compose Plugin

Docker 现在提供了 Docker Compose 的插件版本，可以直接与 Docker CLI 集成。

1. **更新包索引并安装 Docker Compose 插件**：

   ```bash
   sudo apt update
   sudo apt install -y docker-compose-plugin
   ```

2. **验证安装**：

   你可以使用以下命令来确保安装成功：

   ```bash
   docker compose version
   ```

无论你选择哪种方法，都应该能够成功安装 Docker Compose 并开始使用它来定义和管理多容器 Docker 应用。

Ubuntu22 安装Docker Compose

在 Ubuntu 22.04 上安装 Docker 是一个相对简单的过程。以下是步骤：

### 1. 更新系统包

首先，确保系统包信息是最新的：

```bash
sudo apt update
sudo apt upgrade -y
```



### 2. 安装依赖包

在安装 Docker 之前，需要一些依赖包：

```bash
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common
```

### 3. 添加 Docker 的官方 GPG 密钥

为了确保下载软件包的安全性，我们需要添加 Docker 的官方 GPG 密钥：

```bash
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
```

### 4. 添加 Docker 的 APT 源

将 Docker 的 APT 源添加到你的系统中：

```bash
echo "deb [arch=amd64 signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
```

### 5. 更新包索引

添加 Docker 的软件源之后，需要更新 APT 包索引：

```bash
sudo apt update
```

### 6. 安装 Docker 引擎

现在可以安装 Docker 引擎了：

```bash
sudo apt install -y docker-ce docker-ce-cli containerd.io
```

### 7. 启动并启用 Docker

安装完成后，启动 Docker 并设置开机自启：

```bash
sudo systemctl start docker
sudo systemctl enable docker
```

### 8. 验证安装

运行以下命令查看 Docker 的版本，并确保 Docker 报告了其版本信息：

```bash
docker --version
```

还可以运行一个简单的测试容器，确保 Docker 工作正常：

```bash
sudo docker run hello-world
```

### 9. （可选）将当前用户加入 `docker` 组

为了不在每次运行 Docker 命令时都使用 `sudo`，可以将当前用户加入 `docker` 组：

```bash
sudo usermod -aG docker $USER
```

然后，重新登录或重新启动系统以使更改生效。

现在，你已经在 Ubuntu 22.04 上成功安装了 Docker！

Ubuntu22 安装Docker

本文作为这篇文章的总结：

https://mp.weixin.qq.com/s/-rXYgsu_1IEpjGvSQArPJQ



### 深入解析FlashAttention的核心原理与优化策略

#### **FlashAttention的核心价值**
- **问题背景**：Transformer的Attention模块存在计算效率瓶颈，传统优化方法（如稀疏近似）虽减少计算量（FLOPs），但未解决关键I/O瓶颈。
- **三大优势**：
  1. **I/O感知的高效计算**：通过优化内存访问模式（减少HBM访问次数）而非仅减少FLOPs提速。
  2. **内存高效**：分块计算（Tiling）避免存储中间矩阵（如QK^T），显著降低内存占用。
  3. **精确计算**：结果与原始Attention完全一致，避免近似算法的误差。

---

#### **数学原理：从Softmax到FlashAttention**

1. **安全Softmax**：通过减去最大值防止数值溢出，但需三次遍历数据。

    Softmax的原始公式：
    $$
    s_i=\frac{e^{x_i}}{\sum_{j=1}^N e^{x_j}}
    $$
    安全Softmax：
    $$
    S_i=\frac{\frac{e^{x_i}}{e^{m_N}}}{\sum_{j=1}^K\left(\frac{e^{x_j}}{e^{m_N}}\right)}=\frac{e^{x_i-m_N}}{\sum_{j=1}^K\left(e^{x_j-m_N}\right)}
    $$
2. **Online Softmax**（Nvidia提出）：
   - **递归思想**：逐元素计算局部最大值和归一化因子，将三次遍历降为两次。
3. **FlashAttention的突破**：
   - **融合计算**：将Softmax与Value矩阵乘法结合，通过分块迭代公式实现单次遍历。
   - **避免中间存储**：直接计算Attention结果，无需保存QK^T和Softmax矩阵。

---

#### **硬件视角：为什么需要FlashAttention？**
- **GPU/NPU内存瓶颈**：
  - **HBM**：容量大（40GB）但带宽低（1.5TB/s）。
  - **SRAM**：带宽高（19TB/s）但容量小（20MB）。
- **计算膨胀系数β**：矩阵乘法（β=O(d)）易受计算带宽限制，Softmax（β≈3）受内存带宽限制。
- **分块策略**：将大矩阵拆分为小块，在SRAM中完成计算，减少HBM交互次数。

---

#### **算法演进：FA-1到FA-3的核心优化**
1. **FA-1**（基础版本）：
   - **外循环分块**：按Q的行分块，内循环加载K/V块，逐块计算Softmax并累加结果。
   - **避免中间矩阵**：融合Softmax与矩阵乘，仅保存最终Attention结果。
2. **FA-2**：
   - **循环结构调整**：将Q作为外循环，K/V为内循环，减少数据重复加载。
   - **计算式优化**：调整Softmax迭代公式，减少除法操作（式4-12），最后统一归一化。
3. **FA-3**（硬件级优化）：
   - **异步计算**：利用H100的Tensor Core异步执行GEMM与Softmax。
   - **低精度加速**：支持FP8计算，提升吞吐量。

---

#### **面试常见问题**
1. **FlashAttention为何比传统Attention快？**
   - 关键在减少HBM访问次数，通过分块计算和融合Softmax与矩阵乘，避免存储中间矩阵。

2. **如何保证计算精确性？**
   - 采用安全Softmax的数学变形，通过局部归一化因子递归计算，结果与原始算法一致。

3. **FA-2相比FA-1改进点？**
   - 外循环调整为Q分块，减少数据加载；优化Softmax迭代公式，减少非矩阵运算。

4. **分块大小如何选择？**
   - 受SRAM容量限制，需确保每个块的计算在SRAM内完成，典型配置为块大小≤128x128。


![image.png](/static/img/a63f18baaa685381e6a9e5e1f5516edf.image.webp)

---

#### **总结**
FlashAttention通过**分块计算**与**迭代式Softmax**的巧妙结合，在保证计算精度的同时，大幅降低内存访问开销，成为大模型训练的关键优化。其设计思想揭示了AI计算中“内存效率优先于计算量”的核心原则，为后续硬件感知算法提供了范本。

FlashAttention 透彻理解

https://www.modelscope.cn/models/iic/cv_ddcolor_image-colorization/summary#ddcolor-%E5%9B%BE%E5%83%8F%E4%B8%8A%E8%89%B2%E6%A8%A1%E5%9E%8B



## 下载模型


```
pip install modelscope


modelscope download --model 'iic/cv_ddcolor_image-colorization' --local_dir './DDColormodel'

```

## 推理
pytroch环境：

```
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia -y

pip install addict modelscope datasets sympy==1.13.1 simplejson sortedcontainers timm
```
推理：
```python
import cv2
from modelscope.outputs import OutputKeys
from modelscope.pipelines import pipeline
from modelscope.utils.constant import Tasks

img_colorization = pipeline(Tasks.image_colorization, 
                       model='./DDColormodel')
img_path = 'https://modelscope.oss-cn-beijing.aliyuncs.com/test/images/audrey_hepburn.jpg'
result = img_colorization(img_path)
cv2.imwrite('result.png', result[OutputKeys.OUTPUT_IMG])
```

原图：

![audrey_hepburn.jpg](/static/img/c6024d7a0f0ab002e4133224881120af.audrey_hepburn.webp)


![result.png](/static/img/fda6112455c6e6e6ccc94914c2f612d8.result.webp)

## docker环境

```
docker run --gpus all --shm-size=32g -it --net host -v ./:/ddcolor kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-pix2pix bash

pip install addict modelscope datasets sympy==1.13.1 simplejson sortedcontainers timm opencv-python

apt-get update
apt-get install -y libgl1-mesa-glx libjpeg-dev libpng-dev libtiff-dev libopencv-dev

docker commit 731cbf160933 kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor

docker push kevinchina/deeplearning:2.5.1-cuda12.1-cudnn9-devel-ddcolor
```

DDColor 效果实战

我是一个专注技术分享的博主,尤其爱搞深度学习和单片机电子。你现在看到的是我的个人博客网站。