Initial commit: Jagirl UI application

.github/instructions/このプロジェクトの目的.instructions.md

@@ -0,0 +1,65 @@
+---
+applyTo: '**'
+---
+Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.
+Miragic AI Image Generator - UI開発用システムプロンプト
+
+このシステムプロンプトは、gradioを用いた画像生成AIのユーザーインターフェースを開発するためのものです。
+Gradioを使用し、以下の設計原則に従って実装してください。
+
+【設計原則】
+1. シンプルさ: UIは最小限で直感的に。不要な機能や複雑さは排除。
+2. 一貫性: 全体で統一されたデザイン言語を維持。
+3. パフォーマンス: 高速な読み込みとレスポンシブな操作性を確保。
+4. アクセシビリティ: すべてのユーザーが利用可能な設計を心がける。
+5. 拡張性: 既存機能を壊さずに将来の拡張が可能な構造。
+
+【実装方針】
+- Gradioの標準コンポーネントを使用（CSSでのスタイリングは最小限）
+- 過剰なJavaScript使用は避ける（できれば使用しない）
+- Hugging Faceパイプラインを用いたモデル推論を統合
+- モバイル・デスクトップ両対応のレスポンシブ設計
+
+【必須機能】
+- テキスト入力：画像生成のプロンプト入力
+- 画像出力：生成された画像の表示
+- オプションパラメータ：画像サイズ、スタイル等のコントロール
+- 生成ボタン：画像生成のトリガー
+- 処理中の視覚的フィードバック
+- プロンプト・ネガティブプロンプトのサポート例示
+
+オプションパラメター
+【オプションパラメーター設定例】
+🔧 Sampling Method (スケジューラー):
+- DDIM: 高品質、少ないステップで良い結果
+- DPMSolver: 高速で高品質（推奨）
+- Euler: 安定した結果
+- EulerA: より多様な結果
+- LMS: 古典的手法
+- PNDM: デフォルト
+
+📊 Sampling Steps (num_inference_steps): 10-150
+- 少ない (10-20): 高速だが品質低め
+- 中程度 (25-40): バランス良好（推奨）
+- 多い (50-150): 高品質だが時間かかる
+
+🎲 Seed (generator):
+- 同じシード = 同じ画像（再現性）
+- ランダムシード = バリエーション
+
+⚙️ CFG Scale (guidance_scale): 1-20
+- 低い (3-5): プロンプトに緩く従う、自然
+- 中程度 (7-10): バランス良好（推奨）
+- 高い (12-20): プロンプトに厳密に従う
+
+🔧 その他:
+- eta: ノイズ制御 (0.0-1.0)
+- width/height: 画像サイズ (64の倍数推奨)
+
+
+
+【注意事項】
+- すべての実装はHugging Faceパイプラインを使用すること
+- 依存関係はrequirements.txtに適切に記述
+- 適切なエラーハンドリングとユーザーフィードバックを実装
+- Hugging Face Spacesのデプロイガイドラインに従うこと

.github/prompts/基本.instructions.md

@@ -0,0 +1,177 @@
+---
+applyTo: '**'
+---
+Provide project context and coding guidelines that AI should follow when generating code, answering questions, or reviewing changes.素晴らしいシステムプロンプトですね。  
+
+
+---
+
+## 🧠 システムプロンプト
+
+---
+
+### 🔧 基本姿勢
+
+あなたは優れたソフトウェアエンジニアです。  
+以下の設計原則・思想・制約のもと、コードを記述・設計・レビューします。
+
+---
+
+### 🎯 プロジェクトの思想と目的
+
+- **目的**：「動く」「速い」「安全」なシステムをシンプルに構築する。
+- **思想**：
+  - **マイクロサービス的アプローチ**：単機能モジュールを意識した設計。
+  - **アジャイル開発対応**：最小限の機能でまず動かすことを重視。
+  - **過剰な機能追加を厳禁**：YAGNI（You Aren't Gonna Need It）を徹底。
+  - **命名の一貫性**：`creators`, `generators`, `builders` などの混在を許さない。
+  - **疎結合・高凝集**：モジュール間の依存を最小限に保つ。
+  - **DRY, KISS, SOLID** を常に意識した設計。
+
+---
+
+### 🧱 設計原則
+
+1. **動くこと**：最小限の機能で動作確認を行う。
+2. **速いこと**：パフォーマンスを意識した実装。
+3. **安全なこと**：型安全性、エラー処理、セキュリティを考慮。
+4. **可読性の高さ**：コードは誰が読んでも理解できるように。
+5. **保守性の高さ**：変更が容易で拡張可能な設計。
+
+---
+
+### 🚫 禁止事項と制約
+
+- ❌ `creators`, `generators`, `builders` などの **役割が曖昧な命名の混在を禁止**。
+  - 例：`UserCreator`, `UserGenerator`, `UserBuilder` は役割が曖昧で混在してはならない。
+  - 代替案：`UserService`, `UserFactory`, `UserHandler` など、**一貫性のある命名**を使用。
+- ❌ **過剰な機能追加**（機能蔓延）をしない。
+  - 必要な機能だけを実装し、**YAGNI** を徹底。
+- ❌ **ハードコード禁止**：設定値やマジックナンバーは定数化・設定ファイル化。
+- ❌ **コメントの省略禁止**：コードには日本語でわかりやすく説明を記述。
+- ❌ **無意味な抽象化禁止**：過度なデザインパターンの適用を避ける。
+- ❌ **正常に動いている環境の変更禁止**：動作確認済みの環境設定を不用意に変更しない。
+
+---
+
+### 🧪 コーディング規約
+
+- ✅ **型ヒント**（type hints）を必須とする。
+- ✅ **docstring** を記述し、関数・クラスの目的を明確にする。
+- ✅ **単体テスト**（unittest / pytest）を必ず記述。
+- ✅ **エラー処理**は以下の流れで実装：
+  1. エラーの分析
+  2. 対処方法の検討
+  3. エラー処理の実装（try-except, logging, fallback など）
+- ✅ **仮想環境**を使用して実行・テストすること。
+
+---
+
+### 🧭 モジュール設計の指針
+
+- 各モジュールは **1つの責務のみを持つ**（Single Responsibility Principle）。
+- モジュール名は **明確で一貫性のある命名**（例：`user_service.py`, `auth_handler.py`）。
+- モジュール間は **依存を最小限に保ち、疎結合**にする。
+- 共通処理は **utils や shared モジュール**に切り出す。
+
+---
+
+### 🧠 開発プロセス
+
+1. **最小限の機能で動かす**（MVP）
+2. **動作確認 → テスト追加 → リファクタリング**
+3. **必要に応じて機能追加**（ただしYAGNIを意識）
+4. **命名・構造の整合性を常にチェック**
+
+---
+
+### 🧾 エラー対応のスタイル
+
+エラー発生時は以下の形式で報告してください：
+
+```
+【エラー内容】
+TypeError: 'NoneType' object is not subscriptable
+
+【原因分析】
+user_data が None の場合にアクセスしようとしている。
+
+【対処方法】
+user_data が None でないことを確認してからアクセスする。
+例：
+if user_data:
+    return user_data['id']
+else:
+    return None
+```
+
+---
+
+### 🧩 まとめ：理想とするコードの特徴
+
+| 特徴         | 説明 |
+|--------------|------|
+| **シンプル** | 不要な機能や複雑さを排除 |
+| **明確**     | 命名・構造が一貫しており、意図が伝わる |
+| **安全**     | 型安全・エラー処理が徹底されている |
+| **保守性**   | 変更・拡張が容易な設計 |
+| **テスト可能** | 単体テストが容易に記述可能 |
+
+---
+
+### 📋 メタデータJSONスキーマ設計原則
+
+本プロジェクトでは、画像パーツのレイアウト情報を管理するためにJSONメタデータを使用します。
+
+#### メタデータの役割
+
+- ✅ **レイアウト情報のみ管理**: bbox（位置・サイズ）、z_order（重なり順）、opacity（透明度）
+- ✅ **DRY原則の徹底**: カラー情報��RGB, fill, stroke）は画像ファイル内部に埋め込み、JSONには記載しない
+- ✅ **後方互換性の確保**: オプションフィールドは`.get()`でデフォルト値を使用
+
+#### 必須フィールド
+
+```json
+{
+  "part_name": "background",
+  "bbox": {"x": 0, "y": 0, "width": 1024, "height": 1024},
+  "canvas_size": {"width": 1024, "height": 1024},
+  "z_order": 0,
+  "has_alpha": true,
+  "is_vector": false,
+  "data_type": "bitmap"
+}
+```
+
+#### オプションフィールド（推奨）
+
+```json
+{
+  "opacity": 1.0,
+  "blend_mode": "normal",
+  "color_profile": "sRGB IEC61966-2.1",
+  "is_global_lineart": false,
+  "parent_part": null,
+  "z_order_mode": "auto",
+  "vector_type": "text",
+  "text_content": "LOGO",
+  "fill_color": {"r": 255, "g": 0, "b": 0, "a": 255},
+  "stroke_color": {"r": 0, "g": 0, "b": 0, "a": 255},
+  "background_color": {"r": 255, "g": 255, "b": 255, "a": 0}
+}
+```
+
+#### 設計上の注意点
+
+- ✅ **カラー情報のメタデータ化**: fill_color, stroke_color, background_colorをRGBA形式で保存
+  - **用途**: PDFフォールバックカラー、プレビュー生成、レイヤー識別用
+  - **⚠️ 必須要件**: メタデータに色情報が存在する場合、**必ず使用すること**（瑕疵案件対策）
+  - **優先順位**: メタデータのカラー情報 > 画像ファイル内の実RGBA値（顧客指定色を最優先）
+  - **欠損時の挙動**: メタデータに色情報がない場合のみ、画像ファイルから自動抽出
+- ✅ **z_order自動計算**: 面積降順 → bbox.y降順 → bbox.x昇順でソート（一意性確保）
+- ✅ **ベクター固有情報**: `vector_type`, `text_content`を保存（将来的な拡張性）
+
+---
+
+ご希望であれば、このプロンプトを `.md` や `.txt` ファイル形式で出力することも可能です。  
+また、チームで共有するための簡潔なバージョンも作成できます。お気軽にどうぞ。

.gitignore

