Serverless Inference で Weave を学ぶ

このガイドでは、Serverless Inference と Weave を使用して、Weave の基礎を学ぶ方法を説明します。Serverless Inference を使用すると、独自のインフラストラクチャーの構築や複数のプロバイダーの APIキーの管理を行わずに、稼働中のオープンソースモデルを使用して LLM アプリケーションを構築し、トレースできます。CoreWeave Forge の APIキーで、Serverless Inference がホストするすべてのモデルを利用できます。このガイドを終えると、LLM Call のトレース、モデルの比較、評価の実行ができ、その結果を Weights & Biases UI で確認できます。

学習内容

このガイドでは、以下の方法を説明します。

Weave と Serverless Inference を設定します。
自動トレース機能を備えた基本的な LLM アプリケーションを構築します。
複数のモデルを比較します。
データセットでモデル性能を評価します。
Weights & Biases の UI で結果を確認します。

前提条件

CoreWeave Forge アカウント
Python 3.10 以降または Node.js 18 以降
必須パッケージがインストールされていること:
- Python: pip install weave openai
- TypeScript: npm install weave openai
OpenAI APIキーが環境変数として設定されていること。

最初の LLM Call をトレースする

このセクションでは、単一の LLM Call を行い、Weave が自動的にそれをトレースする方法を示します。これにより、より複雑な例に進む前に、セットアップが正しく機能していることを確認できます。開始するには、以下のコード例をコピー＆ペーストしてください。このコード例では、Serverless Inference の Llama 3.1-8B を使用しています。このコードを実行すると、Weave は次のことを行います:

LLM Call を自動的にトレースします。
入力、出力、レイテンシー、トークン使用量をログします。
Weights & Biases UI でトレースを表示するためのリンクを提供します。

Python
TypeScript

import weave
import openai

# Weave を初期化します。[YOUR-TEAM] をチーム名に置き換えてください。
weave.init("[YOUR-TEAM]/inference-quickstart")

# Serverless Inference を指す OpenAI 互換のクライアントを作成します
client = openai.OpenAI(
    base_url='https://api.inference.wandb.ai/v1',
    api_key="YOUR_WANDB_API_KEY",  # 実際の APIキー に置き換えてください
    project="[YOUR-TEAM]/my-first-weave-project",  # 使用量のトラッキングに必須
)

# トレースを有効にするために関数をデコレートします。標準の OpenAI クライアントを使用します
@weave.op()
def ask_llama(question: str) -> str:
    response = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[
            {"role": "system", "content": "You are a helpful assistant."},
            {"role": "user", "content": question}
        ],
    )
    return response.choices[0].message.content

# 関数を呼び出します - Weave がすべてを自動的にトレースします
result = ask_llama("What are the benefits of using W&B Weave for LLM development?")
print(result)

import * as weave from 'weave';
import OpenAI from 'openai';

// Weave を初期化します。「[]」で囲まれた値を各自の値に置き換えてください。
await weave.init("[YOUR-TEAM]/inference-quickstart")

// Serverless Inference を指す OpenAI 互換のクライアントを作成します
const client = new OpenAI({
    baseURL: 'https://api.inference.wandb.ai/v1',  // Serverless Inference endpoint
    apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // APIキー に置き換えるか、WANDB_API_KEY 環境変数を設定してください
});

// トレースを有効にするために weave.op で関数をラップします
const askLlama = weave.op(async function askLlama(question: string): Promise<string> {
const response = await client.chat.completions.create({
    model: 'meta-llama/Llama-3.1-70B-Instruct',
    messages: [
    { role: 'system', content: 'You are a helpful assistant.' },
    { role: 'user', content: question }
    ],
});
return response.choices[0].message.content || '';
});

// 関数を呼び出します - Weave がすべてを自動的にトレースします
const result = await askLlama('What are the benefits of using W&B Weave for LLM development?');
console.log(result);

テキスト要約アプリケーションを構築する

