使用

这两天有机会体验了下 Devin，感受到一些小小的震撼。

虽然之前已经用过 cursor 和 windsurf，它们用的模型都一样，理论上能完成的任务和智力是差不多的，但用 Devin 感受还是不太一样，有种 AGI 已经实现了的感觉。

Cursor 和 Devin 核心区别是交互范式，Cursor 是 Copilot，在你工作写代码过程中，实时辅助完成编程任务，而 Devin 是一个员工，交给他复杂任务后不用管它，它主动帮你搞定。可能现在这两者完成的很多任务是一致的，但体验有差异。

我试用的其中一个任务，是扔给它开源项目 JSPatch 的 github 地址，告诉它找个 issue 修一下。它会分解任务逐步执行，包括：

1. 访问 github 网站，浏览issue列表，随机看几个 issue 详情
2. 挑了个 block 相关 issue，浏览项目相关文件，寻找与 issue 相关联的代码文件，制定修复计划
3. 写测试用例 → 修改项目代码尝试修复 issue → 跑用例验证(没 iOS 环境没跑起来) → commit 和提交 PR

这个过程是自动和异步的，它跑在虚拟机里，不需要你提供环境，不需要盯着它，它会自己去调研怎么完成这个任务，做完了会来告诉你（如果用 slack，这个体验过程更顺畅，@它下达任务，任务完成slack回复），这跟给一个员工布置任务，等他做完验收结果的体验很一致。

畅想

现在 Devin 解决问题的能力肯定还有限，真正用下来磕磕碰碰很多任务还是完成不好，现在的模型能力下 Cursor 这种 Copilot 的形态是更实用的，但未来理想的形态肯定是 Devin 这种“员工”形态，因为可以解放注意力，无限扩展同一时间能做的事。

可以想象，这种形态未来的优化速度会很乐观：

1. 基础模型的思维规划能力还没收敛，从sonet o1 到 o3 可以看到还在快速提升
2. 即使基础模型能力放缓了，模型在领域上的调优还有很大空间。
3. 更多工具的接入，也能带来更强大的能力和体验。

以及，模型成本必然比摩尔定律更快速的下降，Devin 会持续用最好的模型最贵的方案，但今天 500美金的效果，一年后成本可能只要5美金就能做到。

Devin 所实现的概念早在 23年初 AutoGPT 就提出，只是当时模型能力还不具备，Claude Sonnet / GPT 4o / GPT o1 这种级别推理能力的模型出现后，才具备可用性，Devin 是实现了这个概念下初步可用的雏形，让人看到这个方向已经初步 ready，剩下的就是持续往这个方向优化和扩展了，Devin 确实称得上是数字员工的开端，设计师agent，交易员agent，数据分析师agent，电商agent，预计会陆续出现。

原理

Devin 是怎么实现的？

有个开源项目 OpenHands（前身 OpenDevin），尝试用开源社区的方式去构建类似 Devin 做的事，虽然能力和效果上不能完全对标 Devin，但可以看个基本雏形。相关论文：https://arxiv.org/abs/2407.16741

文中的这张架构图，可以比较好描述 OpenHands 是怎么做：

三个主要部分：

1. Event Stream：记录每一步指令和执行结果，Action 是指令，Observation 是指令对应的工具执行的结果，Action 和 Observation 最终都是以纯文本记录结果。
2. Runtime：程序运行在独立的 docker 容器里，提供一些工具给 Agent 调用执行，当前包括 Python 运行、终端命令行、浏览器
3. Agent：把 Event Stream 里的所有内容作为上下文，输入到 LLM 推理下一步Action。

还有个关键点没有在图上画出来，为什么把 Event Stream 的所有内容输入到 LLM，LLM 就会按照要求推理出下一步 Action？因为输入到 LLM 的除了 Event Stream 的上下文，还有 Agent 本身的 Prompt，这个 Prompt 描述一些处理原则、当前环境、可用的工具、每个工具的参数、预期输出的格式等，以及还配套了一个示例，指引模型按要求输出。这个 Prompt 本身贴在了文末。

我们跟着图上 Event Stream 的示例，跑一下这个流程：

1. 用户输入一个任务命令：“Can you create a list of numbers from 1 to 10, and create a web page to display them at port 5000?” 到 Event Stream
2. 当前 Event Stream 只有这一条命令内容，输入到 Agent，Agent 会拿它跟上述预置 prompt 一起输入给 LLM，LLM 会推理出下一步是调用 Python 去创建 app.py 文件，输出 Action 指令到 Event Stream。
3. 工具 IPython 对应的 Observation 监听到这个指令，在 Runtime 环境执行了这个命令，输出执行结果“app.py created” 记录在 Event Stream 上
4. Event Stream 接收到 Observation 新的执行结果后，Agent 程序会自动继续把整个 Event Stream 记录连同预置 Prompt 输入给 LLM，推测下一步 Action。推测出来的下一步 Action 是把一大段代码用调用 python 命令的方式写入刚才创建的文件
5. IPython Observation 接收到这个 Action，在 Runtime 环境执行命令，输出执行结果到 Event Stream。

接下来就是不断的循环：Action 驱动 Observation 用工具做处理 → 处理结果输出到 Event Stream → Event Stream 拿所有前文内容到 LLM 输出下一步 Action → 驱动Observation 用工具做处理…

后面的6-9步用了命令行工具和浏览器工具，流程是一样的。这个循环流程什么时候结束？有一个特殊的 Action 叫 finish，如果一个任务 LLM 认为完成了，就会输出调用 finish Action，程序接收到就退出循环，等用户下一步输入。

整体就是自动循环让 LLM 预测下一步动作 → Agent 程序调用工具执行动作 的过程。补充一些点：

1. 整个项目不涉及模型训练，纯工程方案，使用通用 LLM 模型，可以配置 Claude/GPT/Deepseek 等，不过可预见的演进是根据用户使用数据去优化模型以达到领域内更好的效果。
2. 这里没有实现像 Devin 在输出 Action 前先会规划好任务的步骤再一步步执行，但要在上述这个系统加上这个规划能力预计不难。
3. 项目使用 BrowserGym 去和浏览器交互，Agent 对浏览器的操作和识别是另一个大课题，有单独的 benchmark 多种方案，待调研。
4. 随着 Event Stream 里链路的不断增加，上下文会越来越长，到一定程度 openhands 会做两种处理，一种是压缩内容，把前面的上下文发给 llm 精练总结，用更简短的内容作为后续的上下文。另一种是让 LLM 对过去的内容进行重要度排序，只选择对预测下一步重要的几个记录作为上下文，具体逻辑在 condenser.py 里。更长的上下文会用向量数据库 ChromeDB 存储。

附：预置prompt

You are OpenHands agent, a helpful AI assistant that can interact with a computer to solve tasks.
<IMPORTANT>
//
* If user provides a path, you should NOT assume it's relative to the current working directory. Instead, you should explore the file system to find the file before working on it.
* When configuring git credentials, use "openhands" as the user.name and "openhands@all-hands.dev" as the user.email by default, unless explicitly instructed otherwise.
* The assistant MUST NOT include comments in the code unless they are necessary to describe non-obvious behavior.
RuntimeInfo(available_hosts={'http://localhost:54090': 54090, 'http://localhost:55602': 55602})
</IMPORTANT>

<RUNTIME_INFORMATION>
The user has access to the following hosts for accessing a web application,
each of which has a corresponding port:
* http://localhost:54090 (port 54090)
* http://localhost:55602 (port 55602)

When starting a web server, use the corresponding ports. You should also
set any options to allow iframes and CORS requests.
</RUNTIME_INFORMATION>
You have access to the following functions:

---- BEGIN FUNCTION #1: execute_bash ----
Description: Execute a bash command in the terminal.
* Long running commands: For commands that may run indefinitely, it should be run in the background and the output should be redirected to a file, e.g. command = `python3 app.py > server.log 2>&1 &`.
* Interactive: If a bash command returns exit code `-1`, this means the process is not yet finished. The assistant must then send a second call to terminal with an empty `command` (which will retrieve any additional logs), or it can send additional text (set `command` to the text) to STDIN of the running process, or it can send command like `C-c` (Ctrl+C) to interrupt the process.

Parameters:
  (1) command (string, required): The bash command to execute. Can be empty string to view additional logs when previous exit code is `-1`. Can be `C-c` (Ctrl+C) to interrupt the currently running process.
---- END FUNCTION #1 ----

---- BEGIN FUNCTION #2: finish ----
Description: Finish the interaction when the task is complete OR if the assistant cannot proceed further with the task.
No parameters are required for this function.
---- END FUNCTION #2 ----

---- BEGIN FUNCTION #3: web_read ----
Description: Read (convert to markdown) content from a webpage. You should prefer using the `web_read` tool over the `browser` tool, but do use the `browser` tool if you need to interact with a webpage (e.g., click a button, fill out a form, etc.).

You may use the `web_read` tool to read content from a webpage, and even search the webpage content using a Google search query (e.g., url=`https://www.google.com/search?q=YOUR_QUERY`).

Parameters:
  (1) url (string, required): The URL of the webpage to read. You can also use a Google search query here (e.g., `https://www.google.com/search?q=YOUR_QUERY`).
---- END FUNCTION #3 ----

---- BEGIN FUNCTION #4: browser ----
Description: Interact with the browser using Python code. Use it ONLY when you need to interact with a webpage.

See the description of "code" parameter for more details.

Multiple actions can be provided at once, but will be executed sequentially without any feedback from the page.
More than 2-3 actions usually leads to failure or unexpected behavior. Example:
fill('a12', 'example with "quotes"')
click('a51')
click('48', button='middle', modifiers=['Shift'])

Parameters:
  (1) code (string, required): The Python code that interacts with the browser.

The following 15 functions are available. Nothing else is supported.

goto(url: str)
    Description: Navigate to a url.
    Examples:
        goto('http://www.example.com')

go_back()
    Description: Navigate to the previous page in history.
    Examples:
        go_back()

go_forward()
    Description: Navigate to the next page in history.
    Examples:
        go_forward()

noop(wait_ms: float = 1000)
    Description: Do nothing, and optionally wait for the given time (in milliseconds).
    You can use this to get the current page content and/or wait for the page to load.
    Examples:
        noop()

        noop(500)

scroll(delta_x: float, delta_y: float)
    Description: Scroll horizontally and vertically. Amounts in pixels, positive for right or down scrolling, negative for left or up scrolling. Dispatches a wheel event.
    Examples:
        scroll(0, 200)

        scroll(-50.2, -100.5)

fill(bid: str, value: str)
    Description: Fill out a form field. It focuses the element and triggers an input event with the entered text. It works for <input>, <textarea> and [contenteditable] elements.
    Examples:
        fill('237', 'example value')

        fill('45', 'multi-line
example')

        fill('a12', 'example with "quotes"')

select_option(bid: str, options: str | list[str])
    Description: Select one or multiple options in a <select> element. You can specify option value or label to select. Multiple options can be selected.
    Examples:
        select_option('a48', 'blue')

        select_option('c48', ['red', 'green', 'blue'])

click(bid: str, button: Literal['left', 'middle', 'right'] = 'left', modifiers: list[typing.Literal['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']] = [])
    Description: Click an element.
    Examples:
        click('a51')

        click('b22', button='right')

        click('48', button='middle', modifiers=['Shift'])

dblclick(bid: str, button: Literal['left', 'middle', 'right'] = 'left', modifiers: list[typing.Literal['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift']] = [])
    Description: Double click an element.
    Examples:
        dblclick('12')

        dblclick('ca42', button='right')

        dblclick('178', button='middle', modifiers=['Shift'])

hover(bid: str)
    Description: Hover over an element.
    Examples:
        hover('b8')

press(bid: str, key_comb: str)
    Description: Focus the matching element and press a combination of keys. It accepts the logical key names that are emitted in the keyboardEvent.key property of the keyboard events: Backquote, Minus, Equal, Backslash, Backspace, Tab, Delete, Escape, ArrowDown, End, Enter, Home, Insert, PageDown, PageUp, ArrowRight, ArrowUp, F1 - F12, Digit0 - Digit9, KeyA - KeyZ, etc. You can alternatively specify a single character you'd like to produce such as "a" or "#". Following modification shortcuts are also supported: Shift, Control, Alt, Meta, ShiftLeft, ControlOrMeta. ControlOrMeta resolves to Control on Windows and Linux and to Meta on macOS.
    Examples:
        press('88', 'Backspace')

        press('a26', 'ControlOrMeta+a')

        press('a61', 'Meta+Shift+t')

focus(bid: str)
    Description: Focus the matching element.
    Examples:
        focus('b455')

clear(bid: str)
    Description: Clear the input field.
    Examples:
        clear('996')

drag_and_drop(from_bid: str, to_bid: str)
    Description: Perform a drag & drop. Hover the element that will be dragged. Press left mouse button. Move mouse to the element that will receive the drop. Release left mouse button.
    Examples:
        drag_and_drop('56', '498')

upload_file(bid: str, file: str | list[str])
    Description: Click an element and wait for a "filechooser" event, then select one or multiple input files for upload. Relative file paths are resolved relative to the current working directory. An empty list clears the selected files.
    Examples:
        upload_file('572', '/home/user/my_receipt.pdf')

        upload_file('63', ['/home/bob/Documents/image.jpg', '/home/bob/Documents/file.zip'])

---- END FUNCTION #4 ----

---- BEGIN FUNCTION #5: execute_ipython_cell ----
Description: Run a cell of Python code in an IPython environment.
* The assistant should define variables and import packages before using them.
* The variable defined in the IPython environment will not be available outside the IPython environment (e.g., in terminal).

Parameters:
  (1) code (string, required): The Python code to execute. Supports magic commands like %pip.
---- END FUNCTION #5 ----

---- BEGIN FUNCTION #6: str_replace_editor ----
Description: Custom editing tool for viewing, creating and editing files
* State is persistent across command calls and discussions with the user
* If `path` is a file, `view` displays the result of applying `cat -n`. If `path` is a directory, `view` lists non-hidden files and directories up to 2 levels deep
* The `create` command cannot be used if the specified `path` already exists as a file
* If a `command` generates a long output, it will be truncated and marked with `<response clipped>`
* The `undo_edit` command will revert the last edit made to the file at `path`

Notes for using the `str_replace` command:
* The `old_str` parameter should match EXACTLY one or more consecutive lines from the original file. Be mindful of whitespaces!
* If the `old_str` parameter is not unique in the file, the replacement will not be performed. Make sure to include enough context in `old_str` to make it unique
* The `new_str` parameter should contain the edited lines that should replace the `old_str`

Parameters:
  (1) command (string, required): The commands to run. Allowed options are: `view`, `create`, `str_replace`, `insert`, `undo_edit`.
Allowed values: [`view`, `create`, `str_replace`, `insert`, `undo_edit`]
  (2) path (string, required): Absolute path to file or directory, e.g. `/workspace/file.py` or `/workspace`.
  (3) file_text (string, optional): Required parameter of `create` command, with the content of the file to be created.
  (4) old_str (string, optional): Required parameter of `str_replace` command containing the string in `path` to replace.
  (5) new_str (string, optional): Optional parameter of `str_replace` command containing the new string (if not given, no string will be added). Required parameter of `insert` command containing the string to insert.
  (6) insert_line (integer, optional): Required parameter of `insert` command. The `new_str` will be inserted AFTER the line `insert_line` of `path`.
  (7) view_range (array, optional): Optional parameter of `view` command when `path` points to a file. If none is given, the full file is shown. If provided, the file will be shown in the indicated line number range, e.g. [11, 12] will show lines 11 and 12. Indexing at 1 to start. Setting `[start_line, -1]` shows all lines from `start_line` to the end of the file.
---- END FUNCTION #6 ----


If you choose to call a function ONLY reply in the following format with NO suffix:

<function=example_function_name>
<parameter=example_parameter_1>value_1</parameter>
<parameter=example_parameter_2>
This is the value for the second parameter
that can span
multiple lines
</parameter>
</function>

<IMPORTANT>
Reminder:
- Function calls MUST follow the specified format, start with <function= and end with </function>
- Required parameters MUST be specified
- Only call one function at a time
- You may provide optional reasoning for your function call in natural language BEFORE the function call, but NOT after.
- If there is no function call available, answer the question like normal with your current knowledge and do not tell the user about function calls


----------

Here's a running example of how to perform a task with the provided tools.

--------------------- START OF EXAMPLE ---------------------

USER: Create a list of numbers from 1 to 10, and display them in a web page at port 5000.

ASSISTANT: Sure! Let me first check the current directory:
<function=execute_bash>
<parameter=command>
pwd && ls
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
/workspace
openhands@runtime:~/workspace$

ASSISTANT: There is no `app.py` file in the current directory. Let me create a Python file `app.py`:
<function=str_replace_editor>
<parameter=command>create</parameter>
<parameter=path>/workspace/app.py</parameter>
<parameter=file_text>
from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
    numbers = list(range(1, 11))
    return str(numbers)

if __name__ == '__main__':
    app.run(port=5000)
</parameter>
</function>

USER: EXECUTION RESULT of [str_replace_editor]:
File created successfully at: /workspace/app.py

ASSISTANT: I have created a Python file `app.py` that will display a list of numbers from 1 to 10 when you run it. Let me run the Python file for you:
<function=execute_bash>
<parameter=command>
python3 app.py > server.log 2>&1 &
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
[1] 121
[1]+  Exit 1                  python3 app.py > server.log 2>&1

ASSISTANT: Looks like the server is running with PID 121 then crashed. Let me check the server log:
<function=execute_bash>
<parameter=command>
cat server.log
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
Traceback (most recent call last):
  File "/workspace/app.py", line 2, in <module>
    from flask import Flask
ModuleNotFoundError: No module named 'flask'

ASSISTANT: Looks like the server crashed because the `flask` module is not installed. Let me install the `flask` module for you:
<function=execute_bash>
<parameter=command>
pip3 install flask
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
Defaulting to user installation because normal site-packages is not writeable
Collecting flask
  Using cached flask-3.0.3-py3-none-any.whl (101 kB)
Collecting blinker>=1.6.2
  Using cached blinker-1.7.0-py3-none-any.whl (13 kB)
Collecting Werkzeug>=3.0.0
  Using cached werkzeug-3.0.2-py3-none-any.whl (226 kB)
Collecting click>=8.1.3
  Using cached click-8.1.7-py3-none-any.whl (97 kB)
Collecting itsdangerous>=2.1.2
  Using cached itsdangerous-2.2.0-py3-none-any.whl (16 kB)
Requirement already satisfied: Jinja2>=3.1.2 in /home/openhands/.local/lib/python3.10/site-packages (from flask) (3.1.3)
Requirement already satisfied: MarkupSafe>=2.0 in /home/openhands/.local/lib/python3.10/site-packages (from Jinja2>=3.1.2->flask) (2.1.5)
Installing collected packages: Werkzeug, itsdangerous, click, blinker, flask
Successfully installed Werkzeug-3.0.2 blinker-1.7.0 click-8.1.7 flask-3.0.3 itsdangerous-2.2.0

ASSISTANT: The `flask` module is installed successfully. Let me run the Python file again:
<function=execute_bash>
<parameter=command>
python3 app.py > server.log 2>&1 &
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
[1] 124

ASSISTANT:
Let me check the server log again:
<function=execute_bash>
<parameter=command>
cat server.log
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
* Serving Flask app 'app'
 * Debug mode: off
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
 * Running on http://127.0.0.1:5000
Press CTRL+C to quit

ASSISTANT:
The server is running on port 5000 with PID 124. You can access the list of numbers by visiting http://127.0.0.1:5000. If you have any further questions, feel free to ask!

USER: Now kill the server, make it display the numbers in a table format.

ASSISTANT:
Sure! Let me stop the server first:
<function=execute_bash>
<parameter=command>
kill 124
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
[1]+  Terminated              python3 app.py > server.log 2>&1

ASSISTANT:
Now let me display the numbers in a table format:
<function=str_replace_editor>
<parameter=command>str_replace</parameter>
<parameter=path>/workspace/app.py</parameter>
<parameter=old_str>return str(numbers)</parameter>
<parameter=new_str>return '<table>' + ''.join([f'<tr><td>{i}</td></tr>' for i in numbers]) + '</table>'</parameter>
</function>

USER: EXECUTION RESULT of [str_replace_editor]:
The file /workspace/app.py has been edited. Here's the result of running `cat -n` on a snippet of /workspace/app.py:
     3
     4  @app.route('/')
     5  def index():
     6      numbers = list(range(1, 11))
     7      return '<table>' + ''.join([f'<tr><td>{i}</td></tr>' for i in numbers]) + '</table>'
     8
     9  if __name__ == '__main__':
    10      app.run(port=5000)
Review the changes and make sure they are as expected. Edit the file again if necessary.

ASSISTANT:
Running the updated file:
<function=execute_bash>
<parameter=command>
<parameter=command>
python3 app.py > server.log 2>&1 &
</parameter>
</function>

USER: EXECUTION RESULT of [execute_bash]:
[1] 126

ASSISTANT:
The server is running on port 5000 with PID 126. You can access the list of numbers in a table format by visiting http://127.0.0.1:5000. Let me know if you have any further requests!
<function=finish>
</function>

--------------------- END OF EXAMPLE ---------------------

Do NOT assume the environment is the same as in the example above.

附：任务 Prompt示例

以下是真实执行一个任务时，循环添加输入 LLM 的 Prompt case：

--------------------- NEW TASK DESCRIPTION ---------------------
创建一个可以调用deepseek模型的程序，并运行测试确保可用
--------------------- END OF NEW TASK DESCRIPTION ---------------------

PLEASE follow the format strictly! PLEASE EMIT ONE AND ONLY ONE FUNCTION CALL PER MESSAGE.


----------

Let me start by checking the current directory and listing its contents:

<function=execute_bash>
<parameter=command>pwd && ls</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
/workspace
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 0]

----------

I see we are in the `/workspace` directory. Let's create a Python file that can call the DeepSeek model. First, I'll create a new file called `deepseek_app.py`:

<function=str_replace_editor>
<parameter=command>create</parameter>
<parameter=path>/workspace/deepseek_app.py</parameter>
<parameter=file_text>
from deepseek import DeepSeekModel

def call_deepseek_model(input_text):
    model = DeepSeekModel()
    response = model.generate(input_text)
    return response

if __name__ == "__main__":
    test_input = "Hello, DeepSeek!"
    result = call_deepseek_model(test_input)
    print("Model Response:", result)
</parameter>
</function>

