空白诗007

这个屌丝很懒，什么也没留下！

热门标签

Datawhale X 魔搭 AI夏令营第四期魔搭-AIGC文生图方向Task1笔记_simple-aesthetics-predictor

作者：空白诗007 | 2024-08-15 07:50:25

踩

simple-aesthetics-predictor

（赛题链接：可图Kolors-LoRA风格故事挑战赛_创新应用大赛_天池大赛）

（学习链接：‌‍‍‬⁠‍‬‌‌‌⁠‌‍‬‬‬‬‍⁠‍从零入门AI生图原理&实践）

速通指南

1、开通阿里云PAI-DSW试用

（阿里云链接：阿里云免费试用）

最后使用成功，关闭即可

2、在魔搭社区进行授权

（ps：据说在阿里云网站也可以找到运行的地方，可以不用去魔搭社区，魔搭社区可能会在使用高峰期流量过大而加载很慢，想要探索一下的小伙伴可以去找找阿里云的，启动速度会比魔搭要快的，但是整体的运行还是和魔搭社区同步的，以下附上简易版阿里云进入途径）

（魔搭链接：我的Notebook · 魔搭社区）

（ps：如果5000小时试用已经过期了可使用魔搭的免费Notebook实例，如下）

如果Notebook的试用也用完了，那就只能付费使用阿里云了，暂时没有别的解决方法

3、跑通baseline

然后依次点击每一个模块的运行按钮（第一次的时候要这样，后面就可以直接点击>>按钮一键运行了）

提交的时候，这个基础模型三个都可选噢~

赛题解读

1、赛题内容

2、作品提交

（模型上传链接：魔搭模型库和 LoRA 上传地址）

（作品发布链接：比赛品牌馆讨论区）

3、评分标准

Baseline代码解读

1、环境安装


!pip install simple-aesthetics-predictor
!pip install -v -e data-juicer
!pip uninstall pytorch-lightning -y
!pip install peft lightning pandas torchvision
!pip install -e DiffSynth-Studio

!符号用于在Jupyter Notebook或IPython环境中执行系统命令。
-v标志表示安装时显示详细信息（verbose mode），-e标志表示通过编辑模式（editable mode）安装。在编辑模式下安装的包将链接到当前的开发环境，使得对包的修改能够即时生效。
卸载名为pytorch-lightning的Python包，并通过-y标志自动确认卸载过程中的所有提示。
peft: 一个用于性能评估的工具。

2、下载数据集


#下载数据集
from modelscope.msdatasets import MsDataset
 
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)
os.makedirs("./data/data-juicer/input", exist_ok=True)
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")

使用了 MsDataset 类从指定的数据集加载数据。具体来说：
- 'AI-ModelScope/lowres_anime' 是数据集的名称或标识符。
- split='train' 表示加载训练集部分的数据。
- cache_dir="/mnt/workspace/kolors/data" 是数据集的缓存目录，数据集可能会在此处进行下载或存储。
os.makedirs 函数创建目录：
- ./data/lora_dataset/train：存储训练集图像的目录。
- ./data/data-juicer/input：存储数据预处理输入文件的目录。
open("./data/data-juicer/input/metadata.jsonl", "w") as f 打开文件 metadata.jsonl 用于写入数据预处理后的元数据，jsonl 文件格式是每行一个 JSON 对象，适合存储和处理大型数据集的元数据。
for data_id, data in enumerate(tqdm(ds)): 迭代数据集中的每个数据项：
- data["image"].convert("RGB") 将图像数据转换为RGB格式。
- image.save(f"/mnt/workspace/kolors/data/lora_dataset/train/{data_id}.jpg") 将处理后的图像保存到 ./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)) 将元数据以 JSON 格式写入 metadata.jsonl 文件。

3、处理数据集，保存数据处理结果


data_juicer_config = """
# global parameters
project_name: 'data-process'
dataset_path: './data/data-juicer/input/metadata.jsonl'  # path to your dataset directory or file
np: 4  # number of subprocess to process your dataset
text_keys: 'text'
image_key: 'image'
image_special_token: '<__dj__image>'
export_path: './data/data-juicer/output/result.jsonl'
# process schedule
# a list of several process operators with their arguments
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
"""
with open("data/data-juicer/data_juicer_config.yaml", "w") as file:
    file.write(data_juicer_config.strip())
 
