from diffusers import (
    StableDiffusionXLPipeline,
    DPMSolverMultistepScheduler,
    AutoencoderKL,
)
import torch
 
# VAE をロード (品質向上のため専用VAEを使用)
vae = AutoencoderKL.from_pretrained(
    "madebyollin/sdxl-vae-fp16-fix",
    torch_dtype=torch.float16,
)
 
# SDXL パイプラインをロード
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    vae=vae,
    torch_dtype=torch.float16,
    variant="fp16",
    use_safetensors=True,
)
pipe.to("cuda")
 
# サンプラーを高速版に変更
pipe.scheduler = DPMSolverMultistepScheduler.from_config(
    pipe.scheduler.config
)
 
# 画像生成
image = pipe(
    prompt="A majestic Japanese castle surrounded by cherry blossoms, "
           "golden hour lighting, photorealistic, 8K",
    negative_prompt="low quality, blurry, distorted",
    num_inference_steps=25,
    guidance_scale=7.0,
    width=1024,
    height=1024,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
 
image.save("castle.png")

from diffusers import (
    StableDiffusionXLPipeline,
    DPMSolverMultistepScheduler,
    AutoencoderKL,
)
import torch
from compel import Compel, ReturnedEmbeddingsType
 
# VAE ロード
vae = AutoencoderKL.from_pretrained(
    "madebyollin/sdxl-vae-fp16-fix",
    torch_dtype=torch.float16,
)
 
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    vae=vae,
    torch_dtype=torch.float16,
    variant="fp16",
    use_safetensors=True,
)
pipe.to("cuda")
 
# メモリ最適化の各種オプション
pipe.enable_attention_slicing()     # Attention メモリ削減
pipe.enable_vae_slicing()           # VAE メモリ削減
pipe.enable_vae_tiling()            # 大解像度時のVAE処理
# pipe.enable_model_cpu_offload()   # VRAM不足時にCPUオフロード
# pipe.enable_sequential_cpu_offload()  # 極端にVRAM不足の場合
 
# Compel によるプロンプトの重み付け制御
compel = Compel(
    tokenizer=[pipe.tokenizer, pipe.tokenizer_2],
    text_encoder=[pipe.text_encoder, pipe.text_encoder_2],
    returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,
    requires_pooled=[False, True],
)
 
# プロンプト重み付け: (word)++ で強調、(word)-- で抑制
prompt = "A (majestic)++ Japanese castle, (cherry blossoms)++, golden hour"
negative = "(low quality)--, (blurry)--, distorted, watermark"
 
conditioning, pooled = compel(prompt)
neg_conditioning, neg_pooled = compel(negative)
 
image = pipe(
    prompt_embeds=conditioning,
    pooled_prompt_embeds=pooled,
    negative_prompt_embeds=neg_conditioning,
    negative_pooled_prompt_embeds=neg_pooled,
    num_inference_steps=30,
    guidance_scale=7.0,
    width=1024,
    height=1024,
).images[0]
 
image.save("castle_weighted.png")

from diffusers import StableDiffusionXLPipeline
import torch
 
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
).to("cuda")
 
# LoRA をロードして適用
pipe.load_lora_weights(
    "path/to/lora",
    weight_name="anime_style_v2.safetensors",
    adapter_name="anime_style",
)
 
# LoRA の影響度を調整 (0.0~1.0)
pipe.set_adapters(["anime_style"], adapter_weights=[0.8])
 
image = pipe(
    prompt="1girl, cherry blossom, detailed eyes, anime style",
    num_inference_steps=25,
).images[0]
 
# 複数 LoRA の同時適用
pipe.load_lora_weights(
    "path/to/lora2",
    weight_name="lighting_enhance.safetensors",
    adapter_name="lighting",
)
pipe.set_adapters(
    ["anime_style", "lighting"],
    adapter_weights=[0.7, 0.5],  # 個別に重み調整
)

"""
LoRA ファインチューニングの実行例
diffusers の train_dreambooth_lora_sdxl.py スクリプトを使用
"""
 
# コマンドライン実行の設定
train_config = {
    "pretrained_model_name_or_path": "stabilityai/stable-diffusion-xl-base-1.0",
    "instance_data_dir": "./training_images",     # 学習画像フォルダ (10-30枚推奨)
    "output_dir": "./my_lora_model",
    "instance_prompt": "a photo of sks dog",      # sks はトリガーワード
    "resolution": 1024,
    "train_batch_size": 1,
    "gradient_accumulation_steps": 4,
    "learning_rate": 1e-4,
    "lr_scheduler": "cosine",
    "lr_warmup_steps": 100,
    "max_train_steps": 1000,
    "rank": 32,                                    # LoRA のランク (4-128)
    "seed": 42,
    "mixed_precision": "fp16",
    "use_8bit_adam": True,                         # メモリ節約
    "gradient_checkpointing": True,                # メモリ節約
    "prior_preservation": True,                    # 過学習防止
    "prior_preservation_class_prompt": "a photo of a dog",
    "num_class_images": 100,
}
 
