취업하고싶어요

11주차 TIL - 전략을 개선 해보자

게임취업하고싶은 사람 — Fri, 18 Apr 2025 20:41:44 +0900

✅ 추가 가능한 전략적 개선 제안

1. 포트폴리오 최적화 (Multi-symbol 배분 전략)

현재는 각 종목에 동일 자산 배분
→ 예측 정확도, 변동성, 샤프 지수 기반으로 자산 비율 가중치 설정
예시:
python

복사편집

asset_weight = normalize(accuracy * sharpe / volatility)

2. 드로우다운 제한 청산 (Dynamic Stop)

MDD가 특정 % 초과시 전 포지션 청산
자산 보존 우선 전략
예시:
python

복사편집

if current_drawdown > max_allowed_dd: 청산

3. 모델 리트레이닝 또는 슬라이딩 윈도우

현 구조는 과거 전체로 학습
→ 최근 60~120일 기준 슬라이딩 학습으로 적응력 향상
예시:
python

복사편집

for i in range(window, len(df)): train_ensemble(df.iloc[i-window:i])

4. 시간 필터링 (요일/시간 기반 무역 제한)

Crypto는 주말에도 변동성이 심함
→ 일요일 제외, 혹은 특정 시간대만 진입
예시:
python

복사편집

df['hour'] = df.index.hour if not (hour in trade_hours): continue

5. 추가 피처 엔지니어링

현재는 이동평균/RSI/Volatility 정도
→ MACD, %K, %D (Stochastic), CCI, OBV 등 기술지표 추가
또는:
- 이동평균 기울기
- 최근 고점/저점 돌파
- 평균 거래량 대비 급등락 감지

6. 트레이딩 룰 강화: 전략 혼합

Rule-based + ML 기반 신호를 혼합 (예: 둘 다 만족할 때만 진입)
예시:
python

복사편집

if alpha[i] > 0.6 and signal[i] == 1: 진입

7. 수익실현 전략 (TP 조건 도입)

현재는 예측 변화 or 손절로만 포지션 종료
→ 목표 수익률 도달 시 분할청산 전략 추가

8. 강화학습 기반 의사결정 (심화)

stable-baselines3 등 라이브러리를 이용해
포지션 비율, 진입 타이밍을 학습하는 방법으로 확장 가능

적용 순서 추천

포트폴리오 자산 비중 최적화
MACD, CCI 등 추가 기술지표
슬라이딩 윈도우 기반 재학습
요일/시간대 진입 제한
드로우다운 기준 청산
수익실현 TP 도입

11주차 TIL - 반복되는 학습

게임취업하고싶은 사람 — Thu, 17 Apr 2025 20:55:56 +0900

# auto_trading_system/main.py (리디자인: 조건 완화 및 손실 제어 포함)

import ccxt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import font_manager, rc
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
from sklearn.ensemble import RandomForestClassifier
from lightgbm import LGBMClassifier
import traceback
import warnings

warnings.filterwarnings('ignore')

font_path = "c:/Windows/Fonts/malgun.ttf"
font_name = font_manager.FontProperties(fname=font_path).get_name()
rc('font', family=font_name)

symbols = ["BTC/USDT", "ETH/USDT", "XRP/USDT"]
timeframe = '1d'
limit = 500
initial_cash = 10000000
fee = 0.001
risk_free_rate = 0.01
stop_loss_pct = 0.07  # 7% 손절
lookback_window = 100
min_accuracy_threshold = 0.55

exchange = ccxt.binance()

def get_strategy_config(symbol):
    if symbol == "XRP/USDT":
        return {'use_predictive': False, 'label_thresh': 0.02, 'vol_limit': 0.04}
    elif symbol == "ETH/USDT":
        return {'use_predictive': True, 'label_thresh': 0.015, 'vol_limit': 0.05}  # 조건 완화
    else:
        return {'use_predictive': True, 'label_thresh': 0.01, 'vol_limit': 0.03}

def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df.set_index('timestamp', inplace=True)
    return df

def generate_indicators(df):
    df['ma20'] = df['close'].rolling(20).mean()
    df['ma60'] = df['close'].rolling(60).mean()
    df['rsi'] = compute_rsi(df['close'], 14)
    df['volatility'] = df['close'].pct_change().rolling(14).std()
    df['range_ratio'] = (df['high'] - df['low']) / df['open']
    df['body_ratio'] = abs(df['close'] - df['open']) / df['open']
    df['ma_gap'] = df['ma20'] - df['ma60']
    df['trend_up'] = df['ma20'] > df['ma60']
    df.dropna(inplace=True)
    return df

def compute_rsi(series, period):
    delta = series.diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    rs = avg_gain / avg_loss
    return 100 - (100 / (1 + rs))

def rule_based_filter(df):
    df['signal'] = 0
    df.loc[(df['ma20'] > df['ma60']) & (df['rsi'] < 30), 'signal'] = 1
    df.loc[(df['ma20'] < df['ma60']) & (df['rsi'] > 70), 'signal'] = -1
    return df

