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

一、baseline代码精读

借用通义千问，生成代码详细注释

# 安装 simple-aesthetics-predictor 包
!pip install simple-aesthetics-predictor

# 以可编辑模式安装 data-juicer 包，并显示详细信息
!pip install -v -e data-juicer

# 卸载 pytorch-lightning 包
!pip uninstall pytorch-lightning -y

# 安装 peft, lightning, pandas 和 torchvision 包
!pip install peft lightning pandas torchvision

# 以可编辑模式安装 DiffSynth-Studio 包
!pip install -e DiffSynth-Studio

# 导入 ModelScope 数据集模块
from modelscope.msdatasets import MsDataset

# 加载 ModelScope 中的 lowres_anime 数据集
ds = MsDataset.load(
    'AI-ModelScope/lowres_anime',  # 数据集名称
    subset_name='default',  # 子集名称
    split='train',  # 数据集划分
    cache_dir="/mnt/workspace/kolors/data"  # 缓存目录
)

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

# 创建用于保存训练图像的目录
os.makedirs("./data/lora_dataset/train", exist_ok=True)

# 创建用于保存 Data-Juicer 输入文件的目录
os.makedirs("./data/data-juicer/input", exist_ok=True)

# 打开一个 JSONL 文件用于写入数据集的元数据
with open("./data/data-juicer/input/metadata.jsonl", "w") as f:
    # 遍历数据集中的每一项数据
    for data_id, data in enumerate(tqdm(ds)):
        # 将图像转换为 RGB 模式
        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"]  # 图像路径
        }
        
        # 将元数据写入 JSONL 文件
        f.write(json.dumps(metadata))
        f.write("\n")