単一の LLM Call をトレースできたので、このセクションでは、Weave が複数の関数にまたがるネストされたオペレーションをどのようにトレースするかを説明します。これにより、実際の複数ステップの LLM アプリケーションがどのように取得され、UI に表示されるかを確認できます。次に、以下のコードを実行します。これは、Weave がネストされたオペレーションをどのようにトレースするかを示す、基本的な要約アプリケーションです。

Python
TypeScript

import weave
import openai

# Weave を初期化します。「[]」で囲まれた値を自分の値に置き換えてください。
weave.init("[YOUR-TEAM]/inference-quickstart")

client = openai.OpenAI(
    base_url='https://api.inference.wandb.ai/v1',
    api_key="YOUR_WANDB_API_KEY",  # 実際の API キーに置き換えてください
    project="[YOUR-TEAM]/my-first-weave-project",  # 使用量のトラッキングに必須
)

@weave.op()
def extract_key_points(text: str) -> list[str]:
    """Extract key points from a text."""
    response = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[
            {"role": "system", "content": "Extract 3-5 key points from the text. Return each point on a new line."},
            {"role": "user", "content": text}
        ],
    )
    # 空白行を除いた応答を返します
    return [line for line in response.choices[0].message.content.strip().splitlines() if line.strip()]

@weave.op()
def create_summary(key_points: list[str]) -> str:
    """Create a concise summary based on key points."""
    points_text = "\n".join(f"- {point}" for point in key_points)
    response = client.chat.completions.create(
        model="meta-llama/Llama-3.1-8B-Instruct",
        messages=[
            {"role": "system", "content": "Create a one-sentence summary based on these key points."},
            {"role": "user", "content": f"Key points:\n{points_text}"}
        ],
    )
    return response.choices[0].message.content

@weave.op()
def summarize_text(text: str) -> dict:
    """Main summarization pipeline."""
    key_points = extract_key_points(text)
    summary = create_summary(key_points)
    return {
        "key_points": key_points,
        "summary": summary
    }

# サンプルテキストで試します
sample_text = """
The Apollo 11 mission was a historic spaceflight that landed the first humans on the Moon 
on July 20, 1969. Commander Neil Armstrong and lunar module pilot Buzz Aldrin descended 
to the lunar surface while Michael Collins remained in orbit. Armstrong became the first 
person to step onto the Moon, followed by Aldrin 19 minutes later. They spent about 
two and a quarter hours together outside the spacecraft, collecting samples and taking photographs.
"""

result = summarize_text(sample_text)
print("Key Points:", result["key_points"])
print("\nSummary:", result["summary"])

import * as weave from 'weave';
import OpenAI from 'openai';

// Weave を初期化します。your-team/your-project に置き換えてください
await weave.init('[YOUR-TEAM]/inference-quickstart');

const client = new OpenAI({
baseURL: 'https://api.inference.wandb.ai/v1',
apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY',  // あなたの API キーに置き換えるか、WANDB_API_KEY 環境変数を設定してください
});

const extractKeyPoints = weave.op(async function extractKeyPoints(text: string): Promise<string[]> {
const response = await client.chat.completions.create({
    model: 'meta-llama/Llama-3.1-8B-Instruct',
    messages: [
    { role: 'system', content: 'Extract 3-5 key points from the text. Return each point on a new line.' },
    { role: 'user', content: text }
    ],
});
// 空白行を除いた応答を返します
const content = response.choices[0].message.content || '';
return content.split('\n').map(line => line.trim()).filter(line => line.length > 0);
});

const createSummary = weave.op(async function createSummary(keyPoints: string[]): Promise<string> {
const pointsText = keyPoints.map(point => `- ${point}`).join('\n');
const response = await client.chat.completions.create({
    model: 'meta-llama/Llama-3.1-8B-Instruct',
    messages: [
    { role: 'system', content: 'Create a one-sentence summary based on these key points.' },
    { role: 'user', content: `Key points:\n${pointsText}` }
    ],
});
return response.choices[0].message.content || '';
});