def generate_target(df, thresh):
    future_max = df['close'].shift(-1).rolling(window=3).max()
    df['target'] = np.where(future_max > df['close'] * (1 + thresh), 1, 0)
    return df

def train_ensemble(df):
    df = df.copy().iloc[-lookback_window:]
    features = ['ma20', 'ma60', 'rsi', 'volatility', 'range_ratio', 'body_ratio', 'ma_gap']
    X = df[features]
    y = df['target']
    X_train, X_test, y_train, y_test = train_test_split(X, y, shuffle=False, test_size=0.2)
    models = [
        XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
        RandomForestClassifier(n_estimators=100),
        LGBMClassifier(min_gain_to_split=0, min_data_in_leaf=1, verbose=-1)
    ]
    preds = []
    for model in models:
        model.fit(X_train, y_train)
        preds.append(model.predict_proba(X)[:, 1])
    alpha = np.mean(preds, axis=0)
    acc = accuracy_score(y_test, (alpha[-len(y_test):] > 0.5).astype(int))
    print(f"[정확도] {acc:.2f}")
    return alpha if acc >= min_accuracy_threshold else None

def run_backtest(df, alpha, use_predictive, vol_limit):
    asset = initial_cash
    coin = 0
    entry_price = 0
    trades = 0
    asset_curve = []
    daily_returns = []

    for i in range(1, len(df)):
        price = df['close'].iloc[i]
        trend_up = df['trend_up'].iloc[i]
        signal = df['signal'].iloc[i]
        a = alpha[i] if not np.isnan(alpha[i]) else 0.5
        vol = df['volatility'].iloc[i]

        allow_trade = False
        position_ratio = 0

        if use_predictive and vol < vol_limit and (a > 0.6 or a < 0.4):
            position_ratio = min(max(abs(a - 0.5) * 2, 0.2), 0.8)
            allow_trade = True
        elif not use_predictive and signal == 1:
            position_ratio = 0.5
            allow_trade = True

        if allow_trade and coin == 0:
            invest = asset * position_ratio * (1 - fee)
            coin = invest / price
            asset -= invest
            entry_price = price
            trades += 1

        if coin > 0 and price < entry_price * (1 - stop_loss_pct):
            asset += coin * price * (1 - fee)
            coin = 0
            trades += 1

        if coin > 0 and ((use_predictive and a < 0.4) or (not use_predictive and signal == -1)):
            asset += coin * price * (1 - fee)
            coin = 0
            trades += 1

        total_value = asset + coin * price
        asset_curve.append(total_value)
        if i > 1:
            ret = (asset_curve[-1] - asset_curve[-2]) / asset_curve[-2]
            daily_returns.append(ret)

    final = asset + coin * df['close'].iloc[-1]
    sharpe = (np.mean(daily_returns) - risk_free_rate / 365) / (np.std(daily_returns) + 1e-6) * np.sqrt(365)
    mdd = np.max(np.maximum.accumulate(asset_curve) - asset_curve)
    df['asset_curve'] = pd.Series(asset_curve, index=df.index[-len(asset_curve):])

    return df, {
        '최종 자산': final,
        '수익률': (final - initial_cash) / initial_cash * 100,
        '거래 횟수': trades,
        'Sharpe': sharpe,
        'MDD': mdd
    }

def plot_results(df, stats, symbol):
    plt.figure(figsize=(14, 6))
    plt.subplot(2, 1, 1)
    plt.plot(df['close'], label='Close')
    plt.plot(df['ma20'], label='MA20')
    plt.plot(df['ma60'], label='MA60')
    plt.title(f"{symbol} 가격 및 지표")
    plt.legend()
    plt.grid()

    plt.subplot(2, 1, 2)
    plt.plot(df['asset_curve'], label='자산곡선', color='green')
    plt.title(f"{symbol} 수익곡선 / 최종: {int(stats['최종 자산'])}원 | 수익률: {stats['수익률']:.2f}% | 거래: {stats['거래 횟수']}회 | Sharpe: {stats['Sharpe']:.2f} | MDD: {stats['MDD']:.2f}")
    plt.legend()
    plt.grid()
    plt.tight_layout()
    plt.savefig(f"{symbol.replace('/', '_')}_result.png")
    plt.show()

if __name__ == '__main__':
    for symbol in symbols:
        try:
            print(f"[진행] {symbol} 시작")
            cfg = get_strategy_config(symbol)
            df = fetch_ohlcv(symbol)
            df = generate_indicators(df)
            df = rule_based_filter(df)
            df = generate_target(df, cfg['label_thresh'])
            alpha = train_ensemble(df)
            if alpha is None:
                print(f"[중단] {symbol}: 모델 성능 미달")
                continue

            alpha = np.concatenate([np.full(len(df) - len(alpha), np.nan), alpha])

            df, stats = run_backtest(df, alpha, cfg['use_predictive'], cfg['vol_limit'])
            plot_results(df, stats, symbol)

        except Exception as e:
            traceback.print_exc()
            print(f"[오류] {symbol}: {str(e)}")

    print("[완료] 모든 종목 처리 종료")

11주차 TIL - 개선 또 개선

게임취업하고싶은 사람 — Wed, 16 Apr 2025 22:31:38 +0900

