Datawhale AI夏令营第四期 AIGC文生图方向 Task2笔记

在Task1中，我探索了文生图的一些原理以及历史，并以自己对文生图的操作流程的理解和分析，浅浅学习了一下baseline的整体框架。在学习Task2的过程中，我了解到了AI大模型对于学习有着促进和协助的作用，并逐渐学会了使用通义千问大模型，对我精读baseline有着非常重要的作用和帮助。

一、运用AI大模型精读代码

通义千问模型：https://tongyi.aliyun.com/qianwen/

1.1分析代码的主体框架

首先打开通义千问模型的对话模块，然后输入如下图的问题去分析代码的主体框架

问题放在这儿可以拿去引用：

你是一个优秀的python开发工程师，现在我们需要你帮我们分析这个代码的主体框架，你需要把代码按照工作流分成几部分，用中文回答我的问题。{此处替换你自己的代码}

生成的结果如下，你会发现读完之后对整体框架和工作流程有一个更加清晰的认识和了解。

这段代码的主要工作流程可以分为以下几个部分：

1. 环境准备
- 安装依赖库：通过`pip`安装一系列Python库，包括`simple-aesthetics-predictor`、`data-juicer`、`peft`、`lightning`、`pandas`、`torchvision`以及`DiffSynth-Studio`。
- 卸载旧库：卸载`pytorch-lightning`，并安装新版本。

 2. 数据集加载与预处理
- 加载数据集：从ModelScope平台加载名为`lowres_anime`的数据集，并指定其子集和分割。
- 保存图像和元数据：遍历数据集中的每个样本，将图像转换为RGB模式并保存到磁盘，同时构造包含文本标签和图像路径的元数据，并写入到一个新的JSONL文件中。

3. 数据集构建与过滤
- 定义过滤配置：创建一个YAML配置文件来定义数据处理规则，例如图像尺寸和长宽比的过滤条件。
- 执行数据过滤：使用`data-juicer`工具处理数据集，根据配置文件中的规则过滤数据。

4. 数据集后处理
- 整理过滤后的数据：读取经过过滤后的数据集，将其转换为DataFrame格式，并保存为CSV文件。

5. 计算图像与文本相似性
- 加载CLIP模型和处理器：加载`CLIP`模型及其预处理器，用于计算图像与文本之间的相似性。
- 计算相似性得分：对每张图像和对应的文本进行编码，并计算它们之间的相似性得分。

6. 数据加载器创建
- 定义数据集类：创建一个自定义的PyTorch数据集类，用于处理图像和文本数据。
- 创建数据加载器：基于定义的数据集类创建数据加载器，以供后续模型训练使用。

7. 图像生成
- 加载Stable Diffusion模型：加载`StableDiffusionPipeline`模型，该模型能够根据给定的提示生成图像。
- 生成图像：使用不同的提示（prompts）生成一系列二次元风格的图像，并保存到磁盘。

8. 结果展示
- 合并并展示图像：将生成的多个图像合并为一个大图，并展示结果。

总结来说，整个过程涉及从加载原始数据集开始，对其进行预处理和过滤，再进行后处理以生成图像与文本相似性的计算，之后定义数据加载器供模型训练使用，接着使用深度学习模型生成图像，最后将这些图像合并并展示结果。

 1.2逐行解释代码

同样的道理输入你先要问的问题，比如：

你是一个优秀的python开发工程师，现在我们需要你帮我们逐行分析这个代码，用中文回答我的问题。{此处替换你自己的代码}

生成的结果如下，感受到了AI大模型的细致的回答。

# 使用 !pip 命令安装 simple-aesthetics-predictor 库，该库可能用于评估图像的美学质量。
!pip install simple-aesthetics-predictor

# 使用 !pip 命令安装 data-juicer 库，并将其设置为可编辑模式（-e），这允许我们在开发过程中修改源码而无需重新安装。
!pip install -v -e data-juicer

# 使用 !pip 命令卸载 pytorch-lightning 库。
!pip uninstall pytorch-lightning -y

# 使用 !pip 命令安装多个库，包括用于高效微调模型的 peft、简化 PyTorch 模型训练的 lightning、数据处理的 pandas 和图像处理的 torchvision。
!pip install peft lightning pandas torchvision

# 使用 !pip 命令以可编辑模式安装 DiffSynth-Studio 库，这可能是一个用于生成或处理图像的库。
!pip install -e DiffSynth-Studio

# 导入 ModelScope 中用于处理数据集的 MsDataset 类。
from modelscope.msdatasets import MsDataset

# 加载名为 lowres_anime 的数据集，并指定使用默认子集（subset_name）和训练集（split），缓存在指定的目录中（cache_dir）。
ds = MsDataset.load(
    'AI-ModelScope/lowres_anime',
    subset_name='default',
    split='train',
    cache_dir="/mnt/workspace/kolors/data"
)

# 导入必要的 Python 库。
import json, os
from data_juicer.utils.mm_utils import SpecialTokens
from tqdm import tqdm

# 创建用于存放处理后的图像和元数据的目录。
os.makedirs("./data/lora_dataset/train", exist_ok=True)
os.makedirs("./data/data-juicer/input", exist_ok=True)

