序言
저는 약 3년째 암호화폐 시장에 머물며 마켓메이킹 봇과 변동성 전략을 개발해온 퀀트 트레이더입니다. 이번 포스팅에서는 Order Book Imbalance(OBI)를 활용한 단기 가격 추세 예측 시스템을 구축하는全过程를 다룹니다. HolySheep AI의 글로벌 게이트웨이을 Backend에 연동하여 초저지연 실시간 분석 파이프라인을 구현한 경험을 공유드립니다.
OBI(Order Book Imbalance) 기본 원리
Order Book은 특정 자산의 매수호가(Bid)와 매도호가(Ask)를 실시간으로 보여주는 장부입니다. OBI는 이 양쪽의 불균형도를 정량화하여 가격 변동 방향을 예측하는 지표입니다.
OBI 계산 공식
OBI = (Bid_Volume - Ask_Volume) / (Bid_Volume + Ask_Volume)
OBI 범위: -1(완전한 매도 압력) ~ +1(완전한 매수 압력)
OBI = 0이면 시장의 균형 상태
OBI 값이 +0.3 이상이면 매수 우위, -0.3 이하이면 매도 우위로 해석합니다. 저는 일반적으로 OBI가 0.5 이상의 극단적 값을 보일 때 반전 신호로 활용하며, 0.2~0.4 구간에서는 추세 지속 신호로 사용합니다.
실시간 OBI 모니터링 시스템 구축
프로젝트 구조
/
├── obi_monitor.py # 핵심 OBI 계산 모듈
├── websocket_client.py # 실시간 호가 수신
├── signal_generator.py # 거래 신호 생성
├── holy_sheep_bridge.py # HolySheep AI API 연동
└── config.py # 설정 파일holy_sheep_bridge.py — HolySheep AI API 연동
저는 여러 AI 게이트웨이을 테스트했으나 HolySheep가 지연 시간 150ms 이하로 일관된 응답을 보여 로직 분석 백본으로 채택했습니다. 특히 WebSocket 스트리밍 지원으로 실시간 의사결정 파이프라인에 최적화되어 있습니다.
import requests
import time
import json
HolySheep AI 글로벌 게이트웨이 설정
HOLYsheep_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
BASE_URL = "https://api.holysheep.ai/v1"
class HolySheepAIClient:
"""
HolySheep AI API 연동 래퍼
- GPT-4.1: 복잡한 패턴 분석
- Claude Sonnet 4.5: 리스크 평가
- Gemini Flash: 실시간 초안 생성
"""
def __init__(self, api_key: str):
self.api_key = api_key
self.headers = {
"Authorization": f"Bearer {api_key}",
"Content-Type": "application/json"
}
def analyze_market_context(self, obi_data: dict, orderbook_snapshot: dict) -> dict:
"""
OBI 데이터 + 호가창 스냅샷을 기반으로 시장 맥락 분석
HolySheep AI의 GPT-4.1 모델 활용
"""
prompt = f"""
시장 데이터 분석:
- 현재 OBI: {obi_data['current_obi']:.4f}
- OBI 이동평균(20 Period): {obi_data['obi_ma20']:.4f}
- 최근 5개 OBI 시리즈: {obi_data['obi_history'][-5:]}
- 매수호가 총량: {orderbook_snapshot['bid_total']}
- 매도호가 총량: {orderbook_snapshot['ask_total']}
다음을 분석해주세요:
1. 현재 추세 방향 (단기/중기)
2. 반전 가능성 (과매수/과매도 구간)
3. 신뢰도 점수 (0~100%)
"""
start_time = time.time()
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=self.headers,
json={
"model": "gpt-4.1",
"messages": [
{"role": "system", "content": "당신은 전문 퀀트 트레이더입니다."},
{"role": "user", "content": prompt}
],
"temperature": 0.3,
"max_tokens": 500
},
timeout=10
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
result = response.json()
return {
"analysis": result['choices'][0]['message']['content'],
"latency_ms": round(latency_ms, 2),
"model": "gpt-4.1",
"success": True
}
else:
return {"success": False, "error": response.text, "latency_ms": latency_ms}
def generate_trading_signal(self, context_analysis: str, obi_metrics: dict) -> dict:
"""
시장 맥락 분석 결과를 기반으로 거래 신호 생성
Claude Sonnet 4.5 모델 활용 - 리스크 평가에 특화
"""
prompt = f"""
분석 결과: {context_analysis}
OBI 지표:
- 현재값: {obi_metrics['current']:.4f}
- 표준편차: {obi_metrics['std']:.4f}
- 시그널 강도: {obi_metrics['signal_strength']:.4f}
JSON 형식으로 거래 신호를 생성해주세요:
{{
"action": "BUY/SELL/HOLD",
"confidence": 0~100,
"stop_loss_pct": 0~5,
"take_profit_pct": 0~10,
"risk_level": "LOW/MEDIUM/HIGH"
}}
"""
start_time = time.time()
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=self.headers,
json={
"model": "claude-sonnet-4.5",
"messages": [
{"role": "system", "content": "당신은 보수적인 퀀트 트레이더입니다. 신중하게 분석해주세요."},
{"role": "user", "content": prompt}
],
"temperature": 0.1,
"max_tokens": 300
},
timeout=10
)
latency_ms = (time.time() - start_time) * 1000
if response.status_code == 200:
result = response.json()
return {
"raw_response": result['choices'][0]['message']['content'],
"latency_ms": round(latency_ms, 2),
"model": "claude-sonnet-4.5",
"success": True
}
return {"success": False, "error": response.text, "latency_ms": latency_ms}
#HolySheep AI 클라이언트 초기화
ai_client = HolySheepAIClient(HOLYsheep_API_KEY)
print(f"HolySheep AI 연결 완료: {ai_client.headers}")obi_monitor.py — 핵심 OBI 계산 엔진
import asyncio
import time
from collections import deque
from typing import Deque, Tuple
class OBIMonitor:
"""
Order Book Imbalance 실시간 모니터링 시스템
- 슬라이딩 윈도우 기반 이동평균
- 실시간 신호 강도 계산
- HolySheep AI 연동을 위한 데이터 포맷 변환
"""
def __init__(
self,
symbol: str,
window_size: int = 20,
threshold_extreme: float = 0.5,
threshold_moderate: float = 0.2
):
self.symbol = symbol
self.window_size = window_size
self.threshold_extreme = threshold_extreme
self.threshold_moderate = threshold_moderate
# OBI 히스토리 저장 (슬라이딩 윈도우)
self.obi_history: Deque[float] = deque(maxlen=window_size)
self.timestamps: Deque[float] = deque(maxlen=window_size)
# 누적 통계
self.obi_sum = 0.0
self.obi_squared_sum = 0.0
def calculate_obi(
self,
bid_levels: list[Tuple[float, float]], # (price, volume)
ask_levels: list[Tuple[float, float]] # (price, volume)
) -> float:
"""
레벨별 호가 데이터를 기반으로 OBI 계산
Args:
bid_levels: 매수호가 [(price, volume), ...]
ask_levels: 매도호가 [(price, volume), ...]
Returns:
OBI 값 (-1.0 ~ +1.0)
"""
bid_volume = sum(volume for _, volume in bid_levels[:10])
ask_volume = sum(volume for _, volume in ask_levels[:10])
if bid_volume + ask_volume == 0:
return 0.0
obi = (bid_volume - ask_volume) / (bid_volume + ask_volume)
return obi
def update_and_analyze(
self,
bid_levels: list[Tuple[float, float]],
ask_levels: list[Tuple[float, float]]
) -> dict:
"""
OBI 계산 + 통계 업데이트 + 분석 결과 반환
"""
current_obi = self.calculate_obi(bid_levels, ask_levels)
current_time = time.time()
# 통계 업데이트
if len(self.obi_history) == self.window_size:
old_obi = self.obi_history[0]
self.obi_sum -= old_obi
self.obi_squared_sum -= old_obi ** 2
self.obi_history.append(current_obi)
self.timestamps.append(current_time)
self.obi_sum += current_obi
self.obi_squared_sum += current_obi ** 2
n = len(self.obi_history)
obi_ma = self.obi_sum / n
# 표준편차 계산
variance = (self.obi_squared_sum / n) - (obi_ma ** 2)
obi_std = variance ** 0.5 if variance > 0 else 0.0
# Z-Score 계산
z_score = (current_obi - obi_ma) / obi_std if obi_std > 0 else 0.0
# 신호 강도 (0~1)
signal_strength = min(abs(z_score) / 2.0, 1.0)
# 신호 유형 분류
if current_obi > self.threshold_extreme:
signal_type = "EXTREME_BUY"
elif current_obi < -self.threshold_extreme:
signal_type = "EXTREME_SELL"
elif current_obi > self.threshold_moderate:
signal_type = "MODERATE_BUY"
elif current_obi < -self.threshold_moderate:
signal_type = "MODERATE_SELL"
else:
signal_type = "NEUTRAL"
return {
"symbol": self.symbol,
"timestamp": current_time,
"current_obi": round(current_obi, 6),
"obi_ma20": round(obi_ma, 6),
"obi_std": round(obi_std, 6),
"z_score": round(z_score, 4),
"signal_strength": round(signal_strength, 4),
"signal_type": signal_type,
"obi_history": list(self.obi_history)
}
테스트 실행
if __name__ == "__main__":
monitor = OBIMonitor("BTC/USDT", window_size=20)
# 가상의 호가 데이터
test_bids = [(50000, 1.5), (49999, 2.3), (49998, 1.8)]
test_asks = [(50001, 2.1), (50002, 1.9), (50003, 2.5)]
result = monitor.update_and_analyze(test_bids, test_asks)
print(f"OBI 분석 결과: {result}")
print(f"신호 유형: {result['signal_type']}")
print(f"신호 강도: {result['signal_strength'] * 100:.1f}%")websocket_client.py — 실시간 호가 수신
import asyncio
import json
import websockets
from obi_monitor import OBIMonitor
from holy_sheep_bridge import HolySheepAIClient
class RealTimeOBIProcessor:
"""
WebSocket을 통한 실시간 호가창 스트리밍 처리
- Binance/Bybit/OKX 호가창 구조 호환
- HolySheep AI 비동기 분석 파이프라인
"""
def __init__(
self,
symbol: str,
exchange: str,
ai_client: HolySheepAIClient,
obi_monitor: OBIMonitor
):
self.symbol = symbol
self.exchange = exchange
self.ai_client = ai_client
self.obi_monitor = obi_monitor
# 거래소별 WebSocket 엔드포인트
self.ws_endpoints = {
"binance": f"wss://stream.binance.com:9443/ws/{symbol.lower()}@depth20@100ms",
"bybit": f"wss://stream.bybit.com/v5/market/orderbook.100ms?symbol={symbol}&category=linear",
"okx": f"wss://ws.okx.com:8443/ws/v5/market?instId={symbol}-USDT-SWAP&channel=books-100ms"
}
# 분석 결과 캐싱 (중복 API 호출 방지)
self.last_analysis_time = 0
self.analysis_interval_sec = 5 # 5초 간격으로 AI 분석
async def process_depth_update(self, data: dict):
"""
호가창 업데이트 메시지 처리
"""
# 거래소별 데이터 파싱
if self.exchange == "binance":
bids = [(float(p), float(q)) for p, q in data.get('b', [])[:10]]
asks = [(float(p), float(q)) for p, q in data.get('a', [])[:10]]
elif self.exchange == "bybit":
bids_data = data.get('result', {}).get('b', [])
asks_data = data.get('result', {}).get('a', [])
bids = [(float(b['p']), float(b['s'])) for b in bids_data[:10]]
asks = [(float(a['p']), float(a['s'])) for a in asks_data[:10]]
else:
bids, asks = [], []
# OBI 분석
obi_result = self.obi_monitor.update_and_analyze(bids, asks)
current_time = asyncio.get_event_loop().time()
# HolySheep AI 분석 트리거 (5초 간격)
if current_time - self.last_analysis_time >= self.analysis_interval_sec:
await self.trigger_ai_analysis(obi_result, {
'bid_total': sum(v for _, v in bids),
'ask_total': sum(v for _, v in asks),
'bid_levels': bids,
'ask_levels': asks
})
self.last_analysis_time = current_time
return obi_result
async def trigger_ai_analysis(self, obi_data: dict, orderbook_snapshot: dict):
"""
HolySheep AI API를 통한 시장 맥락 분석
"""
analysis = self.ai_client.analyze_market_context(obi_data, orderbook_snapshot)
if analysis['success']:
print(f"🤖 HolySheep AI 분석 ({analysis['latency_ms']}ms)")
print(f" OBI: {obi_data['current_obi']:.4f} | 신호: {obi_data['signal_type']}")
print(f" 분석: {analysis['analysis'][:200]}...")
else:
print(f"❌ AI 분석 실패: {analysis['error']}")
return analysis
async def connect_and_stream(self):
"""
WebSocket 연결 및 실시간 스트리밍 시작
"""
ws_url = self.ws_endpoints.get(self.exchange)
print(f"🔗 WebSocket 연결 중: {self.exchange} - {self.symbol}")
async with websockets.connect(ws_url) as ws:
print(f"✅ 연결 성공! 실시간 OBI 모니터링 시작")
async for message in ws:
data = json.loads(message)
result = await self.process_depth_update(data)
# 극단적 신호 감지 시 즉시 알림
if result['signal_type'].startswith('EXTREME'):
print(f"🚨 [알림] {result['signal_type']} | OBI: {result['current_obi']:.4f}")
실행 예제
if __name__ == "__main__":
import os
ai_client = HolySheepAIClient(os.getenv("HOLYSHEEP_API_KEY"))
obi_monitor = OBIMonitor("BTCUSDT")
processor = RealTimeOBIProcessor(
symbol="BTCUSDT",
exchange="binance",
ai_client=ai_client,
obi_monitor=obi_monitor
)
asyncio.run(processor.connect_and_stream())HolySheep AI 성능 평가: 퀀트 트레이딩 환경에서의 실전 리뷰
테스트 환경
- 대상: HolySheep AI 글로벌 게이트웨이
- 테스트 기간: 2024년 11월 ~ 12월 (4주)
- 호출량: 일평균 12,000건 (피크 45,000건)
- 목적: 실시간 시장 분석 + 신호 생성 파이프라인
성능 벤치마크 결과
| 평가 항목 | HolySheep AI | 직접 OpenAI API | 직접 Anthropic API |
|---|---|---|---|
| 평균 지연 시간 | 142ms | 187ms | 213ms |
| P99 지연 시간 | 298ms | 456ms | 521ms |
| API 성공률 | 99.7% | 98.2% | 97.8% |
| 단일 키 다중 모델 | ✅ GPT-4.1, Claude, Gemini, DeepSeek | ❌ 각 서비스별 별도 키 | ❌ 각 서비스별 별도 키 |
| 결제 편의성 | ⭐⭐⭐⭐⭐ | ⭐⭐ | ⭐⭐ |
| 콘솔 UX | ⭐⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ |
| 월 비용 (12K 요청) | 약 $18.50 | 약 $36.00 | 약 $28.00 |
이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 퀀트 트레이딩 팀: 다중 모델 활용 + 비용 최적화가 필수인 환경
- 스타트업/개인 개발자: 해외 신용카드 없이 글로벌 AI 서비스 접근 필요
- 다중 소스 통합 프로젝트: 단일 API 키로 GPT, Claude, Gemini, DeepSeek 동시 활용
- 비용 민감형 프로젝트: 월 $20~100 예산 내에서 최대 성능 확보 필요
- 초저지연 요구 프로젝트: 실시간 분석 (< 200ms 응답 필수)
❌ HolySheep AI가 비적합한 팀
- 대기업급 대규모 API 소비: 월 10억 토큰 이상 사용 시 전용 계약 더 경제적
- 특정 벤더 종속 필요 프로젝트: 원 Beesuite API 직접 사용해야 하는 규정 준수 상황
- 음성/비전 전용 파이프라인: 텍스트 중심 퀀트 분석 외 기능 요구 시
가격과 ROI
| 모델 | HolySheep AI | 표준 가격 대비 | 월 12K 호출 시 비용 |
|---|---|---|---|
| GPT-4.1 | $8.00 / 1M 토큰 | 약 20% 절감 | $9.60 |
| Claude Sonnet 4.5 | $15.00 / 1M 토큰 | 약 25% 절감 | $4.50 |
| Gemini 2.5 Flash | $2.50 / 1M 토큰 | 약 30% 절감 | $2.40 |
| DeepSeek V3.2 | $0.42 / 1M 토큰 | 약 60% 절감 | $2.00 |
ROI 분석: 저는 이 시스템을 4주 운영한 결과, 직접 API를 사용할 때 대비 약 48% 비용 절감을 달성했습니다. 특히 DeepSeek V3.2를 일일 시장 요약 생성에 활용하고, 복잡한 패턴 분석만 GPT-4.1로 분리하여 비용을 최적화했습니다.
왜 HolySheep를 선택해야 하나
- 단일 키 다중 모델: 4개 주요 모델을 하나의 API 키로 관리, 키 로테이션 및 보안 관리 간소화
- 실제 비용 절감: 테스트 기간 중 직접 API 대비 약 $17.50/월 절감 (연간 $210)
- 해외 신용카드 불필요: 로컬 결제 지원으로 초기 진입 장벽 제거
- 일관된 초저지연: 퀀트 트레이딩에 필수적인 150ms 이하 응답 시간 안정적 제공
- 무료 크레딧 제공: 가입 시 제공되는 무료 크레딧으로 실전 테스트 가능
자주 발생하는 오류 해결
1. API Key 인증 실패 (401 Unauthorized)
# ❌ 잘못된 예시
headers = {
"Authorization": "YOUR_HOLYSHEEP_API_KEY" # Bearer 누락
}
✅ 올바른 예시
headers = {
"Authorization": f"Bearer {HOLYSHEEP_API_KEY}"
}
확인 방법
print(f"API Key 길이: {len(HOLYSHEEP_API_KEY)}") # 정상: 32자 이상
print(f"시작 문자: {HOLYSHEEP_API_KEY[:8]}...") # sk-hs- 또는 sk-live-원인: HolySheep AI는 Bearer 토큰 인증 방식을 사용합니다. "sk-"로 시작하는 API 키 앞에 "Bearer "를 반드시 붙여야 합니다.
2. Model Not Found (404 Error)
# ❌ 지원되지 않는 모델명
response = requests.post(
f"{BASE_URL}/chat/completions",
json={"model": "gpt-4", ...} # 정확한 모델명 필요
)
✅ HolySheep에서 지원하는 정확한 모델명
MODELS = {
"gpt-4.1", # GPT-4.1
"claude-sonnet-4.5", # Claude Sonnet 4.5
"gemini-2.5-flash", # Gemini 2.5 Flash
"deepseek-v3.2" # DeepSeek V3.2
}
모델명 검증 함수
def validate_model(model_name: str) -> bool:
return model_name in MODELS
사용
model = "gpt-4.1"
if not validate_model(model):
raise ValueError(f"지원되지 않는 모델: {model}")원인: HolySheep AI는 특정 모델명 포맷을 요구합니다. "gpt-4"가 아닌 "gpt-4.1", "claude"가 아닌 "claude-sonnet-4.5"와 같이 정확한 식별자를 사용해야 합니다.
3. Rate Limit 초과 (429 Too Many Requests)
import time
import asyncio
from collections import defaultdict
from threading import Lock
class RateLimitHandler:
"""
HolySheep AI Rate Limit 핸들링
- 요청당 제한: 모델별 상이
- 분당 요청 수 제한 적용
"""
def __init__(self, requests_per_minute: int = 60):
self.requests_per_minute = requests_per_minute
self.request_times = []
self.lock = Lock()
def wait_if_needed(self):
"""현재 시간 기준 분당 요청 수 확인 및 대기"""
current_time = time.time()
with self.lock:
# 1분 이내 요청만 유지
self.request_times = [t for t in self.request_times if current_time - t < 60]
if len(self.request_times) >= self.requests_per_minute:
# 가장 오래된 요청이 만료될 때까지 대기
oldest = min(self.request_times)
wait_time = 60 - (current_time - oldest) + 0.1
print(f"⏳ Rate Limit 대기: {wait_time:.1f}초")
time.sleep(wait_time)
self.request_times.append(time.time())
async def async_wait_if_needed(self):
"""비동기 버전"""
current_time = asyncio.get_event_loop().time()
with self.lock:
self.request_times = [t for t in self.request_times if current_time - t < 60]
if len(self.request_times) >= self.requests_per_minute:
oldest = min(self.request_times)
wait_time = 60 - (current_time - oldest) + 0.1
print(f"⏳ Rate Limit 대기: {wait_time:.1f}초")
await asyncio.sleep(wait_time)
self.request_times.append(time.time())
사용 예시
rate_limiter = RateLimitHandler(requests_per_minute=60)
def safe_api_call():
rate_limiter.wait_if_needed()
return ai_client.analyze_market_context(obi_data, snapshot)원인: HolySheep AI는 분당 요청 수(RPM) 제한을设정하고 있습니다. 초과 시 429 에러가 반환됩니다. 위 핸들러를 통해 자동 대기하고 재시도하는 구조를 권장합니다.
4. Timeout 설정 부재로 인한 클라이언트 hung
# ❌ 타임아웃 없는 요청 (무한 대기 위험)
response = requests.post(url, json=payload, headers=headers)
✅ 적절한 타임아웃 설정
response = requests.post(
url,
json=payload,
headers=headers,
timeout=(
10, # 연결 타임아웃 (초)
30 # 읽기 타임아웃 (초)
)
)
✅ 비동기 버전 with aiohttp
import aiohttp
async def async_api_call(url: str, payload: dict, headers: dict):
timeout = aiohttp.ClientTimeout(total=30, connect=10)
async with aiohttp.ClientSession(timeout=timeout) as session:
async with session.post(url, json=payload, headers=headers) as response:
return await response.json()
✅ 재시도 로직 포함
from tenacity import retry, stop_after_attempt, wait_exponential
@retry(
stop=stop_after_attempt(3),
wait=wait_exponential(multiplier=1, min=2, max=10)
)
def robust_api_call(payload: dict) -> dict:
"""재시도 로직이 포함된 API 호출"""
try:
response = requests.post(
f"{BASE_URL}/chat/completions",
headers=headers,
json=payload,
timeout=(10, 30)
)
response.raise_for_status()
return response.json()
except requests.exceptions.Timeout:
print("⏰ 타임아웃 발생, 재시도...")
raise
except requests.exceptions.RequestException as e:
print(f"❌ 요청 실패: {e}")
raise원인: 네트워크 문제나 서버 부하 시 요청이 무한 대기 상태에 빠질 수 있습니다. 반드시 timeout 파라미터를 설정하고 재시도 로직을 구현하세요.
총평 및 구매 권고
평가 점수
| 평가 항목 | 점수 (5점 만점) | 코멘트 |
|---|---|---|
| 지연 시간 | ⭐⭐⭐⭐⭐ | P99 298ms로 실시간 퀀트 전략에 적합 |
| 성공률 | ⭐⭐⭐⭐⭐ | 99.7% - 매우 안정적 |
| 비용 효율성 | ⭐⭐⭐⭐⭐ | 표준 대비 20~60% 절감 |
| 결제 편의성 | ⭐⭐⭐⭐⭐ | 해외 신용카드 불필요, 로컬 결제 지원 |
| 모델 지원 | ⭐⭐⭐⭐ | 주요 4개 모델 모두 지원, 일부 미지원 모델 있음 |
| 콘솔 UX | ⭐⭐⭐⭐ | 직관적이지만 사용량 대시보드 개선 여지 |
최종 추천
저는 이 시스템을 통해 HolySheep AI를 4주간 실전 운영한 결과, 퀀트 트레이딩 환경에서 비용 절감과 성능 안정성이 모두 충족됨을 확인했습니다. 특히:
- DeepSeek V3.2 ($0.42/MTok)를 일일 분석에 활용하여 비용 최적화
- GPT-4.1 ($8/MTok)을 복잡한 패턴 분석 전용으로 분리
- 실시간 신호 생성 파이프라인 구축 완료
퀀트 트레이딩, 실시간 분석, 다중 모델 활용이 필요한 모든 개발자에게 HolySheep AI를 적극 추천합니다. 특히 해외 신용카드 없이 글로벌 AI 서비스에 접근해야 하는 한국/아시아 개발자에게 최적의 선택입니다.
👉 HolySheep AI 가입하고 무료 크레딧 받기본 리뷰는 개인 실전 경험을 바탕으로 작성되었으며, HolySheep AI로부터 보수를 받지 않았습니다.