!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
 
 
texts, file_names = [], []
os.makedirs("./data/lora_dataset_processed/train", exist_ok=True)
with open("./data/data-juicer/output/result.jsonl", "r") as file:
    for data_id, data in enumerate(tqdm(file.readlines())):
        data = json.loads(data)
        text = data["text"]
        texts.append(text)
        image = Image.open(data["image"][0])
        image_path = f"./data/lora_dataset_processed/train/{data_id}.jpg"
        image.save(image_path)
        file_names.append(f"{data_id}.jpg")
data_frame = pd.DataFrame()
data_frame["file_name"] = file_names
data_frame["text"] = texts
data_frame.to_csv("./data/lora_dataset_processed/train/metadata.csv", index=False, encoding="utf-8-sig")
data_frame

（1）配置说明

data_juicer_config 是一个YAML格式的字符串，定义了数据处理的各种参数和操作流程。
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：过滤图像尺寸，保留宽度和高度均大于等于 1024 像素的图像。
- image_aspect_ratio_filter：过滤图像宽高比，保留宽高比在 0.5 到 2.0 之间的图像。

（2）执行说明

!dj-process 是一个命令行工具，用于执行数据处理任务。
--config data/data-juicer/data_juicer_config.yaml 指定了配置文件的路径，告诉命令行工具按照配置文件中定义的流程处理数据。

（3）处理说明

os.makedirs("./data/lora_dataset_processed/train", exist_ok=True) 创建存储处理后数据的目录 ./data/lora_dataset_processed/train。
打开处理后的数据文件 ./data/data-juicer/output/result.jsonl，逐行读取每条数据

（4）保存数据

创建一个空的 Pandas 数据框 data_frame。
将 file_names 列和 texts 列添加到数据框中。
使用 to_csv 方法将数据框保存为 CSV 文件 ./data/lora_dataset_processed/train/metadata.csv，编码为 utf-8-sig，并且不包含行索引。

4、Lora微调


# 下载模型
from diffsynth import download_models
download_models(["Kolors", "SDXL-vae-fp16-fix"])
 
#模型训练
import os
 
cmd = """
python DiffSynth-Studio/examples/train/kolors/train_kolors_lora.py \
  --pretrained_unet_path models/kolors/Kolors/unet/diffusion_pytorch_model.safetensors \
  --pretrained_text_encoder_path models/kolors/Kolors/text_encoder \
  --pretrained_fp16_vae_path models/sdxl-vae-fp16-fix/diffusion_pytorch_model.safetensors \
  --lora_rank 16 \
  --lora_alpha 4.0 \
  --dataset_path data/lora_dataset_processed \
  --output_path ./models \
  --max_epochs 1 \
  --center_crop \
  --use_gradient_checkpointing \
  --precision "16-mixed"
""".strip()
 
os.system(cmd)

download_models(["Kolors", "SDXL-vae-fp16-fix"])：这行代码调用了 diffsynth 库中的 download_models 函数，用于下载指定的模型。
- "Kolors" 是要下载的第一个模型的标识符。
- "SDXL-vae-fp16-fix" 是要下载的第二个模型的标识符。
模型训练说明
- cmd 是一个包含要执行的命令的字符串变量，这个命令将在操作系统的 shell 中运行。
- --pretrained_unet_path models/kolors/Kolors/unet/diffusion_pytorch_model.safetensors：指定预训练的 U-Net 模型路径。
- --pretrained_text_encoder_path models/kolors/Kolors/text_encoder：指定预训练的文本编码器路径。
- --pretrained_fp16_vae_path models/sdxl-vae-fp16-fix/diffusion_pytorch_model.safetensors：指定预训练的半精度 VAE 模型路径。
- --lora_rank 16：设置 Lora 模型的秩为 16。
- --lora_alpha 4.0：设置 Lora 模型的 alpha 参数为 4.0。
- --dataset_path data/lora_dataset_processed：指定训练数据集的路径。
- --output_path ./models：指定模型训练结果输出的路径。
- --max_epochs 1：设置最大训练轮数为 1。
- --center_crop：使用中心裁剪图像。
- --use_gradient_checkpointing：使用梯度检查点技术。
- --precision "16-mixed"：设置训练精度为混合精度 16 位。
os.system(cmd)：通过操作系统的 shell 执行存储在cmd变量中的命令。