# 打开一个文件，用于写入元数据（JSONL 格式）。遍历数据集中的每个条目，将图像转换为 RGB 格式并保存到磁盘，同时构造包含文本标签和图像路径的元数据，并写入文件。
with open("./data/data-juicer/input/metadata.jsonl", "w") as f:
    for data_id, data in enumerate(tqdm(ds)):
        image = data["image"].convert("RGB")
        image.save(f"/mnt/workspace/kolors/data/lora_dataset/train/{data_id}.jpg")
        metadata = {"text": "二次元", "image": [f"/mnt/workspace/kolors/data/lora_dataset/train/{data_id}.jpg"]}
        f.write(json.dumps(metadata))
        f.write("\n")

# 定义数据处理规则，包括图像尺寸和长宽比的过滤条件。
data_juicer_config = """
# 全局参数
project_name: 'data-process'
dataset_path: './data/data-juicer/input/metadata.jsonl'  # 数据集目录或文件的路径
np: 4  # 处理数据集的子进程数量

text_keys: 'text'
image_key: 'image'
image_special_token: '<__dj__image>'

export_path: './data/data-juicer/output/result.jsonl'

# 处理计划
# 包含多个处理操作符及其参数的列表
process:
    - image_shape_filter:
        min_width: 1024
        min_height: 1024
        any_or_all: any
    - image_aspect_ratio_filter:
        min_ratio: 0.5
        max_ratio: 2.0
        any_or_all: any
"""

# 将配置文件写入 YAML 文件。
with open("data/data-juicer/data_juicer_config.yaml", "w") as file:
    file.write(data_juicer_config.strip())

# 使用 data-juicer 工具处理数据集，根据配置文件中的规则过滤数据。
!dj-process --config data/data-juicer/data_juicer_config.yaml

# 导入必要的 Python 库。
import pandas as pd
import os, json
from PIL import Image
from tqdm import tqdm

# 创建用于存放处理后的图像和元数据的目录。
os.makedirs("./data/data-juicer/output/images", exist_ok=True)

# 读取经过过滤后的数据集，并将其转换为 DataFrame 格式，然后将这些数据保存为 CSV 文件。
texts, file_names = [], []
with open("./data/data-juicer/output/result.jsonl", "r") as f:
    for line in tqdm(f):
        metadata = json.loads(line)
        texts.append(metadata["text"])
        file_names.append(metadata["image"][0])

df = pd.DataFrame({"text": texts, "file_name": file_names})
df.to_csv("./data/data-juicer/output/result.csv", index=False)

# 显示处理后的 DataFrame。
df

# 导入 CLIP 模型和预处理器。
from transformers import CLIPProcessor, CLIPModel
import torch

# 加载 CLIP 模型和预处理器。
model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# 从 DataFrame 中加载图像，并使用 CLIP 预处理器进行预处理。
images = [Image.open(img_path) for img_path in df["file_name"]]
inputs = processor(text=df["text"].tolist(), images=images, return_tensors="pt", padding=True)

# 使用 CLIP 模型计算图像与文本之间的相似性。
outputs = model(**inputs)
logits_per_image = outputs.logits_per_image  # 这是图像-文本相似度分数
probs = logits_per_image.softmax(dim=1)  # 我们可以通过 softmax 获得概率

# 输出相似性得分。
probs

# 导入 PyTorch 数据集和数据加载器类。
from torch.utils.data import Dataset, DataLoader

# 定义自定义数据集类。
class CustomDataset(Dataset):
    def __init__(self, df, processor):
        self.texts = df["text"].tolist()
        self.images = [Image.open(img_path) for img_path in df["file_name"]]
        self.processor = processor

    # 返回数据集中元素的数量。
    def __len__(self):
        return len(self.texts)

    # 获取数据集中指定索引处的元素。
    def __getitem__(self, idx):
        inputs = self.processor(text=self.texts[idx], images=self.images[idx], return_tensors="pt", padding=True)
        return inputs

# 创建自定义数据集实例，并基于此数据集创建数据加载器。
dataset = CustomDataset(df, processor)
dataloader = DataLoader(dataset, batch_size=8)

# 遍历数据加载器中的每个批次，并计算图像与文本之间的相似性。
for batch in dataloader:
    outputs = model(**batch)
    logits_per_image = outputs.logits_per_image
    probs = logits_per_image.softmax(dim=1)
    print(probs)

# 导入必要的库。
import torch
from diffusers import StableDiffusionPipeline

# 设置随机种子以确保生成结果的一致性。
torch.manual_seed(1)

# 加载 Stable Diffusion 模型。
pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v-1-4", torch_dtype=torch.float16)
pipe = pipe.to("cuda")

# 定义提示和负向提示。
prompt = "二次元，一个紫色长发小女孩穿着粉色吊带漏肩连衣裙，在练习室练习唱歌，手持话筒"
negative_prompt = "丑陋、变形、嘈杂、模糊、低对比度"
guidance_scale = 4
num_inference_steps = 50

