Unicasso：基于CLIP优化的ASCII艺术生成原理与实战

1. 什么是 Unicasso？为什么用“优化”而不是“转换”生成 ASCII 艺术

在大多数开发者的印象里，把图片转成 ASCII 艺术，无非就是先缩小图片、转灰度，再把每个像素的亮度值映射到一个字符集上。这个过程更像“采样”或“量化”：字符是死的，亮度是唯一的依据，最终效果往往是“能看出轮廓，但缺少细节”。如果原图带有人物、动物、纹理复杂的场景，转换结果通常比较粗糙，甚至像打了马赛克。

Unicasso 的思路完全不同。它不是做“像素到字符的映射”，而是把 ASCII 艺术生成问题建模成一个“优化问题”。简单说，它先用一个图像理解模型（CLIP）去评估“当前生成的 ASCII 图”和“原图”在语义上有多接近，然后通过不断调整字符布局和字符选择，让两者越来越接近。

这个思路本质上和很多生成式 AI 方法类似：

• 随机初始化一个候选解；
• 用损失函数衡量当前解和目标之间的差距；
• 迭代更新解，直到损失收敛。

区别在于，这里的“候选解”是一块字符画布，“目标”是原图的语义特征，“损失函数”则由 CLIP 模型来提供。

所以 Unicasso 的核心价值可以总结成三句话：

1. 它不是传统查表式 ASCII 转换工具，而是基于 CLIP 的优化生成器。
2. 它生成的 ASCII 艺术，不是“像素近似”，而是“语义近似”。
3. 它把 CLIP 模型从“图像分类”“图文匹配”这类常规应用，扩展到了字符艺术生成领域。

对开发者来说，这个项目值得关注的地方不只是“能生成好看的 ASCII 图”，而是它示范了一个通用套路：任何可以被评估的视觉目标，都可以通过优化方式生成。这个思路可以迁移到排版、字体设计、像素画生成、甚至 UI 草图生成等方向。

2. 基础概念拆解：ASCII 艺术、CLIP 模型与优化目标

2.1 ASCII 艺术：从字符到图像的经典表达

ASCII 艺术，简单说，就是用 ASCII 字符集里的可打印字符（比如@、#、*、.、空格）拼出图案。早期的终端没有图形界面，ASCII 艺术是表达图像的重要手段。即使在今天，代码注释里的 ASCII 图、终端启动横幅、开源项目 README 里的 Logo，仍然大量使用 ASCII 艺术。

传统转换工具通常按以下流程工作：

1. 加载原图，缩小到目标尺寸（例如宽度 100 字符）。
2. 调整宽高比，因为字符本身不是正方形。
3. 将彩色图转为灰度图。
4. 将灰度值映射到字符集，例如暗部用@，亮部用空格。

这种流程的问题已经说过：字符选择只看灰度，缺少对“形状”“语义”的感知。比如照片里的一只猫，传统转换可能输出一大片@和#，轮廓勉强能看，但眼睛、耳朵、胡须这些关键部位完全丢失。

Unicasso 想解决的，正是这个问题。

2.2 CLIP 模型：连接图像与文本的“语义评估器”

CLIP 是 OpenAI 提出的多模态模型，全称是 Contrastive Language-Image Pre-training。它的核心能力是：把图像和文本映射到同一个向量空间，在这个空间里，语义相近的图像和文本会靠得很近。

用一句话解释：

CLIP 能告诉你，一张图像和一段文字在语义上有多匹配。

这个能力在 Unicasso 里的用法很巧妙：

• 原图经过 CLIP 的图像编码器，得到一个特征向量V_target；
• 当前 ASCII 画布被渲染成图像后，经过同一个 CLIP 图像编码器，得到另一个特征向量V_current；
• 计算两个特征向量之间的距离，作为损失函数；
• 用优化算法不断修改 ASCII 画布，让V_current逐渐靠近V_target。

换句话说，Unicasso 不关心像素是不是一样，只关心“语义上像不像”。这给了优化过程很大的自由度：只要最终布局在语义上接近原图，字符具体怎么排、用什么字符，都是可以被搜索出来的。

2.3 优化目标：为什么需要离散优化

这里有一个技术难点需要特别说明：

ASCII 画布上每个格子只能选择有限个字符，比如 95 个可打印 ASCII 字符。这意味着优化变量是离散的，不是连续的。传统的梯度下降法对连续变量有效，但对离散变量并不直接适用。