const summarizeText = weave.op(async function summarizeText(text: string): Promise<{key_points: string[], summary: string}> {
const keyPoints = await extractKeyPoints(text);
const summary = await createSummary(keyPoints);
return {
    key_points: keyPoints,
    summary: summary
};
});

// サンプルテキストで試します
const sampleText = `
The Apollo 11 mission was a historic spaceflight that landed the first humans on the Moon 
on July 20, 1969. Commander Neil Armstrong and lunar module pilot Buzz Aldrin descended 
to the lunar surface while Michael Collins remained in orbit. Armstrong became the first 
person to step onto the Moon, followed by Aldrin 19 minutes later. They spent about 
two and a quarter hours together outside the spacecraft, collecting samples and taking photographs.
`;

const result = await summarizeText(sampleText);
console.log('Key Points:', result.key_points);
console.log('\nSummary:', result.summary);

複数のモデルを比較する

Weave の一般的な使用例として、同じプロンプトに対する異なるモデルの応答を比較することが挙げられます。Serverless Inference では、複数のモデルにアクセスできます。次のコードを使用して、Llama と DeepSeek のそれぞれの応答のパフォーマンスを比較します。

Python
TypeScript

import weave
import openai

# Weave を初期化します。your-team/your-project に置き換えてください
weave.init("[YOUR-TEAM]/inference-quickstart")

client = openai.OpenAI(
    base_url='https://api.inference.wandb.ai/v1',
    api_key="YOUR_WANDB_API_KEY",  # 実際の APIキーに置き換えてください
    project="[YOUR-TEAM]/my-first-weave-project",  # 使用量のトラッキングに必須です
)

# 異なる LLM を比較するための Model クラスを定義します
class InferenceModel(weave.Model):
    model_name: str
    
    @weave.op()
    def predict(self, question: str) -> str:
        response = client.chat.completions.create(
            model=self.model_name,
            messages=[
                {"role": "user", "content": question}
            ],
        )
        return response.choices[0].message.content

# 異なるモデルのインスタンスを作成します
llama_model = InferenceModel(model_name="meta-llama/Llama-3.1-8B-Instruct")
deepseek_model = InferenceModel(model_name="deepseek-ai/DeepSeek-V3.1")

# それぞれの応答を比較します
test_question = "Explain quantum computing in one paragraph for a high school student."

print("Llama 3.1 8B response:")
print(llama_model.predict(test_question))
print("\n" + "="*50 + "\n")
print("DeepSeek V3 response:")
print(deepseek_model.predict(test_question))

import * as weave from 'weave';
import OpenAI from 'openai';

// Weave を初期化します。your-team/your-project に置き換えてください
await weave.init("[YOUR-TEAM]/inference-quickstart")

const client = new OpenAI({
  baseURL: 'https://api.inference.wandb.ai/v1',
  apiKey: process.env.WANDB_API_KEY || 'YOUR_WANDB_API_KEY', // APIキーに置き換えるか、WANDB_API_KEY 環境変数を設定してください
});

// weave.op を使用してモデル関数を作成します（TypeScript では weave.Model はサポートされません）
function createModel(modelName: string) {
  return weave.op(async function predict(question: string): Promise<string> {
    const response = await client.chat.completions.create({
      model: modelName,
      messages: [
        { role: 'user', content: question }
      ],
    });
    return response.choices[0].message.content || '';
  });
}

// 異なるモデルのインスタンスを作成します
const llamaModel = createModel('meta-llama/Llama-3.1-8B-Instruct');
const deepseekModel = createModel('deepseek-ai/DeepSeek-V3.1');

// それぞれの応答を比較します
const testQuestion = 'Explain quantum computing in one paragraph for a high school student.';

console.log('Llama 3.1 8B response:');
console.log(await llamaModel(testQuestion));
console.log('\n' + '='.repeat(50) + '\n');
console.log('DeepSeek V3 response:');
console.log(await deepseekModel(testQuestion));

