Stable Diffusion — AI 图像生成终极指南

git clone https://github.com/AUTOMATIC1111/stable-diffusion-webui.git
cd stable-diffusion-webui
./webui.sh

FROM nvidia/cuda:12.2-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y \
    python3 python3-pip git wget \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY . .

RUN pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121
RUN pip3 install -r requirements.txt

CMD ["python3", "webui.py", "--api"]

pip install diffusers transformers accelerate safetensors

from diffusers import StableDiffusionPipeline
import torch

# 加载模型
pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    variant="fp16"
)
pipe = pipe.to("cuda")

# 生成图像
image = pipe(
    "a photo of a cat wearing sunglasses",
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

image.save("output.png")

from diffusers import StableDiffusionXLPipeline
import torch

# 加载基座模型
base_model = "stabilityai/stable-diffusion-xl-base-1.0"
pipe = StableDiffusionXLPipeline.from_pretrained(base_model, torch_dtype=torch.float16)
pipe = pipe.to("cuda")

# 加载训练好的 LoRA 适配器
lora_path = "./my-lora/checkpoint.safetensors"
pipe.load_lora_weights(lora_path, weight_name="pytorch_lora_weights.safetensors")

# 使用 LoRA 生成
image = pipe(
    prompt="a photo of my product in studio lighting",
    negative_prompt="blurry, low quality, distorted",
    num_inference_steps=25,
    guidance_scale=7.0
).images[0]

image.save("lora_output.png")

pip install accelerate diffusers transformers datasets

# 准备训练数据目录
mkdir -p ./train_data
# 将 15-30 张你的主题图片放入 train_data/

# 运行训练
accelerate launch train_dreambooth.py \
    --pretrained_model_name_or_path="stabilityai/stable-diffusion-xl-base-1.0" \
    --instance_data_dir="./train_data" \
    --instance_prompt="a photo of my product" \
    --output_dir="./my-lora" \
    --resolution=1024 \
    --train_batch_size=1 \
    --gradient_accumulation_steps=4 \
    --learning_rate=1e-6 \
    --lr_scheduler="constant" \
    --lr_warmup_steps=0 \
    --max_train_steps=1000

from diffusers import ControlNetModel, StableDiffusionControlNetPipeline
import torch
from PIL import Image

# 加载 ControlNet 模型
controlnet = ControlNetModel.from_pretrained(
    "lllyasviel/control_v11p_sd15_canny",
    torch_dtype=torch.float16
)

pipe = StableDiffusionControlNetPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    controlnet=controlnet,
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 准备控制图像
control_image = Image.open("pose_reference.jpg").resize((512, 512))

# 使用姿态控制生成
image = pipe(
    prompt="a person standing confidently in a business suit",
    control_image=control_image,
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]

from diffusers import StableDiffusionIPAdapterPipeline
import torch

pipe = StableDiffusionIPAdapterPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    ip_adapter="h94/IP-Adapter",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 使用参考图像风格
reference = Image.open("art_style_reference.jpg")

image = pipe(
    prompt="a landscape painting in this style",
    image=reference,
    num_inference_steps=25
).images[0]

from flask import Flask, request, jsonify
from diffusers import StableDiffusionPipeline
import torch
import io
from PIL import Image
import base64

app = Flask(__name__)

pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

@app.route("/generate", methods=["POST"])
def generate():
    data = request.json
    prompt = data.get("prompt", "")
    negative_prompt = data.get("negative_prompt", "")
    steps = data.get("steps", 30)
    guidance = data.get("guidance", 7.5)
    
    image = pipe(
        prompt=prompt,
        negative_prompt=negative_prompt,
        num_inference_steps=steps,
        guidance_scale=guidance
    ).images[0]
    
    # 转换为 base64 JSON 响应
    buffered = io.BytesIO()
    image.save(buffered, format="PNG")
    img_str = base64.b64encode(buffered.getvalue()).decode()
    
    return jsonify({
        "image": f"data:image/png;base64,{img_str}",
        "seed": None
    })

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8000)

pip install xformers

from diffusers import StableDiffusionPipeline
import torch

pipe = StableDiffusionPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
    use_safetensors=True
)
pipe.enable_xformers_memory_efficient_attention()  # 2-3 倍加速
pipe.to("cuda")

# 更快生成
image = pipe("a cat wearing sunglasses", num_inference_steps=20).images[0]

from diffusers import StableDiffusionXLPipeline
from optimum.intel import IPEXQuantizedModelForCausalLM

# 导出模型至 ONNX
pipe.export_to_onnx(
    "./model.onnx",
    fp16=True,
    device="cuda"
)

# 转换为 TensorRT 引擎
from optimum.onnxruntime import ORTModelForDiffusion
ort_model = ORTModelForDiffusion.from_pretrained("./model.onnx")

from diffusers import StableDiffusionImg2ImgPipeline
import torch
from PIL import Image

pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-refiner-1.0",
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 加载源图像
source = Image.open("photo.jpg").convert("RGB")

# 转换生成
result = pipe(
    prompt="convert to oil painting style",
    image=source,
    strength=0.75,
    num_inference_steps=30
).images[0]

result.save("transformed.jpg")

from diffusers import StableDiffusionUpscalePipeline

upscale_pipeline = StableDiffusionUpscalePipeline.from_pretrained(
    "stabilityai/stable-diffusion-x4-upscaler",
    torch_dtype=torch.float16
)
upscale_pipeline = upscale_pipeline.to("cuda")

# 升频低分辨图像
low_res = Image.open("lowres.png")
upscaled = upscale_pipeline(
    prompt="high quality, detailed, 4k",
    image=low_res
).images[0]

upscaled.save("upscaled.png")

from diffusers import AutoPipelineForText2Image
import torch
from PIL import Image

pipeline = AutoPipelineForText2Image.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16
)
pipeline = pipeline.to("cuda")

prompts = [
    "a sunset over mountains",
    "a city skyline at night",
    "an underwater coral reef",
    "a forest in autumn"
]

images = []
for prompt in prompts:
    img = pipeline(prompt, num_inference_steps=25).images[0]
    images.append(img)

# 创建网格
grid_size = int(len(images) ** 0.5)
width, height = images[0].size
grid = Image.new("RGB", (width * grid_size, height * ((len(images) + grid_size - 1) // grid_size)))

for i, img in enumerate(images):
    row = i // grid_size
    col = i % grid_size
    grid.paste(img, (col * width, row * height))

grid.save("generation_grid.png")

# 通用质量提升器
generic_negative = """
low quality, blurry, noisy, jpeg artifacts, 
poorly drawn, deformed, ugly, duplicate, 
mutilated, extra fingers, mutated hands, 
poorly drawn hands, poorly drawn face, mutation
"""

# 摄影专用负面
photography_negative = """
cartoon, anime, illustration, painting, 
drawing, sketch, 3d render, plastic
"""

# 产品摄影
product_negative = """
background clutter, text, watermark, logo, 
person, people, animal, insect, car, vehicle
"""

image = pipe(
    prompt="professional product shot of wireless headphones",
    negative_prompt=product_negative,
    num_inference_steps=30,
    guidance_scale=7.5
).images[0]