## 部署 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

初始化：


```c
void OLED_Init(void)
{
    oled_port_init();
    delay(4000);       //初始化之前的延时很重要！

    OLED_WR_Byte_(0xAE, OLED_CMD); //--display off
    OLED_WR_Byte_(0x00, OLED_CMD); //---set low column address
    OLED_WR_Byte_(0x10, OLED_CMD); //---set high column address
    OLED_WR_Byte_(0x40, OLED_CMD); //--set start line address
    OLED_WR_Byte_(0xB0, OLED_CMD); //--set page address
    OLED_WR_Byte_(0x81, OLED_CMD); // contract control
    OLED_WR_Byte_(0xFF, OLED_CMD); //--128
    OLED_WR_Byte_(0xA1, OLED_CMD); //set segment remap
    OLED_WR_Byte_(0xA6, OLED_CMD); //--normal / reverse
    OLED_WR_Byte_(0xA8, OLED_CMD); //--set multiplex ratio(1 to 64)
    OLED_WR_Byte_(0x3F, OLED_CMD); //--1/32 duty
    OLED_WR_Byte_(0xC8, OLED_CMD); //Com scan direction
    OLED_WR_Byte_(0xD3, OLED_CMD); //-set display offset
    OLED_WR_Byte_(0x00, OLED_CMD); //
    OLED_WR_Byte_(0xD5, OLED_CMD); //set osc division
    OLED_WR_Byte_(0x80, OLED_CMD); //
    OLED_WR_Byte_(0xD8, OLED_CMD); //set area color mode off
    OLED_WR_Byte_(0x05, OLED_CMD); //
    OLED_WR_Byte_(0xD9, OLED_CMD); //Set Pre-Charge Period
    OLED_WR_Byte_(0xF1, OLED_CMD); //
    OLED_WR_Byte_(0xDA, OLED_CMD); //set com pin configuartion
    OLED_WR_Byte_(0x12, OLED_CMD); //
    OLED_WR_Byte_(0xDB, OLED_CMD); //set Vcomh
    OLED_WR_Byte_(0x30, OLED_CMD); //
    OLED_WR_Byte_(0x8D, OLED_CMD); //set charge pump enable
    OLED_WR_Byte_(0x14, OLED_CMD); //

    OLED_Clear();
    OLED_WR_Byte_(0xAF, OLED_CMD); //--turn on oled panel

}

```





这些字符：

```bash
 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
```
取字模方法：


![img_v3_02ff_7914e3e5-778c-40c9-a5b4-3ad3a8bd7a4g.jpg](/static/img/8a7f0c13b950087b6dd2598b0416a64f.img_v3_02ff_7914e3e5-778c-40c9-a5b4-3ad3a8bd7a4g.webp)



![img_v3_02ff_458538c6-c8e7-4347-b546-2c1af96e770g.jpg](/static/img/fa68683e3f4f007a74a98e8afdfad309.img_v3_02ff_458538c6-c8e7-4347-b546-2c1af96e770g.webp)

效果：

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

1.45寸OLED,SSD1306,双排显示，实战教程

### 博客文章：理解 Python 中的 `multiprocessing.set_start_method('spawn')`

在 Python 的并发编程领域，如何管理进程的启动对于确保程序稳定性和合理管理资源至关重要。`multiprocessing` 模块为启动子进程提供了几种方法，其中 `spawn` 是在某些场景下特别有用和稳健的选项。






#### 不同的进程启动方法:
Python 的 `multiprocessing` 模块主要支持三种启动子进程的方法：

1. **fork（Unix/Linux 上的默认方式）**：
   - `fork` 方法通过复制当前进程来创建子进程，子进程继承父进程的内存和文件描述符。这种方法效率较高，但可能导致复杂问题，例如继承不希望的内存状态，以及当使用类似 CUDA 的库时，两个进程可能会同时尝试访问 GPU，这在 fork 环境中是不可能的。

