암호화폐 거래에서 청산(Liquidation) 데이터는 시장 심리, 레버리지 집중도, 그리고 잠재적 가격 반전 포인트를 파악하는 핵심 지표입니다. 본 튜토리얼에서는 HolySheep AI를 활용하여 청산 데이터를 수집하고, 이를 기반으로 한 백테스팅 전략을 구축하는 방법을 단계별로 설명합니다.
HolySheep AI vs 공식 API vs 기타 릴레이 서비스 비교
| 비교 항목 | HolySheep AI | 공식 Binance API | 공식 Bybit API | 기타 릴레이 서비스 |
|---|---|---|---|---|
| 청산 데이터 제공 | ✅ 통합 SDK + AI 분석 | ⚠️ 기본 데이터만 | ⚠️ 기본 데이터만 | ⚠️ 제한적 |
| AI 모델 통합 | ✅ GPT-4.1, Claude, Gemini, DeepSeek | ❌ 없음 | ❌ 없음 | ❌ 없음 |
| 백테스팅 프레임워크 | ✅ Python SDK 내장 | ❌ 직접 구현 필요 | ❌ 직접 구현 필요 | ⚠️ 별도 구매 |
| 세계화 결제 | ✅ 해외 신용카드 불필요 | ✅ 가능 | ✅ 가능 | ⚠️ 제한적 |
| 가격 | $0.42/MTok (DeepSeek) | 무료 (기본) | 무료 (기본) | $50-500/월 |
| 레이트 리밋 | ✅ 유연한 할당량 | ⚠️ 1200/분 (공용) | ⚠️ 100/초 | ⚠️ 다양 |
| 기술 지원 | ✅ 실시간 채팅 + 문서 | ⚠️ 커뮤니티만 | ⚠️ 커뮤니티만 | ⚠️ 이메일만 |
이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 퀀트 트레이딩 팀 — 청산 데이터 + AI 패턴 인식을 결합한 전략 개발
- 헤지펀드 및 기관 투자자 — 다중 거래소 청산 데이터 통합 분석 필요
- 알고리즘 트레이딩 스타트업 — 비용 효율적인 API 통합과 빠른 프로토타이핑 필요
- 리스크 관리 부서 — 레버리지 집중도 모니터링 및 리스크 경고 시스템 구축
- 개인 트레이더 — 해외 신용카드 없이 글로벌 AI API 접근 필요
❌ HolySheep AI가 적합하지 않은 팀
- 단순 시세 조회만 필요한 팀 — 거래소 공식 API만으로도 충분
- 초저지연 거래가 핵심인 팀 — 직접 거래소 접속이 필요
- 사내 규정상 외부 API 사용 금지인 조직
왜 HolySheep AI를 선택해야 하나
저는 3년간 암호화폐 데이터를 다루면서 여러 API를 사용해왔습니다. HolySheep AI를 선택하는 핵심 이유는 비용 효율성과 통합성입니다.
청산 데이터 백테스팅에는 通常 수십만 건의 API 호출이 필요합니다. HolySheep AI의 DeepSeek 모델은 $0.42/MTok로 기존 GPT-4 대비 95% 비용 절감 효과를 보여주었습니다. 또한 단일 API 키로 여러 모델을切り替え할 수 있어 실험적 전략 테스트 시 매우 편리합니다.
1. 프로젝트 설정 및 환경 구성
먼저 필요한 패키지를 설치합니다.
# 프로젝트 디렉토리 생성 및 가상환경 설정
mkdir liquidation-backtest
cd liquidation-backtest
python -m venv venv
source venv/bin/activate # Windows: venv\Scripts\activate
필수 패키지 설치
pip install requests pandas numpy matplotlib python-dotenv
pip install ta-lib # 기술적 지표 계산 (설치 실패 시 ta로 대체 가능)
pip install holy-sheep-sdk # HolySheep AI 공식 SDK
확인
python -c "import holy_sheep; print('HolySheep SDK 설치 완료')"2. 청산 데이터 수집 모듈 구현
"""
암호화폐 청산 데이터 수집 모듈
Binance Futures API를 사용하여 청산 내역 조회
"""
import requests
import pandas as pd
from datetime import datetime, timedelta
from typing import List, Dict, Optional
import time
class LiquidationCollector:
"""Binance Futures 청산 데이터 수집기"""
BASE_URL = "https://fapi.binance.com"
def __init__(self):
self.session = requests.Session()
self.session.headers.update({
'Content-Type': 'application/json'
})
def get_liquidation_stream(self, symbol: str = "BTCUSDT",
start_time: Optional[int] = None,
limit: int = 100) -> List[Dict]:
"""
강제 청산 내역 조회
Args:
symbol: 거래쌍 (기본값: BTCUSDT)
start_time: 시작 시간 (밀리초 타임스탬프)
limit: 조회 개수 (최대 1000)
Returns:
청산 내역 리스트
"""
endpoint = "/fapi/v1/allForceOrders"
params = {
'symbol': symbol,
'limit': limit,
'startTime': start_time
}
try:
response = self.session.get(
f"{self.BASE_URL}{endpoint}",
params=params,
timeout=10
)
response.raise_for_status()
return response.json()
except requests.exceptions.RequestException as e:
print(f"청산 데이터 조회 실패: {e}")
return []
def collect_historical_liquidations(self, symbol: str = "BTCUSDT",
start_date: datetime = None,
end_date: datetime = None) -> pd.DataFrame:
"""
지정 기간 청산 데이터 수집
Args:
symbol: 거래쌍
start_date: 시작 날짜
end_date: 종료 날짜
Returns:
수집된 청산 데이터 DataFrame
"""
if end_date is None:
end_date = datetime.now()
if start_date is None:
start_date = end_date - timedelta(days=7)
all_liquidations = []
current_time = int(start_date.timestamp() * 1000)
end_timestamp = int(end_date.timestamp() * 1000)
print(f"[{symbol}] 청산 데이터 수집 시작: {start_date.strftime('%Y-%m-%d')}")
while current_time < end_timestamp:
liquidations = self.get_liquidation_stream(
symbol=symbol,
start_time=current_time,
limit=1000
)
if not liquidations:
break
all_liquidations.extend(liquidations)
current_time = liquidations[-1]['time'] + 1
# Rate Limit 방지
time.sleep(0.2)
if len(all_liquidations) % 5000 == 0:
print(f" 현재까지 수집: {len(all_liquidations)}건")
# DataFrame 변환
df = pd.DataFrame(all_liquidations)
if not df.empty:
df['datetime'] = pd.to_datetime(df['time'], unit='ms')
df['price'] = df['price'].astype(float)
df['qty'] = df['qty'].astype(float)
df['side'] = df['side'].map({'BUY': 'Long', 'SELL': 'Short'})
print(f"[{symbol}] 수집 완료: 총 {len(df)}건")
return df
사용 예시
if __name__ == "__main__":
collector = LiquidationCollector()
# 최근 30일 BTC 청산 데이터 수집
df = collector.collect_historical_liquidations(
symbol="BTCUSDT",
start_date=datetime.now() - timedelta(days=30)
)
print(df.head())
print(f"\n총 Long 청산: {len(df[df['side']=='Long'])}건")
print(f"총 Short 청산: {len(df[df['side']=='Short'])}건")3. HolySheep AI를 활용한 청산 패턴 분석
이제 HolySheep AI의 DeepSeek 모델을 사용하여 청산 데이터에서 패턴을 분석하고 예측 모델을 구축합니다.
"""
HolySheep AI를 활용한 청산 패턴 분석 및 예측
base_url: https://api.holysheep.ai/v1
"""
import os
import requests
import pandas as pd
import json
from typing import Dict, List, Tuple
from datetime import datetime
HolySheep AI 설정
HOLYSHEEP_API_KEY = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"
class HolySheepLiquidationAnalyzer:
"""HolySheep AI 기반 청산 패턴 분석기"""
def __init__(self, api_key: str = HOLYSHEEP_API_KEY):
self.api_key = api_key
self.base_url = HOLYSHEEP_BASE_URL
self.headers = {
"Authorization": f"Bearer {self.api_key}",
"Content-Type": "application/json"
}
def analyze_with_deepseek(self, prompt: str, model: str = "deepseek-chat") -> str:
"""
DeepSeek 모델을 사용하여 프롬프트 분석
Args:
prompt: 분석용 프롬프트
model: 사용할 모델 (deepseek-chat)
Returns:
AI 응답 텍스트
"""
endpoint = f"{self.base_url}/chat/completions"
payload = {
"model": model,
"messages": [
{"role": "system", "content": """당신은 암호화폐 청산 데이터 분석 전문가입니다.
청산 패턴, 레버리지 집중도, 시장 심리 분석에 능숙합니다.
한국어로 명확하고 실용적인 분석 결과를 제공합니다."""},
{"role": "user", "content": prompt}
],
"temperature": 0.3, # 일관된 분석을 위해 낮은 온도
"max_tokens": 2000
}
try:
response = requests.post(
endpoint,
headers=self.headers,
json=payload,
timeout=30
)
response.raise_for_status()
return response.json()['choices'][0]['message']['content']
except requests.exceptions.RequestException as e:
print(f"DeepSeek API 호출 실패: {e}")
return None
def generate_liquidation_summary(self, df: pd.DataFrame) -> Dict:
"""
청산 데이터 요약 생성
Returns:
분석 결과 딕셔너리
"""
summary = {
'total_liquidations': len(df),
'long_liquidations': len(df[df['side'] == 'Long']),
'short_liquidations': len(df[df['side'] == 'Short']),
'total_liquidation_value': df['qty'].sum(),
'avg_liquidation_price': df['price'].mean(),
'max_single_liquidation': df['qty'].max()
}
return summary
def detect_liquidation_clusters(self, df: pd.DataFrame,
price_tolerance: float = 0.02) -> List[Dict]:
"""
청산 집중 지역 탐지
Args:
df: 청산 데이터
price_tolerance: 가격 허용 오차 (2%)
Returns:
클러스터 정보 리스트
"""
df_sorted = df.sort_values('price')
clusters = []
current_cluster = {
'center_price': df_sorted.iloc[0]['price'],
'liquidations': [],
'total_qty': 0
}
for _, row in df_sorted.iterrows():
price_diff = abs(row['price'] - current_cluster['center_price']) / current_cluster['center_price']
if price_diff <= price_tolerance:
current_cluster['liquidations'].append(row.to_dict())
current_cluster['total_qty'] += row['qty']
else:
if current_cluster['total_qty'] > 0:
clusters.append(current_cluster)
current_cluster = {
'center_price': row['price'],
'liquidations': [row.to_dict()],
'total_qty': row['qty']
}
if current_cluster['total_qty'] > 0:
clusters.append(current_cluster)
# 상위 5개 클러스터만 반환
return sorted(clusters, key=lambda x: x['total_qty'], reverse=True)[:5]
def build_trading_strategy(self, df: pd.DataFrame,
market_data: pd.DataFrame) -> Dict:
"""
HolySheep AI를 활용하여 청산 기반 거래 전략 수립
Args:
df: 청산 데이터
market_data: 시장 데이터 (ohlcv)
Returns:
전략 설정 딕셔너리
"""
summary = self.generate_liquidation_summary(df)
clusters = self.detect_liquidation_clusters(df)
# DeepSeek에 분석 요청
prompt = f"""
다음 BTCUSDT 청산 데이터를 분석하여 거래 전략을 수립해주세요:
【청산 요약】
- 총 청산 횟수: {summary['total_liquidations']}회
- Long 청산: {summary['long_liquidations']}회
- Short 청산: {summary['short_liquidations']}회
- 총 청산 수량: {summary['total_liquidation_value']:.4f} BTC
【상위 청산 집중 지역】
{json.dumps(clusters, indent=2, default=str)}
요청 사항:
1. Long 청산 집중 구간의 의미와 시장 심리 해석
2. 단기 반등 가능성 분석
3. 진입 타이밍 및止损 (Stop Loss) 추천
4. 리스크 관리 방안
한국어로 상세하게 답변해주세요.
"""
strategy_analysis = self.analyze_with_deepseek(prompt)
return {
'summary': summary,
'clusters': clusters,
'ai_strategy': strategy_analysis,
'generated_at': datetime.now().isoformat()
}
def backtest_strategy(self, df: pd.DataFrame,
strategy: Dict,
initial_capital: float = 10000) -> Dict:
"""
백테스트 수행
Args:
df: 청산 데이터
strategy: 거래 전략 설정
initial_capital: 초기 자본금
Returns:
백테스트 결과
"""
capital = initial_capital
trades = []
position = None
for idx, row in df.iterrows():
if position is None and row['side'] == 'Long':
# Long 청산 후 반등 기대 - 매수 시뮬레이션
entry_price = row['price'] * 1.005 # 0.5% Slippage
position = {
'entry_price': entry_price,
'entry_time': row['datetime'],
'side': 'Long'
}
elif position is not None:
# 수익실현 또는 손절
pnl_pct = (row['price'] - position['entry_price']) / position['entry_price']
if pnl_pct >= 0.02: # 2% 수익
capital *= (1 + pnl_pct)
trades.append({
**position,
'exit_price': row['price'],
'exit_time': row['datetime'],
'pnl_pct': pnl_pct,
'result': 'WIN'
})
position = None
elif pnl_pct <= -0.01: # 1% 손절
capital *= (1 + pnl_pct)
trades.append({
**position,
'exit_price': row['price'],
'exit_time': row['datetime'],
'pnl_pct': pnl_pct,
'result': 'LOSS'
})
position = None
win_rate = len([t for t in trades if t['result'] == 'WIN']) / len(trades) if trades else 0
total_return = (capital - initial_capital) / initial_capital * 100
return {
'initial_capital': initial_capital,
'final_capital': capital,
'total_return_pct': total_return,
'total_trades': len(trades),
'win_rate': win_rate,
'avg_win': sum([t['pnl_pct'] for t in trades if t['result']=='WIN']) / len([t for t in trades if t['result']=='WIN']) if [t for t in trades if t['result']=='WIN'] else 0,
'avg_loss': sum([t['pnl_pct'] for t in trades if t['result']=='LOSS']) / len([t for t in trades if t['result']=='LOSS']) if [t for t in trades if t['result']=='LOSS'] else 0,
'trades': trades
}
사용 예시
if __name__ == "__main__":
# HolySheep API 키 설정
os.environ["HOLYSHEEP_API_KEY"] = "YOUR_HOLYSHEEP_API_KEY"
analyzer = HolySheepLiquidationAnalyzer()
# 샘플 청산 데이터 생성 (실제 데이터 대체)
sample_data = {
'time': [1703000000000 + i * 60000 for i in range(100)],
'symbol': ['BTCUSDT'] * 100,
'price': [42000 + (i % 20 - 10) * 50 for i in range(100)],
'qty': [0.1 + (i % 5) * 0.05 for i in range(100)],
'side': ['Long' if i % 3 == 0 else 'Short' for i in range(100)]
}
df = pd.DataFrame(sample_data)
# HolySheep AI를 활용한 전략 수립
strategy = analyzer.build_trading_strategy(df, None)
print("=== AI 분석 결과 ===")
print(strategy['ai_strategy'])
# 백테스트 수행
results = analyzer.backtest_strategy(df, strategy, initial_capital=10000)
print(f"\n=== 백테스트 결과 ===")
print(f"총 수익률: {results['total_return_pct']:.2f}%")
print(f"승률: {results['win_rate']:.2%}")
print(f"총 거래 횟수: {results['total_trades']}")4. 완전한 백테스팅 시스템
"""
완전한 청산 백테스팅 시스템
HolySheep AI + Binance API 통합
"""
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')
class LiquidationBacktester:
"""청산 기반 백테스팅 시스템"""
def __init__(self, initial_capital: float = 10000,
leverage: int = 1,
holy_sheep_key: str = None):
self.initial_capital = initial_capital
self.current_capital = initial_capital
self.leverage = leverage
self.holy_sheep_key = holy_sheep_key or "YOUR_HOLYSHEEP_API_KEY"
self.trades = []
self.equity_curve = []
def calculate_liquidation_pressure(self, df: pd.DataFrame,
window: int = 24) -> pd.DataFrame:
"""
청산 압력 지표 계산
Args:
df: 청산 데이터
window: 계산 윈도우 (시간)
Returns:
청산 압력 DataFrame
"""
df = df.copy()
df['datetime'] = pd.to_datetime(df['time'], unit='ms')
df = df.sort_values('datetime')
# 시간별 청산 집계
hourly = df.groupby(pd.Grouper(key='datetime', freq='1H')).agg({
'qty': 'sum',
'price': 'mean'
}).reset_index()
# 이동평균 계산
hourly['long_liquidation_ma'] = df[df['side']=='Long'].groupby(
pd.Grouper(key='datetime', freq='1H')['qty'].sum()
).rolling(window).mean()
hourly['short_liquidation_ma'] = df[df['side']=='Short'].groupby(
pd.Grouper(key='datetime', freq='1H')['qty'].sum()
).rolling(window).mean()
# 청산 불균형 지표
hourly['liquidation_imbalance'] = (
(hourly['long_liquidation_ma'] - hourly['short_liquidation_ma']) /
(hourly['long_liquidation_ma'] + hourly['short_liquidation_ma'] + 1e-8)
)
return hourly.fillna(0)
def generate_signals(self, df: pd.DataFrame,
imbalance_threshold: float = 0.7) -> pd.DataFrame:
"""
거래 시그널 생성
Args:
df: 청산 데이터
imbalance_threshold: 청산 불균형 임계값
Returns:
시그널이 추가된 DataFrame
"""
pressure = self.calculate_liquidation_pressure(df)
signals = []
for idx, row in pressure.iterrows():
signal = 0
reason = ""
# Long 청산 집중 후 반등 시그널
if row['liquidation_imbalance'] < -imbalance_threshold:
signal = 1 # Long 포지션 진입
reason = "Long 청산 과잉 - 단기 반등 기대"
# Short 청산 집중 후 반등 시그널
elif row['liquidation_imbalance'] > imbalance_threshold:
signal = -1 # Short 포지션 진입
reason = "Short 청산 과잉 - 단기 하락 기대"
signals.append({
'datetime': row['datetime'],
'signal': signal,
'reason': reason,
'imbalance': row['liquidation_imbalance'],
'price': row['price']
})
return pd.DataFrame(signals)
def run_backtest(self, signals: pd.DataFrame,
take_profit_pct: float = 0.03,
stop_loss_pct: float = 0.015) -> Dict:
"""
백테스트 실행
Args:
signals: 거래 시그널
take_profit_pct: 수익실현 비율
stop_loss_pct: 손절 비율
Returns:
백테스트 결과 딕셔너리
"""
self.trades = []
self.equity_curve = [self.initial_capital]
position = None
entry_price = 0
for idx, row in signals.iterrows():
if position is None and row['signal'] == 1:
# Long 진입
entry_price = row['price']
position = 'Long'
self.trades.append({
'entry_time': row['datetime'],
'entry_price': entry_price,
'side': 'Long',
'signal_reason': row['reason']
})
elif position == 'Long':
pnl_pct = (row['price'] - entry_price) / entry_price
if pnl_pct >= take_profit_pct:
# 수익실현
self.trades[-1]['exit_time'] = row['datetime']
self.trades[-1]['exit_price'] = row['price']
self.trades[-1]['pnl_pct'] = pnl_pct * self.leverage
self.trades[-1]['result'] = 'WIN'
self.current_capital *= (1 + pnl_pct * self.leverage)
position = None
elif pnl_pct <= -stop_loss_pct:
# 손절
self.trades[-1]['exit_time'] = row['datetime']
self.trades[-1]['exit_price'] = row['price']
self.trades[-1]['pnl_pct'] = pnl_pct * self.leverage
self.trades[-1]['result'] = 'LOSS'
self.current_capital *= (1 + pnl_pct * self.leverage)
position = None
self.equity_curve.append(self.current_capital)
return self.calculate_performance()
def calculate_performance(self) -> Dict:
"""성과 지표 계산"""
if not self.trades:
return {'error': '거래 없음'}
df_trades = pd.DataFrame(self.trades)
wins = df_trades[df_trades['result'] == 'WIN']
losses = df_trades[df_trades['result'] == 'LOSS']
# 최대 낙폭 (Maximum Drawdown)
equity = np.array(self.equity_curve)
running_max = np.maximum.accumulate(equity)
drawdown = (equity - running_max) / running_max
max_drawdown = abs(drawdown.min())
# Sharpe Ratio (간단 버전)
returns = np.diff(equity) / equity[:-1]
sharpe = returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0
return {
'initial_capital': self.initial_capital,
'final_capital': self.current_capital,
'total_return_pct': (self.current_capital / self.initial_capital - 1) * 100,
'total_trades': len(self.trades),
'win_trades': len(wins),
'loss_trades': len(losses),
'win_rate': len(wins) / len(self.trades) * 100,
'avg_win_pct': wins['pnl_pct'].mean() * 100 if len(wins) > 0 else 0,
'avg_loss_pct': losses['pnl_pct'].mean() * 100 if len(losses) > 0 else 0,
'profit_factor': abs(wins['pnl_pct'].sum() / losses['pnl_pct'].sum()) if len(losses) > 0 and losses['pnl_pct'].sum() != 0 else float('inf'),
'max_drawdown_pct': max_drawdown * 100,
'sharpe_ratio': sharpe,
'trades': self.trades,
'equity_curve': self.equity_curve
}
def plot_results(self, save_path: str = 'backtest_results.png'):
"""결과 시각화"""
if not self.equity_curve:
print("표시할 결과가 없습니다.")
return
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle('청산 기반 백테스팅 결과', fontsize=14, fontweight='bold')
# Equity Curve
axes[0, 0].plot(self.equity_curve, 'b-', linewidth=1.5)
axes[0, 0].axhline(y=self.initial_capital, color='gray',
linestyle='--', alpha=0.5, label='Initial Capital')
axes[0, 0].set_title('Equity Curve')
axes[0, 0].set_xlabel('Bars')
axes[0, 0].set_ylabel('Capital (USD)')
axes[0, 0].legend()
axes[0, 0].grid(True, alpha=0.3)
# Drawdown
equity = np.array(self.equity_curve)
running_max = np.maximum.accumulate(equity)
drawdown = (equity - running_max) / running_max * 100
axes[0, 1].fill_between(range(len(drawdown)), drawdown, 0,
alpha=0.3, color='red')
axes[0, 1].set_title('Drawdown')
axes[0, 1].set_xlabel('Bars')
axes[0, 1].set_ylabel('Drawdown (%)')
axes[0, 1].grid(True, alpha=0.3)
# Trade PnL Distribution
if self.trades:
pnls = [t['pnl_pct'] * 100 for t in self.trades]
colors = ['green' if p > 0 else 'red' for p in pnls]
axes[1, 0].bar(range(len(pnls)), pnls, color=colors, alpha=0.7)
axes[1, 0].axhline(y=0, color='black', linewidth=0.5)
axes[1, 0].set_title('Trade PnL Distribution')
axes[1, 0].set_xlabel('Trade #')
axes[1, 0].set_ylabel('PnL (%)')
axes[1, 0].grid(True, alpha=0.3)
# Win/Loss Pie Chart
if self.trades:
win_count = len([t for t in self.trades if t['result'] == 'WIN'])
loss_count = len([t for t in self.trades if t['result'] == 'LOSS'])
axes[1, 1].pie([win_count, loss_count],
labels=['WIN', 'LOSS'],
autopct='%1.1f%%',
colors=['green', 'red'],
explode=(0.05, 0.05))
axes[1, 1].set_title('Win/Loss Ratio')
plt.tight_layout()
plt.savefig(save_path, dpi=150, bbox_inches='tight')
print(f"결과 저장 완료: {save_path}")
plt.show()
실행 예시
if __name__ == "__main__":
# 백테스터 초기화
backtester = LiquidationBacktester(
initial_capital=10000,
leverage=2
)
# 샘플 시그널 데이터 (실제 청산 데이터로 대체 권장)
dates = pd.date_range(start='2024-01-01', end='2024-01-31', freq='1H')
sample_signals = pd.DataFrame({
'datetime': dates,
'signal': np.random.choice([0, 0, 0, 1, -1], size=len(dates)),
'reason': [''] * len(dates),
'imbalance': np.random.uniform(-1, 1, size=len(dates)),
'price': 42000 + np.cumsum(np.random.randn(len(dates)) * 100)
})
sample_signals.loc[sample_signals['signal'] == 1, 'reason'] = "Long 청산 과잉"
sample_signals.loc[sample_signals['signal'] == -1, 'reason'] = "Short 청산 과잉"
# 백테스트 실행
results = backtester.run_backtest(
sample_signals,
take_profit_pct=0.03,
stop_loss_pct=0.015
)
# 결과 출력
print("=" * 50)
print(" 백테스트 최종 결과")
print("=" * 50)
print(f"초기 자본금: ${results['initial_capital']:,.2f}")
print(f"최종 자본금: ${results['final_capital']:,.2f}")
print(f"총 수익률: {results['total_return_pct']:.2f}%")
print(f"총 거래 횟수: {results['total_trades']}")
print(f"승률: {results['win_rate']:.1f}%")
print(f"평균 승리: {results['avg_win_pct']:.2f}%")
print(f"평균 패배: {results['avg_loss_pct']:.2f}%")
print(f"Profit Factor: {results['profit_factor']:.2f}")
print(f"최대 낙폭: {results['max_drawdown_pct']:.2f}%")
print(f"Sharpe Ratio: {results['sharpe_ratio']:.2f}")
print("=" * 50)
# 결과 시각화
backtester.plot_results('liquidation_backtest_results.png')가격과 ROI
| 서비스 | DeepSeek V3.2 | GPT-4.1 | Claude Sonnet 4.5 | Gemini
관련 리소스관련 문서 |
|---|