# accelerate を使った訓練コマンド生成
def generate_train_command(config):
    cmd = "accelerate launch train_dreambooth_lora_sdxl.py"
    for key, value in config.items():
        if isinstance(value, bool):
            if value:
                cmd += f" --{key}"
        else:
            cmd += f" --{key}={value}"
    return cmd
 
print(generate_train_command(train_config))
 
# 訓練後の LoRA 使用
# pipe.load_lora_weights("./my_lora_model", weight_name="pytorch_lora_weights.safetensors")
# image = pipe("a photo of sks dog in a garden", num_inference_steps=25).images[0]

from diffusers import (
    StableDiffusionXLControlNetPipeline,
    ControlNetModel,
    AutoencoderKL,
)
from diffusers.utils import load_image
from controlnet_aux import CannyDetector, OpenposeDetector, MidasDetector
import torch
from PIL import Image
 
# --- Canny Edge ControlNet ---
controlnet_canny = ControlNetModel.from_pretrained(
    "diffusers/controlnet-canny-sdxl-1.0",
    torch_dtype=torch.float16,
    variant="fp16",
)
 
vae = AutoencoderKL.from_pretrained(
    "madebyollin/sdxl-vae-fp16-fix",
    torch_dtype=torch.float16,
)
 
pipe = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet_canny,
    vae=vae,
    torch_dtype=torch.float16,
    variant="fp16",
)
pipe.to("cuda")
pipe.enable_model_cpu_offload()
 
# エッジ検出
canny = CannyDetector()
source_image = load_image("reference_building.png")
canny_image = canny(source_image, low_threshold=100, high_threshold=200)
 
# エッジに基づいた画像生成
image = pipe(
    prompt="A futuristic glass skyscraper, same structure as reference, "
           "cyberpunk city, neon lights, night scene, photorealistic",
    negative_prompt="low quality, blurry",
    image=canny_image,
    controlnet_conditioning_scale=0.7,  # ControlNet の影響度
    num_inference_steps=30,
    guidance_scale=7.5,
).images[0]
 
image.save("controlnet_building.png")
 
 
# --- OpenPose ControlNet ---
controlnet_pose = ControlNetModel.from_pretrained(
    "thibaud/controlnet-openpose-sdxl-1.0",
    torch_dtype=torch.float16,
)
pipe_pose = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet_pose,
    vae=vae,
    torch_dtype=torch.float16,
)
pipe_pose.to("cuda")
 
# ポーズ検出
openpose = OpenposeDetector.from_pretrained("lllyasviel/Annotators")
pose_image = openpose(load_image("person_reference.png"))
 
# ポーズに基づいた画像生成
image_pose = pipe_pose(
    prompt="A samurai warrior in traditional armor, dynamic pose, "
           "detailed, concept art, dramatic lighting",
    image=pose_image,
    controlnet_conditioning_scale=0.8,
    num_inference_steps=30,
).images[0]
 
image_pose.save("controlnet_samurai.png")
 
 
# --- Depth ControlNet ---
controlnet_depth = ControlNetModel.from_pretrained(
    "diffusers/controlnet-depth-sdxl-1.0",
    torch_dtype=torch.float16,
)
pipe_depth = StableDiffusionXLControlNetPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    controlnet=controlnet_depth,
    vae=vae,
    torch_dtype=torch.float16,
)
pipe_depth.to("cuda")
 
# 深度マップ推定
midas = MidasDetector.from_pretrained("lllyasviel/Annotators")
depth_image = midas(load_image("room_photo.png"))
 
# 深度に基づいたインテリアデザイン変換
image_depth = pipe_depth(
    prompt="Modern Japanese interior, tatami room, shoji screens, "
           "natural light, same spatial layout, interior design magazine",
    image=depth_image,
    controlnet_conditioning_scale=0.6,
    num_inference_steps=30,
).images[0]
 
image_depth.save("controlnet_interior.png")

from diffusers import (
    StableDiffusionXLPipeline,
    DPMSolverMultistepScheduler,
    EulerDiscreteScheduler,
    EulerAncestralDiscreteScheduler,
    UniPCMultistepScheduler,
    KDPM2AncestralDiscreteScheduler,
    HeunDiscreteScheduler,
    DDIMScheduler,
)
import torch
import time
 
pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
).to("cuda")
 
