> ## Documentation Index
> Fetch the complete documentation index at: https://wb-21fd5541-wbdocs-1882.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# W&B Inference で Weave を学ぶ

> W&B Inference を使って Weave の基本を学び、モデル call をトレースし、出力を比較し、評価を実行します。

export const GitHubLink = ({url}) => <a href={url} target="_blank" rel="noopener noreferrer" className="github-source-link">
    <svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
      <path d="M12 0C5.37 0 0 5.37 0 12c0 5.31 3.435 9.795 8.205 11.385.6.105.825-.255.825-.57 0-.285-.015-1.23-.015-2.235-3.015.555-3.795-.735-4.035-1.41-.135-.345-.72-1.41-1.23-1.695-.42-.225-1.02-.78-.015-.795.945-.015 1.62.87 1.845 1.23 1.08 1.815 2.805 1.305 3.495.99.105-.78.42-1.305.765-1.605-2.67-.3-5.46-1.335-5.46-5.925 0-1.305.465-2.385 1.23-3.225-.12-.3-.54-1.53.12-3.18 0 0 1.005-.315 3.3 1.23.96-.27 1.98-.405 3-.405s2.04.135 3 .405c2.295-1.56 3.3-1.23 3.3-1.23.66 1.65.24 2.88.12 3.18.765.84 1.23 1.905 1.23 3.225 0 4.605-2.805 5.625-5.475 5.925.435.375.81 1.095.81 2.22 0 1.605-.015 2.895-.015 3.3 0 .315.225.69.825.57A12.02 12.02 0 0024 12c0-6.63-5.37-12-12-12z" />
    </svg>
    GitHub のソース
  </a>;

export const ColabLink = ({url}) => <a href={url} target="_blank" rel="noopener noreferrer" className="colab-link">
    <svg width="20" height="20" viewBox="0 0 24 24" fill="currentColor" xmlns="http://www.w3.org/2000/svg">
      <path d="M14.25.18l.9.2.73.26.59.3.45.32.34.34.25.34.16.33.1.3.04.26.02.2-.01.13V8.5l-.05.63-.13.55-.21.46-.26.38-.3.31-.33.25-.35.19-.35.14-.33.1-.3.07-.26.04-.21.02H8.77l-.69.05-.59.14-.5.22-.41.27-.33.32-.27.35-.2.36-.15.37-.1.35-.07.32-.04.27-.02.21v3.06H3.17l-.21-.03-.28-.07-.32-.12-.35-.18-.36-.26-.36-.36-.35-.46-.32-.59-.28-.73-.21-.88-.14-1.05-.05-1.23.06-1.22.16-1.04.24-.87.32-.71.36-.57.4-.44.42-.33.42-.24.4-.16.36-.1.32-.05.24-.01h.16l.06.01h8.16v-.83H6.18l-.01-2.75-.02-.37.05-.34.11-.31.17-.28.25-.26.31-.23.38-.2.44-.18.51-.15.58-.12.64-.1.71-.06.77-.04.84-.02 1.27.05zm-6.3 1.98l-.23.33-.08.41.08.41.23.34.33.22.41.09.41-.09.33-.22.23-.34.08-.41-.08-.41-.23-.33-.33-.22-.41-.09-.41.09zm13.09 3.95l.28.06.32.12.35.18.36.27.36.35.35.47.32.59.28.73.21.88.14 1.04.05 1.23-.06 1.23-.16 1.04-.24.86-.32.71-.36.57-.4.45-.42.33-.42.24-.4.16-.36.09-.32.05-.24.02-.16-.01h-8.22v.82h5.84l.01 2.76.02.36-.05.34-.11.31-.17.29-.25.25-.31.24-.38.2-.44.17-.51.15-.58.13-.64.09-.71.07-.77.04-.84.01-1.27-.04-1.07-.14-.9-.2-.73-.25-.59-.3-.45-.33-.34-.34-.25-.34-.16-.33-.1-.3-.04-.25-.02-.2.01-.13v-5.34l.05-.64.13-.54.21-.46.26-.38.3-.32.33-.24.35-.2.35-.14.33-.1.3-.06.26-.04.21-.02.13-.01h5.84l.69-.05.59-.14.5-.21.41-.28.33-.32.27-.35.2-.36.15-.36.1-.35.07-.32.04-.28.02-.21V6.07h2.09l.14.01.21.03zm-6.47 14.25l-.23.33-.08.41.08.41.23.33.33.23.41.08.41-.08.33-.23.23-.33.08-.41-.08-.41-.23-.33-.33-.23-.41-.08-.41.08z" />
    </svg>
    Colabで試す
  </a>;

