# 如何在 Linux 上使用 Python 快速搭建 HTTP 服务来共享图片

在许多开发和数据处理场景中，快速共享文件，尤其是图片文件，是一项重要的需求。本文将介绍如何在 Linux 系统上使用 Python 的内置库快速搭建一个 HTTP 服务，以便其他服务器或客户端可以通过 URL 访问和下载指定目录中的图片。

## 为什么选择 Python 的 HTTP 服务？

Python 是一种简单易学且功能强大的编程语言，其内置的 `http.server` 模块可以帮助我们轻松创建一个 HTTP 服务器。与其他复杂的网络框架相比，`http.server` 提供了一个快速的解决方案，适合需要临时文件共享或开发测试的场景。





## 准备工作

### 1. 确保 Python 已安装

在开始之前，确保你的 Linux 系统上已安装 Python。可以使用以下命令检查 Python 的版本：
```bash
python3 --version
```
如果未安装，可以使用包管理器进行安装。例如，在 Ubuntu 上，你可以通过以下命令安装 Python：
```bash
sudo apt update
sudo apt install python3
```

### 2. 准备图片文件

在搭建 HTTP 服务之前，确保你已经准备好了要共享的图片文件，并将它们放置在一个目录中。例如，我们将要共享的图片文件放在 `/ssd/xiedong/zizhishenhe/20240802zizhi` 目录下。

## 搭建 HTTP 服务

### 1. 打开终端

首先，打开终端并使用 `cd` 命令导航到存放图片的目录：
```bash
cd /ssd/xiedong/zizhishenhe/20240802zizhi
```

### 2. 启动 HTTP 服务器

在该目录下，使用以下命令启动 HTTP 服务（这里使用端口 `8000`）：
```bash
python3 -m http.server 8000
```
执行此命令后，你的 HTTP 服务器将在所有可用的 IP 地址上启动，并开始监听指定的端口。

## 访问图片

服务启动后，可以通过浏览器或其他客户端访问你的图片。使用以下格式的 URL 来访问图片：
```
http://<你的服务器IP>:8000/<图片路径>
```
例如，如果你的服务器 IP 地址为 `192.168.1.10`，则可以通过以下 URL 访问某张图片：
```
http://192.168.1.10:8000/10.人力资源服务许可证/008_renli-3.jpg
```

## 注意事项

- **防火墙设置**：确保你的防火墙配置允许流量通过你选择的端口（如 `8000`）。在 Ubuntu 上，可以使用以下命令：
  ```bash
  sudo ufw allow 8000
  ```
  
- **安全性考虑**：使用 HTTP 服务时，请注意安全性，特别是在公共网络中，建议限制访问或使用更安全的 HTTPS。

- **后台运行**：如果需要在后台持续运行该服务，可以使用 `nohup` 命令：
  ```bash
  nohup python3 -m http.server 8000 &
  ```

## 停止服务

如果你需要停止正在运行的 HTTP 服务，可以在终端中找到该进程并结束，或者使用 `Ctrl + C` 来停止在前台运行的服务。

## 总结

通过本文，你已经学习了如何在 Linux 上使用 Python 快速搭建一个 HTTP 服务来共享图片。这种方法简单有效，非常适合临时共享和测试需求。如果你对 Python 和网络编程感兴趣，可以进一步研究 Flask 或 Django 等更复杂的框架，来实现更为丰富的功能。希望本篇文章对你有所帮助！

如何在 Linux 上使用 Python 快速搭建 HTTP 服务来共享图片

### 使用 Docker 容器下载 `laion_aesthetics_1024_33M_9.parquet` 文件示例

我下载了一个示例文件 `laion_aesthetics_1024_33M_9.parquet` 并存放在 `/ssd/xiedong/parquet_test` 目录中，接下来，我将通过启动 Docker 容器来完成该文件的数据下载。

核心思路是：**每个容器配备一个配置文件**，配置文件内定义了下载设置（如输入和输出文件位置等）。容器启动后会依据配置文件执行任务，任务完成后容器自动关闭。






### 构建带有环境的 Docker 镜像

首先，制作一个包含所需环境的镜像：