# スケジューラの一覧と特徴
schedulers = {
    "DPM++ 2M Karras": {
        "class": DPMSolverMultistepScheduler,
        "config": {"use_karras_sigmas": True, "algorithm_type": "dpmsolver++"},
        "推奨ステップ": 25,
        "特徴": "高速・高品質のバランスが最良。最も汎用的",
    },
    "Euler": {
        "class": EulerDiscreteScheduler,
        "config": {},
        "推奨ステップ": 30,
        "特徴": "シンプルで安定。Midjourney のデフォルトに近い",
    },
    "Euler Ancestral": {
        "class": EulerAncestralDiscreteScheduler,
        "config": {},
        "推奨ステップ": 30,
        "特徴": "ランダム性あり。同一シードでもやや異なる結果",
    },
    "UniPC": {
        "class": UniPCMultistepScheduler,
        "config": {},
        "推奨ステップ": 20,
        "特徴": "最小ステップ数で高品質。高速生成に最適",
    },
    "Heun": {
        "class": HeunDiscreteScheduler,
        "config": {},
        "推奨ステップ": 25,
        "特徴": "高品質だが低速 (各ステップで2回評価)。精密な生成向き",
    },
    "DDIM": {
        "class": DDIMScheduler,
        "config": {},
        "推奨ステップ": 50,
        "特徴": "決定論的。画像間の補間に使用可能",
    },
}
 
# ベンチマーク実行
prompt = "A beautiful landscape, mountains, lake, sunset, photorealistic"
results = {}
 
for name, sched_info in schedulers.items():
    scheduler = sched_info["class"].from_config(
        pipe.scheduler.config, **sched_info["config"]
    )
    pipe.scheduler = scheduler
    steps = sched_info["推奨ステップ"]
 
    start = time.time()
    image = pipe(
        prompt=prompt,
        num_inference_steps=steps,
        guidance_scale=7.0,
        generator=torch.Generator("cuda").manual_seed(42),
    ).images[0]
    elapsed = time.time() - start
 
    results[name] = {
        "time": round(elapsed, 2),
        "steps": steps,
        "特徴": sched_info["特徴"],
    }
    image.save(f"scheduler_{name.replace(' ', '_').lower()}.png")
 
# 結果出力
for name, info in results.items():
    print(f"{name}: {info['time']}秒 ({info['steps']}ステップ)")
    print(f"  特徴: {info['特徴']}")

from openai import OpenAI
import base64
import httpx
from pathlib import Path
 
client = OpenAI()
 
# 基本的な画像生成
response = client.images.generate(
    model="dall-e-3",
    prompt="日本の伝統的な温泉旅館の露天風呂。紅葉に囲まれ、"
           "湯気が朝霧のように立ち上る。写真のようにリアル。",
    size="1792x1024",       # 横長
    quality="hd",           # 高品質モード
    style="natural",        # "natural" or "vivid"
    n=1,
)
 
# 生成された画像の情報
image_url = response.data[0].url
revised_prompt = response.data[0].revised_prompt  # GPT-4が書き換えたプロンプト
print(f"修正プロンプト: {revised_prompt}")
 
# 画像をダウンロード
image_data = httpx.get(image_url).content
Path("onsen.png").write_bytes(image_data)
 
# バリエーション生成のパターン
prompts_batch = [
    "同じ温泉旅館を春の桜の季節で",
    "同じ温泉旅館を冬の雪景色で",
    "同じ温泉旅館を夏の緑深い季節で",
]
 
for i, prompt in enumerate(prompts_batch):
    resp = client.images.generate(
        model="dall-e-3",
        prompt=prompt,
        size="1024x1024",
        quality="standard",
    )
    print(f"Season {i}: {resp.data[0].url}")

from openai import OpenAI
import httpx
import json
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor
 
client = OpenAI()
 
class DALLEWorkflow:
    """DALL-E 3 の実務的な活用パターン集"""
 
    def __init__(self, output_dir="./generated"):
        self.client = OpenAI()
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(exist_ok=True)
 
    def generate_with_metadata(self, prompt, size="1024x1024",
                                quality="hd", style="natural"):
        """メタデータ付き画像生成"""
        response = self.client.images.generate(
            model="dall-e-3",
            prompt=prompt,
            size=size,
            quality=quality,
            style=style,
            n=1,
        )
 
        image_url = response.data[0].url
        revised_prompt = response.data[0].revised_prompt
 
        # 画像ダウンロード
        image_data = httpx.get(image_url).content
 
        # ファイル名生成
        import hashlib
        name_hash = hashlib.md5(prompt.encode()).hexdigest()[:8]
        filename = f"dalle3_{name_hash}.png"
        filepath = self.output_dir / filename
 
        filepath.write_bytes(image_data)
 
        # メタデータ保存
        metadata = {
            "original_prompt": prompt,
            "revised_prompt": revised_prompt,
            "size": size,
            "quality": quality,
            "style": style,
            "filename": filename,
        }
        meta_path = self.output_dir / f"dalle3_{name_hash}_meta.json"
        meta_path.write_text(json.dumps(metadata, ensure_ascii=False, indent=2))
 
        return filepath, metadata
 
    def generate_product_shots(self, product_name, angles=None, styles=None):
        """商品画像の複数アングル生成"""
        if angles is None:
            angles = [
                "front view, centered",
                "45 degree angle, slightly above",
                "close-up detail shot",
                "lifestyle setting, in use",
            ]
        if styles is None:
            styles = ["natural"]
 
        results = []
        for angle in angles:
            for style in styles:
                prompt = (
                    f"Professional product photography of {product_name}, "
                    f"{angle}, studio lighting, white background, "
                    f"commercial quality, 4K, no text or watermark"
                )
                filepath, meta = self.generate_with_metadata(
                    prompt, size="1024x1024", quality="hd", style=style
                )
                results.append({"file": str(filepath), "angle": angle, **meta})
 
        return results
 
    def generate_with_chatgpt_enhancement(self, rough_description):
        """ChatGPT でプロンプトを拡張してから生成"""
        # GPT-4 でプロンプトを改善
        enhancement = self.client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content":
                    "You are an expert at writing prompts for DALL-E 3. "
                    "Given a rough description, create a detailed, vivid prompt "
                    "that will produce a stunning image. Include details about "
                    "lighting, composition, style, and mood."},
                {"role": "user", "content": rough_description},
            ],
            max_tokens=300,
        )
        enhanced_prompt = enhancement.choices[0].message.content
 
        # 強化されたプロンプトで生成
        filepath, meta = self.generate_with_metadata(enhanced_prompt)
        meta["rough_description"] = rough_description
        meta["enhanced_prompt"] = enhanced_prompt
 
        return filepath, meta
 
 