# 使用 Stable Diffusion 模型生成图像。
image = pipe(
    prompt=prompt,
    negative_prompt=negative_prompt,
    guidance_scale=guidance_scale,
    num_inference_steps=num_inference_steps,
    height=1024,
    width=1024,
).images[0]

# 保存生成的图像。
image.save("example_image.png")

# 显示生成的图像。
image

# 导入 PIL 库。
from PIL import Image

# 设置随机种子以确保生成结果的一致性。
torch.manual_seed(1)

# 使用不同的提示生成图像。
image = pipe(
    prompt="二次元，日系动漫，演唱会的观众席，人山人海，一个紫色短发小女孩穿着粉色吊带漏肩连衣裙坐在演唱会的观众席，舞台上衣着华丽的歌星们在唱歌",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("1.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(1)
image = pipe(
    prompt="二次元，一个紫色短发小女孩穿着粉色吊带漏肩连衣裙坐在演唱会的观众席，露出憧憬的神情",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度，色情擦边",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("2.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(2)
image = pipe(
    prompt="二次元，一个紫色短发小女孩穿着粉色吊带漏肩连衣裙坐在演唱会的观众席，露出憧憬的神情",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度，色情擦边",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("3.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(5)
image = pipe(
    prompt="二次元，一个紫色短发小女孩穿着粉色吊带漏肩连衣裙，对着流星许愿，闭着眼睛，十指交叉，侧面",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度，扭曲的手指，多余的手指",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("4.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(0)
image = pipe(
    prompt="二次元，一个紫色中等长度头发小女孩穿着粉色吊带漏肩连衣裙，在练习室练习唱歌",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("5.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(1)
image = pipe(
    prompt="二次元，一个紫色长发小女孩穿着粉色吊带漏肩连衣裙，在练习室练习唱歌，手持话筒",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("6.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(7)
image = pipe(
    prompt="二次元，紫色长发少女，穿着黑色连衣裙，试衣间，心情忐忑",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("7.jpg")

# 使用不同的提示生成图像。
torch.manual_seed(0)
image = pipe(
    prompt="二次元，紫色长发少女，穿着黑色礼服，连衣裙，在台上唱歌",
    negative_prompt="丑陋、变形、嘈杂、模糊、低对比度",
    cfg_scale=4,
    num_inference_steps=50, height=1024, width=1024,
)
image.save("8.jpg")

# 导入必要的库。
import numpy as np
from PIL import Image

# 将之前生成的图像合并成一个大图像，并调整尺寸。
images = [np.array(Image.open(f"{i}.jpg")) for i in range(1, 9)]
image = np.concatenate([
    np.concatenate(images[0:2], axis=1),
    np.concatenate(images[2:4], axis=1),
    np.concatenate(images[4:6], axis=1),
    np.concatenate(images[6:8], axis=1),
], axis=0)
image = Image.fromarray(image).resize((1024, 2048))

# 显示合并后的图像。
image

1.3截取代码询问

如果有不理解的代码片段，也可以直接截取下来进行询问，得到详细的分析

二、创作属于自己的连环画

2.1数据准备

我想创建一个英姿飒爽的男生在球场打球的连环画，我会写下一些关于场景的提示词

男生打篮球过程的现代风格描述

场景一：男生正在热身
- 风格：现代
- 画面：上半身
- 人物：一个短发青年
- 场景：篮球场上
- 做啥事情：正在拉伸肌肉，准备活动

场景二：男生准备投篮
- 风格：现代
- 画面：全身
- 人物：一个身穿白色运动衫的青年
- 场景：篮球场上
- 做啥事情：跳起投篮，篮球即将飞向篮筐

场景三：男生完成投篮
- 风格：现代
- 画面：上半身
- 人物：一个身穿蓝色运动衫的青年
- 场景：篮球场上
- 做啥事情：投篮后，转身看向篮筐，等待篮球入网

场景四：男生与队友击掌庆祝
- 风格：现代
- 画面：上半身
- 人物：一个身穿红色运动衫的青年和他的队友
- 场景：篮球场上
- 做啥事情：击掌庆祝进球

场景五：男生休息
- 风格：现代
- 画面：上半身
- 人物：一个身穿黄色运动衫的青年
- 场景：篮球场边的长椅上
- 做啥事情：喝水休息，汗水顺着脸颊流下

场景六：男生再次上场
- 风格：现代
- 画面：全身
- 人物：一个身穿绿色运动衫的青年
- 场景：篮球场上
- 做啥事情：重新回到场上，准备再次投入比赛

场景七：男生扣篮
- 风格：现代
- 画面：全身
- 人物：一个身穿灰色运动衫的青年
- 场景：篮球场上
- 做啥事情：飞跃起来，准备扣篮

场景八：男生完成训练
- 风格：现代
- 画面：上半身
- 人物：一个身穿黑色运动衫的青年
- 场景：篮球场旁
- 做啥事情：结束训练后，整理装备，面带微笑

 2.2执行baseline&换上新的提示词

找到baseline中生成图像的板块

换上正向提示词和反向提示词

运行程序生成图像

到此你就拥有了属于自己的连环画，不过看效果这个提示词的效果不是很连贯，可以在用AI大模型提升一下提示词的质量，还有待改进。