Unicasso 的取舍是：把离散问题近似成连续问题来解。具体来说，它对每个格子的字符概率分布做优化，而不是直接选择一个字符。训练过程中，字符的 one-hot 选择被替换为概率分布；推理时，再从分布里采样或取概率最大的字符。这种技巧在 NLP 和生成模型里非常常见，比如 Gumbel-Softmax 就是为了解决这类离散采样不可导的问题。

所以，Unicasso 里的“optimization”不是指调超参数，而是指它把字符生成问题真正当作一个优化问题来求解。

3. 环境准备：运行 Unicasso 需要哪些条件

由于 Unicasso 依赖 CLIP 模型和 PyTorch，运行环境相对较重。下面按从底层到上层的顺序列出主要依赖。

3.1 硬件环境

• 建议使用 NVIDIA GPU，显存 6GB 及以上。CLIP 模型推理本身不算特别吃显存，但由于优化过程需要反复计算梯度，GPU 能显著缩短迭代时间。
• CPU 也可以运行，但速度会慢很多。如果只是跑小尺寸示例（比如 64×32 字符画布），CPU 也能接受，只是等待时间会长一些。
• 内存建议 8GB 以上。

3.2 软件环境

推荐使用 Python 3.8 及以上版本。核心依赖包括：

• PyTorch（1.10 以上均可，建议使用与 CUDA 版本匹配的最新稳定版）
• torchvision
• clip（OpenAI 官方开源库，或者通过open_clip_torch使用）
• PIL/Pillow
• numpy
• matplotlib（用于可视化中间结果，不是必须）
• tqdm（用于显示优化进度）

如果你之前没用过 CLIP，建议先单独跑一次 CLIP 的图像编码流程，确认环境没问题，再进入 Unicasso 的完整流程。这样可以避免把“Unicasso 的 bug”和“CLIP 环境问题”混在一起排查。

3.3 获取代码

Unicasso 是开源项目，可以从 GitHub 获取：

git clone https://github.com/sickcodes/unicasso.git cd unicasso

注意：项目可能有多个分支或版本更新，实际使用时以仓库 README 为准。如果该仓库结构发生变化，比如依赖文件从requirements.txt改成pyproject.toml，需要按最新说明操作。

3.4 虚拟环境建议

强烈建议使用虚拟环境，避免依赖版本污染其他项目：

python -m venv venv source venv/bin/activate # Windows 下为 venv\Scripts\activate pip install -r requirements.txt

如果在安装 CLIP 依赖时遇到问题，可能是网络原因，也可能是 PyTorch 版本不匹配。建议先单独安装 PyTorch，再安装其他依赖：

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu118

然后测试 CLIP 是否可用：

import clip import torch device = "cuda" if torch.cuda.is_available() else "cpu" model, preprocess = clip.load("ViT-B/32", device=device) print(model) print("CLIP load success on", device)

这一步能跑通，说明基础环境没有问题。

4. 核心原理拆解：Unicasso 的优化流程

在进入完整代码之前，先把 Unicasso 的优化流程拆成几个环节。理解流程后再看代码，就不会被细节绕晕。

4.1 输入输出映射

Unicasso 的目标是生成一块字符画布。画布的每个格子都有一个字符索引。为了能和 CLIP 配合，这些离散索引会被表示成概率分布。

假设画布尺寸是W x H，字符集大小是C，那么优化变量就是一个形状为(H, W, C)的张量。每个格子对应一个C维的概率向量，表示每个字符被选中的概率。

4.2 字符画布渲染

要让 CLIP 能理解 ASCII 画布，必须把字符画布“渲染”成图像。这一步通常包括：

• 选择字体和字号；
• 将字符逐个绘制到白色或黑色背景上；
• 将渲染结果调整到 CLIP 期望的输入尺寸（例如 224×224 或 336×336）。

渲染本身不可导，但 Unicasso 做了一个关键选择：在字符概率分布上直接做可微渲染。也就是说，它不是先采样字符再画图，而是把每个格子里所有字符的渲染结果，按照概率加权融合成一张“软图像”。这样梯度就能从 CLIP 的损失函数流回字符概率张量。

4.3 损失函数

