2025年全面掌握图像生成技术：从文本到创意，零基础快速入门领先

# 2025年扩散模型基础架构示意
import torch
import torch.nn as nn

class DiffusionBase(nn.Module):
    def __init__(self, image_size, hidden_dim):
        super(DiffusionBase, self).__init__()
        self.image_size = image_size
        self.hidden_dim = hidden_dim
        # 定义噪声预测网络
        self.noise_predictor = nn.Sequential(
            nn.Conv2d(3, hidden_dim, kernel_size=3, padding=1),
            # 更多网络层...
            nn.Conv2d(hidden_dim, 3, kernel_size=3, padding=1)
        )
        
    def forward(self, x, t):
        # x: 输入图像/噪声
        # t: 时间步
        # 预测噪声并返回
        return self.noise_predictor(x)

# 2025年文本到图像生成模型的高级实现
import torch
from transformers import AutoProcessor, AutoModelForTextToImage
from PIL import Image
import numpy as np

class AdvancedTextToImageGenerator:
    def __init__(self, model_name="stabilityai/stable-diffusion-xl-base-1.0"):
        # 加载预训练的文本到图像生成模型
        self.processor = AutoProcessor.from_pretrained(model_name)
        self.model = AutoModelForTextToImage.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            use_safetensors=True
        )
        
        # 移至GPU（如果可用）
        if torch.cuda.is_available():
            self.model.to("cuda")
        
        # 设置默认生成参数
        self.default_params = {
            "num_inference_steps": 30,
            "height": 1024,
            "width": 1024,
            "seed": 42,
            "guidance_scale": 7.5
        }
    
    def enhance_prompt(self, prompt):
        # 提示词增强，提高生成质量
        enhancements = [
            "best quality", "masterpiece", "highly detailed",
            "professional photography", "cinematic lighting",
            "ultra high res", "sharp focus", "vibrant colors"
        ]
        
        # 检查提示词是否已经包含增强词
        for enhancement in enhancements:
            if enhancement.lower() not in prompt.lower():
                prompt += f", {enhancement}"
        
        return prompt
    
    def generate_image(self, prompt, negative_prompt="", **kwargs):
        # 合并默认参数和用户提供的参数
        params = {**self.default_params, **kwargs}
        
        # 增强提示词
        enhanced_prompt = self.enhance_prompt(prompt)
        
        # 准备输入
        inputs = self.processor(
            text=enhanced_prompt,
            negative_prompt=negative_prompt,
            return_tensors="pt"
        )
        
        # 移至GPU（如果可用）
        if torch.cuda.is_available():
            inputs = {k: v.to("cuda") for k, v in inputs.items()}
        
        # 生成图像
        with torch.autocast("cuda", enabled=torch.cuda.is_available()):
            image = self.model.generate(
                **inputs,
                num_inference_steps=params["num_inference_steps"],
                height=params["height"],
                width=params["width"],
                guidance_scale=params["guidance_scale"],
                generator=torch.manual_seed(params["seed"] if "seed" in params else 42)
            ).images[0]
        
        return image
    
    def generate_multiple_images(self, prompt, num_images=4, **kwargs):
        # 生成多个图像
        images = []
        base_seed = kwargs.pop("seed", self.default_params["seed"])
        
        for i in range(num_images):
            # 使用不同的种子
            image = self.generate_image(prompt, seed=base_seed + i, **kwargs)
            images.append(image)
        
        return images
    
    def save_image(self, image, output_path):
        # 保存图像到文件
        image.save(output_path)
        return output_path
    
    def generate_variations(self, base_image, prompt, num_variations=4, **kwargs):
        # 生成图像变体
        # 注意：此功能需要支持图像到图像转换的模型
        # 这里仅作示意，实际实现可能需要不同的模型或方法
        from transformers import DiffusionPipeline
        
        # 假设我们使用一个支持图像到图像转换的扩散模型
        pipeline = DiffusionPipeline.from_pretrained(
            "stabilityai/stable-diffusion-xl-refiner-1.0",
            torch_dtype=torch.float16,
            use_safetensors=True
        )
        
        if torch.cuda.is_available():
            pipeline.to("cuda")
        
        variations = []
        base_seed = kwargs.pop("seed", self.default_params["seed"])
        
        for i in range(num_variations):
            # 使用不同的种子生成变体
            variation = pipeline(
                prompt=prompt,
                image=base_image,
                strength=0.75,
                num_inference_steps=30,
                generator=torch.manual_seed(base_seed + i)
            ).images[0]
            variations.append(variation)
        
        return variations