```bash
docker run -it -v /ssd/xiedong/parquet_test:/ssd/xiedong/parquet_test buluma/python:3.10.4-ubuntu22.04 bash
pip install img2dataset
apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*
pip cache purge
docker commit e768addf27ec kevinchina/deeplearning:ubuntu22.python3.10.img2dataset
```

---

### 创建下载脚本 `download_parquet.py`

此脚本负责根据配置文件下载 Parquet 数据，并处理失败的下载任务重试：

```python
import argparse
import json
import multiprocessing
import os
import pandas as pd
from img2dataset import download
import os
import time

def prepare_retry_download(url_list_dir, output_folder):
    # 定义重试下载逻辑，生成一个包含失败下载项的 Parquet 文件
    src_in = os.path.dirname(url_list_dir)
    src_in = os.path.join(src_in, "retry_download")
    os.makedirs(src_in, exist_ok=True)
    parquet_file = os.path.join(src_in, "retry_download.parquet")
    if os.path.exists(parquet_file):
        print("已经存在 retry_download.parquet")
        return parquet_file
    
    # 从输出文件夹中查找需要重试的下载文件
    files = [f for f in os.listdir(output_folder) if f.endswith(".parquet")]
    files_abs = sorted([os.path.join(output_folder, f) for f in files])
    df = pd.read_parquet(files_abs[0], engine='pyarrow')
    df = df[df['status'] == "failed_to_download"]
    
    # 处理前1000个文件，合并失败记录
    for file in files_abs[1:1000]:
        file_b = os.path.splitext(os.path.basename(file))[0] + "_stats.json"
        stats_file = os.path.join(output_folder, file_b)
        if not os.path.exists(stats_file):
            continue
        with open(stats_file, "r") as f:
            data = json.load(f)
        if data["successes"] / data["count"] > 0.60:
            continue
        df_tmp = pd.read_parquet(file, engine='pyarrow')
        df = pd.concat([df, df_tmp[df_tmp['status'] == "failed_to_download"]], axis=0)
    
    # 排除不需要重试的错误
    exclude_errors = ["Max retries exceeded with url", "HTTP Error 400", "HTTP Error 403", "HTTP Error 404", 
                      "HTTP Error 415", "HTTP Error 500", "HTTP Error 501", "HTTP Error 502", "HTTP Error 503"]
    for e in exclude_errors:
        df = df[~df['error_message'].str.contains(e)]
    
    # 保留必要列并重命名
    df = df.rename(columns={"caption": "TEXT", "url": "URL", "key": "KEY"})[["TEXT", "URL", "KEY"]]
    df.to_parquet(parquet_file, engine='pyarrow')
    return parquet_file

def wait_for_env_variable(env_var_name, check_interval=5):
    # 等待环境变量的设置
    while True:
        env_var_value = os.getenv(env_var_name)
        if env_var_value:
            print(f"找到环境变量 '{env_var_name}'：{env_var_value}")
            return env_var_value
        else:
            print(f"等待环境变量 '{env_var_name}' 被设置...")
            time.sleep(check_interval)

if __name__ == '__main__':
    # 等待环境变量
    env_var_value = wait_for_env_variable("PFVAR")
    
    # 读取配置文件
    with open(env_var_value, 'r', encoding='utf-8') as f:
        config = json.load(f)

    # 设置下载参数
    url_list = config["url_list"]
    output_folder = config["output_folder"]
    thread_count = config.get("thread_count", 16)
    timeout = config.get("timeout", 120)
    number_sample_per_shard = config.get("number_sample_per_shard", 2000)

    print("并发请求数量：", multiprocessing.cpu_count() * thread_count)

    download(
        processes_count=multiprocessing.cpu_count(),
        thread_count=thread_count,
        url_list=url_list,
        output_folder=output_folder,
        image_size=1024,
        resize_mode="no",
        skip_reencode=True,
        output_format="webdataset",
        input_format="parquet",
        url_col="URL",
        caption_col="TEXT",
        enable_wandb=False,
        number_sample_per_shard=number_sample_per_shard,
        distributor="multiprocessing",
        min_image_size=128,
        max_aspect_ratio=5,
        incremental_mode="incremental",
        timeout=timeout,
    )

    # 准备重试下载
    parquet_file = prepare_retry_download(url_list, output_folder)
    retry_output_folder = os.path.join(output_folder, "_retry_download")

    download(
        processes_count=multiprocessing.cpu_count(),
        thread_count=thread_count,
        url_list=parquet_file,
        output_folder=retry_output_folder,
        image_size=1024,
        resize_mode="no",
        skip_reencode=True,
        output_format="webdataset",
        input_format="parquet",
        url_col="URL",
        caption_col="TEXT",
        save_additional_columns=["KEY"],
        enable_wandb=False,
        number_sample_per_shard=number_sample_per_shard,
        distributor="multiprocessing",
        min_image_size=128,
        max_aspect_ratio=5,
        incremental_mode="incremental",
        timeout=timeout,
    )

    print("重试成功率可能为0，说明第一次下载已经非常成功。重试时无需关注成功率。")
    print("程序执行完毕，无需重新运行。")
```