Unicasso 最常用的损失函数是 CLIP 特征空间的余弦距离或欧氏距离。公式可以简写为：

loss = 1 - cosine_similarity(V_target, V_current)

其中：

• V_target：原图经过 CLIP 编码后的特征向量；
• V_current：当前 ASCII 画布渲染图经过 CLIP 编码后的特征向量。

当loss减小，意味着当前画布在语义上越来越接近原图。

除了语义损失，项目可能还引入了其他正则项，比如字符分布均匀性、边缘平滑度、字符集多样性等。这些正则项能避免优化结果出现大面积重复字符、噪点过多等问题。

4.4 优化器选择

由于优化变量是离散字符的概率分布，一般可以使用 Adam 或 SGD 等通用优化器。实际项目中，Adam 通常优于 SGD，因为它对学习率的选择不那么敏感，且能更快收敛。

4.5 迭代与采样

优化完成后，对每个格子的概率分布取argmax，得到最终字符。这时生成的 ASCII 艺术就是最终结果。

5. 完整实战：在本地运行一个 Unicasso 示例

下面给出一个可以独立运行的完整示例。这里不直接复制项目源码，而是用一个最小实现来演示“基于 CLIP 的 ASCII 优化生成”这一核心思路。示例代码使用 PyTorch 和 CLIP，逻辑清晰，可以作为理解 Unicasso 的起点。

5.1 创建项目结构

建议先创建一个目录：

unicasso-demo/ ├── input.jpg # 输入图片 ├── ascii_art.py # 核心代码 ├── output.txt # 输出的 ASCII 艺术 └── output.png # ASCII 艺术渲染图

本示例中，input.jpg可以是一张简单的物体图片，例如苹果、猫、汽车等。为了保证效果，建议选择主体明确、背景简单的图片。

5.2 编写核心代码

以下是完整的ascii_art.py示例。为了便于理解，我把代码拆成几个函数，并用注释说明关键步骤。