✅ 1. BTC/USDT

최종 자산: 10,304,720원
수익률: +3.05%
Sharpe: 0.26 (양호한 편)
MDD: 429,808원
거래 횟수: 34회

해석:
보수적이지만 실현 가능한 성과.
추세 구간에서 진입해 상승분을 적절히 취한 흔적이 보임.
변동성이 낮은 시기에 거래를 자제한 것도 좋은 전략.

✅ 2. ETH/USDT

최종 자산: 10,000,000원
수익률: 0.00%
Sharpe: -523.42 (거래가 없었기 때문에 왜곡된 수치)
MDD: 0.00
거래 횟수: 0회

해석:
예측 신호가 미약하거나 조건 충족이 없었음.
시장 추세 인식 조건이 너무 보수적일 가능성 있음.
→ 진입 기준 완화나 시장 필터 조정 고려 필요.

✅ 3. XRP/USDT

최종 자산: 8,988,370원
수익률: -10.12%
Sharpe: -0.13
MDD: 3,489,943원
거래 횟수: 8회

해석:
루즈한 진입 또는 진입 후 반등 실패로 손절 발생.
상승 시기 후반에 진입한 흔적이 보이며, 하락장에서 손실 확대.
→ 리스크 제어 조건 보강, 진입 타이밍 조정, 과매수 방지 룰 필요.

전략 통합 평가

종목수익률거래 수Sharpe위험관리

BTC/USDT	✅ 양호	안정적	+0.26	적절함
ETH/USDT	⛔ 없음	없음	N/A	지나치게 보수적
XRP/USDT	❌ 손실	적음	-0.13	❗ 리스크 확대 우려

제안할 다음 개선 포인트

ETH/USDT의 진입조건 완화
- trend_up + vol 조건 너무 강할 수 있음
- 예측 점수 기준만으로 진입해보는 실험 추천
XRP/USDT 손실 관리 강화
- 예측 신뢰도 낮을 때 진입 금지
- 볼린저밴드 + RSI 기반 과매수 회피 필터 도입
공통
- MDD 기반 조건부 전량 청산 전략
- 전체 자산의 5~20%만 진입하는 분산 진입 전략

11주차 TIL - 수익은 개선 되었느니라~

게임취업하고싶은 사람 — Tue, 15 Apr 2025 20:58:34 +0900

이번 결과는 전략 리디자인(예측 확률 기반 포지션 사이징 + 시장 추세 조건 + 진입 확률 필터 + 라벨 완화)을 적용한 후 수익성과 안정성 면에서 전반적인 도약을 보여줬어. 아래에 종목별로 상세 해설할게.

✅ BTC/USDT 분석

항목결과

최종 자산	11,698,147원
수익률	+16.98%
거래 수	118회
Sharpe	0.54
MDD	296만 원

해설

진입 횟수가 대폭 증가(118회) → 라벨 완화 + 확률 조건 완화의 영향
하단 수익곡선에서 꾸준한 수익성과 회복 탄력성 확인 가능
Sharpe 지수가 0.5를 넘으며 위험 대비 보상 우수

✅ ETH/USDT 분석

항목결과

최종 자산	14,382,651원
수익률	+43.83%
거래 수	104회
Sharpe	1.17 (우수)
MDD	264만 원

해설

수익곡선이 중후반부에 급등하며 우상향 안정적 수익 구조 형성
Sharpe > 1.0 → 전문가 전략 수준의 수익/위험 균형
가장 이상적인 결과 (전략 전환 + 포지션 조절 + 진입확률 필터의 총합 효과)

❌ XRP/USDT 분석

항목결과

최종 자산	6,161,369원
수익률	-38.39%
거래 수	12회
Sharpe	-0.71
MDD	585만 원

해설

거래 수 12회 → 여전히 예측력이 낮고 진입 기준 충족이 어려운 구조
초반 수익 후 지속적인 하락 → 모델의 학습/예측 한계
XRP는 기술적 노이즈가 많거나 예측 모델과 궁합이 맞지 않는 종목일 가능성

✅ 종합 비교 표

종목수익률Sharpe거래 수MDD전략 평가

BTC	+16.98%	0.54	118	296만	안정적 수익 구조 형성
ETH	+43.83%	1.17	104	264만	가장 이상적인 전략 적용
XRP	-38.39%	-0.71	12	585만	학습 성능 및 전략 미흡

11주차 TIL - 그래도 갈길이 멀다

게임취업하고싶은 사람 — Mon, 14 Apr 2025 20:38:25 +0900

# auto_trading_system/main.py (종목별 전략 최적화 + 앙상블 모델 + 실시간 대응 구조)

import ccxt
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import font_manager, rc
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from xgboost import XGBClassifier
from sklearn.ensemble import RandomForestClassifier
from lightgbm import LGBMClassifier
import warnings
from tqdm import tqdm

warnings.filterwarnings('ignore')

# 폰트 설정
font_path = "c:/Windows/Fonts/malgun.ttf"
font_name = font_manager.FontProperties(fname=font_path).get_name()
rc('font', family=font_name)