---

### 创建 Dockerfile

```bash
FROM kevinchina/deeplearning:ubuntu22.python3.10.img2dataset

WORKDIR /app

COPY download_parquet.py .

ENTRYPOINT ["python", "download_parquet.py"]
```

---

### 构建镜像

```bash
docker build -t kevinchina/deeplearning:ubuntu22.python3.10.img2dataset.app .
```

---

### 配置文件 `config_part00059.json`

配置文件应指定 Parquet 文件位置和数据下载的持久化存储目录：

```json
{
  "url_list": "/ssd/xiedong/parquet_test/laion_aesthetics_1024_33M_9.parquet",
  "output_folder": "/ssd/xiedong/parquet_test/laion_aesthetics_1024_33M_9",
  "thread_count": 16,
  "timeout": 120,
  "number_sample_per_shard": 2000
}
```

---

### 执行下载

最后，使用以下命令启动下载任务：

```bash
docker run -d \
-v /ssd/xiedong/parquet_test:/ssd/xiedong/parquet_test \
-e PFVAR=/ssd/xiedong/parquet_test/config_part00059.json \
kevinchina/deeplearning:ubuntu22.python3.10.img2dataset.app | xargs -I {} docker logs -f {}
```

使用容器，如何快速下载parquet文件数据集

### 下载并配置Qwen2-VL-72B-Instruct-GPTQ-Int4模型

首先，下载Qwen2-VL-72B-Instruct-GPTQ-Int4模型到指定路径（例如：`/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4`）。该路径可以根据实际情况调整。





### 创建yaml配置文件

在路径`/root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4`下，创建一个名为`sft_xd_custom.yaml`的配置文件，内容如下：

```yaml
model_name_or_path: /xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4  # 容器内的路径
template: qwen2_vl
finetuning_type: lora
```

### Dockerfile配置

以下是Dockerfile的配置，基础镜像可以根据你的需求选择适合的深度学习镜像：

```dockerfile
# 使用指定的深度学习基础镜像
FROM kevinchina/deeplearning:llamafactory20241009

# 运行命令
CMD ["bash", "-c", "cd /app && llamafactory-cli api /xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4/sft_xd_custom.yaml"]
```

### 构建Docker镜像

使用以下命令构建Docker镜像：

```bash
docker build -f Dockerfile . -t kevinchina/deeplearning:llamafactory_qwen2vl
```

### 运行容器并挂载模型与数据集

执行以下命令运行容器，并将模型挂载到`/xiedong/Qwen2-VL-7B-Instruct`，同时挂载数据集到算法容器中。这样，在本地请求时可以直接使用容器内的图片路径，而无需通过URL。

```bash
docker run -d --rm --gpus=all \
    -v /root/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4:/xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4 \
    -v /path/to/SAM-dataset:/data \
    -p 7860:8000 \
    --shm-size 16G \
    kevinchina/deeplearning:llamafactory_qwen2vl | xargs -I {} docker logs -f {}
```

### 本地访问代码示例

以下是使用OpenAI API的本地访问代码示例：