# 文件路径：ascii_art.py import torch import torch.nn as nn import torch.optim as optim import clip import numpy as np from PIL import Image, ImageDraw, ImageFont # --------------------------- # 1. 字符集与渲染参数 # --------------------------- CHARS = list("@%#*+=-:. ") CHAR_WIDTH = 12 CHAR_HEIGHT = 18 OUTPUT_WIDTH = 80 # ASCII 艺术宽度（字符数） OUTPUT_HEIGHT = 40 # ASCII 艺术高度（字符数） FONT_PATH = "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf" # 按实际系统修改 def load_target_image(path, clip_preprocess): image = Image.open(path).convert("RGB") image = clip_preprocess(image).unsqueeze(0) return image # --------------------------- # 2. 字符渲染函数 # --------------------------- def render_ascii(canvas_probs, chars, width, height, font_path): """ 将字符概率画布渲染为图像。 canvas_probs: shape (H, W, C) 的概率张量。 """ font = ImageFont.truetype(font_path, CHAR_HEIGHT) # 图像尺寸：字符宽 * 列数，字符高 * 行数 img_width = width * CHAR_WIDTH img_height = height * CHAR_HEIGHT # 预先渲染每个字符到小图块 char_images = [] for c in chars: img = Image.new("RGB", (CHAR_WIDTH, CHAR_HEIGHT), color=(255, 255, 255)) draw = ImageDraw.Draw(img) draw.text((1, 1), c, fill=(0, 0, 0), font=font) char_images.append(np.array(img).astype(np.float32)) char_stack = torch.from_numpy(np.stack(char_images)).to(canvas_probs.device) # char_stack shape: (C, CHAR_WIDTH, CHAR_HEIGHT, 3) canvas_probs_3d = canvas_probs.permute(2, 0, 1) # (C, H, W) result = torch.zeros((height, width, CHAR_WIDTH, CHAR_HEIGHT, 3), device=canvas_probs.device) for y in range(height): for x in range(width): # 混合所有字符的像素，按概率加权 blend = torch.zeros((CHAR_WIDTH, CHAR_HEIGHT, 3), device=canvas_probs.device) for ci, c in enumerate(chars): blend += canvas_probs[y, x, ci] * char_stack[ci] result[y, x] = blend # 拼接成整张图像 rows = [] for y in range(height): row = torch.cat([result[y, x] for x in range(width)], dim=1) rows.append(row) full_img = torch.cat(rows, dim=0) return full_img.unsqueeze(0).permute(0, 3, 1, 2) # (1, 3, H, W) # --------------------------- # 3. 损失函数 # --------------------------- def clip_loss(current_img, target_feat, clip_model, preprocess): """ current_img: 形状为 (1, 3, H, W) 的渲染图像，值范围 0~255。 preprocess 会做 Normalize，但我们这里已经控制范围接近 0~1。 """ # CLIP 期望输入尺寸为 224x224，先缩放 current_img_resized = torch.nn.functional.interpolate( current_img / 255.0, size=(224, 224), mode="bilinear", align_corners=False ) # CLIP 预处理需要 Normalize，手动补上 mean = torch.tensor([0.48145466, 0.4578275, 0.40821073], device=current_img.device).view(1, 3, 1, 1) std = torch.tensor([0.26862954, 0.26130258, 0.27577711], device=current_img.device).view(1, 3, 1, 1) current_img_norm = (current_img_resized - mean) / std current_feat = clip_model.encode_image(current_img_norm) current_feat = current_feat / current_feat.norm(dim=-1, keepdim=True) loss = 1.0 - (current_feat * target_feat).sum(dim=-1).mean() return loss # --------------------------- # 4. 优化主流程 # --------------------------- def main(): device = "cuda" if torch.cuda.is_available() else "cpu" print(f"Using device: {device}") # 加载 CLIP clip_model, preprocess = clip.load("ViT-B/32", device=device) # 加载目标图片并提取特征 target_img = load_target_image("input.jpg", preprocess).to(device) with torch.no_grad(): target_feat = clip_model.encode_image(target_img) target_feat = target_feat / target_feat.norm(dim=-1, keepdim=True) # 初始化概率画布：均匀分布 canvas_probs = torch.rand(OUTPUT_HEIGHT, OUTPUT_WIDTH, len(CHARS), device=device, requires_grad=True) # 用 softmax 让概率归一化 canvas_probs = torch.log_softmax(canvas_probs, dim=-1) # 优化器 optimizer = optim.Adam([canvas_probs], lr=0.1) # 迭代优化 steps = 200 for step in range(steps): optimizer.zero_grad() rendered = render_ascii(canvas_probs, CHARS, OUTPUT_WIDTH, OUTPUT_HEIGHT, FONT_PATH) loss = clip_loss(rendered, target_feat, clip_model, preprocess) loss.backward() optimizer.step() if step % 20 == 0: print(f"Step {step}, loss: {loss.item():.4f}") # 取出最终字符 final_probs = torch.softmax(canvas_probs, dim=-1) final_indices = torch.argmax(final_probs, dim=-1).cpu().numpy() # 输出为文本 ascii_lines = [] for y in range(OUTPUT_HEIGHT): line = "".join(CHARS[idx] for idx in final_indices[y]) ascii_lines.append(line) with open("output.txt", "w", encoding="utf-8") as f: f.write("\n".join(ascii_lines)) print("Done! Output saved to output.txt") if __name__ == "__main__": main()

5.3 代码说明

这段代码可能不是项目源码的精确复制，但它抓住了 Unicasso 的核心流程。逐段解释：

• 字符集：使用从密到疏的字符序列@%#*+=-:.，这是 ASCII 艺术最常见的排列。
• 渲染函数：对每个字符先渲染成小图块，再根据当前概率加权混合。这里的canvas_probs就是优化变量。
• CLIP 损失：计算当前渲染图像与目标图片在 CLIP 特征空间的距离。由于target_feat已经归一化，1 - cosine_similarity的取值范围是 0 到 2，越小表示越相似。
• 优化器：使用 Adam，学习率设为 0.1。这个学习率偏高，但可以从快速探索开始；如果 loss 震荡，可以适当调低到 0.01。
• 迭代次数：200 步是一个起点。通常 100 到 500 步之间可以得到比较完整的效果。

运行：

python ascii_art.py

输出结果会保存到output.txt。你也可以用任意文本编辑器打开查看。

5.4 预期效果

在 80×40 字符画布上，如果输入是一张清晰的苹果照片，优化后输出的 ASCII 艺术应该能看出大致的圆形轮廓、高光区域和阴影区域。相比传统灰度映射，它的优势在于形状和结构更接近原图。

6. 从 Unicasso 到 CLIP 应用延展：优化思路的更多用法