# 설정값
symbols = ["BTC/USDT", "ETH/USDT", "XRP/USDT"]
exchange = ccxt.binance()
timeframe = '1d'
limit = 500
initial_cash = 10000000
fee = 0.001
risk_free_rate = 0.01
stop_loss_pct = 0.1
min_accuracy_threshold = 0.55
lookback_window = 100

# 종목별 전략 설정
def get_strategy_config(symbol):
    if symbol == "XRP/USDT":
        return {'use_predictive': False, 'label_thresh': 0.02}
    elif symbol == "ETH/USDT":
        return {'use_predictive': True, 'label_thresh': 0.015}
    else:
        return {'use_predictive': True, 'label_thresh': 0.01}

# 데이터 수집
def fetch_ohlcv(symbol):
    ohlcv = exchange.fetch_ohlcv(symbol, timeframe=timeframe, limit=limit)
    df = pd.DataFrame(ohlcv, columns=['timestamp', 'open', 'high', 'low', 'close', 'volume'])
    df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms')
    df.set_index('timestamp', inplace=True)
    return df

# 지표 생성
def generate_indicators(df):
    df['ma20'] = df['close'].rolling(20).mean()
    df['ma60'] = df['close'].rolling(60).mean()
    df['rsi'] = compute_rsi(df['close'], 14)
    df['volatility'] = df['close'].pct_change().rolling(14).std()
    df['range_ratio'] = (df['high'] - df['low']) / df['open']
    df['body_ratio'] = abs(df['close'] - df['open']) / df['open']
    df['ma_gap'] = df['ma20'] - df['ma60']
    df['trend_up'] = df['ma20'] > df['ma60']
    df.dropna(inplace=True)
    return df

def compute_rsi(series, period):
    delta = series.diff()
    gain = delta.where(delta > 0, 0)
    loss = -delta.where(delta < 0, 0)
    avg_gain = gain.rolling(window=period).mean()
    avg_loss = loss.rolling(window=period).mean()
    rs = avg_gain / avg_loss
    return 100 - (100 / (1 + rs))

# 룰 기반 필터
def rule_based_filter(df):
    df['signal'] = 0
    df.loc[(df['ma20'] > df['ma60']) & (df['rsi'] < 30), 'signal'] = 1
    df.loc[(df['ma20'] < df['ma60']) & (df['rsi'] > 70), 'signal'] = -1
    return df

# 라벨링
def generate_target(df, thresh):
    future_max = df['close'].shift(-1).rolling(window=3).max()
    df['target'] = np.where(future_max > df['close'] * (1 + thresh), 1, 0)
    return df

# 앙상블 모델 학습 (XGB + RF + LGBM 평균)
def train_ensemble(df):
    df = df.copy().iloc[-lookback_window:]
    features = ['ma20', 'ma60', 'rsi', 'volatility', 'range_ratio', 'body_ratio', 'ma_gap']
    X = df[features]
    y = df['target']
    X_train, X_test, y_train, y_test = train_test_split(X, y, shuffle=False, test_size=0.2)

    models = [
        XGBClassifier(use_label_encoder=False, eval_metric='logloss'),
        RandomForestClassifier(n_estimators=100),
        LGBMClassifier()
    ]
    preds = []
    for model in models:
        model.fit(X_train, y_train)
        preds.append(model.predict_proba(X)[:, 1])
    alpha = np.mean(preds, axis=0)
    acc = accuracy_score(y_test, (alpha[-len(y_test):] > 0.5).astype(int))
    print(f"[정확도] {acc:.2f}")
    return alpha if acc >= min_accuracy_threshold else None

# 백테스트
def run_backtest(df, alpha, use_predictive):
    asset = initial_cash
    coin = 0
    entry_price = 0
    trades = 0
    asset_curve = []
    daily_returns = []

    for i in range(1, len(df)):
        price = df['close'].iloc[i]
        trend_up = df['trend_up'].iloc[i]
        signal = df['signal'].iloc[i]
        a = alpha[i]
        vol = df['volatility'].iloc[i]

        allow_trade = False
        position_ratio = 0

        if use_predictive and trend_up and vol < 0.03 and (a > 0.6 or a < 0.4):
            position_ratio = min(max(a, 0.4), 0.9)
            allow_trade = True
        elif not use_predictive and signal == 1:
            position_ratio = 0.5
            allow_trade = True

        if allow_trade and coin == 0:
            invest = asset * position_ratio * (1 - fee)
            coin = invest / price
            asset -= invest
            entry_price = price
            trades += 1

        if coin > 0 and price < entry_price * (1 - stop_loss_pct):
            asset += coin * price * (1 - fee)
            coin = 0
            trades += 1

        if coin > 0 and ((use_predictive and a < 0.4) or (not use_predictive and signal == -1)):
            asset += coin * price * (1 - fee)
            coin = 0
            trades += 1

        total_value = asset + coin * price
        asset_curve.append(total_value)
        if i > 1:
            ret = (asset_curve[-1] - asset_curve[-2]) / asset_curve[-2]
            daily_returns.append(ret)

    final = asset + coin * df['close'].iloc[-1]
    sharpe = (np.mean(daily_returns) - risk_free_rate / 365) / (np.std(daily_returns) + 1e-6) * np.sqrt(365)
    mdd = np.max(np.maximum.accumulate(asset_curve) - asset_curve)
    df['asset_curve'] = pd.Series(asset_curve, index=df.index[-len(asset_curve):])

    return df, {
        '최종 자산': final,
        '수익률': (final - initial_cash) / initial_cash * 100,
        '거래 횟수': trades,
        'Sharpe': sharpe,
        'MDD': mdd
    }