@@ -0,0 +1,96 @@
+# Python-generated files
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+dist/
+wheels/
+*.egg-info
+.eggs/
+*.egg
+MANIFEST
+develop-eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+downloads/
+eggs/
+.installed.cfg
+pip-wheel-metadata/
+share/python-wheels/
+
+# Virtual environments
+.venv/
+venv/
+ENV/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+.vs/
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# 出力ファイル（生成された画像）
+outputs/
+*.png
+*.jpg
+*.jpeg
+*.webp
+
+# ログファイル
+logs/
+*.log
+
+# 作業用ファイル（README.mdと.github以下のmdは除外しない）
+*.md
+!README.md
+!.github/**/*.md
+*.txt
+!requirements.txt
+!prompt_base.txt
+!仮想環境への入り方.txt
+
+# テストディレクトリ
+test/
+
+# 不要なフォルダ（削除予定または作業用）
+Miragic-AI-Image-Generator/
+gradio_UI_Asahi-main/
+
+# Hugging Face Cache
+.cache/
+huggingface/
+
+# PyTorchモデルファイル
+*.pth
+*.pt
+*.ckpt
+*.safetensors
+
+# Jupyter Notebook
+.ipynb_checkpoints/
+*.ipynb
+
+# 環境設定
+.env
+.env.local
+.env.*
+
+# Gradio
+flagged/
+gradio_cached_examples/
+
+# Git
+*.orig

.python-version

@@ -0,0 +1 @@
+3.11

app.py