2. **spawn（Windows 上的默认方式，也可用于 Unix/Linux）**：
   - 启动新进程时，`spawn` 不会继承父进程的内存状态。它会启动一个全新的 Python 解释器，然后只执行指定的目标函数或代码片段。这种方式更“干净”，因为它不继承父进程的状态和资源。因此，在使用 CUDA 或其他需要特殊初始化的资源时，`spawn` 更加安全。

3. **forkserver（仅在 Unix/Linux 上可用）**：
   - `forkserver` 是介于 `fork` 和 `spawn` 之间的方式。它首先会启动一个单独的“fork 服务器”，所有子进程都是通过这个服务器的 fork 创建的。这样既避免了父进程的某些状态被继承，但创建子进程的速度又比 `spawn` 快。

#### 为什么使用 `spawn`？
在使用 CUDA（即 GPU 加速）的场景下，特别是在 Unix/Linux 系统上，`fork` 是默认的进程启动方式，它会把父进程的资源（包括 GPU 上的资源）一并继承给子进程。这可能导致 CUDA 资源无法重新初始化的错误。因此，需要使用 `spawn` 来确保每个子进程都从头开始，并且可以正确初始化 CUDA 资源。

#### 代码示例：
```python
import multiprocessing

def task():
    print("This is a multiprocessing task!")

if __name__ == '__main__':
    # 使用 'spawn' 方法启动多进程
    multiprocessing.set_start_method('spawn')
    
    # 创建并启动一个子进程
    p = multiprocessing.Process(target=task)
    p.start()
    p.join()
```
解释：
- `multiprocessing.set_start_method('spawn')`：告诉 Python 使用 `spawn` 方式启动子进程。
- `p = multiprocessing.Process(target=task)`：创建一个新的子进程，执行 `task` 函数。
- `p.start()`：启动子进程。
- `p.join()`：等待子进程执行完成。

通过 `spawn`，每个子进程都是独立的 Python 解释器实例，这就避免了在 `fork` 中可能出现的资源冲突问题，特别是当你使用像 CUDA 这样需要显式初始化的资源时。

#### 总结：
- **fork**：效率高，但在使用 CUDA 等情况下可能不适用。
- **spawn**：启动一个全新的进程，适合需要独立资源初始化的情况，如 CUDA。
- 使用 `multiprocessing.set_start_method('spawn')` 来强制 Python 使用 `spawn` 方法启动子进程，确保不会发生像 CUDA 这样的冲突问题。

理解 Python 中的 multiprocessing.set_start_method('spawn')

在本篇文章中，我们将介绍 FLUX.1 文生图技术，并进行实际操作演示。