# 시각화
def plot_results(df, stats, symbol):
    plt.figure(figsize=(14, 6))
    plt.subplot(2, 1, 1)
    plt.plot(df['close'], label='Close')
    plt.plot(df['ma20'], label='MA20')
    plt.plot(df['ma60'], label='MA60')
    plt.title(f"{symbol} 가격 및 지표")
    plt.legend()
    plt.grid()

    plt.subplot(2, 1, 2)
    plt.plot(df['asset_curve'], label='자산곡선', color='green')
    plt.title(f"{symbol} 수익곡선 / 최종: {int(stats['최종 자산'])}원 | 수익률: {stats['수익률']:.2f}% | 거래: {stats['거래 횟수']}회 | Sharpe: {stats['Sharpe']:.2f} | MDD: {stats['MDD']:.2f}")
    plt.legend()
    plt.grid()
    plt.tight_layout()
    plt.show()

# 실행
if __name__ == '__main__':
    for symbol in symbols:
        try:
            print(f"[진행] {symbol} 시작")
            cfg = get_strategy_config(symbol)
            df = fetch_ohlcv(symbol)
            df = generate_indicators(df)
            df = rule_based_filter(df)
            df = generate_target(df, cfg['label_thresh'])
            alpha = train_ensemble(df)
            if alpha is None:
                print(f"[중단] {symbol}: 모델 성능 미달")
                continue
            df, stats = run_backtest(df, alpha, cfg['use_predictive'])
            plot_results(df, stats, symbol)
        except Exception as e:
            print(f"[오류] {symbol}: {str(e)}")

    print("[완료] 모든 종목 처리 종료")

10주차 TIL - 진짜 자동매매가 작동할까?

게임취업하고싶은 사람 — Fri, 11 Apr 2025 19:09:42 +0900

✅ BTC/USDT 분석

항목결과

최종 자산	11,698,147원
수익률	+16.98%
거래 수	118회
Sharpe	0.54
MDD	296만 원

해설

진입 횟수가 대폭 증가(118회) → 라벨 완화 + 확률 조건 완화의 영향
하단 수익곡선에서 꾸준한 수익성과 회복 탄력성 확인 가능
Sharpe 지수가 0.5를 넘으며 위험 대비 보상 우수

✅ ETH/USDT 분석

항목결과

최종 자산	14,382,651원
수익률	+43.83%
거래 수	104회
Sharpe	1.17 (우수)
MDD	264만 원

해설

수익곡선이 중후반부에 급등하며 우상향 안정적 수익 구조 형성
Sharpe > 1.0 → 전문가 전략 수준의 수익/위험 균형
가장 이상적인 결과 (전략 전환 + 포지션 조절 + 진입확률 필터의 총합 효과)

❌ XRP/USDT 분석

항목결과

최종 자산	6,161,369원
수익률	-38.39%
거래 수	12회
Sharpe	-0.71
MDD	585만 원

해설

거래 수 12회 → 여전히 예측력이 낮고 진입 기준 충족이 어려운 구조
초반 수익 후 지속적인 하락 → 모델의 학습/예측 한계
XRP는 기술적 노이즈가 많거나 예측 모델과 궁합이 맞지 않는 종목일 가능성

✅ 종합 비교 표

종목수익률Sharpe거래 수MDD전략 평가

BTC	+16.98%	0.54	118	296만	안정적 수익 구조 형성
ETH	+43.83%	1.17	104	264만	가장 이상적인 전략 적용
XRP	-38.39%	-0.71	12	585만	학습 성능 및 전략 미흡

핵심 결론

✅ 전체 전략 리디자인 효과는 매우 긍정적
✅ 예측 확률 기반 포지션 조절 + 추세 기반 전략 전환 + 진입 필터링 = 고성능 자동매매 시스템 완성
❌ XRP는 데이터 구조 또는 시장 특성상 예측 기반 전략에 부적합 → 향후 룰 기반 or 제외 고려

10주차 TIL - 전략 수정

게임취업하고싶은 사람 — Thu, 10 Apr 2025 20:48:50 +0900

바이낸스 데이터를 활용한 Python 기반 자동매매 프로그램 개발과 백테스팅 시스템 구축에 대해 도와드리겠습니다.

추천할 만한 매매 전략으로는 다음과 같은 것들이 있습니다:

