AI大模型教程
一起来学习
当前位置：5bei.cn大模型教程网 > AI创作 > 正文

Datawhale X 魔搭 AI夏令营AIGC方向task3

2025-06-22 分类：AI创作 阅读(186)

ComfyUI 样例

下载并安装 ComfyUI

# #@title Environment Setup

from pathlib import Path

OPTIONS = {}
UPDATE_COMFY_UI = True  #@param {type:”boolean”}
INSTALL_COMFYUI_MANAGER = True  #@param {type:”boolean”}
INSTALL_KOLORS = True  #@param {type:”boolean”}
INSTALL_CUSTOM_NODES_DEPENDENCIES = True  #@param {type:”boolean”}
OPTIONS[‘UPDATE_COMFY_UI’] = UPDATE_COMFY_UI
OPTIONS[‘INSTALL_COMFYUI_MANAGER’] = INSTALL_COMFYUI_MANAGER
OPTIONS[‘INSTALL_KOLORS’] = INSTALL_KOLORS
OPTIONS[‘INSTALL_CUSTOM_NODES_DEPENDENCIES’] = INSTALL_CUSTOM_NODES_DEPENDENCIES

current_dir = !pwd
WORKSPACE = f”{current_dir[0]}/ComfyUI”

%cd /mnt/workspace/

![ ! -d $WORKSPACE ] && echo -= Initial setup ComfyUI =- && git clone https://github.com/comfyanonymous/ComfyUI
%cd $WORKSPACE

if OPTIONS[‘UPDATE_COMFY_UI’]:
  !echo “-= Updating ComfyUI =-“
  !git pull

if OPTIONS[‘INSTALL_COMFYUI_MANAGER’]:
  %cd custom_nodes
  ![ ! -d ComfyUI-Manager ] && echo -= Initial setup ComfyUI-Manager =- && git clone https://github.com/ltdrdata/ComfyUI-Manager
  %cd ComfyUI-Manager
  !git pull

if OPTIONS[‘INSTALL_KOLORS’]:
  %cd ../
  ![ ! -d ComfyUI-KwaiKolorsWrapper ] && echo -= Initial setup KOLORS =- && git clone https://github.com/kijai/ComfyUI-KwaiKolorsWrapper.git
  %cd ComfyUI-KwaiKolorsWrapper
  !git pull

%cd $WORKSPACE

if OPTIONS[‘INSTALL_CUSTOM_NODES_DEPENDENCIES’]:
  !pwd
  !echo “-= Install custom nodes dependencies =-“
  ![ -f “custom_nodes/ComfyUI-Manager/scripts/colab-dependencies.py” ] && python “custom_nodes/ComfyUI-Manager/scripts/colab-dependencies.py”

!wget “https://modelscope.oss-cn-beijing.aliyuncs.com/resource/cloudflared-linux-amd64.deb”
!dpkg -i cloudflared-linux-amd64.deb

下载模型

#@markdown ###Download standard resources

OPTIONS = {}

#@markdown **unet**

!wget -c “https://modelscope.cn/models/Kwai-Kolors/Kolors/resolve/master/unet/diffusion_pytorch_model.fp16.safetensors” -P ./models/diffusers/Kolors/unet/
!wget -c “https://modelscope.cn/models/Kwai-Kolors/Kolors/resolve/master/unet/config.json” -P ./models/diffusers/Kolors/unet/

#@markdown **encoder**

!modelscope download –model=ZhipuAI/chatglm3-6b-base –local_dir ./models/diffusers/Kolors/text_encoder/

#@markdown **vae**

!wget -c “https://modelscope.cn/models/AI-ModelScope/sdxl-vae-fp16-fix/resolve/master/sdxl.vae.safetensors” -P ./models/vae/ #sdxl-vae-fp16-fix.safetensors

#@markdown **scheduler**
!wget -c “https://modelscope.cn/models/Kwai-Kolors/Kolors/resolve/master/scheduler/scheduler_config.json” -P ./models/diffusers/Kolors/scheduler/

#@markdown **modelindex**
!wget -c “https://modelscope.cn/models/Kwai-Kolors/Kolors/resolve/master/model_index.json” -P ./models/diffusers/Kolors/

安装 LoRA 节点