```python
from openai import OpenAI

# 初始化OpenAI客户端
client = OpenAI(api_key='YOUR_API_KEY', base_url='http://101.136.22.140:7860/v1')

# 获取模型名称
model_name = client.models.list().data[0].id

# 发送请求并获取响应
response = client.chat.completions.create(
    model=model_name,
    messages=[{
        'role': 'user',
        'content': [{
            'type': 'text',
            'text': 'Describe the image please',
        }, {
            'type': 'image_url',
            'image_url': {
                'url': 'https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg',
            },
        }],
    }],
    temperature=0.8,
    top_p=0.8
)

# 打印返回的文本内容
print(response.choices[0].message.content)
```

### base64图片访问

https://github.com/sashabaranov/go-openai/issues/539

```python
import openai
import base64
import io
from PIL import Image
import requests

# 初始化 OpenAI 客户端
openai.api_key = "YOUR_API_KEY"  # 替换为你的 API 密钥


def convert_image_to_base64(image_path):
    """
    将本地图片转换为 base64 字符串，并生成 data URL 格式
    """
    with open(image_path, 'rb') as image_file:
        base64_image = base64.b64encode(image_file.read()).decode("utf-8")
    return f"data:image/png;base64,{base64_image}"


def create_prompt_turns(instruction, base64_image):
    """
    生成请求消息，包含文本和图片
    """
    prompt_turns = [
        {
            "role": "user",
            "content": [
                {"type": "text", "text": instruction},
                {
                    "type": "image_url",
                    "image_url": {
                        "url": base64_image,
                        "detail": "low"  # 可以根据需要设置图像质量级别
                    },
                },
            ]
        }
    ]
    return prompt_turns


def send_request(image_path, tokens, language):
    """
    构造请求并发送给 OpenAI 接口
    """
    # 将图片转换为 base64 格式
    base64_image = convert_image_to_base64(image_path)

    # 创建请求消息
    system_prompt = "User's preferred language: " + language
    prompt_turns = create_prompt_turns(system_prompt, base64_image)

    # 构造请求体
    data = {
        "model": "gpt-4-vision",  # 替换为实际的模型名称
        "messages": prompt_turns,
        "max_tokens": tokens,
        "temperature": 0.8,
        "top_p": 0.8
    }

    # 发送 POST 请求到 API 端点
    response = requests.post("http://101.136.22.140:7860/v1/chat/completions", json=data, headers={
        "Authorization": f"Bearer {openai.api_key}",
        "Content-Type": "application/json"
    })

    # 检查响应并打印结果
    if response.status_code == 200:
        return response.json()
    else:
        print(f"Error: {response.status_code}, {response.text}")
        return None


if __name__ == "__main__":
    # 设置相关参数
    image_path = "input1.png"  # 替换为你的图片路径
    tokens = 1000  # 生成的最大tokens数
    language = "English"  # 偏好的语言

    # 发送请求并打印结果
    result = send_request(image_path, tokens, language)
    if result:
        print(result)

```

【深度学习】LLaMA-Factory部署Qwen2-VL-72B-Instruct-GPTQ-Int4，容器即服务启动

## 部署 Qwen2-VL-72B-Instruct-GPTQ-Int4 模型