이동평균선 교차(Moving Average Crossover): 단기 이동평균선이 장기 이동평균선을 상향 돌파할 때 매수, 하향 돌파할 때 매도하는 전략입니다. 비교적 구현이 쉽고 트렌드 추종에 효과적입니다.
RSI(상대강도지수) 기반 전략: RSI가 30 이하로 떨어질 때 매수, 70 이상 올라갈 때 매도하는 과매수/과매도 지표를 활용합니다.
볼린저 밴드 전략: 가격이 하단밴드 아래로 떨어질 때 매수, 상단밴드 위로 올라갈 때 매도하는 전략입니다.
MACD 교차 전략: MACD 라인이 시그널 라인을 상향 돌파할 때 매수, 하향 돌파할 때 매도합니다.

바이낸스 라이브러리를 사용하는 방법의 장점은:

공식 지원: 바이낸스에서 직접 관리하는 라이브러리이므로 API 변경 시 업데이트가 빠릅니다.
다양한 기능: 시장 데이터 조회, 주문 생성/취소, 계정 잔액 확인 등 거의 모든 바이낸스 기능을 사용할 수 있습니다.
WebSocket 지원: 실시간 시장 데이터를 WebSocket을 통해 효율적으로 받을 수 있습니다.
안정성: 많은 사용자가 검증한 라이브러리입니다.

실시간 자동매매 시스템을 구현하려면 WebSocket을 활용한 방식을 추천합니다. 이를 통해 실시간으로 시장 변화를 감지하고 매매 신호를 포착할 수 있습니다. 백테스팅 시스템을 확장해서 실시간 트레이딩 시스템으로 만들 때 바이낸스 라이브러리의 WebSocket 기능이 특히 유용합니다.

바이낸스의 WebSocket API를 활용한 실시간 자동매매 시스템입니다. 주요 기능과 사용법을 설명해드리겠습니다:

주요 기능

실시간 가격 데이터 수신: WebSocket을 통해 실시간으로 캔들 데이터를 수신합니다.
다양한 매매 전략: 이동평균선, RSI, 볼린저 밴드, MACD 등 다양한 전략을 선택할 수 있습니다.
테스트 모드: 실제 주문 없이 전략을 테스트할 수 있습니다.
자동 재연결: WebSocket 연결이 끊어지면 자동으로 재연결을 시도합니다.

바이낸스 API 키와 시크릿 없이도 자동매매 시스템을 개발하고 테스트할 수 있는 몇 가지 방법이 있습니다:

공개 데이터 API 사용: 바이낸스는 시장 데이터를 가져오는 공개 API를 제공합니다. 이는 인증이 필요 없으며 시장 데이터를 실시간으로 가져올 수 있습니다. 단, 실제 주문은 불가능합니다.
바이낸스 테스트넷 사용: 바이낸스는 테스트 목적으로 테스트넷을 제공합니다. 여기서 API 키를 얻어 실제 돈을 사용하지 않고 거래를 테스트할 수 있습니다.
과거 데이터 기반 시뮬레이션: 과거 데이터를 다운로드하여 시뮬레이션을 실행할 수 있습니다.

import websocket
import json
import pandas as pd
import numpy as np
import threading
import time
from datetime import datetime