5、加载微调好的模型


from diffsynth import ModelManager, SDXLImagePipeline
from peft import LoraConfig, inject_adapter_in_model
import torch
 
 
def load_lora(model, lora_rank, lora_alpha, lora_path):
    lora_config = LoraConfig(
        r=lora_rank,
        lora_alpha=lora_alpha,
        init_lora_weights="gaussian",
        target_modules=["to_q", "to_k", "to_v", "to_out"],
    )
    model = inject_adapter_in_model(lora_config, model)
    state_dict = torch.load(lora_path, map_location="cpu")
    model.load_state_dict(state_dict, strict=False)
    return model
 
 
# Load models
model_manager = ModelManager(torch_dtype=torch.float16, device="cuda",
                             file_path_list=[
                                 "models/kolors/Kolors/text_encoder",
                                 "models/kolors/Kolors/unet/diffusion_pytorch_model.safetensors",
                                 "models/kolors/Kolors/vae/diffusion_pytorch_model.safetensors"
                             ])
pipe = SDXLImagePipeline.from_model_manager(model_manager)
 
# Load LoRA
pipe.unet = load_lora(
    pipe.unet,
    lora_rank=16, # This parameter should be consistent with that in your training script.
    lora_alpha=2.0, # lora_alpha can control the weight of LoRA.
    lora_path="models/lightning_logs/version_0/checkpoints/epoch=0-step=500.ckpt"
)

（1）导入所需的库和模块

diffsynth：包含了模型管理和图像处理流水线的相关功能。

（2）定义加载LoRA模型的函数

model：要加载 LoRA 的模型。
lora_rank：LoRA 的秩（rank）参数，影响适配器层的维度。
lora_alpha：LoRA 的 alpha 参数，用于控制 LoRA 适配器的权重。
lora_path：LoRA 模型的路径，即预训练模型的权重文件路径。
LoraConfig：使用 peft 库中的 LoraConfig 类来配置 LoRA 的参数，包括秩、alpha 值、初始化权重方式和目标模块。
inject_adapter_in_model：通过 peft 库中的 inject_adapter_in_model 函数将 LoRA 适配器注入到模型中。
torch.load(lora_path, map_location="cpu")：加载预训练的 LoRA 模型的权重。
model.load_state_dict(state_dict, strict=False)：将加载的权重应用到模型中，strict=False 表示允许部分加载。

（3）加载模型和应用LoRA

ModelManager：使用 diffsynth 中的 ModelManager 类来管理模型，指定了模型的数据类型为 torch.float16，设备为 "cuda"（GPU）。
file_path_list：指定了需要加载的模型文件的路径列表，包括文本编码器、U-Net 和 VAE 模型。
SDXLImagePipeline.from_model_manager(model_manager)：使用 ModelManager 创建 SDXLImagePipeline，这是一个图像处理流水线，用于处理图像数据。
pipe.unet = load_lora(...)：调用之前定义的 load_lora 函数，将加载的 LoRA 模型应用到 SDXLImagePipeline 的 U-Net 模型 (pipe.unet) 上。

6、图片生成


torch.manual_seed(0)
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）图片生成模块

每个 torch.manual_seed(x) 设置了一个特定的随机种子，确保每次生成的图像是确定性的。这在生成对比图时很有用。
使用 pipe 对象生成图像：
- pipe 是一个 SDXLImagePipeline 对象，用于处理图像生成任务。
- prompt 参数包含了描述图像内容的文本。
- negative_prompt 是描述不希望出现在图像中的内容。
- cfg_scale=4 是指定了图像生成的缩放因子。
- num_inference_steps=50 指定了生成图像的推断步数。
- height=1024, width=1024 指定了生成图像的高度和宽度。
每次生成的图像都使用 image.save("X.jpg") 进行保存，其中 X 是保存的文件名，依次为 1.jpg 到 8.jpg。