----------

EXECUTION RESULT of [str_replace_editor]:
File created successfully at: /workspace/deepseek_app.py

----------

Now, let's check if the `deepseek` module is installed. If not, we'll need to install it:

<function=execute_bash>
<parameter=command>pip3 show deepseek</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
WARNING: Package(s) not found: deepseek
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 1]

----------

The `deepseek` module is not installed. Let me install it using pip:

<function=execute_bash>
<parameter=command>pip3 install deepseek</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Collecting deepseek
  Downloading deepseek-1.0.0-py3-none-any.whl.metadata (3.9 kB)
Requirement already satisfied: requests in /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages (from deepseek) (2.32.3)
Requirement already satisfied: charset-normalizer<4,>=2 in /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages (from requests->deepseek) (3.4.1)
Requirement already satisfied: idna<4,>=2.5 in /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages (from requests->deepseek) (3.10)
Requirement already satisfied: urllib3<3,>=1.21.1 in /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages (from requests->deepseek) (2.3.0)
Requirement already satisfied: certifi>=2017.4.17 in /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages (from requests->deepseek) (2024.12.14)
Downloading deepseek-1.0.0-py3-none-any.whl (4.5 kB)
Installing collected packages: deepseek
Successfully installed deepseek-1.0.0
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 0]

----------

The `deepseek` module is now installed. Let's run the `deepseek_app.py` program to test if it works:

<function=execute_bash>
<parameter=command>python3 deepseek_app.py</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Traceback (most recent call last):
  File "/workspace/deepseek_app.py", line 1, in <module>
    from deepseek import DeepSeekModel
ImportError: cannot import name 'DeepSeekModel' from 'deepseek' (/openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages/deepseek/__init__.py)
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 1]

----------

It seems the `DeepSeekModel` class is not available in the `deepseek` module. Let me check the documentation or available classes in the `deepseek` module:

<function=execute_bash>
<parameter=command>python3 -c "import deepseek; print(dir(deepseek))"</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
['DeepSeekAPI', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__path__', '__spec__', '__version__', 'api', 'const']
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 0]

----------

The `deepseek` module provides a `DeepSeekAPI` class instead of `DeepSeekModel`. Let me update the `deepseek_app.py` file to use the correct class:

<function=str_replace_editor>
<parameter=command>str_replace</parameter>
<parameter=path>/workspace/deepseek_app.py</parameter>
<parameter=old_str>
from deepseek import DeepSeekModel

def call_deepseek_model(input_text):
    model = DeepSeekModel()
    response = model.generate(input_text)
    return response
</parameter>
<parameter=new_str>
from deepseek import DeepSeekAPI

def call_deepseek_model(input_text):
    api = DeepSeekAPI()
    response = api.generate(input_text)
    return response
</parameter>
</function>

----------

EXECUTION RESULT of [str_replace_editor]:
The file /workspace/deepseek_app.py has been edited. Here's the result of running `cat -n` on a snippet of /workspace/deepseek_app.py:
     1        from deepseek import DeepSeekAPI
     2        
     3        def call_deepseek_model(input_text):
     4            api = DeepSeekAPI()
     5            response = api.generate(input_text)
     6            return response
     7        
     8        if __name__ == "__main__":
     9            test_input = "Hello, DeepSeek!"
    10            result = call_deepseek_model(test_input)
Review the changes and make sure they are as expected. Edit the file again if necessary.

----------

Now that the file is updated, let's run the program again to test if it works:

<function=execute_bash>
<parameter=command>python3 deepseek_app.py</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Traceback (most recent call last):
  File "/workspace/deepseek_app.py", line 10, in <module>
    result = call_deepseek_model(test_input)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/workspace/deepseek_app.py", line 4, in call_deepseek_model
    api = DeepSeekAPI()
          ^^^^^^^^^^^^^
  File "/openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages/deepseek/api.py", line 9, in __init__
    raise ValueError("DEEPSEEK_API_KEY is missing")
ValueError: DEEPSEEK_API_KEY is missing
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 1]

----------

The program requires an API key to use the `DeepSeekAPI`. Let me update the program to include the API key as an environment variable. First, I'll modify the `deepseek_app.py` file:

<function=str_replace_editor>
<parameter=command>str_replace</parameter>
<parameter=path>/workspace/deepseek_app.py</parameter>
<parameter=old_str>
from deepseek import DeepSeekAPI

def call_deepseek_model(input_text):
    api = DeepSeekAPI()
    response = api.generate(input_text)
    return response
</parameter>
<parameter=new_str>
import os
from deepseek import DeepSeekAPI

def call_deepseek_model(input_text):
    api_key = os.getenv("DEEPSEEK_API_KEY")
    if not api_key:
        raise ValueError("Please set the DEEPSEEK_API_KEY environment variable.")
    api = DeepSeekAPI(api_key=api_key)
    response = api.generate(input_text)
    return response
</parameter>
</function>

----------

EXECUTION RESULT of [str_replace_editor]:
The file /workspace/deepseek_app.py has been edited. Here's the result of running `cat -n` on a snippet of /workspace/deepseek_app.py:
     1        import os
     2        from deepseek import DeepSeekAPI
     3        
     4        def call_deepseek_model(input_text):
     5            api_key = os.getenv("DEEPSEEK_API_KEY")
     6            if not api_key:
     7                raise ValueError("Please set the DEEPSEEK_API_KEY environment variable.")
     8            api = DeepSeekAPI(api_key=api_key)
     9            response = api.generate(input_text)
    10            return response
    11        
    12        if __name__ == "__main__":
    13            test_input = "Hello, DeepSeek!"
    14            result = call_deepseek_model(test_input)
Review the changes and make sure they are as expected. Edit the file again if necessary.

----------

Now, let's set the `DEEPSEEK_API_KEY` environment variable and run the program again. Please provide the API key for DeepSeek, and I will set it up for you. If you don't have one, you may need to sign up for an API key from DeepSeek's official website.

<function=execute_bash>
<parameter=command>export DEEPSEEK_API_KEY=your_api_key_here && python3 deepseek_app.py</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Traceback (most recent call last):
  File "/workspace/deepseek_app.py", line 14, in <module>
    result = call_deepseek_model(test_input)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/workspace/deepseek_app.py", line 9, in call_deepseek_model
    response = api.generate(input_text)
               ^^^^^^^^^^^^
AttributeError: 'DeepSeekAPI' object has no attribute 'generate'
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 1]

----------

It seems the `DeepSeekAPI` class does not have a `generate` method. Let me check the available methods in the `DeepSeekAPI` class:

<function=execute_bash>
<parameter=command>python3 -c "from deepseek import DeepSeekAPI; print(dir(DeepSeekAPI))"</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_post_request', 'chat_completion', 'completion_impl', 'fim_completion', 'get_models', 'user_balance']
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 0]

----------

The `DeepSeekAPI` class provides methods like `chat_completion`, `fim_completion`, and `get_models`. Let's update the `deepseek_app.py` file to use the `chat_completion` method instead of `generate`:

<function=str_replace_editor>
<parameter=command>str_replace</parameter>
<parameter=path>/workspace/deepseek_app.py</parameter>
<parameter=old_str>
api = DeepSeekAPI(api_key=api_key)
    response = api.generate(input_text)
    return response
</parameter>
<parameter=new_str>
api = DeepSeekAPI(api_key=api_key)
    response = api.chat_completion(input_text)
    return response
</parameter>
</function>

----------

EXECUTION RESULT of [str_replace_editor]:
The file /workspace/deepseek_app.py has been edited. Here's the result of running `cat -n` on a snippet of /workspace/deepseek_app.py:
     4        def call_deepseek_model(input_text):
     5            api_key = os.getenv("DEEPSEEK_API_KEY")
     6            if not api_key:
     7                raise ValueError("Please set the DEEPSEEK_API_KEY environment variable.")
     8            api = DeepSeekAPI(api_key=api_key)
     9            response = api.chat_completion(input_text)
    10            return response
    11        
    12        if __name__ == "__main__":
    13            test_input = "Hello, DeepSeek!"
    14            result = call_deepseek_model(test_input)
Review the changes and make sure they are as expected. Edit the file again if necessary.

----------

Now, let's run the program again with the updated method. Please provide the `DEEPSEEK_API_KEY` environment variable:

<function=execute_bash>
<parameter=command>export DEEPSEEK_API_KEY=your_api_key_here && python3 deepseek_app.py</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Traceback (most recent call last):
  File "/workspace/deepseek_app.py", line 14, in <module>
    result = call_deepseek_model(test_input)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/workspace/deepseek_app.py", line 9, in call_deepseek_model
    response = api.chat_completion(input_text)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages/deepseek/api.py", line 62, in chat_completion
    response = self._post_request(API_CHAT_COM, payload, stream)
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/openhands/poetry/openhands-ai-5O4_aCHf-py3.12/lib/python3.12/site-packages/deepseek/api.py", line 25, in _post_request
    raise Exception(f"HTTP Error {response.status_code}: {response.text}")
Exception: HTTP Error 401: {"error":{"message":"Authentication Fails (no such user)","type":"authentication_error","param":null,"code":"invalid_request_error"}}
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 1]

----------

The error indicates that the provided API key is invalid or does not correspond to a valid user. To proceed, you will need to:

1. Obtain a valid API key from DeepSeek's official platform.
2. Ensure the API key is correctly set in the environment.

Once you have a valid API key, you can set it and run the program again. Let me know if you need further assistance!

----------

key: *** ///在这里输入了key，隐藏

----------

Thank you for providing the API key. Let's set the environment variable and run the program again:

<function=execute_bash>
<parameter=command>export DEEPSEEK_API_KEY=sk-4a727097b1ef4e61a3444ec96e1e0db0 && python3 deepseek_app.py</parameter>
</function>

----------

EXECUTION RESULT of [execute_bash]:
Model Response: Hello! How can I assist you today? 😊
[Python Interpreter: /openhands/poetry/openhands-ai-5O4_aCHf-py3.12/bin/python]
[Command finished with exit code 0]

又到了 31 号这天，回想起来 24 年过得很快，回顾过去一些事，有的感觉就前几周的事，一看原来已经过去四五个月。照例在这天写篇生活记录。

学习

去年说今年要学下AI，总算有点进展，虽然进度不理想，但也算迈开了步伐。

学习如果没有一些事项引导，就很难进行，最好的学习方式是直接在做的过程中学，真正进去做这个事的过程中会不断遇到一些问题，解决这些问题过程就是很自然的逐渐学习和深入的过程。

没这个条件的话，就退而求其次，用分享输出的方式引导学习，所以我时隔四五年不写博客，今年又开始写了，主要就是让我的学习有个地方做完整的记录，有相应的引导。

在软件工程时代，一个功能能不能实现，原理链路大概是怎样，基本都能知道，上一轮以推荐为主的 AI 也大致能了解原理。而这次的生成式 AI 太魔法了，应用范围和影响力也远超过去，完全不了解它是怎么回事很让人难受，有种跟不上时代的感觉，学一些皮毛后感觉好一些。

不过最好还是机会边做边学，希望25年能多一些深入实践，让自己在创造的状态里学习。

今年 AI 继续快速发展，有几个时刻对 AI 的能力和带来的体验还是很震惊的：

1. AI Coding：第一次用 cursor 的补全能力、compose 创建多个文件能力，第一次用 windsurf 直接创建项目跑起来，都让人震惊。虽然一些微调和 bug AI 还不能解决得很好，但做一个 demo 完全没问题，对程序员来说，也可以完全忽略不同编程语言/平台特性前期学习的障碍，无差别上手码代码。AI Coding 是今年完全跑出来的赛道，大家都看到了它的机会，以后没有一个程序员不需要 AI 辅助 Coding，而且 AI Coding 还能不断转换非程序员群体进来构建任意软件交互功能，想象空间很大，可以预料 25 年这个赛道会比百团大战更热闹。
2. Prompt 的能力：看到 Glif 的 AI 梗图生成很惊讶，只需要输入工种比如“程序员”，LLM 就能生成信息量极大的针对这个工种的梗，当时感觉自己确实是 LLM 小白，LLM 本身存储压缩的信息量是巨大的。
3. 视频生成：年初的 sora 震惊许多人，但第一次上手用视频生成才会真实感受到冲击，第一次用即梦的视频S2.0模型时，超高清和稳定的人脸运动属实惊艳，很容易做画面感很好的视频，一直想给小说《十日终焉》配个AI生成的小片，终于圆了这个念想。
4. NotebookLM：生成的真实对话声音的真实性实在太强，一点AI味都没有。文字/图片/音频/视频，以后 AI 可以自由在多个模态之间自由切换，只要有源头内容，各种形态的展示都不会是问题。

播客

前两天小宇宙推送年度总结，看到今年我在上面听的总时长时很惊讶，166个小时，我已经成为播客的忠实用户了。想想也合理，一年200多个工作日，如果每个工作日上下班开车一小时听一小时，也有200多个小时。

网络上高质量内容一直在切换形态，从最开始的 blog，到后来的公众号知乎，在公众号和知乎泛化后，高质量的内容逐渐转移到播客上了，在海外更是这样，特别是AI前沿信息基本都在播客上，国内也逐渐是这个趋势，今年特别明显。

除了听几个AI相关的博客，听得最多的是半拿铁，内容做得太好了，有几个很喜欢的系列，包括任天堂往事、日漫史、改革开放系列。

改革开放系列让人看到整个路径的曲折，路线反复的历史背景，一大波有担当的政府官员推动历史，克服极大的困难才让改革开放走下去，听到最近一期成事后的片尾曲《春天的故事》时，竟有些动容。

日漫史和任天堂往事，也跟着它回忆了一下这些从小到大的精神粮食，任天堂不断把游戏欢乐带给更广泛的人，强大的创新能力，至暗时刻也能翻身，不愧是游戏界的神。日本漫画家没日没夜奋斗完成作品的干劲，这种投入强度和一根筋的热情，也只有日本能把漫画行业做出来。

游戏

今年玩过最好的游戏当然是《黑神话悟空》，远超预期，独有的中国文化之美，光看画面就是很大的享受，尤其是小西天，剧情音乐也都很顶，黄风岭陕西说唱、《壁上观》都很美，能玩到这样的游戏真好。不足的是难度没有循序渐进，开头的白衣居士卡得我差点放弃，后面反而障碍不多，但偶尔被 boss 卡还是挺难受。另外玩游戏过程中几乎感受不到剧情，这么顶的剧情全靠外部解说，也不知是不是个传播策略。

看了黑神话悟空相关的访谈，一个体制以外冒出来的好的作品，都是极具个人色彩的，精品是靠一小撮人投入极大的热情和毅力创造出来的。有黑神话悟空，国产 3A 大作有希望，但5年-10年内还会不会有其他精品出来，不太乐观，只能肯定的是大公司不会有。

物品

1. 九号电动车，体验超预期，一线互联网水准的 APP 体验，停车自动锁，坐上自动解锁，二轮电动也跟上了智能电动汽车的步伐，生活中再也没有钥匙这个东西了。
2. Vision Pro，年初在同事那里体验了一波 Vision Pro，效果很震撼，特别是演示的恐龙视频，3D 全景高分辨率带来真正身临其境的感觉，但它更像是一个概念机，长板很长，短板很短，希望苹果能坚持继续解决佩戴舒适度、成本价格问题，真正把这个领域做起来，还是很期待 Vision Pro 的体验能成为日常的时代，不知道10年后能不能达成，掐指一算 Google glass 都已经12年了，穿戴式设备的进度十分缓慢。
3. meta 眼镜，Vision Pro 没那么快普及，但可以预见的是类 meta 眼镜接下来一年会爆发，可能是今年最吸引人的硬件，随时抓拍记录生活，叠加AI对话的概念，除了拍摄和AI，还有望部分代替掉 Airpods，绝对的爆款，期待国产卷出性价比体验都更高的版本，迫不及待想买了。
4. Airpods 非入耳式的降噪，在飞机上效果极佳，至今每一代的Airpods 基本都买了，仍是非常值得入手的产品。
5. 米家智能家居，今年终于出了独立的电动窗帘，让我这没留充电位置的窗帘也能支持电动了，外加捣鼓了玄关灯、灯带，可惜楼盘自带的“智能“系统阻止了我进一步捣鼓，如果有机会装修房子，一定让全家都配好米家。

旅游

去了银川中卫，香格里拉，西双版纳，哈尔滨雪乡，成都(团建)，中山，长沙。

银川中卫沙漠星星酒店，感受非常好，就算在五一假期，也是一片片空旷的沙漠没什么人，小朋友骑骑骆驼玩玩沙，很惬意。

雪乡在我印象中是前几年坑人口碑很差的形象，实际上超预期，雪景小镇很美，游玩设施也不错，没遇到什么坑人的场景，体验不错，可惜的是时间太短了，有机会可以再去。

香格里拉没想象中美，可能因为天气一直是阴天和下雨，偶尔的蓝天惊鸿一瞥是很漂亮，另外带着小孩没法去徒步，也没去雪山，就小小感受下藏族的风格。西双版纳很有泰国风味，热带雨林的感觉很明显，云南这两个地方的差异太大了。

成都的毕棚沟和香格里拉海拔都3000米以上，感觉没什么高原反应，明年可以去西藏了。

对成都和长沙印象都挺好，长沙五一广场方圆一大片人山人海，走哪都是商店大商场，都是茶颜悦色，夜夜笙歌，真是娱乐之都。

25年希望继续解锁世界地图。

小孩

跟同事聊娃，经常会聊出焦虑，不鸡娃不上奥数和考KET就上不了好的初中，而我们什么都没准备，让我有点担心是不是对娃太佛系了，到时会后悔，但每次想来想去最终还是不想让小孩太卷。大娃三年级作业开始变多，偶尔拖拉和烦躁，但总体上学习还是比较自觉的，成绩也不错，只要保持这个感觉，应该不至于太落后？

小娃5岁了，3-4岁有段时间专门气人，回看以前大娃也是一样有这样的时期，然后今年某个时候突然间感觉就长大了，讲理、能沟通，情绪控制也好一点了，甚至惊奇发现他学习也是挺认真的，超出预期的成长，很欣慰。

再次推荐洪恩系列 APP，小娃玩着玩着就学会了很多汉字/拼音/英文单词，以前大娃也是，这过程就是在不断玩游戏，玩的过程中学，好的学习就应该是这样。

一些喜欢的瞬间：

1. 跟小娃的玩马里奥惊奇，一不小心挂了，小屁孩嫌弃地说“你会不会的，我来给你示范一下”
2. 某次玩黑猴时卡在 boss 上，我吐槽打不过好烦，小娃在旁边一本正经纠正我说：“玩游戏是享受”
3. 我的朋友圈开始收到来自大娃的评论，微信开始用得溜了，长大了，不想她那么快长大。
4. 大娃二娃在家日常的吵吵闹闹。每当这时候就想起《IQ博士》里小云和小吉在屋子里翻天覆地吵闹的画面，真是太像了。以后我一定会怀念这样的场景。

其他

身体好了很多，中招咳嗽也就两次，健身断断续续，没坚持上。

今年大环境不太好，但困难总会过去，希望能保持乐观和学习心态，希望25年大家都能过得好~

近期即梦上线了 AI 图片生成文字的能力，在生成海报、封面以及各种场景下渲染文字效果是非常不错的。最开始AI生成的图片中，涉及到文字的基本都是不能看的乱码，需要针对性训练优化才能做到生成清晰的文字并融入图片。那这里是怎么做优化的？对这个原理比较好奇，尝试通过几篇公开论文学习下相关实现思路原理。

大致思路：Recraft

目前生成文字(英文)最好的模型是 Recraft，官方有篇文章 《How To Create SOTA Image Generation with Text: Recraft’s ML Team Insights》介绍了模型训练的大体过程，挺适合简单了解大致思路的，简单复述下。

首先说明下为什么图片生成文字容易乱码？

1. 一是数据量不足：图片生成模型是通过大量图片+图片描述去做训练，而大部分图片的描述是不怎么包含图上的文字的，比如拍一个街道建筑图，图上会有很多店面的名字文字，图片描述可能就是类似 城市/街道/红色招牌等描述，并没有把图上的所有文字放进去，模型只能在少部分相对简单的场景（比如图上只有几个字，图片描述中也有这几个字）中学习生成正确的文本，幻觉会比较严重。
2. 二是文字的错误更容易被发现，相对于人物动作不协调、衣服花纹的差错，文字只要有一笔一划错误就很容易被人察觉识别为乱码，需要更精确的生成。

接下来看优化文字生成能力的大致流程：

第一步，准备数据。准备大量的包含文字的图片，包括海报、封面、广告、Logo等，对这些图片进行处理。处理包含两部分，一是用 OCR 模型识别图像上的文字位置和文字内容，二是用多模态模型识别这张图的内容，输出描述文本。得到了海量的 图片 – 文本布局和内容 – 图片描述 组合的数据。

第二步，使用数据训练模型，跟第一步是反着的过程。先训练一个布局模型，可以通过输入 prompt → 输出文本布局+内容。再把 prompt 和文本布局输入生图模型，最终生成带文字的图片。

大流程就是这样，再稍微把其中布局模型展开一下：

输入 prompt 输出 文字内容+布局，用的是一个大语言模型(LLM)，定义了一个输出的文本格式，包含文本内容和这些文本的坐标。同时还会根据文本和坐标数据，用文字渲染工具画张图片出来。

这张渲染出来的文字布局图会作为生图时的参考，用类似ControlNet 的方式作用在生图过程中，最终生成图上的文字。

这是个大致流程，文中没有展开里面模型架构的一些细节，原文上表示思路基于 TextDiffuser2，但看起来思路上跟 GlyphControl、TextDiffuser、TextDiffuser2 都有关系。

各方案大的思路都差不多，基本都是分两步，生成文字布局信息，再作用在生图过程中，主要是模型架构不同，以及数据集质量不同。下面看看这些相关的论文和一些模型细节。

GlyphControl

先看看相对简单的 GlyphControl，23年11月的论文，基本就是一种 ControlNet，跟边缘轮廓、姿态等 ControlNet 没太大差异。ControlNet 的相关介绍可以看回这篇。

训练阶段：找一批带文字的图片，用OCR 识别文字内容和位置，再渲染出一张白底黑字的图片，将图片描述和这张白底黑字图片一起进入 Glyph ControlNet 网络训练。这个白底黑字的图片就是参考图，跟边缘轮廓/姿态等其他 ControlNet 的参考图作用和流程都一样。

