当前位置：AIGC资讯 > AIGC > 正文

【Datawhale X 魔搭 AI夏令营】第四期 AIGC方向 学习笔记

零基础30分钟速通文生图

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

1、开通阿里云免费试用

链接：https://free.aliyun.com/?productCode=learn

2、在魔搭社区进行授权

链接：https://www.modelscope.cn/my/mynotebook/authorization

新用户注册后还需绑定阿里云账号

 二、在魔搭社区创建PAI实例

链接：https://www.modelscope.cn/my/mynotebook/authorization

三、体验baseline 

1、下载baseline文件

git lfs install
git clone https://www.modelscope.cn/datasets/maochase/kolors.git

2、进入kolors文件夹，打开baseline文件

3、安装 Data-Juicer 和 DiffSynth-Studio 

4、调整prompt

prompt：你想要生成的图片应该包含的内容

negative_prompt：你不希望生成的图片的内容

5、一键运行代码 

四、微调结果上传魔搭

1、移动结果文件

打开terminal，运行下面的命令

mkdir /mnt/workspace/kolors/output & cd 
cp /mnt/workspace/kolors/models/lightning_logs/version_0/checkpoints/epoch\=0-step\=500.ckpt /mnt/workspace/kolors/output/
cp /mnt/workspace/kolors/1.jpg /mnt/workspace/kolors/output/

2、将结果文件保存到本地

3、创建并上传模型

完成后关闭PAI实例即可。

baseline代码分析

1、下载数据集

from modelscope.msdatasets import MsDataset

ds = MsDataset.load(
    'AI-ModelScope/lowres_anime',
    subset_name='default',
    split='train',
    cache_dir="/mnt/workspace/kolors/data"
)

这段代码是用于加载一个名为"AI-ModelScope/lowres_anime"的数据集，并将其存储在变量ds中。这个数据集来自于ModelScope平台，它是一个开源的机器学习模型库，提供了各种预训练模型和数据集供用户使用。代码中的MsDataset.load()函数用于加载数据集。它接受以下参数：

1、'AI-ModelScope/lowres_anime'：数据集的名称，这里是低分辨率动漫图像数据集。

2、subset_name：数据集的子集名称，默认为'default'。

3、split：指定加载数据集的训练集。还可以选择其他选项，如'test'或'validation'。

4、cache_dir：缓存目录，用于存储下载的数据集文件。如果已经下载过数据集，它将从该目录中加载数据，而不是重新下载。

2、保存数据集中的图片及元数据

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")

这段代码主要用于将数据集中的图像数据保存到指定的文件夹，并将相关的元数据信息写入到一个JSONL文件中。具体步骤如下：

1、导入所需的库：json用于处理JSON格式的数据，os用于操作文件和目录，data_juicer.utils.mm_utils中的SpecialTokens用于处理特殊字符，tqdm用于显示进度条。

2、创建两个目录：./data/lora_dataset/train用于存储图像数据，./data/data-juicer/input用于存储元数据信息。

3、打开一个名为metadata.jsonl的文件，以写入模式。

4、遍历数据集ds，对于每个数据项：将图像转换为RGB格式并保存到./data/lora_dataset/train目录下，文件名为{data_id}.jpg。再创建一个包含文本和图像路径的字典metadata。最后将metadata字典转换为JSON格式的字符串，并写入到metadata.jsonl文件中，每个条目占一行。

3、使用 data-juicer 处理数据

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())

这段代码定义了一个名为data_juicer_config的字符串，其中包含了一个YAML格式的配置信息。这个配置信息主要用于数据预处理，包括项目名称、数据集路径、子进程数量、文本键、图像键、图像特殊标记、导出路径以及处理计划等。处理计划中包含了两个过滤器：image_shape_filter和image_aspect_ratio_filter，分别用于过滤图像的形状和宽高比。

4、保存处理好的数据

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

这段代码主要用于处理result.jsonl文件，并将其中的文本和图像数据提取出来，然后保存到一个新的文件夹中。具体步骤如下：

1、导入所需的库：pandas（用于数据处理），os（用于文件操作），json（用于解析JSON数据），PIL（用于处理图像）和tqdm（用于显示进度条）。

2、创建一个名为"lora_dataset_processed/train"的文件夹，如果该文件夹已存在，则不会报错。