# 使用例
workflow = DALLEWorkflow(output_dir="./product_shots")
 
# 商品画像生成
results = workflow.generate_product_shots("minimalist leather wallet")
for r in results:
    print(f"[{r['angle']}] {r['file']}")
 
# ChatGPT 強化生成
filepath, meta = workflow.generate_with_chatgpt_enhancement(
    "日本の古い温泉街の夜景"
)
print(f"生成: {filepath}")
print(f"強化プロンプト: {meta['enhanced_prompt'][:100]}...")

"""
DALL-E 3 パラメータの効果比較
 
サイズ:
  1024x1024  — 正方形 (デフォルト、SNS投稿向き)
  1024x1792  — 縦長 (ポスター、スマホ壁紙)
  1792x1024  — 横長 (バナー、プレゼン背景)
 
品質:
  standard   — 標準品質、高速、$0.040/枚
  hd         — 高品質、精密なディテール、$0.080/枚
 
スタイル:
  natural    — 写実的、自然な印象
  vivid      — 鮮やか、コントラスト強め、映画的
"""
 
from openai import OpenAI
client = OpenAI()
 
# パラメータの全組み合わせで生成比較
def compare_dalle3_params(base_prompt):
    sizes = ["1024x1024", "1024x1792", "1792x1024"]
    qualities = ["standard", "hd"]
    styles = ["natural", "vivid"]
 
    results = []
    for size in sizes:
        for quality in qualities:
            for style in styles:
                response = client.images.generate(
                    model="dall-e-3",
                    prompt=base_prompt,
                    size=size,
                    quality=quality,
                    style=style,
                    n=1,
                )
                cost = 0.040 if quality == "standard" and size == "1024x1024" else \
                       0.080 if quality == "standard" else \
                       0.080 if size == "1024x1024" else 0.120
                results.append({
                    "size": size,
                    "quality": quality,
                    "style": style,
                    "cost_usd": cost,
                    "revised_prompt": response.data[0].revised_prompt[:80],
                    "url": response.data[0].url,
                })
                print(f"Generated: {size} / {quality} / {style} (${cost})")
 
    return results
 
# 使用例
# results = compare_dalle3_params("A serene Japanese garden in autumn")

"""
Midjourney パラメータリファレンス (v6.1)
 
構文: /imagine prompt: [テキスト] --[パラメータ]
"""
 
MIDJOURNEY_PARAMS = {
    # アスペクト比
    "--ar": {
        "説明": "画像のアスペクト比",
        "例": "--ar 16:9, --ar 3:2, --ar 1:1",
        "デフォルト": "1:1",
    },
    # スタイライズ
    "--s": {
        "説明": "Midjourneyのスタイル適用度 (0-1000)",
        "例": "--s 50 (控えめ), --s 750 (強い)",
        "デフォルト": "100",
    },
    # カオス
    "--c": {
        "説明": "バリエーションの多様性 (0-100)",
        "例": "--c 0 (安定), --c 50 (多様)",
        "デフォルト": "0",
    },
    # 品質
    "--q": {
        "説明": "生成品質/計算量 (.25, .5, 1)",
        "例": "--q 1 (最高), --q .5 (高速)",
        "デフォルト": "1",
    },
    # ネガティブ
    "--no": {
        "説明": "除外したい要素",
        "例": "--no text, watermark, people",
    },
    # シード
    "--seed": {
        "説明": "再現性のためのシード値",
        "例": "--seed 12345",
    },
    # スタイルロー
    "--sref": {
        "説明": "スタイル参照画像URL",
        "例": "--sref https://example.com/style.png",
    },
    # キャラクターリファレンス (v6+)
    "--cref": {
        "説明": "キャラクター参照画像URL",
        "例": "--cref https://example.com/character.png",
        "注意": "同一キャラクターの別ポーズ生成に使用",
    },
    # タイル
    "--tile": {
        "説明": "タイリング可能なパターンを生成",
        "例": "--tile",
        "用途": "テクスチャ、壁紙、テキスタイル",
    },
    # ストップ
    "--stop": {
        "説明": "生成を途中で停止 (10-100)",
        "例": "--stop 80",
        "用途": "抽象的、未完成感のある画像",
    },
    # ウィアード
    "--weird": {
        "説明": "実験的・奇抜な生成 (0-3000)",
        "例": "--weird 500",
    },
}
 