Unicasso 并不是 CLIP 唯一能发挥价值的场景。理解它的优化机制后，你可以把同样思路迁移到很多方向。

6.1 CLIP 作为“可微评估器”

CLIP 最常见的应用是零样本图像分类、图文检索、图像标签标注。但 Unicasso 展示了另一个重要用法：把 CLIP 当作可微评估器，让一个生成过程朝着语义目标优化。

这个思路在字体生成、Logo 生成、像素画生成、LaTeX 排版生成、UI 原型生成等领域都可以复用。核心套路是：

1. 定义一个可微的渲染器，把离散结构映射成图像。
2. 用 CLIP 计算渲染图像和文本描述或参考图像之间的语义距离。
3. 用优化器迭代更新离散结构。

6.2 常见 CLIP 应用对比

Unicasso 显然属于第四类。

6.3 与生成模型的区别

相比 Stable Diffusion 这类扩散模型，Unicasso 没有训练一个从文本到图像的生成器，而是通过优化已有字符画布来逼近语义目标。它更轻量，不需要大规模数据集，也不依赖 AIGC 模型，但对优化过程和字符画布的表达能力有更高要求。

7. 常见问题排查：报错与效果不佳的解决思路

在运行 Unicasso 或相关优化代码时，可能会遇到以下几类问题。按现象、原因、解法三部分说明。

7.1 CLIP 相关报错

7.2 UnicodeDecodeError 深入排查

有些开发者在处理 ASCII 输出时遇到这样的报错：

UnicodeDecodeError: 'ascii' codec can't decode byte 0xe5 in position 71: ordinal not in range(128)

这个报错通常不是你代码逻辑的问题，而是文件编码问题。Python 在某些环境下默认使用 ASCII 编码读取文件，但文件内容是 UTF-8 编码的中文或特殊字符。

解决办法：

with open("output.txt", "r", encoding="utf-8") as f: content = f.read()

而不是：

with open("output.txt", "r") as f: # 可能使用系统默认编码 content = f.read()

另外，如果是在 Windows 的 cmd 或 PowerShell 里输出中文到控制台，也可能出现乱码或编码错误。建议把输出写入文件，而不是直接打印到控制台。

7.3 优化效果不佳

7.4 渲染图像与预期不符

如果渲染出的 ASCII 图像和原图在视觉上差异很大，可能是语义损失的权重偏低，或者正则项权重过高。建议先关掉正则项，只保留 CLIP 损失，观察基础优化效果，再逐步添加正则项。

8. 最佳实践与工程建议

当你想把 Unicasso 这类项目真正用于生产环境或长期维护时，以下几个建议值得参考。

8.1 模块化设计

不要把整个优化流程写在一个脚本里。建议拆分为：

• renderer.py：负责字符渲染；
• losses.py：定义损失函数；
• optimizer.py：负责优化循环；
• config.py：集中管理超参数；
• main.py：负责命令行入口。

这样后续替换字符集、修改渲染器、调整损失函数都会更方便。

8.2 使用配置管理

优化参数（学习率、迭代步数、画布尺寸、字符集、CLIP 模型版本）应该放在配置文件中，而不是硬编码在代码里。推荐使用 YAML 或 JSON：

# config.yaml output_width: 80 output_height: 40 learning_rate: 0.1 steps: 200 clip_model: ViT-B/32 char_set: "@%#*+=-:. " font_path: "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf" seed: 42

然后通过解析配置来初始化优化器：

import yaml with open("config.yaml", "r", encoding="utf-8") as f: config = yaml.safe_load(f) OUTPUT_WIDTH = config["output_width"] OUTPUT_HEIGHT = config["output_height"] LEARNING_RATE = config["learning_rate"] STEPS = config["steps"]

8.3 日志与可观测性

优化过程是个迭代过程，建议记录每一步的 loss 以及中间渲染结果。可以每 20 步保存一张中间效果图，这样即使最终结果不理想，也能定位是哪一步开始变差的。

建议记录：

• 当前迭代步数；
• 当前 loss 值；
• 当前学习率；
• 字符选择变化比例；
• 渲染图的缩略图。

8.4 固定随机种子

优化过程受初始化和随机性影响。为了保证可复现，需要在代码开头固定随机种子：