3、打开data-juicer/output/result.jsonl文件，并逐行读取其中的数据。

4、对于每一行数据，使用json.loads()将其解析为Python字典。

5、从字典中提取"text"字段的值，并将其添加到texts列表中。

6、使用PIL库打开字典中"image"字段的第一个元素所表示的图像文件，并将其保存到"lora_dataset_processed/train"文件夹下，文件名为当前数据的索引值加上".jpg"后缀。

7、将保存的图像文件名添加到file_names列表中。

8、创建一个空的pandas DataFrame，并将file_names和texts列表分别作为"file_name"和"text"列添加到DataFrame中。

8、将DataFrame保存为CSV文件，命名为"metadata.csv"，并存储在"lora_dataset_processed/train"文件夹下。

5、下载模型

from diffsynth import download_models

download_models(["Kolors", "SDXL-vae-fp16-fix"])

diffsynth提供了一些预训练的模型。在这个例子中，我们使用diffsynth库中的download_models函数来下载指定的模型。

download_models函数接受一个模型名称列表作为参数，然后从远程服务器下载这些模型到本地。在这个例子中，我们下载了两个模型："Kolors"和"SDXL-vae-fp16-fix"。

6、开始训练

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)

这段代码是用于在Python中执行一个外部命令的。具体来说，它使用os.system()函数来运行一个包含多个参数的命令行命令。

7、加载模型

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"
)

这段代码主要实现了加载LoRA（Low-Rank Adaptation）模型的功能。LoRA是一种轻量级的模型微调方法，通过在原有模型的基础上添加低秩矩阵来调整模型的权重，从而使得模型能够更好地适应特定的任务。

代码首先导入了所需的库和模块，包括diffsynth中的ModelManager和SDXLImagePipeline，以及peft中的LoraConfig和inject_adapter_in_model。然后定义了一个名为load_lora的函数，该函数接受一个模型、LoRA的秩（rank）、LoRA的alpha值和LoRA模型的路径作为输入参数，返回加载了LoRA权重的模型。

接下来，代码创建了一个ModelManager实例，用于加载预训练的Kolors模型。然后使用SDXLImagePipeline.from_model_manager方法从ModelManager实例中创建一个图像处理管道。最后，使用load_lora函数加载LoRA权重到UNet模型中。

8、prompt微调

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")

这几段代码均是使用Python的PyTorch库进行深度学习模型推理的示例。它使用了torch.manual_seed(0)来设置随机数生成器的种子，以确保实验的可重复性。接下来，调用pipe函数，该函数是一个自定义的函数，用于处理图像生成任务。传递给pipe函数的参数包括：

1、prompt：一个描述图像内容的字符串。

2、negative_prompt：一个描述不希望出现在图像中的内容的字符串。

3、cfg_scale：一个控制生成图像质量的参数，数值越大，生成的图像质量越高。

4、num_inference_steps：推理过程中的迭代次数，数值越大，生成的图像越精细。

5、height和width：生成图像的高度和宽度。

通过调整prompt可以生成自己想要的图片，prompt越详细，生成的图片越准确。

9、生成图片

最后，将生成的图像保存

import numpy as np
from PIL import Image


images = [np.array(Image.open(f"{i}.jpg")) for i in range(1, 5)]
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

这段代码的主要功能是将四张图片拼接成一张新的图片。

首先，导入所需的库：numpy和PIL（Python Imaging Library）。使用列表推导式，将四张名为"1.jpg"、"2.jpg"、"3.jpg"、“4.jpg”的图片分别读取为numpy数组，并将它们存储在名为images的列表中。使用numpy的concatenate函数，将这四张图片按照指定的轴（axis）进行拼接。这里分为两步：第一步，将前两张图片沿着水平方向（axis=1）拼接在一起。第二步，将后两张图片也沿着水平方向拼接在一起。接着，将这两组拼接后的图片沿着垂直方向（axis=0）拼接在一起，得到一张完整的大图。最后，将拼接好的numpy数组转换回PIL图像对象，并调整其大小为1024x2048像素。

10、生成结果

总结

这个链接可能存在安全风险，为了保护您的设备和数据安全，请避免访问此链接。
koljsonprompt数据集sdxltpu文件夹pytorchnumpy二次元pythoncodecsvdiffusionfixgit元数据token预训练pandas

更新时间 2024-09-08