def build_mj_prompt(text: str, **params) -> str:
    """Midjourney用プロンプトを構築"""
    parts = [f"/imagine prompt: {text}"]
    for param, value in params.items():
        if not param.startswith("--"):
            param = f"--{param}"
        parts.append(f"{param} {value}")
    return " ".join(parts)
 
# 使用例
prompt = build_mj_prompt(
    "Ancient Japanese temple, moss-covered, misty morning",
    ar="16:9", s="250", c="20", q="1", no="people, text"
)
print(prompt)

"""
Midjourney 実践的プロンプトテンプレート
"""
 
class MidjourneyPromptBuilder:
    """Midjourney 向けプロンプトの体系的な構築"""
 
    # スタイルプリセット
    STYLE_PRESETS = {
        "photorealistic": "photorealistic, DSLR, 85mm lens, f/1.8, "
                         "natural lighting, 8K resolution",
        "cinematic": "cinematic lighting, film grain, anamorphic, "
                    "movie still, dramatic shadows",
        "anime": "anime style, cel shading, vibrant colors, "
                "detailed, Studio Ghibli inspired",
        "watercolor": "watercolor painting, soft edges, transparent washes, "
                     "artistic, paper texture",
        "3d_render": "3D render, octane render, subsurface scattering, "
                    "volumetric lighting, high detail",
        "concept_art": "concept art, digital painting, matte painting, "
                      "artstation trending, detailed illustration",
        "oil_painting": "oil painting, classical style, rich textures, "
                       "canvas texture, chiaroscuro lighting",
        "flat_design": "flat design, vector art, clean lines, "
                      "minimal, modern graphic design",
    }
 
    # ライティングプリセット
    LIGHTING_PRESETS = {
        "golden_hour": "golden hour, warm light, long shadows",
        "blue_hour": "blue hour, twilight, cool tones",
        "studio": "studio lighting, softbox, key light and fill light",
        "dramatic": "dramatic lighting, strong contrast, rim lighting",
        "natural": "natural daylight, soft shadows",
        "neon": "neon lighting, cyberpunk, colorful glow",
        "moonlight": "moonlit, silvery light, ethereal atmosphere",
    }
 
    # 構図プリセット
    COMPOSITION_PRESETS = {
        "rule_of_thirds": "rule of thirds composition",
        "centered": "centered symmetrical composition",
        "wide_angle": "wide angle perspective, expansive view",
        "closeup": "extreme close-up, macro detail",
        "birds_eye": "bird's eye view, top-down perspective",
        "worms_eye": "worm's eye view, looking up, dramatic angle",
    }
 
    def build(self, subject, style=None, lighting=None,
              composition=None, additional="", **mj_params):
        """構造化されたプロンプトを構築"""
        parts = [subject]
 
        if style and style in self.STYLE_PRESETS:
            parts.append(self.STYLE_PRESETS[style])
        elif style:
            parts.append(style)
 
        if lighting and lighting in self.LIGHTING_PRESETS:
            parts.append(self.LIGHTING_PRESETS[lighting])
 
        if composition and composition in self.COMPOSITION_PRESETS:
            parts.append(self.COMPOSITION_PRESETS[composition])
 
        if additional:
            parts.append(additional)
 
        prompt_text = ", ".join(parts)
 
        # Midjourney パラメータを追加
        param_parts = []
        for param, value in mj_params.items():
            if not param.startswith("--"):
                param = f"--{param}"
            if value is True:
                param_parts.append(param)
            else:
                param_parts.append(f"{param} {value}")
 
        if param_parts:
            prompt_text += " " + " ".join(param_parts)
 
        return f"/imagine prompt: {prompt_text}"
 
 
# 使用例
builder = MidjourneyPromptBuilder()
 
# フォトリアルな風景
prompt1 = builder.build(
    subject="Ancient Japanese shrine in a bamboo forest",
    style="photorealistic",
    lighting="golden_hour",
    composition="rule_of_thirds",
    ar="16:9", s="200", q="1"
)
print(f"風景: {prompt1}")
 