在之前的文章 [【深度学习】LLaMA-Factory部署Qwen2-VL](https://www.dong-blog.fun/post/1723) 中，已经介绍了如何部署未量化的模型。本篇将讨论如何部署量化过的模型，即 Qwen2-VL-72B-Instruct-GPTQ-Int4。





### 1. 环境准备

#### 安装 AutoGPTQ 依赖
在部署 Qwen2-VL-72B-Instruct-GPTQ-Int4 模型前，首先需要安装 AutoGPTQ。可以参考 [AutoGPTQ 安装方法](https://www.dong-blog.fun/post/1736)。

执行以下命令启动 Docker 容器：

```bash
docker run -it --rm --gpus=all -v /root/xiedong/:/xiedong/ --net host --shm-size 16G --name llamafactory4 kevinchina/deeplearning:llamafactory20240926 bash
```

设置 CUDA 环境变量：
```bash
echo 'export TORCH_CUDA_ARCH_LIST="7.2;7.5;8.0;8.6;8.7;9.0+PTX"' >> ~/.bashrc
source ~/.bashrc
```

**TORCH_CUDA_ARCH_LIST** 是用于控制 PyTorch 在编译 CUDA 扩展时支持的 CUDA 计算能力的环境变量。根据不同的 NVIDIA GPU 架构，设置相应的计算能力版本：

- 计算能力 5.x：Maxwell 架构 (如 GTX 980)
- 计算能力 6.x：Pascal 架构 (如 GTX 1080)
- 计算能力 8.x：Ampere 架构 (如 A100)

#### 安装 AutoGPTQ

克隆 AutoGPTQ 仓库并安装依赖：

```bash
git clone https://github.com/PanQiWei/AutoGPTQ.git && cd AutoGPTQ
pip install .
```

编译过程如下图所示：

![编译图](https://www.dong-blog.fun/static/img/9d77ceb5be8637a18fea66c0522634e5.image.webp)

安装成功后，如下图所示：

![安装成功图](https://www.dong-blog.fun/static/img/577917f6e888ca5f64e7b9bf294fd1b3.image.webp)

### 2. 部署 Hugging Face Optimum 库

Hugging Face 的 Optimum 库专为硬件加速模型的训练和推理设计，支持在不同硬件上优化模型部署。可以通过以下命令从源码安装：

```bash
python -m pip install git+https://github.com/huggingface/optimum.git
```

安装成功图示：

![安装成功图](https://www.dong-blog.fun/static/img/14488efc97705491ded738267e5a6666.image.webp)

### 3. 部署 Qwen2-VL-72B-Instruct-GPTQ-Int4

切换到应用目录：

```bash
cd /app
```

编辑 `sft_xd_seal.yaml` 配置文件：

```bash
vim examples/inference/sft_xd_seal.yaml
```

将以下内容写入文件：

```yaml
model_name_or_path: /xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4
# adapter_name_or_path: output/saves/qwen2_vl-7b/lora/sft_xd
template: qwen2_vl
finetuning_type: lora
```

#### 启动 OpenAPI 接口服务

编辑完配置文件后，使用以下命令启动 OpenAPI 接口服务：

```bash
llamafactory-cli api examples/inference/sft_xd_seal.yaml
```

成功部署后，日志如下所示：

```bash
[INFO|modeling_utils.py:4568] 2024-10-09 03:55:18,572 >> All model checkpoint weights were used when initializing Qwen2VLForConditionalGeneration.
[INFO|modeling_utils.py:4576] 2024-10-09 03:55:18,572 >> All the weights of Qwen2VLForConditionalGeneration were initialized from the model checkpoint at /xiedong/Qwen2-VL-72B-Instruct-GPTQ-Int4.
...
INFO:     Uvicorn running on http://0.0.0.0:8000 (Press CTRL+C to quit)
```

部署成功的图示：

![部署成功图](https://www.dong-blog.fun/static/img/c7a57dc1f08b3dc0267d7914dd2675d6.image.webp)

### 4. 显存占用情况

成功部署后的显存占用图如下所示：

![显存占用图](https://www.dong-blog.fun/static/img/c4a4ff842bf0d98089016db359eddfd3.image.webp)

### 5. OpenAI API 调用示例

以下是一个使用 OpenAI API 进行多模态推理的代码示例：

```python
from openai import OpenAI

client = OpenAI(api_key='YOUR_API_KEY', base_url='http://101.136.22.140:8000/v1')
model_name = client.models.list().data[0].id

response = client.chat.completions.create(
    model=model_name,
    messages=[{
        'role': 'user',
        'content': [{
            'type': 'text',
            'text': 'Describe the image please',
        }, {
            'type': 'image_url',
            'image_url': {
                'url': 'https://raw.githubusercontent.com/open-mmlab/mmdeploy/main/tests/data/tiger.jpeg',
            },
        }],
    }],
    temperature=0.8,
    top_p=0.8
)

print(response)
print(response.choices[0].message.content)
```

访问成功后的返回结果如下图所示：

![访问成功图](https://www.dong-blog.fun/static/img/a3933c6f342d281dd1e5526eed65a4d8.image.webp)


### 6. 上传我的镜像给大家用


```bash
docker push kevinchina/deeplearning:llamafactory20241009
```

【深度学习】LLaMA-Factory部署Qwen2-VL-72B-Instruct-GPTQ-Int4

## AutoGPTQ 安装教程与问题解决

### 参考教程：
官方教程地址：[AutoGPTQ 教程](https://github.com/AutoGPTQ/AutoGPTQ/blob/main/README_zh.md





教程中提到的基本安装步骤如下：

1. 克隆源码：
   ```bash
   git clone https://github.com/PanQiWei/AutoGPTQ.git && cd AutoGPTQ
   ```

2. 从项目目录进行安装：
   ```bash
   pip install .
   ```

3. 如果不需要构建 CUDA 拓展，可以使用以下命令取消构建：
   ```bash
   BUILD_CUDA_EXT=0 pip install .
   ```

4. 对于支持的系统，可以通过以下命令启用 triton 加速：
   ```bash
   pip install .[triton]
   ```

5. 针对 AMD GPU 用户，若需要从源码安装支持 RoCm，请先设置 `ROCM_VERSION` 环境变量，并通过设置 `PYTORCH_ROCM_ARCH` 来加快编译速度。例如，对于 MI200 系列设备，设置该变量为 `gfx90a`：
   ```bash
   ROCM_VERSION=5.6 pip install .
   ```

6. 在使用 RoCm 系统时，还需要预先安装以下依赖包：`rocsparse-dev`, `hipsparse-dev`, `rocthrust-dev`, `rocblas-dev`, `hipblas-dev`。

---

### 错误问题描述与解决方案

#### 我的系统信息：
```bash
nvcc --version
```
显示为：
```
Cuda compilation tools, release 12.3, V12.3.107
```

#### 错误日志：
```bash
pip install .
```
报错如下：
```
...
ValueError: Trying to compile AutoGPTQ for CUDA compute capabilities 5.2;6.0;6.1;7.0;7.2;7.5;8.0;8.6;8.7;9.0+PTX, but AutoGPTQ does not support the compute capabilities {'5.2'}...
```

#### 问题分析：
从错误日志可以看出，当前环境中的 `TORCH_CUDA_ARCH_LIST` 包含了不支持的 CUDA 计算能力 5.2。而 NVIDIA A100 显卡支持的计算能力是 8.0 及以上。

#### 解决方案：

1. **更新 `TORCH_CUDA_ARCH_LIST` 环境变量**：
   为解决该问题，你需要去除不支持的 5.2 计算能力，并保留 A100 显卡支持的 8.0 及以上版本。可以通过以下步骤进行操作：

   ```bash
   export TORCH_CUDA_ARCH_LIST="8.0;8.6;8.7"
   ```

2. **持久化设置**：
   如果希望每次启动环境时自动应用该设置，可以将其添加到 `.bashrc` 文件中：

   ```bash
   echo 'export TORCH_CUDA_ARCH_LIST="7.2;7.5;8.0;8.6;8.7;9.0+PTX"' >> ~/.bashrc
   source ~/.bashrc
   ```

3. **重新安装 AutoGPTQ**：
   完成上述设置后，重新执行安装命令，确保环境变量正确生效并避免不兼容的计算能力导致的问题。

---

通过以上步骤，你可以顺利解决由于不兼容 CUDA 计算能力导致的安装报错问题，并确保 AutoGPTQ 正常运行于 NVIDIA A100 显卡上。

Cuda12.3 A100 install AutoGPTQ

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

如何在 Linux 上使用 Python 快速搭建 HTTP 服务来共享图片

为什么选择 Python 的 HTTP 服务？

使用 Docker 容器下载 laion_aesthetics_1024_33M_9.parquet 文件示例

下载并配置Qwen2-VL-72B-Instruct-GPTQ-Int4模型

部署 Qwen2-VL-72B-Instruct-GPTQ-Int4 模型

AutoGPTQ 安装教程与问题解决

参考教程：

使用 Docker 容器下载 `laion_aesthetics_1024_33M_9.parquet` 文件示例