# HuggingFace にモデルをアップロード
from huggingface_hub import HfApi, create_repo
from transformers import AutoTokenizer, AutoModelForCausalLM
 
class HuggingFacePublisher:
    """HuggingFace モデル公開管理"""
 
    def __init__(self, token: str):
        self.api = HfApi(token=token)
        self.token = token
 
    def publish_model(self, model_path: str, repo_name: str,
                      model_card: str) -> str:
        """モデルを公開"""
        # 1. リポジトリ作成
        repo_url = create_repo(
            repo_name,
            token=self.token,
            private=False,
            repo_type="model"
        )
 
        # 2. モデルファイルをアップロード
        self.api.upload_folder(
            folder_path=model_path,
            repo_id=repo_name,
            token=self.token
        )
 
        # 3. モデルカード作成
        self.api.upload_file(
            path_or_fileobj=model_card.encode(),
            path_in_repo="README.md",
            repo_id=repo_name,
            token=self.token
        )
 
        return repo_url
 
    def create_model_card(self, config: dict) -> str:
        """モデルカード（README）生成"""
        return f"""---
license: {config['license']}
language: {config['language']}
tags: {config['tags']}
datasets: {config['datasets']}
metrics: {config['metrics']}
---
 
# {config['name']}
 
## Model Description
{config['description']}
 
## Intended Use
{config['intended_use']}
 
## Training Data
{config['training_data']}
 
## Evaluation Results
{config['eval_results']}
 
## Limitations
{config['limitations']}
 
## How to Use
```python
from transformers import pipeline
pipe = pipeline("text-generation", model="{config['repo_id']}")
result = pipe("Your input text here")

# Replicate でのモデル公開と実行
import replicate
 
class ReplicateDeployer:
    """Replicate モデルデプロイ管理"""
 
    def __init__(self, api_token: str):
        self.client = replicate.Client(api_token=api_token)
 
    def run_model(self, model_id: str, inputs: dict) -> any:
        """既存モデルを実行"""
        output = replicate.run(
            model_id,
            input=inputs
        )
        return output
 
    def run_image_generation(self, prompt: str) -> str:
        """画像生成モデル実行"""
        output = replicate.run(
            "stability-ai/sdxl:latest",
            input={
                "prompt": prompt,
                "negative_prompt": "low quality, blurry",
                "width": 1024,
                "height": 1024,
                "num_outputs": 1
            }
        )
        return output[0]  # 画像URL
 
    def run_llm(self, prompt: str, model: str = "meta/llama-2-70b-chat") -> str:
        """LLM実行"""
        output = replicate.run(
            model,
            input={
                "prompt": prompt,
                "max_tokens": 512,
                "temperature": 0.7
            }
        )
        return "".join(output)

# cog.yaml - Replicate用モデル定義
"""
build:
  python_version: "3.11"
  python_packages:
    - torch==2.1.0
    - transformers==4.36.0
    - accelerate==0.25.0
  gpu: true
 