lora_node = “””
import torch
from peft import LoraConfig, inject_adapter_in_model

class LoadKolorsLoRA:
    @classmethod
    def INPUT_TYPES(s):
        return {
            “required”: {
                “kolors_model”: (“KOLORSMODEL”, ),
                “lora_path”: (“STRING”, {“multiline”: False, “default”: “”,}),
                “lora_alpha”: (“FLOAT”, {“default”: 2.0, “min”: 0.0, “max”: 4.0, “step”: 0.01}),
            },
        }

    RETURN_TYPES = (“KOLORSMODEL”,)
    RETURN_NAMES = (“kolors_model”,)
    FUNCTION = “add_lora”
    CATEGORY = “KwaiKolorsWrapper”

    def convert_state_dict(self, state_dict):
        prefix_rename_dict = {
            “blocks.7.transformer_blocks”: “down_blocks.1.attentions.0.transformer_blocks”,
            “blocks.10.transformer_blocks”: “down_blocks.1.attentions.1.transformer_blocks”,
            “blocks.15.transformer_blocks”: “down_blocks.2.attentions.0.transformer_blocks”,
            “blocks.18.transformer_blocks”: “down_blocks.2.attentions.1.transformer_blocks”,
            “blocks.21.transformer_blocks”: “mid_block.attentions.0.transformer_blocks”,
            “blocks.25.transformer_blocks”: “up_blocks.0.attentions.0.transformer_blocks”,
            “blocks.28.transformer_blocks”: “up_blocks.0.attentions.1.transformer_blocks”,
            “blocks.31.transformer_blocks”: “up_blocks.0.attentions.2.transformer_blocks”,
            “blocks.35.transformer_blocks”: “up_blocks.1.attentions.0.transformer_blocks”,
            “blocks.38.transformer_blocks”: “up_blocks.1.attentions.1.transformer_blocks”,
            “blocks.41.transformer_blocks”: “up_blocks.1.attentions.2.transformer_blocks”,
        }
        suffix_rename_dict = {
            “.to_out.lora_A.default.weight”: “.to_out.0.lora_A.default.weight”,
            “.to_out.lora_B.default.weight”: “.to_out.0.lora_B.default.weight”,
        }
        state_dict_ = {}
        for name, param in state_dict.items():
            for prefix in prefix_rename_dict:
                if name.startswith(prefix):
                    name = name.replace(prefix, prefix_rename_dict[prefix])
            for suffix in suffix_rename_dict:
                if name.endswith(suffix):
                    name = name.replace(suffix, suffix_rename_dict[suffix])
            state_dict_[name] = param
        lora_rank = state_dict_[“up_blocks.1.attentions.2.transformer_blocks.1.attn2.to_q.lora_A.default.weight”].shape[0]
        return state_dict_, lora_rank

    def load_lora(self, model, lora_rank, lora_alpha, state_dict):
        lora_config = LoraConfig(
            r=lora_rank,
            lora_alpha=lora_alpha,
            init_lora_weights=”gaussian”,
            target_modules=[“to_q”, “to_k”, “to_v”, “to_out.0”],
        )
        model = inject_adapter_in_model(lora_config, model)
        model.load_state_dict(state_dict, strict=False)
        return model

    def add_lora(self, kolors_model, lora_path, lora_alpha):
        state_dict = torch.load(lora_path, map_location=”cpu”)
        state_dict, lora_rank = self.convert_state_dict(state_dict)
        kolors_model[“pipeline”].unet = self.load_lora(kolors_model[“pipeline”].unet, lora_rank, lora_alpha, state_dict)
        return (kolors_model,)

NODE_CLASS_MAPPINGS = {
    “LoadKolorsLoRA”: LoadKolorsLoRA,
}
NODE_DISPLAY_NAME_MAPPINGS = {
    “LoadKolorsLoRA”: “Load Kolors LoRA”,
}
__all__ = [“NODE_CLASS_MAPPINGS”, “NODE_DISPLAY_NAME_MAPPINGS”]
“””.strip()

import os

os.makedirs(“/mnt/workspace/ComfyUI/custom_nodes/ComfyUI-LoRA”, exist_ok=True)
with open(“/mnt/workspace/ComfyUI/custom_nodes/ComfyUI-LoRA/__init__.py”, “w”, encoding=”utf-8″) as f:
    f.write(lora_node)