推理阶段：分两部分输入，生图的 Prompt 和白底黑字参考图，这张参考图看起来是要用户自己另外准备的，可以直接画一张白底黑字的图，或者描述文字内容、行信息、大小位置布局，用工具生成白底黑字参考图，再和 prompt 一起去生成相应的带图的文字。

效果：文字能较准确生成，但没有控制字体样式和文本颜色的能力，泛化性会比较差。布局和位置需要额外输入，产品化实用性低一些。

疑问：controlNet 23年2月出现，为什么11月才有人用于改进图片文字渲染，ControlNet作者自己不试试呢？

还有一篇更直接的，直接用 ControlNet 的边缘轮廓做文字生成，也不用自己训练，做了个评测： 《Typographic Text Generation with Off-the-Shelf Diffusion Model》

TextDiffuser

TextDiffuser 是23年10月的论文，跟上面 ControlNet 的思路有差异：

1. 不用准备参考图，用一个模型从 prompt 中推断文字布局。
2. 直接在生图扩散模型中训练，非 ControlNet 插件的形式。

流程：

1. 布局生成：先根据 prompt 生成逐个字母的文字形状 mask 图。用一个 transformer 模型（非LLM）理解输入的语义，识别出图上要画哪些文字，这些文字在画布上应该是在哪个位置，获得每一个字符在画布上的box位置，再用字体渲染库（如pillow）把这些文字渲染上去，生成这些字符的遮罩表示(Mask)。
2. 图像生成：将上一步得到的字符遮罩输入扩散模型，参与引导扩散过程，使图片能在遮罩对应的位置生成对应的字符形状。

训练：

1. 数据：作者从各处收集了1000万张带有文字的图像-文本对，称为MARIO-10M，主要来源是开源的LAION-400M，从中筛选带文字的高质量的图，也对数据进行了处理，包括文本检测识别、字符级的位置数据、原有的图片描述文字等。
2. 布局阶段：会使用这个数据集去做训练上面提到的 transformer 模型，输入是图片描述文字，输出是每个字符的 mask 遮罩。在数据集中，每张图片的描述、以及每张图片经过 OCR 识别处理后字符的遮罩位置都有，模型就能学习到对不同的图片描述，对应的最终的文本位置和形状应该是怎样的。
3. 图片生成阶段：这个数据集也会在扩散模型的基础上去做进一步训练，在这过程中 U-Net 的参数是冻结的，猜测是避免核心生图能力被破坏？训练过程中只会修改扩散模型 U-Net 以外的其他模块参数，整个网络还是能学习拟合到数据集里 图片描述(prompt) + 字符遮罩数据 → 带文字图片 这里的对应关系。

这整个过程，就是为生图增加信息量，布局阶段渲染的每个字符的 mask 是很大的信息量来源，引导图片扩散方向不飘。

效果：

相对未针对性训练的生图模型，能生成合理清晰的文字，在给定图像补充文字上效果也不错，也能做到控制文本颜色了，但字体多样性差一些。

TextDiffuser2

TextDiffuser 有个问题，它第一阶段产生的文字 mask 是用单一字体渲染的结果，用这个 mask 引导生图，结果是生成的结果字形的多样性比较差，生成的文字倾向于规整，手写或艺术字很难出现，GlyphControl也有同样的问题。另外 TextDiffuser 布局转换器对用户输入 prompt 的理解能力也有限。

TextDiffuser2 差异在于：

1. 布局模型用大语言模型去替换。LLM 能表现出比较强的语义理解布局规划能力，用一个 LLM 去理解 prompt 转化为对应的布局格式，效果会更好。
2. 生图阶段，对扩散模型中的语言模型(clip)和 U-Net 都做了训练。

训练

布局模型：

1. 使用 LLM vicuna-7b-v1.5 模型进行微调，训练用的还是前面的 MARIO-10M 数据集，拿这个数据集每张图对应的描述文字作为输入，用 OCR 把每张图片的内容和位置信息提取出来作为预期输出做训练。
2. 这里自定义了布局的格式，一个关键词以一组坐标和字母组成，比如 [x25][y89][x108][y96][W][I][L][D]，两个坐标表示方块左上右下两个点。每个字符单独标记，会比去做BPE分词标记效果好。
3. LLM在学习了大量文字对应图片的构图后，可以从语义推理这些文字的构图应该是怎样的，同时 LLM 自身也能很好理解哪些词是关键字，哪些词应该在同一行。比如上图的 旷野之息邮票 a stamp of Breath of the Wild，LLM 可以学到图上的文本应该是 Breath of the Wild，而对于邮票比较好的布局是上下两行，有个关键字 Wild 突出，得出相应的布局数据。
4. 根据论文描述，5000个数据量的训练效果是最好的，可能数据多了反而过拟合效果不好。

生图模型：

1. 直接在扩散模型中训练，图上的 M2 是扩散模型里的 clip 文本模型，布局内容和文本 prompt 会一起输入，U-Net 也参与了训练，继续在用 MARIO-10M 数据集做训练。为什么这种方式训练效果好，文中没怎么提到。

效果

TextDiffuser2 的多样性会好一些，字体形态多样。

总结

还有一些其他方案，例如 GlyphDraw、AnyText等，大原理差不多，不展开多说了。最后，用 notion AI 总结下本篇文章：

AI 图片生成文字主要有以下几种方案：

1. GlyphControl：通过白底黑字的参考图来控制生成文字的位置和内容，实现简单但泛化性较差。
2. TextDiffuser：采用两阶段方案 – 先用 transformer 模型生成文字布局 mask，再用扩散模型生成最终图像。但生成的字体样式比较单一。
3. TextDiffuser2：改进了 TextDiffuser，用大语言模型替代布局生成，并对扩散模型进行更全面的训练，使生成的文字样式更加丰富多样。

这些方案的核心思路都是：

• 准备大量包含文字的图片数据集（如广告、海报等）
• 设计两阶段架构：先生成文字布局，再生成最终图像
• 通过不同的技术手段（如 ControlNet、LLM等）来提升生成效果

目前 TextDiffuser2 的效果最好，既保证了文字的准确性，又能生成多样化的字体样式。Recraft 借鉴了 TextDiffuser2 和 GlyphControl。

近期苹果发布的新品，无论是 iPhone 还是 Mac，都一改之前挤牙膏的风格，在最低配机器上都加大了内存，目的很明确，就是支撑 iPhone 和 Mac 上的端 AI 大模型。过去一年，AI手机、AI电脑的概念也一度在炒，在之前写的文章也说过，在客户端上跑大模型，一定是未来趋势。那目前端上大模型情况怎样？

应用近况

总的来说，各家陆续出了不少小模型，相关工具链也能支持它们在客户端上跑起来，但可用的应用几乎没见到。

不少手机厂商都号称接入了端模型，但实际上没搜到相关具体应用，Apple Intelligence 还在路上，演示的能力似乎大多是云端模型，不确定本地小模型能做的事。Google Pixel 8 也没有接入Gemini nano，小米14上没有MiLM，小爱完全靠云端模型，OPPO find7 号称端侧模型用于生成通话摘要等一系列能力，但似乎得联网，不确定端模型在上面起到的作用有多大，真正能离线用的也只有图片消除功能。

为什么雷声大雨点小？

1. 完全体 LLM 近一年的应用场景也有限，端上也就更少了，当前阶段业界精力还是主要投入在研发最好的模型上，很难顾得上端的优化。
2. 现在的硬件和模型优化程度还不允许 LLM 在端上有作为。端设备基本都对体积和功耗敏感，这两者都限制了硬件能提供的最大性能，7B的模型硬件支持不好，3B的效果不好。

我在 Macbook pro M1 上试跑了下，感受是：3B级别的小模型基本不可用，7B/8B级别的模型速度太慢，资源占用也太大：

1. llama3.2 3B模型，大小2G，推理速度 62 token/s，翻译/总结/简单的指令理解，都有很大偏差，基本不可用。3B 这个级别或更小的模型，目前看起来需要针对特定任务做微调才能有作用，通用能力不太行。
2. llama 3.1 8B模型，大小15G，推理速度约 8 token/s，基本问答/翻译/总结可用，但速度太慢，资源要求太高。（这篇文章估算了推理速度，与实测差不多）

LLM 端推理引擎

客户端 LLM 应用还没到时候，但不妨碍大家对这个方向的投入热情，相关的工具链有比较大的进展。

这块工具链的核心是推理引擎，LLM 的训练和推理一般都用 PyTorch，它在GPU适配/加速/生态上都是最好的，但在客户端跑模型，有一些其他诉求：

1. 在 CPU 上推理的能力，以及能适配多种 GPU 加速
2. 量化技术，需要更小的模型、更低的资源消耗
3. 可以轻量编译部署到多种客户端环境

所以需要另一种推理引擎，目前用得最多的是 llama.cpp。

llama.cpp 是 C++ 开发的 LLM 推理引擎，最开始只用于 meta 的 Llama 模型推理，后来扩展到更多模型，包括 Mistral / Gemma / Phi / QWen 等基本所有开源的 LLM，也包括基于 LLM 的多模态模型 llava。llama.cpp 是个人开源项目，基于同个作者的 ggml，在它基础上加了相关大模型推理的功能，token 化 / 缓存管理等。

llama.cpp 可以跑在基本所有主流操作系统上，Android、iOS、Linux、Windows、macOS，甚至 WebAssembly上也提供支持，支持各种 GPU / CPU / NPU 推理。

基于 llama.cpp，上层包装了很多应用，可以方便地在桌面端和移动端跑各种 LLM 模型，桌面端上使用最多的是 ollama，近期 LMStudio 也很不错，移动端上可以用 pocketPal。

上述这些都是包装了模型下载管理和聊天的壳，目前比较少见到基于 llama.cpp 包装更上层垂类场景的应用。有些些 Mac AI 应用会同时提供线上 GPT 接口以及本地 ollama 接口，LLM 处理可以在本地进行，例如做音频视频转文字和总结的 MemoAI，这也可能是后续 Mac/PC 本地 AI 应用的标配。

除了llama.cpp，还有类似的mlc-llm，也是全平台和多种 GPU 支持。还有专为苹果芯片优化的LM Studio MLX，不多介绍了。

LLM 以外

在实际应用中，端 LLM 还没能用起来，但一些厂商为了推 AI 手机 / AI 设备的概念，经常会包装进一些其他的 AI 能力，比如图片消除能力、语音唤醒识别能力。目前端 AI 真正能在实际场景中应用得好的，也还是这些多媒体图片/语音处理类的小模型，跟 LLM 无关。

常见的图片处理比如 杂物擦除、图片超清、背景去除等，都有很多小模型，转换为 ONNX 或其他推理引擎支持的格式就可以在端上跑。

ONNX 是一种标准开放的模型格式，PyTorch / TensorFlow 等各大深度学习框架训练的模型都可以转为 ONNX 格式，然后用统一的 ONNX Runtime 推理引擎部署在多种硬件和操作系统上，目前大多数端上推理引擎也都支持 ONNX 格式做推理，腾讯的 ncnn/TNN，阿里的MNN，小米的 mace 等都支持 ONNX 格式。

理论上只要模型不大，对硬件运算要求没有特别高，转化为 ONNX 格式后在端上都能很好地使用，很多特定的多媒体能力很符合这个条件，例如杂物擦除MI-GAN，只有590万个参数，直接跑在浏览器上 / APP 上都没问题，效果也不差。还有其他很多基于 GAN 的模型，图片超清Real-ESRGAN，老照片修复 GFPGAN 等，运算要求都不高，跑在端上没什么问题。IOPaint 这个项目可以看到比较多类似的模型。

如果不考虑多平台部署，把模型转为平台自带推理引擎支持的格式，是能更大程度优化性能的，例如可以将模型转为 CoreML 格式跑在 iOS/Mac 上，但相对比较少，大家更倾向于跨平台的方案。iOS 上比较有名的端生图 APP DrawThings 就是将 Stable Diffusion 转为 CoreML 格式并量化后跑在端上。也有把 SD 转为 ONNX 格式去端上跑的，但还没看到比较好的应用。

一些遐想

端模型的应用，从硬件上分两种：

AI 硬件

1. 有些场景可以不受设备大小限制、甚至续航功率限制，可以做得比较大，车机系统是一种，这是最好最大的应用场景，端上大模型 AI 应用会最先产生在这个领域，FSD也可以认为是端 AI 的一种。
2. 还有一些可能得 AI 教育硬件，陪伴的玩偶等，本身也足够塞个大运算量芯片和大电池。一些刚需的硬件，比如导盲眼镜，也可以是连着口袋里一个不小的计算设备，这些算是后续可能的端上大模型的应用场景。
3. 但除了车载系统以外，其他 AI 硬件要采用这种方式，发展会比较难。技术体验是一回事，还有商业模式的问题。
4. 这些设备是自带硬件端上跑，还是云端跑，其实就是买断制和订阅制的区别。在端上跑需要用户一次性付出较高的硬件成本，但后续没有其他额外的成本。云端跑初期用户付出的硬件成本低，甚至厂家也愿意赔钱卖机器，但后期是可以用订阅服务制长期收费。从这角度看，用户和商家基本都会选择订阅制，对双方都更友好。所以端大模型要在 AI 硬件上流行起来，还比较难，除非是有些场景对隐私和实时性要求就是很高。

手机电脑

另一种就是利用已有设备，不需要用户额外花钱买硬件，那就还是回到设备大小、续航功耗、发热、机型覆盖等限制，有些场景为了省成本可以先用起来，PC / Mac 陆续可以有一些应用场景，例如上面提到的连接 ollama 的 MemoAI，浏览器上的 AI 搜索也非常适合端上 LLM 去做，但可能这几年会一直处于小场景尝试的阶段，要到主流的程度还早得很，也可能一直不会是主流，手机更是了。

AIGC 图片生成的技术，基本是22年开始爆发，Midjourney 2022年7月推出，Stable Diffusion 2022年8月推出，至今两年发展迅速，已经广泛在很多场景应用，但这个市场上是谁在用图片生成，用来做什么，一直以来在我认知里都有些模糊，这篇文章做下相关调研。

线上线下所有用到图片的地方，都有 AI 图片生成的应用空间，而 AI 图片生成的能力，也会创造出新的领域和行业，就目前能看到的已经在应用的场景，归归类可以分为：生产力工具、大众娱乐、探索创作。

ToB：生产力工具

把 AI 图片生成能力作为实际工作中的生产力工具，用在各领域的内容生产，替换原来的工作流，效率有量级上的提升，同时也有因为 AI 图生成带来的新的领域，例如自媒体。

这里的用户大部分是设计师，全球设计师 9000w，包含建筑设计、室内设计、工业设计、服装设计、产品设计、平面设计等，Adobe 付费订阅人数2650w（2022年），是非常大的市场。

电商

电商有大量的市场，为了展示、介绍、美化不同种类的商品，对图片有巨大的诉求，是AI图片（以及视频）最好的应用场景。

1. 模特图：模特换衣、模特生成、在线试衣，专门服务服饰品类的工具，全球电商服饰品类市场规模六千亿美元，这让它对应的工具需求也足够大，能搜到的有几十家公司专门在做，例如Botika、VModel.AI、摹小仙、千面AI模特、ZMO.ai、linkfox，美图秀秀/醒图等也有相关工具。入门门槛低，但效果的调优是wu’zhi’jing的，不同角度/动作/不同衣服穿上后的自然度等都需要不断调优。
   

   换模特	换衣

2. 商品图：上传商品图，AI 可以帮你生成商品在不同环境下的宣传图，免去摆拍。相对于直接抠图→套模板，AI生成质量高，可定制程度也高，可以创造符合商品的各种背景，商品能更好融入对应背景、环境的光线阴影、颜色、高保真，这里的效果调优也是无止尽。同样有非常多公司在做，photoecom、灵动AI 、PicCopilot。综合性的图片工具大多也会加入这个功能，比如 photoroom。
   

   灵动AI	photoroom

3. 其他长尾：电商很庞大，除了上述两个类，整个上下游各个品类还有不少细小长尾的 AI 图片生成需求，例如 T恤定制、衣服花纹生成、款式生成、站外营销图等。
4. 从发展趋势看，电商平台如果自身有余力，都会去做这样的工具，嵌入到自己平台内，整个工作流更顺，像淘宝千牛自己就做了。但竞争是无止境的，所有商家都用平台提供的工具，质量品质同质化后，就会有个性化或追求更好效果的诉求，外部工具一直会有机会。

素材

素材应该是需求第二大的领域，活动图、海报、封面插图(文章/播客/杂志)、PPT，日常工作很多场景会用到，以前是搜图片找素材拼接，但如果是商用场景，一不小心有侵权的风险，素材是需要付费的，AI 图生成目前没有这个问题，而中国的版权图片市场规模在2020年是34亿，在高速复合增长。素材生成的诉求很泛，不太依赖可控生成，应该大部分都用图生成质量最好的 Midjourney，海报生成因为涉及文字，ideogram.ai 有较大的优势。

ideogram海报	营销素材	壁纸

自媒体

AI 图片生成的能力会被一些自媒体创作者用于创作有趣的内容，带来流量，进而接商单。例如影视/动漫 IP 二创、自制IP形象（宠物打工、宠物时装秀等）、扩图玩梗、表情包等，会不断有各种有趣的玩法持续出现。

高质量图	扩图，玩梗	玩法	影视IP二创	自制IP

其他

1. 游戏设计：首当其冲是游戏原画，AI 图片生成出来的质量，跟外包原画师已经没有太大差异，或者质量更好，去年就传出游戏公司大规模砍原画外包的新闻。同时游戏内容本身需要大量的角色、场景设计，对于质量要求不高的 2D 游戏，AI图生成已经可以很好满足需求。
   

   角色生成	游戏原画

2. 建筑设计：借助 SD ControlNet 的能力，很容易做到建筑线稿设计图转绘为效果图，渲染不同风格，也不需要有多少微调的工作，各工作室自己可以部署。对于建筑灵感，直接用 Midjourney 看起来也是足够。
   

   概念设计	线稿转绘

3. 漫画/绘本故事：核心是模型角色保持的能力。儿童绘本故事门槛很低，网上也有大量应用的教程，大众对质量的要求也没那么高，这是 AI 图生成目前擅长的。漫画门槛高一些，核心是故事、分镜的质量，生图所占的比例其实不高，所以如果用 AI 大规模生产，质量堪忧，但也有一些精品，比如这个。针对漫画有一些独立的产品和模型，例如dashtoon、Comic Factory、comicsmaker、llamagen等。
   

   武侠漫画	Comic Factory

4. 动画/短剧：同样借助角色保持能力，生成图片后转成视频形式去消费，这也是后续内容制作的趋势。目前还没看到大规模成熟的应用，短剧类 midreal 相对小众，月活几万的级别。小说转动画视频有不少产品在尝试 剪映的故事成片、极虎漫剪、漫剪猫等，规模比较小，但作为生产力工具，付费率是挺高的，做出来的内容有一定消费价值。

ToC：大众娱乐

图片特效

大众用户日常社交对图片是刚需，AI 图片生成在这个领域的应用是最广泛和成熟的，跑出很多爆款产品，Top 的是 Remini（23年MAU 8000w+，收入6643万美元），其他也有非常多产品冒出，AIMirror/FaceAPP/Lensa/Prisma等。

这个领域不断会有爆品出现，理论上不会一家独大，每个产品都有机会，逻辑是：出效果爆款→社交媒体传播全网引爆→大量用户使用&付费→热点几周后消退，用户少量留存，大量流失→找下一个爆款→找到进入下一个循环，找不到产品逐渐消亡。典型的持续活下来的产品是Remini，消亡的是妙鸭。

具体应用上，姑且分为 AI 写真和特效。

1. AI写真：人像 P 图是刚需，AI写真算是这个刚需的分支，火过很多产品，国内的妙鸭，海外Remini，还有一大波专门做这块的垂类产品 PhotoAI、星绘等。妙鸭虽然火一波以后销声匿迹，但这个需求是长期可持续的，photoAI 是独立开发者的产品，月流水已经到17万美元。主要用于各社交软件头像、linkedin商务照等。
2. 特效：比如风格化的黏土风格、盲盒公仔、迪斯尼风等，还有其他例如换发型、换性别、变老变年轻、扩图等特效。

Remini 众多特效	星绘 AI 写真	ailabtools 换性别、年龄

新场景

另一类 ToC 的应用，是把 AI 图片生成能力作为全新产品的一部分嵌入，跟产品形态有较强的绑定。

1. 陪伴类产品：纯 LLM 文字陪伴发展下去肯定是结合图片生成/视频生成，让人更沉浸式，可以衍生抽卡、剧情图、虚拟女友形象等。产品非常多，MiniMax 的 星野/Talkie、candy.ai、dreamgf.ai 等，AI 陪伴还在爆发增长期，AI 生图在这个领域有很大应用空间。

2. 教育类产品：DoDoboo 将儿童涂鸦实时转为绘画作品，激发儿童创造力。是一个尝试性的应用场景，没有很成功，但 AI 教育是万亿级别市场，儿童教育领域本身注重创造力想象力的培养，AI 图片生成就是想象力的呈现，是有机会创造或融入更多教育产品。

   

3. NSFW：成人产品，比较特殊，市场自然是巨大的，待分析。

Talkie	DoDoboo

探索创作

除了上述 ToB 和 ToC 两类非常明确的应用场景外，AI图生成还衍生出另一波探索型用户。他们不是为工作，无商业目的，单纯喜欢玩 AI 创作，他们可能不会画画，AI 让他们可以不需要学习绘画技能，就能创作出好的作品，这对有创作欲的人有很强的吸引力。

Midjourney 付费用户中，只有 32% 的用户目的是工作或实际需求，68%的用户是为了娱乐。一方面因为 Midjourney 可控性不足，导致很难在真实生产环境使用，较少覆盖上述 ToB/ToC 的那部分用户，另一方面也能看出，纯粹探索 AI 玩图片生成的人群规模也不小，24 年 Q2 Midjourney 月活 600万+，24 年预计收入预计超过 3 亿美元。

Midjourney	Midjourney	thehybridportraits 高端定制

图片生成技术，跟摄影技术有点像：