predict: "predict.py:Predictor"
"""
 
# predict.py
from cog import BasePredictor, Input, Path
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
 
class Predictor(BasePredictor):
    def setup(self):
        """モデルロード（起動時に1回だけ実行）"""
        self.model = AutoModelForCausalLM.from_pretrained(
            "your-model-path",
            torch_dtype=torch.float16,
            device_map="auto"
        )
        self.tokenizer = AutoTokenizer.from_pretrained("your-model-path")
 
    def predict(
        self,
        prompt: str = Input(description="入力テキスト"),
        max_tokens: int = Input(description="最大トークン数", default=256),
        temperature: float = Input(description="温度", default=0.7),
    ) -> str:
        """推論実行"""
        inputs = self.tokenizer(prompt, return_tensors="pt").to("cuda")
        outputs = self.model.generate(
            **inputs,
            max_new_tokens=max_tokens,
            temperature=temperature,
            do_sample=True
        )
        return self.tokenizer.decode(outputs[0], skip_special_tokens=True)

# BAD: モデルだけアップロード、README無し
api.upload_folder(folder_path="./model", repo_id="my-model")
# → 誰も使い方がわからない、ダウンロード数ゼロ
 
# GOOD: 充実したモデルカード + デモ + 使用例
publish_model_with_docs(
    model_path="./model",
    model_card=create_detailed_model_card(),
    demo=create_gradio_demo(),
    examples=create_usage_examples(),
    benchmarks=create_benchmark_results()
)
# → ドキュメントが充実 → 信頼性UP → ダウンロード増

# BAD: GPT-4のプロンプトを変えただけのGPTs
gpt_store_app = {
    "name": "Amazing Writer AI",
    "prompt": "あなたは優秀なライターです",  # これだけ
    "value": "ゼロ（誰でも作れる）"
}
 
# GOOD: 独自データ・独自処理で差別化
gpt_store_app = {
    "name": "法務契約レビューAI",
    "features": [
        "1000件の契約書データで学習済みナレッジ",
        "リスク条項の自動検出アルゴリズム",
        "業界別チェックリスト統合",
        "判例データベース連携"
    ],
    "value": "弁護士3時間分の作業を10分に短縮"
}

# HuggingFace モデル公開の完全フロー
class HuggingFacePublishFlow:
    """HuggingFace への公開からプロモーションまでの完全フロー"""
 
    def __init__(self, token: str, org_name: str):
        self.api = HfApi(token=token)
        self.org = org_name
 
    def full_publish_flow(self, model_config: dict):
        """完全な公開フロー"""
 
        # Step 1: リポジトリ作成
        repo_id = f"{self.org}/{model_config['name']}"
        create_repo(repo_id, token=self.api.token, private=False)
 
        # Step 2: モデルファイルアップロード
        self.api.upload_folder(
            folder_path=model_config["model_path"],
            repo_id=repo_id,
            commit_message="Initial model upload"
        )
 
        # Step 3: 充実したモデルカード作成
        model_card = self._create_comprehensive_card(model_config)
        self.api.upload_file(
            path_or_fileobj=model_card.encode(),
            path_in_repo="README.md",
            repo_id=repo_id
        )
 
        # Step 4: サンプルコード追加
        examples = self._create_examples(model_config)
        self.api.upload_file(
            path_or_fileobj=examples.encode(),
            path_in_repo="examples/quickstart.py",
            repo_id=repo_id
        )
 
        # Step 5: ベンチマーク結果追加
        benchmarks = self._create_benchmarks(model_config)
        self.api.upload_file(
            path_or_fileobj=benchmarks.encode(),
            path_in_repo="benchmarks/results.json",
            repo_id=repo_id
        )
 
        # Step 6: Spaces デモ作成
        self._create_demo_space(model_config, repo_id)
 
        return {
            "model_url": f"https://huggingface.co/{repo_id}",
            "demo_url": f"https://huggingface.co/spaces/{self.org}/{model_config['name']}-demo",
            "status": "published"
        }
 
    def _create_comprehensive_card(self, config: dict) -> str:
        """包括的なモデルカード生成"""
        return f"""---
license: {config.get('license', 'apache-2.0')}
language:
  - {config.get('language', 'ja')}
tags:
  - {config.get('task', 'text-generation')}
  - production-ready
datasets:
  - {config.get('dataset', 'custom')}
metrics:
  - accuracy
  - f1
model-index:
  - name: {config['name']}
    results:
      - task:
          type: {config.get('task', 'text-generation')}
        metrics:
          - name: Accuracy
            type: accuracy
            value: {config.get('accuracy', 0.95)}
---
 
# {config['name']}
 
## Model Description
{config['description']}
 
## Performance Highlights
- Accuracy: {config.get('accuracy', '95%')}
- Inference Speed: {config.get('speed', '50ms/request')}
- Model Size: {config.get('size', '350M parameters')}
 
## Intended Use
{config.get('intended_use', 'Production-ready for text processing tasks')}
 
