> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Serverless Inference로 Weave 배우기
> Serverless Inference를 사용해 모델 Call을 트레이스하고, 출력을 비교하고, 평가를 실행하며 Weave의 기본 개념을 익혀 보세요.
export const GitHubLink = ({url, compact = false}) =>
{compact ? "View source" : <>
GitHub source
}
;
export const ColabLink = ({url}) =>
Try in Colab
;
이 가이드에서는 Weave를 [Serverless Inference](/ko/products/inference/serverless)와 함께 사용하면서 Weave의 기본 사항을 익히는 방법을 설명합니다. Serverless Inference를 사용하면 자체 인프라를 구성하거나 여러 공급자의 API 키를 관리하지 않고도 실시간으로 제공되는 오픈 소스 모델로 LLM 애플리케이션을 구축하고 트레이스할 수 있습니다. CoreWeave Forge API 키만 있으면 [Serverless Inference에서 호스팅하는 모든 모델](/ko/products/inference/serverless/models)을 사용할 수 있습니다. 이 가이드를 마치면 LLM Call을 트레이스하고, 모델을 비교하고, 평가를 실행해 그 결과를 Weights & Biases UI에서 검토할 수 있습니다.
학습 내용
이 가이드에서는 다음 방법을 설명합니다.
* Weave와 Serverless Inference 설정하기
* 자동 트레이싱 기능을 갖춘 기본 LLM 애플리케이션 구축하기
* 여러 모델 비교하기
* 데이터셋에서 모델 성능 평가하기
* Weights & Biases UI에서 결과 확인하기
사전 요구 사항
* [CoreWeave Forge 계정](https://id.coreweave.com/signup)
* Python 3.10 이상 또는 Node.js 18 이상
* 필수 패키지 설치:
* **Python**: `pip install weave openai`
* **TypeScript**: `npm install weave openai`
* 환경 변수로 설정된 [OpenAI API 키](https://platform.openai.com/api-keys)
첫 번째 LLM Call 트레이스하기
이 섹션에서는 LLM Call을 한 번 수행하고 Weave가 이를 자동으로 트레이스하도록 하는 방법을 설명합니다. 더 복잡한 예시로 넘어가기 전에 설정이 제대로 작동하는지 확인할 수 있습니다.
먼저 다음 코드 예시를 복사하여 붙여 넣으세요. 이 예시에서는 Serverless Inference의 Llama 3.1-8B를 사용합니다.
이 코드를 실행하면 Weave는 다음을 수행합니다.
* LLM Call을 자동으로 트레이스합니다.
* 입력, 출력, 지연 시간, 토큰 사용량을 로깅합니다.
* Weights & Biases UI에서 트레이스를 확인할 수 있는 링크를 제공합니다.
```python lines theme={"system"}
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)
```
```typescript lines theme={"system"}
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 엔드포인트
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 {
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 lines theme={"system"}
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"])
```
```typescript lines theme={"system"}
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 {
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 {
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 lines theme={"system"}
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))
```
```typescript lines theme={"system"}
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 {
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 작업에서 모델의 성능을 평가하세요. `EvaluationLogger`는 자동 집계, 토큰 사용량 캡처, UI의 다양한 비교 기능을 갖춘 구조화된 평가 추적을 제공합니다.
이전 섹션에서 사용한 스크립트에 다음 코드를 추가하세요.
```python lines theme={"system"}
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"]},
]
# Scorer 정의
@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 탭으로 이동하여 모델별 결과를 비교하세요
```
```typescript twoslash lines theme={"system"}
// @noErrors
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'] },
];
// 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 };
});
// Weave의 EvaluationLogger로 모델 평가
async function evaluateModel(
model: (question: string) => Promise,
modelName: string,
dataset: DatasetExample[]
): Promise {
// 토큰 사용량을 캡처하려면 반드시 모델을 호출하기 *전에* 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 and Biases UI의 Evals 탭으로 이동하여 모델별 결과를 비교하세요
```
이 예시를 실행하면 트레이스된 LLM Call, 중첩된 요약 파이프라인, 모델 비교, 전체 평가가 Weave에 로깅됩니다. 예시를 실행하면 터미널에 트레이스 링크가 반환되며, 링크를 클릭하면 Weights & Biases UI에서 트레이스를 확인할 수 있습니다.
Weights & Biases UI에서는 다음 작업을 할 수 있습니다.
* 모든 LLM Call의 타임라인을 검토합니다.
* 각 오퍼레이션의 입력과 출력을 살펴봅니다.
* 토큰 사용량과 예상 비용을 확인합니다(EvaluationLogger가 자동으로 캡처).
* 지연 시간과 성능 메트릭을 분석합니다.
* **Evals** 탭으로 이동하여 집계된 평가 결과를 확인합니다.
* **Compare** 기능을 사용하여 여러 모델의 성능을 비교 분석합니다.
* 개별 예시를 차례로 넘겨 보며 동일한 입력에 대해 각 모델이 어떤 성능을 보였는지 확인합니다.
사용 가능한 모델
사용 가능한 모델의 전체 목록은 Serverless Inference 문서의 [사용 가능한 모델 섹션](/ko/products/inference/serverless/models)을 참조하세요.
다음 단계
기본 개념을 익혔다면 다음 리소스를 통해 Weave와 Serverless Inference를 더 깊이 있게 활용해 보세요.
* **플레이그라운드 사용하기**: Weave 플레이그라운드에서 [모델을 대화형으로 사용해 보세요](/ko/products/wandb/weave/guides/tools/playground#access-the-playground)
* **평가 구축하기**: LLM 애플리케이션을 [체계적으로 평가](/ko/products/wandb/weave/guides/core-types/evaluations)하는 방법을 알아보세요
* **다른 인테그레이션 사용해 보기**: Weave는 [OpenAI, Anthropic 등 다양한 서비스](/ko/products/wandb/weave/guides/integrations)와 연동됩니다
문제 해결
인증 오류
인증 오류가 발생하면 다음을 확인하세요.
1. 유효한 CoreWeave Forge 계정이 있는지 확인하세요.
2. [forge.coreweave.com/settings](https://forge.coreweave.com/settings)에서 발급받은 올바른 API 키를 사용하고 있는지 확인하세요.
3. 프로젝트 이름이 `your-team/your-project` 형식인지 확인하세요.
요청 속도 제한 오류
Serverless Inference에는 프로젝트별 동시성 한도가 있습니다. 요청 속도 제한에 도달하면 다음을 시도하세요.
* 동시 요청 수를 줄이세요.
* Call 사이에 지연 시간을 두세요.
* 더 높은 한도가 필요하면 플랜 업그레이드를 고려하세요.
자세한 내용은 [Serverless Inference 한도 문서](/ko/products/inference/serverless/usage-limits)를 참조하세요.
크레딧 소진
무료 티어에서 제공하는 크레딧은 한정되어 있습니다. 자세한 내용은 [사용량 및 한도 문서](/ko/products/inference/serverless/usage-limits)를 참조하세요.