1. 没有摄影时，只能通过超高的绘画技术记录现实画面，门槛很高，摄影技术让人人拥有记录现实的能力，只需要按个按钮。
2. 而没有图片生成技术时，也只能通过绘画技术记录和创作现实没有的画面，把心中想象的创意具象化，图片生成技术让人人拥有创作的能力，只需要输入文字。
3. 除此以外，还有一些相似点：
   1. 人人能用，但专业才能用得好：AIGC跟相机一样只是技术，日常拍照人人能拍，要拍出好的照片，不是人人能做到，即使摄影看起来只是按下快门，调下参数。图片生成随便输入 prompt 人人能创作图片，但要创作出好的作品，也不会是人人都能做到，即使看起来只需要输入文字。
   2. 大众需要，商业也需要：摄影可以记录生活，这是大众需要的，也可以杂质配图、做商业广告等，这是商业需要的。图片生成也一样。
   3. 新的艺术形式：摄影单独是一种艺术形式，相信 AI 图片生成也会带来独有的新的艺术形式，只是目前还未成型，摄影从诞生到成为一种艺术形式，也花了60年。跟画画与摄影不同的是，AI 图片生成创作，是有双向交互的，它不是定死的画笔或相机，创作过程中，AI 创作出来的内容会牵引下一步创作动作，不是一步到位，也不是忠实呈现自己脑里所想、呈现现实世界已有的东西，AI 不仅是工具，作品是人与 AI 的共创，有可能是新的艺术形式。

但跟摄影不同的是，图片生成技术，也许无法像拍照一样普及率那么高，摄像头记录美好生活是高频刚需，但创作不是，纯 AI 创作最终还是属于少部分创作者，就像能称为摄影师的只是少部分人。AI 技术进步是赋予了不会画画但有创意的一波人更强的能力，就像抖音最终赋予的也是少部分创作者展示他们才华的能力一样。

创作无法普及到大众，但创作出来的内容是能普及的，内容消费是大众刚需，至于这波创作者能否创作出跟摄像头相媲美的另一个维度的内容，支撑起一个 AI 内容消费社区，有待探索。

最后

生产工具、大众娱乐、探索创作，这三类图片生成的应用，差距还是比较大的。

1. 生产工具，需要深入到场景做微调，不断优化效果、深入工作流。
2. 大众娱乐，需要的是制造爆款的能力。
3. 探索创作，需要有最好的基础模型能力，以及做好社区运营。

目前看起来没有一个产品能大面积覆盖这几个场景，未来会不会有？只要团队能满足这些条件，能造出一个超级应用满足所有图生成的诉求，大众认知上是没问题的，像上个时代的 Photoshop。

是什么

1. 在机器学习领域，”模态”被用来描述不同类型的数据形式，如文本、图像、视频、音频等。
2. 最开始以 ChatGPT 为代表的大语言模型，都是只支持文本这个单一模态。
3. 可以同时处理文本、图像、音频等多种形式的数据输入输出的大模型，就是多模态大模型。

特点：端到端

一个模型能同时理解和处理多种模态的数据输入。

1. 非端到端的例子：
   1. 在 ChatGPT 上，可以调用 DALL-E 生成图片，但实际流程是 prompt → GPT4模型 → 生成细节提示词 →DALL-E模型 → 生成高质量细节图像，只是一个能力串联，并不是一个多模态大模型。
   2. 在豆包或其他一些LLM APP上，支持语音输入→文字和语音输出，实际流程是 语音→ASR模型转文字→LLM→文字→tts模型转语音，并不是端到端 语音→LLM→语音。
2. 端到端的例子：
   1. GPT4o 的实时语音对话，流程是 语音→ GPT4o模型→语音。延迟低、语气/音色/停顿/语义都能综合理解到。
   2. claude3.5 支持按要求识别图片，流程是 图片+prompt → claude模型→文本。能很好结合 prompt 按要求输出对图片的识别。
3. 端到端的好处：
   1. 模型能直接从原始的数据中学习不同模态之间的关联和映射关系，发现隐藏在数据中的复杂跨模态模式，可以 scale up 达到涌现，没有中间折损，可以做到低延时。

原理：基于大语言模型

1. 多模态大模型以大语言模型为基础模型，复用已预训练好的模型理解能力，在上面增加其他模态的能力，对齐多个模态的特征让原大语言模型能理解。GPT4o 就是在 GPT4 基础上增加音频/图片的特征能力，它在文本上的理解能力还是跟 GPT4 差不多。
2. 模型通用的基本构造(参考这篇文章)：

   1. 编码模块，将图片/视频/音频等模态编码为特征 token，一般还伴随一些压缩的处理。

   2. 投影层(Projector)，让不同模态的特征 token 语义对齐，这是模型重点要训练的部分。

   3. LLM，多个模态的特征都在基础 LLM 大模型上做处理理解，通常 LLM 本身也要在新的模态训练过程中做相应微调，适配新的模态。

   4. 若支持多模态输出，也同样有模态对应的投影层和解码层。

      

当前模型能力

把多模态大模型能力拆分成输入理解、输出生成的话：

1. 当前主要在发展输入理解部分，较多大模型支持了图片理解、视频理解能力。
2. 输出生成上，主流的还是各模态各自在发展阶段，如图片生成模型、视频生成模型、音乐生成模型，都是独立单任务模型。GPT4o、gemini 支持了音频的端到端理解和生成，其他大模型基本还只支持文本生成。
3. 有一些新的模型在尝试大统一，输入输出都支持 文本、图片、音频、视频多种模态，如腾讯刚出的 VITA、AnyGPT、Unified-IO，都处于起步阶段，看起来综合效果还没很好。

图片理解

通往多模态的第一步，基本都是在LLM上加入图像识别能力，已成为目前大模型标配，这是最自然最广泛的需求，难度也不高。

现状：大部分模型 文心一言，豆包，GPT4o，claude、Gemini 等都支持，开源的 Qwen-VL、LLaVA、Yi-VL、MiniCPM-V 等也非常多。

能力：大模型加持的图像识别，各项能力都能胜任，包括OCR、图片物体理解、逻辑理解、文档图表理解、隐喻理解等。

效果：能力比较全面，但也相对平庸，相对垂直领域专门优化的图片识别模型，效果有差距。例如各大模型在OCR能力上的评测，相对最好的OCR垂直模型有差距，更垂直的像植物识别这种，跟PictureThis 这类专门优化过的差距会更大。对图片理解上，结合大模型能力效果会比较好（评测）。图片识别评测维度非常多，有各种维度的评测标准，从个人实际观感上综合识别效果最好的是claude 3.5。

原理

以 Yi-VL 为例，其他模型差不太多，都是在 LLM 基础上增加图像编码处理然后端到端训练 ：

1. 图中的Large Language Model是基础模型，Yi-34B-Chat或Yi-6B-Chat。
2. Vision Transformer（ViT）模块用于图像编码，用CLIP模型。
3. Projection 模块处理图像特征，训练后的这一层让图像特征跟文本特征空间对齐，包含 layer normalizations 和 Multilayer Perceptron（MLP）。
4. 火焰标志表示训练，雪花标志标识冻结不训练。训练分了3步，用了不同的 图片-文本 数据对，最后一步 LLM 也参与训练了。
5. LLaVA/MiniCPM-V也是类似的结构和训练过程，训练最后一步都会微调到LLM基模参数。

应用

1. 图片搜索、语义搜索、物体识别、人脸识别这些垂类小模型已经能做好。
2. 给图片配诗、给图片配音、拍照搜题+解题、阅卷、验证图识别等，这些用结合LLM的大模型，门槛会降低，效果也会有优化。
3. 截屏识别自动化，试卷阅卷，这种场景结合 LLM 才能做好

视频理解

现状：部分主流大模型支持通过把视频抽帧为一系列静态图进入模型分析，本质上是图片理解能力，能做到一定程度的内容理解，GPT4o 基本是这样，一些支持图片识别的大模型稍加调整也能支持这种方式。少部分模型能识别视频和对应的音频，如Gemini、阿里开源的 VideoLLaMA2。有比较多的开源模型在做各种方式的尝试，更好识别视频帧之间的时间逻辑关系、跟音频/文字模态做更好的整合理解。

效果：有个项目 Video-MME 专门分析各大模型视频识别理解能力，测了多个模型在各种理解任务上的表现，包括时间/空间关系的感知和逻辑推理、文字/物体感知、信息总结等，视频类型包括电影、体育、vlog等，能结合整个视频里的信息做理解。各模型在2分钟以内的短视频上理解能力已经不错，中长视频会差比较多，Gemini、GPT4o和效果最好的，开源的模型差距还比较大。

原理

视频理解的主流方法是使用图像编码器从视频中提取帧，对其进行编码，然后用压缩模块压缩视频编码信息，再将其输入到 LLM 中，与文本输入进行联合理解。

也有很多模型在尝试各种方案，如智谱 CogVLM2 加入时间定位、时间戳的数据，让模型能感知视频对应时间。有些模型尝试改造 LLM，不让视觉特征与文本混合，在 LLM 内部增加独立的 transformer 模块处理，如 mPLUG-Owl3。

以 VideoLLaMA2 为例看下大致原理， 综合支持了视频和音频输入，视频和音频分别编码：

1. 视频按帧编码为特征，经过STC Connector 处理，Spatial Convolution 处理视频帧特征，提取空间信息，Spatial – Temporal Downsampling 降低视频数据维度，再经过投影层与其他模态特征对齐，一起进入大模型。音频也是一样的流程。
2. 训练分成多个步骤，视频、音频分别单独训练，最后再联合视频音频一起训练，每个步骤有对应的数据集，看起来只有最后一步联合训练，LLM基模的参数才会参与训练。

（题外话，名字叫 VideoLLaMA2，实际上跟Llama没关系，LLM基模用的是Mistral）

应用

基于类似的原理，可以自行训练在垂类表现更好的视频模型，例如：

1. 视频配文案
2. 视频内容总结、解读
3. 视频内容搜索（以自然语言搜索长视频特定内容出现位置）
4. 影视解读（影视时长过长，当前大模型 context 能力还不具备）

音频理解&输出

能力：GPT4o 和 Gemini 都支持了音频理解和输出，能很好理解音频里的语气、语调、节奏、风格等信息，细微的喘息、叹气声都能很好识别和生成，实时性也能做到很高。

原理

目前 GPT4o 和 gemini 相关公开的具体实现细节较少，最基本的原理跟上述应该差不多，语音编码为token→投影层对齐其他模态→输出预测语音token→解码为语音。可以看看 AnyGPT 的实现：

应用

最主要的应用是拟人真实程度高的实时语音对话，从GPT4o的演示看，这点对体验影响很大，即使智能能力进步不大，真实性和实时带来的 AGI 感受也是很强。

语音转录、会议记录总结等，虽然已经有很多 ASR 模型能做到转文字，但整个音频的内容、多人对话、语气情绪都能输入大模型，结合大模型理解能力，预计能做到更好的效果。

其他

端到端生成图片 Gemini 号称支持，但没找到相应资料，视频生成单模型都还在摸索，结合 LLM 还早。多模态大模型整体处于发展阶段，各模态的理解和生成还没到很高的水平，整体进展没预期快，但以当前的能力，针对垂直场景做一些训练，是能够较低门槛做出一些之前做不到或做不好的应用了，例如视频配旁白。

经常看见有一些视频生成的模型出来，类型还不太一样，简单学习和调研下这个领域和相关技术的情况。在我所看到的有限的范围里，可以把近期出现的视频生成能力分成两类：

1. 一类是专门精细化控制人物表情动作的模型，驱动一张人像照片动起来。这类模型存在已久，老技术也能实现，近期不断有新模型出现，效果也越来越好，业界好像没针对这一类命个名，姑且叫它人像视频。
2. 另一类是通用的视频生成基础模型，包括基于扩散模型的，以及 sora 出现后的 DiT 架构模型。另外跟 Stable Diffusion 图片生成的生态类似，也会有一些为视频生成基础模型配套的可控编辑扩展模型。

人像视频

先来看看人像视频，常见有两类：

1. 表情控制：输入人物表情视频，让图片的人脸跟着做同样的表情。变种是输入音频，让图片人脸跟着音频的口型动，talking photo。
2. 姿态控制：输入人物动作的视频，让图片的人跟着视频的动作动。火过的 case 是通义千问的全民舞王科目三。

表情控制(Vimi)	姿态控制(Animate Anyone)

这里的技术都不是这波大模型后才有的，上个时代已经有很多做得不错，上一波爆火的蚂蚁呀嘿已经是 2021 年的事了，相关论文也是 2019 年就有了：《First Order Motion Model for Image Animation》。后面不断有新的方案，包括基于和不基于扩散模型的方案。下面列几个近期出现，看起来还行的方案。

表情控制

基于扩散模型

基于扩散模型的方案，大体思路看起来是在原网络插入 pose/人脸点位 控制，跟 ControlNet 原理差不多，扩散模型本身除了 SD Unet 那套外，基本都会加入视频生成常见的 spatial-attention 和 temporal-attention。

AniPortrait(华为)：24年3月发布。支持从语音生成对应每一帧的口型和人脸位置图，再基于 SD1.5 扩散模型 + motion module 从参考图生成视频结果。开源可用。
megActor(旷世科技)：24年5月发布。没有把视频解析成中间关键点去驱动图片，而是原视频画面直接驱动，以预期得到更生动的效果，2个UNet网络，推理成本看起来会高一些，效果稳定性一般。只支持视频面部特征，不支持音频对口型，开源可用。
EchoMimic(蚂蚁)：24年7月发布。同时使用音频和面部特征进行训练，可单独用音频生成，也可以结合输入视频的面部特征生成，结果更自然，开源可用，comfyUI module可用。

还有几个不开源的：微软的VASA-1，阿里的EMO，都是语音对口型，朝着数字人方向做的。

非扩散模型

非扩散模型的方案，看起来基本也是先把人脸节点生成完，再用其他的网络结构去应用到图上生成视频。

LivePortrait(快手)：24年7月刚出的模型，模型很小，主干网络是 ConvNeXt-V2-Tiny，28M参数量，各部分加起来就500M，号称速度很快，单帧推理时间在 RTX 4090 GPU 是 12.8ms，都能稳定实时输出 60 帧视频了，很适合端上部署，这也是非扩散模型的优势，还有个特点是能快速精确控制眼睛和嘴巴的开闭程度，动画稳定。comfyUI module 也有了。
VividTalk(阿里)：跟 AniPortrait 有点像，同样是训练音频→表情嘴型关键点，音频→头部运动关键点，再经与图片一起进入另一个网络生成最终视频，只是这网络不是基于扩散模型。未开源，真实效果未知。

姿态控制

AnimateAnyone(阿里)，23年底发布。效果比较稳定，官方没开源，但摩尔线程基于论文做了开源实现 Moore-AnimateAnyone ，后续腾讯 MusePose 基于这个开源实现继续优化和封装，comfyUI可用。
magic-animate(字节)，23年底发布。Pose 序列不是 OpenPose 人体骨骼，而是丰富的整个人的动作 densePose，视频转 densePose 还比较麻烦，densePose 序列用 ControlNet 的方式去做生成的控制，另外有一个网络去编码人物形象做IP保持。试用下来，参考图跟 pose 的形象姿态差异大的场景也能支持，比如让蒙娜丽莎跳舞，但这种场景下效果不太好，人脸基本不保持，只保持了人物衣着的IP形象。已开源。

还有其他很多，MimicMotion，MuseV，Follow Your Pose，DreaMoving 等，大同小异。

视频生成

视频生成模型业界除了最出名的 runway、pika、sora，也陆续有不少开源的方案出来，当前已有的开源方案基本都是基于 Latent Diffusion Model，核心是 UNet 降噪网络，基于这种网络还有不少做视频可控编辑扩展模型，DiT 架构还在路上。

基础模型

I2VGen-XL(阿里)，23年11月发布。比较常规，基于 3D-UNet 扩散模型生成，分成基础生成和高清细化两个阶段，细化阶段不是单纯提高分辨率，会改善时间连续性、引入文本输入控制内容。开源可用。
SVD(Stable Video Diffusion)，23年12月发布。模型结构复用 Video LDM，主要是在 U-Net 和 VAE 解码器中分别加入时序层（temporal attention layer），SVD 论文本身在讲模型怎么训练的，包括高质量视频的微调。
PixelDance(字节)，23年11月发布。特点是首尾帧机制，首帧图作为强引导，与噪点图拼接一起作为输入，严格遵守首帧图，同时尾帧图作为弱引导，训练中会随机抛弃尾帧，推理降噪过程中在步数大于τ值时也会抛弃尾帧，避免完全对齐，让生成的结果有多样性。在 DiT 架构的模型出现之前，效果基本是最好的，生成的视频运动幅度大，稳定性不错。未开源。
ConsistI2V(零一万物) ，24年2月发布。跟 PixelDance 有点像，也是首帧与噪点图拼接一起作为输入（类似 SD 的垫图），同时会把首帧也作为降噪过程条件作用在 spatial-attention 和 temporal-attention 上，较大地强调首帧图片的重要性，这样生成的视频不容易崩，一致性比较好。 已开源，可在线试用。

可控编辑

视频生成的可控编辑是指通过各种方式控制视频生成方向，例如运动方向、内容替换、风格迁移等，原理上跟图片生成的 ControlNet / IPAdatper 等机制差不多，基于上述视频生成基础模型，训练扩展模型插入原网络，控制生成方向。

图生视频控制

大部分视频生成是图生视频，在图片上圈选运动范围和运动轨迹是很自然的诉求，一代目 Runway 上的 Motion Brush 就是做这个，基本应该应该是后续正经视频生成模型的标配，也有开源模型基于 SVD 等基模做了这个能力。

mofa-video(腾讯)，24年7月发布，基于 SVD。可以训练多种 adapter，控制图片生成，包括手势控制、人脸关键点控制、姿势关键点等，每种控制 adapter 独立训练，可以独立使用或组合使用，比较灵活通用。开源可用。

视频内容编辑/风格化

这一类指 Video to Video，修改原视频上的元素，替换衣服、人物等，部分也包含了视频风格迁移能力。

ReVideo(腾讯)，24年7月发布，基于SVD。通过修改第一帧和绘制轨迹线，对视频中特定区域内容和运动进行定制化编辑。使用分阶段训练的策略，简单理解为，A阶段重点训练运动轨迹，B阶段重点训练内容替换，再进行结合。开源可用。
I2VEdit(商汤)，基于SVD，利用成熟的图像工具编辑第一帧，再将第一帧的修改应用到整个视频，实现局部替换和风格化。
AnyV2V(华为)： 比较通用的视频编辑框架，可以灵活用于多个视频生成模型，包括I2VGen-XL、ConsistI2V、SEINE， 同样是先通过各种方式改造编辑视频首帧，再插入视频生成模型，将风格和替换内容扩展到整个视频，实现视频编辑能力。通用于多个模型的原理，简单理解是提取了空间注意力/时间注意力特征注入了原生成模型的 spatical-attention/temporal-attention 模块，理论上差不多架构的模型都能通用。 可试用。
animatediff：animatediff 比较特殊，不是基于 SVD，而是基于图生成 Stable Diffusion，在上面训练加上运动模块 Motion Module，学习了视频片段的运动知识，支持视频生成。很早发布，在 SD 生态配合 IPAdapter / ControlNet 等各种扩展和 LoRA 模型一起使用，组合出很多有趣的应用，看到的大部分视频风格转动漫风基本是基于这个方案。

DiT

DiT(Diffusion Transformer) 是视频生成基础模型的一个算法架构，应该放在基础模型部分的，但它太新了，想单独抽出来细看一下。

上面大部分模型，包括可控性的扩展模型，核心底层都是基于经典的 UNet 架构，但 Sora 出来后，业界公认 DiT 架构才是未来，毕竟效果太碾压了，最近可灵 / Luma 的出现也印证了这点。架构范式转移到 DiT 后，原先在 UNet 上做的各种可控雕花，看起来基本上是没法迁移到 DiT 架构的，一切得重来。

DiT 架构开源的只见到去年11月 sora 出来之前的 Latte，研究性比较多，效果一般。其他靠谱的开源模型还没见到，毕竟 Sora 还没见影，可灵和 luma 也刚出。（DiT架构的图片生成就有一些，比如腾讯混元）

DiT的架构图，与 LLM 的架构同源，核心是 transformer 模块，跟基于 UNet 的模型都不一样，我们尝试来看看在这个架构下视频生成的推理过程：

1. 初始化一个噪声视频。
2. 视频会先转换成潜空间的表示，后续的运算都在潜空间里运算，这点跟 Stable Diffusion 一类的扩展模型一致，视频应该是使用 VQ-VAE 进行编码到潜空间。
3. 视频的表示会被分割成一个个 patch 块，每个 patch 块是一个 token，patch == token。
4. 这些代表整个视频的 patch 块集合，一起进入 DiT Block。这个 DiT Block 就是个类 transformer 模块，与 LLM 一样核心也是多头注意力，在这里会计算每个 token 之间的注意力，加上引导词和步数条件，做相应计算。
5. 按 LLM 模型的套路，这里 N 个 DiT Block 跑完，整个流程跑完，输出会是预测的下一个 token。但我理解这里的输出并不是下一个 token（一个 token 只是一个 patch），而是这里的 patch 合集经过这些 DiT Block 的注意力运算和条件引导，变换成离最终视频更近的一个表示，也就是对这里的噪声视频做了一次降噪。
6. 如果是20次降噪，重复20次这个过程，一个纯噪声视频生成最终清晰的视频。
7. 如果要垫图，首帧图尾帧图，只需要让图片跟输入的纯噪声视频做一些结合就可以。

可以看到跟其他的 UNet 为核心的架构有本质差别，像 ControlNet 各种可控性的研究没法迁移，需要另外找控制路径。从业界在这领域卷的程度看，预期发展还是会非常快，等下一个 DiT 架构的靠谱视频生成模型开源，也应该很快会有人在上面把相关可控能力不断研究补齐了。

感想

这个领域给我感受是模型超多，看不完跟不上，只能先了解个大概，在有具体应用场景时，再根据需求做相应深入的调研。

为什么这么多模型？看起来它训练的资源门槛没那么高（比 LLM 低），有公开训练数据集（WebVid 和 LAION），论文上都会把方法给出，width=甚至模型和代码也开源，各研究者很容易从中吸收学习做改进，再造一个模型，现在也没出现一个效果通用秒杀一切的模型，所以三天两头出个新模型是常态。

DiT 架构后，视频生成和视频编辑这些模型大概率要淘汰，而人像视频可能在较长一段时间内仍有应用空间，如果要做 AI 视频短片，人物表情动作精细控制挺重要，DiT 架构目前还没看到有能做到精细控制的技术，基于 Unet 的通用视频生成模型这么长时间也没法做好这块的可控性，可能一段时间内还得靠原有技术做这里的可控后编辑。