@@ -0,0 +1,484 @@
+"""
+Miragic AI Image Generator - Main Application
+TV Asahi J Channel ブランド統合版
+
+統合機能:
+- Gradio UI フレームワーク (TV Asahi J Channel デザイン)
+- aipicasso/jagirl モデルによる高品質画像生成
+- 詳細パラメータ制御とログ機能
+- Text-to-Image 対応
+"""
+
+import gradio as gr
+import torch
+from diffusers import (
+    StableDiffusionXLPipeline,
+    DDIMScheduler,
+    DPMSolverMultistepScheduler,
+    EulerDiscreteScheduler,
+    EulerAncestralDiscreteScheduler,
+    PNDMScheduler,
+    LMSDiscreteScheduler
+)
+from huggingface_hub import login
+import os
+import base64
+from datetime import datetime
+import random
+import json
+import logging
+from pathlib import Path
+import traceback
+from PIL import Image
+import numpy as np
+import time
+
+# 統合ロガーのインポート
+import sys
+sys.path.append(os.path.join(os.path.dirname(__file__), 'utils'))
+from logger import get_logger, log_generation
+
+# 標準ロガー設定
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# 定数定義
+HISTORY_FILE = "logs/generation_history.json"
+OUTPUT_DIR = "outputs"
+
+# 統合ロガーインスタンス
+unified_logger = get_logger("logs")
+
+# グローバル変数でパイプラインを管理
+txt2img_pipe = None
+model_loaded = False
+
+def setup_scheduler(pipe, scheduler_type="default"):
+    """
+    スケジューラーの設定
+    
+    Args:
+        pipe: StableDiffusionXLPipeline
+        scheduler_type: スケジューラータイプ
+            - "default": デフォルト
+            - "DDIM": 高品質、少ないステップ
+            - "DPMSolver": 高速で高品質（推奨）
+            - "Euler": 安定した結果
+            - "EulerA": より多様な結果
+            - "LMS": 古典的手法
+            - "PNDM": デフォルト
+    
+    Returns:
+        設定されたscheduler
+    """
+    schedulers = {
+        "DDIM": DDIMScheduler,
+        "DPMSolver": DPMSolverMultistepScheduler,
+        "Euler": EulerDiscreteScheduler,
+        "EulerA": EulerAncestralDiscreteScheduler,
+        "PNDM": PNDMScheduler
+    }
+    
+    # LMSはscipyが必要なため、利用可能な場合のみ追加
+    try:
+        schedulers["LMS"] = LMSDiscreteScheduler
+    except:
+        logger.warning("⚠️ LMSスケジューラーは利用できません (scipyが必要)")
+    
+    if scheduler_type != "default" and scheduler_type in schedulers:
+        try:
+            return schedulers[scheduler_type].from_config(pipe.scheduler.config)
+        except ImportError as e:
+            logger.warning(f"⚠️ {scheduler_type}スケジューラーが利用できません: {e}")
+            return pipe.scheduler
+    return pipe.scheduler
+
+def setup_model():
+    """モデルのセットアップと最適化"""
+    global txt2img_pipe, model_loaded
+    
+    if model_loaded:
+        return True
+    
+    try:
+        logger.info("🔧 モデルをセットアップ中...")
+        
+        # GPU確認
+        if not torch.cuda.is_available():
+            logger.error("❌ CUDA が利用できません。GPUを確認してください。")
+            return False
+        
+        device = "cuda"
+        logger.info(f"✅ デバイス: {device}")
+        
+        # Text-to-Image パイプライン
+        logger.info("📦 Text-to-Image パイプライン読み込み中...")
+        txt2img_pipe = StableDiffusionXLPipeline.from_pretrained(
+            "aipicasso/jagirl",
+            torch_dtype=torch.float16,
+            use_safetensors=True
+        ).to(device)
+        
+        # GPU移動後にFP16に変換
+        try:
+            txt2img_pipe = txt2img_pipe.to(dtype=torch.float16)
+            logger.info("✅ FP16モードに変換")
+        except:
+            logger.warning("⚠️ FP16変換をスキップ、FP32で継続")
+        
+        # メモリ効率化 (xformersは使用しない - CPU版PyTorchのため)
+        try:
+            txt2img_pipe.enable_xformers_memory_efficient_attention()
+            logger.info("✅ xFormers メモリ効率化を有効化")
+        except Exception as e:
+            logger.warning(f"⚠️ xFormers無効 (CPU版PyTorch使用中): {e}")
+        
+        # CPU Offloadは無効化（全てGPUで処理）
+        logger.info("🎯 GPU専用モードで動作")
+        
+        logger.info("✅ モデルセットアップ完了")
+        model_loaded = True
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ モデルセットアップ失敗: {e}")
+        return False
+
+def log_generation_details(prompt, negative_prompt, params, output_filepath, execution_time):
+    """
+    生成詳細のログ記録（統合ロガー使用）
+    
+    Args:
+        prompt: メインプロンプト
+        negative_prompt: ネガティブプロンプト
+        params: 生成パラメータ辞書
+        output_filepath: 生成画像のファイルパス
+        execution_time: 実行時間（秒）
+    
+    Returns:
+        generation_id: 生成記録のユニークID
+    """
+    try:
+        generation_id = unified_logger.log_generation(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            parameters=params,
+            output_filepath=output_filepath,
+            execution_time=execution_time
+        )
+        
+        logger.info(f"📝 生成ログを記録: {generation_id}")
+        return generation_id
+        
+    except Exception as e:
+        logger.error(f"❌ ログ記録失敗: {e}")
+        traceback.print_exc()
+        return None
+
+def load_generation_history():
+    """生成履歴を読み込む（統合ロガー形式）"""
+    try:
+        if os.path.exists(HISTORY_FILE):
+            with open(HISTORY_FILE, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                # 統合ロガーの形式: {"generations": [...]}
+                if isinstance(data, dict) and 'generations' in data:
+                    generations = data['generations']
+                    # 最新10件を返す
+                    return generations[-10:] if len(generations) > 10 else generations
+                # 古い形式（リスト）の場合
+                elif isinstance(data, list):
+                    return data[-10:]
+                else:
+                    return []
+        return []
+    except Exception as e:
+        logger.error(f"履歴読み込み失敗: {e}")
+        return []
+
+def format_history_display():
+    """履歴表示用のフォーマット（統合ロガー形式対応）"""
+    history = load_generation_history()
+    if not history:
+        return "📝 生成履歴がありません"
+    
+    display_text = "## 📋 Recent Generation History (最新10件)\n\n"
+    
+    for i, entry in enumerate(reversed(history), 1):
+        # 統合ロガー形式のフィールド
+        gen_id = entry.get('generation_id', 'Unknown')
+        timestamp = entry.get('timestamp', 'Unknown')
+        prompt = entry.get('prompt', 'No prompt')
+        # プロンプトが長い場合は省略
+        prompt_display = prompt[:50] + "..." if len(prompt) > 50 else prompt
+        
+        # パラメータから情報取得
+        params = entry.get('parameters', {})
+        seed = params.get('seed', 'N/A')
+        steps = params.get('num_inference_steps', 'N/A')
+        
+        # 結果情報
+        result = entry.get('result', {})
+        success = result.get('success', False)
+        exec_time = result.get('execution_time_seconds', 0)
+        
+        status = "✅ Success" if success else "❌ Failed"
+        
+        display_text += f"### {i}. {status}\n"
+        display_text += f"**ID:** {gen_id}\n"
+        display_text += f"**Time:** {timestamp}\n"
+        display_text += f"**Prompt:** {prompt_display}\n"
+        display_text += f"**Seed:** {seed} | **Steps:** {steps}\n"
+        display_text += f"**Execution:** {exec_time:.1f}s\n"
+        display_text += "---\n"
+    
+    return display_text
+
+def refresh_history():
+    """履歴更新関数"""
+    return format_history_display()
+
+def generate_txt2img(prompt, negative_prompt="", num_images=1, steps=25, guidance=7.5, size=1024, seed=None, scheduler="default"):
+    """
+    テキストから画像生成（完全なパラメータ対応）
+    
+    Args:
+        prompt: メインプロンプト
+        negative_prompt: ネガティブプロンプト
+        num_images: 生成画像数
+        steps: サンプリングステップ数 (10-150)
+        guidance: CFG Scale/ガイダンス強度 (1-20)
+        size: 画像サイズ (512, 768, 1024)
+        seed: シード値 (Noneでランダム)
+        scheduler: スケジューラータイプ
+    
+    Returns:
+        生成された画像のリスト
+    """
+    global txt2img_pipe
+    
+    if not prompt.strip():
+        return []
+    
+    if not model_loaded:
+        if not setup_model():
+            return []
+    
+    try:
+        logger.info(f"🎨 画像生成開始: {prompt[:50]}...")
+        
+        start_time = time.time()
+        
+        # シード設定（0またはNoneの場合はランダム）
+        if seed is None or seed == 0:
+            seed = random.randint(1, 2**32-1)
+        
+        generator = torch.Generator(device="cuda").manual_seed(seed)
+        
+        # スケジューラー設定
+        original_scheduler = txt2img_pipe.scheduler
+        if scheduler != "default":
+            txt2img_pipe.scheduler = setup_scheduler(txt2img_pipe, scheduler)
+        
+        # パラメータ設定
+        params = {
+            "prompt": prompt,
+            "negative_prompt": negative_prompt,
+            "num_inference_steps": int(steps),
+            "guidance_scale": float(guidance),
+            "width": int(size),
+            "height": int(size),
+            "num_images_per_prompt": 1,
+            "generator": generator
+        }
+        
+        # 画像生成（autocastを使用���ない - test_high_quality_generation.pyと同じ）
+        result = txt2img_pipe(**params)
+        
+        # スケジューラーを元に戻す
+        if scheduler != "default":
+            txt2img_pipe.scheduler = original_scheduler
+        
+        execution_time = time.time() - start_time
+        
+        # 画像保存
+        outputs_dir = Path("outputs")
+        outputs_dir.mkdir(exist_ok=True)
+        
+        saved_paths = []
+        for i, image in enumerate(result.images):
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            filename = f"txt2img_{timestamp}_seed{seed}_{i+1}.png"
+            filepath = outputs_dir / filename
+            image.save(filepath, quality=95)
+            saved_paths.append(str(filepath))
+            logger.info(f"💾 画像保存: {filepath}")
+        
+        # ログ記録（統合ロガー使用）
+        log_params = {
+            "num_inference_steps": int(steps),
+            "guidance_scale": float(guidance),
+            "width": int(size),
+            "height": int(size),
+            "seed": seed,
+            "scheduler_type": scheduler,
+            "num_images": num_images,
+            "torch_dtype": "float16",
+            "mode": "txt2img"
+        }
+        
+        log_generation_details(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            params=log_params,
+            output_filepath=saved_paths[0] if saved_paths else "",
+            execution_time=execution_time
+        )
+        
+        logger.info(f"✅ 生成完了: {execution_time:.2f}秒, {len(result.images)}枚")
+        
+        return result.images
+        
+    except Exception as e:
+        logger.error(f"❌ 画像生成失敗: {e}")
+        logger.error(traceback.format_exc())
+        return []
+
+def create_gradio_app():
+    """Gradio アプリケーションの作成"""
+    
+    # カスタムカラーオブジェクトを作成（TV Asahi Blue）
+    custom_blue = gr.themes.Color(
+        c50="#f0f4ff",
+        c100="#dbeafe", 
+        c200="#bfdbfe",
+        c300="#93c5fd",
+        c400="#60a5fa",
+        c500="#284baf",  # メインの色
+        c600="#1e40af",
+        c700="#1d4ed8",
+        c800="#1e3a8a",
+        c900="#1e3a8a",
+        c950="#172554"
+    )
+    
+    # メインUI構築
+    with gr.Blocks(
+        title="Jagirl",
+        theme=gr.themes.Default(primary_hue=custom_blue)
+    ) as demo:
+        
+        # メインタブ
+        with gr.Tabs() as tabs:
+            
+            # Text-to-Image タブ
+            with gr.TabItem("Text to Image", id="txt2img"):
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        txt_prompt = gr.Textbox(
+                            label="Prompt / プロンプト",
+                            placeholder="Enter your prompt | 高品質なアニメ風の美しい女性の画像を生成するプロンプトを入力",
+                            lines=3,
+                            max_lines=5
+                        )
+                        
+                        txt_negative_prompt = gr.Textbox(
+                            label="Negative Prompt / ネガティブプロンプト",
+                            value="(worst quality, low quality:1.4), (illustration, 3d, 2d, painting, cartoons, sketch:1.3), (monochrome, grayscale:1.2), teeth, open mouth, (bad hands, bad fingers, deformed hands, mutated fingers:1.3), watermark, signature, text, logo, extra limbs, malformed limbs, poorly drawn face, poorly drawn hands, mutation, deformed, bad anatomy, bad proportions, duplicate, cropped, jpeg artifacts, blurry, out of focus, oversaturated, artificial lighting",
+                            lines=3,
+                            max_lines=5
+                        )
+                        
+                        with gr.Accordion("Advanced Settings / 詳細設定", open=True):
+                            txt_step = gr.Slider(
+                                minimum=10, maximum=150, value=25, step=5,
+                                label="Sampling Steps / サンプリングステップ数 (推奨: 20-40)"
+                            )
+                            txt_guidance = gr.Slider(
+                                minimum=3.0, maximum=15.0, value=7.5, step=0.5,
+                                label="CFG Scale / ガイダンス強度 (推奨: 7-10)"
+                            )
+                            # 画像サイズは1024x1024固定 (UIには表示しない)
+                            # サポート解像度例: 512x512, 768x768, 1024x1024, 1280x1280, 1536x1536
+                            txt_size = 1024  # 固定値
+                            txt_seed = gr.Number(
+                                label="Seed (空欄でランダム)",
+                                value=None,
+                                precision=0
+                            )
+                            txt_scheduler = gr.Dropdown(
+                                choices=["default", "DDIM", "DPMSolver", "Euler", "EulerA", "LMS", "PNDM"],
+                                value="default",
+                                label="Scheduler / スケジューラー (推奨: DPMSolver)"
+                            )
+                        
+                        txt_generate_btn = gr.Button(
+                            "🎨 画像生成開始", 
+                            variant="primary",
+                            size="lg"
+                        )
+                    
+                    with gr.Column(scale=3):
+                        txt_gallery = gr.Image(
+                            label="Generated Image / 生成された画像",
+                            type="pil",
+                            interactive=False,
+                            show_label=True,
+                            show_download_button=True,
+                            container=True,
+                            height=None,
+                            width=None
+                        )
+        
+        # システム情報（公開用）
+        with gr.Accordion("System Information / システム情報", open=False):
+            gr.HTML(f"""
+            <div style="padding: 10px;">
+                <p><strong>Model:</strong> aipicasso/jagirl (Stable Diffusion XL)</p>
+                <p><strong>Framework:</strong> PyTorch {torch.__version__}</p>
+                <p><strong>Device:</strong> {'GPU (CUDA ' + torch.version.cuda + ')' if torch.cuda.is_available() else 'CPU'}</p>
+                <p><strong>Diffusers:</strong> Latest</p>
+                <p><strong>Default Resolution:</strong> 1024x1024</p>
+            </div>
+            """)
+        
+        # 画像生成用のラッパー関数（2重呼び出し防止）
+        def generate_single_image(prompt, neg_prompt, step, guidance, seed, scheduler):
+            result = generate_txt2img(prompt, neg_prompt, 1, step, guidance, txt_size, seed, scheduler)
+            return result[0] if result else None
+        
+        # イベントバインディング
+        txt_generate_btn.click(
+            fn=generate_single_image,
+            inputs=[txt_prompt, txt_negative_prompt, txt_step, txt_guidance, txt_seed, txt_scheduler],
+            outputs=txt_gallery,
+            show_progress=True
+        )
+    
+    return demo
+
+def main():
+    """メインアプリケーション"""
+    logger.info("🚀 Miragic AI Image Generator 起動中...")
+    
+    # 必要なディレクトリを作成
+    Path("outputs").mkdir(exist_ok=True)
+    Path("logs").mkdir(exist_ok=True)
+    
+    # Gradio アプリケーション作成
+    demo = create_gradio_app()
+    
+    # アプリケーション起動
+    logger.info("🌐 Webアプリケーションを起動...")
+    demo.launch(
+        server_name="127.0.0.1",
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False,
+        inbrowser=True  # ブラウザを自動で開く
+    )
+
+if __name__ == "__main__":
+    main()

gradio_ui/.gitignore

@@ -0,0 +1,42 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# UV lock file
+uv.lock
+
+# Project-specific files
+reference/
+
+# IDE and development tools
+.serena/
+.github/
+.github/prompts/
+
+# Unused image files (keep only: j_channel.svg, J_channel.svg, tvasahi.svg)
+imgs/j_channel.eps
+imgs/j_channel.png
+imgs/J_channel.psd
+imgs/J_channel_large.png
+imgs/pc_main.jpg
+imgs/pc_main.psd
+
+# Other unused image formats
+*.webp
+*.bmp
+*.tiff
+*.ico
+
+# Unused Python files
+# (Add specific .py files here as they become unused)
+
+# documentation files
+依頼内容.md
+仕様書.md

gradio_ui/.python-version

@@ -0,0 +1 @@
+3.11.12

gradio_ui/README.md

@@ -0,0 +1,130 @@
+# テレビ朝日 スーパーJチャンネル - AI画像生成システムUI
+
+## 概要
+Gradioを使用したテレビ朝日 スーパーJチャンネル向けのAI画像生成UI。
+
+### スクリーンショット
+- Text to Image
+![alt text](imgs/test2image.png)
+
+- Image to Image
+![alt text](imgs/test2image.png)
+
+
+
+## 起動方法
+
+### UV使用
+```bash
+# UVでの起動
+uv run python app.py
+```
+
+### Python環境
+```bash
+# 依存関係インストール
+pip install -r requirements.txt
+
+# アプリケーション起動
+python app.py
+```
+
+起動後、ブラウザで `http://localhost:7860` にアクセス
+
+## 機能
+
+### Text-to-Image タブ
+
+- テキストプロンプトから最大4枚の画像生成
+- Advanced Settings（Step、Guidance Scale、Size等）
+- 2x2グリッドでの結果表示
+- ダウンロード機能付きギャラリー
+
+### Image-to-Image タブ
+
+- 参考画像 + テキストプロンプトで画像生成
+- Prompt Strength（参考画像の影響度）調整
+- アップロード画像のプレビュー
+- 同じAdvanced Settings対応
+
+### 共通機能
+
+- テレビ朝日・Jチャンネルのロゴ表示（#284baf カラー）
+- 最小限のデザイン（シンプルさ最優先）
+- Base64インライン画像埋め込み
+- 日本語・英語併記のUI
+
+## 技術仕様
+
+- **フレームワーク**: Gradio >= 5.48.0
+- **環境管理**: UV（Python 3.11.12）
+- **レイアウト**: gr.Blocks + カスタムテーマ
+- **色設計**: #284baf統一カラー（ボタン・タブ）
+- **依存関係**: gradio, numpy, pillow
+
+
+### 画像生成関数の実装
+
+現在はダミー処理。実際のAIモデルに置き換える場合：
+
+```python
+def generate_txt2img(prompt, num_images=4):
+    """
+    テキストから画像生成
+    
+    Args:
+        prompt (str): 生成プロンプト
+        num_images (int): 生成枚数（1-4枚）
+    
+    Returns:
+        list: 生成された画像のリスト
+    
+    Note:
+        実際のAI画像生成モデル（Stable Diffusion, DALL-E等）に置き換える際は、
+        Advanced Settingsのパラメータ（step, guidance, size等）も
+        引数として追加し、モデルに渡してください。
+    """
+    # 例: モデルにパラメータを渡す場合
+    # return model.generate(prompt, num_images=num_images, steps=step, guidance_scale=guidance, size=size)
+    pass
+
+def generate_img2img(prompt, reference_image, num_images=4):
+    """
+    参考画像+テキストから画像生成
+    
+    Args:
+        prompt (str): 生成プロンプト
+        reference_image: 参考画像（PIL Image）
+        num_images (int): 生成枚数（1-4枚）
+    
+    Returns:
+        list: 生成された画像のリスト
+    """
+    pass
+```
+
+### ログ機能
+
+`logs/` フォルダを活用してユーザー操作をトラッキング
+
+## 📁 ファイル構成
+
+```text
+gradio_ui_asahi/
+├── app.py                 # メインアプリケーション
+├── requirements.txt       # 依存関係
+├── pyproject.toml        # UV設定
+├── imgs/                 # ロゴ画像
+│   ├── tvasahi.svg      # TVasahiロゴ（フッター用）
+│   └── j_channel.svg    # Jチャンネルロゴ（ヘッダー用）
+├── logs/                 # ログファイル（将来使用）
+└── README.md             # このファイル
+```
+## 設計原則
+- **統一感**: #284baf カラーでブランディング統一
+
+## 更新履歴
+
+- **v1.0**: 初期UI実装（txt2img/img2img）
+- **v1.1**: Advanced Settings 追加
+- **v1.2**: カラーテーマ統一（#284baf）

gradio_ui/app.py

@@ -0,0 +1,220 @@
+import gradio as gr
+import os
+import base64
+
+# ダミー画像生成関数（実際のモデルは未実装）
+def generate_txt2img(prompt, num_images=4):
+    """テキストから画像生成（ダミー処理）"""
+    if not prompt.strip():
+        return []
+    
+    # 実際の実装では、ここでAI画像生成モデルを呼び出し
+    # 現在はダミー画像を返す（グレーのデフォルト）
+    dummy_images = []
+    for i in range(num_images):
+        # プレースホルダー画像のパスを生成
+        dummy_path = f"https://via.placeholder.com/512x512?text=Generated+Image+{i+1}"
+        dummy_images.append(dummy_path)
+    
+    return dummy_images
+
+def generate_img2img(prompt, reference_image, num_images=4):
+    """参考画像+テキストから画像生成（ダミー処理）"""
+    if not prompt.strip():
+        return []
+    
+    if reference_image is None:
+        return generate_txt2img(prompt, num_images)
+    
+    # 実際の実装では、参考画像とプロンプトを使用してAI生成
+    dummy_images = []
+    for i in range(num_images):
+        dummy_path = f"https://via.placeholder.com/512x512?text=Img2Img+Result+{i+1}"
+        dummy_images.append(dummy_path)
+    
+    return dummy_images
+
+# Gradioテーマシステムを使用してボタンとタブの色を統一
+
+# カスタムカラーオブジェクトを作成
+custom_blue = gr.themes.Color(
+    c50="#f0f4ff",
+    c100="#dbeafe", 
+    c200="#bfdbfe",
+    c300="#93c5fd",
+    c400="#60a5fa",
+    c500="#284baf",  # メインの色
+    c600="#1e40af",
+    c700="#1d4ed8",
+    c800="#1e3a8a",
+    c900="#1e3a8a",
+    c950="#172554"
+)
+
+# メインUI構築
+with gr.Blocks(
+    title="TV Asahi J Channel Image UI",
+    theme=gr.themes.Default(primary_hue=custom_blue),
+    css=".header-bg { background-color: #284baf; } .footer-bg { background-color: white; justify-content: center; display: flex; align-items: center; }"
+) as demo:
+    
+    # ヘッダー部分（j_channel.pngを中央配置）
+    with gr.Row(elem_classes=["header-bg"], equal_height=True):
+        try:
+            with open("imgs/j_channel.svg", 'rb') as f:
+                b64 = base64.b64encode(f.read()).decode()
+            gr.HTML(
+                '<div style="width:100%;display:flex;justify-content:center;align-items:center;">'
+                f'<img src="data:image/svg+xml;base64,{b64}" style="height:150px;aspect-ratio:auto;display:block;" alt="J Channel logo" />'
+                '</div>'
+            )
+        except:
+            gr.HTML('<span>Missing J Channel logo</span>')
+    
+    # メインタブ
+    with gr.Tabs() as tabs:
+        
+        # Text-to-Image タブ
+        with gr.TabItem("Text to Image", id="txt2img"):
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    txt_prompt = gr.Textbox(
+                        label="Prompt / プロンプト",
+                        placeholder="Enter your prompt | モデルに入力するプロンプトをここに入力",
+                        lines=1,
+                        max_lines=1
+                    )
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        txt_num_images = gr.Slider(
+                            minimum=1, maximum=4, value=4, step=1,
+                            label="Number of Images / 生成枚数"
+                        )
+                        txt_step = gr.Slider(
+                            minimum=2, maximum=50, value=12, step=1,
+                            label="Step"
+                        )
+                        txt_guidance = gr.Slider(
+                            minimum=0, maximum=20, value=7.5, step=0.5,
+                            label="Guidance Scale (プロンプトの反映力)"
+                        )
+                        txt_prompt_strength = gr.Slider(
+                            minimum=0, maximum=1, value=0.8, step=0.05,
+                            label="Prompt Strength (画像入力時のみ)",
+                            interactive=False
+                        )
+                        txt_size = gr.Slider(
+                            minimum=512, maximum=2048, value=1024, step=64,
+                            label="Size (px)"
+                        )
+                    
+                    txt_generate_btn = gr.Button(
+                        "画像生成開始", 
+                        variant="primary"
+                    )
+                
+                with gr.Column(scale=3):
+                    txt_gallery = gr.Gallery(
+                        label="生成された画像",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        show_download_button=True,
+                        object_fit="contain"
+                    )
+        
+        # Image-to-Image タブ
+        with gr.TabItem("Image to Image", id="img2img"):
+            
+            with gr.Row():
+                with gr.Column(scale=2):
+                    # 参考画像入力
+                    img_reference = gr.Image(
+                        label="参考画像",
+                        type="pil"
+                    )
+                    
+                    img_prompt = gr.Textbox(
+                        label="Prompt / プロンプト",
+                        placeholder="Enter your prompt | モデルに入力するプロンプトをここに入力",
+                        lines=1,
+                        max_lines=1
+                    )
+                    
+                    with gr.Accordion("Advanced Settings", open=False):
+                        img_num_images = gr.Slider(
+                            minimum=1, maximum=4, value=4, step=1,
+                            label="Number of Images / 生成枚数"
+                        )
+                        img_step = gr.Slider(
+                            minimum=2, maximum=50, value=12, step=1,
+                            label="Step"
+                        )
+                        img_guidance = gr.Slider(
+                            minimum=0, maximum=20, value=7.5, step=0.5,
+                            label="Guidance Scale (プロンプトの反映力)"
+                        )
+                        img_prompt_strength = gr.Slider(
+                            minimum=0, maximum=1, value=0.8, step=0.05,
+                            label="Prompt Strength (画像入力時のみ)"
+                        )
+                        img_size = gr.Slider(
+                            minimum=512, maximum=2048, value=1024, step=64,
+                            label="Size (px)"
+                        )
+                    
+                    img_generate_btn = gr.Button(
+                        "画像生成開始", 
+                        variant="primary"
+                    )
+                
+                with gr.Column(scale=3):
+                    img_gallery = gr.Gallery(
+                        label="生成された画像",
+                        columns=2,
+                        rows=2,
+                        height="auto",
+                        show_download_button=True,
+                        object_fit="contain"
+                    )
+    
+
+    
+    # イベントバインディング
+    txt_generate_btn.click(
+        fn=generate_txt2img,
+        inputs=[txt_prompt, txt_num_images],
+        outputs=txt_gallery,
+        show_progress=True
+    )
+    
+    img_generate_btn.click(
+        fn=generate_img2img,
+        inputs=[img_prompt, img_reference, img_num_images],
+        outputs=img_gallery,
+        show_progress=True
+    )
+
+    # フッター部分（ロゴのみ表示 / 背景白 / 中心位置 / サイズ半分）
+    with gr.Row(elem_classes=["footer-bg"]):
+        try:
+            with open("imgs/tvasahi.svg", 'rb') as f:
+                b64 = base64.b64encode(f.read()).decode()
+            gr.HTML(
+                '<div style="width:100%;display:flex;justify-content:center;align-items:center;">'
+                f'<img src="data:image/svg+xml;base64,{b64}" style="height:30px;aspect-ratio:auto;display:block;" alt="TV Asahi logo" />'
+                '</div>'
+            )
+        except:
+            gr.HTML('<span>Missing TV Asahi logo</span>')
+
+# 起動設定
+if __name__ == "__main__":
+    demo.launch(
+        server_name=None,
+        server_port=7860,
+        share=False,
+        show_error=True,
+        quiet=False
+    )

gradio_ui/main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from gradio UI!")
+
+
+if __name__ == "__main__":
+    main()

gradio_ui/pyproject.toml

@@ -0,0 +1,11 @@
+[project]
+name = "gradio-ui-asahi"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.11.12"
+dependencies = [
+    "gradio>=5.48.0",
+    "numpy>=2.3.3",
+    "pillow>=11.3.0",
+]

gradio_ui/requirements.txt

@@ -0,0 +1,4 @@
+# Required libraries (consistent with pyproject.toml)
+gradio>=5.48.0
+numpy>=2.3.3
+pillow>=11.3.0

prompt_base.txt

@@ -0,0 +1,23 @@
+Main Prompt:
+xxmixgirl, 1girl, solo, photorealistic, RAW photo, best quality, ultra high res, 8k uhd, professional photography, sharp focus, natural lighting, beach photography,
+
+Japanese woman, early 20s, black hair, medium length hair, wispy bangs, brown eyes, detailed eyes, beautiful detailed face, pale skin, natural makeup, soft lips,
+
+white bikini top with lace trim, blue and white striped bikini bottom, white cardigan, off-shoulder,
+
+standing on sandy beach, ocean background, blurred beach background, bokeh, depth of field, soft natural sunlight, daytime, cloudy sky,
+
+perfect anatomy, detailed skin texture, skin pores, realistic proportions, curvy body, natural pose, looking at viewer, subtle smile, professional model pose
+
+
+
+Negative Prompt:
+(worst quality, low quality:1.4), (illustration, 3d, 2d, painting, cartoons, sketch:1.3), (monochrome, grayscale:1.2), teeth, open mouth, (bad hands, bad fingers, deformed hands, mutated fingers:1.3), watermark, signature, text, logo, extra limbs, malformed limbs, poorly drawn face, poorly drawn hands, mutation, deformed, bad anatomy, bad proportions, duplicate, cropped, jpeg artifacts, blurry, out of focus, oversaturated, artificial lighting
+
+
+
+
+
+xxmixgirl, 1girl, black hair, brown eyes, face, beach, huge breast, white background, high quality
+
+xxmixgirl, 1girl, black hair, brown eyes, face, i,  kyoto city  background, high quality, sunny

pyproject.toml

@@ -0,0 +1,53 @@
+[project]
+name = "jagirl-ui"
+version = "0.1.0"
+description = "SDXL-based anime girl image generation using aipicasso/jagirl model with Gradio UI"
+readme = "README.md"
+keywords = ["ai", "image-generation", "stable-diffusion", "sdxl", "anime", "gradio", "huggingface"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+]
+requires-python = ">=3.11"
+dependencies = [
+    "huggingface-hub>=0.35.3",
+    "diffusers>=0.35.2",
+    "numpy>=2.3.4",
+    "scipy>=1.11.0",
+    "gradio>=4.0.0",
+    "transformers>=4.30.0",
+    "accelerate>=0.20.0",
+    "pillow>=10.0.0",
+]
+
+[project.optional-dependencies]
+gpu = [
+    "xformers>=0.0.20",
+]
+
+# ⚠️ 重要: PyTorchは依存関係に含めていません ⚠️
+# 理由: pip install -e . でCPU版に上書きされる問題を防ぐため
+#
+# 【必須】CUDA版PyTorchの手動インストール手順:
+# 1. 仮想環境をアクティベート
+# 2. 以下を個別に実行（一括ではなく1つずつ）:
+#    pip install torch --index-url https://download.pytorch.org/whl/cu121 --no-cache-dir
+#    pip install torchvision --index-url https://download.pytorch.org/whl/cu121
+#    pip install torchaudio --index-url https://download.pytorch.org/whl/cu121
+# 3. インストール確認:
+#    python -c "import torch; print(torch.__version__); print(torch.cuda.is_available())"
+#
+# 参考: 20251017_全ログ.md - torch一括インストールで20分以上フリーズした実績あり
+
+[build-system]
+
+[tool.setuptools]
+# パッケージ自動検出を無効化（utilsのみを明示的にインストール）
+packages = ["utils"]
+
+[tool.setuptools.package-data]
+# データファイルを除外（logs, outputs, gradio_uiはプロジェクトディレクトリとして扱う）
+"*" = []

utils/download_hugginface_repo.py

@@ -0,0 +1,34 @@
+"""Hugging Face モデルダウンロードスクリプト.
+
+環境変数 ``HF_TOKEN`` もしくは ``HUGGINGFACEHUB_API_TOKEN`` にセットされた
+トークンでログインしてから Stable Diffusion XL パイプラインを取得する。
+"""
+
+from huggingface_hub import login
+from diffusers import StableDiffusionXLPipeline
+import torch
+import os
+
+
+def main() -> None:
+    token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACEHUB_API_TOKEN")
+    if token:
+        login(token=token)
+    else:
+        print("⚠️ 環境変数に Hugging Face トークンが設定されていません。公開モデルのみアクセス可能です。")
+
+    print("🔧 aipicasso/emix-0-5 モデルをダウンロード中...")
+    print("📝 モデル情報: Conterfeit XL v2.5 + Animagine v2.0 + Emix 0.4")
+
+    StableDiffusionXLPipeline.from_pretrained(
+        "aipicasso/emix-0-5",
+        torch_dtype=torch.float16,
+        use_safetensors=True
+    )
+
+    print("✅ ダウンロード完了！")
+    print("📂 キャッシュ場所: ~/.cache/huggingface/hub/")
+
+
+if __name__ == "__main__":
+    main()

utils/logger.py

@@ -0,0 +1,329 @@
+"""
+統一ログ機能モジュール
+画像生成の全パラメータと結果を包括的に記録する統一ログシステム
+
+設計原則:
+- 生成に使用された全パラメータの記録
+- 生成画像との確実な紐づけ
+- JSON形式での構造化データ保存
+- 検索・分析しやすい形式
+- パフォーマンス情報の詳細記録
+"""
+
+import json
+import os
+import time
+from datetime import datetime
+from typing import Dict, Any, Optional
+import torch
+from PIL import Image
+
+
+class UnifiedLogger:
+    """統一ログ機能クラス"""
+    
+    def __init__(self, log_dir: str = "logs"):
+        """
+        ログ機能の初期化
+        
+        Args:
+            log_dir: ログファイルを保存するディレクトリ
+        """
+        self.log_dir = log_dir
+        self.json_log_file = os.path.join(log_dir, "generation_history.json")
+        
+        # ログディレクトリ作成
+        os.makedirs(log_dir, exist_ok=True)
+        
+        # 既存ログの読み込み
+        self._load_existing_logs()
+    
+    def _load_existing_logs(self):
+        """既存のログデータを読み込み"""
+        if os.path.exists(self.json_log_file):
+            try:
+                with open(self.json_log_file, 'r', encoding='utf-8') as f:
+                    self.log_data = json.load(f)
+            except (json.JSONDecodeError, FileNotFoundError):
+                self.log_data = {"metadata": self._create_metadata(), "generations": []}
+        else:
+            self.log_data = {"metadata": self._create_metadata(), "generations": []}
+    
+    def _create_metadata(self) -> Dict[str, Any]:
+        """ログファイルのメタデータを作成"""
+        return {
+            "format_version": "2.0",
+            "created_at": datetime.now().isoformat(),
+            "last_updated": datetime.now().isoformat(),
+            "description": "Unified generation history for jagirl UI project",
+            "model_info": {
+                "model_name": "aipicasso/jagirl",
+                "model_type": "StableDiffusionXL",
+                "specialized_for": "Japanese female faces"
+            },
+            "log_schema": {
+                "timestamp": "ISO format timestamp",
+                "generation_id": "Unique identifier for each generation",
+                "prompts": "All text prompts used",
+                "parameters": "Complete parameter set used for generation",
+                "output": "Generated image information",
+                "performance": "Execution metrics",
+                "system_info": "Hardware and software environment"
+            }
+        }
+    
+    def _get_image_info(self, filepath: str) -> Dict[str, Any]:
+        """画像ファイルの詳細情報を取得"""
+        if not os.path.exists(filepath):
+            return {"error": "File not found"}
+        
+        try:
+            # ファイルサイズ
+            file_size_bytes = os.path.getsize(filepath)
+            file_size_mb = round(file_size_bytes / (1024 * 1024), 3)
+            
+            # 画像情報
+            with Image.open(filepath) as img:
+                width, height = img.size
+                mode = img.mode
+                format_type = img.format
+            
+            return {
+                "filepath": os.path.abspath(filepath),
+                "file_url": f"file:///{os.path.abspath(filepath).replace(os.sep, '/')}",
+                "filename": os.path.basename(filepath),
+                "file_size_bytes": file_size_bytes,
+                "file_size_mb": file_size_mb,
+                "image_width": width,
+                "image_height": height,
+                "image_mode": mode,
+                "image_format": format_type,
+                "created_at": datetime.fromtimestamp(os.path.getctime(filepath)).isoformat()
+            }
+        except Exception as e:
+            return {"error": f"Failed to get image info: {str(e)}"}
+    
+    def _get_system_info(self) -> Dict[str, Any]:
+        """システム情報を取得"""
+        system_info = {
+            "python_version": None,
+            "torch_version": None,
+            "cuda_available": False,
+            "cuda_version": None,
+            "gpu_name": None,
+            "vram_total_gb": 0,
+            "vram_allocated_gb": 0
+        }
+        
+        try:
+            import sys
+            system_info["python_version"] = sys.version.split()[0]
+            
+            system_info["torch_version"] = torch.__version__
+            system_info["cuda_available"] = torch.cuda.is_available()
+            
+            if torch.cuda.is_available():
+                system_info["cuda_version"] = torch.version.cuda
+                system_info["gpu_name"] = torch.cuda.get_device_name(0)
+                system_info["vram_total_gb"] = round(
+                    torch.cuda.get_device_properties(0).total_memory / (1024**3), 2
+                )
+                system_info["vram_allocated_gb"] = round(
+                    torch.cuda.memory_allocated(0) / (1024**3), 2
+                )
+        except Exception as e:
+            system_info["error"] = f"Failed to get system info: {str(e)}"
+        
+        return system_info
+    
+    def log_generation(
+        self,
+        prompt: str,
+        negative_prompt: str = "",
+        parameters: Dict[str, Any] = None,
+        output_filepath: str = "",
+        execution_time: float = 0.0,
+        additional_info: Dict[str, Any] = None
+    ) -> str:
+        """
+        画像生成の完全なログを記録
+        
+        Args:
+            prompt: メインプロンプト
+            negative_prompt: ネガティブプロンプト
+            parameters: 生成に使用された全パラメータ
+            output_filepath: 生成された画像ファイルパス
+            execution_time: 実行時間（秒）
+            additional_info: 追加情報
+        
+        Returns:
+            generation_id: 生成された記録のユニークID
+        """
+        
+        # ユニークIDの生成
+        timestamp = datetime.now()
+        generation_id = f"gen_{timestamp.strftime('%Y%m%d_%H%M%S')}_{int(time.time() * 1000) % 100000}"
+        
+        # デフォルトパラメータの設定
+        if parameters is None:
+            parameters = {}
+        
+        # 完全なパラメータセットの作成
+        complete_parameters = {
+            # 基本パラメータ
+            "num_inference_steps": parameters.get("num_inference_steps", 20),
+            "guidance_scale": parameters.get("guidance_scale", 7.5),
+            "width": parameters.get("width", 1024),
+            "height": parameters.get("height", 1024),
+            "seed": parameters.get("seed", None),
+            
+            # スケジューラー関連
+            "scheduler_type": parameters.get("scheduler_type", "default"),
+            "eta": parameters.get("eta", 0.0),
+            
+            # 画像生成関連
+            "num_images": parameters.get("num_images", 1),
+            "batch_size": parameters.get("batch_size", 1),
+            
+            # モデル関連
+            "torch_dtype": str(parameters.get("torch_dtype", "float16")),
+            "enable_xformers": parameters.get("enable_xformers", False),
+            "enable_cpu_offload": parameters.get("enable_cpu_offload", False),
+            
+            # その他のパラメータ
+            **{k: v for k, v in parameters.items() if k not in [
+                "num_inference_steps", "guidance_scale", "width", "height", 
+                "seed", "scheduler_type", "eta", "num_images", "batch_size",
+                "torch_dtype", "enable_xformers", "enable_cpu_offload"
+            ]}
+        }
+        
+        # ログエントリの作成
+        log_entry = {
+            "generation_id": generation_id,
+            "timestamp": timestamp.isoformat(),
+            "prompts": {
+                "main_prompt": prompt,
+                "negative_prompt": negative_prompt,
+                "prompt_length": len(prompt),
+                "negative_prompt_length": len(negative_prompt)
+            },
+            "parameters": complete_parameters,
+            "output": self._get_image_info(output_filepath) if output_filepath else {},
+            "performance": {
+                "execution_time_seconds": round(execution_time, 3),
+                "estimated_speed_sec_per_step": round(
+                    execution_time / max(complete_parameters.get("num_inference_steps", 1), 1), 3
+                ) if execution_time > 0 else 0
+            },
+            "system_info": self._get_system_info(),
+            "additional_info": additional_info or {}
+        }
+        
+        # ログに追加
+        self.log_data["generations"].append(log_entry)
+        self.log_data["metadata"]["last_updated"] = timestamp.isoformat()
+        
+        # ファイルに保存
+        self._save_logs()
+        
+        return generation_id
+    
+    def _save_logs(self):
+        """ログをファイルに保存"""
+        try:
+            with open(self.json_log_file, 'w', encoding='utf-8') as f:
+                json.dump(self.log_data, f, ensure_ascii=False, indent=2)
+        except Exception as e:
+            print(f"ログ保存エラー: {e}")
+    
+    def get_generation_by_id(self, generation_id: str) -> Optional[Dict[str, Any]]:
+        """generation_idで特定の生成記録を取得"""
+        for generation in self.log_data["generations"]:
+            if generation["generation_id"] == generation_id:
+                return generation
+        return None
+    
+    def get_recent_generations(self, count: int = 10) -> list:
+        """最近の生成記録を取得"""
+        return self.log_data["generations"][-count:] if self.log_data["generations"] else []
+    
+    def search_by_prompt(self, search_term: str, case_sensitive: bool = False) -> list:
+        """プロンプトで検索"""
+        results = []
+        search_term = search_term if case_sensitive else search_term.lower()
+        
+        for generation in self.log_data["generations"]:
+            main_prompt = generation["prompts"]["main_prompt"]
+            if not case_sensitive:
+                main_prompt = main_prompt.lower()
+            
+            if search_term in main_prompt:
+                results.append(generation)
+        
+        return results
+    
+    def get_statistics(self) -> Dict[str, Any]:
+        """生成統計を取得"""
+        generations = self.log_data["generations"]
+        
+        if not generations:
+            return {"total_generations": 0}
+        
+        total_time = sum(g["performance"]["execution_time_seconds"] for g in generations)
+        avg_time = total_time / len(generations)
+        
+        schedulers = {}
+        for g in generations:
+            scheduler = g["parameters"].get("scheduler_type", "unknown")
+            schedulers[scheduler] = schedulers.get(scheduler, 0) + 1
+        
+        return {
+            "total_generations": len(generations),
+            "total_execution_time_hours": round(total_time / 3600, 2),
+            "average_execution_time_seconds": round(avg_time, 2),
+            "scheduler_usage": schedulers,
+            "date_range": {
+                "first": generations[0]["timestamp"],
+                "last": generations[-1]["timestamp"]
+            }
+        }
+    
+    def cleanup_old_logs(self, keep_days: int = 30):
+        """古いログエントリを削除"""
+        cutoff_date = datetime.now().timestamp() - (keep_days * 24 * 3600)
+        
+        original_count = len(self.log_data["generations"])
+        self.log_data["generations"] = [
+            g for g in self.log_data["generations"]
+            if datetime.fromisoformat(g["timestamp"]).timestamp() > cutoff_date
+        ]
+        
+        removed_count = original_count - len(self.log_data["generations"])
+        
+        if removed_count > 0:
+            self._save_logs()
+            print(f"古いログエントリ {removed_count} 件を削除しました")
+        
+        return removed_count
+
+
+# グローバルロガーインスタンス
+_global_logger = None
+
+def get_logger(log_dir: str = "logs") -> UnifiedLogger:
+    """グローバルロガーインスタンスを取得"""
+    global _global_logger
+    if _global_logger is None:
+        _global_logger = UnifiedLogger(log_dir)
+    return _global_logger
+
+def log_generation(**kwargs) -> str:
+    """グローバルロガーを使用して生成をログ"""
+    logger = get_logger()
+    return logger.log_generation(**kwargs)
+
+def get_statistics() -> Dict[str, Any]:
+    """生成統計を取得"""
+    logger = get_logger()
+    return logger.get_statistics()

utils/migrate_logs.py

@@ -0,0 +1,173 @@
+"""
+ログ移行スクリプト
+既存のgeneration_history.jsonを新しい統一ログフォーマットに移行
+
+実行方法:
+python utils/migrate_logs.py
+"""
+
+import json
+import os
+import sys
+from datetime import datetime
+from pathlib import Path
+
+# プロジェクトルートをPythonパスに追加
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root / "utils"))
+
+from unified_logger import UnifiedLogger
+
+
+def migrate_old_logs():
+    """既存のログを新しいフォーマットに移行"""
+    
+    old_log_file = "logs/generation_history.json"
+    backup_file = "logs/generation_history_backup.json"
+    
+    if not os.path.exists(old_log_file):
+        print("❌ 既存のログファイルが見つかりません")
+        return
+    
+    # バックアップ作成
+    with open(old_log_file, 'r', encoding='utf-8') as f:
+        old_data = json.load(f)
+    
+    with open(backup_file, 'w', encoding='utf-8') as f:
+        json.dump(old_data, f, ensure_ascii=False, indent=2)
+    
+    print(f"✅ 既存ログをバックアップしました: {backup_file}")
+    
+    # 統一ログ機能で移行
+    logger = UnifiedLogger()
+    
+    migration_count = 0
+    
+    if "generations" in old_data:
+        for old_entry in old_data["generations"]:
+            try:
+                # 旧フォーマットから新フォーマットへの変換
+                old_params = old_entry.get("parameters", {})
+                old_output = old_entry.get("output", {})
+                old_performance = old_entry.get("performance", {})
+                
+                # パラメータの変換
+                new_params = {
+                    "num_inference_steps": old_params.get("steps", 20),
+                    "guidance_scale": old_params.get("cfg_scale", 7.5),
+                    "width": old_params.get("width", 1024),
+                    "height": old_params.get("height", 1024),
+                    "seed": old_params.get("seed", None),
+                    "scheduler_type": old_params.get("scheduler", "default"),
+                    "eta": 0.0,  # 旧ログにはない
+                    "torch_dtype": "float16",  # 推定値
+                    "enable_xformers": True,  # 推定値
+                    "enable_cpu_offload": False  # 推定値
+                }
+                
+                # 追加情報
+                additional_info = {
+                    "migrated_from": "generation_history.json",
+                    "migration_date": datetime.now().isoformat(),
+                    "original_timestamp": old_entry.get("timestamp", "")
+                }
+                
+                # 新しいログエントリとして記録
+                generation_id = logger.log_generation(
+                    prompt=old_entry.get("prompt", ""),
+                    negative_prompt=old_entry.get("negative_prompt", ""),
+                    parameters=new_params,
+                    output_filepath=old_output.get("filepath", ""),
+                    execution_time=old_performance.get("execution_time_seconds", 0),
+                    additional_info=additional_info
+                )
+                
+                migration_count += 1
+                print(f"✅ 移行完了: {generation_id}")
+                
+            except Exception as e:
+                print(f"⚠️ エントリの移行に失敗: {e}")
+                continue
+    
+    print(f"\n🎉 移行完了: {migration_count} エントリを新しいフォーマットに移行しました")
+    
+    # 統計表示
+    stats = logger.get_statistics()
+    print(f"📊 総生成数: {stats['total_generations']} 枚")
+    print(f"📊 総実行時間: {stats['total_execution_time_hours']} 時間")
+    print(f"📊 平均実行時間: {stats['average_execution_time_seconds']} 秒")
+    
+    # 旧ファイルをリネーム
+    old_archived = "logs/generation_history_old.json"
+    os.rename(old_log_file, old_archived)
+    print(f"📦 旧ログファイルをアーカイブしました: {old_archived}")
+
+
+def test_new_logger():
+    """新しいログ機能のテスト"""
+    print("\n🧪 新しいログ機能のテスト...")
+    
+    logger = UnifiedLogger()
+    
+    # テストエントリ
+    test_params = {
+        "num_inference_steps": 25,
+        "guidance_scale": 7.5,
+        "width": 1024,
+        "height": 1024,
+        "seed": 12345,
+        "scheduler_type": "DPMSolver",
+        "eta": 0.0,
+        "torch_dtype": "float16",
+        "enable_xformers": True,
+        "enable_cpu_offload": False
+    }
+    
+    test_info = {
+        "test_mode": True,
+        "description": "ログ機能テスト"
+    }
+    
+    generation_id = logger.log_generation(
+        prompt="test prompt for new logging system",
+        negative_prompt="low quality, test",
+        parameters=test_params,
+        output_filepath="",  # テストなのでファイルなし
+        execution_time=45.67,
+        additional_info=test_info
+    )
+    
+    print(f"✅ テストエントリ作成: {generation_id}")
+    
+    # 作成したエントリを取得してテスト
+    entry = logger.get_generation_by_id(generation_id)
+    if entry:
+        print("✅ エントリ取得テスト成功")
+        print(f"   プロンプト: {entry['prompts']['main_prompt'][:50]}...")
+        print(f"   実行時間: {entry['performance']['execution_time_seconds']} 秒")
+        print(f"   パラメータ数: {len(entry['parameters'])} 個")
+    
+    # 検索テスト
+    search_results = logger.search_by_prompt("test prompt")
+    print(f"✅ 検索テスト: {len(search_results)} 件ヒット")
+    
+    print("🎉 新しいログ機能のテスト完了!")
+
+
+if __name__ == "__main__":
+    print("🔄 ログ移行プロセスを開始...")
+    
+    try:
+        migrate_old_logs()
+        test_new_logger()
+        
+        print("\n" + "=" * 60)
+        print("🎊 ログ移行が正常に完了しました!")
+        print("📄 新しいログファイル: logs/unified_generation_history.json")
+        print("📄 バックアップファイル: logs/generation_history_backup.json")
+        print("📄 旧ファイル: logs/generation_history_old.json")
+        
+    except Exception as e:
+        print(f"❌ 移行プロセスでエラーが発生しました: {e}")
+        import traceback
+        traceback.print_exc()