启动 ComfyUI

  • 启动后，通过代码输出的链接查看 UI 页面
  • 点击右侧“Load”，加载“kolors_example.json”（不带 LoRA）或者 “kolors_with_lora_example.json”（带 LoRA）
  • 加载 LoRA 时，请在“lora_path”处填入 LoRA 模型的路径，例如 /mnt/workspace/models/lightning_logs/version_0/checkpoints/epoch=0-step=500.ckpt

  • %cd /mnt/workspace/ComfyUI
    import subprocess
    import threading
    import time
    import socket
    import urllib.request

    def iframe_thread(port):
      while True:
          time.sleep(0.5)
          sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
          result = sock.connect_ex(('127.0.0.1', port))
          if result == 0:
            break
          sock.close()
      print("nComfyUI finished loading, trying to launch cloudflared (if it gets stuck here cloudflared is having issues)n")

      p = subprocess.Popen(["cloudflared", "tunnel", "--url", "http://127.0.0.1:{}".format(port)], stdout=subprocess.PIPE, stderr=subprocess.PIPE)
      for line in p.stderr:
        l = line.decode()
        if "trycloudflare.com " in l:
          print("This is the URL to access ComfyUI:", l[l.find("http"):], end='')
        #print(l, end='')

    threading.Thread(target=iframe_thread, daemon=True, args=(8188,)).start()

    !python main.py --dont-print-server

文章来源于互联网:Datawhale X 魔搭 AI夏令营AIGC方向task3

相关推荐: 杭州php开发 ai写作

杭州PHP开发：构建高效网站的基石 一、 了解PHP基础概念。首先需要掌握的是PHP的基本语法和结构，包括变量定义、数据类型、流程控制语句等。 学习如何搭建PHP环境。通常我们会选择XAMPP或者WAMP这样的集成环境来快速配置好Apache服务器+MySQL…

赞(0)
未经允许不得转载：5bei.cn大模型教程网 » Datawhale X 魔搭 AI夏令营AIGC方向task3

Datawhale X 魔搭 AI夏令营 AIGC方向 task2笔记

2025-03-14 分类：AI创作 阅读(70)

     纯小白，自学！从零入门AI生图（AIGC方向）基于魔搭社区“可图Kolors-LoRA风格故事挑战赛”开展实践学习。#Datawhale X 魔搭 AI夏令营#

一、利用AI精读baseline学习代码

     task2的目的是精读baseline，从代码层面理解AI生图，直播演示了用通义千问解析代码，我也用GPT-4o,文心一言解析代码，看看区别。

    这个是文生图代码的框架结构：

baseline中的所有代码：

!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

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

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: ''

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/data-juicer/output/images", exist_ok=True)
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)

df

from transformers import CLIPProcessor, CLIPModel
import torch

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
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  # this is the image-text similarity score
probs = logits_per_image.softmax(dim=1)  # we can take the softmax to get the probabilities

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

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

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. 分析代码的主体架构

  2. GPT、文心一言输入的Prompt

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

    GPT的分析：

这个代码可以分为几个主要的工作流程部分，每个部分的作用如下：

### 1. **环境准备和依赖安装**
   – 安装所需的Python库和依赖。

!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

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

### 3. **数据过滤与配置**
   – 配置数据过滤器，对生成的图像数据进行尺寸和比例过滤。