class BinanceDataCollector:
    def __init__(self, symbol='btcusdt', interval='1m'):
        self.symbol = symbol.lower()
        self.interval = interval
        self.ws = None
        self.closes = []
        self.highs = []
        self.lows = []
        self.volumes = []
        self.timestamps = []
        self.df = pd.DataFrame()
        self.max_candles = 300
        self.socket_running = False

    def on_message(self, ws, message):
        msg = json.loads(message)
        self.process_candle(msg)

    def on_error(self, ws, error):
        print(f"WebSocket 오류: {error}")

    def on_close(self, ws, close_status_code, close_msg):
        print("WebSocket 연결이 종료되었습니다.")
        self.socket_running = False

    def on_open(self, ws):
        print("WebSocket 연결이 시작되었습니다.")
        self.socket_running = True

    def process_candle(self, msg):
        """실시간 캔들 데이터 처리"""
        try:
            candle = msg['k']
            is_candle_closed = candle['x']

            if is_candle_closed:
                timestamp = datetime.fromtimestamp(candle['t']/1000)
                close = float(candle['c'])
                high = float(candle['h'])
                low = float(candle['l'])
                volume = float(candle['v'])

                print(f"캔들 종료: {timestamp} | 종가: {close}")

                # 데이터 추가
                self.timestamps.append(timestamp)
                self.closes.append(close)
                self.highs.append(high)
                self.lows.append(low)
                self.volumes.append(volume)

                # 최대 캔들 수 유지
                if len(self.closes) > self.max_candles:
                    self.timestamps.pop(0)
                    self.closes.pop(0)
                    self.highs.pop(0)
                    self.lows.pop(0)
                    self.volumes.pop(0)

                # 데이터프레임 업데이트
                self.update_dataframe()
                self.analyze_data()

        except Exception as e:
            print(f"데이터 처리 중 오류 발생: {e}")

    def update_dataframe(self):
        """데이터프레임 업데이트"""
        self.df = pd.DataFrame({
            'timestamp': self.timestamps,
            'close': self.closes,
            'high': self.highs,
            'low': self.lows,
            'volume': self.volumes
        })
        self.df.set_index('timestamp', inplace=True)

        # 기술적 지표 추가
        if len(self.df) > 50:
            # 이동평균선
            self.df['sma_20'] = self.df['close'].rolling(window=20).mean()
            self.df['sma_50'] = self.df['close'].rolling(window=50).mean()

            # RSI
            delta = self.df['close'].diff()
            gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
            loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
            rs = gain / loss
            self.df['rsi'] = 100 - (100 / (1 + rs))

            # MACD
            self.df['ema_12'] = self.df['close'].ewm(span=12, adjust=False).mean()
            self.df['ema_26'] = self.df['close'].ewm(span=26, adjust=False).mean()
            self.df['macd'] = self.df['ema_12'] - self.df['ema_26']
            self.df['signal'] = self.df['macd'].ewm(span=9, adjust=False).mean()

    def analyze_data(self):
        """데이터 분석 및 매매 신호 감지"""
        if len(self.df) < 2:
            return

        last_row = self.df.iloc[-1]
        prev_row = self.df.iloc[-2]

        # 여기에 매매 신호 분석 로직 추가
        # 예: 이동평균선 교차 전략
        if 'sma_20' in last_row and 'sma_50' in last_row:
            if (prev_row['sma_20'] <= prev_row['sma_50']) and (last_row['sma_20'] > last_row['sma_50']):
                print("매수 신호: 이동평균선 골든 크로스")
            elif (prev_row['sma_20'] >= prev_row['sma_50']) and (last_row['sma_20'] < last_row['sma_50']):
                print("매도 신호: 이동평균선 데드 크로스")

        # RSI 기반 전략
        if 'rsi' in last_row:
            if last_row['rsi'] < 30:
                print(f"과매도 구간 (RSI: {last_row['rsi']:.2f})")
            elif last_row['rsi'] > 70:
                print(f"과매수 구간 (RSI: {last_row['rsi']:.2f})")

        # MACD 기반 전략
        if 'macd' in last_row and 'signal' in last_row:
            if (prev_row['macd'] <= prev_row['signal']) and (last_row['macd'] > last_row['signal']):
                print("매수 신호: MACD 골든 크로스")
            elif (prev_row['macd'] >= prev_row['signal']) and (last_row['macd'] < last_row['signal']):
                print("매도 신호: MACD 데드 크로스")

    def start_collecting(self):
        """데이터 수집 시작"""
        # WebSocket 연결 설정
        socket_url = f"wss://streahttp://m.binance.com:9443/ws/{self.symbol}@kline_{self.interval}"
        websocket.enableTrace(False)
        self.ws = websocket.WebSocketApp(
            socket_url,
            on_message=self.on_message,
            on_error=self.on_error,
            on_close=self.on_close,
            on_open=self.on_open
        )

        print(f"\n===== 데이터 수집 시작 =====")
        print(f"심볼: {self.symbol}")
        print(f"간격: {self.interval}")
        print("========================\n")

        # WebSocket 실행 (별도 스레드)
        wst = threading.Thread(target=self.ws.run_forever)
        wst.daemon = True
        wst.start()

        # 메인 스레드에서는 간단한 상태 확인
        print("실시간 데이터 수집 시작 (종료하려면 Ctrl+C)")
        try:
            while True:
                if not self.socket_running:
                    print("WebSocket 연결이 종료되었습니다. 재연결 시도 중...")
                    wst = threading.Thread(target=self.ws.run_forever)
                    wst.daemon = True
                    wst.start()
                time.sleep(5)
        except KeyboardInterrupt:
            print("사용자에 의해 프로그램이 종료되었습니다.")
            self.ws.close()

        print("데이터 수집 종료")

# 메인 실행 코드
if __name__ == "__main__":
    # 설정
    symbol = "btcusdt"  # 거래 심볼
    interval = "1m"     # 캔들 간격 (1m, 5m, 15m, 1h, 4h, 1d)

    # 데이터 수집기 초기화 및 시작
    collector = BinanceDataCollector(symbol=symbol, interval=interval)
    collector.start_collecting()

10주차 TIL - 지금까지 적용해본 모델

게임취업하고싶은 사람 — Wed, 9 Apr 2025 20:46:36 +0900

10주차 TIL - ARIMA X 라고?

게임취업하고싶은 사람 — Tue, 8 Apr 2025 20:53:41 +0900

✅ ARIMA-X란?

ARIMAX (AutoRegressive Integrated Moving Average with eXogenous variables)
기본 시계열 예측 모델 ARIMA에 외생변수(다른 변수)를 추가한 모델
예: close 가격을 예측하는데 volume, high, low 등을 외생변수로 추가

✅ 지금 구조 vs ARIMAX

항목현재 모델 (Transformer)ARIMAX

대상	회귀 + 분류 (복합)	회귀 (단일)
입력	다변량 시계열, 60개 step	단변량 + 외생 변수
예측 방식	딥러닝 기반 패턴 학습	통계적 선형 회귀 계열
장점	비선형 복잡한 패턴 대응 가능	해석력, 빠른 학습
단점	많은 데이터 필요, 느림	성능 한계, 비선형 처리 어려움

✅ ARIMAX를 쓰려면 적합한 경우