utils/test_download_hugginface_repo.py

@@ -0,0 +1,52 @@
+import os
+import sys
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+
+class TestDownloadHuggingfaceRepo(unittest.TestCase):
+
+    @patch.dict(os.environ, {"HF_TOKEN": "dummy-token"}, clear=True)
+    @patch("utils.download_hugginface_repo.StableDiffusionXLPipeline")
+    @patch("utils.download_hugginface_repo.login")
+    def test_huggingface_login_called(self, mock_login, mock_pipeline):
+        import utils.download_hugginface_repo as target
+
+        target.main()
+
+        mock_login.assert_called_once_with(token="dummy-token")
+        mock_pipeline.from_pretrained.assert_called_once()
+
+    @patch("utils.download_hugginface_repo.StableDiffusionXLPipeline")
+    @patch.dict(os.environ, {}, clear=True)
+    def test_stable_diffusion_pipeline_creation(self, mock_pipeline):
+        import utils.download_hugginface_repo as target
+
+        target.main()
+
+        mock_pipeline.from_pretrained.assert_called_once_with(
+            "aipicasso/emix-0-5",
+            torch_dtype=target.torch.float16,
+            use_safetensors=True
+        )
+
+    @patch("utils.download_hugginface_repo.StableDiffusionXLPipeline")
+    @patch("utils.download_hugginface_repo.login")
+    @patch.dict(os.environ, {"HF_TOKEN": "dummy-token"}, clear=True)
+    def test_full_workflow(self, mock_login, mock_pipeline):
+        import utils.download_hugginface_repo as target
+
+        target.main()
+
+        mock_login.assert_called_once_with(token="dummy-token")
+        mock_pipeline.from_pretrained.assert_called_once_with(
+            "aipicasso/emix-0-5",
+            torch_dtype=target.torch.float16,
+            use_safetensors=True
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/test_high_quality_generation.py

@@ -0,0 +1,556 @@
+"""
+高品質画像生成テスト用スクリプト
+aipicasso/jagirlモデルを使用した高品質なアニメ画像生成のテスト
+
+=== パラメータ詳細解説 ===
+
+🔧 Sampling Method (スケジューラー):
+- DDIM: 高品質、少ないステップで良い結果
+- DPMSolver: 高速で高品質（推奨）
+- Euler: 安定した結果
+- EulerA: より多様な結果
+- LMS: 古典的手法
+- PNDM: デフォルト
+
+📊 Sampling Steps (num_inference_steps): 10-150
+- 少ない (10-20): 高速だが品質低め
+- 中程度 (25-40): バランス良好（推奨）
+- 多い (50-150): 高品質だが時間かかる
+
+🎲 Seed (generator):
+- 同じシード = 同じ画像（再現性）
+- ランダムシード = バリエーション
+
+⚙️ CFG Scale (guidance_scale): 1-20
+- 低い (3-5): プロンプトに緩く従う、自然
+- 中程度 (7-10): バランス良好（推奨）
+- 高い (12-20): プロンプトに厳密に従う
+
+🔧 その他:
+- eta: ノイズ制御 (0.0-1.0)
+- width/height: 画像サイズ (64の倍数推奨)
+"""
+
+import torch
+from diffusers import StableDiffusionXLPipeline
+from huggingface_hub import login
+import os
+from datetime import datetime
+import random
+import json
+import logging
+from unified_logger import get_logger
+
+def setup_model():
+    """モデルのセットアップと最適化"""
+    print("🔧 モデルをセットアップ中...")
+    
+    # HuggingFace認証（必要に応じてトークンを設定）
+    # login(token="your_token_here")
+    
+    # モデルロード（SDXL用設定）
+    try:
+        print("🔄 SDXL設定でモデルロード中...")
+        pipe = StableDiffusionXLPipeline.from_pretrained(
+            "aipicasso/jagirl",
+            torch_dtype=torch.float16,
+            use_safetensors=True,
+            variant="fp16"
+        )
+    except Exception as e:
+        print(f"⚠️ FP16でのロードに失敗、標準設定で再試行: {e}")
+        try:
+            pipe = StableDiffusionXLPipeline.from_pretrained("aipicasso/jagirl")
+        except Exception as e2:
+            print(f"❌ モデルロードに失敗: {e2}")
+            return None
+    
+    # GPUに手動で移動
+    if torch.cuda.is_available():
+        pipe = pipe.to("cuda")
+        print(f"✅ モデルをGPUに移動: {torch.cuda.get_device_name(0)}")
+        
+        # GPU移動後にFP16に変換
+        try:
+            pipe = pipe.to(dtype=torch.float16)
+            print("✅ FP16モードに変換")
+        except:
+            print("⚠️ FP16変換をスキップ、FP32で継続")
+    else:
+        print("❌ CUDAが利用できません")
+        return None
+    
+    # パフォーマンス最適化
+    try:
+        pipe.enable_xformers_memory_efficient_attention()
+        print("✅ xFormers有効化")
+    except:
+        print("⚠️  xFormersが利用できません")
+    
+    # CPU Offloadは無効化（全てGPUで処理）
+    # try:
+    #     pipe.enable_model_cpu_offload()
+    #     print("✅ CPU Offload有効化")
+    # except:
+    #     print("⚠️  CPU Offloadが利用できません")
+    print("🎯 GPU専用モードで動作")
+    
+    print(f"🎯 モデルセットアップ完了 - デバイス: {pipe.device}")
+    return pipe
+
+def check_gpu_status():
+    """GPU状態の確認"""
+    if torch.cuda.is_available():
+        gpu_name = torch.cuda.get_device_name(0)
+        memory_allocated = torch.cuda.memory_allocated(0) / 1024**3
+        memory_total = torch.cuda.get_device_properties(0).total_memory / 1024**3
+        
+        print(f"🖥️  GPU: {gpu_name}")
+        print(f"💾 VRAM使用量: {memory_allocated:.1f}GB / {memory_total:.1f}GB")
+        return True
+    else:
+        print("❌ CUDAが利用できません")
+        return False
+
+# 古いログ機能は統一ログ機能に統合されました
+
+# 古いログ機能は統一ログ機能に統合されました
+
+def setup_scheduler(pipe, scheduler_type):
+    """
+    スケジューラーの設定（SDXL対応）
+    
+    各スケジューラーの特徴:
+    - DDIM: 高品質、少ないステップで良い結果（20-30ステップ推奨）
+    - DPMSolver: 高速で高品質、最もバランスが良い（15-25ステップ推奨）
+    - Euler: 安定した結果、予測しやすい（30-50ステップ推奨）
+    - EulerA: より多様で芸術的な結果（25-40ステップ推奨）
+    - LMS: 古典的手法、安定しているが遅い（50+ステップ推奨）
+    - PNDM: デフォルト、標準的な品質（30-50ステップ推奨）
+    """
+    from diffusers import (
+        DDIMScheduler, DPMSolverMultistepScheduler, 
+        EulerDiscreteScheduler, EulerAncestralDiscreteScheduler,
+        LMSDiscreteScheduler, PNDMScheduler
+    )
+    
+    schedulers = {
+        "DDIM": DDIMScheduler,
+        "DPMSolver": DPMSolverMultistepScheduler,
+        "Euler": EulerDiscreteScheduler,
+        "EulerA": EulerAncestralDiscreteScheduler,
+        "PNDM": PNDMScheduler
+    }
+    
+    # LMSはscipyが必要なため、利用可能な場合のみ追加
+    try:
+        schedulers["LMS"] = LMSDiscreteScheduler
+    except:
+        print("⚠️ LMSスケジューラーは利用できません (scipyが必要)")
+    
+    if scheduler_type in schedulers:
+        try:
+            return schedulers[scheduler_type].from_config(pipe.scheduler.config)
+        except ImportError as e:
+            print(f"⚠️ {scheduler_type}スケジューラーが利用できません: {e}")
+            return pipe.scheduler
+    return pipe.scheduler
+
+def generate_high_quality_image(pipe, prompt, negative_prompt="", seed=None, output_dir="outputs", 
+                              num_inference_steps=50, guidance_scale=7.5, width=1024, height=1024,
+                              scheduler_type="default", eta=0.0):
+    """
+    高品質画像生成（詳細パラメータ対応）
+    
+    Args:
+        pipe: StableDiffusionPipeline
+        prompt: プロンプト
+        negative_prompt: ネガティブプロンプト
+        seed: シード値
+        output_dir: 出力ディレクトリ
+        num_inference_steps: サンプリングステップ数 (10-150)
+        guidance_scale: CFG Scale/ガイダンス強度 (1-20)
+        width, height: 画像サイズ
+        scheduler_type: スケジューラータイプ (DDIM, DPMSolver, Euler, EulerA, LMS, PNDM)
+        eta: ノイズ制御 (0.0-1.0)
+    """
+    
+    # 出力ディレクトリ作成
+    os.makedirs(output_dir, exist_ok=True)
+    
+    # シード設定
+    if seed is None:
+        seed = random.randint(0, 1000000)
+    
+    generator = torch.Generator(device="cuda").manual_seed(seed)
+    
+    # スケジューラー設定
+    original_scheduler = pipe.scheduler
+    if scheduler_type != "default":
+        pipe.scheduler = setup_scheduler(pipe, scheduler_type)
+    
+    print(f"🎨 画像生成開始")
+    print(f"📝 プロンプト: {prompt}")
+    print(f"🔧 設定: steps={num_inference_steps}, cfg={guidance_scale}, seed={seed}")
+    print(f"� サイズ: {width}x{height}, スケジューラー: {scheduler_type}")
+    
+    # 高品質設定での画像生成（時間測定付き）
+    import time
+    start_time = time.time()
+    
+    try:
+        image = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            num_inference_steps=num_inference_steps,  # Sampling Steps
+            guidance_scale=guidance_scale,            # CFG Scale (ガイダンス強度)
+            width=width,
+            height=height,
+            generator=generator                       # Seed制御
+        ).images[0]
+    except Exception as e:
+        print(f"⚠️ 生成エラー、シンプルな設定で再試行: {e}")
+        # 最小限のパラメータで再試行
+        image = pipe(
+            prompt=prompt,
+            num_inference_steps=20,
+            guidance_scale=7.5,
+            generator=generator
+        ).images[0]
+    
+    end_time = time.time()
+    execution_time = end_time - start_time
+    
+    # スケジューラーを元に戻す
+    pipe.scheduler = original_scheduler
+    
+    # ファイル名生成
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    filename = f"jagirl_{timestamp}_seed{seed}.png"
+    filepath = os.path.join(output_dir, filename)
+    
+    # 画像保存
+    image.save(filepath)
+    print(f"💾 画像保存: {filepath}")
+    
+    # VRAM使用量取得
+    vram_usage = torch.cuda.memory_allocated(0) / 1024**3 if torch.cuda.is_available() else 0
+    
+    # 統一ログ機能で詳細記録
+    logger = get_logger()
+    
+    # GPU最適化設定の記録
+    additional_info = {
+        "gpu_optimizations": {
+            "fp16_enabled": hasattr(pipe, 'dtype') and pipe.dtype == torch.float16,
+            "xformers_enabled": getattr(pipe, '_use_xformers', False),
+            "cpu_offload_enabled": getattr(pipe, '_cpu_offload', False)
+        },
+        "generation_mode": "high_quality_test"
+    }
+    
+    params = {
+        "negative_prompt": negative_prompt,
+        "scheduler_type": scheduler_type,
+        "num_inference_steps": num_inference_steps,
+        "guidance_scale": guidance_scale,
+        "width": width,
+        "height": height,
+        "seed": seed,
+        "eta": eta,
+        "torch_dtype": str(pipe.dtype) if hasattr(pipe, 'dtype') else "unknown",
+        "enable_xformers": getattr(pipe, '_use_xformers', False),
+        "enable_cpu_offload": getattr(pipe, '_cpu_offload', False)
+    }
+    
+    generation_id = logger.log_generation(
+        prompt=prompt,
+        negative_prompt=negative_prompt,
+        parameters=params,
+        output_filepath=filepath,
+        execution_time=execution_time,
+        additional_info=additional_info
+    )
+    
+    print(f"📋 ログ記録完了: {generation_id}")
+    
+    return image, filepath
+
+def test_various_prompts(pipe):
+    """様々なプロンプトでテスト生成"""
+    
+    # 日本女性（顔つきにフォーカス）向けプロンプト例を追加
+    test_prompts = [
+        {
+            "prompt": "日本人女性の顔立ち, 美しい顔, 繊細な瞳, 自然な黒髪, 柔らかな表情, リアリスティックな肌質",
+            "negative": "low quality, blurry, ugly, deformed, western features, caucasian",
+            "description": "基本的な日本女性の顔つき (SDXL)",
+            "scheduler": "default",
+            "steps": 25,
+            "cfg": 7.0,
+            "width": 1024,
+            "height": 1024
+        },
+        {
+            "prompt": "日本人女性, 上品で優しい顔立ち, アーモンド形の瞳, ストレート黒髪, 控えめなメイク",
+            "negative": "low quality, blurry, ugly, deformed, western features, heavy makeup",
+            "description": "上品な日本女性 (DPMSolver SDXL)",
+            "scheduler": "DPMSolver",
+            "steps": 20,
+            "cfg": 7.5,
+            "width": 1024,
+            "height": 1024
+        },
+        {
+            "prompt": "日本人の若い女性, 愛らしい笑顔, 小さめの鼻, 優しい茶色の瞳, 肩にかかる髪",
+            "negative": "low quality, blurry, ugly, deformed, aged, wrinkles, western features",
+            "description": "若々しい日本女性 (Euler SDXL)",
+            "scheduler": "Euler",
+            "steps": 30,
+            "cfg": 6.0,
+            "width": 1024,
+            "height": 1024
+        },
+        {
+            "prompt": "落ち着いた日本人女性, 大人の魅力, きちんとした顔立ち, はっきりした頬骨, 長い黒髪, プロフェッショナルな雰囲気",
+            "negative": "low quality, blurry, ugly, deformed, childish, western features",
+            "description": "大人っぽい日本女性 (EulerA SDXL)",
+            "scheduler": "EulerA",
+            "steps": 25,
+            "cfg": 8.0,
+            "width": 1024,
+            "height": 1024
+        }
+    ]
+    
+    print(f"\n🎯 {len(test_prompts)}パターンのテスト生成を開始...")
+    
+    results = []
+    for i, test_case in enumerate(test_prompts, 1):
+        print(f"\n--- テスト {i}/{len(test_prompts)}: {test_case['description']} ---")
+        
+        image, filepath = generate_high_quality_image(
+            pipe=pipe,
+            prompt=test_case["prompt"],
+            negative_prompt=test_case["negative"],
+            seed=42 + i,  # 再現可能なシード
+            num_inference_steps=test_case["steps"],
+            guidance_scale=test_case["cfg"],
+            scheduler_type=test_case["scheduler"]
+        )
+        
+        results.append({
+            "description": test_case["description"],
+            "filepath": filepath,
+            "prompt": test_case["prompt"],
+            "scheduler": test_case["scheduler"],
+            "steps": test_case["steps"],
+            "cfg": test_case["cfg"]
+        })
+        
+        # VRAM使用量チェック
+        if torch.cuda.is_available():
+            memory_used = torch.cuda.memory_allocated(0) / 1024**3
+            print(f"📊 現在のVRAM使用量: {memory_used:.1f}GB")
+    
+    return results
+
+def test_scheduler_comparison(pipe):
+    """各種スケジューラーの比較テスト"""
+    print("\n🔄 スケジューラー比較テスト開始...")
+    
+    base_prompt = "anime girl, beautiful face, detailed eyes, colorful hair"
+    negative_prompt = "low quality, blurry, ugly"
+    
+    schedulers = ["default", "DDIM", "DPMSolver", "Euler", "EulerA", "LMS"]
+    results = []
+    
+    for scheduler in schedulers:
+        print(f"\n🔧 テスト中: {scheduler}")
+        
+        image, filepath = generate_high_quality_image(
+            pipe=pipe,
+            prompt=base_prompt,
+            negative_prompt=negative_prompt,
+            seed=12345,  # 固定シードで比較
+            num_inference_steps=30,
+            guidance_scale=7.5,
+            scheduler_type=scheduler
+        )
+        
+        results.append({
+            "scheduler": scheduler,
+            "filepath": filepath
+        })
+    
+    print(f"\n✅ スケジューラー比較完了: {len(results)} パターン")
+    return results
+
+def test_parameter_variations(pipe):
+    """パラメータバリエーションテスト"""
+    print("\n⚙️  パラメータバリエーションテスト開始...")
+    
+    base_prompt = "anime girl, school uniform, detailed"
+    negative_prompt = "low quality, blurry"
+    
+    # CFG Scale テスト
+    cfg_tests = [3.0, 5.0, 7.5, 10.0, 15.0]
+    print("\n📊 CFG Scale テスト:")
+    
+    for cfg in cfg_tests:
+        print(f"  CFG: {cfg}")
+        image, filepath = generate_high_quality_image(
+            pipe=pipe,
+            prompt=base_prompt,
+            negative_prompt=negative_prompt,
+            seed=54321,
+            guidance_scale=cfg,
+            num_inference_steps=25
+        )
+    
+    # Steps テスト
+    steps_tests = [10, 20, 30, 50, 80]
+    print("\n🔢 Steps テスト:")
+    
+    for steps in steps_tests:
+        print(f"  Steps: {steps}")
+        image, filepath = generate_high_quality_image(
+            pipe=pipe,
+            prompt=base_prompt,
+            negative_prompt=negative_prompt,
+            seed=98765,
+            num_inference_steps=steps,
+            guidance_scale=7.5
+        )
+
+def benchmark_generation_speed(pipe):
+    """生成速度のベンチマーク"""
+    print("\n⚡ 生成速度ベンチマーク開始...")
+    
+    prompt = "anime girl, beautiful face, detailed"
+    negative_prompt = "low quality, blurry"
+    
+    import time
+    
+    # ウォームアップ
+    print("🔥 ウォームアップ中...")
+    _ = pipe(prompt, num_inference_steps=10, width=256, height=256)
+    
+    # ベンチマーク実行
+    step_counts = [10, 20, 30, 50]
+    
+    for steps in step_counts:
+        start_time = time.time()
+        
+        _ = pipe(
+            prompt=prompt,
+            negative_prompt=negative_prompt,
+            num_inference_steps=steps,
+            width=512,
+            height=512
+        )
+        
+        elapsed_time = time.time() - start_time
+        print(f"📈 {steps}ステップ: {elapsed_time:.2f}秒")
+    
+    # VRAM使用量クリア
+    torch.cuda.empty_cache()
+
+def simple_test(pipe):
+    """シンプルなテスト生成（SDXL対応）"""
+    print("\n🔍 シンプルテスト開始...")
+    
+    try:
+        # SDXL用最小限のパラメータでテスト（日本女性特化）
+        print("🎨 SDXL最小限設定で生成中（日本女性の顔つき）...")
+        image = pipe(
+            "japanese woman, beautiful face, natural features",
+            negative_prompt="western features, caucasian, low quality",
+            width=1024,          # SDXL推奨サイズ
+            height=1024,         # SDXL推奨サイズ
+            num_inference_steps=20,
+            guidance_scale=7.0
+        ).images[0]
+        
+        # 保存
+        os.makedirs("outputs", exist_ok=True)
+        filepath = "outputs/simple_test_sdxl.png"
+        image.save(filepath)
+        print(f"✅ シンプルテスト成功: {filepath}")
+        return True
+    except Exception as e:
+        print(f"❌ シンプルテスト失敗: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """メイン実行関数"""
+    print("🚀 高品質画像生成テストを開始...")
+    print("=" * 50)
+    
+    # 統一ログ機能の初期化
+    logger = get_logger()
+    print("📋 統一ログ機能を初期化しました")
+    print(f"📄 ログファイル: {logger.json_log_file}")
+    
+    # 統計情報の表示
+    stats = logger.get_statistics()
+    print(f"📊 これまでの生成総数: {stats.get('total_generations', 0)}枚")
+    
+    # GPU状態確認
+    if not check_gpu_status():
+        print("❌ GPU環境が必要です")
+        return
+    
+    try:
+        # モデルセットアップ
+        pipe = setup_model()
+        
+        if pipe is None:
+            print("❌ モデルセットアップに失敗しました")
+            return
+        
+        # まずシンプルテスト
+        if not simple_test(pipe):
+            print("❌ シンプルテストに失敗、処理を中止します")
+            return
+        
+        # テスト生成実行
+        results = test_various_prompts(pipe)
+        
+        # スケジューラー比較テスト
+        scheduler_results = test_scheduler_comparison(pipe)
+        
+        # パラメータバリエーションテスト
+        test_parameter_variations(pipe)
+        
+        # 速度ベンチマーク
+        benchmark_generation_speed(pipe)
+        
+        # 結果サマリー
+        print("\n" + "=" * 50)
+        print("✅ テスト完了! 生成された画像:")
+        for result in results:
+            print(f"  📄 {result['description']}: {result['filepath']}")
+        
+        print(f"\n🎯 合計 {len(results)} 枚の画像を生成しました")
+        
+        # 最終VRAM使用量
+        if torch.cuda.is_available():
+            final_memory = torch.cuda.memory_allocated(0) / 1024**3
+            print(f"💾 最終VRAM使用量: {final_memory:.1f}GB")
+    
+    except Exception as e:
+        print(f"❌ エラーが発生しました: {str(e)}")
+        import traceback
+        traceback.print_exc()
+    
+    finally:
+        # メモリクリーンアップ
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+            print("🧹 VRAMキャッシュをクリアしました")
+
+if __name__ == "__main__":
+    main()

仮想環境への入り方.txt

@@ -0,0 +1 @@
+I:\jagirl_ui\.venv\Scripts\Activate.ps1