# コンセプトアート
prompt2 = builder.build(
    subject="A cyberpunk samurai standing on a neon-lit rooftop",
    style="concept_art",
    lighting="neon",
    composition="worms_eye",
    additional="rain, reflections, detailed armor",
    ar="2:3", s="500"
)
print(f"コンセプトアート: {prompt2}")
 
# テキスタイルパターン
prompt3 = builder.build(
    subject="Japanese wave pattern with koi fish",
    style="flat_design",
    additional="seamless pattern, navy blue and gold",
    tile=True, ar="1:1", s="100"
)
print(f"パターン: {prompt3}")

from diffusers import FluxPipeline
import torch
 
# Flux.1-dev モデルのロード
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()  # VRAM 節約
 
# 基本生成 — Flux はテキスト描画が非常に得意
image = pipe(
    prompt='A wooden sign in a forest that reads "Welcome to the '
           'Enchanted Forest" in elegant calligraphy, '
           'moss-covered, sunlight filtering through leaves',
    num_inference_steps=28,
    guidance_scale=3.5,      # Flux は低 CFG が推奨 (2.0-5.0)
    width=1024,
    height=768,
    generator=torch.Generator("cpu").manual_seed(42),
).images[0]
 
image.save("flux_basic.png")

from diffusers import FluxPipeline, FluxImg2ImgPipeline
import torch
from PIL import Image
 
# --- Flux テキスト描画の実践例 ---
pipe = FluxPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
)
pipe.enable_model_cpu_offload()
 
# テキスト描画 (Flux の最大の強み)
text_prompts = [
    'A coffee shop menu board that reads:\n'
    '"Today\'s Special\nMatcha Latte - $5\nEspresso - $4"\n'
    'chalk style on dark background',
 
    'A vintage book cover with the title "The Last Samurai" '
    'in gold embossed letters, leather texture, ornate border',
 
    'A neon sign that says "OPEN 24/7" in bright pink and blue, '
    'wet street reflection, night scene, Japanese alley',
]
 
for i, prompt in enumerate(text_prompts):
    image = pipe(
        prompt=prompt,
        num_inference_steps=28,
        guidance_scale=3.5,
        width=1024,
        height=1024,
        generator=torch.Generator("cpu").manual_seed(42 + i),
    ).images[0]
    image.save(f"flux_text_{i}.png")
    print(f"Generated: flux_text_{i}.png")
 
 
# --- Flux img2img ---
pipe_i2i = FluxImg2ImgPipeline.from_pretrained(
    "black-forest-labs/FLUX.1-dev",
    torch_dtype=torch.bfloat16,
)
pipe_i2i.enable_model_cpu_offload()
 
# 既存画像のスタイル変換
init_image = Image.open("photo.png").resize((1024, 1024))
image = pipe_i2i(
    prompt="Same scene but in Studio Ghibli anime style, "
           "vibrant colors, detailed background",
    image=init_image,
    strength=0.6,           # 元画像の維持度 (0.0=変更なし, 1.0=完全生成)
    num_inference_steps=28,
    guidance_scale=3.5,
).images[0]
image.save("flux_style_transfer.png")

import torch
from diffusers import StableDiffusionXLPipeline, DPMSolverMultistepScheduler
from pathlib import Path
import json
import time
from dataclasses import dataclass, asdict
from typing import Optional
 
@dataclass
class GenerationJob:
    """画像生成ジョブの定義"""
    prompt: str
    negative_prompt: str = "low quality, blurry, distorted, watermark"
    width: int = 1024
    height: int = 1024
    num_inference_steps: int = 25
    guidance_scale: float = 7.0
    seed: Optional[int] = None
    lora_path: Optional[str] = None
    lora_weight: float = 0.8
    output_name: Optional[str] = None
 