목표가 단순 단일 변수 예측 (예: 가격)
데이터 수가 적고 모델 해석이 중요한 경우
트레이딩 신호보단 예측 정확도 중심의 분석일 때

✅ 지금 프로젝트와의 궁합

현재 목표는 하이브리드 예측 (변동률 + 급등/급락 분류)
분류는 ARIMA-X로는 불가능
회귀도 ARIMA-X는 단기 예측엔 약하고, 변동률 예측 성능이 제한됨

✅ 요약

질문답변

ARIMA-X 사용 가능한가?	가능함
지금 구조와 잘 맞나?	잘 맞진 않음 (분류 불가, 패턴 한계)
언제 사용 추천?	단기 단일 회귀 분석 + 해석 중요할 때

10주차 TIL - 모델 모델 모델!

게임취업하고싶은 사람 — Mon, 7 Apr 2025 21:01:36 +0900

지금 모델은 기본적인 구조를 잘 갖췄지만, 실전 예측 성능을 높이려면 아래와 같은 개선 포인트들을 고려해보는 게 좋아.
이건 실제 트레이딩 시나 하이브리드 시계열 모델에서 검증된 방식

✅ 1. 데이터 전처리 개선

Log return 사용
log(close_t / close_t-1)은 일반적인 return보다 더 안정적이고 정규분포에 가까워짐
피처 정규화
volume, price 등은 MinMaxScaler 또는 StandardScaler로 정규화하고 학습에 사용
→ 각 피처의 크기 차이를 줄여 학습 안정화 가능

✅ 2. 라벨 구조 개선 (클래스 불균형 완화)

급등/급락 비율이 너무 적으면 분류 모델이 "보통"만 예측하려 함
라벨을 5분봉 대신 30분봉 등으로 바꾸면 급등/급락 빈도가 증가해 불균형이 완화됨
또는 focal loss나 class weight를 적용해 학습 밸런싱 가능

✅ 3. 모델 구조 개선

Conv1D + Transformer 조합
Conv로 로컬 패턴을 먼저 잡고, Transformer로 시계열 전체 문맥 이해
LayerNormalization 위치 조정 (Pre-Norm vs Post-Norm)
안정성 개선에 영향 있음
Dropout 추가 조정
오버피팅 방지 (특히 작은 데이터셋에서는 효과적)

✅ 4. Custom Metric / Loss

Custom classification F1-score metric: 정확도 외의 균형 지표 필요
하이브리드 risk-adjusted loss
급등/급락 예측 실패에 더 큰 패널티를 주는 방식 고려

✅ 5. 후처리 + 시각화 개선

예측값의 direction (상승/하락) 일치율 분석
→ 실제 가격 방향성과 모델 예측이 얼마나 맞는지 확인
예측 변동률을 바탕으로 가상 수익률 계산 시뮬레이션

1	라벨 불균형 보정 (윈도우 길이, class weight 등)	분류 성능 크게 개선 가능
2	Conv1D + Transformer 구조	성능과 연산 효율 동시 확보
3	가상 수익률 분석	실전 적용 가능성 평가 가능

취업하고싶어요

11주차 TIL - 전략을 개선 해보자

✅ 추가 가능한 전략적 개선 제안

1. 포트폴리오 최적화 (Multi-symbol 배분 전략)

2. 드로우다운 제한 청산 (Dynamic Stop)

3. 모델 리트레이닝 또는 슬라이딩 윈도우

4. 시간 필터링 (요일/시간 기반 무역 제한)

5. 추가 피처 엔지니어링

6. 트레이딩 룰 강화: 전략 혼합

7. 수익실현 전략 (TP 조건 도입)

8. 강화학습 기반 의사결정 (심화)

적용 순서 추천

11주차 TIL - 반복되는 학습

11주차 TIL - 개선 또 개선

✅ 1. BTC/USDT

✅ 2. ETH/USDT

✅ 3. XRP/USDT

전략 통합 평가

제안할 다음 개선 포인트

11주차 TIL - 수익은 개선 되었느니라~

✅ BTC/USDT 분석

해설

✅ ETH/USDT 분석

해설

❌ XRP/USDT 분석

해설

✅ 종합 비교 표

11주차 TIL - 그래도 갈길이 멀다

10주차 TIL - 진짜 자동매매가 작동할까?

✅ BTC/USDT 분석

해설

✅ ETH/USDT 분석

해설

❌ XRP/USDT 분석

해설

✅ 종합 비교 표

핵심 결론

10주차 TIL - 전략 수정

주요 기능

10주차 TIL - 지금까지 적용해본 모델

10주차 TIL - ARIMA X 라고?

✅ ARIMA-X란?

✅ 지금 구조 vs ARIMAX

✅ ARIMAX를 쓰려면 적합한 경우

✅ 지금 프로젝트와의 궁합

✅ 요약

10주차 TIL - 모델 모델 모델!

✅ 1. 데이터 전처리 개선

✅ 2. 라벨 구조 개선 (클래스 불균형 완화)

✅ 3. 모델 구조 개선

✅ 4. Custom Metric / Loss

✅ 5. 후처리 + 시각화 개선

추천 우선순위 TOP 3