## Quick Start
```python
from transformers import pipeline
pipe = pipeline("{config.get('task', 'text-generation')}", model="{self.org}/{config['name']}")
result = pipe("Your input text here")
print(result)

@misc{{{config['name']},
  author = {{{config.get('author', 'Your Name')}}},
  title = {{{config['name']}}},
  year = {{2025}},
  publisher = {{HuggingFace}},
}}

# GPT Store での成功パターン分析
gpt_store_strategies = {
    "category_leaders": {
        "productivity": {
            "example": "議事録AI要約ツール",
            "differentiator": "Zoom/Teams統合、日本語最適化",
            "monthly_users": "10,000+",
            "revenue_model": "ChatGPT Plus経由の収益シェア"
        },
        "education": {
            "example": "TOEIC対策AIチューター",
            "differentiator": "問題生成+弱点分析+学習計画",
            "monthly_users": "25,000+",
            "revenue_model": "GPT利用量シェア + 外部サービス誘導"
        },
        "legal": {
            "example": "契約書レビューGPT",
            "differentiator": "日本法準拠チェック、判例DB連携",
            "monthly_users": "5,000+",
            "revenue_model": "GPT利用量シェア + コンサル誘導"
        }
    },
    "success_factors": [
        "明確なニッチ: 汎用ではなく特定用途に特化",
        "独自データ: 公開データにない専門知識を組み込む",
        "アクション連携: 外部APIとの統合で実用性を高める",
        "継続的改善: ユーザーフィードバックに基づく週次更新",
        "SEO対策: GPT Storeの検索最適化（タイトル、説明文）"
    ],
    "monetization_flow": {
        "step_1": "無料GPTで認知獲得（月1万ユーザー目標）",
        "step_2": "プレミアム機能を外部SaaSで提供",
        "step_3": "企業向けカスタムGPT開発の受注",
        "step_4": "GPT Store 収益シェア + 外部売上の2軸"
    }
}

# AIマーケットプレイスでのコミュニティ構築戦略
community_strategy = {
    "huggingface_community": {
        "activities": [
            "モデルカードに詳細なドキュメントを記載",
            "Discussionsタブで質問に回答",
            "定期的なモデル更新（月1回以上）",
            "Spacesでインタラクティブデモを公開",
            "他の人気モデルとの比較ベンチマークを公開"
        ],
        "growth_metrics": {
            "downloads_monthly": "目標: 1000+",
            "likes": "目標: 50+",
            "community_engagement": "Discussion回答率 90%+"
        }
    },
    "cross_platform_promotion": {
        "twitter": "週2回のモデル紹介ツイート + デモ動画",
        "reddit": "r/MachineLearning, r/LocalLLaMA に月1投稿",
        "youtube": "モデルの使い方チュートリアル動画（月1本）",
        "blog": "技術ブログでモデルの設計思想を解説",
        "discord": "AIコミュニティのDiscordサーバーで情報共有"
    },
    "collaboration_opportunities": [
        "他のモデル作者との共同研究",
        "企業との共同ファインチューニング",
        "学術論文への貢献",
        "オープンソースプロジェクトへの統合"
    ]
}

# マーケットプレイス別の価格最適化
pricing_optimization = {
    "replicate_pricing": {
        "strategies": [
            {
                "name": "フリーミアム入口",
                "approach": "最初の100回実行無料、以降従量課金",
                "implementation": "Webhook経由でカウント、上限到達後にリダイレクト",
                "conversion_rate": "5-10%"
            },
            {
                "name": "段階的価格",
                "approach": "利用量に応じた価格逓減",
                "tiers": [
                    {"up_to": 1000, "per_run": "$0.01"},
                    {"up_to": 10000, "per_run": "$0.005"},
                    {"up_to": None, "per_run": "$0.002"}
                ],
                "benefit": "大口利用者を獲得しやすい"
            },
            {
                "name": "品質別価格",
                "approach": "推論精度/速度に応じた複数バリエーション",
                "variants": {
                    "fast": {"speed": "100ms", "quality": "90%", "price": "$0.001"},
                    "balanced": {"speed": "500ms", "quality": "95%", "price": "$0.005"},
                    "premium": {"speed": "2s", "quality": "99%", "price": "$0.02"}
                }
            }
        ]
    },
    "huggingface_pricing": {
        "inference_api": {
            "free_tier": "レート制限あり（月1000リクエスト）",
            "pro_tier": "月$9で10倍のレート",
            "enterprise": "専用エンドポイント、SLA付き"
        },
        "spaces_hosting": {
            "free": "CPU、2GB RAM、72時間スリープ",
            "basic": "$5/月、持続稼働",
            "gpu": "$20-100/月、GPU付き"
        }
    }
}

marketplace_trends = {
    "2025": {
        "key_trends": [
            "マルチモーダルモデルの標準化（テキスト+画像+音声）",
            "エージェントマーケットプレイスの台頭",
            "ファインチューニングのセルフサービス化",
            "モデルのコンポーザビリティ（組み合わせ利用）"
        ],
        "market_size": "$5B",
        "dominant_platforms": ["HuggingFace", "Replicate", "Together AI"]
    },
    "2026": {
        "key_trends": [
            "業界特化型AIマーケットプレイスの出現",
            "AIエージェント間の連携プロトコル標準化",
            "オンデバイスAIモデルマーケットの成長",
            "AI品質認証制度の普及"
        ],
        "market_size": "$12B",
        "opportunities": [
            "業界特化マーケットプレイスの構築",
            "AIモデル品質テストサービス",
            "エージェント連携ミドルウェア"
        ]
    },
    "2027": {
        "key_trends": [
            "自律型AIエージェントのマーケットプレイス",
            "合成データマーケットプレイス",
            "AIモデルの資産化（NFT/トークン化）",
            "規制対応AIマーケット（RegTech AI）"
        ],
        "market_size": "$25B+"
    }
}

import asyncio
import aiohttp
from dataclasses import dataclass, field
from datetime import datetime, timedelta
from typing import Optional
import json
 
@dataclass
class PlatformMetrics:
    """各プラットフォームの指標データ"""
    platform: str
    model_name: str
    downloads_total: int = 0
    downloads_30d: int = 0
    api_calls_today: int = 0
    revenue_mtd: float = 0.0
    avg_latency_ms: float = 0.0
    error_rate: float = 0.0
    active_users: int = 0
    rating: float = 0.0
    last_updated: datetime = field(default_factory=datetime.now)
 
class MultiPlatformDashboard:
    """マルチプラットフォーム統合ダッシュボード"""
 
    def __init__(self, config: dict):
        self.config = config
        self.metrics_history: list[dict] = []
        self.alert_thresholds = {
            "error_rate_max": 0.05,        # 5%以上でアラート
            "latency_max_ms": 3000,         # 3秒以上でアラート
            "revenue_drop_pct": 0.20,       # 20%以上の収益減でアラート
            "download_spike_pct": 5.0       # 5倍以上のスパイクで通知
        }
 
    async def collect_huggingface_metrics(self, model_id: str) -> PlatformMetrics:
        """HuggingFace のモデル指標を取得"""
        async with aiohttp.ClientSession() as session:
            # モデル情報の取得
            async with session.get(
                f"https://huggingface.co/api/models/{model_id}",
                headers={"Authorization": f"Bearer {self.config['hf_token']}"}
            ) as resp:
                data = await resp.json()
 
            # ダウンロード統計の取得
            async with session.get(
                f"https://huggingface.co/api/models/{model_id}/downloads"
            ) as resp:
                downloads = await resp.json()
 
            return PlatformMetrics(
                platform="huggingface",
                model_name=model_id,
                downloads_total=data.get("downloads", 0),
                downloads_30d=sum(
                    d.get("count", 0) for d in downloads.get("last_30_days", [])
                ),
                active_users=data.get("likes", 0),
                rating=0.0,  # HuggingFaceにはレーティングなし
                last_updated=datetime.now()
            )
 
    async def collect_replicate_metrics(self, model_id: str) -> PlatformMetrics:
        """Replicate のモデル指標を取得"""
        async with aiohttp.ClientSession() as session:
            async with session.get(
                f"https://api.replicate.com/v1/models/{model_id}",
                headers={"Authorization": f"Token {self.config['replicate_token']}"}
            ) as resp:
                data = await resp.json()
 
            # 実行統計の取得
            async with session.get(
                f"https://api.replicate.com/v1/models/{model_id}/predictions",
                headers={"Authorization": f"Token {self.config['replicate_token']}"},
                params={"created_after": (
                    datetime.now() - timedelta(days=30)
                ).isoformat()}
            ) as resp:
                predictions = await resp.json()
 
            run_count = len(predictions.get("results", []))
            return PlatformMetrics(
                platform="replicate",
                model_name=model_id,
                api_calls_today=run_count,
                avg_latency_ms=self._calc_avg_latency(predictions.get("results", [])),
                active_users=data.get("run_count", 0),
                last_updated=datetime.now()
            )
 
    def _calc_avg_latency(self, predictions: list) -> float:
        """平均レイテンシの計算"""
        if not predictions:
            return 0.0
        latencies = []
        for p in predictions:
            if p.get("completed_at") and p.get("started_at"):
                start = datetime.fromisoformat(p["started_at"])
                end = datetime.fromisoformat(p["completed_at"])
                latencies.append((end - start).total_seconds() * 1000)
        return sum(latencies) / len(latencies) if latencies else 0.0
 
    async def collect_all_metrics(self) -> list[PlatformMetrics]:
        """全プラットフォームの指標を並列収集"""
        tasks = []
        for model in self.config.get("huggingface_models", []):
            tasks.append(self.collect_huggingface_metrics(model))
        for model in self.config.get("replicate_models", []):
            tasks.append(self.collect_replicate_metrics(model))
 
        results = await asyncio.gather(*tasks, return_exceptions=True)
        metrics = [r for r in results if isinstance(r, PlatformMetrics)]
 
        # アラートチェック
        for m in metrics:
            self._check_alerts(m)
 
        # 履歴に保存
        self.metrics_history.append({
            "timestamp": datetime.now().isoformat(),
            "metrics": [self._to_dict(m) for m in metrics]
        })
 
        return metrics
 
    def _check_alerts(self, metrics: PlatformMetrics) -> list[str]:
        """閾値ベースのアラートチェック"""
        alerts = []
        if metrics.error_rate > self.alert_thresholds["error_rate_max"]:
            alerts.append(
                f"[ALERT] {metrics.platform}/{metrics.model_name}: "
                f"エラー率 {metrics.error_rate:.1%} が閾値超過"
            )
        if metrics.avg_latency_ms > self.alert_thresholds["latency_max_ms"]:
            alerts.append(
                f"[ALERT] {metrics.platform}/{metrics.model_name}: "
                f"レイテンシ {metrics.avg_latency_ms:.0f}ms が閾値超過"
            )
        return alerts
 
    def _to_dict(self, m: PlatformMetrics) -> dict:
        """PlatformMetrics を辞書に変換"""
        return {
            "platform": m.platform,
            "model_name": m.model_name,
            "downloads_total": m.downloads_total,
            "downloads_30d": m.downloads_30d,
            "api_calls_today": m.api_calls_today,
            "revenue_mtd": m.revenue_mtd,
            "avg_latency_ms": m.avg_latency_ms,
            "error_rate": m.error_rate,
            "active_users": m.active_users,
            "rating": m.rating
        }
 
    def generate_weekly_report(self) -> str:
        """週次レポートの生成"""
        report_lines = [
            "=" * 60,
            f"  AIマーケットプレイス 週次レポート",
            f"  期間: {(datetime.now() - timedelta(days=7)).strftime('%Y-%m-%d')} "
            f"- {datetime.now().strftime('%Y-%m-%d')}",
            "=" * 60,
            ""
        ]
 
        # プラットフォーム別集計
        if self.metrics_history:
            latest = self.metrics_history[-1]["metrics"]
            for m in latest:
                report_lines.extend([
                    f"[{m['platform']}] {m['model_name']}",
                    f"  ダウンロード数(30日): {m['downloads_30d']:,}",
                    f"  API呼び出し: {m['api_calls_today']:,}",
                    f"  平均レイテンシ: {m['avg_latency_ms']:.0f}ms",
                    f"  エラー率: {m['error_rate']:.2%}",
                    f"  月間収益: ${m['revenue_mtd']:,.2f}",
                    ""
                ])
 
        return "\n".join(report_lines)

class CrossPlatformPublisher:
    """複数プラットフォームへの同時公開"""
 
    def __init__(self, credentials: dict):
        self.credentials = credentials
        self.publish_log: list[dict] = []
 
    async def publish_to_all(self, model_config: dict) -> dict:
        """全プラットフォームに同時公開"""
        results = {}
 
        # 各プラットフォーム向けにモデルを最適化して公開
        publish_tasks = {
            "huggingface": self._publish_huggingface(model_config),
            "replicate": self._publish_replicate(model_config),
            "ollama": self._publish_ollama(model_config)
        }
 
        for platform, task in publish_tasks.items():
            try:
                result = await task
                results[platform] = {"status": "success", "url": result}
                self.publish_log.append({
                    "platform": platform,
                    "model": model_config["name"],
                    "status": "success",
                    "timestamp": datetime.now().isoformat()
                })
            except Exception as e:
                results[platform] = {"status": "error", "message": str(e)}
                self.publish_log.append({
                    "platform": platform,
                    "model": model_config["name"],
                    "status": "error",
                    "error": str(e),
                    "timestamp": datetime.now().isoformat()
                })
 
        return results
 
    async def _publish_huggingface(self, config: dict) -> str:
        """HuggingFace に公開"""
        from huggingface_hub import HfApi
        api = HfApi(token=self.credentials["hf_token"])
 
        repo_id = f"{config['author']}/{config['name']}"
        api.create_repo(repo_id, exist_ok=True)
        api.upload_folder(
            folder_path=config["model_path"],
            repo_id=repo_id
        )
        return f"https://huggingface.co/{repo_id}"
 
    async def _publish_replicate(self, config: dict) -> str:
        """Replicate に公開"""
        # Cog設定ファイルの自動生成
        cog_config = {
            "build": {
                "python_version": config.get("python_version", "3.11"),
                "python_packages": config.get("dependencies", [])
            },
            "predict": config.get("predict_file", "predict.py:Predictor")
        }
 
        # cog push コマンドの実行
        import subprocess
        result = subprocess.run(
            ["cog", "push", f"r8.im/{config['author']}/{config['name']}"],
            capture_output=True, text=True,
            cwd=config["model_path"]
        )
        if result.returncode != 0:
            raise RuntimeError(f"Cog push failed: {result.stderr}")
 
        return f"https://replicate.com/{config['author']}/{config['name']}"
 
    async def _publish_ollama(self, config: dict) -> str:
        """Ollama Registry に公開"""
        # Modelfile の生成
        modelfile_content = f"""
FROM {config.get('base_model', './model.gguf')}
PARAMETER temperature {config.get('temperature', 0.7)}
PARAMETER top_p {config.get('top_p', 0.9)}
SYSTEM \"\"\"{config.get('system_prompt', 'You are a helpful assistant.')}\"\"\"
"""
        modelfile_path = f"{config['model_path']}/Modelfile"
        with open(modelfile_path, "w") as f:
            f.write(modelfile_content)
 
        import subprocess
        # ローカルモデル作成
        subprocess.run(
            ["ollama", "create", config["name"], "-f", modelfile_path],
            check=True
        )
        # レジストリにプッシュ
        subprocess.run(
            ["ollama", "push", f"{config['author']}/{config['name']}"],
            check=True
        )
        return f"https://ollama.com/library/{config['author']}/{config['name']}"

class ComplianceChecker:
    """AIモデル公開時のコンプライアンスチェッカー"""
 
    REGULATIONS = {
        "GDPR": {
            "region": "EU",
            "requirements": [
                "学習データに個人情報が含まれていないことの確認",
                "データ処理の法的根拠の文書化",
                "データ主体の権利（削除要求等）への対応手順",
                "データ保護影響評価（DPIA）の実施"
            ]
        },
        "AI_Act": {
            "region": "EU",
            "requirements": [
                "AIシステムのリスク分類（高リスク/限定リスク/最小リスク）",
                "高リスクAIの場合: 適合性評価の実施",
                "透明性要件: AI生成コンテンツの明示",
                "技術文書の作成と保管"
            ]
        },
        "APPI": {
            "region": "Japan",
            "requirements": [
                "個人情報の利用目的の特定と通知",
                "要配慮個人情報の取得に関する同意",
                "第三者提供時の記録義務",
                "越境移転に関する規制への対応"
            ]
        }
    }
 
    def check_model_compliance(self, model_info: dict) -> dict:
        """モデルのコンプライアンス状況をチェック"""
        results = {}
        target_regions = model_info.get("target_regions", ["global"])
 
        for reg_name, reg_info in self.REGULATIONS.items():
            if "global" in target_regions or reg_info["region"] in target_regions:
                checks = []
                for req in reg_info["requirements"]:
                    status = self._evaluate_requirement(model_info, req)
                    checks.append({
                        "requirement": req,
                        "status": status,
                        "action_needed": status != "compliant"
                    })
                results[reg_name] = {
                    "region": reg_info["region"],
                    "checks": checks,
                    "overall": "compliant" if all(
                        c["status"] == "compliant" for c in checks
                    ) else "needs_review"
                }
 
        return results
 
    def _evaluate_requirement(self, model_info: dict, requirement: str) -> str:
        """個別要件の評価"""
        # 学習データの透明性チェック
        if "個人情報" in requirement or "personal" in requirement.lower():
            if model_info.get("training_data_audit"):
                return "compliant"
            return "needs_review"
 
        # ドキュメント要件チェック
        if "文書" in requirement or "記録" in requirement:
            if model_info.get("documentation_complete"):
                return "compliant"
            return "needs_action"
 
        return "needs_review"
 
    def generate_compliance_report(self, results: dict) -> str:
        """コンプライアンスレポートの生成"""
        report = ["# コンプライアンスレポート", ""]
        for reg_name, reg_data in results.items():
            report.append(f"## {reg_name} ({reg_data['region']})")
            report.append(f"全体ステータス: {reg_data['overall']}")
            report.append("")
            for check in reg_data["checks"]:
                icon = "[OK]" if check["status"] == "compliant" else "[!!]"
                report.append(f"  {icon} {check['requirement']}")
            report.append("")
        return "\n".join(report)