class BatchGenerator:
    """バッチ画像生成パイプライン"""
 
    def __init__(self, model_id="stabilityai/stable-diffusion-xl-base-1.0",
                 output_dir="./batch_output", device="cuda"):
        self.output_dir = Path(output_dir)
        self.output_dir.mkdir(parents=True, exist_ok=True)
        self.device = device
 
        self.pipe = StableDiffusionXLPipeline.from_pretrained(
            model_id,
            torch_dtype=torch.float16,
            variant="fp16",
        ).to(device)
 
        self.pipe.scheduler = DPMSolverMultistepScheduler.from_config(
            self.pipe.scheduler.config,
            use_karras_sigmas=True,
        )
        self.pipe.enable_attention_slicing()
 
    def generate_single(self, job: GenerationJob, index: int = 0):
        """単一ジョブの実行"""
        # LoRA 適用
        if job.lora_path:
            self.pipe.load_lora_weights(job.lora_path)
            self.pipe.set_adapters(
                ["default"], adapter_weights=[job.lora_weight]
            )
 
        # シード設定
        generator = None
        if job.seed is not None:
            generator = torch.Generator(self.device).manual_seed(job.seed)
 
        start_time = time.time()
 
        image = self.pipe(
            prompt=job.prompt,
            negative_prompt=job.negative_prompt,
            width=job.width,
            height=job.height,
            num_inference_steps=job.num_inference_steps,
            guidance_scale=job.guidance_scale,
            generator=generator,
        ).images[0]
 
        elapsed = time.time() - start_time
 
        # ファイル保存
        if job.output_name:
            filename = f"{job.output_name}.png"
        else:
            filename = f"batch_{index:04d}.png"
 
        filepath = self.output_dir / filename
        image.save(filepath)
 
        # メタデータ保存
        metadata = {
            **asdict(job),
            "filename": filename,
            "generation_time_sec": round(elapsed, 2),
        }
        meta_path = self.output_dir / f"{filename.replace('.png', '_meta.json')}"
        meta_path.write_text(json.dumps(metadata, ensure_ascii=False, indent=2))
 
        # LoRA をアンロード
        if job.lora_path:
            self.pipe.unload_lora_weights()
 
        return filepath, metadata
 
    def run_batch(self, jobs: list[GenerationJob]):
        """バッチ実行"""
        results = []
        total = len(jobs)
 
        for i, job in enumerate(jobs):
            print(f"[{i+1}/{total}] {job.prompt[:60]}...")
            filepath, meta = self.generate_single(job, i)
            results.append(meta)
            print(f"  -> {filepath} ({meta['generation_time_sec']}秒)")
 
        # バッチサマリー保存
        summary_path = self.output_dir / "batch_summary.json"
        summary_path.write_text(json.dumps(results, ensure_ascii=False, indent=2))
        print(f"\nバッチ完了: {total}枚生成")
 
        return results
 
 
# 使用例
generator = BatchGenerator(output_dir="./product_images")
 
jobs = [
    GenerationJob(
        prompt="Professional product photo of wireless earbuds, "
               "white background, studio lighting, 4K",
        seed=42,
        output_name="earbuds_front",
    ),
    GenerationJob(
        prompt="Professional product photo of wireless earbuds, "
               "in charging case, white background, studio lighting",
        seed=43,
        output_name="earbuds_case",
    ),
    GenerationJob(
        prompt="Lifestyle photo of person wearing wireless earbuds, "
               "jogging in park, natural lighting",
        seed=44,
        width=1024,
        height=768,
        output_name="earbuds_lifestyle",
    ),
]
 
results = generator.run_batch(jobs)

import requests
import json
import time
from pathlib import Path
import websocket
 
class ComfyUIClient:
    """ComfyUI の API クライアント
 
    ComfyUI をサーバーモードで起動: python main.py --listen
    """
 
    def __init__(self, host="127.0.0.1", port=8188):
        self.base_url = f"http://{host}:{port}"
        self.ws_url = f"ws://{host}:{port}/ws"
 
    def queue_prompt(self, workflow: dict) -> str:
        """ワークフローをキューに追加"""
        response = requests.post(
            f"{self.base_url}/prompt",
            json={"prompt": workflow},
        )
        return response.json()["prompt_id"]
 
    def get_history(self, prompt_id: str) -> dict:
        """生成履歴を取得"""
        response = requests.get(f"{self.base_url}/history/{prompt_id}")
        return response.json()
 
    def get_image(self, filename: str, subfolder: str = "",
                  folder_type: str = "output") -> bytes:
        """生成画像をダウンロード"""
        params = {
            "filename": filename,
            "subfolder": subfolder,
            "type": folder_type,
        }
        response = requests.get(
            f"{self.base_url}/view", params=params
        )
        return response.content
 
    def wait_for_completion(self, prompt_id: str, timeout: int = 120):
        """生成完了を待機"""
        start = time.time()
        while time.time() - start < timeout:
            history = self.get_history(prompt_id)
            if prompt_id in history:
                return history[prompt_id]
            time.sleep(1)
        raise TimeoutError(f"Generation timed out after {timeout}s")
 
    def generate_from_workflow(self, workflow_path: str,
                                prompt_text: str, seed: int = -1):
        """ワークフローJSON からバッチ生成"""
        with open(workflow_path) as f:
            workflow = json.load(f)
 
        # プロンプトノードを更新
        for node_id, node in workflow.items():
            if node.get("class_type") == "CLIPTextEncode":
                if "positive" in node.get("_meta", {}).get("title", "").lower():
                    node["inputs"]["text"] = prompt_text
            if node.get("class_type") == "KSampler":
                if seed >= 0:
                    node["inputs"]["seed"] = seed
 
        prompt_id = self.queue_prompt(workflow)
        result = self.wait_for_completion(prompt_id)
        return result
 
 
# 使用例
# client = ComfyUIClient()
# result = client.generate_from_workflow(
#     "workflow_sdxl.json",
#     prompt_text="A beautiful sunset over Mount Fuji",
#     seed=42,
# )

from diffusers import (
    StableDiffusionXLPipeline,
    StableDiffusionXLImg2ImgPipeline,
)
import torch
from PIL import Image
 