Transformer 作为新 AI 时代的基石，有必要深入了解下。网上对 Transformer 的教学文章/视频非常多，很多讲得很好，像 3Blue1Brown 的讲解视频，以及这篇文章。整个详细过程原理写不来，本文主要记录一下其中我觉得比较容易混淆的 Attention 模块运算过程，主要是里面的 Q K V 的概念/运算过程/作用。

这是 Transformer 架构图，左边是 encoder，右边是 decoder，实际 LLM 大模型是只由右边 decoder 构成，这里面大部分是常用的 Feed Forward（前馈网络）/ Add（残差连接）/ Norm（层归一化），核心还是 Multi-Head Attention 模块，我们来具体看看 Multi-Head Attention 模块里做了什么。

输入

假设一个字是一个 token，输入是”我有一个玩”（用于推测下一个字”具“），5 个字，每个字用一个向量表示，每个向量假设是 9 维（GPT3 是 12288 维），也就是用 9 个数值表示这个字，那每个词顺序排下来，就组成了 5 行 9 列的输入矩阵，称他为 X，每一行代表一个词。

6每一个圈圈代表一个数值。”我“字由蓝色的9个数值表示，“有”字是绿色的9个数值。这 9 个数值组成一个 9 维向量，这里每个字对应的向量值是一开始定好的，至于怎么定的不细说，可以看看相关文章。

这个输入矩阵经过 Multi-Head Attention 模块运算，输出另一个同宽高的矩阵，接下来详细看看这个运算过程。

权重矩阵 & Multi-Head Attention

Multi-Head Attention 是由多个 Self Attention 模块拼接而成，如果它只有一个 head，就是一个 Self Attension 模块。

Self Attention

Self Attention 模块里，会包含 Wq Wk Wv 三个参数权重矩阵，模型训练过程就是不断调整 Wq Wk Wv 里的数值。

这几个权重矩阵的行和列数，需要满足：

1. 行数：输入矩阵 X 会与它们进行相乘，所以行数需要与输入词向量的维度匹配，也就是 9。
2. 列数：Transformer 中整个 Attention 模块的输入数据和输出数据维度应该是一致的，才能多层重复叠加，从矩阵相乘特性知道，这些权重矩阵的列数也应该对齐词向量的维度，还是 9。

所以如果这里是单个 Self Attention，Wq Wk Wv 就是行数和列数都是与词向量维度一致的矩阵，也就是 9×9。

Multi-Head Attention

但这里希望模型能捕获到单词间的多种不同注意力，所以会把它拆出来再拼接。假设把它拆成 3 个 head，那就是能捕获到 3 种单词之间不同的关系。这里拆出来的 3 个 head 就是 3 个 Self Attention 模块，每个模块有自己的 Wq Wk Wv 矩阵，行列数是 9 x 3。这里每个 Self Attention 独自进行注意力运算后，再组合拼接。

这里文字描述得比较绕，见后续运算过程和结果的图示比较清晰。

Attention 运算过程

先来看这里每个 Self Attention 模块的运算过程。

这里输入向量分别与 Wq Wk Wv 相乘，得到新的矩阵 Q K V，Q(query) K(key) V(value) 名字已经对应了它的含义，看完它的运算过程后，再来补充下对它含义的理解。

可以认为这里 Q K V 这几个新的矩阵，每一行仍然是表示一个单词 token 向量，只是换了种表示 （矩阵的乘法特性，例如第一行里的每一个数据都是由原矩阵第一行与 W 矩阵运算得来，与其他行无关）。

下图是 Q 矩阵的运算过程，K V 的过程一样，只是 W 权重矩阵的值不同，略过。

接着要做的是，计算每一个单词对于其他单词的 Attention 系数，这是一个两两可重复排列组合。上面 5 个单词，每个单词都 K 矩阵里的自己以及其他所有单词逐一计算出一个值，生成一个 5 x 5 的矩阵。这个矩阵的计算方式就是 Q*KT(K的转置矩阵)，由矩阵乘法特性可以看出，这样算出来的矩阵，就是单词之间的关系值，比如第一行第五列数值，就是“我”和“玩”之间的注意力关系值。下图用颜色表示这个过程。

相乘后对这个矩阵进行 softmax （在这之前还会除以 √dk 向量维度，可以先忽略），每一行的和都为1，这里的矩阵第 i 行的数据表示的是第 i 个单词与其他单词的关系，这里归一化后，数值可以表示理解为，从全文范围上，每个单词对这第 i 个单词的重要程度比例。

最后这里的 Attention 系数矩阵，与矩阵 V 相乘，得到的是新的结合了每个单词之间 Attention 信息的矩阵。输出的矩阵中每一行还是表示一个单词，但这个单词向量经过这里注意力运算后，每个单词向量都集合了上下文每个单词的注意力信息。

单独拆除这里的第一行看看它的意义，单词”我“跟每一个字的注意力权重，再乘以每个字在 V 矩阵里的向量表示，结果再相加，组成最后的结果。比如这里第一个字”我“跟第三个字”一“的权重是0.1，那”一“的向量值对运算后最后表示”我“这个字的向量结果影响很小，如果是 0 就是没有影响。

上述整个过程，可以用这个数学公式表示：

Multi-Head Attention 模块里每个 Self Attention 模块都做同样的运算（但里面的 Wq Wk Wv 权重不同，数值结果不同），拼接起来，形成最终的结果，这个结果矩阵里，每一行每个字的表示，都已经集合了与其他所有字的注意力关系信息。

整个过程实际上还有个掩码的机制，按上述运算，这里输出的每个单词向量都包含了上下文所有的信息，通过掩码机制，会变成每个单词只包含单词所在前面位置的信息，比如第二行“有”只包含了“我”和“有”的信息，没有后面”一“”个“”玩“的信息。这里不继续展开了。

这里每一行包含了前面所有单词的注意力信息，也就可以通过这里的表示预测下一个单词，所以从这个矩阵最后一行“玩”的向量数值，就可以用于预测对应下一个单词是什么。

整个 Multi-Head Attention 的运算过程大致是这样了。实际模型如 GPT3，单词向量维度是12288，上下文长度2048（每个 token 都要跟2048个token计算注意力），每个 Multi-Head Attention 分成 96 个 head，同时有 96 层叠加，也就是 96 个 Multi-Head Attention，运算量是巨大的。

Q K V 的作用

Q 可以理解为原输入的词数据，拿着这个数据找谁跟我有关系。K 是被找的数据，用于计算输入的每个词之间的关系。Q 和 K 是为了算出 Attention 关系系数，知道每个 K 的数据跟 Q 是什么关系。

如果 Q 和 K 是同个输入变换来的，那就是自注意力，如果是不同输入变换来，那就是交叉注意力，比如 Stable Diffusion 里 Unet 的交叉注意力模块中，Q 是文字 prompt，K 和 V 是图片信息，Q 与 K 计算的是文字与图片信息的 Attention 关系系数。

K 和 V 是同个数据源，这个数据源，从 Q 和 K 的运算知道每个 Q 与数据源的关系系数，再与数据源做运算就是把这个关系数据作用到源数据上，源数据去做相应偏移，也就是可以在 Q 的作用下对源数据做相应推测。

感想

为什么这样一个算法架构，能衍生出智能，而且这个架构能扩展到多模态，语音、图像、视频基于它都有非常好的效果？我个人理解，最核心有两个点：

1. 上下文信息充足
2. 并行计算能力强

其他算法架构如果能充分融入上下文信息，规模大了也能有智能，只是 Transformer 可并行运算的特性，让目前的计算机算力可以触摸到涌现的那个点。

LUI 交互

LUI (Language User Interface，自然语言 or 输入框为主的交互) 有几大缺点：

1. 效率低（打字）or 隐私性差（语音）。
2. 说话是填空题（要动脑），GUI 是选择题（可无脑选）。
3. 难以精确表达。

这三点都是成本，如果一些场景想尝试 LUI 代替部分 GUI，需要时刻想好，如果用户得到的体验大于这几点成本，那就是合适的场景，否则不要勉强。

用 LUI 操作使用工具，模型能力（识别/执行能力）得在这个垂直领域靠近 AGI（代指跟人的识别和执行能力一致），或者能在这领域内限定在尽量小的范围内靠近 AGI，否则交互过程中模型不理解/无法执行带来的挫败，加上第一二点的成本，用户得到的体验大概率是负的。

微软copilot 尝试了GUI 为主，LUI为辅的方式。剪映的对话式剪辑尝试了以 LUI 为中心，GUI 为辅或者没有 GUI 的方式。目前看起来都没达到预期。原因自然是模型能力还达不到，识别和执行能力差。

视频剪辑/PPT制作 领域都太大，在这个大垂直领域模型要做到 AGI 的程度还太早，也是高估了短期模型能力的进步速度，需要把领域范围限定得更小，在这范围内用户的输入都能很好理解和执行，才可能跑通。

假如模型真达到 AGI 的程度，跟人的能力一样，是否视频剪辑用 LUI 是最好的方式？想象中不一定，工具能力不会是无限的，总有个范围，这个范围 GUI 能清楚地告诉你，LUI 很难，到时可能会有其他演化的交互配合 LUI。

新计算机

最近学习 transformer，看那些向量/矩阵的乘法，有种在学数字电路原理的感觉，要作类比的话，模型就是新的计算机，transformer 像芯片，SFT 像汇编，prompt 像 c 语言，往上 langchain/coze 是高级语言的尝试。原计算机是确定性计算，模型是概率性的模拟人脑的计算机。

但模型并没有遵循摩尔定律，18 个月性能翻一翻，GPU 运算能力确实每年性能都在暴涨，但模型的性能不是计算速度，而是理解能力。GPT-3.5 出来已经 18 个月了，GPT-4 已经 15 个月，模型能力的进步很有限，在这过程最大的变化只是开源模型逐渐追上，以及基于模型上层搭建的应用和生态上，基础模型能力没有大的突破。

我们预期模型性能能持续增强，基础是 Scaling Law，Llama3 训练中的最大参数量模型是4000亿，传闻 GPT4 参数量是1万亿，而人类大脑神经元突触连接有1000万亿（来源Wikipedia，也有说100万亿的），神经网络本身就是模仿大脑的构造，如果做类比有 100-1000 倍的差距，有很大的空间。Scaling Law 目前看还没收敛，能继续往这条路走，只是技术上的承接还没看到规律，无法形成新的摩尔定律，所以大家很期待 GPT-5，它能一定程度上让人判断模型的摩尔定律大概是什么节奏和速度。

图生成和视频生成领域，反而在过去18个月里有非常明显的提升，因为相对 LLM 它还在早期，而图像和视频的特性导致它早期也能有很好的应用。若 LLM 不顺利，图片视频能持续保持这提升速度，更有可能成为这几年的重点。

能，但还比较勉强。

在客户端上跑大模型，一定是未来的趋势。

1. 上个时代 AI 的核心应用是推荐系统，推荐是依赖海量数据的，海量数据只有服务端上存在，在推荐这主场景下客户端 AI 上能做的事很少，发展得比较吃力。
2. 生成式 AI 时代，最大的应用就是模型本身，只有训练时依赖海量数据，使用时并不依赖数据，那理论上只要客户端硬件资源足够，在客户端使用，跟在服务端使用，场景和效果是一致的。
3. 生成式 AI 在端上跑模型，最大的优势是成本。成本是当前生成式 AI 应用除了效果以外第二大关键因素，在用户客户端上跑模型，对服务提供方来说就是 0 成本，0 成本使更多场景大规模免费应用成为可能。其他的优势还包括 隐私保护、实时性、离线可用。

硬件条件

那当前手机设备硬件条件如何？我们可以通过一些指标对手机和服务端的算力差距有个大概认识。

显存：一个模型能不能跑，取决于显存够不够，显存不够模型无法加载。

1. 服务端一般用独立显卡，有独立显存。
2. 手机通常使用系统级芯片 Soc（System on a Chip），无独立显卡，SoC 中包含了 CPU、GPU、基带等多个组件，使用统一内存架构允许 CPU 和 GPU 共享同一块内存，所以手机 GPU 显存跟手机内存是一个东西。

性能：而模型跑得快不快，取决于芯片性能怎样。

1. 芯片性能取决于很多因素，例如芯片架构、显存带宽，而算力是其中一个，通常用TOPS（万亿次每秒 Tera Operations Per Second）指标来衡量算力。TOPS 默认是针对 INT8 整型数的处理次数，另一个指标 TFLOPS 是针对 Float32 浮点数的处理次数。
2. 在通用 GPU 以外，现代芯片会搭载专门处理 AI 运算的硬件加速器，NVIDIA 是 Tensor Core，手机 SoC 芯片是 NPU （Neural Processing Unit 神经网络处理单元），以下是 Tensor Core 和 NPU 的运算性能指标。
3. 不同芯片性能，特别是涉及不同芯片架构设计的，应该以实测数据作为对比，但当前缺乏这类数据，先用 TOPS 指标看个大概。

我们看看当前常用的英伟达各种显卡芯片，以及移动端设备芯片这几个指标的情况：

手机内存显存与系统共用，正常能提供给 APP 使用的内存只有1/2~2/3，所以可以认为对 APP 来说，手机设备的可用内存需要减半，否则有内存不足 APP 被系统 kill 的风险，像 iPhone 15 Pro 预计是4G，小米14等高端机是8G。

生图模型要求

那当前主流的生图模型，对硬件的要求是怎样？

显存

Stable Diffusion XL base 参数量 3.5B（35 亿），精度 Float16（16位bits，2个字节），换算下来参数总大小 6.5G，实际文件大小6.94G，在模型推理过程中，参数得加载到显存中，也就是显存至少6.9G，同时在模型推理过程过程中，也有一些中间值需要保留在显存中，所以正常需要8G – 12G显存支持。

实测在 Macbook 跑起来，占用了10.3G。极端情况下，通过显存调度之类的技术在 4G 显存也能勉强跑起来，但会性能较差或不稳定。

这个显存要求，在 iPhone 15 Pro 基本是不满足的，Android 高端机整体内存普遍较大，勉强可以支持。

性能

我在 A10 卡和 M1 MacBook Pro 上分别实测了下，SDXL base 模型生成 1024×1024 的图，A10大概6.4秒，M1 大概 95 秒。如果只看 TOPS 指标，A10 220TOPS 是 M1 11TOPS 的20倍，实测跑下来 95秒/6.4秒 = 14.8倍，也就是 M1 与 A10 的实际差距没那么大。

真实性能受各种因素影响，每个芯片有各自的优化方案，单用 TOPS 指标难以衡量，但可以看个大概。如果只看 TOPS 倍率，内存完全足够的情况下，搭载骁龙 8 Gen3 的小米 14 生成同样的图预计需要 17.6s，官方宣传是15s左右。

量化

原 SDXL 模型硬件要求高，但如果可以牺牲部分效果，是有办法对原模型做压缩，让它可以跑在低内存手机的。

模型为了成本、速度考虑，一般会进行不同程度的量化。量化就是降低模型参数的精度，神经网络模型中的参数通常使用32位浮点数 Float32 表示，但 Float32(4个字节) 存储大计算量也大，进一步可以压缩映射到更低的数值表示，包括 Float16、Int8、Int4 甚至 Int2 都有应用，只是会带来不同程度的效果损失。

模型量化后，参数需要的存储空间降低，所需要的显存跟着降低，而因为数据量小了，计算量也相应减小，模型推理速度也会加快。

Draw things 这个应用，将 SDXL base 模型量化到 Int8 的精度，模型大小 2G，可以跑在 4G 内存的 iPhone 上（APP 最多只能使用 2G 内存，为此作者做了系列优化）。实测 SDXL base Int8 模型 在 iPhone 13 Pro Max（A15，6G）上，生成 1024*768 的图需要 180s，跟它硬件 TOPS 算力差得有点多，可以认为是推理架构上为了节省内存做的妥协。

LLM 大模型要求

那在 LLM 大模型上，情况怎样？

我们拿阿里通义千问qwen的模型大概看下它 7B 和 72B 在不同量化下的大小。qwen 最大模型是 72B，而 llama3 最大是 400B(还在训练中)，可以预估 400B 模型会是接近1T的体量。

如果拿400B模型对标GPT4，72B 模型对标 GPT3.5+，可以看到目前可用的 LLM 模型推理成本和硬件要求是非常高的，比图生成高几十倍。

qwen 最小的 1.8B 模型，生成 2048 个 token 最低需要 2.9G 显存，当前高端机是可以跑起来的。但 1.8B 效果差很多，预计只能预训练做特定任务。7B 可用性高一些，可以看到 7B 模型就没多少手机能支持了，骁龙8 Gen3 宣传号称 7B 模型推理每秒执行 20 个token，未搜到相关实测。

Google 用于端侧的 Gemini Nano 有 1.8B、3.25B 两种参数量。苹果之前放出来的 OpenELM 模型有 0.27B ~ 3B 的参数量，最新 iOS18 的 AI 模型估计用的就是 OpenELM，限制了只有最新 iPhone 15 Pro 能跑。

iOS Android 都在往系统级集成端侧 LLM 大模型这个方向做，系统集成有更多的硬件资源调度权限，在当前资源条件下容易先做起来，APP 能用到的资源有限，目前很难跑起来。

所以手机跑 LLM 大模型，用最小的模型，在最高端的手机上理论可行，实际应用还要再等等。

端模型问题

除了硬件理论情况，端模型也有一些问题待解决：

1. 对服务提供方，有技术保密问题：在端上部署模型，模型、prompt、workflow 都是存储在本地，虽然可以做各种加密，但总能破解，如果服务方视这些为核心竞争力，那就难以以这种方案部署，更有可能的是端云协同的架构，部分运算放客户端，云端处理核心和保密部分。
2. 对于手机用户：手机耗电、发热、耗时问题：大量运算跑满 GPU 必然导致手机发热严重耗电高，在持续使用的场景下体验会比云端差，手机芯片跑起来速度也会不如云端快，手机端系统需要做好资源控制和平衡。
3. 生态问题：英伟达的CUDA、PyTorch 生态，相关工具链/社区，在端上都是需要重新建立的，当然只要有场景有诉求，这些可以补上，但需要时间。
4. 场景和价格问题：能运行大模型的手机，在未来几年价格还是高的，目前还没有比较好的理由让用户接受这个溢价，对用户来说，像生图、修图、LLM当前服务端能提供最好的，在端侧跑模型体验没提升，就没必要溢价买个高端机，高端机平民化速度就会慢。在没有 killer APP 的情况下， 需要靠手机厂商和系统强推了，例如 iOS 18 新Siri 只在最高端机可使用。

结论

图生成硬件要求不算高，高端机已经摸到实际应用的门槛，预计再过一两年，硬件进一步提升，不追求效果极致的图生成应用场景，大部分会部署在客户端上。

LLM 硬件要求高，iOS/Android 系统级应用有条件接入，APP 基本还用不了。等系统应用被大众认知和接受，硬件普遍升级，才轮到 APP 端发挥。

当前过渡阶段，端云协同的方案会比较多，预计也会存在很长一段时间。例如图生成，可以将部分运算（比如 VAE 编解码）放到端上，主生成流程放云端。iOS 18 Siri 也会判断如果用户输入的是简单指令，就不请求服务端，直接端模型生成。

接上篇，继续优化我们的黏土风 workflow。

引导图控制

来看看上篇里的最后一个case：

黏土风格效果还可以，但人物动作总会跟原图不一致，一会双手放地板，一会侧身。图生图一般希望整体轮廓、人物姿态与原图一致，有没有办法控制？

我们可以给它加上 ControlNet 节点，用 canny 边缘检测，试试控制画面主体的轮廓结构：

这下就比较准确地还原了原图的姿势了。

ControlNet 介绍

ControlNet 是一种神经网络架构，能做到通过添加额外的引导图片输入（如边缘图、姿态图等）来控制 SD 模型的扩散生成方向，实现对图像生成过程的精确引导。

通过这套架构，可以训练出每种控制方式对应的模型，生图过程中应用这个模型，输入对应的引导图，就能生成对应的图。

以下是 ControlNet 作者训练好的几种模型，以及用这些引导图生成的图片效果：sketch草稿、map法线贴图、depth深度图、canny边缘、line线、edge边缘、场景、Pose人物姿势

看下 ComfyUI ControlNet 相关的这几个节点：

1. 每个 ControlNet 模型的输入，都是预处理好的一张引导图，一般用简单的算法就能处理出来，这里用的是 ControlNet canny 边缘控制的一个模型，对应一个 canny 算法节点，一个古老的算法，python 的 OpenCV 库就有。
2. 接着加载 canny 对应的 ControlNet 模型。
3. 这张边缘图片输入到 ControlNet 模型，跟文本一起，作为模型降噪生成过程中的引导，指引降噪方向，生成符合文本描述、符合图片边缘形状的图。

这里的 canny 可以替换成 sketch、depth、pose 等算法，搭配上对应的 ControlNet 模型，就能实现不同的控制方式。

ControlNet 原理

扩散生图模型出现后，就有很多人探索怎样更好控制它的生成，显然如果只能用文字生图，可控性太差，最直观的还是能通过草图指引控制它画什么。

怎么解这个问题？对模型简单做一个端到端微调是否可行？例如想让模型按 canny 检测出来的边缘去生成图片，那造一堆 原图 – canny图 的配对作为训练集，微调让模型学习到边缘图和最终生图的关系，是否就可以？大思路是这样，但需要解决微调带来的过拟合、破坏原模型能力的问题，需要设计一个网络结构，能很好认得 canny 引导图特征、跟扩散模型很好结合、效果稳定。

有很多人做过不同的研究，提出过多种方法，ControlNet 的方法相对前人有很大优势，能稳定用在各种场景上，效果最佳，应用广泛。

网络架构

来看看 ControlNet 的这张架构图，我把相应的输入输出示意图加上：

理解这个网络结构前，可以看回这篇文章理解下 SD UNet 网络。上采样 = encoder，下采样 = decoder，为了方便和与上图对应，下面就只提 encoder 和 decoder。

这个图左边是 SD 原 UNet 网络，右边是 ControlNet 新加的网络。首先是把 SD 原网络的参数冻结，不参与训练，这跟前面介绍的 LoRA 套路是一样的，训练不影响原网络，只调整新网络，有诸多好处。

接着它把 SD UNet 网络里的 encoder 和 middle 部分复制出来，再用零卷积（zero convolution）连接到原 SD 网络对应的 decoder 层。几个要点：