data_juicer_config = """
# global parameters
project_name: 'data-process'
dataset_path: './data/data-juicer/input/metadata.jsonl'
np: 4

text_keys: 'text'
image_key: 'image'
image_special_token: ''

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

# process schedule
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

### 4. **结果处理与导出**
   – 处理过滤后的数据，并将结果保存为CSV文件。

import pandas as pd
import os, json
from PIL import Image
from tqdm import tqdm

texts, file_names = [], []
os.makedirs("./data/data-juicer/output/images", exist_ok=True)
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)

df

### 5. **CLIP模型推理**
   – 使用CLIP模型进行图像和文本的相似度计算。

from transformers import CLIPProcessor, CLIPModel
import torch

model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32")
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

### 6. **自定义数据集与批量处理**
   – 定义自定义数据集类，并使用DataLoader进行批量数据处理。
   

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)

### 7. **Stable Diffusion生成图像**
   – 使用Stable Diffusion生成高分辨率的二次元图像。

import torch
from diffusers import StableDiffusionPipeline

torch.manual_seed(1)
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

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

### 8. **拼接图像**
   – 将生成的多张图像拼接成一张大图。

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. 环境配置与依赖安装：

    • 使用pip命令安装和卸载必要的Python库，包括simple-aesthetics-predictor、data-juicer（以可编辑模式安装）、peft、lightning、pandas、torchvision和DiffSynth-Studio。
    • 卸载pytorch-lightning库，避免版本冲突。
  2. 数据准备：

    • 使用modelscope.msdatasets从AI-ModelScope加载低分辨率动漫数据集，并指定缓存目录。
    • 创建数据目录结构，将加载的数据集图片保存到指定路径，并生成对应的元数据文件（metadata.jsonl），包含图片路径和文本标签。
  3. 数据预处理：

    • 编写data_juicer配置文件，定义数据处理的参数和流程，如图片尺寸和宽高比过滤。
    • 使用dj-process命令和配置文件对数据进行预处理，生成过滤后的结果集。
  4. 数据处理与CSV导出：

    • 从预处理结果中读取元数据，将文本和图片路径信息提取出来，保存到Pandas DataFrame中。
    • 将DataFrame导出为CSV文件，方便后续处理。
  5. 图像文本相似度评估：

    • 加载CLIP模型和处理器，用于计算图像和文本之间的相似度。
    • 使用CLIP模型对预处理后的数据集进行图像和文本的相似度评估，并打印结果。
  6. 自定义数据集与数据加载：

    • 定义了一个继承自torch.utils.data.Dataset的CustomDataset类，用于加载自定义的图像和文本数据。
    • 实例化CustomDataset并使用DataLoader进行批量加载，以便在训练或评估中使用。
  7. 图像生成：

    • 使用StableDiffusionPipeline从diffusers库生成基于给定提示（prompt）的图像。
    • 通过调整不同的提示、负向提示（negative_prompt）、配置（cfg_scale）和推理步数（num_inference_steps）等参数，生成多个不同的图像，并保存到本地。
  8. 图像拼接与展示：

    • 读取之前生成的多个图像，将它们拼接成一个大的图像。
    • 展示拼接后的图像。

这个代码框架涵盖了从数据准备、预处理、评估到图像生成的完整流程，展示了在AI模型开发中，特别是基于文本到图像生成任务中的典型工作流程。

二、实战演练一一基于话剧的连环画制作

1.让通义千问帮我编一个8张图的故事：

提示词没啥大毛病，不过根据需要要加风格提示词和负面提示词

负面提示词：丑陋，变形，嘈杂，模糊，低对比度

2.执行Task1的30分钟速通Baseline

3.替换prompt

4.生成图片并保存

TASK2总结：学会了使用AI分析程序代码，相对于封装好的Stable diffusion，从代码层面详细了解了AI图片生成过程，但是对代码的设计具体操作依然不了解，想知道更多代码的具体应用，比如导入不同库和基础模型的方法，库和模型的获取方法等等，代码调用和Stable diffusion 秋叶WebUI生图的区别等等。

文章来源于互联网:Datawhale X 魔搭 AI夏令营 AIGC方向 task2笔记

相关推荐: FLUX 1 将像 Stable Diffusion 一样完整支持ControlNet组件

之前 InstantX 团队做的多合一的 Flux ControlNet 现在开始和 ShakkerAI 合作并推出了：Shakker-Labs/FLUX.1-dev-ControlNet-Union-Pro 该模型支持 7 种控制模式，包括 canny (0…

赞(0)
未经允许不得转载：5bei.cn大模型教程网 » Datawhale X 魔搭 AI夏令营 AIGC方向 task2笔记
分享到： 更多 (0)
标签：

相关推荐

吐血推荐

对比kimi、通义千问、文心一言的写代码能力

真实对比kimi、通义千问、文心一言的写代码能力，到底谁强？

热门文章

AI大模型,我们的未来

小欢软考联系我们