# 定义 Data-Juicer 的配置字符串
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  # 至少有一边满足条件即可
"""

# 写入 Data-Juicer 的配置文件
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

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

# 创建用于保存经过 Data-Juicer 处理后图像的目录
os.makedirs("./data/data-juicer/output/images", exist_ok=True)

# 读取 Data-Juicer 输出的 JSONL 文件
texts, file_names = [], []
with open("./data/data-juicer/output/result.jsonl", "r") as f:
    # 遍历文件中的每一行
    for line in tqdm(f):
        # 解析 JSON 字符串
        metadata = json.loads(line)
        
        # 提取文本和图像路径
        texts.append(metadata["text"])
        file_names.append(metadata["image"][0])

# 创建 Pandas DataFrame
df = pd.DataFrame({"text": texts, "file_name": file_names})

# 将 DataFrame 保存为 CSV 文件
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")

# 加载 CLIP 处理器
processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")

# 加载图像
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)

# 获取模型输出
outputs = model(**inputs)

# 计算图像和文本的相似度得分
logits_per_image = outputs.logits_per_image

# 计算概率
probs = logits_per_image.softmax(dim=1)

# 显示概率
probs

# 定义自定义数据集类
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 = DataLoader(dataset, batch_size=8)

# 遍历 DataLoader 中的批次
for batch in dataloader:
    # 获取模型输出
    outputs = model(**batch)
    
    # 计算图像和文本的相似度得分
    logits_per_image = outputs.logits_per_image
    
    # 计算概率
    probs = logits_per_image.softmax(dim=1)
    
    # 打印概率
    print(probs)

# 导入 torch 和 StableDiffusionPipeline
import torch
from diffusers import StableDiffusionPipeline

# 设置随机数种子
torch.manual_seed(1)

# 加载预训练的 StableDiffusion 模型
pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v-1-4", torch_dtype=torch.float16)

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

# 定义提示
prompt = "二次元，一个紫色长发小女孩穿着粉色吊带漏肩连衣裙，在练习室练习唱歌，手持话筒"

# 定义负面提示
negative_prompt = "丑陋、变形、嘈杂、模糊、低对比度"

# 设置引导比例和推理步骤数量
guidance_scale = 4
num_inference_steps = 50

# 生成图像
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

# 重复上述过程，生成更多图像并保存
# ...

# 导入 numpy 和 PIL
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)  # 垂直拼接所有水平拼接后的图像

# 将合并后的图像转换为 PIL.Image 对象并调整大小
image = Image.fromarray(image).resize((1024, 2048))

# 显示合并后的图像
image

这段代码执行了以下操作：

1. 安装和卸载软件包：

   • 安装 simple-aesthetics-predictor、data-juicer、peft、lightning、pandas 和 torchvision 软件包，并卸载然后重新安装 pytorch-lightning。
   • 在可编辑模式下安装 DiffSynth-Studio。

2. 加载和处理数据：

   • 从 ModelScope 加载了一个动漫数据集。
   • 将数据集中的图像保存到磁盘，并创建了一个 JSONL 文件，其中包含图像路径和对应的文本描述。

3. 使用 Data-Juicer 过滤数据：

   • 使用 Data-Juicer 对图像进行过滤，确保它们满足特定的尺寸和宽高比要求。
   • 过滤后的结果被保存为 JSONL 文件。

4. 创建 DataFrame 并使用 CLIP 模型处理数据：

   • 从经过 Data-Juicer 处理的数据集中创建了一个 Pandas DataFrame。
   • 使用 CLIP 模型对图像和文本进行编码，并计算图像与文本之间的相似度分数。

5. 创建 PyTorch 数据集：

   • 创建了一个自定义的 PyTorch 数据集类，并用其加载数据。
   • 使用 DataLoader 来批量加载数据并再次通过 CLIP 模型进行处理。

6. 生成图像：

   • 使用 StableDiffusionPipeline 根据不同的提示生成了一系列的二次元风格图像，并保存到了磁盘上。

7. 合并生成的图像：

   • 最后将生成的八张图像合并成一张大图，并调整大小以适应展示。

代码分析

• 数据准备：

  • 从 ModelScope 下载数据集，并将图像文件保存到指定目录。
  • 创建一个 JSONL 文件，每行包含图像的路径和描述性文本。

• Data-Juicer 配置：

  • 设置 Data-Juicer 配置文件来过滤图像，只保留宽度和高度至少为 1024 像素且宽高比在 0.5 到 2.0 之间的图像。
  • 运行 Data-Juicer 过程以应用这些过滤条件，并输出结果。

• 使用 CLIP 模型：

  • 使用 CLIP 模型计算图像和文本之间的相似度。
  • 创建 PyTorch 数据集和 DataLoader，以便更高效地处理数据。

• 使用 StableDiffusionPipeline 生成图像：

  • 根据不同的提示生成一系列图像，每个提示都描述了一个二次元场景。
  • 通过设置种子来控制随机性，确保每次运行时生成相同的图像。

• 合并图像：

  • 使用 NumPy 和 PIL 库将多个单独的图像合并成一张大图像。

二、借用AI生成prompt

还是利用通义千问，给出具体场景要求让其生成详细prompt

图片编号	场景描述	正向提示词	反向提示词
图 1	女主正在上课	童话风格，教室，金色长发少女，认真听课, 手上拿着笔，身着红色鲜艳的校服，上半身，正面，坐在课桌前	丑陋，变形，嘈杂，模糊，低对比度
图 2	开始睡着了	童话风格，教室，金色长发少女，闭上眼睛,身着红色鲜艳的校服，上半身，正面，坐在课桌前	丑陋，变形，嘈杂，模糊，低对比度
图 3	进入梦乡，梦到自己在森林	童话风格，四周全是茂密的森林，金色长发少女，站白色长裙，上半身，看向远方	丑陋，变形，嘈杂，模糊，低对比度
图 4	王子骑马而来	童话风格，四周全是茂密的森林，一位英俊的王子，骑着白马，上半身	丑陋，变形，嘈杂，模糊，低对比度
图 5	两人相谈甚欢	童话风格，四周全是茂密的森林，金色长发少女，一位英俊的王子，白色长裙，两个人一起聊天，开心，上半身	丑陋，变形，嘈杂，模糊，低对比度
图 6	两人一起跳舞	童话风格，四周全是茂密的森林，金色长发少女，白色长裙，一位英俊的王子，两个人一起跳舞，全身	丑陋，变形，嘈杂，模糊，低对比度
图 7	下课了，梦醒了	童话风格，教室，金色长发少女，用右手揉眼睛，左手拿笔，闭上眼睛,身着红色鲜艳的校服，上半身，正面，坐在课桌前	丑陋，变形，嘈杂，模糊，低对比度
图 8	又回到了学习生活中	童话风格，教室，金色长发少女，惊醒, 惊讶，身着红色鲜艳的校服，上半身，正面，坐在课桌前，墙上有下课铃	丑陋，变形，嘈杂，模糊，低对比度

 替换原来的prompt生成图像，结果如下：