モデル性能を評価する

このセクションでは、その場限りの比較にとどまらず、データセット全体で体系的な評価を実行し、モデルの品質を系統的に測定して比較する方法を説明します。 Weave に組み込まれている EvaluationLogger を使用して、Q&A タスクでのモデル性能を評価します。これにより、自動集約、トークン使用量の取得、UI の豊富な比較機能を備えた、体系的な評価のトラッキングが可能になります。前のセクションで使用したスクリプトに、次のコードを追加します:

Python
TypeScript

from typing import Optional
from weave import EvaluationLogger

# シンプルなデータセットを作成します
dataset = [
    {"question": "What is 2 + 2?", "expected": "4"},
    {"question": "What is the capital of France?", "expected": "Paris"},
    {"question": "Name a primary color", "expected_one_of": ["red", "blue", "yellow"]},
]

# スコアラーを定義します
@weave.op()
def accuracy_scorer(expected: str, output: str, expected_one_of: Optional[list[str]] = None) -> dict:
    """Score the accuracy of the model output."""
    output_clean = output.strip().lower()
    
    if expected_one_of:
        is_correct = any(option.lower() in output_clean for option in expected_one_of)
    else:
        is_correct = expected.lower() in output_clean
    
    return {"correct": is_correct, "score": 1.0 if is_correct else 0.0}

# Weave の EvaluationLogger を使用してモデルを評価します
def evaluate_model(model: InferenceModel, dataset: list[dict]):
    """Run evaluation on a dataset using Weave's built-in evaluation framework."""
    # トークン使用量を取得するため、モデルを呼び出す前に EvaluationLogger を初期化します
    # これは Serverless Inference のコストをトラッキングするうえで特に重要です
    # モデル名を有効な形式に変換します（英数字以外の文字をアンダースコアに置き換えます）
    safe_model_name = model.model_name.replace("/", "_").replace("-", "_").replace(".", "_")
    eval_logger = EvaluationLogger(
        model=safe_model_name,
        dataset="qa_dataset"
    )
    
    for example in dataset:
        # モデルの予測を取得します
        output = model.predict(example["question"])
        
        # 予測をログします
        pred_logger = eval_logger.log_prediction(
            inputs={"question": example["question"]},
            output=output
        )
        
        # 出力を採点します
        score = accuracy_scorer(
            expected=example.get("expected", ""),
            output=output,
            expected_one_of=example.get("expected_one_of")
        )
        
        # スコアをログします
        pred_logger.log_score(
            scorer="accuracy",
            score=score["score"]
        )
        
        # この予測のログを終了します
        pred_logger.finish()
    
    # サマリーをログします - Weave が精度のスコアを自動的に集計します
    eval_logger.log_summary()
    print(f"Evaluation complete for {model.model_name} (logged as: {safe_model_name}). View results in the Weights & Biases UI.")

# 複数のモデルを比較します - Weave の評価フレームワークの主要機能です
models_to_compare = [
    llama_model,
    deepseek_model,
]

for model in models_to_compare:
    evaluate_model(model, dataset)

# Weights and Biases の UI で Evals タブにアクセスして、モデル間で結果を比較します

import { EvaluationLogger } from 'weave';

// 簡単なデータセットを作成します
interface DatasetExample {
  question: string;
  expected?: string;
  expected_one_of?: string[];
}

const dataset: DatasetExample[] = [
  { question: 'What is 2 + 2?', expected: '4' },
  { question: 'What is the capital of France?', expected: 'Paris' },
  { question: 'Name a primary color', expected_one_of: ['red', 'blue', 'yellow'] },
];