1. 与 decoder 的连接：
   1. 整个 ControlNet 网络的目的并不是按 UNet 网络流程有一个输入和输出，ControlNet 网络是只有输入没有输出的，它的目的是在 encoder 识别处理引导图（外加与降噪图/文字Prompt/步数的关系），再把这些信息跳跃连接回原 SD 网络的 decoder，所以 ControlNet 网络本身是不需要 decoder 的，图上的零卷积只是把 encoder 层跳跃连接回 decoder 对应的层。
   2. 为什么这样做？SD UNet 网络里 encoder 各层保留了图片的细节信息，decoder 只有宏观信息，所以把 encoder 各层都跳跃连接回 decoder 对应的层，这样 decoder 拥有宏观和微观细节所有信息，进行一步步生图。那 ControlNet 这里做的，就是为 decoder 增加信息，不止是原降噪图的细节信息，还加上引导图信息，指引降噪生成方向。
2. 为什么用 1×1 卷积作为连接，而不是做一个简单的叠加？
   1. 如果叠加，会破坏原生图能力。这个 1×1 的卷积，最开始训练前初始化值为0，encoder 里的参数经过这个零卷积相乘，最终输出是0，叠加作用在 SD 网络里的值也是0，也就是训练一开始这个网络对 SD 生图完全没有影响，保留完整的生图能力。随着训练进行，这里的 1×1 不再是零卷积，会逐渐变成一个个权重值，那参数经过这个卷积叠加到 SD 网络，影响就不再是0，可以指引降噪方向。我理解为整个训练过程中生图能力都没被破坏，引导图 ControlNet 对网络带来的影响是一点一点叠加上去的。
   2. 另一点，自己猜的，与 1×1 卷积 相乘的主要作用是降维，引导图信息有限，低通道低维度的数据已经能比较好地表示，不需要跟降噪生图那么大的数据量，对原网络的影响也小些？
3. 其他几个小点：
   1. 它这里原样地复制了 SD UNet 网络一半的参数，并没有像 LoRA 那样对数据进行压缩，也可以理解为因为这样所以对网络的控制可以更细致。所以它的模型大小是比LoRA大很多，但比原 SD 模型小的。
   2. 一开始输入的 Condition 是像边缘图这样的图片，图上没画出来的是这个图片还会经过一个四层卷积层，把这张图片转化为隐空间的表示。
   3. SD 的输入，包括噪声图、文字 prompt 和 timestep 步数，都会进入到 ControlNet 网络参与训练，因为 ControlNet 是从 UNet 原网络复制出来的，有完整的处理这些输入的能力。

训练过程

沿着上面这张图再复述一下训练过程：

1. 准备好训练数据：原图 – canny引导图 – 文本描述(可选)
2. 前向传播：
   1. ControlNet：在 SD 每一步降噪过程中，噪声图与引导图 c 叠加，与文本prompt、步数 一起进入 ControlNet 网络，这里的输入跟 SD 原网络是一样的，每层的输出也一样，每一层推理出的噪声图数据表示，都通过 1×1 卷积连接回到 SD 网络。
   2. Stable Diffusion：噪声图、文本 prompt、步数，一起输入网络推理出下一步噪声图，跟原 SD 训练和推理流程一致，只是这里的 decoder 网络已经叠加了 ControlNet 的网络。
   3. SD 这里的文本输入也可以为空，训练网络只拟合边缘图信息，实际上 ControlNet 作者训练的那几个模型，训练过程中有一半数据集是无文本输入。
3. 损失函数计算：我们知道每一步期望这个网络输出的图是什么（参考SD扩散训练过程），评估预测和输出的差异。
4. 反向传播：把差异（损失函数梯度）回传网络，更新网络参数值。SD 网络是锁住的，不回传，参数不变。只在 ControlNet 网络做回传和参数值更新，这里的更新包括每个 encoder 块的参数值，以及1×1卷积的权重值。

训练完后，ControlNet 部分就变成了一个“认得” canny 边缘图片条件的网络，给这个网络输入其他的 Canny 图，经过 ControlNet 作用叠加在 SD 模型上，引导 SD 降噪方向。

论文上还提到一个现象：突然收敛，模型没有逐渐学习识别输入的边缘图片条件，而是在训练到6000多步的时候，突然认得边缘图开始遵循这个输入条件生图。为什么是会突然收敛，也没说为什么，特定架构下的现象，有些玄学。

这是非常通用的架构，只要是跟原图关联的引导图，像上面示例的 sketch、depth、pose 等都可以用同样的方法训练出对应的 ControllNet 模型。

若要自己训练一个 ControlNet 模型，作者有篇详细的教程和探讨：《Train a ControlNet to Control SD》

消融实验

消融实验（Ablation Study）是机器学习领域常用概念，指通过修改或移除模块，来测量这些模块/结构设计对结果的影响，也就是 ABTest。

作者这篇文章分享了做的两个消融实验：《Why ControlNets use deep encoder》。尝试了 ControlNet-Lite 和 ControlNet-MLP 这两个更简单的网络对比效果。这俩不是从原 UNet 网络复制出来，而是自定一个网络，再把这网络作用回原 UNet 网络，ControlNet-Lite是简单的卷积网络，ControlNet-MLP是用像素级多层感知机（Multilayer Perceptron）构造这个网络。

文中可以看出，在 prompt 充足的情况下，这俩简单的架构都能得到很好效果，甚至更简单的架构也能起作用，要指引图片按轮廓生成，并没有很难，难点在与生图模型的结合。在 prompt 不清晰、或没有 prompt 的情况下，这俩架构表现就差多了，生成的图无意义。

之前也有不少其他人的尝试各种方法，比如这篇论文《Sketch-Guided Text-to-Image Diffusion Models》，不足的地方也是与 SD 图生成的语义没法很好结合，只认识边不能让物体与边很好结合。作者认为 ControlNet 现在的架构能做到跟原网络很好结合，两个关键点：

1. 用零卷积连接，确保了训练刚开始时对原网络无影响。上面也有说到，沿用 SD 原网络对物体的理解能力，再逐步调节，每一步训练都完整应用 SD 原本的高质量生图能力。否则按随机初始化叠加，一开始几个训练步骤下来，整个网络识别物体的能力很快被破坏。
2. ControlNet 的网络也需要接收 Prompt 作为输入，这样 ControlNet 编码器才能认识 Prompt 对象，不会与用户输入脱节，比如训练过程中 ControlNet 网络认识了房子的轮廓，如果没有 Prompt 参与训练，就算用户输入蛋糕，网络也会引导向生成房子，而不是蛋糕模样的房子。

ControlNet 先学到这里，我们继续来优化黏土风 workflow。

人脸保持

我们拿目前加了 ControlNet 的 workflow 试试人物的效果：

效果还行，但人脸跟原图有些对不上，如果我们想让人脸更接近原图，做一个人物美化的黏土风，有没有什么办法？

可以试试给 workflow 加上 IPAdapter 节点，IPAdapter 有强大的风格迁移、人脸保持的能力，先看看效果：

用的是针对人脸训练的 ipadapter-face 模型，人脸美化多了，相比之前相似度高一些，算是人脸美化风格的黏土风，但也不怎么像。

提高 IPAdapter 的权重，能得到越来越像的脸，但跟黏土风融合得不是很好，权重越大黏土风格的感觉越弱：

IPAdapter 还有一个专门为人脸保持做的版本 IPAdapter-FaceID，与黏土风格的融合效果好一些，但人脸特征保持程度也一般：

在进一步优化前，先来认识一下IPAdapter。

IPAdapter 介绍

IPAdapter 是垫图神器，提供风格迁移能力，输入一张参考图，模型会按这张参考图的风格去生成图片。IPAdapter 目前有两类模型：

1. IPAdapter
   1. 提供整图风格迁移能力，与直接图生图有本质区别，原理上图生图是在原图加噪点基础上做演化生成，IPAdapter 是让模型认识图片风格要素，生成跟原图宏观风格一致的图片。
   2. 结合 ControlNet 等插件，在一些场景下能得到很惊艳的效果：
   3. IPAdapter 针对 SD1.5 和 SDXL 训了好几个模型，也针对人脸迁移做了优化， **ip-adapter-plus-face** 就是其中之一，使用裁剪的人脸图像作为训练集，对人脸的迁移效果好一些。上面第一步用的就是这个模型。
2. IPAdapter-FaceID
   1. 在 IPAdapter 的架构下，使用人脸特征代替用 CLIP 编码的图片特征，模型对人脸识别能力更强。这个版本实验中，不允许商用。
   2. 跟着上面 IPAdapter-FaceID 的 workflow 说明一下各模块：
      1. 用 InsightFace 提取人脸特征
      2. 人脸特征不像图像特征那么容易学习，因此这个模型配套训练了一个 LoRA 提高学习效果。
      3. 仅使用人脸特征，模型生成结果不稳定，受 Prompt 的影响很大，因此 IPAdapter-FaceID-Plus 版本尝试将人脸特征和 CLIP 编码的图像特征结合起来，所以这里还是需要一个 CLIP 模块。

IPAdapter 原理

IPAdapter 由两部分组成：提取图像特征的编码器，以及把图像特征接入网络而新增的解耦交叉注意力模块。

1. 图片编码器：对参考图编码，提取图像特征
   1. IPAdapter 对参考图的编码，使用了 CLIP 模型，但不是 SD 内置的 CLIP，CLIP 是一个模型家族，作者应该是挑了对图像特征识别编码效果更好的 CLIP 模型。
   2. 后续新出的 IPAdapter-FaceID，是使用了 人脸特征 FaceID 代替图像特征，具体来说是用 InsightFace 库提取人脸特征向量进入网络，更好保留参考图里的人脸身份特征。
   3. 编码后的图像，这里加一个可训练小型投影网络，通过 Linear layer 和 Layer Normalization 投影到长度4的特征序列中，进入网络。
2. 解耦交叉注意力（decoupled cross-attention）：
   1. 回顾 SD UNet 网络的构成，整个网络有16个 Transformer 模块，每个 Transformer 模块里有一个自注意力层和一个交叉注意力层。
   2. 将编码后的图像特征加入到 SD UNet 网络，常规做法是图片特征与文字特征相加，再一起进入 Transformer 模块里训练。但 IPAdapter 用了另一种方式，它向这些 Transformer 模块另外增加一个交叉注意力层，用以处理图像特征，然后把文字和图像两个交叉注意力层相加，称为解耦交叉注意力。
   3. 为什么这样做？不跟文本 prompt 混合，这样图片的特征可以在网络中完整保存下来，跟文字一样具有独立引导能力。
   4. 如果不用解耦交叉注意力机制会怎样？作者做了消融实验，用一般的方法 — 图片特征与文本特征直接连接，一起嵌入到 UNet 的交叉注意力层中，结果如下图的 Simple adapter 所示，能根据图像风格生图，但质量低很多。

ComfyUI 上 IPAdapter 的两个节点，一个是 CLIP 图片编码器，一个是包含架构图里红色区域可训练参数的 IPAdapter 模型。

训练时跟 ControlNet / LoRA 等一样，也是冻结原 SD 网络，只训练新加的 IPAdapter Transformer 网络，大概2200万个参数，IPAdapter SD 1.5 的模型大小基本 44M，对应着 22M 个参数。但 IPAdapter SDXL 的模型大了20倍，原因不明（原 XL 参数量只比 1.5 大 7 倍）。

InstantID

IPAdapter 在很多场景生图场景下做风格迁移和人脸保持都是神器，但在我们黏土风 workflow 下表现一般，我们试试另一个专门针对人脸迁移的技术：InstantID。

人脸特征的保持以及黏土风格融合的效果比 IPAdapter 好很多。试过其他图，人脸轮廓特征也很明显能更好保留下来：

InstantID 原理

InstantID的 原理很简单，可以近似理解为 InstantID = IPAdapter-FaceID + 人脸ControlNet。

看这两张图，ComfyUI 里使用 InstantID 的几个模块，跟架构图对应，由三部分组成：

1. 用 InsightFace 库提取人脸特征，用一个 projection layer 投影映射成跟文本的特征空间一致的向量表示。
2. 添加解耦交叉注意力层，与 IPAdapter 一致。
3. 加一个面部识别的 ControlNet，但有些小改动：
   1. 只使用五个面部关键点（两个用于眼睛，一个用于鼻子，两个用于嘴巴）作为条件输入，而不是细粒度的 OpenPose 面部关键点。防止强调多余的面部特性，比如嘴巴闭合这种是可以由prompt控制，而不需要保持的。
   2. 原 ControlNet 文本 Prompt 是加入网络训练的，这里没有加入，只用人脸信息作为ControlNet 中交叉注意力层的条件，主要是希望这个网络只控制人脸，不受文本对人脸描述的影响。

前两步基本就是 IPAdapter-FaceID，第三步就是一个特制的 ControlNet。

从前面效果看起来，第三步这个人脸特征 ControlNet 对人脸特征保持作用很大，用已有的技术方法做组合微调，已经能很好解决一些问题。

最后

我们使用 ControlNet、IPAdapter、InstantID 对黏土风格 workflow 做优化，希望能达到跟原图一致性较高、人脸迁移较好的效果，其中 InstantID 组合了前面两个技术，有很强的人脸迁移能力，但这也带来副作用。在原网络上叠加各种修改，对原生图模型都会造成不同程度的破坏，比如加了 InstantID 后，原文字 Prompt 和 Canny ControlNet 的控制就没那么精准了，上面几个例子可以看出，原来的 ControlNet Canny 边缘图已经很难起作用了，这很好理解，在原网络上叠加的处理，各部分是相对独立的，很难有非常好的融合，InstantID 把方向强力往人脸保持上引，其他输入条件就会被弱化。

这种 Adapter 类，需要在效果和原模型侵入程度间保持平衡，不同场景选择不同的方案，在某些场景要更好的效果，还是得自行微调模型，目前还没看到很完美的方案。

到这里已经可以有一个还算可以、对人脸风格化友好的黏土风格图生成 workflow 了。目前黏土风 workflow 要再进一步优化到生产环境，就是继续调整 Prompt、调整各组件参数，或者训练专有的 LoRA 模型了。

目前对应 workflow 见下图，可在 ComfyUI 上导入：

参考资料

ControlNet 论文：https://arxiv.org/abs/2302.05543

ControlNet如何为扩散模型添加额外模态的引导信息：https://zhuanlan.zhihu.com/p/605761756

精确控制 AI 图像生成的破冰方案，ControlNet 和 T2I-Adapter：https://zhuanlan.zhihu.com/p/608609941

浅谈扩散模型的有分类器引导和无分类器引导：https://zhuanlan.zhihu.com/p/582880086

使用 diffusers 训练你自己的 ControlNet：https://huggingface.co/blog/zh/train-your-controlnet

深入浅出完整解析ControlNet核心基础知识：https://zhuanlan.zhihu.com/p/660924126

快速理解AIGC图像控制利器ControlNet和Lora的架构原理：https://blog.csdn.net/colorant/article/details/136732221

InstantID技术小结：http://www.myhz0606.com/article/instantID

IP-Adapter 原理和实践：https://zhuanlan.zhihu.com/p/683504661

IPAdapter使用：https://www.runcomfy.com/zh-CN/tutorials/comfyui-ipadapter-plus-deep-dive-tutorial

新一代“垫图”神器，IP-Adapter的完整应用解读：https://developer.jdcloud.com/article/3483

如何在 ComfyUI 中使用 IPAdapter Plus 进行风格迁移：https://www.comflowy.com/zh-CN/blog/IPAdapter-Plus

IP‐Adapter‐Face：https://github.com/tencent-ailab/IP-Adapter/wiki/IP‐Adapter‐Face

在前面的学习中，我们把 SD UNet 网络当成黑盒，不太影响对图片生成大致原理的理解，但在继续学 SD 的过程中，发现 ControlNet、T2I-Adapter、IPAdapter 等这些技术，都是在原 SD 网络模型上以各种方式对网络做修改叠加，要理解这些技术，还是得先了解下 SD UNet 网络结构的一些细节，不然看得很费劲。

SD 模型构成

从之前的学习我们知道，Stable Diffusion 模型里包含了三个组件：CLIP、VAE、UNet，这三个组件的参数和大小分布(来源)：

整个生图的核心网络就是 UNet。UNet 最初是用于医学图像分割任务而提出来的，但它的特性展现了在图像其他领域的应用潜力，后续经过扩散模型的改进，很好应用在了图像生成上，所以 Stable Diffusion 的 UNet 实际上在原 UNet 网络架构上做了一些改造。

基础 UNet 网络

我们先来看看原 UNet 网络架构：

1. 左边输入图片，经过整个网络处理，右边输出同尺寸图片。（原 UNet 网络用于医学图像识别分割，所以图上右边标的输出是一张同尺寸分割图。SD 这里的输出是降噪图）
2. 左边下采样（也可以称为编码器），右边上采样（也可以称为解码器），一张图片经过一层层下采样计算，尺寸逐渐减小（图中的网络是减小到32×32），再经过右边层层上采样，恢复到原尺寸。那这里下采样和上采样的作用是什么？
3. 下采样，是使用某种计算方式让更小的数据表示整张图片，这更小的数据代表了对这张图片高纬度的描述，而不是像素级细致的描述。
   1. 越小的数据对图片的表示和描述越宏观，有利于捕捉图片的语义特征。
   2. 例如一张猫在屋子前玩耍的地图，原图能看清所有细节，但因为细节太多，模型想要知道图里有猫和屋子，得把每个像素组合运算才行，但下采样到最小，最宏观的猫和屋子就容易识别。
4. 上采样，是让图片的宏观小尺寸表示恢复成原图片尺寸。
   1. 比如对于图片分割（把图片上的物体分割出来），我们在下采样后的小数据量的高维表示里识别了图片的主体、边缘，最后还是要转回在原尺寸图片上表示，不然识别了也没用。
   2. 那不断下采样过程中肯定把图片细节都丢失了，再上采样，怎么可能还原图片细节？那就要说到跳跃连接（skip connection）了。
5. 跳跃连接，也就是并不是顺着网络的方向连接，而是跳过原网络方向，跳着连接传输信息。说得有点拗口，看图很容易理解，就是图上中间的几条灰色箭头。
   1. 原网络连接方向是图片输入→下采样各节点→上采样各节点→输出图片这个链路，就是图中U字型的路径。
   2. 在这个路径之外，左边的下采样的每一层，都额外连接到右边上采样对应的层上面，将两个网络进行拼接。
   3. 上采样每一层，都在拼接了左边下采样对应层的数据后，再一起作为下一层上采样的输入。
   4. 为什么这样做，很容易理解，左边的每一层网络都保留了图片不同程度的细节，右边的每一层因为是上采样过来的，只有宏观信息，没有图片细节，那把左边图片细节信息拼接过去，右边这个网络宏观特征和微观细节都具备了，每一层都有不同程度的对图片的宏观语义理解和微观细节，就能做各种事情了，包括图片分割、语义生成图片。

UNet 网络大致思路是这样，这里面具体的卷积运算和公式，不看应该不影响对整体思路和作用的理解。

Stable Diffusion UNet 结构

最初的 DDPM（去噪扩散概率模型），和后来改良的 LDM（潜在扩散模型），对 UNet 网络逐步做了一些改造，以适合扩散模型图生成的过程，SD 是基于 LDM 实现的。

最后 SD 里的 UNet，整体结构流程跟上述一致，改造大部分是在上采样和下采样的每一层的实现里，最大的改造是引入了 ResnetBlock（残差模块）和 Transformer 模块。ResnetBlock 提升网络表达能力（原 UNet 是简单卷积模块），而 Transformer 模块的交叉注意力机制，将文本提示（prompt）的嵌入与图像特征进行融合，实现基于文本条件的图像生成。

SD UNet 每个模块的组成如图（图片来源）：

左边下采样每层由2个残差模块和2个Transformer模块连接组成，右边上采样是各3个，中间层是2个残差模块和1个Transformer模块。（高维的d4和u1没有接入Transformer模块，原因不明，可能是试过加入后效果不佳，在高维这里加入 Prompt 交叉注意机制，文字权重太大？）

细分模块结构

里面每一块具体的结构这篇文章画得很详细，摘录学习一下。我们拿其中一个下采样模块看看：

两个残差模块，两个Transformer模块。这图表示了 SD 生图的三个输入：input（噪声图）、prompt_embdding（文字 Prompt）、time_embdding（步数）在这几个模块的流转和处理。这里每一个小模块处理完后，输出的可以近似认为都是一个预测的噪声图的数据表示。

残差模块的输入输出 噪声图+步数 → 预测噪声图，Transformer 模块的输入输出是 噪声图+ Prompt → 预测噪声图。

再细看一下 Transformer 模块，Transformer 模块由下图所示好几个部分组成，最主要的是 自注意力模块（SelfAttention）和交叉注意力模块（CrossAttention）：

展开看看这两个模块：

自注意力模块，Transformer 结构里的 QKV 输入都是图片特征（上一层的处理结果，就是降噪图的特征），这样做可以让模型获得包含整个输入图像的感受野，捕捉图片特征中不同位置之间的关系， 全局感受力是 Transformer 架构的特点。

交叉注意力模块，它的作用是融合不同模态的输入，在这里就是融合噪声图和文本特征，Q的输入是图片特征，KV的输入是文字 prompt_embedding，让图片特征可以关注到文字输入，根据注意力权重调整图片的生成方向。文字 prompt 在整个Transformer模块中只作用在交叉注意力这部分里。

Transformer 的机制原理、QKV的含义，是另一个比较大的话题，可以先看看网上其他相关讲解，比如这篇，后续再细拆深入。

关键几个模块的组成了解了，再回到整个UNet的构成：

现在通过这些结构图，可以大致看到 UNet 网络里的整体处理流程，以及关键模块的作用，经过这些模块的逐个叠加，组合成一个个采样模块，再组合成 UNet 网络架构，完成整个生图运算。

这里面还有很多需要深入学习的点，当前先了解到这个维度，已经可以帮助大致理解后续 ControlNet 等网络的机制原理。

参考资料

UNet 论文：https://arxiv.org/abs/1505.04597

原版实现及 Diffusers 实现源码解读：https://zhouyifan.net/2024/01/23/20230713-SD3/ （周弈帆的博客，看简介挺有意思的一人）

U-Net简明教程：http://www.bimant.com/blog/unet-crash-tutorial/

Stable Diffusion1.5网络结构-超详细原创：https://blog.csdn.net/xd_wjc/article/details/134441396

Stable-Diffusion模型结构详解：https://zhuanlan.zhihu.com/p/638867353

