### 博客文章：理解 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，文生图，推理部署实战教程

### 项目地址及配置指南

我们使用合成数据和经过筛选的公开数据来训练我们的模型。该模型已在 10 亿张图像上进行了预训练。微调数据包括 3000 万张专注于特定视觉内容和风格的高质量美学图像，以及 300 万张偏好数据图像。


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

项目地址：[Stable Diffusion 3 Medium](https://huggingface.co/stabilityai/stable-diffusion-3-medium)

为了顺利拉取项目资源，您需要科学上网，并获取 Hugging Face Token。下面是获取 Token 的步骤。

### 如何获取 Hugging Face Token

1. 前往 [Hugging Face 官方教程](https://huggingface.co/docs/hub/security-tokens)，了解 Token 相关信息。
2. 访问 [Hugging Face Token 管理页面](https://huggingface.co/settings/tokens)，并确保您已注册或登录账号。
3. 在 Token 页面点击“新增 Token”，并确保赋予仓库访问权限。参考下图：

![Token 设置示例](/static/img/9be2f2d779f912a78edffd37f5e6721d.image.webp)

4. 成功生成的 Token 格式类似如下：

```
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
```

复制并保存该 Token。





### 环境配置



接下来，使用 Conda 创建一个 Python 3.10 及以上版本的虚拟环境。


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

conda activate py310bizhi

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 # full options are cpu/cu118/cu121/cu124

pip install git+https://github.com/xhinker/sd_embed.git@main

```



并安装以下依赖包：


```bash
pip install git+https://github.com/huggingface/diffusers.git

pip install -U transformers accelerate sentencepiece peft
```

### 运行代码

完成环境配置后，下载并执行以下链接中的 `app.py` 文件。该代码会自动拉取项目仓库内容，并生成一个基于 Gradio 的前端页面：

[下载 app.py](https://huggingface.co/spaces/ameerazam08/SD-3-Medium-GPU/resolve/main/app.py)

需要修改app.py里面的Token变量。

也就是这个：
https://huggingface.co/spaces/ameerazam08/SD-3-Medium-GPU/blob/main/app.py




### 下载仓库代码解读

代码是：

```python
import os
import random
import uuid

import gradio as gr
import numpy as np
from PIL import Image
import spaces
import torch
from diffusers import StableDiffusion3Pipeline, DPMSolverMultistepScheduler, AutoencoderKL
from huggingface_hub import snapshot_download

huggingface_token = os.getenv("HF_TOKEN")

model_path = snapshot_download(
    repo_id="stabilityai/stable-diffusion-3-medium", 
    # revision="refs/pr/26", # 这个删除就可以下载最新代码
    repo_type="model", 
    ignore_patterns=["*.md", "*..gitattributes"],
    local_dir="stable-diffusion-3-medium",
    token=huggingface_token,
    )
```

这段代码主要用于从 Hugging Face Hub 下载特定的模型仓库（repository）到本地。下面逐步解释代码的功能及其具体操作：

1. **导入必要的库和模块**：
2. 
    - **os**：用于与操作系统进行交互，如获取环境变量。
    - **random** 和 **uuid**：用于生成随机数和唯一标识符，可能在后续代码中用于生成随机输入或标识。
    - **gradio**：用于构建用户界面，可能用于展示生成的图像或接受用户输入。
    - **numpy** 和 **PIL**：用于处理图像数据。
    - **spaces** 和 **torch**：与 Hugging Face 的 Spaces 和 PyTorch 相关，用于深度学习模型的加载和运行。
    - **diffusers** 模块中的类：用于处理和运行稳定扩散模型（Stable Diffusion）。
    - **huggingface_hub.snapshot_download**：用于从 Hugging Face Hub 下载模型的快照。

2. **获取 Hugging Face 的访问令牌**：
    ```python
    huggingface_token = os.getenv("HF_TOKEN")
    ```
    这里通过环境变量 `HF_TOKEN` 获取 Hugging Face 的访问令牌，用于身份验证和授权访问私有模型或需要权限的资源。

3. **下载模型仓库的快照**：
    ```python
    model_path = snapshot_download(
        repo_id="stabilityai/stable-diffusion-3-medium", 
        revision="refs/pr/26",
        repo_type="model", 
        ignore_patterns=["*.md", "*..gitattributes"],
        local_dir="stable-diffusion-3-medium",
        token=huggingface_token,
    )
    ```
    - **repo_id**：指定要下载的仓库名称，这里是 `"stabilityai/stable-diffusion-3-medium"`，即稳定扩散 3 中等版本的模型。
    - **revision**：指定要下载的特定版本或分支，这里是 `"refs/pr/26"`，通常表示一个 Pull Request 的第 26 号。
    - **repo_type**：指定仓库类型，这里是 `"model"`，表示这是一个模型仓库。
    - **ignore_patterns**：指定要忽略的文件模式，这里忽略了所有 `.md` 文件和 `.gitattributes` 文件，避免下载不必要的文档或配置文件。
    - **local_dir**：指定本地保存目录，这里设置为 `"stable-diffusion-3-medium"`，即当前工作目录下的一个名为 `stable-diffusion-3-medium` 的文件夹。
    - **token**：使用前面获取的 Hugging Face 访问令牌进行身份验证。

    **功能说明**：
    - `snapshot_download` 函数会从 Hugging Face Hub 下载指定仓库的快照（即特定版本的文件集合）。
    - 由于指定了 `ignore_patterns`，并不会下载整个仓库，而是排除了匹配这些模式的文件。
    - 下载的内容会保存在当前工作目录下的 `stable-diffusion-3-medium` 文件夹中。如果该文件夹不存在，函数会自动创建。

4. **总结**：
    - **是否下载完整的仓库**：不完全是。代码通过 `ignore_patterns` 参数排除了部分文件（如 `.md` 和 `.gitattributes` 文件），因此下载的内容是仓库的一个子集，主要是模型相关的文件，而非整个仓库的所有内容。
    - **下载位置**：下载的文件会保存在当前工作目录下名为 `stable-diffusion-3-medium` 的文件夹中。你可以在运行脚本的目录中找到这个文件夹，里面包含了下载的模型文件和相关资源。

如果你希望查看下载的具体内容，可以进入 `stable-diffusion-3-medium` 文件夹，查看其中的文件和子目录。此外，如果需要下载整个仓库而不忽略任何文件，可以移除或调整 `ignore_patterns` 参数。

### 最新仓库

删除代码里这一行，从而下载到最新的仓库文件：revision="refs/pr/26"

修改后就可以下载最新的模型：_medium_incl_clips_t5xxlfp16.safetensors


### 推理教程

https://huggingface.co/docs/diffusers/main/en/api/pipelines/stable_diffusion/stable_diffusion_3

### 推理代码

介绍：

1. sd3_medium.safetensors 包括 MMDiT 和 VAE 权重，但不包括任何文本编码器。
2. sd3_medium_incl_clips_t5xxlfp16.safetensors包含所有必要的权重，包括 T5XXL 文本编码器的 fp16 版本。
3. sd3_medium_incl_clips_t5xxlfp8.safetensors包含所有必要的权重，包括 T5XXL 文本编码器的 fp8 版本，在质量和资源要求之间提供平衡。
4. sd3_medium_incl_clips.safetensors包括除 T5XXL 文本编码器之外的所有必要权重。它需要的资源很少，但如果没有 T5XXL 文本编码器，模型的性能会有所不同。
5. 该text_encoders文件夹包含三个文本编码器及其原始模型卡链接，以方便用户使用。text_encoders 文件夹中的所有组件（以及嵌入在其他包中的等效组件）均受其各自的原始许可证约束。
6. 该example_workfows文件夹包含舒适的工作流程示例。


登录，输入指令后给Token：

```bash
huggingface-cli login
```

然后执行推理代码：

sd3_medium_incl_clips_t5xxlfp16.safetensors推理代码：


```python
import torch
from diffusers import StableDiffusion3Pipeline

# 从单一文件加载模型，并启用 T5XXL 文本编码器 (fp16 版本)
pipe = StableDiffusion3Pipeline.from_single_file(
    "/ssd/xiedong/SD-3-Medium-GPU/stable-diffusion-3-medium/sd3_medium_incl_clips_t5xxlfp16.safetensors",
    torch_dtype=torch.float16,
)

# 启用 CPU 模型卸载以节省显存资源
pipe.enable_model_cpu_offload()

# 将模型移动到 GPU
pipe.to("cuda")

# 设置生成图片的提示词 (prompt)
prompt = "a picture of a cat holding a sign that says hello world"

# 执行推理并生成图像
image = pipe(
    prompt=prompt,
    num_inference_steps=28,  # 设置推理步数
    height=1024,             # 设置图像高度
    width=1024,              # 设置图像宽度
    guidance_scale=7.0,      # 设置引导比例
).images[0]

# 保存生成的图像
image.save('sd3_t5_fp16_output.png')

```

这样就可以得到一只肥猫：


![sd3_t5_fp16_output.png](/static/img/edcc36d4c6fcc59eecd2d1f26ca581ce.sd3_t5_fp16_output.webp)



### 最佳实践

在提示词的使用上，SD3 引入了显著的变化，现在用户可以输入长达 10,000 个字符的提示词。这一突破极大地拓展了我们与模型互动的空间，克服了以往 CLIP 文本编码器仅支持 77 个令牌的限制。虽然提示词过长可能会让模型忽略部分内容，但这一功能却极大提升了模型在生成图像时对提示词的遵从度，帮助用户实现更加精细的控制。

然而，值得注意的是，SD3 在训练过程中并未使用负向提示词。因此，负向提示词在这个模型中可能不会如预期那样有效，甚至会带来噪音或不必要的输出变化。这意味着，我们需要重新审视提示词的使用策略。

对于撰写提示词，建议大家使用清晰、详细的描述性语句，而不是简单的关键词堆叠。这将有助于模型更好地理解我们的意图，从而生成更符合预期的图像。


### 占用显存

删除这句后pipe.enable_model_cpu_offload()，占用显存17G左右。

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



### 多进程生图

将文本'res_answer.txt'里每一行都用来生图，3个进程，一个显卡里一个进程：


```python
import torch
from diffusers import StableDiffusion3Pipeline
import multiprocessing
import os


# 从文件中读取所有提示词
def read_prompts(file_path):
    with open(file_path, 'r') as file:
        prompts = file.readlines()
    return [prompt.strip() for prompt in prompts]


# 每个进程的工作函数
def generate_images(gpu_id, prompts, start_idx):
    # 加载模型
    pipe = StableDiffusion3Pipeline.from_single_file(
        "/ssd/xiedong/SD-3-Medium-GPU/stable-diffusion-3-medium/sd3_medium_incl_clips_t5xxlfp16.safetensors",
        torch_dtype=torch.float16,
    )

    # 将模型移动到对应的 GPU
    pipe.to(f"cuda:{gpu_id}")

    # 生成图像
    for i, prompt in enumerate(prompts):
        image = pipe(
            prompt=prompt,
            num_inference_steps=28,
            height=1024,
            width=1024,
            guidance_scale=7.0,
        ).images[0]

        # 保存图像，文件名从 start_idx 开始递增
        image_path = f"img_sd3/{start_idx + i:04d}.png"
        image.save(image_path)
        print(f"GPU {gpu_id}: Saved image {image_path}")


if __name__ == "__main__":
    # 提示词文件路径
    prompt_file = 'res_answer.txt'
    prompts = read_prompts(prompt_file)

    # 将提示词分成三份，分别由三个进程处理
    num_gpus = 3
    prompts_split = [prompts[i::num_gpus] for i in range(num_gpus)]

    # 创建多个进程
    processes = []
    for gpu_id in range(num_gpus):
        start_idx = gpu_id * len(prompts_split[gpu_id])
        p = multiprocessing.Process(target=generate_images, args=(gpu_id, prompts_split[gpu_id], start_idx))
        processes.append(p)
        p.start()

    # 等待所有进程完成
    for p in processes:
        p.join()

```

### 更高级的生图代码-突破77 tokens 限制

需要这个库，克服77个tokens限制：

https://github.com/xhinker/sd_embed?tab=readme-ov-file#stable-diffusion-3

安装sd_embed：


```bash
pip install torchao --extra-index-url https://download.pytorch.org/whl/cu121 # full options are cpu/cu118/cu121/cu124

pip install git+https://github.com/xhinker/sd_embed.git@main
```

就可以跑生图：


```bash
import gc
import torch
from diffusers import StableDiffusion3Pipeline
from sd_embed.embedding_funcs import get_weighted_text_embeddings_sd3

# 加载模型
pipeline = StableDiffusion3Pipeline.from_single_file(
    "/ssd/xiedong/SD-3-Medium-GPU/stable-diffusion-3-medium/sd3_medium_incl_clips_t5xxlfp16.safetensors",
    torch_dtype=torch.float16,
)
# 将模型移动到对应的 GPU
pipeline.to('cuda:0')

prompt = """\
A cyberpunk cockpit of a futuristic aircraft, filled with glowing screens and intricate controls, surrounded by sleek metallic panels. The cabin is illuminated by a spectrum of neon colors, primarily vibrant blues and purples, creating a high-tech ambiance. Through the large, panoramic windows, a sprawling metropolis can be seen below, with bright neon lights and bustling streets, reflecting the essence of a thriving city at night. The cockpit is framed with high-definition digital readouts displaying flight data, while a pilot, clad in an illuminated visor and tactical gear, focuses intently on the controls. The scene is dynamic, with a sense of speed emphasized by streaks of light visible through the windows, captured in sharp detail using a super long lens.
"""

neg_prompt = """\
deformed, distorted, disfigured, poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, NSFW
"""

(
    prompt_embeds
    , prompt_neg_embeds
    , pooled_prompt_embeds
    , negative_pooled_prompt_embeds
) = get_weighted_text_embeddings_sd3(
    pipeline
    , prompt=prompt
    , neg_prompt=neg_prompt
)

image = pipeline(
    prompt_embeds=prompt_embeds
    , negative_prompt_embeds=prompt_neg_embeds
    , pooled_prompt_embeds=pooled_prompt_embeds
    , negative_pooled_prompt_embeds=negative_pooled_prompt_embeds
    , num_inference_steps=30
    , height=1024
    , width=1024 + 512
    , guidance_scale=4.0
    , generator=torch.Generator('cuda:0').manual_seed(2)
).images[0]

# 构建保存路径和文件名
image_filename = f"1.png"

# 保存图像
image.save(image_filename)

del prompt_embeds, prompt_neg_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds
gc.collect()
torch.cuda.empty_cache()

```

效果是ok的：


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


警告是正常的，不用理会：

Token indices sequence length is longer than the specified maximum sequence length for this model (107 > 77). Running this sequence through the model will result in indexing errors


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


数据为json格式：

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

多进程跑这些数据生图：


```bash
import torch
from diffusers import StableDiffusion3Pipeline
import multiprocessing
import os
import json
import gc
import torch
from diffusers import StableDiffusion3Pipeline
from sd_embed.embedding_funcs import get_weighted_text_embeddings_sd3


# 从JSON文件中读取所有response提示词
def read_prompts(file_path):
    with open(file_path, 'r') as file:
        data = json.load(file)
    # 提取所有状态为 "success" 的 response 字段
    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(gpu_id, prompts, start_idx):
    # 加载模型
    pipeline = StableDiffusion3Pipeline.from_single_file(
        "/ssd/xiedong/SD-3-Medium-GPU/stable-diffusion-3-medium/sd3_medium_incl_clips_t5xxlfp16.safetensors",
        torch_dtype=torch.float16,
    )
    # 将模型移动到对应的 GPU
    pipeline.to(gpu_id)

    # 生成图像
    for i, prompt in enumerate(prompts):

        neg_prompt = """\
        deformed, distorted, disfigured, poorly drawn, bad anatomy, wrong anatomy, extra limb, missing limb, floating limbs, mutated hands and fingers, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, NSFW
        """

        (
            prompt_embeds
            , prompt_neg_embeds
            , pooled_prompt_embeds
            , negative_pooled_prompt_embeds
        ) = get_weighted_text_embeddings_sd3(
            pipeline
            , prompt=prompt
            , neg_prompt=neg_prompt
        )

        image = pipeline(
            prompt_embeds=prompt_embeds
            , negative_prompt_embeds=prompt_neg_embeds
            , pooled_prompt_embeds=pooled_prompt_embeds
            , negative_pooled_prompt_embeds=negative_pooled_prompt_embeds
            , num_inference_steps=30
            , height=1024
            , width=1024 + 512
            , guidance_scale=4.0
            , generator=torch.Generator(gpu_id).manual_seed(2)
        ).images[0]

        # 构建保存路径和文件名
        image_filename = f"img_sd3/{start_idx + i:04d}.png"
        txt_filename = f"img_sd3/{start_idx + i:04d}.txt"

        # 保存图像
        image.save(image_filename)

        # 保存提示词到文本文件
        save_prompt_to_txt(txt_filename, prompt)

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

        del prompt_embeds, prompt_neg_embeds, pooled_prompt_embeds, negative_pooled_prompt_embeds
        gc.collect()
        torch.cuda.empty_cache()


if __name__ == "__main__":
    multiprocessing.set_start_method('spawn')

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

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

    # 定义任务列表，指定每个进程要使用的GPU
    tasks = ["cuda:0", "cuda:1", "cuda:2"]  # 可以根据需求修改此列表来控制进程和GPU的分配

    # 将提示词分成与tasks长度相等的份数
    num_tasks = len(tasks)
    prompts_split = [prompts[i::num_tasks] for i in range(num_tasks)]

    # 创建多个进程
    processes = []
    for idx, gpu_id in enumerate(tasks):
        start_idx = idx * len(prompts_split[idx])
        p = multiprocessing.Process(target=generate_images, args=(gpu_id, prompts_split[idx], start_idx))
        processes.append(p)
        p.start()

    # 等待所有进程完成
    for p in processes:
        p.join()

```

stable-diffusion-3-medium部署体验实战教学

fooocus-api，得到一些训练图片的过程

## 弹簧器与阻尼器


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






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


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

## 并联和串联


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


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


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


并联结构的系统方程包含质量、阻尼、刚度项，适用于描述自由振动和强阻尼系统，振动衰减较快。

串联结构的系统方程主要依赖位移和速度，通常用于柔性或低频振动系统，振动衰减较慢。

## 题目1



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


**解答：**

我们需要求解机械系统的传递函数 $G(s) = \dfrac{X_o(s)}{X_i(s)}$。为此，按照以下步骤进行分析。

### 1. 引入辅助点并建立力平衡方程

在阻尼器 $f_1$ 和弹簧 $K_1$ 之间引入一个辅助点，设其位移为 $x$，方向向下。系统的结构如下：

- **点 1**：位移为 $x_i$
- 阻尼器 $f_2$ 和弹簧 $K_2$ 并联，连接点 1 和点 2
- **点 2**：位移为 $x_o$
- 阻尼器 $f_1$，连接点 2 和辅助点
- 弹簧 $K_1$，连接辅助点和地面

### 2. 建立力平衡方程

对于点 2，根据力平衡，可得：

1. **从点 1 到点 2 的力：**

   - 弹簧 $K_2$ 的力：$K_2(x_i - x_o)$
   - 阻尼器 $f_2$ 的力：$f_2 \dot{(x_i - x_o)}$

2. **从点 2 到辅助点的力：**

   - 阻尼器 $f_1$ 的力：$f_1 \dot{(x_o - x)}$

因此，点 2 的力平衡方程为：

$$
K_2(x_i - x_o) + f_2 \dot{(x_i - x_o)} = f_1 \dot{(x_o - x)}
$$

对于辅助点，根据力平衡，可得：

- 弹簧 $K_1$ 的力：$K_1 x$
- 阻尼器 $f_1$ 的力：$f_1 \dot{(x_o - x)}$

由于弹簧 $K_1$ 和阻尼器 $f_1$ 连接在一起，力相等，因此有：

$$
K_1 x = f_1 \dot{(x_o - x)}
$$

### 3. 对方程进行拉普拉斯变换

假设初始条件为零，对上述两个方程进行拉普拉斯变换：

1. 对第一个方程：

$$
K_2 [X_i(s) - X_o(s)] + f_2 s [X_i(s) - X_o(s)] = f_1 s [X_o(s) - X(s)]
$$

2. 对第二个方程：

$$
K_1 X(s) = f_1 s [X_o(s) - X(s)]
$$

### 4. 解出 $X(s)$ 与 $X_o(s)$ 的关系

从第二个方程解出 $X(s)$：

$$
\begin{aligned}
K_1 X(s) &= f_1 s [X_o(s) - X(s)] \\
K_1 X(s) + f_1 s X(s) &= f_1 s X_o(s) \\
X(s) [K_1 + f_1 s] &= f_1 s X_o(s) \\
X(s) &= \frac{f_1 s}{K_1 + f_1 s} X_o(s)
\end{aligned}
$$

### 5. 消除 $X(s)$，建立 $X_i(s)$ 和 $X_o(s)$ 的关系

将 $X(s)$ 代入第一个方程：

$$
K_2 [X_i(s) - X_o(s)] + f_2 s [X_i(s) - X_o(s)] = f_1 s \left[ X_o(s) - \frac{f_1 s}{K_1 + f_1 s} X_o(s) \right]
$$

简化右侧：

$$
\begin{aligned}
f_1 s \left[ X_o(s) - \frac{f_1 s}{K_1 + f_1 s} X_o(s) \right] &= f_1 s X_o(s) \left[ 1 - \frac{f_1 s}{K_1 + f_1 s} \right] \\
&= f_1 s X_o(s) \left( \frac{K_1}{K_1 + f_1 s} \right) \\
&= \frac{K_1 f_1 s}{K_1 + f_1 s} X_o(s)
\end{aligned}
$$

因此，方程变为：

$$
\left( K_2 + f_2 s \right) [X_i(s) - X_o(s)] = \frac{K_1 f_1 s}{K_1 + f_1 s} X_o(s)
$$

整理得：

$$
\left( K_2 + f_2 s \right) X_i(s) = \left( K_2 + f_2 s + \frac{K_1 f_1 s}{K_1 + f_1 s} \right) X_o(s)
$$

### 6. 求解传递函数 $G(s)$

传递函数为：

$$
G(s) = \frac{X_o(s)}{X_i(s)} = \frac{K_2 + f_2 s}{K_2 + f_2 s + \dfrac{K_1 f_1 s}{K_1 + f_1 s}}
$$

### 7. 化简传递函数

首先，将分母中的分式合并：

$$
\begin{aligned}
\text{分母} &= K_2 + f_2 s + \frac{K_1 f_1 s}{K_1 + f_1 s} \\
&= \frac{(K_2 + f_2 s)(K_1 + f_1 s) + K_1 f_1 s}{K_1 + f_1 s} \\
&= \frac{K_2 K_1 + K_2 f_1 s + f_2 s K_1 + f_2 f_1 s^2 + K_1 f_1 s}{K_1 + f_1 s}
\end{aligned}
$$

将分子也乘以 $K_1 + f_1 s$：

$$
\text{分子} = (K_2 + f_2 s)(K_1 + f_1 s)
$$

因此，传递函数变为：

$$
G(s) = \frac{(K_2 + f_2 s)(K_1 + f_1 s)}{(K_2 + f_2 s)(K_1 + f_1 s) + K_1 f_1 s}
$$

### 8. 展开并整理

展开分子：

$$
\text{分子} = K_2 K_1 + K_2 f_1 s + f_2 s K_1 + f_2 f_1 s^2
$$

展开分母：

$$
\begin{aligned}
\text{分母} &= K_2 K_1 + K_2 f_1 s + f_2 s K_1 + f_2 f_1 s^2 + K_1 f_1 s \\
&= K_2 K_1 + (K_2 f_1 + f_2 K_1 + K_1 f_1) s + f_2 f_1 s^2
\end{aligned}
$$

### 9. 写成标准形式

将分子和分母写成关于 $s$ 的多项式：

$$
\begin{aligned}
\text{分子} &= f_1 f_2 s^2 + (K_1 f_2 + K_2 f_1) s + K_1 K_2 \\
\text{分母} &= f_1 f_2 s^2 + (K_1 f_2 + K_2 f_1 + K_1 f_1) s + K_1 K_2
\end{aligned}
$$

### 10. 归一化处理

为了进一步简化，我们将分子和分母同时除以 $K_1 K_2$：

$$
G(s) = \frac{\dfrac{f_1 f_2}{K_1 K_2} s^2 + \left( \dfrac{f_1}{K_1} + \dfrac{f_2}{K_2} \right) s + 1}{\dfrac{f_1 f_2}{K_1 K_2} s^2 + \left( \dfrac{f_1}{K_1} + \dfrac{f_2}{K_2} + \dfrac{f_1}{K_2} \right) s + 1}
$$

### 11. 最终的传递函数

得到机械系统的传递函数：

$$
G(s) = \frac{\dfrac{f_1 f_2}{K_1 K_2} s^2 + \left( \dfrac{f_1}{K_1} + \dfrac{f

_2}{K_2} \right) s + 1}{\dfrac{f_1 f_2}{K_1 K_2} s^2 + \left( \dfrac{f_1}{K_1} + \dfrac{f_2}{K_2} + \dfrac{f_1}{K_2} \right) s + 1}
$$

### 总结

通过引入辅助点并建立力平衡方程，利用拉普拉斯变换，将位移 $X(s)$ 表示为 $X_o(s)$ 的函数，进而消除 $X(s)$，建立了 $X_i(s)$ 和 $X_o(s)$ 之间的关系。经过代数化简，得到了机械系统的传递函数 $G(s)$。

## 题目1的问题

**解答：**

您的问题主要是关于如何确定力的方向，以及为什么力的表达式是那样的。让我一步步解释。

### 1. 力的方向如何确定？

在机械系统中，力的方向取决于元件的特性和位移（或速度）的方向。一般来说：

- **弹簧力**：弹簧力的方向总是试图恢复弹簧的原始长度，即阻止弹簧被拉伸或压缩。它的大小为 $F = K \Delta x$，方向与位移的增量 $\Delta x$ 相反。

- **阻尼器力**：阻尼器的力与两端相对速度成正比，大小为 $F = f \Delta \dot{x}$，方向与相对速度 $\Delta \dot{x}$ 相反。

### 2. 为什么弹簧 $K_2$ 的力是 $K_2(x_i - x_o)$？

- **位移定义**：设定向下为正方向。$x_i$ 是点 1 的位移，$x_o$ 是点 2 的位移。

- **弹簧的伸缩量**：弹簧 $K_2$ 的伸缩量为 $\Delta x = x_o - x_i$。因为一端在点 1（位移 $x_i$），另一端在点 2（位移 $x_o$）。

- **弹簧力的计算**：弹簧力为 $F = K_2 \Delta x = K_2(x_o - x_i)$。但是，由于力的方向与伸缩量相反，所以作用在点 2 上的弹簧力为：

$$
F_{K_2} = -K_2(x_o - x_i) = K_2(x_i - x_o)
$$

这里，负号表示力的方向与 $x_o - x_i$ 相反。

### 3. 为什么阻尼器 $f_2$ 的力是 $f_2 \dot{(x_i - x_o)}$？

- **相对速度**：阻尼器 $f_2$ 的两端位移为 $x_i$ 和 $x_o$，因此相对速度为 $\Delta \dot{x} = \dot{x}_o - \dot{x}_i$。

- **阻尼力的计算**：阻尼力为 $F = f_2 \Delta \dot{x} = f_2(\dot{x}_o - \dot{x}_i)$。同样，力的方向与相对速度相反，所以作用在点 2 上的阻尼力为：

$$
F_{f_2} = -f_2(\dot{x}_o - \dot{x}_i) = f_2(\dot{x}_i - \dot{x}_o)
$$

### 4. 为什么点 2 可以进行力平衡？

在力学中，如果我们考虑的是质量为零或忽略不计的节点（即点 2 没有质量或惯性），那么在该点上的所有力的和应该为零（静力平衡），或者等于质量乘以加速度（动力平衡）。在这个问题中，我们假设点 2 的质量可以忽略，因此可以进行力平衡。

### 5. 点 2 的力平衡方程如何建立？

**作用在点 2 上的力：**

- **来自弹簧 $K_2$ 的力**：$F_{K_2} = K_2(x_i - x_o)$

- **来自阻尼器 $f_2$ 的力**：$F_{f_2} = f_2(\dot{x}_i - \dot{x}_o)$

- **来自阻尼器 $f_1$ 的力**：阻尼器 $f_1$ 连接点 2 和辅助点（位移为 $x$），相对速度为 $\dot{x}_o - \dot{x}$。阻尼器的力为：

$$
F_{f_1} = f_1(\dot{x}_o - \dot{x})
$$

力的方向是与相对速度相反，但在这里，我们将力视为作用在点 2 上的力，所以直接使用这个表达式。

**力平衡方程：**

在点 2 上，所有作用在其上的力的代数和应为零：

$$
F_{K_2} + F_{f_2} - F_{f_1} = 0
$$

这里，$F_{f_1}$ 是作用在点 2 上，由于阻尼器 $f_1$ 连接点 2 和辅助点，力的方向与相对速度一致（因为阻尼力总是阻碍相对运动）。

因此，力平衡方程为：

$$
K_2(x_i - x_o) + f_2(\dot{x}_i - \dot{x}_o) = f_1(\dot{x}_o - \dot{x})
$$

### 6. 为什么力的方向如此选择？

- **弹簧力**：如果 $x_o > x_i$，即点 2 向下移动多于点 1，弹簧被拉伸，弹簧力试图将点 2 拉回，作用在点 2 上的力向上，为负方向，因此 $F_{K_2} = K_2(x_i - x_o)$。

- **阻尼力**：同理，若 $\dot{x}_o > \dot{x}_i$，即点 2 的速度大于点 1，阻尼器力试图阻碍这种相对运动，作用在点 2 上的力为向上，即 $F_{f_2} = f_2(\dot{x}_i - \dot{x}_o)$。

- **阻尼器 $f_1$ 的力**：阻尼器连接点 2 和辅助点，若 $\dot{x}_o > \dot{x}$，阻尼器力试图阻碍点 2 相对于辅助点的向下运动，作用在点 2 上的力为向上，所以力为 $F_{f_1} = f_1(\dot{x}_o - \dot{x})$。

### 7. 总结

因此，作用在点 2 上的力平衡方程就是将所有作用在点 2 上的力求和，并设其代数和为零：

$$
\text{作用在点 2 上的上行力（正）} = \text{作用在点 2 上的下行力（负）}
$$

也就是说：

$$
K_2(x_i - x_o) + f_2(\dot{x}_i - \dot{x}_o) = f_1(\dot{x}_o - \dot{x})
$$

### 8. 关于辅助点的力平衡

对于辅助点（位移为 $x$），同样进行力平衡：

- **来自阻尼器 $f_1$ 的力**：$F_{f_1} = f_1(\dot{x}_o - \dot{x})$，作用在辅助点上的力方向与相对速度相反。

- **来自弹簧 $K_1$ 的力**：$F_{K_1} = K_1 x$，弹簧连接辅助点和地面，假设地面位移为零。

力平衡方程为：

$$
f_1(\dot{x}_o - \dot{x}) = K_1 x
$$

### 9. 总体理解

- **点 2 的力平衡**：考虑所有连接到点 2 的元件（弹簧 $K_2$、阻尼器 $f_2$、阻尼器 $f_1$）产生的力。

- **力的方向**：根据元件的特性（弹簧力与位移差成正比，方向相反；阻尼力与速度差成正比，方向相反），确定作用在点 2 上的力。

- **力平衡方程**：将作用在点 2 上的所有力相加，设代数和为零，得到力平衡方程。

### 10. 进一步说明

- **为何不用考虑惯性力？** 在这个问题中，我们假设系统是准静态的，或者点 2 的质量可以忽略，所以不考虑惯性力。如果点 2 有质量，我们需要考虑 $m \ddot{x}_o$ 的影响。

- **为何不考虑其他力？** 因为系统中只存在弹簧和阻尼器，且假设没有外力直接作用在点 2 上，所以只需要考虑这些元件产生的力。

### 11. 最后的力平衡方程

综上所述，点 2 的力平衡方程为：

$$
K_2(x_i - x_o) + f_2(\dot{x}_i - \dot{x}_o) = f_1(\dot{x}_o - \dot{x})
$$

这个方程表达了作用在点 2 上的所有力的平衡关系。

**希望这能帮助您理解力的方向和力平衡方程的建立。**

弹簧器与阻尼器系统

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

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

什么是 FLUX.1？

项目地址及配置指南

如何获取 Hugging Face Token

弹簧器与阻尼器

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