ml-model-integration

ML モデルの統合

googleadsagent.ai™によるAgent Skills™の一部です

説明

ML モデルの統合では、HuggingFace Hub から機械学習モデルを発見、評価、デプロイするためのワークフローを提供します。エージェントはタスクの種類でモデルレジストリを検索し、ベンチマークデータセットで候補を評価し、ローカルまたは API ベースで実行する推論パイプラインを構成して、ドメイン適応のためのファインチューニングワークフローを調整します。

HuggingFace Hub では、テキスト生成、画像分類、物体検出、音声認識、翻訳、要約など、何百種類ものタスクに対応する 500,000 以上のモデルがホストされています。この多様なモデルを使いこなすには、モデルアーキテクチャ、ライセンスの互換性、ハードウェア要件、ベンチマーク性能を理解する必要があります。このスキルはそうした知識を体系化し、適切なタスクに適したコストのモデルをエージェントが選べるよう支援します。

このスキルでは、モデルのライフサイクル全体を扱います。モデルの発見（タスクによる検索、ライセンスやサイズによる絞り込み）、評価（テストデータでの推論実行、レイテンシーと品質の測定）、デプロイ（ローカルの Transformers パイプライン、HuggingFace Inference API、または TGI/vLLM によるセルフホスト）、ファインチューニング（少量の学習データでドメイン固有のカスタマイズを行う LoRA アダプター）を対象とします。

使用する場面

• 特定の ML タスク（分類、生成、検出）に使うモデルを選定するとき
• ローカルまたは API 経由の推論パイプラインを設定するとき
• ドメイン固有のデータで事前学習済みモデルをファインチューニングするとき
• 独自のベンチマークでモデル品質を評価するとき
• 最適化されたサービングでモデルを本番環境にデプロイするとき
• ユーザーが HuggingFace、Transformers、またはモデルの選定について質問したとき

仕組み

graph TD
    A[Task Definition] --> B[Search HuggingFace Hub]
    B --> C[Filter: License, Size, Downloads]
    C --> D[Shortlist Top-3 Candidates]
    D --> E[Evaluate on Benchmark Data]
    E --> F{Quality Sufficient?}
    F -->|Yes| G[Deploy as Inference Pipeline]
    F -->|No| H[Fine-tune with LoRA]
    H --> I[Evaluate Fine-tuned Model]
    I --> G
    G --> J{Deployment Target}
    J -->|Local| K[Transformers Pipeline]
    J -->|API| L[HuggingFace Inference API]
    J -->|Self-Hosted| M[TGI / vLLM Server]

ワークフローはモデルの選定ではなく、タスクの定義から始まります。エージェントはタスクに合ったモデルを検索して候補を評価し、既製モデルの性能が不十分な場合にのみファインチューニングを行います。

実装

from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
from huggingface_hub import HfApi, ModelFilter
from peft import LoraConfig, get_peft_model, TaskType
import torch

def discover_models(task: str, min_downloads: int = 1000, license: str = "apache-2.0") -> list[dict]:
    api = HfApi()
    models = api.list_models(
        filter=ModelFilter(task=task, library="transformers"),
        sort="downloads",
        direction=-1,
        limit=20,
    )
    results = []
    for m in models:
        if m.downloads >= min_downloads:
            results.append({
                "id": m.modelId,
                "downloads": m.downloads,
                "likes": m.likes,
                "tags": m.tags,
                "pipeline_tag": m.pipeline_tag,
            })
    return results[:10]

def setup_inference(model_id: str, task: str, device: str = "auto") -> pipeline:
    return pipeline(
        task=task,
        model=model_id,
        device_map=device,
        torch_dtype=torch.float16,
    )

def evaluate_model(pipe, test_data: list[dict], label_key: str = "label") -> dict:
    correct = 0
    total = len(test_data)
    latencies = []

    for item in test_data:
        import time
        start = time.time()
        pred = pipe(item["text"])
        latencies.append((time.time() - start) * 1000)

        if pred[0]["label"] == item[label_key]:
            correct += 1

    return {
        "accuracy": correct / total,
        "avg_latency_ms": sum(latencies) / len(latencies),
        "p95_latency_ms": sorted(latencies)[int(0.95 * len(latencies))],
        "total_samples": total,
    }

def finetune_lora(
    base_model: str,
    train_dataset,
    output_dir: str,
    num_epochs: int = 3,
    lora_rank: int = 16,
):
    model = AutoModelForSequenceClassification.from_pretrained(base_model)
    tokenizer = AutoTokenizer.from_pretrained(base_model)

    lora_config = LoraConfig(
        task_type=TaskType.SEQ_CLS,
        r=lora_rank,
        lora_alpha=32,
        lora_dropout=0.1,
        target_modules=["q_proj", "v_proj"],
    )
    model = get_peft_model(model, lora_config)
    trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
    total = sum(p.numel() for p in model.parameters())
    print(f"Trainable: {trainable:,} / {total:,} ({100 * trainable / total:.1f}%)")

    from transformers import Trainer, TrainingArguments
    args = TrainingArguments(
        output_dir=output_dir,
        num_train_epochs=num_epochs,
        per_device_train_batch_size=8,
        learning_rate=2e-4,
        save_strategy="epoch",
        logging_steps=50,
        fp16=True,
    )
    trainer = Trainer(model=model, args=args, train_dataset=train_dataset, tokenizer=tokenizer)
    trainer.train()
    model.save_pretrained(output_dir)

ベストプラクティス

• モデルを検索する前に必ずタスクを定義します。モデルを先に選んで、それに合うタスクを探してはいけません
• 性能を評価する前に、ライセンスの互換性（Apache-2.0、MIT）で絞り込みます
• 公開済みのベンチマークだけでなく、独自のデータでも評価します。ドメインが重要です
• ファインチューニングには LoRA を使い、フルファインチューニングと比べて学習コストを 90% 削減します
• コンシューマー向けハードウェアで推論する場合は、モデルを量子化します（GPTQ、AWQ、bitsandbytes）
• 推論を再現可能にするため、コミットハッシュでモデルのリビジョンを固定します

プラットフォームとの互換性

プラットフォーム	サポート	備考
Cursor	完全	Python + Transformers
VS Code	完全	Jupyter + ML ツール
Windsurf	完全	ML ワークフローのサポート
Claude Code	完全	パイプラインスクリプトの生成
Cline	完全	モデル統合
aider	部分的	コード生成のみ

関連スキル

• プログラムによる動画作成
• Web アセット生成
• React のベストプラクティス
• バッチ処理

キーワード

huggingface transformers model-selection inference-pipeline fine-tuning lora model-evaluation ml-deployment

---

© 2026 googleadsagent.ai™ | Agent Skills™ | MIT License