Unet网络详解：https://blog.csdn.net/qq_58529413/article/details/125704059

Stable Diffusion XL网络结构：https://blog.csdn.net/xd_wjc/article/details/134530784

从零开始学扩散模型：https://huggingface.co/datasets/HuggingFace-CN-community/Diffusion-book-cn

继续学习 Stable Diffusion，这次想以搭建一个实际可用的生图场景 — 黏土风格作为引导，弄清楚整个流程的同时，把过程中遇到的相关概念和原理也做了解，所以这篇是掺和了应用流程和原理的文章。

ComfyUI & 模型

使用 Stable Diffusion 去生成图，有非常多的插件/模型/配置相互搭配组合使用，一般用 WebUI 和 ComfyUI 这两个工具，更推荐 ComfyUI，自由串联一个个模块，流程更清楚，网上有很多在自己电脑部署使用 comfyUI 的保姆级教程，比如这个，这里就不多介绍了。

先看 ComfyUI 这个默认的最简单的 workflow：

这里面简单的几个元素概念和生图流程，上篇文章都有介绍过：最左边的 Load Checkpoint 是加载 SD 模型，接着用 CLIP 模型编码文本 → 生成隐空间原始噪声图 → 采样器根据文本和噪声图输入→在隐空间里迭代降噪生成隐空间图片→最终用VAE解码图片。

为什么叫模型 checkpoint ？模型在微调训练过程中，会在关键节点保存模型参数的状态，这个保存点被称为 checkpoint，SD 有大量基于基座模型微调训练的模型，包括官方出的，比如 SDv1.5 是从 v1.2 的基础上调整得到的，SDXL Turbo 也是基于 SDXL1.0 基础上训练的，这些模型都被称为 checkpoint，这些 checkpoint 包含了生成图所需要的全部核心组件，包括 VAE、CLIP、UNet 的模型数据，可以直接使用。

那模型文件的后缀为什么是 .safetensors ？早期的模型文件后缀是 .ckpt （checkpoint缩写），一个通过 Python 序列化后的数据，使用时需要对它反序列化，这个反序列化过程也就容易被注入恶意代码，所以后面提出了新型安全的格式 safetensors，只包含张量数据（模型上的参数数据），无需反序列化，安全且速度快，目前模型基本都以这种方式存储。

我们用这个默认 workflow，选个模型，用纯提示词 claymation style, a tower 试试生成黏土风图片：（图上使用了 dreamshaperXL 模型，是在SDXL 的基础上微调的最受欢迎的一个模型）

可以看到效果并不是很好，比较生硬。可能加多一些细节提示词、调节下相关参数会好一些，但在图片训练过程中，黏土风格相关的图片数量应该是不多的，训练图片对应的文本描述也比较散，如果固定要这种风格，生图的 prompt 要尽量贴近训练时这类图偏对应的文本，才有可能有好一点的效果，这很难控制，也不保证效果，很难达到我们想要的风格。

模型微调

如果我要一个能更好输出黏土风格的模型，那可以给这个模型做微调，给它输入更多黏土风格的图片训练，让它学会我们具体要的是什么，针对性输出。

微调 SD 模型，目前从成本大到小，目前用得最多的有三种方式：

1. Full Finetune：
   1. 最朴素的方式，使用图片+ 标注的数据集，进行迭代训练，对原模型所有参数进行调整，成本最高，但可以对整个模型做全面调优，大幅改变生成风格，上面的 dreamshaperXL 就是以这种方式。它训练数据量要求大、计算资源消耗高、最终模型就是包含所有模型参数的 checkpoint。
   2. 这种训练我理解适合大量的数据、对模型整体做调优较合适，如果只是想在特定领域，用少量数据，比如把某只猫，把某个人脸、某个物品训练进去让模型认识，那很可能出现过拟合问题（数据不够多样，污染了通用词，比如拿自家的猫训练，最终整个模型对 cat 这个输入只能生成自家的猫），或欠拟合问题（训练样本太少，没有影响到网络参数，训练无效）。
2. Dreambooth：
   1. 针对 Full Finetune 过拟合和欠拟合、数据量大的问题的一种解决方案，数据量要求小，个位数的图片可训练，能很好还原训练图片里的人物/物品，同时不会污染原模型，能正常用原模型的能力，只在有特殊 prompt 的情况下命中微调的效果。它跟 finetune 一样是修改整个模型的参数，所以产物跟原模型一样大，也是个完整的 checkpoint。具体原理可以看这些文章（1 2）的介绍。
3. LoRA：训练门槛极低，只需要个人PC的算力、个位数（三五张图片）也能训练出特定人物、风格的微调模型，也能达到很好的效果，生成的是外挂文件，体积小可插拔，是目前 SD 使用最广的微调模型，原理下面细讲。

像黏土风格这种诉求，仅是一种风格化的优化，是比较适合使用 LoRA 模型的，从 civitai （最大的SD 模型社区）上找了个黏土风的 LoRA 模型 CLAYMATE，在原 workflow 简单加上这个 LoRA模型，先看看应用的效果：

同样的提示词下，效果好了很多，是比较舒服的黏土的风格。

每个 LoRA 都有个触发词，上面用的这个模型触发词就是 claymation style，我理解相当于训练时大部分图片的 prompt 标签都加上了这个词，这样使用这个词时，模型能更好定位到训练到的数据。比如下面去掉这个claymation style ，即使用了 LoRA，也对应不上这个 LoRA 的风格。

这模型是怎么训练的？基本上流程是，选好图片→处理图片（裁剪+加提示词）→用工具 Kohya 训练→看结果调参重复，具体跟着网上教程走就行，各种参数细节参考这里，我还没真正执行过训练，先不多说。另外训练的整个代码生态都是围绕 NVIDIA 显卡建立的，Mac 没有 NVIDIA 显卡，没法训练。虽然理论上可行，但社区生态不友好，基本不可用，要训练只能搞台 PC 或用云服务器。

LoRA 原理

来具体看看 LoRA 的原理，全称 Low-Rank Adaptation，低秩适应。什么是低秩？为什么能做到微调成本低文件小效果也不差？

Full finetune

先看看正常的微调，也就是前面说的 Full finetune，下面这图很好理解，正常微调就是通过新增的训练集，重新调整这模型里面网络的参数，把这个参数更新到原有网络里，变成一个新的模型使用。

这里除了前面说的要求的训练数据量大、容易过拟合/欠拟合的问题外，还有个大的问题，就是计算量大、资源要求高。

大模型都是由多层神经网络叠加组成，Transformer 和 UNet 都是，使用这些模型时，是对这些模型正向推理，这个过程需要的资源不高，只需要把模型参数全部加载进内存，一层层正向计算就行。

但训练这些神经网络要求就比正向推理高很多，整个训练中，每一步训练的过程包括：

1. 前向传播：训练数据(样本)输入当前网络，生成预测结果（跟使用模型一致）
2. 损失函数计算：把预测结果跟样本对应的预期输出对比，评估差异
3. 反向传播：把这个差异（损失函数的梯度），反向从输出层到输入层传播，计算每一层每个参数对这个差异的贡献，记下相应数据。
4. 更新参数：对反向传播获得的数据，更新网络中每个参数值

这里内存中就需要同时存在好几个数据：1.原网络参数 2.前向传播过程中计算出来的数据，反向传播计算时需要用到 3.反向传播过程中每个参数的差异贡献(梯度值)，更新参数时要用到。

所以假如整个神经网络有 n 个参数，每一步训练就要在显存存储 3n 个数据，进行 3n 次计算（正向推理、反向传播计算，更新每个参数的值）。还有一些训练优化的方法，数据的存储和计算量会更高。Stable diffusion XL 的参数量是35亿，llama 3最高参数量达到4000亿，每一步的计算量感人。

参数冻结

再来看看 LoRA 怎么解这个问题。

首先，LoRA训练过程中，会把原网络参数冻结（下图的W），不会去修改原网络参数，只让原网络参与正向推理预测结果的过程，所有对参数的调节都独立出来在 △W 上，这个△W最终也不会更新在网络上，只会在使用这个模型时外挂式地加上它，跟原模型一起叠加共同进行推理。

到这里，其实它只是换种方式，专门把训练变化的部分抽出来，其他都没变，△W 跟 W 的参数个数一样，该存储和计算的量一样。

低秩分解

下一步才是主要的，接下来需要一点点基础线性代数矩阵的知识。

前面这个分离出来的部分△W，变成下图这样，不是用跟原网络一样的参数量去表示，而是通过一个数学的方法 低秩分解 去表示，把原模型参数 W 和 △W 看成一个矩阵数据，那 △W 这个矩阵可以用两个小矩阵Wa 和 Wb 相乘去表示，这过程就叫低秩分解。

矩阵中秩(Rank)的概念简单说就是矩阵中行列较小的那个值，比如 100 x 5 的矩阵，秩就是5，把100 x 100 的矩阵，分解成 100 x 5 和 5 x 100 的矩阵相乘（相乘后是100×100的矩阵），就是低秩分解。图中的 r (rank)就是这个秩。

可以看到这个秩越小，数据量越小，比如分解成 100×10 和 10×100 两个矩阵，这俩矩阵数据量是2000，如果分解成 100 x 5 和 5 x 100 ，数据量是1000，相对于原矩阵 100×100 数据量 10000，要存储的数据量下降10倍。

所以 LoRA 训练出来的不是△W，而是分解后的两个低秩矩阵 Wa 和 Wb，这就是 Low-Rank Adaptation 低秩适应的意思。设定的秩的值越低，所要存储的数据量越低， 所以 LoRA 模型会根据训练时设置的秩值，比原模型大小低一两个数量级。同时训练过程中，因为这俩低秩矩阵跟原矩阵不是一个数量级，所需要的计算量和显存也相应减少了，在普通 PC 也能跑起来。

看起来很神奇，把一个完整的数据做这样的分解，数据的信息量肯定减少了，为什么用这种方式做微调，效果还能好？LoRA 论文中表示，在预训练的大模型上微调时，如果是处理一个细分的小任务，参数的更新主要在低维子空间中，很多高维子空间的参数在微调前后根本就没动，越简单的细分任务，对应要更新的参数维度就越低，可以简单理解为 LoRA 的低秩分解能对应到大模型低维子空间的参数更新中，更多扩展阅读参考 1 2 3。

模型微调和 LoRA 原理就介绍到这里，我们继续回到黏土风的整个 workflow。

图生图

黏土风格这种模型的应用场景是给用户当图片特效使用，也就是需要图生图的方式，前面只做了文生图，来看看图生图的 workflow，以及生成的效果：

只需要在前面的 workflow 基础上，把生成空白噪声图 Empty Latent image 节点，改成 Load image + VAE 编码节点即可。

这里的原理很好理解，文生图是用一张全是随机噪点的图作为输入，沿着 Prompt 逐步降噪生成图片。我们把这个输入换成一张真实的图片，再在上面加上一定量的随机噪点，代替完全随机噪点图进行采样迭代逐步生成图片。把这个加了噪点图片看成是图片生成降噪过程中的某一步状态的话，相当于之前图片是从 0 开始生成，现在是从某一个中间过程点开始去生成，整个流程是一样的。

这里要加多少噪点，在 KSample 这个采样器节点的 denoise 里可以设置，来看看同样的文本 prompt 和图片输入的情况下，设置不同值的效果

denoise 为 0 时，没有加噪点，也就没有去噪的过程，输出是原图，denoise 为 0.4 时，可以猜想到，这时加的噪点程度不影响图的主结构，猫戴帽子的细节也还有，那降噪生成后这些细节还会保留，随着噪点越来越多，原图的细节越来越少，到 denoise 为1.0时，也就是加100%噪点时，跟输入一张随机噪声图是一样的，跟原图就没什么关系了，只跟输入的 Prompt 文字有关系。

看起来设置 0.4 到 0.6 之间的降噪，效果还可以，即保留了原图整图的大致内容，也能适当加上黏土的风格。用其他图片尝试，也还行：

图片 Tag 生成

但这里不同的图片的 Prompt 得自己手动改，才能生成类似的图，我们正常使用这类风格化滤镜是不需要自己输入 prompt 的。我们可以加个图片 Prompt 生成器，让它描述输入的图片，再作为图片生成的过程。

我们添加 WD14 Tagger 这个插件节点，它可以从图片中反推出适用于 SD 提示词的标签（booru风格标签），我们把它解析出来的 tag，跟 LoRA 模型的触发词 claymation style page 一起组合，作为 Prompt 输入，这样就实现了只输入图片，不用修改 Prompt 就能产出对应的图了。

这里注意得用 (claymation style page:2) 这种 Prompt 权重表达方式，把这几个 LoRA 模型的触发词调高权重，不然会淹没在图片输出的众多Tag上，没法起到作用。

最终的 workflow文件（下载这张图片可在ComfyUI上导入）：

到这里，我们实现了一个最简单的黏土风格图生图流程，也认识了过程中涉及到的技术原理。目前这只是个最简单的 demo，在某些图片下效果还可以，但要真正达到可用还有很多问题，后续会随着一些问题继续探索 SD 里的相关技术。

参考资料

LoRA模型微调原理：https://www.bilibili.com/video/BV1Tu4y1R7H5

利用LoRA对LLM进行参数高效的微调：https://zhuanlan.zhihu.com/p/632159261

神经网络训练：https://blog.csdn.net/brytlevson/article/details/131660289

Stable Diffusion原理可视化：https://www.youtube.com/watch?v=ezgKJhi0Czc

最近关注和学习 AI 比较多，包括 AIGC 和 LLM 大模型，现在 AI 的原理介绍和入门教程已经非常多了，但还是想自己写一下，主要是遵从费曼学习法，分享是最好的学习，帮助自己整理思路。

本文介绍这一轮图片生成热潮的集大成者 Stable Diffusion 涉及的一些图片生成基本原理，这里全篇不会有数学公式，因为大部分公式我也不懂，但应该不会太影响理解基本原理和思路，有理解错误的地方欢迎指正。

扩散模型

在看图片生成这个逆天能力的时候，很好奇它是怎么做到的。要完全理解这里面的算法细节门槛挺高，但要了解基础原理概念还是简单的。

目前市面上文字生成图片基本上都基于 Diffusion 扩散模型，Stable Diffusion 自然也是，它最基本的原理是：根据文字指示，把一张随机生成的全是噪点的图片，一步步去掉噪点生成跟文字描述匹配的图片。

具体是怎样做到的？这里可以分步看两个问题：

1. 怎么从一张随机噪点的图生成一张正常的图
2. 怎么控制这个生成的图跟输入的 prompt 文字关联上

先看第一个问题，从随机噪点图生成一张正常图片，通过训练和组合 UNet 模型可以做到。

单步训练-生成

UNet 是个深度学习网络模型，模型细节不说，个人可以非常粗略地理解为，这个 UNet 模型里面的参数，记录了训练的图片的内容，但它不是精确存储，而是有一些映射和数学运算，做到可以识别提取图片特征，模糊地记忆图片的关键信息，混合存储。

这个模型训练出来后，如果你是用一张图片玩命训练它，那它最终恢复出来的就是这张图片(maybe?)。如果你用1万张图片训练这个模型，那它恢复出来的会是这一万张图片内容随机组合的一张图片。

下面稍微再展开看下训练过程和生成过程：

1. 选一张正常图片A，随机生成一个噪声X，给A加上这个噪声。A+X=A1。
2. 把A1输入到模型，我们希望做到的是，模型能在只有输入A1，没有输入噪声X的情况下，能自己推理知道噪声X是什么，如果能做到，那就可以通过A1 – X = A，把更清晰的图给反解出来了，也就是输入一张有噪点的图，输出一张去了噪点的图。
3. 怎样做到？在训练过程中，我们是有A1和X这两个数据的，模型自己生成另一个噪声Y，跟噪声X对比，然后通过不断调节自己的参数，让自己生成的这个噪声接近X就行了。
4. 这样模型记录了相关参数，下次拿A1过来，它就能推算出近似于上面加的噪声X，然后做A1 – X = A去噪，得到更清晰的图片A。

总的来说，我们训练的这个模型，它的能力就是，给一个图片，它能预测出来这张图片上是加了多少噪声，这样就可以让这张图减掉这些噪声，得到更清晰一点的图。

多步扩散

上面是简化的一步，只是把图片从稍微加了点噪声中还原出来，并不是直接从一个没有信息量充满噪声的图片中直接还原蹦出一张图来。要实现从纯噪声图生成一张图片，需要重复很多步上述步骤，所以它还有一个Time step的参数参与在训练过程中。

Time step 就是噪声强度，很好理解，表示的是加多少次噪声。回到上面的训练过程继续：

1. 上面的训练，A 是完全没加过噪声的图片，A1是加了一次噪声X的图片，time step 就是1表示加了一次噪声，A1 和 t=1 输入到模型，训练出能推算 A1->A的能力
2. 下一步针对A1再加一个噪声X2，A1+X2=A2，time step就是2，把加了两次噪声的图片A2和t=2输入到模型，训练出能推算A2->A1的能力
3. 循环N次，加上多张图片重复这个步骤，模型的参数就学会了这里每一个步骤加的噪声数据。
   1. 实际训练过程中，t会是一个随机数，经过海量图片多轮训练，会覆盖所有t的值。下图epoch[回合]，表示一轮一轮的训练，每次用不同的图片，不同的time step做训练

   

4. 最后就能从这个链路里把一个满是噪声（比如加了1000次噪声）的A1000逐渐去噪生成出清晰的图片A。A1000->A999 … ->A2->A1->A：
   

训练和生成过程简化后就是这样。如果训练集是一张图片反复训练，我猜测输入一张加满噪声的图，最终会把这张图片还原出来。如果训练集是海量的图片，那这里还原出来的图片，如果不加其他控制，就会是这些海量图片随机的组合结果。

控制生成

接下来到下一个问题，就是怎样控制它去噪过程，让它生成的图片跟我们输入的文案描述匹配。

概念上很简单，就是在训练和生成过程中，把图片的描述文字也加进去。我们事先准备提供给模型训练的数据，除了图片本身，还需要包含对这张图片的文本描述，这样模型才能学到文本和图片内容的关系。

按刚才训练过程的示意图，实际上模型是三个输入，加了噪声的图片A1、图片对应的文本描述text，噪声强度time step，在这三者的作用下共同推理出对应的噪声。

有text的训练输入后，后续在通过噪声生成图片的过程中，根据用户输入的prompt文本，就可以引导去噪的走向。

如果比较具象地想象这个过程，比如训练集有20张图片，5张的图片描述是girl，其他15张没有girl。训练过程中，girl这个词就跟这5张图片关联记录在网络参数里，在训练后使用这个模型时，输入的文本有girl，那去噪的过程的每一步就大概率会定位到这5张图片训练时的数据，会有更大概率去噪的过程走向这5张图片，而不是之前的随机走向。

到这里，扩散模型最基本的原理就差不多了。

重要概念

上述整个过程比较简化，过程中有几个重要的问题和概念还没提到，这里逐个说明。

Latent Space & VAE

上述的扩散模型的训练和使用，有个很明显要解决的问题，就是图片太大了，如果图片用像素数据表示，现在 iPhone 拍的一张照片有最小有 500w 像素，即使做常见的图片压缩(JPG/PNG)，也有几百K的数据大小，如果用原图按上面的流程跑下来，计算量巨大，显然我们要针对图片做降维（或者理解为压缩），把一张图片的数据量降低，再进行后续的训练和使用。所以需要一个降维模型做这个事，这个模型需要满足：

1. 有 encode 和 decode，需要能从 encode 和处理后的低维数据 decode 成高清图片。
2. 要压缩得尽量小，方便低成本做上述海量的计算。
3. 信息要能保留得足够多。
4. 信息要有语义，不然训练过程中不同图片的信息无法交叉融合。

VAE （Variational Autoencoders 变分自编码器）能做到这些，VAE 提供了 encoder 和 decoder，一张图片经过 VAE encode，可以压缩成仅有 64x64x4 的矩阵，这里经过 encode 后的数据空间，就称为隐空间（Latent Space），在这个空间里进行上述扩散模型的训练和生成流程，成本就非常低，这也是目前Stable Diffusion能跑在我们普通电脑上的原因。最后在隐空间里生成的图片数据，经过 VAE decoder，就能转换成高清图。

那 VAE 为什么能做到这样？一张图片转成 64x64x4 这么小的数据量，为什么能保存图片的信息？通俗理解是 VAE 把图片内容转成了语义概率表示，相当于变成了这张图片的描述，比如描述这张图片有猫的概率、有猫爪子的概率，猫在左边的概率，绿色的概率，类似这样，更深入就不了解了，这篇文章 有讲解到一些，也只了解到这里了。

CLIP

VAE 解决图片编码问题，再来看看文本的编码。在控制生成里，文本实际上是怎样参与到模型训练和生成的过程？如果文本只是随便编码进入模型，模型可能只认得一些特定字符，不认识语义，也就在后续的图片生成中没法比较好地通过自由的prompt文案控制。

SD 使用 OpenAI 训练的 CLIP 模型，把文本转为对应的向量，为什么用它，因为 CLIP 模型本身是一个文本到图片的映射模型，它对文本转出来的向量，更贴近图片的特征空间。

稍微展开说下原理：

1. 有N张图片、以及它们对应的 N 个对图片的描述文本
2. 对图像进行编码，得到I，下图中，I1/I2/…/IN 表示从第 1 到 N 张图片的编码表示。
3. 对文本片段进行编码，得到T，下图中，T1/T2..TN 表示从第 1 到 N 张图片对应的文本描述。
4. 模型的任务是训练 TextEncoder 和 ImageEncoder的 参数：
   1. 让图中蓝色部分Ti和Ii相似度变高，它们原本就是一一对应的文本-图片，属于正样本。（数学上是计算余弦相似度，越大表示相似度越高，最大化这个值）
   2. 让白色部分相似度最低，它们的文本和图片是没有关系的，属于负样本。（数学上是余弦相似度值最小化）

这样训练后，最终使用这个模型时，TextEncoder出来的向量表示，就跟图片内容有很强的关系。比如下图第四行，猫的文字描述通过 TextEncode 出来的值，跟猫的图片的ImageEncode出来的值，相似度更高，跟其图片的encode相似度就低。