<div style={{ display: 'flex', gap: '12px', flexWrap: 'wrap' }}>
  <ColabLink url="https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/learn-weave-with-inference.ipynb" />

  <GitHubLink url="https://github.com/wandb/docs/blob/main/weave/cookbooks/source/learn-weave-with-inference.ipynb" />
</div>

このガイドでは、[W\&B Inference](https://docs.wandb.ai/inference/) で W\&B Weave を使う方法を紹介します。W\&B Inference を使うと、自前のインフラストラクチャーを用意したり、複数のプロバイダーの APIキー を管理したりすることなく、すぐに使えるオープンソースモデルで LLM アプリケーションを構築し、トレースできます。W\&B APIキー があれば、[W\&B Inference でホストされているすべてのModels](https://docs.wandb.ai/inference/models/) を利用できます。

<div id="what-youll-learn">
  ## このガイドで学べること
</div>

このガイドでは、次のことを学びます。

* Weave と W\&B Inference を設定する
* 自動トレースを備えた基本的な LLM アプリケーションを構築する
* 複数のModelsを比較する
* データセットに対するモデル性能を評価する
* Weave UI で結果を確認する

<div id="prerequisites">
  ## 前提条件
</div>

* [W\&Bアカウント](https://wandb.ai/signup)
* Python 3.8+ または Node.js 18+
* 必要なパッケージがインストールされていること:
  * **Python**: `pip install weave openai`
  * **TypeScript**: `npm install weave openai`
* [OpenAI APIキー](https://platform.openai.com/api-keys) が環境変数として設定されていること

<div id="trace-your-first-llm-call">
  ## 最初の LLM call をトレースする
</div>

まず、次のコード例をコピー＆ペーストしてください。このコード例では、W\&B Inference の Llama 3.1-8B を使用します。

このコードを実行すると、Weave は次のことを行います。

* LLM call を自動的にトレースします
* inputs、outputs、レイテンシー、トークン使用量をログします
* Weave UI でトレースを表示するためのリンクを提供します

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    import weave
    import openai

    # Weave を初期化します - your-team/your-project を置き換えてください
    weave.init("<team-name>/inference-quickstart")

    # W&B Inference を指す OpenAI 互換クライアントを作成します
    client = openai.OpenAI(
        base_url='https://api.inference.wandb.ai/v1',
        api_key="YOUR_WANDB_API_KEY",  # 実際の APIキー に置き換えてください
        project="<team-name>/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)
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines theme={null}
    import * as weave from 'weave';
    import OpenAI from 'openai';

    // Weave を初期化します - "<>" で囲まれた値を自分のものに置き換えてください。
    await weave.init("<team-name>/inference-quickstart")

    // W&B Inference を指す OpenAI 互換クライアントを作成します
    const client = new OpenAI({
        baseURL: 'https://api.inference.wandb.ai/v1',  // W&B 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);
    ```
  </Tab>
</Tabs>

<div id="build-a-text-summarization-application">
  ## テキスト要約アプリケーションを構築する
</div>

次に、このコードを実行してみてください。これは、Weave がネストした処理をどのようにトレースするかを示すシンプルな要約アプリです。

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    import weave
    import openai

    # Weaveを初期化する - "<>"で囲まれた値を自分のものに置き換えてください。
    weave.init("<team-name>/inference-quickstart")

    client = openai.OpenAI(
        base_url='https://api.inference.wandb.ai/v1',
        api_key="YOUR_WANDB_API_KEY",  # 実際のAPIキーに置き換えてください
        project="<team-name>/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"])
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines theme={null}
    import * as weave from 'weave';
    import OpenAI from 'openai';

    // Weaveを初期化 - your-team/your-projectを置き換えてください
    await weave.init('<team-name>/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);
    ```
  </Tab>
</Tabs>

<div id="compare-multiple-models">
  ## 複数のモデルを比較する
</div>

W\&B Inference では複数のモデルを利用できます。Llama と DeepSeek の応答パフォーマンスを比較するには、次のコードを使用します。

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    import weave
    import openai

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

    client = openai.OpenAI(
        base_url='https://api.inference.wandb.ai/v1',
        api_key="YOUR_WANDB_API_KEY",  # 実際の APIキー に置き換えてください
        project="<team-name>/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))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines theme={null}
    import * as weave from 'weave';
    import OpenAI from 'openai';

    // Weave を初期化します。your-team/your-project に置き換えてください
    await weave.init("<team-name>/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));
    ```
  </Tab>
</Tabs>

<div id="evaluate-model-performance">
  ## モデル性能を評価する
</div>

Weave に組み込まれている `EvaluationLogger` を使用して、Q\&A タスクにおけるモデル性能を評価します。これにより、自動集計、トークン使用量の記録、UI での高度な比較機能を含む、構造化された評価トラッキングが可能になります。

前のセクションで使用したスクリプトに、次のコードを追加します：

<Tabs>
  <Tab title="Python">
    ```python lines theme={null}
    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:
        """モデル出力の精度をスコアリングする。"""
        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]):
        """Weaveの組み込み評価フレームワークを使用してデータセットの評価を実行する。"""
        # トークン使用量を取得するため、モデルを呼び出す前にEvaluationLoggerを初期化する
        # W&B 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"{model.model_name}（{safe_model_name}としてログ済み）の評価が完了しました。Weave UIで結果を確認してください。")

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

    for model in models_to_compare:
        evaluate_model(model, dataset)

    # Weave UIで「Evals」タブにアクセスし、モデル間の結果を比較する
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript lines theme={null}
    import { EvaluationLogger } from 'weave';

    // Create a simple dataset
    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'] },
    ];

    // Define a scorer
    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 };
    });

    // Evaluate a model using Weave's EvaluationLogger
    async function evaluateModel(
      model: (question: string) => Promise<string>,
      modelName: string,
      dataset: DatasetExample[]
    ): Promise<void> {
      // Initialize EvaluationLogger BEFORE calling the model to capture token usage
      // This is especially important for W&B Inference to track costs
      // Convert model name to a valid format (replace non-alphanumeric chars with underscores)
      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) {
        // Get model prediction
        const output = await model(example.question);
        
        // Log the prediction
        const predLogger = evalLogger.logPrediction(
          { question: example.question },
          output
        );
        
        // Score the output
        const score = await accuracyScorer({
          expected: example.expected || '',
          output: output,
          expected_one_of: example.expected_one_of
        });
        
        // Log the score
        predLogger.logScore('accuracy', score.score);
        
        // Finish logging for this prediction
        predLogger.finish();
      }
      
      // Log summary - Weave automatically aggregates the accuracy scores
      await evalLogger.logSummary();
      console.log(`Evaluation complete for ${modelName} (logged as: ${safeModelName}). View results in the Weave UI.`);
    }

    // Compare multiple models - a key feature of Weave's evaluation framework
    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);
    }

    // In the Weave UI, navigate to the Evals tab to compare results across models
    ```
  </Tab>
</Tabs>

これらの例を実行すると、ターミナルにトレースへのリンクが表示されます。いずれかのリンクをクリックすると、Weave UIでトレースを確認できます。

Weave UIでは、次のことができます。

* すべてのLLM callsのタイムラインを確認する
* 各operationの入力と出力を調べる
* トークン使用量と推定コストを表示する (EvaluationLoggerが自動的に取得)
* レイテンシとパフォーマンスのメトリクスを分析する
* **Evals** タブにアクセスして、集計された評価結果を確認する
* **Compare** 機能を使用して、異なるModels間のパフォーマンスを分析する
* 個々の例を順に見ながら、同じ入力に対して異なるModelsがどのようなパフォーマンスを示したかを確認する

<div id="available-models">
  ## 利用可能なModels
</div>

利用可能なModelsの一覧については、W\&B Inference ドキュメントの[利用可能なModels セクション](https://docs.wandb.ai/inference/models/)を参照してください。

<div id="next-steps">
  ## 次のステップ
</div>

* **Playgroundを使う**: Weave Playgroundで[モデルをインタラクティブに試す](/ja/weave/guides/tools/playground#access-the-playground)
* **評価を作成する**: LLM アプリケーションの[体系的な評価](/ja/weave/guides/core-types/evaluations)について学ぶ
* **他のインテグレーションも試す**: Weave は [OpenAI、Anthropic など多数](/ja/weave/guides/integrations)と連携できます

<div id="troubleshooting">
  ## トラブルシューティング
</div>

<details>
  <summary>認証エラー</summary>

  認証エラーが発生した場合:

  1. 有効な W\&B アカウントを持っていることを確認します
  2. [wandb.ai/settings](https://wandb.ai/settings) の正しいAPIキーを使用していることを確認します
  3. プロジェクト名が `team-name/project-name` の形式に従っていることを確認します
</details>

<details>
  <summary>レート制限エラー</summary>

  W\&B Inference にはプロジェクトごとの同時実行制限があります。レート制限に達した場合は、次をお試しください:

  * 同時リクエスト数を減らす
  * リクエストの間に遅延を入れる
  * より高い制限が必要な場合は、プランのアップグレードを検討する

  詳細については、[W\&B Inference の制限に関するドキュメント](https://docs.wandb.ai/inference/usage-limits/)を参照してください。
</details>

<details>
  <summary>クレジットの不足</summary>

  無料枠で利用できるクレジットには上限があります。詳細は、[使用量と制限に関するドキュメント](https://docs.wandb.ai/inference/usage-limits/)を参照してください。
</details>