# 示例使用代码
# text_to_image_generator = AdvancedTextToImageGenerator()
# 
# # 生成单张图像
# # image = text_to_image_generator.generate_image(
# #     prompt="A futuristic cityscape with flying cars and neon lights at night"
# # )
# # print(f"生成了图像，尺寸: {image.size}")
# # text_to_image_generator.save_image(image, "futuristic_city.png")
# 
# # 生成多张图像
# # images = text_to_image_generator.generate_multiple_images(
# #     prompt="A cyberpunk detective in a rainy city",
# #     num_images=4
# # )
# # for i, img in enumerate(images):
# #     text_to_image_generator.save_image(img, f"cyberpunk_detective_{i}.png")
# 
# # 生成图像变体
# # variations = text_to_image_generator.generate_variations(
# #     base_image=image, 
# #     prompt="A futuristic cityscape with flying cars and neon lights at night, winter version",
# #     num_variations=4
# # )
# # for i, var in enumerate(variations):
# #     text_to_image_generator.save_image(var, f"futuristic_city_variation_{i}.png")

# 2025年基于扩散模型的无条件图像生成示例实现
import torch
from transformers import DiffusionPipeline
from PIL import Image
import numpy as np

class AdvancedUnconditionalImageGenerator:
    def __init__(self, model_name="stabilityai/stable-diffusion-xl-base-1.0"):
        # 加载预训练的无条件图像生成模型
        self.pipeline = DiffusionPipeline.from_pretrained(
            model_name,
            torch_dtype=torch.float16,
            use_safetensors=True
        )
        
        # 移至GPU（如果可用）
        if torch.cuda.is_available():
            self.pipeline.to("cuda")
        
        # 设置默认生成参数
        self.default_params = {
            "num_inference_steps": 30,
            "height": 1024,
            "width": 1024,
            "seed": 42,
            "guidance_scale": 0.0  # 0.0表示无条件生成
        }
    
    def generate_image(self, **kwargs):
        # 合并默认参数和用户提供的参数
        params = {**self.default_params, **kwargs}
        
        # 确保无条件生成
        params["guidance_scale"] = 0.0
        
        # 生成图像
        with torch.autocast("cuda", enabled=torch.cuda.is_available()):
            image = self.pipeline(
                num_inference_steps=params["num_inference_steps"],
                height=params["height"],
                width=params["width"],
                generator=torch.manual_seed(params["seed"])
            ).images[0]
        
        return image
    
    def generate_multiple_images(self, num_images=4, **kwargs):
        # 生成多个无条件图像
        images = []
        base_seed = kwargs.pop("seed", self.default_params["seed"])
        
        for i in range(num_images):
            # 使用不同的种子
            image = self.generate_image(seed=base_seed + i, **kwargs)
            images.append(image)
        
        return images
    
    def generate_image_grid(self, num_rows=2, num_cols=2, **kwargs):
        # 生成图像网格
        total_images = num_rows * num_cols
        images = self.generate_multiple_images(num_images=total_images, **kwargs)
        
        # 创建网格图像
        grid_width = self.default_params["width"] * num_cols
        grid_height = self.default_params["height"] * num_rows
        grid = Image.new("RGB", (grid_width, grid_height))
        
        # 将生成的图像放入网格
        for i in range(num_rows):
            for j in range(num_cols):
                index = i * num_cols + j
                if index < len(images):
                    grid.paste(images[index], (j * self.default_params["width"], i * self.default_params["height"]))
        
        return grid, images
    
    def save_image(self, image, output_path):
        # 保存图像到文件
        image.save(output_path)
        return output_path
    
    def apply_style_transfer(self, generated_image, style_reference=None):
        # 对生成的图像应用风格迁移
        # 注意：此功能需要额外的风格迁移模型
        # 这里仅作示意，实际实现可能需要不同的模型或方法
        from transformers import AutoProcessor, AutoModelForImageStyleTransfer
        
        # 假设我们使用一个预训练的风格迁移模型
        style_model_name = "facebook/convnext-base-384"
        processor = AutoProcessor.from_pretrained(style_model_name)
        style_model = AutoModelForImageStyleTransfer.from_pretrained(style_model_name)
        
        if torch.cuda.is_available():
            style_model.to("cuda")
        
        # 处理输入
        inputs = processor(images=generated_image, return_tensors="pt")
        if torch.cuda.is_available():
            inputs = {k: v.to("cuda") for k, v in inputs.items()}
        
        # 应用风格迁移
        with torch.no_grad():
            outputs = style_model(**inputs)
        
        # 获取风格化图像
        styled_image = processor.image_processor.postprocess(outputs.logits, return_tensor=False)[0]
        
        return styled_image