PS. 更细节的 CLIP 怎么跟 SD 生成过程结合，还没弄得很清楚，实际上SD 没有用 CLIP 里的 Image encoder，扩展模型训练过程中是用别的 Image Encoder，那就并没有用到文本和实际图片的对应映射关系，但可能CLIP出来的文本编码，语义和表现形式上已经是图片的模式，比如文字 cat，它能跟图片空间里猫所表示的形态(形状/位置)、视觉(眼睛/颜色/形状)、语义(宠物/动物)能比较接近地对应上，也能存储到相关信息，所以跟其他图片编码结合，也能起到很大作用？

采样器

编码和数据量的问题解决了，还有个问题没提到，就是上面流程里的步数太长了，最开始提出的扩散模型训练方案 DDPM（Denoising Diffusion Probabilistic Models 去噪扩散概率模型），正常需要 1000 步降噪过程（称为采样），才能生成一张不错的图片，即使上述隐空间已经降低了计算量，但生成一张图要1000步，还是达不到大规模可用。

为什么 DDPM 一定要这么多次采样？这篇文章说得比较清楚，不能直接减小步数（每次噪声加得很少，避免一步就破坏掉原图），不能跳步降噪（每一步状态都依赖前一步，号称马尔科夫性质）。

随后很快有人提出 DDIM（Denoising Diffusion Implicit Models 去噪扩散隐式模型） 方案，训练时还是 DDPM 一步步来，但生成时是可以做到跳步，同时还能让在步数变少的情况下保持生成的稳定。DDIM不是从头开始逐步去噪，而是选择几个关键的时间点，只在这些时间点上进行去噪操作，并且中间的步骤，比如从降噪100次的图片，下一步直接生成降噪90次的图片，跳10步，生成速度就快了10倍。为什么它能做到跳步，具体原因都是数学公式，就不展开了（还没全看懂），可以看回这篇文章。

Stable Diffusion 的 WebUI 上有很多采样器，Eular a，Karras，DPM 等，在去噪过程中通过不同的方法，有不同的多样化程度、图像质量、速度、收敛性的区别。

Stable Diffusion

最后总结说下 Stable Diffusion。上面整个过程和概念，是一个个解决问题的方法，把它们组合起来，逐渐建立起基于扩散模型生成图片的方法大厦，谁都可以用这些公开的理论方法建一套自己的生图模型。

Stable Diffusion 就在这些基础上做一些改进，建立一套稳定的框架、训练出基础模型，开源让所有人可以用，整个 SD 就是多种能力的组合，这些能力可以分别不断升级替换，模型本身还有很多方式去做更强的控制干预（controlNet / LORA等），使得它可定制性可玩性很强，生态越来越繁荣。

最后让我们用一个图串起整个流程和讲解到的概念。

1. Part1 是用 CLIP 模型对文本做编码。
2. Part2 在模型训练过程中，图片经过 AutoencoderKL（VAE编码器的实现）生成隐空间下图片的表示，随机生成一个 noise 噪声，加到这个图片里，同时把通过 CLIP 模型编码的图片对应描述文本加入进来，一起进入 UNet 模型，训练预测加了多少 noise 噪声的能力。
3. Part3 在模型推理过程中，输入一个完全随机噪点，在隐空间里通过不同的采样器，结合prompt 文本输入（图上没表示出来，文本数据会参与到降噪过程），在 UNet 模型里迭代多步做降噪预测，生成隐空间里的图片，再通过 VAE AutoencoderKL 解码出图片。

了解整个基础流程和概念后，现在看 Stable Diffusion 论文中的这张架构图，应该也大致能理解是什么意思了。

参考资料

• CLIP 相关：CLIP论文，扩散模型引入CLIP论文，CLIP 详解，多模态预训练CLIP
• VAE 相关：理解VAE，VAE and Disentanglement
• 采样器相关：为什么训练用ddpm, 采样用ddim，DDMP论文，DDMI论文
• 整体原理相关：深入浅出完整解析 SD 核心基础知识，扩散模型是如何工作的，Stable Diffusion 原理
• B站一个介绍SD原理的视频，讲得挺好，但只有14个粉丝，不容易： https://www.bilibili-bb.com/video/BV1Wo4y1g7mm
• 光年之外产品负责人张涛分享 Stable Diffusion 原理及发展历程： https://www.bilibili.com/video/BV1wZ421h7w7

最后一刻才动笔，本想不写了，但已经是连续第17年年终博客了，不管好赖，还是不要断了，随便写写。

旅游

疫情开放了，本来想去更多的地方，但真是很难，只在下半年去了香港和马来西亚，一家人出去还是比较紧张的。

关于香港，上一次去是十年前了，今年再去看不到什么变化，很明显能感受到的是香港的科技互联网跟十年前也差不多，很差，比如八达通充值后扣了钱但没到账，一搜一堆人这半年反馈很多，这在国内互联网是P0级别按小时修复的问题，香港好像没打算修，其他还有很多槽点，比如买地铁票被吞/出票错误，因为垄断了这些事不重要吧。但它还是国际化大都市，各国各色的人，多样化国际化的感觉很好。

马来西亚去了吉隆坡和兰卡威，感受了下伊斯兰教清真寺，挺友好的，特别是布城的粉红清真寺，接待人热情，很多宣传资料以非常直白的方式介绍伊斯兰教，探讨生命的意义，探讨的过程挺好，很科学很思辨，但结论是人类的意义就是相信并崇拜安拉，这让人难以接受。在兰卡威首次驾驶右舵汽车，稍微熟悉一下没啥问题，也是个新体验，整个兰卡威感觉还行，不是旅游旺季人很少，是挺舒服的，听说东马仙本那更好点，下次有机会再去。

6月再出差去了次美国，对洛杉矶市中心的印象就是脏乱差，尿骚味，流浪汉。入住的第一天同事的东西在酒店里还全被偷了，还好有苹果的find功能，否则整个街道都没有摄像头，完全不可能找回。旧金山也是脏乱差的代表，坑人、垃圾乱飘、砸车风险高、拥挤，但其他地方似乎又很好，像阿纳海姆就很漂亮，美国太大了，差异很大，有机会都体验下。住了airbnb美国的大house，住的几个小区应该不差，但整个感觉很僻静，很冷清，不怎样。

家庭

今年身体是近十年最差的，有一半的时间在咳嗽，上半年已经连续咳了两个月，6月底中招后又一直持续咳了半年，断断续续咽炎鼻窦炎轮流来，搞得很严重，病总是一直不好，很影响心情。3月中开始健身一直到6月，本来希望坚持锻炼下身体能好点的，结果好像身体免疫力越来越差，平时不运动，马上去健身似乎也不是好事，6月开始咳后也没法继续了，咳的时候不敢运动，等好了还是得再看看别的锻炼方式。

对两个小孩的教育还是很佛系，有点放养，也导致一些问题，难以教育，两个娃在探索上的缺乏，拒绝尝试新东西，看电视也喜欢看已看过的，一遍又一遍，十分念旧，怎么引导他们的好奇心和探索欲，没找到方法。另一个是锻炼缺乏，身体素质不太好，也是我的问题，来年要跟家人一起加油。

年末经历了亲人过世，面对死亡很沉重，怎样能尽可能安心地面对后续可能的离别？好好对待在的人，也好好对待自己，不要时间到了后悔。

学习

在各种行业的萎靡下，AI 的发展几乎是唯一能触动大家神经的，发展速度太快，主要是研究方向明确了，全世界那么多聪明人/先进的组织/最多的资本支持，都沿着这条路跑，自然很快，但跑了一年后，大家期望的大模型跟各行各业结合的应用还没跑出来比较好的，还需要继续探索，总体上，它的未来是显而易见让人兴奋的，今年没有多少时间投入学习，明年得规划好投入，希望有进展。

今年读的书很少，但上下班听讲述和小课程比较多，印象比较深的是华衫讲儒学，听完对很多概念都理解了，格物致知/必有事焉而勿正/中庸/近悦远来/诚意正心，非常强的正气，当然道理都懂但难的就是做到，做到的真是圣人。我至今没找到修身养性的方法，通过多看这些书明白这些概念，远远不行，看的另一本书《悉达多》，明确讲到这个问题，没有任何宗派教义可以教人领悟涅槃，都要靠自己体验，自己领悟。

其他

股票继续跌，我一直放着一直存着希望，这么低的价格，真的不涨回来吗，结果真的不涨，还继续跌，核心是什么都知道，信心很重要，但信心不断被殴打。房子方面年初还有回涨趋势，当时甚至想搞满杠杆进入，还好最后没有，越来越往下走刹不住车，等经济好了，信心有了，房子才有可能回来吧，现在保命就行了，还了房贷，安心活着。

今年35岁了，国内特有的年龄槛，虽然有时候是调侃，但焦虑切实存在，来年加油吧。

疫情

2022是疫情防控拉胯的一年，各种大规模封控带来的不合逻辑的事情频繁出现，到11月顶峰，太多魔幻的事情，真是挺怕要倒退50年，一个不符合逻辑的社会，还好后面止住了。那段时间在家办公关了一个多月，真是给闷坏了，12月放开后，某天开车出去转转，看到街边恢复生气的样子有点感动，自由而归于正常的感觉。

紧接而来的就是大规模的快速感染，速度确实是快到出乎意料，而zf在这块确实继续在拉胯，核酸全撤，抗原不准以及难抢，导致想尽早自我隔离避免感染家人是很难做到的，撤了所有防控措施，药也储备不足，拉胯，全得靠自己。放开后去深圳出了趟差，一不注意，回来就导致全家中招了。

两三天的反复发烧，最高到40度，头痛欲裂，睡不着非常痛苦，脑子乱七八糟转，感觉在非常高速地运转，各种碎片漂移凑不成一块但又停不下来，夹杂着痛苦，在万花筒的世界中。全身酸软、刺痛、咳嗽加剧、肠胃不舒服、鼻塞，症状确实是很猛，还好布洛芬能帮助扛一下。家人有各不一样的症状，总的来说还好，算平安度过，希望以后不要再得了。

不知道世界接下来能不能恢复正常，传播力这么强的病毒，变种又那么多，持续下去受不了。回看以前出去玩的照片，人堆中没有戴口罩，有种恍如隔世，希望世界能恢复。

股票

还以为去年股市已经是惨案了，没想到今年更拉胯，持续下跌，最低只跌剩最高点的20%，我买的都是中概股，跌的也都是中概，也是跟疫情的操作有关，对中国的信心快被疫情期间的各种操作消磨殆尽了，从奋斗变成躺平，爱怎样怎样，放弃幻想，做好打工人，不想玩了。

教育

俩小孩大娃上学了，小娃上幼儿园，小学还好，没有传说中那么卷，作业不多，我们也是很佛系，前面还有每天晚上陪着做作业看英语绘本，后面也少了。虽然不卷，但像英语没有提前学就容易跟不上，跟不上就容易产生厌学情绪。大娃在学习上算是很乖了，目前还没有血压高涨的经历。小娃幼儿园基本就上了一个多月，后面就因为自己感冒、疫情一直没去，社交能力基本为0，希望下学期能正常。

回看小孩的成长，今年2月希希才掉第一颗牙，转眼间牙掉了七八颗，大牙都长出来了，挺快的。希希年初也还不会玩游戏，下半年跟她一起通关了双人成行，现在也玩得很溜了。

旅游

很想旅游的一年，5月去了下潮州汕头转转，7月去了呼伦贝尔，带着大娃三个人，幸运地没被疫情封控影响，完整地游玩了草原，大片大片的草原，金黄色的油菜花田比草原更美，村庄里看漫天繁星，高空秋千和滑草，麋鹿卡丁车骑马，玩得还算不错，不过就景色来说，还是去年的新疆最美。

8月跟公司团队去成都开会，再去了下川西海螺沟一片，不过时间太短过于仓促，没玩什么，仅到此一游，走非常险的山路到若丁山，很适合野营的一个地方，大片草地配合漂亮的山景，下午在那里度过很舒适惬意，要是晚上能住下看星星就更好了。

期望明年可以出国游，可憋太久了，疫情以后不断把自己缩小在两点一线，封控期间还只剩一个点，整个人感觉非常闭塞，长久下去对身心健康不利，希望能更多出游，对在全国全世界留下脚印这事很感兴趣。

玩乐

当前几乎唯一持久的兴趣就是看看NBA，22赛季一整个赛季勇士库里看下来，最后竟然真的夺冠了，有点梦幻，G4感受到库里强悍的意志力，体育不是体能技巧的比拼，精神力量在当中占的比重很高，才会这么有魅力。同时这一年也见识了威少、杜兰特从各种嘲讽中不受影响一步步走出来的坚韧，球星确实身心都很强大，看别人做到自己做不到的事，敬佩。

科技和互联网变得有些无趣，以前喜欢体验感受各种手机，现在千篇一律，已经玩不出花了，iPhone也没什么惊喜，反而摄像头越来越傻大黑粗，VR彻底凉凉的感觉，互联网产品没什么让人惊艳的新品，也就chatGPT稍微亮眼。倒是今年玩了个让人惊叹的游戏–双人成行，每次玩都在感叹它的创意创造力，不愧是年度最佳游戏，强烈推荐亲子或情侣玩。

及时行乐，成了新的标语，之前工作的比重占太大了，现在各方面都无趣的情况下，不如多让自己玩得开心，旅游、游戏、体育娱乐等，看到同事们也在开拓自己的兴趣找乐子，多玩玩多体验生活，别到老了后悔。

最后

2022年元旦全家感冒咳了两个月，年末全家中新冠又是一波，希望来年都能健康，多体验美好生活。

一年没写博客，生疏了，到了年终这篇不知道该写啥，博客这个词现在也变得非常有年代感，差不多要彻底消失了。没写的最主要原因是懒了，另外好像也变得不那么愿意发表观点了。

总的来说今年还是一个对自己不太满意的一年，对自己的期望没达到，一整年时间，做成了什么事情？达成了什么成就？认知有什么提升？回想起来并没有多少值得一提的，只能写写一些生活小事。

经历了一次特别的体验，住在6月份广州疫情最中心地区，被完全封闭在家27天，不能下楼不能收快递，物资紧缺，吃肉成奢侈，体验了一下物资相对匮乏的生活，感受上还好，在哪不是一样拿着电脑手机联网工作，差别不是很大。

还有一次体验，跟一个人聊技术聊了一个多小时，感觉进入了心流的状态，很怀念心流的感觉，岗位不同以后，进入这种状态就变得很困难。当时聊完挺兴奋，工作10年，回想起这个互联网大航海时代，有很多参与其中的回忆，只不过是纯技术的。往后10年，希望能再做些事，为自己留下更多好的回忆。

今年各种政策轰炸，行业一个个毁灭和暴跌，去年那个外滩事情真是中国互联网的拐点。上半年在各种纠结，真是很难，下半年感觉开始佛了，爱怎样就怎样。有时会想，向前看这么简单的道理为什么实践起来难呢，进化论的角度看，是绝对理性倾向向前看的人在原始社会活不下来吗，没想明白。

今年也成了资深韭菜，以前每次股灾一般中概股不会太怎样，今年倒是纯中概股股灾，完全踩在雷区里，美股的资产变成负数，确实自己不是这块料也没有太大兴趣投入，也是直接躺平了。

挤着时间还是转悠了几个地方，带家人去北京，跟朋友去了阳江，两人去了新疆，喀纳斯的美景值得多去看看，是个好地方，青色湖水山色配得上仙境的称呼，可惜在禾木刚好阴天没看到星星银河，这个愿望继续往后推了。

今年大娃小娃健康成长，小娃到2岁还不说话，最近一个月才开始开窍咿咿呀呀各种学说话，是最可爱的时候了。大娃继续经常撒娇可爱，但很多时候不讲理，被气得够呛，以前看的育儿方法在情绪面前都忘光了，情绪控制也是今年对自己很失望的一点，不仅没长进还退步了。

2022年，希望明年回顾时对自己的表现能满意一些。

2020是很特殊的年份，世界发生很多大事，感觉过得很快，又感觉过得很慢，每年都会发生很多不好的事和好的事，看自己更在意和看重哪部分。

工作

今年上半年工作上拿到不错的成绩，年中去晋升答辩，也是一段难忘的经历，前一晚通宵改PPT，大雨的日子，六七点回家还被车栏撞到流血，睡了半个钟匆忙跑去答辩，喝了几瓶红牛咖啡头脑都不是很清醒，顺利讲完回答完问题，然而并没有通过，确实很难。

年末从蚂蚁转岗到lazada，结束三年半蚂蚁的历程，也结束了一年多以来北上广深杭多地跑的处境，今年飞机坐了36次，因为疫情算起来只比去年多几次，但总感觉多了很多，好几次延误凌晨两三点才到家，也经常早上五点出发赶飞机，有点累，对比下现在广深跑简直跟同城没什么区别。刚到新环境，目前状态不错，尽力做好事情，务实解决问题，不着急，就是英语口语这个问题没解决。

蚂蚁上市这历史的一粒尘落头上，作为其中一小员无力影响事情本身，能做是调整心态，做好自己的事，以及相信公司本身的价值。舆论上势头往哪处走，内容就会投其所好地往哪处生产，追涨杀跌是群众普遍行为规律，谁都能上来说两句，看起来讲得头头是道，实际上基本事实都不顾，跟那些养生排毒文章一个性质。巧合的是，2010年11月3日腾讯发表3Q大战“艰难的决定”声明，2020年11月3日，蚂蚁暂缓上市，十年过去。

物质

用心感受一些美好的物质，对提升幸福感很有帮助。

特别喜欢今年的 iPhone 12 pro 的工业设计，用了半个多月每次用还是很有愉悦感，上次有这种感觉的手机是9年前的 iPhone 4s，可能我更偏向喜欢这种规规整整很有秩序感的设计，美轮美奂，爱不释手，全平的屏幕，玻璃跟金属直接衔接感觉很完美，如果摄像头处是平的就更完美了。今年iPhone 买的就是外形工业设计和拍照的提升，5g/A14什么的基本无感，iPhone已经性能过剩，软件没有把提升的性能吃完，就算是三年前的iPhone X用起来速度也是没什么问题。智能手机诞生13年，还没有看到下一代突破的曙光。

今年换了辆车，起初到处试驾一些bba传统车型，感觉跟我的雷凌没什么区别，后面试特斯拉model3，真是有种震撼的感觉，我这个不懂车的理工男太容易被这种产品吸引了，极简（大部分人觉得是粗糙）的内饰，没有一大批乱七八糟的按钮，现代的车机系统，给我第一感受这跟之前试驾的车不是一个时代的东西，冲击比较大，我不知道传统车厂会不会成为诺基亚，但当时确实有类似手机功能机和iPhone 对比的感觉。只是model3这种自己开着爽坐车的人不舒服的体验，不适合我这二胎家庭的需求，所以并没有买model3，而modelX又过于高价，觉得远不值那个价钱，最后买了特别符合我这个实用主义奶爸定位的理想ONE，这车除了外形个人不喜欢，其他表现都很好，车机系统的体验感觉是所有车里最好的，比较满意。

今年开始似乎酒成了我一大爱好，开始品尝各种威士忌，买了各种酒摆柜子上，看着就舒服，有种手办的感觉，喝着也爽，经常小酌。有时不同酒的小差别我也喝不懂，就是喜欢尝，目前喝起来感觉最好的是山崎，就是太贵了。酒吧里的鸡尾酒和氛围也是挚爱，同时我一直想知道酒吧里的冰块哪里有卖，透明无暇实心的冰块可以融化得很慢，自己冻不出来，也没地方买，酒吧的酒就贵在这冰块上了。

家庭

小男孩进入精力旺盛阶段，男孩跟女孩真是天生有巨大差别，大女儿一岁多时经常乖乖坐着玩玩具，小男孩一岁多基本坐不下来，满屋不停乱跑乱爬，举止粗鲁，摔了无数次，破皮流血都好几次，真是累坏人了，茁壮成长中。

大女儿有时特别暖心，有时特别任性，教育的问题长期困扰我们，家里每个人的教育方式理念难达成一致，加上大人自身一些脾气缺陷让孩子学了，经常会闹腾搞得不愉快，不知道怎么教。年末开始听一些育儿类书籍的讲书，正面管教、亲密关系、父母的语言、不吼不叫等等，讲的教育理念其实差不多，就是无条件爱孩子、倾听、说出情绪、正面肯定、理解、保持温柔、不计较、定规则底线、不评价、言传身教、以身作则，我觉得听完是有些作用的，对小孩在努力变得更有耐心容忍度更高一些，有意识实践这些理念，只是小孩性格习惯形成后，并不是一两招一朝一夕就能轻易改变的，任重道远，知行合一不容易，努力做好父亲的角色吧。

今年小孩学钢琴，我也以极其缓慢的速度跟她一起学了，羡慕会弹琴的人，不需要达到多好的水平，只需要有时能玩玩抒发情绪减缓压力，琴棋书画诗词歌赋是抒发和感受情感的介质，少了这些能力，人生会少了一些乐趣。

今年的疫情改变世界，作为普通人被改变的并不是很多，疫情导致年初在老家一家老少十几个人一起待了一个月整，十分难得，这一个月估计我爸妈可开心了，一大家人在一起的感觉多好，几个小朋友也玩得high，离开时小孩哭得很厉害，以后估计很难有这样的机会了。疫情导致全国的感冒大降，因为全年戴口罩，今年我完全没生过病，什么感冒咽喉发炎都没了，口罩的作用很大，只是戴口罩像给人类打了个补丁，只是个临时方案，期望科技能提供更好的方案。

个人

有段时间工作上有些迷失，加上一直多地跑，家庭矛盾等问题，状态很差，那时看脱口秀李雪琴的的专访，说到以前没事桌上的笔掉地上了，都能让自己情绪一下子掉下来，虽然还没那么夸张，但竟然感觉情况特别类似。经过几轮调整后现在好很多，年末这段时间基本恢复正常了。

有时候多看看或听听一些我觉得是“科学式鸡汤”的书对调整心态挺有帮助的，像 正念、被讨厌的勇气、活好 这些书，短期内可以注入一些理念，时刻提醒关注当下，意识上淡化处理压力带来的负面情绪。幸福快乐是种能力，如果不是天生具有的话，是应该花时间学学的。

另一个缓解方式是多跟不同的人聊天，了解广阔世界不同的生活方式价值观，过去几年好像被困在一个圈子里出不来，视野越来越局限在公司内，内心也狭小起来，一些问题在狭小的圈子/体系/空间里可能是致命焦虑的大问题，但在其他多元的世界里它可能不值一提，前提是脑子里有没有这个世界。

2021 期望能持续年末的状态，找好自己的节奏和方法，做点事情赚点钱实现好自己的价值，多点感受身边美好的事物。