## 什么是 FLUX.1？
FLUX.1 是 Black Forest Labs 推出的文生图模型，详细介绍请参考官方文章：[Black Forest Labs 公告](https://blackforestlabs.ai/announcing-black-forest-labs/)




### 模型对比
FLUX.1 提供了三个不同的版本，适用于不同的使用场景。如下图所示：

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

**三个模型的区别：**

1. **FLUX.1 [pro]**：FLUX.1 的高级版本，提供最顶尖的图像生成性能，具有极高的提示跟随能力、图像质量和输出多样性。您可以通过 API 申请 FLUX.1 [pro] 的访问权限，也可以通过 Replicate 和 fal.ai 平台获取。同时，我们提供定制化的企业解决方案，如有需求请联系 flux@blackforestlabs.ai。

2. **FLUX.1 [dev]**：这是一个为非商业用途而开发的开放版本，基于 FLUX.1 [pro] 蒸馏生成，保持了类似的质量和提示响应能力。FLUX.1 [dev] 的权重可以在 HuggingFace 获取，并可以通过 Replicate 或 Fal.ai 直接尝试使用。如需商业应用，请联系 flux@blackforestlabs.ai。

3. **FLUX.1 [schnell]**：该版本速度最快，适用于本地开发和个人使用，基于 Apache 2.0 许可证开源发布。与 FLUX.1 [dev] 类似，权重可以在 HuggingFace 上获取，推理代码可在 GitHub 和 HuggingFace 的 Diffusers 中找到。我们很高兴宣布其已与 ComfyUI 完成首日集成。

### 项目地址

FLUX.1 [dev] 的项目地址为：[HuggingFace FLUX.1-dev](https://huggingface.co/black-forest-labs/FLUX.1-dev)

此外，您还可以参考 HuggingFace 的相关教程：[HuggingFace Diffusers教程](https://huggingface.co/docs/diffusers/main/en/api/pipelines/flux)

直接体验的网址：https://huggingface.co/spaces/black-forest-labs/FLUX.1-dev

## 实战教程

接下来，我们将进行 FLUX.1 文生图的推理部署实战。请按照以下步骤操作：

1. **创建 Python 虚拟环境**

首先，使用 Conda 创建一个 Python 3.10 及以上版本的虚拟环境：

```bash
conda create -n py310bizhi python=3.10 -y
conda activate py310bizhi
```

2. **安装 PyTorch 和相关依赖**

```bash
conda install pytorch torchvision torchaudio pytorch-cuda=12.1 -c pytorch -c nvidia -y
pip install torchao --extra-index-url https://download.pytorch.org/whl/cu121
pip install git+https://github.com/xhinker/sd_embed.git@main
pip install git+https://github.com/huggingface/diffusers.git
pip install -U transformers accelerate sentencepiece peft
```

3. **登录 HuggingFace 终端客户端**

```bash
huggingface-cli login
```

输入指令并输入您的 Token 进行登录。

4. **下载并使用模型**

以下代码展示了如何下载并使用 FLUX.1 [dev] 模型：

```python
import torch
from diffusers import FluxPipeline

# 指定模型下载的目录为当前工作目录
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev", 
    torch_dtype=torch.bfloat16, 
    cache_dir="./"  # 将模型下载到当前目录
)

pipe.enable_model_cpu_offload()  # 节省显存

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt,
    height=1024,
    width=1024,
    guidance_scale=3.5,
    num_inference_steps=50,
    max_sequence_length=512,
    generator=torch.Generator("cpu").manual_seed(0)
).images[0]

image.save("flux-dev.png")
```

显存占用：


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


5. **结果展示**

在执行过程中，模型会自动从仓库下载。请注意，下载过程中可能需要科学上网工具，最终结果将生成一张名为 `flux-dev.png` 的图片。

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

这是我生成的图片：


![flux-dev.png](/static/img/4ee591004cfcfca6825695da47d455d6.flux-dev.webp)


## 量化

To use Flux.1 in a 24G VRAM GPU, we need to quantize the Transformer model and T5 text encoder model to qfloat8 using optimum-quanto. see Quanto: a PyTorch quantization backend for Optimum and Memory-efficient Diffusion Transformers with Quanto and Diffusers to convert Diffusion model weights to qfloat8 so that we can use Flux in a 24G VRAM with Diffusers.

量化后速度还是慢，但显存低：

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


这是代码：


```python
from diffusers import DiffusionPipeline, FluxTransformer2DModel
from torchao.quantization import quantize_, int8_weight_only
import torch
from sd_embed.embedding_funcs import get_weighted_text_embeddings_flux1

# model_path = "black-forest-labs/FLUX.1-schnell"
model_path = "/ssd/xiedong/FLUX/models--black-forest-labs--FLUX.1-dev/snapshots/0ef5fff789c832c5c7f4e127f94c8b54bbcced44"

transformer = FluxTransformer2DModel.from_pretrained(
    model_path
    , subfolder="transformer"
    , torch_dtype=torch.bfloat16
)
quantize_(transformer, int8_weight_only())

pipe = DiffusionPipeline.from_pretrained(
    model_path
    , transformer=transformer
    , torch_dtype=torch.bfloat16
)

pipe.enable_model_cpu_offload()

# %%
prompt = """\
A dreamy, soft-focus photograph capturing a romantic Jane Austen movie scene, 
in the style of Agnes Cecile. Delicate watercolors, misty background, 
Regency-era couple, tender embrace, period clothing, flowing dress, dappled sunlight, 
ethereal glow, gentle expressions, intricate lace, muted pastels, serene countryside, 
timeless romance, poetic atmosphere, wistful mood, look at camera.
"""

prompt_embeds, pooled_prompt_embeds = get_weighted_text_embeddings_flux1(
    pipe=pipe
    , prompt=prompt
)
image = pipe(
    prompt_embeds=prompt_embeds
    , pooled_prompt_embeds=pooled_prompt_embeds
    , width=1024 + 512
    , height=1024
    , num_inference_steps=50
    , guidance_scale=4.0
).images[0]

image.save("flux-dev2.png")

```

## 全gpu跑

速度很快：

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


这是代码：

```bash
import torch
from diffusers import FluxPipeline

# 指定模型下载目录为已有的目录
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
    cache_dir="/ssd/xiedong/FLUX/"
)
pipe.to('cuda:0')

# pipe.enable_model_cpu_offload()  # 节省显存

prompt = "A cat holding a sign that says hello world"
image = pipe(
    prompt,
    height=1024,
    width=1024,
    guidance_scale=3.5,
    num_inference_steps=50,
    max_sequence_length=512,
).images[0]

image.save("flux-dev.png")

```

## docker环境

### 制作docker环境

无法准确看到对应显卡，只能用docker切分显卡环境了。

制作docker环境：


```bash
docker pull pytorch/pytorch:2.4.1-cuda12.1-cudnn9-devel

docker run -it --gpus device=1 -v /ssd/xiedong/bizhi_generate_images:/ssd/xiedong/bizhi_generate_images -v /ssd/xiedong/FLUX:/ssd/xiedong/FLUX pytorch/pytorch:2.4.1-cuda12.1-cudnn9-devel bash

pip install torchao --extra-index-url https://download.pytorch.org/whl/cu121
apt update
apt install git vim curl wget -y
pip install git+https://github.com/xhinker/sd_embed.git@main
pip install git+https://github.com/huggingface/diffusers.git
pip install -U transformers accelerate sentencepiece peft


# 安装中文语言包
apt-get install -y locales
# 生成简体中文 UTF-8 语言环境
locale-gen zh_CN.UTF-8
# 设置默认语言环境为中文
export LANG=zh_CN.UTF-8

apt-get clean && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

pip cache purge

docker commit b58e6e463809 kevinchina/deeplearning:flux

docker push kevinchina/deeplearning:flux
```

### 脚本

这个python脚本保存为x10_flux_all_gen_no_mutil.py

调用方法是：

`python x10_flux_all_gen_no_mutil.py 0 0`

`python x10_flux_all_gen_no_mutil.py 1 1000`

`python x10_flux_all_gen_no_mutil.py 2 2000`

就是数据分3分跑，每一份保存的其实点不一样，分别是0、1000、2000这样的保存其实点，我总的数据就1k多。

```python
import argparse
import torch
from diffusers import DiffusionPipeline
import os
import json
import gc
from sd_embed.embedding_funcs import get_weighted_text_embeddings_flux1


# 从JSON文件中读取所有response提示词
def read_prompts(file_path):
    with open(file_path, 'r') as file:
        data = json.load(file)
    return [entry['response'] for entry in data if entry['status'] == 'success']


# 创建保存图像的目录
def create_directory(directory_path):
    if not os.path.exists(directory_path):
        os.makedirs(directory_path)


# 保存提示词到文本文件
def save_prompt_to_txt(file_path, prompt):
    with open(file_path, 'w') as file:
        file.write(prompt)


# 生成图像
def generate_images(prompts, start_idx):
    model_path = "/ssd/xiedong/FLUX/models--black-forest-labs--FLUX.1-dev/snapshots/0ef5fff789c832c5c7f4e127f94c8b54bbcced44"

    pipe = DiffusionPipeline.from_pretrained(
        model_path
        , torch_dtype=torch.bfloat16
    )

    pipe.to('cuda:0')

    for i, prompt in enumerate(prompts):
        image_filename = f"img_flux/{start_idx + i:04d}.png"
        txt_filename = f"img_flux/{start_idx + i:04d}.txt"

        if os.path.exists(image_filename) and os.path.exists(txt_filename):
            continue

        prompt_embeds, pooled_prompt_embeds = get_weighted_text_embeddings_flux1(
            pipe=pipe
            , prompt=prompt
        )
        image = pipe(
            prompt_embeds=prompt_embeds
            , pooled_prompt_embeds=pooled_prompt_embeds
            , width=1024 + 512
            , height=1024
            , num_inference_steps=50
            , guidance_scale=4.0
        ).images[0]

        image.save(image_filename)
        save_prompt_to_txt(txt_filename, prompt)

        print(f"GPU cuda:0: Saved image {image_filename} and prompt text {txt_filename}")

        gc.collect()
        torch.cuda.empty_cache()


if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Run app.py with GPU')
    parser.add_argument('gpu_index', type=int, help='The index of the GPU (e.g. 0, 1, 2 for cuda:0, cuda:1, cuda:2)')
    parser.add_argument('start_idx', type=int, help='start_idx')
    args = parser.parse_args()

    # JSON文件路径
    json_file = 'res_answer.json'
    prompts = read_prompts(json_file)

    # 创建保存图像和文本文件的目录
    output_dir = 'img_flux'
    create_directory(output_dir)

    # 根据显卡编号将提示词等分
    num_gpus = 3  # 假设有3个显卡
    prompts_split = [prompts[i::num_gpus] for i in range(num_gpus)]

    # 选取当前GPU要处理的那一部分提示词
    selected_prompts = prompts_split[args.gpu_index]

    # 开始生成图像，传入与该GPU对应的提示词部分
    generate_images(selected_prompts, start_idx=args.start_idx)


```

### 跑镜像
显卡0

```bash
docker run -it --gpus device=0 -v /ssd/xiedong/bizhi_generate_images:/ssd/xiedong/bizhi_generate_images -v /ssd/xiedong/FLUX:/ssd/xiedong/FLUX kevinchina/deeplearning:flux bash

cd /ssd/xiedong/bizhi_generate_images

python x10_flux_all_gen_no_mutil.py 0 0
```


显卡1

```bash
docker run -it --gpus device=1 -v /ssd/xiedong/bizhi_generate_images:/ssd/xiedong/bizhi_generate_images -v /ssd/xiedong/FLUX:/ssd/xiedong/FLUX kevinchina/deeplearning:flux bash

cd /ssd/xiedong/bizhi_generate_images

python x10_flux_all_gen_no_mutil.py 1 1000
```

显卡2

```bash
docker run -it --gpus device=2 -v /ssd/xiedong/bizhi_generate_images:/ssd/xiedong/bizhi_generate_images -v /ssd/xiedong/FLUX:/ssd/xiedong/FLUX kevinchina/deeplearning:flux bash

cd /ssd/xiedong/bizhi_generate_images

python x10_flux_all_gen_no_mutil.py 2 2000
```

【深度学习】FLUX.1，文生图，推理部署实战教程

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

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

AutoGPTQ 安装教程与问题解决

参考教程：

博客文章：理解 Python 中的 multiprocessing.set_start_method('spawn')

什么是 FLUX.1？

博客文章：理解 Python 中的 `multiprocessing.set_start_method('spawn')`