# 示例使用代码
# unconditional_generator = AdvancedUnconditionalImageGenerator()
# 
# # 生成单张图像
# # image = unconditional_generator.generate_image()
# # print(f"生成了图像，尺寸: {image.size}")
# # unconditional_generator.save_image(image, "unconditional_image.png")
# 
# # 生成多张图像
# # images = unconditional_generator.generate_multiple_images(num_images=4)
# # for i, img in enumerate(images):
# #     unconditional_generator.save_image(img, f"unconditional_image_{i}.png")
# 
# # 生成图像网格
# # grid, grid_images = unconditional_generator.generate_image_grid(num_rows=2, num_cols=2)
# # unconditional_generator.save_image(grid, "image_grid.png")
# 
# # 应用风格迁移
# # styled_image = unconditional_generator.apply_style_transfer(image)
# # unconditional_generator.save_image(styled_image, "styled_image.png")

# 图像生成模型量化优化示例
import torch
from transformers import DiffusionPipeline
from torch.quantization import quantize_dynamic

class QuantizedImageGenerator:
    def __init__(self, model_name="stabilityai/stable-diffusion-xl-base-1.0", is_text_to_image=True):
        # 加载预训练的图像生成模型
        if is_text_to_image:
            from transformers import AutoProcessor, AutoModelForTextToImage
            self.processor = AutoProcessor.from_pretrained(model_name)
            self.model = AutoModelForTextToImage.from_pretrained(
                model_name,
                torch_dtype=torch.float16,
                use_safetensors=True
            )
            self.is_text_to_image = True
        else:
            self.pipeline = DiffusionPipeline.from_pretrained(
                model_name,
                torch_dtype=torch.float16,
                use_safetensors=True
            )
            self.is_text_to_image = False
        
        # 移至GPU（如果可用）
        if torch.cuda.is_available():
            if self.is_text_to_image:
                self.model.to("cuda")
            else:
                self.pipeline.to("cuda")
        
        # 设置默认生成参数
        self.default_params = {
            "num_inference_steps": 30,
            "height": 512,
            "width": 512,
            "seed": 42,
            "guidance_scale": 7.5 if self.is_text_to_image else 0.0
        }
    
    def quantize_model(self, quantization_type="dynamic"):
        # 对模型进行量化优化
        if quantization_type == "dynamic":
            # 动态量化（仅支持CPU）
            if torch.cuda.is_available():
                if self.is_text_to_image:
                    self.model.to("cpu")
                else:
                    self.pipeline.to("cpu")
            
            if self.is_text_to_image:
                # 对文本到图像模型进行动态量化
                self.model = quantize_dynamic(
                    self.model,
                    {torch.nn.Linear, torch.nn.Conv2d},
                    dtype=torch.qint8
                )
            else:
                # 对无条件图像生成模型进行动态量化
                self.pipeline.unet = quantize_dynamic(
                    self.pipeline.unet,
                    {torch.nn.Linear, torch.nn.Conv2d},
                    dtype=torch.qint8
                )
                self.pipeline.vae = quantize_dynamic(
                    self.pipeline.vae,
                    {torch.nn.Linear, torch.nn.Conv2d},
                    dtype=torch.qint8
                )
            
            print("模型已成功进行动态量化优化")
        elif quantization_type == "static":
            # 静态量化（需要校准数据）
            # 注意：完整的静态量化需要准备校准数据集
            print("静态量化需要准备校准数据集，这里略过详细实现")
        else:
            print(f"不支持的量化类型: {quantization_type}")
        
        return self.model if self.is_text_to_image else self.pipeline