import random import numpy as np import torch random.seed(42) np.random.seed(42) torch.manual_seed(42) if torch.cuda.is_available(): torch.cuda.manual_seed_all(42)

8.5 性能优化

如果画布尺寸较大，字符渲染会成为性能瓶颈。可以考虑：

• 将字符渲染结果预先计算并缓存，不重复渲染相同字符；
• 使用torch.nn.functional.conv2d或批量矩阵乘法代替逐像素循环；
• 使用半精度训练（混合精度）；
• 在不影响效果的前提下减小 CLIP 输入分辨率，如从 336×336 降到 224×224。

8.6 安全与版权考虑

• 不要用他人受版权保护的图片直接生成 ASCII 艺术并商用，除非已获得授权。
• 在生成涉及人物、人脸的内容时，注意隐私和肖像权问题。
• 如果用于自动化生产环境，建议增加人工审核步骤，避免生成不合规内容。

9. 更深一步：如何改造 Unicasso 适配自己的需求

如果你已经跑通了上面的示例，接下来可以尝试以下几种改动，加深理解。

9.1 支持文本描述输入

当前示例是用“原图”作为目标。你可以改成：用一段文字描述作为目标，让 CLIP 评估 ASCII 画布与文本之间的相似度。这样就能实现“文生 ASCII 艺术”。

改动方法：

# 用文本特征替换目标图像特征 text = clip.tokenize(["a red apple on a white table"]).to(device) with torch.no_grad(): target_feat = clip_model.encode_text(text) target_feat = target_feat / target_feat.norm(dim=-1, keepdim=True)

9.2 支持彩色 ASCII 艺术

传统 ASCII 艺术是单色的。如果你想生成保留颜色信息的 ASCII 艺术，可以在渲染时为每个字符增加一个前景色变量，把颜色也纳入优化范围。不过这会显著增加参数量，需要更大的画布和更多迭代步数。

9.3 自定义字符集

可以根据场景选择不同的字符集。例如：

• 纯线条字符：|/\/\-_
• 密度字符：.:-=+*#%@
• 混合字符：@#S%?*+;:,

字符集的种类和数量会直接影响优化难度。字符越多，搜索空间越大，收敛越慢。

9.4 引入正则项

常见正则项包括：

• 邻接一致性：相邻格子尽量选择相似字符，减少噪点；
• 字符频率均衡：避免某个字符出现次数过多；
• 边缘保留：在图像边缘区域使用更密集的字符，在平滑区域使用更稀疏的字符。

10. 总结与下一步学习路线

本文从一个真实开源项目 Unicasso 出发，梳理了它背后的核心思想：把 ASCII 艺术生成当作一个基于 CLIP 特征的优化问题。它不是传统意义上的“图片转字符”，而是通过迭代优化让字符画布在语义上逼近原图。

通过本文，你应该掌握了以下内容：

• Unicasso 与传统 ASCII 转换工具的核心区别；
• CLIP 模型在图像语义理解中的作用；
• 离散字符生成如何近似成连续优化问题；
• 一个可运行的最小 Python 示例；
• 常见报错排查方式，包括 CLIP 加载失败和 UnicodeDecodeError 等；
• 基于 CLIP 优化思想扩展到其他生成场景的方法。

下一步，你可以从两个方向继续深入：

方向一：深入理解 CLIP 内部机制。可以去读 CLIP 原始论文，了解对比学习目标、图像/文本编码器结构、温度系数等细节。只有理解了 CLIP 的特征空间是什么，才能更好地设计损失函数。

方向二：尝试更专业的离散优化方法。当前示例用的是概率分布加 softmax 的近似方案。你可以进一步学习 Gumbel-Softmax、Straight-Through Estimator 等方法，看看是否能提升 ASCII 生成质量。

最后，如果你准备在真实项目中使用这类技术，有两个建议需要牢记：

第一，先用小尺寸验证思路，再扩大画布和增加迭代次数。直接跑到 200×100 的字符画布，不仅耗时长，而且往往难调整。

第二，保留中间结果。优化过程本身就是一个很有意思的可视化过程，你可以在每一步保存字符画布渲染图，生成一段 GIF 或视频，这会成为很有价值的项目展示素材。

如果本文对你有帮助，建议收藏备用。也欢迎在评论区交流你在运行 Unicasso 或 CLIP 优化项目时遇到的问题，相互排查效率会更高。