// スコアラーを定義します
const accuracyScorer = weave.op(function accuracyScorer(args: {
  expected: string;
  output: string;
  expected_one_of?: string[];
}): { correct: boolean; score: number } {
  const outputClean = args.output.trim().toLowerCase();
  
  let isCorrect: boolean;
  if (args.expected_one_of) {
    isCorrect = args.expected_one_of.some(option => 
      outputClean.includes(option.toLowerCase())
    );
  } else {
    isCorrect = outputClean.includes(args.expected.toLowerCase());
  }
  
  return { correct: isCorrect, score: isCorrect ? 1.0 : 0.0 };
});

// Weave の EvaluationLogger を使用してモデルを評価します
async function evaluateModel(
  model: (question: string) => Promise<string>,
  modelName: string,
  dataset: DatasetExample[]
): Promise<void> {
  // トークン使用量を取得するため、モデルを呼び出す前に EvaluationLogger を初期化します
  // これは、Serverless Inference でコストをトラッキングする際に特に重要です
  // モデル名を有効な形式に変換します（英数字以外の文字をアンダースコアに置き換えます）
  const safeModelName = modelName.replace(/\//g, '_').replace(/-/g, '_').replace(/\./g, '_');
  const evalLogger = new EvaluationLogger({
    name: 'inference_evaluation',
    model: { name: safeModelName },
    dataset: 'qa_dataset'
  });
  
  for (const example of dataset) {
    // モデルの予測を取得します
    const output = await model(example.question);
    
    // 予測をログします
    const predLogger = evalLogger.logPrediction(
      { question: example.question },
      output
    );
    
    // 出力を採点します
    const score = await accuracyScorer({
      expected: example.expected || '',
      output: output,
      expected_one_of: example.expected_one_of
    });
    
    // スコアをログします
    predLogger.logScore('accuracy', score.score);
    
    // この予測のログを終了します
    predLogger.finish();
  }
  
  // サマリーをログします - Weave が精度スコアを自動的に集計します
  await evalLogger.logSummary();
  console.log(`Evaluation complete for ${modelName} (logged as: ${safeModelName}). View results in the weights and Biases UI.`);
}

// 複数のモデルを比較します - Weave の評価フレームワークの主要な機能です
const modelsToCompare = [
  { model: llamaModel, name: 'meta-llama/Llama-3.1-8B-Instruct' },
  { model: deepseekModel, name: 'deepseek-ai/DeepSeek-V3.1' },
];

for (const { model, name } of modelsToCompare) {
  await evaluateModel(model, name, dataset);
}

// Weights & Biases の UI で Evals タブにアクセスして、モデル間で結果を比較します

これらのサンプルを実行すると、LLM Call、ネストした summarization pipeline、モデル比較、および Weave にログされた full 評価をトレースします。これらのサンプルを実行すると、ターミナルにトレースへのリンクが返されます。任意のリンクをクリックして、Weights & Biases UI でトレースを表示します。 Weights & Biases UI では、次の操作が可能です。

すべての LLM Call のタイムラインを確認します。
各オペレーションの入力と出力を検査します。
トークン使用量と推定コストを表示します (EvaluationLogger により自動的に取得されます) 。
レイテンシーとパフォーマンスメトリクスを分析します。
Evals タブにアクセスして、集計された評価結果を確認します。
Compare 機能を使用して、異なるモデル間でのパフォーマンスを分析します。
特定のサンプルをページ送りして、同じ入力に対して異なるモデルがどのように動作したかを確認します。

利用可能なモデル

利用可能なモデルの全一覧については、Serverless Inference ドキュメントの利用可能なモデルのセクションを参照してください。

次のステップ

基本を押さえたら、以下のリソースで Weave と Serverless Inference についてさらに詳しく学べます:

プレイグラウンドを使用する: Weave Playground でモデルをインタラクティブに試します
評価を構築する: LLM アプリケーションの体系的な評価について学びます
他のインテグレーションを試す: Weave は OpenAI、Anthropic など、多くのサービスと連携します

​学習内容

​前提条件

​最初の LLM Call をトレースする

​テキスト要約アプリケーションを構築する

​複数のモデルを比較する

​モデル性能を評価する

​利用可能なモデル

​次のステップ

​トラブルシューティング