# 示例使用代码（简化版）
# quantized_text_to_image = QuantizedImageGenerator(is_text_to_image=True)
# quantized_unconditional = QuantizedImageGenerator(is_text_to_image=False)
# 
# # 对模型进行量化
# # quantized_text_to_image_model = quantized_text_to_image.quantize_model()
# # quantized_unconditional_model = quantized_unconditional.quantize_model()

# 图像生成模型知识蒸馏优化示例
import torch
import torch.nn as nn
from transformers import DiffusionPipeline

class TextToImageKnowledgeDistillation:
    def __init__(self, teacher_model_name="stabilityai/stable-diffusion-xl-base-1.0",
                 student_model_name="stabilityai/stable-diffusion-2-base"):
        # 加载教师模型和学生模型
        self.teacher_pipeline = DiffusionPipeline.from_pretrained(
            teacher_model_name,
            torch_dtype=torch.float16,
            use_safetensors=True
        )
        
        self.student_pipeline = DiffusionPipeline.from_pretrained(
            student_model_name,
            torch_dtype=torch.float16,
            use_safetensors=True
        )
        
        # 移至GPU（如果可用）
        if torch.cuda.is_available():
            self.teacher_pipeline.to("cuda")
            self.student_pipeline.to("cuda")
        
        # 设置损失函数
        self.loss_fn = nn.MSELoss()
        
        # 设置优化器
        self.optimizer = torch.optim.Adam(self.student_pipeline.unet.parameters(), lr=1e-5)
    
    def distill(self, prompt, num_steps=100):
        # 知识蒸馏过程
        for step in range(num_steps):
            # 教师模型生成图像和潜在表示
            with torch.no_grad():
                teacher_output = self.teacher_pipeline(
                    prompt=prompt,
                    num_inference_steps=20,
                    output_hidden_states=True
                )
                teacher_hidden_states = teacher_output.hidden_states
            
            # 学生模型生成图像和潜在表示
            student_output = self.student_pipeline(
                prompt=prompt,
                num_inference_steps=20,
                output_hidden_states=True
            )
            student_hidden_states = student_output.hidden_states
            
            # 计算蒸馏损失
            loss = 0
            for t_hs, s_hs in zip(teacher_hidden_states, student_hidden_states):
                loss += self.loss_fn(t_hs, s_hs)
            
            # 反向传播和优化
            self.optimizer.zero_grad()
            loss.backward()
            self.optimizer.step()
            
            if step % 10 == 0:
                print(f"蒸馏步骤 {step}/{num_steps}, 损失: {loss.item():.4f}")
        
        return self.student_pipeline
    
    def save_distilled_model(self, save_path):
        # 保存蒸馏后的模型
        self.student_pipeline.save_pretrained(save_path)
        print(f"蒸馏后的模型已保存到 {save_path}")

# 示例使用代码（简化版）
# distiller = TextToImageKnowledgeDistillation()
# 
# # 执行知识蒸馏
# # distilled_pipeline = distiller.distill("A beautiful landscape with mountains and lake")
# 
# # 保存蒸馏后的模型
# # distiller.save_distilled_model("distilled_stable_diffusion")