# 二段階生成: txt2img → img2img で品質向上
base_pipe = StableDiffusionXLPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
).to("cuda")
 
refine_pipe = StableDiffusionXLImg2ImgPipeline.from_pretrained(
    "stabilityai/stable-diffusion-xl-base-1.0",
    torch_dtype=torch.float16,
).to("cuda")
 
prompt = "A detailed fantasy map of a fictional island, "
prompt += "hand-drawn style, parchment texture, labeled locations"
negative = "low quality, blurry, modern"
 
# Step 1: 基本画像生成
base_image = base_pipe(
    prompt=prompt,
    negative_prompt=negative,
    num_inference_steps=30,
    guidance_scale=7.0,
    width=1024,
    height=1024,
    generator=torch.Generator("cuda").manual_seed(42),
).images[0]
base_image.save("map_base.png")
 
# Step 2: img2img でディテール追加
refined_image = refine_pipe(
    prompt=prompt + ", intricate details, fine lines",
    negative_prompt=negative,
    image=base_image,
    strength=0.35,          # 低い strength でディテールのみ追加
    num_inference_steps=25,
    guidance_scale=7.0,
).images[0]
refined_image.save("map_refined.png")
 
# Step 3: 部分的な Hires Fix (高解像度化)
# 画像を2倍に拡大してから img2img
upscaled = base_image.resize((2048, 2048), Image.LANCZOS)
hires_image = refine_pipe(
    prompt=prompt + ", ultra detailed, sharp lines",
    negative_prompt=negative,
    image=upscaled,
    strength=0.25,          # 構造を維持しつつ高解像度ディテール追加
    num_inference_steps=30,
    guidance_scale=7.0,
).images[0]
hires_image.save("map_hires.png")

class PromptQualityManager:
    """画像生成プロンプトの品質管理システム"""
 
    # 品質向上タグ (モデル共通)
    QUALITY_TAGS = {
        "high": [
            "masterpiece", "best quality", "highly detailed",
            "sharp focus", "professional",
        ],
        "photo": [
            "photorealistic", "DSLR quality", "natural lighting",
            "8K resolution", "RAW photo",
        ],
        "art": [
            "masterpiece", "artstation trending", "detailed illustration",
            "professional artwork", "concept art",
        ],
    }
 
    # ネガティブプロンプト (モデル共通)
    NEGATIVE_PRESETS = {
        "standard": (
            "low quality, worst quality, blurry, distorted, "
            "deformed, ugly, watermark, text, signature"
        ),
        "photo": (
            "low quality, worst quality, blurry, out of focus, "
            "overexposed, underexposed, noise, grain, "
            "watermark, text, illustration, painting, cartoon"
        ),
        "art": (
            "low quality, worst quality, blurry, distorted, "
            "deformed, ugly, amateur, bad anatomy, "
            "bad proportions, watermark, text"
        ),
        "product": (
            "low quality, blurry, distorted, watermark, text, "
            "shadow on background, cluttered background, "
            "multiple objects, person"
        ),
    }
 
    def build_prompt(self, subject, quality_preset="high",
                     additional_tags=None, style_tags=None):
        """構造化されたプロンプト生成"""
        parts = [subject]
 
        if quality_preset in self.QUALITY_TAGS:
            parts.extend(self.QUALITY_TAGS[quality_preset])
 
        if style_tags:
            parts.extend(style_tags)
 
        if additional_tags:
            parts.extend(additional_tags)
 
        return ", ".join(parts)
 
    def get_negative(self, preset="standard", additional=None):
        """ネガティブプロンプト取得"""
        neg = self.NEGATIVE_PRESETS.get(preset, self.NEGATIVE_PRESETS["standard"])
        if additional:
            neg += ", " + ", ".join(additional)
        return neg
 
 
# 使用例
pm = PromptQualityManager()
 
# フォトリアルな商品画像
prompt = pm.build_prompt(
    subject="Wireless bluetooth earbuds on marble surface",
    quality_preset="photo",
    additional_tags=["studio lighting", "45 degree angle"],
)
negative = pm.get_negative("product")
 
print(f"Prompt: {prompt}")
print(f"Negative: {negative}")
 
# アート作品
prompt_art = pm.build_prompt(
    subject="A dragon flying over a medieval castle",
    quality_preset="art",
    style_tags=["digital painting", "epic fantasy", "volumetric lighting"],
)
negative_art = pm.get_negative("art")
print(f"\nArt Prompt: {prompt_art}")
print(f"Art Negative: {negative_art}")

# ComfyUI Manager の導入 (推奨)
cd ComfyUI/custom_nodes
git clone https://github.com/ltdrdata/ComfyUI-Manager.git
 
# 手動でカスタムノードを追加
git clone https://github.com/author/custom-node-repo.git
 
# 依存パッケージのインストール
pip install -r custom-node-repo/requirements.txt
 
# ComfyUI を再起動