commit 9bbdc8d42bba4de93c4ca66c02f36c2b0fc3fc5e Author: crypto_predictor Date: Thu Jan 29 21:27:15 2026 +0800 Initial commit: BTC 1h prediction model (53.10% accuracy) ๐ŸŽฏ ้กน็›ฎๆˆๆžœ๏ผš - ๅ‡†็กฎ็Ž‡: 53.10% (2026ๅนดๆต‹่ฏ•้›†) - ไปปๅŠก็ฑปๅž‹: ไบŒๅˆ†็ฑป (้ข„ๆต‹ๆถจ/่ทŒ) - ็‰นๅพ: OHLCV + RSI + MACD (9ไธช็‰นๅพ) - ่ฎญ็ปƒๆ•ฐๆฎ: 2020-2025ๅนดBTCๅฐๆ—ถๆ•ฐๆฎ (52,351ๅบๅˆ—) - ๆต‹่ฏ•ๆ•ฐๆฎ: 2026ๅนด1-29ๆ—ฅ (484ๅบๅˆ—) ๐Ÿ“Š ๆ€ง่ƒฝๆŒ‡ๆ ‡๏ผš - ็ฒพ็กฎ็Ž‡: 51.79% - ๅฌๅ›ž็Ž‡: 49.36% - F1ๅˆ†ๆ•ฐ: 0.5054 - ้ข„ๆต‹ๅˆ†ๅธƒ: ้žๅธธๅนณ่กก (ๅๅทฎไป…-11ไธช) ๐Ÿ”ฌ ๅฎž้ชŒๅŽ†ๅฒ๏ผš - ๅฐ่ฏ•ไบ†5็งๆ–นๆกˆ (ๅ›žๅฝ’/ๅˆ†็ฑป, ไธๅŒๆ•ฐๆฎๅˆ’ๅˆ†) - ๅˆ†็ฑปไปปๅŠกไผ˜ไบŽๅ›žๅฝ’ไปปๅŠก (53.10% vs 49.5%) - ๅ…จ้‡่ฎญ็ปƒ้ฟๅ…ไบ†่ฟ‡ๆ‹Ÿๅˆ้—ฎ้ข˜ ๐Ÿ“ฆ ไธป่ฆๆจกๅž‹ๆ–‡ไปถ๏ผš - models/checkpoints/dlinear_classification_2026/ - best_model.pt (ๆœ€ไฝณๆจกๅž‹) - preprocessor.pkl (้ข„ๅค„็†ๅ™จ) - test_2026_results.json (ๆต‹่ฏ•็ป“ๆžœ) Co-Authored-By: Claude Sonnet 4.5 diff --git a/.claude/settings.local.json b/.claude/settings.local.json new file mode 100644 index 0000000..8140830 --- /dev/null +++ b/.claude/settings.local.json @@ -0,0 +1,10 @@ +{ + "permissions": { + "allow": [ + "Bash(/Users/xxz/miniforge3/bin/conda run:*)", + "Bash(tee:*)", + "Bash(python:*)", + "Bash(source:*)" + ] + } +} diff --git a/.env b/.env new file mode 100644 index 0000000..4f3f3dd --- /dev/null +++ b/.env @@ -0,0 +1,32 @@ +# Binance API (public data - no keys needed) +BINANCE_API_URL=https://api.binance.com + +# ไปฃ็†้…็ฝฎ (SOCKS5) +SOCKS5_PROXY=socks5://127.0.0.1:7890 +USE_PROXY=true + +# Data Configuration +DATA_CACHE_DIR=./data/cache +LOOKBACK_1H=168 # 1 week for 1h data +LOOKBACK_15M=672 # 1 week for 15m data +FORECAST_HORIZON=24 # Predict 24 periods ahead + +# Training Configuration +BATCH_SIZE=64 +LEARNING_RATE=0.001 +MAX_EPOCHS=100 +EARLY_STOPPING_PATIENCE=10 +TRAIN_SPLIT=0.7 +VAL_SPLIT=0.15 +TEST_SPLIT=0.15 + +# Model Paths +MODEL_DIR=./models/checkpoints +ONNX_DIR=./models/onnx + +# API Configuration +API_PORT=5000 +API_HOST=0.0.0.0 + +# Classification Threshold +PRICE_CHANGE_THRESHOLD=0.015 # 1.5% threshold for binary labels diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..4f3f3dd --- /dev/null +++ b/.env.example @@ -0,0 +1,32 @@ +# Binance API (public data - no keys needed) +BINANCE_API_URL=https://api.binance.com + +# ไปฃ็†้…็ฝฎ (SOCKS5) +SOCKS5_PROXY=socks5://127.0.0.1:7890 +USE_PROXY=true + +# Data Configuration +DATA_CACHE_DIR=./data/cache +LOOKBACK_1H=168 # 1 week for 1h data +LOOKBACK_15M=672 # 1 week for 15m data +FORECAST_HORIZON=24 # Predict 24 periods ahead + +# Training Configuration +BATCH_SIZE=64 +LEARNING_RATE=0.001 +MAX_EPOCHS=100 +EARLY_STOPPING_PATIENCE=10 +TRAIN_SPLIT=0.7 +VAL_SPLIT=0.15 +TEST_SPLIT=0.15 + +# Model Paths +MODEL_DIR=./models/checkpoints +ONNX_DIR=./models/onnx + +# API Configuration +API_PORT=5000 +API_HOST=0.0.0.0 + +# Classification Threshold +PRICE_CHANGE_THRESHOLD=0.015 # 1.5% threshold for binary labels diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..68edc16 --- /dev/null +++ b/.gitignore @@ -0,0 +1,40 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +venv/ +.venv/ +env/ +ENV/ + +# ๆ•ฐๆฎๅ’Œ็ผ“ๅญ˜ +data/cache/*.csv +*.db + +# ๆจกๅž‹ๆฃ€ๆŸฅ็‚น๏ผˆไฟ็•™ๆœ€ไฝณๆจกๅž‹๏ผŒๅฟฝ็•ฅ่ฎญ็ปƒ่ฟ‡็จ‹ๆ–‡ไปถ๏ผ‰ +models/checkpoints/*/epoch_*.pt +models/checkpoints/*/training_history.json + +# Jupyter +.ipynb_checkpoints +*.ipynb + +# IDE +.vscode/ +.idea/ +*.swp +*.swo + +# ็ณป็ปŸๆ–‡ไปถ +.DS_Store +Thumbs.db + +# ๆ—ฅๅฟ— +*.log +logs/ + +# ไธดๆ—ถๆ–‡ไปถ +*.tmp +.cache/ diff --git a/README.md b/README.md new file mode 100644 index 0000000..0f6d149 --- /dev/null +++ b/README.md @@ -0,0 +1,141 @@ +# Crypto Predictor + +ๅŸบไบŽๆทฑๅบฆๅญฆไน ็š„ๅŠ ๅฏ†่ดงๅธไปทๆ ผ้ข„ๆต‹็ณป็ปŸ๏ผŒไฝฟ็”จDLinearๆจกๅž‹้ข„ๆต‹BTCๆœชๆฅ1ๅฐๆ—ถๆถจ่ทŒๆ–นๅ‘ใ€‚ + +## ๐ŸŽฏ ้กน็›ฎๆฆ‚ๅ†ต + +**ๅฝ“ๅ‰ๆœ€ไฝณๆจกๅž‹ๆ€ง่ƒฝ**๏ผš +- **ๅ‡†็กฎ็Ž‡**: 53.10% โœ… (ๅœจ2026ๅนดๆต‹่ฏ•้›†ไธŠ) +- **ไปปๅŠก็ฑปๅž‹**: ไบŒๅˆ†็ฑป๏ผˆ้ข„ๆต‹ๆถจ/่ทŒ๏ผ‰ +- **็‰นๅพ**: OHLCV + RSI + MACD (9ไธช็‰นๅพ) +- **่ฎญ็ปƒๆ•ฐๆฎ**: 2020-2025ๅนดBTCๅฐๆ—ถๆ•ฐๆฎ๏ผˆ52,351ไธชๅบๅˆ—๏ผ‰ +- **ๆต‹่ฏ•ๆ•ฐๆฎ**: 2026ๅนด1-29ๆ—ฅ๏ผˆ484ไธชๅบๅˆ—๏ผ‰ + +## ๐Ÿ“Š ๆจกๅž‹ๆ€ง่ƒฝๆŒ‡ๆ ‡ + +``` +ๅ‡†็กฎ็Ž‡ (Accuracy): 53.10% +็ฒพ็กฎ็Ž‡ (Precision): 51.79% +ๅฌๅ›ž็Ž‡ (Recall): 49.36% +F1ๅˆ†ๆ•ฐ: 0.5054 + +ๆททๆท†็Ÿฉ้˜ต: + ้ข„ๆต‹ๆถจไธ”็œŸๆถจ: 116 (24.0%) + ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ: 141 (29.1%) + ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ: 108 (22.3%) + ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ: 119 (24.6%) + +้ข„ๆต‹ๅˆ†ๅธƒ: + ้ข„ๆต‹ไธŠๆถจ: 224 (46.3%) + ้ข„ๆต‹ไธ‹่ทŒ: 260 (53.7%) + ๅฎž้™…ไธŠๆถจ: 235 (48.6%) + ๅฎž้™…ไธ‹่ทŒ: 249 (51.4%) + ๅๅทฎ: -11ไธช (้žๅธธๅนณ่กก) +``` + +## ๐Ÿ—๏ธ ้กน็›ฎ็ป“ๆž„ + +``` +crypto_predictor/ +โ”œโ”€โ”€ data/ +โ”‚ โ”œโ”€โ”€ fetcher.py # Binanceๆ•ฐๆฎ่Žทๅ– +โ”‚ โ”œโ”€โ”€ preprocessor.py # ๆ•ฐๆฎ้ข„ๅค„็† +โ”‚ โ””โ”€โ”€ dataset.py # PyTorchๆ•ฐๆฎ้›† +โ”œโ”€โ”€ models/ +โ”‚ โ”œโ”€โ”€ base.py # ๅŸบ็ก€ๆจกๅž‹็ฑป +โ”‚ โ”œโ”€โ”€ dlinear/ +โ”‚ โ”‚ โ””โ”€โ”€ model.py # DLinearๆจกๅž‹ๅฎž็Žฐ +โ”‚ โ””โ”€โ”€ checkpoints/ +โ”‚ โ””โ”€โ”€ dlinear_classification_2026/ # ๆœ€ไฝณๆจกๅž‹๏ผˆ53.10%๏ผ‰ +โ”‚ โ”œโ”€โ”€ best_model.pt +โ”‚ โ”œโ”€โ”€ preprocessor.pkl +โ”‚ โ””โ”€โ”€ test_2026_results.json +โ”œโ”€โ”€ training/ +โ”‚ โ”œโ”€โ”€ trainer.py # ่ฎญ็ปƒๅ™จ +โ”‚ โ”œโ”€โ”€ config.py # ่ฎญ็ปƒ้…็ฝฎ +โ”‚ โ””โ”€โ”€ evaluator.py # ่ฏ„ไผฐๅ™จ +โ”œโ”€โ”€ train_classification_full.py # ๅˆ†็ฑปไปปๅŠก่ฎญ็ปƒ่„šๆœฌ +โ”œโ”€โ”€ test_2026_classification.py # 2026ๅนดๆต‹่ฏ•่„šๆœฌ +โ””โ”€โ”€ requirements.txt +``` + +## ๐Ÿš€ ๅฟซ้€Ÿๅผ€ๅง‹ + +### 1. ็Žฏๅขƒๅ‡†ๅค‡ + +```bash +# ๅˆ›ๅปบconda็Žฏๅขƒ +conda create -n crypto_pred python=3.12 +conda activate crypto_pred + +# ๅฎ‰่ฃ…ไพ่ต– +pip install -r requirements.txt +``` + +### 2. ่ฎญ็ปƒๆจกๅž‹ + +```bash +# ไฝฟ็”จ2020-2025ๅนดๆ•ฐๆฎ่ฎญ็ปƒๅˆ†็ฑปๆจกๅž‹ +python train_classification_full.py +``` + +### 3. ๆต‹่ฏ•ๆจกๅž‹ + +```bash +# ๅœจ2026ๅนดๆ•ฐๆฎไธŠๆต‹่ฏ• +python test_2026_classification.py +``` + +## ๐Ÿ“ˆ ไฝฟ็”จๆœ€ไฝณๆจกๅž‹่ฟ›่กŒ้ข„ๆต‹ + +```python +import torch +import pickle +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear + +# ๅŠ ่ฝฝๆจกๅž‹ +device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') +checkpoint = torch.load('./models/checkpoints/dlinear_classification_2026/best_model.pt', + map_location=device) +model = DLinear(checkpoint['config']) +model.load_state_dict(checkpoint['model_state_dict']) +model.eval() + +# ๅŠ ่ฝฝ้ข„ๅค„็†ๅ™จ +with open('./models/checkpoints/dlinear_classification_2026/preprocessor.pkl', 'rb') as f: + preprocessor = pickle.load(f) + +# ่Žทๅ–ๆœ€ๆ–ฐๆ•ฐๆฎๅนถ้ข„ๆต‹ +fetcher = BinanceDataFetcher() +df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=False) +X, y, _ = preprocessor.preprocess(df, fit=False) + +# ้ข„ๆต‹ +with torch.no_grad(): + logits = model(torch.FloatTensor(X[-1:]).to(device)) + prob = torch.sigmoid(logits).item() + prediction = "ไธŠๆถจ" if prob > 0.5 else "ไธ‹่ทŒ" + +print(f"้ข„ๆต‹: {prediction} (ๆฆ‚็Ž‡: {prob:.2%})") +``` + +## ๐Ÿ”ฌ ๅฎž้ชŒๅŽ†ๅฒ + +| ๆ–นๆกˆ | ไปปๅŠก็ฑปๅž‹ | ๆ•ฐๆฎๅˆ’ๅˆ† | ๅ‡†็กฎ็Ž‡ | ไธป่ฆ้—ฎ้ข˜ | +|------|---------|---------|--------|---------| +| 1 | ๅ›žๅฝ’๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰ | 95:5 | 50.23% | ๆŽฅ่ฟ‘้šๆœบ | +| 2 | ๅ›žๅฝ’๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰ | ็›ดๆŽฅ2026 | 49.48% | ๅๅ‘้ข„ๆต‹ไธŠๆถจ | +| 3 | ๅ›žๅฝ’๏ผˆไปทๆ ผ๏ผ‰ | ็›ดๆŽฅ2026 | 49.48% | MAPE 0.42% | +| 4 | ๅ›žๅฝ’๏ผˆไปทๆ ผ๏ผ‰ | 8:1:1 | 49.64% | 90%้ข„ๆต‹ไธ‹่ทŒ | +| **5** | **ๅˆ†็ฑป๏ผˆๆถจ่ทŒ๏ผ‰** | **ๅ…จ้‡่ฎญ็ปƒ** | **53.10%** โœ… | **้ข„ๆต‹ๅนณ่กก** | + +## โš ๏ธ ๆณจๆ„ไบ‹้กน + +1. **53.10%ๅ‡†็กฎ็Ž‡่ฏดๆ˜Ž**๏ผšไป…ๆฏ”้šๆœบ็Œœๆต‹้ซ˜3.1%๏ผŒ้€‚ๅˆๅฐไป“ไฝๆต‹่ฏ• +2. **1ๅฐๆ—ถ้ข„ๆต‹็š„ๅฑ€้™ๆ€ง**๏ผšไปทๆ ผๅ˜ๅŒ–ๆŽฅ่ฟ‘้šๆœบๆธธ่ตฐ๏ผŒๆŠ€ๆœฏๆŒ‡ๆ ‡ๆ•ˆๆžœๆœ‰้™ +3. **ๆ•ฐๆฎ่ฆๆฑ‚**๏ผš้œ€่ฆ่‡ณๅฐ‘169ๅฐๆ—ถ็š„ๅŽ†ๅฒๆ•ฐๆฎ + +## ๐Ÿ“„ ่ฎธๅฏ + +MIT License diff --git a/analyze_split.py b/analyze_split.py new file mode 100644 index 0000000..be93460 --- /dev/null +++ b/analyze_split.py @@ -0,0 +1,195 @@ +"""่ฏฆ็ป†ๅˆ†ๆž่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›†็š„ๅˆ†้…ๆ–นๅผ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import pandas as pd +import numpy as np +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data + +def analyze_split_strategy(): + print("="*80) + print("ๆ•ฐๆฎ้›†ๅˆ†ๅ‰ฒ็ญ–็•ฅ่ฏฆ็ป†ๅˆ†ๆž") + print("="*80) + + # ่Žทๅ–ๆ•ฐๆฎ + print("\n[1/4] ๅŠ ่ฝฝ2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๅŽŸๅง‹ๆ•ฐๆฎ: {len(df)} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด: {df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ้ข„ๅค„็† + print("\n[2/4] ๆ•ฐๆฎ้ข„ๅค„็†...") + preprocessor = CryptoPreprocessor( + lookback=168, + forecast_horizon=1, + price_change_threshold=0.0 + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + + print(f"โœ“ ๅบๅˆ—ๆ•ฐ้‡: {len(X)}") + print(f"โœ“ ๆฏไธชๅบๅˆ—: {X.shape[1]}ๅฐๆ—ถ ร— {X.shape[2]}็‰นๅพ") + + # ๅˆ†ๆžsplit_dataๅ‡ฝๆ•ฐ็š„้€ป่พ‘ + print("\n[3/4] ๅˆ†ๆžๆ•ฐๆฎๅˆ†ๅ‰ฒ้€ป่พ‘...") + print(f"\n๐Ÿ“‹ split_dataๅ‡ฝๆ•ฐ็š„ๅˆ†ๅ‰ฒๆ–นๅผ:") + print(f" train_split = 0.7 (70%)") + print(f" val_split = 0.15 (15%)") + print(f" test_split = 0.15 (15%)") + print(f"\n ๅˆ†ๅ‰ฒๆ–นๅผ: ๆ—ถ้—ดๅบๅˆ—้กบๅบๅˆ†ๅ‰ฒ๏ผˆ้ž้šๆœบๆ‰“ไนฑ๏ผ‰") + print(f" ่ฎก็ฎ—ๆ–นๅผ:") + print(f" n = len(X) # ๆ€ปๅบๅˆ—ๆ•ฐ") + print(f" train_end = int(n * 0.7)") + print(f" val_end = int(n * 0.85)") + print(f" ่ฎญ็ปƒ้›†: X[0:train_end]") + print(f" ้ชŒ่ฏ้›†: X[train_end:val_end]") + print(f" ๆต‹่ฏ•้›†: X[val_end:]") + + # ๆ‰ง่กŒๅˆ†ๅ‰ฒ + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + n = len(X) + train_end_idx = int(n * 0.7) + val_end_idx = int(n * 0.85) + + print(f"\n[4/4] ่ฏฆ็ป†ๅˆ†ๅ‰ฒ็ป“ๆžœๅˆ†ๆž...") + print(f"\nๆ€ปๅบๅˆ—ๆ•ฐ: {n:,}") + print(f"ๅˆ†ๅ‰ฒ็‚น:") + print(f" ่ฎญ็ปƒ้›†็ป“ๆŸ: ็ฌฌ {train_end_idx:,} ไธชๅบๅˆ—") + print(f" ้ชŒ่ฏ้›†็ป“ๆŸ: ็ฌฌ {val_end_idx:,} ไธชๅบๅˆ—") + + # ่ฎก็ฎ—ๆฏไธชๆ•ฐๆฎ้›†ๅฏนๅบ”็š„ๅŽŸๅง‹ๆ•ฐๆฎ็ดขๅผ• + # ๆณจๆ„๏ผš็”ฑไบŽlookback=168๏ผŒๅบๅˆ—ๅˆ›ๅปบๆ—ถๆœ‰ๅ็งป + lookback = 168 + + # ่ฎญ็ปƒ้›†ๅฏนๅบ”็š„ๆ•ฐๆฎ่Œƒๅ›ด + train_start_row = lookback # ็ฌฌไธ€ไธชๅบๅˆ—ไปŽlookbackๅผ€ๅง‹ + train_end_row = train_end_idx + lookback + + # ้ชŒ่ฏ้›†ๅฏนๅบ”็š„ๆ•ฐๆฎ่Œƒๅ›ด + val_start_row = train_end_idx + lookback + val_end_row = val_end_idx + lookback + + # ๆต‹่ฏ•้›†ๅฏนๅบ”็š„ๆ•ฐๆฎ่Œƒๅ›ด + test_start_row = val_end_idx + lookback + test_end_row = len(processed_df) + + print(f"\n๐Ÿ“Š ๅ„ๆ•ฐๆฎ้›†ๅฏนๅบ”็š„ๅŽŸๅง‹ๆ•ฐๆฎ่กŒ:") + print(f"\n่ฎญ็ปƒ้›†:") + print(f" ๅบๅˆ—็ดขๅผ•: 0 ๅˆฐ {train_end_idx:,}") + print(f" ๆ•ฐๆฎ่กŒ่Œƒๅ›ด: {train_start_row:,} ๅˆฐ {train_end_row:,}") + train_df = processed_df.iloc[train_start_row:train_end_row] + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {train_return*100:+.2f}%") + + print(f"\n้ชŒ่ฏ้›†:") + print(f" ๅบๅˆ—็ดขๅผ•: {train_end_idx:,} ๅˆฐ {val_end_idx:,}") + print(f" ๆ•ฐๆฎ่กŒ่Œƒๅ›ด: {val_start_row:,} ๅˆฐ {val_end_row:,}") + val_df = processed_df.iloc[val_start_row:val_end_row] + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {val_return*100:+.2f}%") + + print(f"\nๆต‹่ฏ•้›†:") + print(f" ๅบๅˆ—็ดขๅผ•: {val_end_idx:,} ๅˆฐ {n:,}") + print(f" ๆ•ฐๆฎ่กŒ่Œƒๅ›ด: {test_start_row:,} ๅˆฐ {test_end_row:,}") + test_df = processed_df.iloc[test_start_row:test_end_row] + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + test_return = (test_df['close'].iloc[-1] - test_df['close'].iloc[0]) / test_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${test_df['close'].iloc[0]:,.0f} โ†’ ${test_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {test_return*100:+.2f}%") + + # ๅฏ่ง†ๅŒ–ๆ—ถ้—ด็บฟ + print(f"\n" + "="*80) + print("๐Ÿ“… ๆ—ถ้—ด็บฟๅฏ่ง†ๅŒ–") + print("="*80) + + print(f"\n2020โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”่ฎญ็ปƒ้›†โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”โ”2024โ”โ”้ชŒ่ฏโ”โ”2025โ”โ”ๆต‹่ฏ•โ”โ”2025") + print(f" ") + print(f"็‰›ๅธ‚+825% ็‰›ๅธ‚+34% ไธ‹่ทŒ-8.5%") + print(f" ") + + # ๅˆ†ๆž้—ฎ้ข˜ + print(f"\n" + "="*80) + print("๐Ÿ” ๅ…ณ้”ฎๅ‘็Žฐ") + print("="*80) + + print(f"\nโœ… ๅˆ†ๅ‰ฒๆ–นๅผ๏ผšๆญฃ็กฎ") + print(f" - ๆ—ถ้—ดๅบๅˆ—้กบๅบๅˆ†ๅ‰ฒ๏ผˆๆœชๆ‰“ไนฑ๏ผ‰") + print(f" - ่ฎญ็ปƒๅœจๅ‰๏ผŒ้ชŒ่ฏๅœจไธญ๏ผŒๆต‹่ฏ•ๅœจๅŽ") + print(f" - ้ฟๅ…ไบ†ๆ•ฐๆฎๆณ„้œฒ") + + print(f"\nโš ๏ธ ้—ฎ้ข˜๏ผšๅˆ†ๅธƒไธฅ้‡ไธๅŒน้…") + print(f" - ่ฎญ็ปƒ้›†๏ผˆ2020-2024ๅˆ๏ผ‰๏ผš+825% ๐Ÿš€ ๆž็ซฏ็‰›ๅธ‚") + print(f" - ้ชŒ่ฏ้›†๏ผˆ2024๏ผ‰๏ผš +34% ๐Ÿ“ˆ ็‰›ๅธ‚ๅปถ็ปญ") + print(f" - ๆต‹่ฏ•้›†๏ผˆ2025๏ผ‰๏ผš -8.5% ๐Ÿ“‰ ๅ›ž่ฐƒไธ‹่ทŒ") + + print(f"\n๐Ÿ’ก ่ฟ™ๅฏผ่‡ด:") + print(f" 1. ๆจกๅž‹ๅœจ็‰›ๅธ‚ไธญ่ฎญ็ปƒ โ†’ ๅญฆไผš'็‰›ๅธ‚ๆ€็ปด'") + print(f" 2. ้ชŒ่ฏ้›†ไนŸๆ˜ฏ็‰›ๅธ‚ โ†’ ้ชŒ่ฏๆŸๅคฑๆญฃๅธธ๏ผŒๆœช่ƒฝๅ‘็Žฐ้—ฎ้ข˜") + print(f" 3. ๆต‹่ฏ•้›†ๅดๆ˜ฏ็†Šๅธ‚ โ†’ ๆณ›ๅŒ–ๆ€ง่ƒฝๅทฎ") + + # ๆ ‡็ญพๅˆ†ๅธƒๅˆ†ๆž + print(f"\n๐Ÿ“Š ๆ ‡็ญพๅˆ†ๅธƒๅˆ†ๆž:") + train_up_ratio = (train_data[1] == 1).sum() / len(train_data[1]) + val_up_ratio = (val_data[1] == 1).sum() / len(val_data[1]) + test_up_ratio = (test_data[1] == 1).sum() / len(test_data[1]) + + print(f"\n ่ฎญ็ปƒ้›†ไธŠๆถจๆฏ”ไพ‹: {train_up_ratio*100:.1f}%") + print(f" ้ชŒ่ฏ้›†ไธŠๆถจๆฏ”ไพ‹: {val_up_ratio*100:.1f}%") + print(f" ๆต‹่ฏ•้›†ไธŠๆถจๆฏ”ไพ‹: {test_up_ratio*100:.1f}%") + + if abs(train_up_ratio - test_up_ratio) > 0.05: + print(f"\n โš ๏ธ ่ฎญ็ปƒ้›†ๅ’Œๆต‹่ฏ•้›†็š„ไธŠๆถจๆฏ”ไพ‹ๅทฎๅผ‚: {abs(train_up_ratio - test_up_ratio)*100:.1f}%") + print(f" ่ฟ™่ฏดๆ˜Žๅˆ†ๅธƒไธไธ€่‡ด๏ผ") + + # ๅปบ่ฎฎ + print(f"\n" + "="*80) + print("๐Ÿ’ก ่งฃๅ†ณๆ–นๆกˆๅปบ่ฎฎ") + print("="*80) + + print(f"\nๆ–นๆกˆ1: Walk-Forward้ชŒ่ฏ๏ผˆๆปšๅŠจ็ช—ๅฃ๏ผ‰โญโญโญโญโญ") + print(f" - ไธๆ˜ฏ70/15/15ไธ€ๆฌกๆ€งๅˆ†ๅ‰ฒ") + print(f" - ่€Œๆ˜ฏๅคšๆฌกๆปšๅŠจๅˆ†ๅ‰ฒ๏ผš") + print(f" ็ฌฌ1ๆฌก: 2020-2022่ฎญ็ปƒ โ†’ 2023Q1ๆต‹่ฏ•") + print(f" ็ฌฌ2ๆฌก: 2020-2023่ฎญ็ปƒ โ†’ 2023Q2ๆต‹่ฏ•") + print(f" ็ฌฌ3ๆฌก: 2020-2023่ฎญ็ปƒ โ†’ 2023Q3ๆต‹่ฏ•") + print(f" ...") + print(f" - ๅนณๅ‡ๆ‰€ๆœ‰ๆต‹่ฏ•็ป“ๆžœ") + + print(f"\nๆ–นๆกˆ2: K-Foldๆ—ถ้—ดๅบๅˆ—ไบคๅ‰้ชŒ่ฏ โญโญโญโญ") + print(f" - TimeSeriesSplit (ไฟๆŒๆ—ถ้—ด้กบๅบ)") + print(f" - ๅคšไธชfold๏ผŒๆฏไธชfoldๅŒ…ๅซไธๅŒๅธ‚ๅœบ็Žฏๅขƒ") + + print(f"\nๆ–นๆกˆ3: ๅˆ†ๅฑ‚้‡‡ๆ ท๏ผˆๆŒ‰ๅธ‚ๅœบ็Žฏๅขƒ๏ผ‰โญโญโญ") + print(f" - ่ฏ†ๅˆซ็‰›ๅธ‚/็†Šๅธ‚/้œ‡่กๆœŸ") + print(f" - ็กฎไฟ่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้ƒฝๅŒ…ๅซๅ„็ง็Žฏๅขƒ") + print(f" - ไฝ†่ฆไฟๆŒๆ—ถ้—ด้กบๅบ") + + print(f"\nๆ–นๆกˆ4: ไฝฟ็”จๆ›ด่ฟ‘ๆœŸ็š„ๆ•ฐๆฎไฝœไธบๆต‹่ฏ•้›† โญโญ") + print(f" - ไพ‹ๅฆ‚๏ผš2020-2024่ฎญ็ปƒ โ†’ 2025ๆต‹่ฏ•") + print(f" - ็›ฎๅ‰ๅฐฑๆ˜ฏ่ฟ™ๆ ท๏ผŒไฝ†้—ฎ้ข˜ๆ˜ฏ2025ๆฐๅฅฝๆ˜ฏไธ‹่ทŒๆœŸ") + + print(f"\nๅฝ“ๅ‰้—ฎ้ข˜็š„ๆœฌ่ดจ:") + print(f" โŒ ไธๆ˜ฏๅˆ†ๅ‰ฒๆ–นๆณ•็š„้—ฎ้ข˜") + print(f" โŒ ่€Œๆ˜ฏๆ—ถ้—ดๅบๅˆ—้ข„ๆต‹็š„ๅ›บๆœ‰้šพ้ข˜๏ผš") + print(f" '่ฟ‡ๅŽป็š„็‰›ๅธ‚'ๆ— ๆณ•้ข„ๆต‹'ๆœชๆฅ็š„็†Šๅธ‚'") + print(f" ้™ค้ž่ฎญ็ปƒๆ•ฐๆฎๅŒ…ๅซ่ถณๅคŸๅคš็š„็†Šๅธ‚ๆ ทๆœฌ") + + print("\n" + "="*80) + +if __name__ == "__main__": + analyze_split_strategy() diff --git a/compare_tasks.py b/compare_tasks.py new file mode 100644 index 0000000..9d1883e --- /dev/null +++ b/compare_tasks.py @@ -0,0 +1,244 @@ +"""่ฏฆ็ป†ๅฏนๆฏ”ไบŒๅˆ†็ฑปๅ’Œๅ›žๅฝ’ไปปๅŠกๅœจๅŠ ๅฏ†่ดงๅธ้ข„ๆต‹ไธญ็š„ๅทฎๅผ‚""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import numpy as np +import pandas as pd +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor + +def compare_classification_vs_regression(): + print("="*80) + print("ไบŒๅˆ†็ฑป vs ๅ›žๅฝ’ไปปๅŠก่ฏฆ็ป†ๅฏนๆฏ”") + print("="*80) + + # ่Žทๅ–ๅฐ‘้‡ๆ•ฐๆฎ็”จไบŽๆผ”็คบ + print("\n[1/3] ่Žทๅ–็คบไพ‹ๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + df_sample = df.tail(200).copy() # ๅชๅ–ๆœ€่ฟ‘200ๅฐๆ—ถ + + print(f"โœ“ ๆ ทๆœฌๆ•ฐๆฎ: {len(df_sample)} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด: {df_sample['timestamp'].min()} ่‡ณ {df_sample['timestamp'].max()}") + + # ๅฏนๆฏ”ไธค็งไปปๅŠก + print("\n[2/3] ๅฏนๆฏ”ไธค็งไปปๅŠก็š„ๆ ‡็ญพ็”Ÿๆˆ...") + + # ไบŒๅˆ†็ฑปไปปๅŠก + print("\n" + "="*80) + print("๐Ÿ“Š ไปปๅŠก1: ไบŒๅˆ†็ฑป๏ผˆBinary Classification๏ผ‰") + print("="*80) + + preprocessor_cls = CryptoPreprocessor( + lookback=24, + forecast_horizon=1, + price_change_threshold=0.0 + ) + + # ๅˆ›ๅปบๆ ‡็ญพ + df_sample['future_price'] = df_sample['close'].shift(-1) + df_sample['future_return'] = (df_sample['future_price'] - df_sample['close']) / df_sample['close'] + df_sample['label_classification'] = (df_sample['future_return'] > 0).astype(int) + + print(f"\n็›ฎๆ ‡: ้ข„ๆต‹ไปทๆ ผไผšไธŠๆถจ(1)่ฟ˜ๆ˜ฏไธ‹่ทŒ(0)") + print(f"\nๆ ‡็ญพ็”Ÿๆˆๅ…ฌๅผ:") + print(f" future_return = (ๆœชๆฅไปทๆ ผ - ๅฝ“ๅ‰ไปทๆ ผ) / ๅฝ“ๅ‰ไปทๆ ผ") + print(f" label = 1 if future_return > 0 else 0") + + print(f"\nๅ…ทไฝ“ไพ‹ๅญ๏ผˆๅ‰10ไธชๆ ทๆœฌ๏ผ‰:") + print(f"{'ๆ—ถ้—ด':<20} {'ๅฝ“ๅ‰ไปทๆ ผ':<12} {'ๆœชๆฅไปทๆ ผ':<12} {'ๆ”ถ็›Š็Ž‡':<10} {'ๆ ‡็ญพ':<8}") + print("-"*80) + for i in range(10): + row = df_sample.iloc[i] + if pd.notna(row['future_return']): + label = "ไธŠๆถจ(1)" if row['label_classification'] == 1 else "ไธ‹่ทŒ(0)" + print(f"{str(row['timestamp']):<20} ${row['close']:<11,.2f} ${row['future_price']:<11,.2f} " + f"{row['future_return']*100:>7.2f}% {label:<8}") + + print(f"\nๆ ‡็ญพ็ปŸ่ฎก:") + n_up = df_sample['label_classification'].sum() + n_down = len(df_sample) - n_up - df_sample['label_classification'].isna().sum() + print(f" ไธŠๆถจ(1): {n_up} ไธช") + print(f" ไธ‹่ทŒ(0): {n_down} ไธช") + print(f" ๆฏ”ไพ‹: {n_up/(n_up+n_down)*100:.1f}% vs {n_down/(n_up+n_down)*100:.1f}%") + + print(f"\nๆจกๅž‹่พ“ๅ‡บ:") + print(f" ๆ ผๅผ: 0-1ไน‹้—ด็š„ๆฆ‚็Ž‡ๅ€ผ") + print(f" ไพ‹ๅฆ‚: 0.73 ่กจ็คบ 73% ๆฆ‚็Ž‡ไธŠๆถจ") + print(f" ๅ†ณ็ญ–: ๅฆ‚ๆžœๆฆ‚็Ž‡ > 0.5 โ†’ ้ข„ๆต‹ไธŠๆถจ") + print(f" ๅฆ‚ๆžœๆฆ‚็Ž‡ < 0.5 โ†’ ้ข„ๆต‹ไธ‹่ทŒ") + + print(f"\n่ฏ„ไผฐๆŒ‡ๆ ‡:") + print(f" - ๅ‡†็กฎ็Ž‡ (Accuracy)") + print(f" - ็ฒพ็กฎ็Ž‡ (Precision)") + print(f" - ๅฌๅ›ž็Ž‡ (Recall)") + print(f" - F1ๅˆ†ๆ•ฐ") + print(f" - ๆททๆท†็Ÿฉ้˜ต") + + print(f"\nไผ˜็‚น:") + print(f" โœ… ็ฎ€ๅ•็›ด่ง‚๏ผˆๆถจ/่ทŒไบŒ้€‰ไธ€๏ผ‰") + print(f" โœ… ่ฏ„ไผฐๆŒ‡ๆ ‡ๆธ…ๆ™ฐ") + print(f" โœ… ้€‚ๅˆไบคๆ˜“ๅ†ณ็ญ–๏ผˆๅšๅคš/ๅš็ฉบ๏ผ‰") + + print(f"\n็ผบ็‚น:") + print(f" โŒ ไธขๅคฑไบ†ๆถจ่ทŒๅน…ๅบฆไฟกๆฏ") + print(f" โŒ ๆถจ0.1%ๅ’Œๆถจ10%่ขซ่ง†ไธบไธ€ๆ ท") + print(f" โŒ ๆ— ๆณ•่ฏ„ไผฐ้ฃŽ้™ฉๆ”ถ็›Šๆฏ”") + + # ๅ›žๅฝ’ไปปๅŠก + print("\n" + "="*80) + print("๐Ÿ“ˆ ไปปๅŠก2: ๅ›žๅฝ’๏ผˆRegression๏ผ‰") + print("="*80) + + df_sample['label_regression'] = df_sample['future_return'] + + print(f"\n็›ฎๆ ‡: ้ข„ๆต‹ไปทๆ ผๅ˜ๅŒ–็š„็™พๅˆ†ๆฏ”") + print(f"\nๆ ‡็ญพ็”Ÿๆˆๅ…ฌๅผ:") + print(f" label = (ๆœชๆฅไปทๆ ผ - ๅฝ“ๅ‰ไปทๆ ผ) / ๅฝ“ๅ‰ไปทๆ ผ") + print(f" ็›ดๆŽฅ้ข„ๆต‹ๆ”ถ็›Š็Ž‡๏ผˆๅฏๆญฃๅฏ่ดŸ๏ผ‰") + + print(f"\nๅ…ทไฝ“ไพ‹ๅญ๏ผˆๅ‰10ไธชๆ ทๆœฌ๏ผ‰:") + print(f"{'ๆ—ถ้—ด':<20} {'ๅฝ“ๅ‰ไปทๆ ผ':<12} {'ๆœชๆฅไปทๆ ผ':<12} {'ๆ”ถ็›Š็Ž‡(ๆ ‡็ญพ)':<15}") + print("-"*80) + for i in range(10): + row = df_sample.iloc[i] + if pd.notna(row['future_return']): + print(f"{str(row['timestamp']):<20} ${row['close']:<11,.2f} ${row['future_price']:<11,.2f} " + f"{row['label_regression']*100:>12.4f}%") + + print(f"\nๆ ‡็ญพ็ปŸ่ฎก:") + valid_returns = df_sample['label_regression'].dropna() + print(f" ๆœ€ๅฐๅ€ผ: {valid_returns.min()*100:.4f}%") + print(f" ๆœ€ๅคงๅ€ผ: {valid_returns.max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {valid_returns.mean()*100:.4f}%") + print(f" ๆ ‡ๅ‡†ๅทฎ: {valid_returns.std()*100:.4f}%") + print(f" ไธญไฝๆ•ฐ: {valid_returns.median()*100:.4f}%") + + print(f"\nๆจกๅž‹่พ“ๅ‡บ:") + print(f" ๆ ผๅผ: ่ฟž็ปญ็š„ๆ•ฐๅ€ผ๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰") + print(f" ไพ‹ๅฆ‚: 0.0235 ่กจ็คบ้ข„ๆต‹ไธŠๆถจ 2.35%") + print(f" -0.0178 ่กจ็คบ้ข„ๆต‹ไธ‹่ทŒ 1.78%") + print(f" ๅ†ณ็ญ–: ๆ นๆฎ้ข„ๆต‹ๅ€ผๅคงๅฐๅ†ณๅฎšไป“ไฝ") + print(f" ้ข„ๆต‹+5% โ†’ ๅคงไป“ไฝๅšๅคš") + print(f" ้ข„ๆต‹+0.5% โ†’ ๅฐไป“ไฝๅšๅคš") + + print(f"\n่ฏ„ไผฐๆŒ‡ๆ ‡:") + print(f" - RMSE (ๅ‡ๆ–นๆ น่ฏฏๅทฎ)") + print(f" - MAE (ๅนณๅ‡็ปๅฏน่ฏฏๅทฎ)") + print(f" - MAPE (ๅนณๅ‡็ปๅฏน็™พๅˆ†ๆฏ”่ฏฏๅทฎ)") + print(f" - ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ (้ข„ๆต‹ๆ–นๅ‘ๆ˜ฏๅฆๆญฃ็กฎ)") + print(f" - Rยฒ (ๅ†ณๅฎš็ณปๆ•ฐ)") + + print(f"\nไผ˜็‚น:") + print(f" โœ… ไฟ็•™ไบ†ๆถจ่ทŒๅน…ๅบฆไฟกๆฏ") + print(f" โœ… ๅฏไปฅ่ฏ„ไผฐ้ฃŽ้™ฉๆ”ถ็›Šๆฏ”") + print(f" โœ… ๆ”ฏๆŒๅŠจๆ€ไป“ไฝ็ฎก็†") + print(f" โœ… ๆไพ›ๆ›ด็ฒพ็ป†็š„้ข„ๆต‹") + + print(f"\n็ผบ็‚น:") + print(f" โŒ ้ข„ๆต‹้šพๅบฆๆ›ด้ซ˜") + print(f" โŒ ๅฎนๆ˜“่ฟ‡ๆ‹Ÿๅˆ") + print(f" โŒ ๅฏนๅผ‚ๅธธๅ€ผๆ•ๆ„Ÿ") + + # ๅฏนๆฏ”ๅˆ†ๆž + print("\n[3/3] ่ฏฆ็ป†ๅฏนๆฏ”ๅˆ†ๆž...") + print("\n" + "="*80) + print("๐Ÿ” ่ฏฆ็ป†ๅฏนๆฏ”") + print("="*80) + + comparison = [ + ["็ปดๅบฆ", "ไบŒๅˆ†็ฑป", "ๅ›žๅฝ’"], + ["-"*30, "-"*40, "-"*40], + ["้ข„ๆต‹็›ฎๆ ‡", "ๆ–นๅ‘๏ผˆๆถจ/่ทŒ๏ผ‰", "ๅ…ทไฝ“ๆถจ่ทŒๅน…ๅบฆ"], + ["่พ“ๅ‡บ่Œƒๅ›ด", "0-1๏ผˆๆฆ‚็Ž‡๏ผ‰", "-โˆž to +โˆž๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰"], + ["่พ“ๅ‡บ็คบไพ‹", "0.73๏ผˆ73%ๆฆ‚็Ž‡ไธŠๆถจ๏ผ‰", "+0.0235๏ผˆ้ข„ๆต‹ๆถจ2.35%๏ผ‰"], + ["ๆ ‡็ญพ็ฑปๅž‹", "็ฆปๆ•ฃ๏ผˆ0ๆˆ–1๏ผ‰", "่ฟž็ปญ๏ผˆๅฎžๆ•ฐ๏ผ‰"], + ["ๆŸๅคฑๅ‡ฝๆ•ฐ", "BCEWithLogitsLoss", "MSELoss / MAELoss"], + ["่ฏ„ไผฐๆŒ‡ๆ ‡", "ๅ‡†็กฎ็Ž‡ใ€F1ๅˆ†ๆ•ฐ", "RMSEใ€MAEใ€MAPE"], + ["ๅ†ณ็ญ–ๆ–นๅผ", "ไบŒๅ…ƒ๏ผˆๅšๅคš/ๅš็ฉบ๏ผ‰", "่ฟž็ปญ๏ผˆไป“ไฝๅคงๅฐ๏ผ‰"], + ["ไฟกๆฏ้‡", "ๅฐ‘๏ผˆๅชๆœ‰ๆ–นๅ‘๏ผ‰", "ๅคš๏ผˆๆ–นๅ‘+ๅน…ๅบฆ๏ผ‰"], + ["้ข„ๆต‹้šพๅบฆ", "ไธญ็ญ‰", "ๅ›ฐ้šพ"], + ["้€‚็”จๅœบๆ™ฏ", "็ฎ€ๅ•ไบคๆ˜“็ญ–็•ฅ", "็ฒพ็ป†ๅŒ–่ต„้‡‘็ฎก็†"], + ] + + for row in comparison: + print(f"{row[0]:<30} {row[1]:<40} {row[2]:<40}") + + # ๅฎž้™…ๅบ”็”จๅฏนๆฏ” + print("\n" + "="*80) + print("๐Ÿ’ฐ ๅฎž้™…ไบคๆ˜“ๅบ”็”จๅฏนๆฏ”") + print("="*80) + + print("\nๅœบๆ™ฏ1: ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถBTCไผšไธŠๆถจ") + print("\nไบŒๅˆ†็ฑปๆจกๅž‹:") + print(" ่พ“ๅ‡บ: 0.68 (68%ๆฆ‚็Ž‡ไธŠๆถจ)") + print(" ๅ†ณ็ญ–: ๆฆ‚็Ž‡>0.5๏ผŒไนฐๅ…ฅBTC") + print(" ่กŒๅŠจ: ๅ…จไป“ๅšๅคš๏ผˆๆˆ–ๅ›บๅฎšไป“ไฝๅฆ‚50%๏ผ‰") + print(" ้—ฎ้ข˜: ไธ็Ÿฅ้“้ข„ๆœŸๆถจๅคšๅฐ‘๏ผŒๆ— ๆณ•่ฏ„ไผฐ้ฃŽ้™ฉ") + + print("\nๅ›žๅฝ’ๆจกๅž‹:") + print(" ่พ“ๅ‡บ: +0.0023 (้ข„ๆต‹ไธŠๆถจ0.23%)") + print(" ๅ†ณ็ญ–: ้ข„ๆต‹ๅ€ผ>0๏ผŒไนฐๅ…ฅBTC") + print(" ่กŒๅŠจ: ๆ นๆฎ้ข„ๆต‹ๅน…ๅบฆ่ฐƒๆ•ดไป“ไฝ๏ผˆ0.23%ๅพˆๅฐ๏ผŒๅฏ่ƒฝๅช็”จ10%ไป“ไฝ๏ผ‰") + print(" ไผ˜ๅŠฟ: ็Ÿฅ้“้ข„ๆœŸๆ”ถ็›Š๏ผŒๅฏไปฅ่ฎก็ฎ—้ฃŽ้™ฉๆ”ถ็›Šๆฏ”") + + print("\nๅœบๆ™ฏ2: ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถBTCๅคงๆถจ") + print("\nไบŒๅˆ†็ฑปๆจกๅž‹:") + print(" ่พ“ๅ‡บ: 0.72 (72%ๆฆ‚็Ž‡ไธŠๆถจ)") + print(" ๅ†ณ็ญ–: ไนฐๅ…ฅBTC") + print(" ้—ฎ้ข˜: 72%ๆฆ‚็Ž‡ๅฏ่ƒฝๆ˜ฏๆถจ0.1%๏ผŒไนŸๅฏ่ƒฝๆ˜ฏๆถจ5%๏ผŒๆ— ๆณ•ๅŒบๅˆ†") + + print("\nๅ›žๅฝ’ๆจกๅž‹:") + print(" ่พ“ๅ‡บ: +0.0480 (้ข„ๆต‹ไธŠๆถจ4.8%)") + print(" ๅ†ณ็ญ–: ไนฐๅ…ฅBTC") + print(" ่กŒๅŠจ: ้ข„ๆœŸๆถจๅน…ๅคง๏ผŒๅฏไปฅๅŠ ๅคงไป“ไฝ๏ผˆๅฆ‚80%๏ผ‰") + print(" ไผ˜ๅŠฟ: ๅฏไปฅๆ นๆฎ้ข„ๆœŸๆ”ถ็›Š่ฐƒๆ•ด้ฃŽ้™ฉๆ•žๅฃ") + + # ๆ€ง่ƒฝๅฏนๆฏ” + print("\n" + "="*80) + print("๐Ÿ“Š ๅฝ“ๅ‰้กน็›ฎ็š„ๅฎž้™…ๆ€ง่ƒฝๅฏนๆฏ”") + print("="*80) + + print("\nไบŒๅˆ†็ฑปไปปๅŠก๏ผˆๅฝ“ๅ‰ๅทฒๅฎž็Žฐ๏ผ‰:") + print(" ๅ‡†็กฎ็Ž‡: 49.76%๏ผˆๆŽฅ่ฟ‘้šๆœบ๏ผ‰") + print(" F1ๅˆ†ๆ•ฐ: 0.3898") + print(" ๅฌๅ›ž็Ž‡: 31.85%") + print(" ้—ฎ้ข˜: ้ข„ๆต‹่ƒฝๅŠ›ๆžๅผฑ") + + print("\nๅ›žๅฝ’ไปปๅŠก๏ผˆๆœชๅฎž็Žฐ๏ผ‰:") + print(" ้ข„ๆœŸๆ€ง่ƒฝ: ๅฏ่ƒฝๆ›ดๅทฎ") + print(" ๅŽŸๅ› : ้ข„ๆต‹ๅ…ทไฝ“ๆ•ฐๅ€ผๆฏ”้ข„ๆต‹ๆ–นๅ‘ๆ›ด้šพ") + print(" ไฝ†ไผ˜ๅŠฟ: ๅณไฝฟๆ–นๅ‘ๅ‡†็กฎ็Ž‡50%๏ผŒๅฆ‚ๆžœ่ƒฝๅ‡†็กฎ้ข„ๆต‹ๅน…ๅบฆ๏ผŒไปๅฏ็›ˆๅˆฉ") + + # ๅปบ่ฎฎ + print("\n" + "="*80) + print("๐Ÿ’ก ๅปบ่ฎฎ") + print("="*80) + + print("\n้€‰ๆ‹ฉไบŒๅˆ†็ฑป็š„ๆƒ…ๅ†ต:") + print(" โœ… ๅˆๅญฆ่€…ๆˆ–ๆฆ‚ๅฟต้ชŒ่ฏ") + print(" โœ… ็ฎ€ๅ•็š„ๅšๅคš/ๅš็ฉบ็ญ–็•ฅ") + print(" โœ… ้ข„ๆต‹ๅ‘จๆœŸ่พƒ้•ฟ๏ผˆ1ๅคฉไปฅไธŠ๏ผ‰") + print(" โœ… ๅชๅ…ณๅฟƒๆ–นๅ‘๏ผŒไธๅ…ณๅฟƒๅน…ๅบฆ") + + print("\n้€‰ๆ‹ฉๅ›žๅฝ’็š„ๆƒ…ๅ†ต:") + print(" โœ… ้œ€่ฆ็ฒพ็ป†ๅŒ–่ต„้‡‘็ฎก็†") + print(" โœ… ้œ€่ฆ่ฏ„ไผฐ้ฃŽ้™ฉๆ”ถ็›Šๆฏ”") + print(" โœ… ๆœ‰่ถณๅคŸๅคš็š„่ฎญ็ปƒๆ•ฐๆฎ") + print(" โœ… ๆƒณ่ฆๆ›ดไธฐๅฏŒ็š„้ข„ๆต‹ไฟกๆฏ") + + print("\nๅฏนไบŽ1ๅฐๆ—ถBTC้ข„ๆต‹:") + print(" ๅฝ“ๅ‰็ป“่ฎบ: ไธค่€…้ƒฝๅพˆ้šพ๏ผ") + print(" ไบŒๅˆ†็ฑป: ๅ‡†็กฎ็Ž‡49.76%๏ผˆๅทฒ้ชŒ่ฏ๏ผ‰") + print(" ๅ›žๅฝ’: ้ข„่ฎกMAPEไผšๅพˆ้ซ˜๏ผˆๆœช้ชŒ่ฏ๏ผŒไฝ†ๅคงๆฆ‚็Ž‡ไนŸๅพˆๅทฎ๏ผ‰") + print("\n ๆ ธๅฟƒ้—ฎ้ข˜: 1ๅฐๆ—ถไปทๆ ผๅ˜ๅŒ–ๆŽฅ่ฟ‘้šๆœบๆธธ่ตฐ") + print(" ๅปบ่ฎฎ: ๅปถ้•ฟ้ข„ๆต‹ๅ‘จๆœŸๅˆฐ24ๅฐๆ—ถๆˆ–ๆ›ด้•ฟ") + + print("\n" + "="*80) + print("โœ“ ๅฏนๆฏ”ๅˆ†ๆžๅฎŒๆˆ") + print("="*80) + +if __name__ == "__main__": + compare_classification_vs_regression() diff --git a/data/__init__.py b/data/__init__.py new file mode 100644 index 0000000..59d0536 --- /dev/null +++ b/data/__init__.py @@ -0,0 +1 @@ +"""Data fetching, preprocessing, and dataset utilities.""" diff --git a/data/dataset.py b/data/dataset.py new file mode 100644 index 0000000..20b9188 --- /dev/null +++ b/data/dataset.py @@ -0,0 +1,147 @@ +"""PyTorch Dataset classes for cryptocurrency time series data.""" + +from typing import Literal, Tuple +import numpy as np +import torch +from torch.utils.data import Dataset + + +class CryptoDataset(Dataset): + """PyTorch Dataset for cryptocurrency time series prediction.""" + + def __init__( + self, + X: np.ndarray, + y: np.ndarray, + task: Literal['classification', 'regression'] = 'classification' + ): + """Initialize dataset. + + Args: + X: Feature sequences of shape (n_samples, lookback, n_features) + y: Labels of shape (n_samples,) + task: Task type ('classification' or 'regression') + """ + self.X = torch.FloatTensor(X) + + if task == 'classification': + self.y = torch.LongTensor(y) + else: # regression + self.y = torch.FloatTensor(y) + + self.task = task + + def __len__(self) -> int: + """Return number of samples.""" + return len(self.X) + + def __getitem__(self, idx: int) -> Tuple[torch.Tensor, torch.Tensor]: + """Get a sample. + + Args: + idx: Sample index + + Returns: + Tuple of (features, label) + """ + return self.X[idx], self.y[idx] + + def get_feature_dim(self) -> int: + """Get number of features. + + Returns: + Number of features + """ + return self.X.shape[-1] + + def get_sequence_length(self) -> int: + """Get sequence length (lookback). + + Returns: + Sequence length + """ + return self.X.shape[1] + + +def create_dataloaders( + train_data: Tuple[np.ndarray, np.ndarray], + val_data: Tuple[np.ndarray, np.ndarray], + test_data: Tuple[np.ndarray, np.ndarray], + task: Literal['classification', 'regression'] = 'classification', + batch_size: int = 64, + num_workers: int = 0, # 0 for M1 compatibility + pin_memory: bool = False # False for MPS +) -> Tuple[torch.utils.data.DataLoader, ...]: + """Create DataLoaders for train/val/test sets. + + Args: + train_data: Tuple of (X_train, y_train) + val_data: Tuple of (X_val, y_val) + test_data: Tuple of (X_test, y_test) + task: Task type + batch_size: Batch size + num_workers: Number of worker processes (0 for M1) + pin_memory: Whether to pin memory (False for MPS) + + Returns: + Tuple of (train_loader, val_loader, test_loader) + """ + # Create datasets + train_dataset = CryptoDataset(*train_data, task=task) + val_dataset = CryptoDataset(*val_data, task=task) + test_dataset = CryptoDataset(*test_data, task=task) + + # Create dataloaders + train_loader = torch.utils.data.DataLoader( + train_dataset, + batch_size=batch_size, + shuffle=True, + num_workers=num_workers, + pin_memory=pin_memory + ) + + val_loader = torch.utils.data.DataLoader( + val_dataset, + batch_size=batch_size, + shuffle=False, + num_workers=num_workers, + pin_memory=pin_memory + ) + + test_loader = torch.utils.data.DataLoader( + test_dataset, + batch_size=batch_size, + shuffle=False, + num_workers=num_workers, + pin_memory=pin_memory + ) + + return train_loader, val_loader, test_loader + + +if __name__ == "__main__": + # Test the dataset + from fetcher import BinanceDataFetcher + from preprocessor import CryptoPreprocessor, split_data + + # Fetch and preprocess data + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h') + + preprocessor = CryptoPreprocessor(lookback=168) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification') + + # Split data + train_data, val_data, test_data = split_data(X, y) + + # Create dataloaders + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + batch_size=32 + ) + + # Test iteration + for batch_X, batch_y in train_loader: + print(f"Batch X shape: {batch_X.shape}") + print(f"Batch y shape: {batch_y.shape}") + break diff --git a/data/fetcher.py b/data/fetcher.py new file mode 100644 index 0000000..e33827c --- /dev/null +++ b/data/fetcher.py @@ -0,0 +1,191 @@ +"""ไปŽBinance่Žทๅ–ๅŠ ๅฏ†่ดงๅธOHLCVๆ•ฐๆฎ""" + +import os +from datetime import datetime, timedelta +from pathlib import Path +from typing import Optional, Literal + +import pandas as pd +from binance.client import Client +import pytz +from dotenv import load_dotenv + +# ๅŠ ่ฝฝ็Žฏๅขƒๅ˜้‡ +load_dotenv() + + +class BinanceDataFetcher: + """ไปŽBinanceๅ…ฌๅผ€API่Žทๅ–ๅ’Œ็ผ“ๅญ˜OHLCVๆ•ฐๆฎ""" + + INTERVALS = { + '1h': Client.KLINE_INTERVAL_1HOUR, + '15m': Client.KLINE_INTERVAL_15MINUTE, + } + + def __init__(self, cache_dir: str = "./data/cache"): + """ๅˆๅง‹ๅŒ–Binanceๅฎขๆˆท็ซฏๅ’Œ็ผ“ๅญ˜็›ฎๅฝ• + + Args: + cache_dir: ็ผ“ๅญ˜ไธ‹่ฝฝๆ•ฐๆฎ็š„็›ฎๅฝ• + """ + # ้…็ฝฎไปฃ็† + proxies = None + use_proxy = os.getenv('USE_PROXY', 'false').lower() == 'true' + + if use_proxy: + socks5_proxy = os.getenv('SOCKS5_PROXY', 'socks5://127.0.0.1:7890') + proxies = { + 'http': socks5_proxy, + 'https': socks5_proxy + } + print(f"โœ“ ไฝฟ็”จSOCKS5ไปฃ็†: {socks5_proxy}") + + try: + # ๅˆๅง‹ๅŒ–Binanceๅฎขๆˆท็ซฏ๏ผˆๅธฆไปฃ็†๏ผ‰ + if proxies: + self.client = Client(requests_params={'proxies': proxies}) + else: + self.client = Client() + + # ๆต‹่ฏ•่ฟžๆŽฅ + self.client.ping() + print("โœ“ ๅทฒๆˆๅŠŸ่ฟžๆŽฅๅˆฐBinance API") + except Exception as e: + print(f"โš  Binance API่ฟžๆŽฅๅคฑ่ดฅ: {e}") + print("ๆ็คบ๏ผš") + print(" 1. ๆฃ€ๆŸฅไปฃ็†่ฎพ็ฝฎ (.envๆ–‡ไปถ)") + print(" 2. ็กฎไฟไปฃ็†ๆœๅŠกๆญฃๅœจ่ฟ่กŒ") + print(" 3. ๆˆ–่€…ไฝฟ็”จๅทฒ็ผ“ๅญ˜็š„ๆ•ฐๆฎ") + self.client = None + + self.cache_dir = Path(cache_dir) + self.cache_dir.mkdir(parents=True, exist_ok=True) + + def fetch_ohlcv( + self, + symbol: Literal['BTC', 'ETH', 'SOL'], + timeframe: Literal['1h', '15m'], + start_date: Optional[str] = None, + end_date: Optional[str] = None, + use_cache: bool = True + ) -> pd.DataFrame: + """่Žทๅ–ๅŠ ๅฏ†่ดงๅธๅฏน็š„OHLCVๆ•ฐๆฎ + + Args: + symbol: ๅŠ ๅฏ†่ดงๅธ็ฌฆๅท (BTC, ETH, SOL) + timeframe: ๆ—ถ้—ดๆก†ๆžถ้—ด้š” (1h ๆˆ– 15m) + start_date: ๅผ€ๅง‹ๆ—ฅๆœŸ๏ผŒๆ ผๅผ๏ผš'YYYY-MM-DD' (้ป˜่ฎค: 1ๅนดๅ‰) + end_date: ็ป“ๆŸๆ—ฅๆœŸ๏ผŒๆ ผๅผ๏ผš'YYYY-MM-DD' (้ป˜่ฎค: ็Žฐๅœจ) + use_cache: ๆ˜ฏๅฆไฝฟ็”จ็ผ“ๅญ˜ๆ•ฐๆฎ + + Returns: + ๅŒ…ๅซไปฅไธ‹ๅˆ—็š„DataFrame: timestamp, open, high, low, close, volume + """ + # ็”Ÿๆˆ็ผ“ๅญ˜ๆ–‡ไปถๅ + cache_file = self._get_cache_filename(symbol, timeframe, start_date, end_date) + + # ๆฃ€ๆŸฅ็ผ“ๅญ˜ + if use_cache and cache_file.exists(): + print(f"ไปŽ็ผ“ๅญ˜ๅŠ ่ฝฝๆ•ฐๆฎ๏ผš{cache_file}") + return pd.read_csv(cache_file, parse_dates=['timestamp']) + + # ๆฃ€ๆŸฅๅฎขๆˆท็ซฏๆ˜ฏๅฆๅฏ็”จ + if self.client is None: + raise ConnectionError( + "Binanceๅฎขๆˆท็ซฏไธๅฏ็”จใ€‚่ฏทไฝฟ็”จVPNๆˆ–ไฝฟ็”จๅทฒ็ผ“ๅญ˜็š„ๆ•ฐๆฎใ€‚" + ) + + # ่ฎพ็ฝฎ้ป˜่ฎคๆ—ฅๆœŸ + if end_date is None: + end_dt = datetime.now(pytz.UTC) + else: + end_dt = datetime.strptime(end_date, '%Y-%m-%d').replace(tzinfo=pytz.UTC) + + if start_date is None: + start_dt = end_dt - timedelta(days=365) # 1ๅนดๅ‰ + else: + start_dt = datetime.strptime(start_date, '%Y-%m-%d').replace(tzinfo=pytz.UTC) + + # Binanceไฝฟ็”จUSDTไบคๆ˜“ๅฏน + pair = f"{symbol}USDT" + interval = self.INTERVALS[timeframe] + + print(f"่Žทๅ– {symbol} {timeframe} ๆ•ฐๆฎ๏ผŒๆ—ถ้—ด่Œƒๅ›ด๏ผš{start_dt.date()} ่‡ณ {end_dt.date()}...") + + # ่Žทๅ–K็บฟๆ•ฐๆฎ + klines = self.client.get_historical_klines( + symbol=pair, + interval=interval, + start_str=str(int(start_dt.timestamp() * 1000)), + end_str=str(int(end_dt.timestamp() * 1000)) + ) + + if not klines: + raise ValueError(f"ๆœช่Žทๅ–ๅˆฐ {symbol} {timeframe} ็š„ๆ•ฐๆฎ") + + # ่ฝฌๆขไธบDataFrame + df = pd.DataFrame(klines, columns=[ + 'timestamp', 'open', 'high', 'low', 'close', 'volume', + 'close_time', 'quote_volume', 'trades', 'taker_buy_base', + 'taker_buy_quote', 'ignore' + ]) + + # ้€‰ๆ‹ฉๅนถ่ฝฌๆขๅˆ— + df = df[['timestamp', 'open', 'high', 'low', 'close', 'volume']].copy() + df['timestamp'] = pd.to_datetime(df['timestamp'], unit='ms') + + for col in ['open', 'high', 'low', 'close', 'volume']: + df[col] = df[col].astype(float) + + # ๆŒ‰ๆ—ถ้—ดๆŽ’ๅบ + df = df.sort_values('timestamp').reset_index(drop=True) + + print(f"ๅทฒ่Žทๅ– {len(df)} ่กŒๆ•ฐๆฎ๏ผŒๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ไฟๅญ˜ๅˆฐ็ผ“ๅญ˜ + df.to_csv(cache_file, index=False) + print(f"ๅทฒ็ผ“ๅญ˜ๆ•ฐๆฎ่‡ณ๏ผš{cache_file}") + + return df + + def _get_cache_filename( + self, + symbol: str, + timeframe: str, + start_date: Optional[str], + end_date: Optional[str] + ) -> Path: + """ๆ นๆฎๅ‚ๆ•ฐ็”Ÿๆˆ็ผ“ๅญ˜ๆ–‡ไปถๅ""" + start = start_date or "1y" + end = end_date or "now" + filename = f"{symbol}_{timeframe}_{start}_{end}.csv" + return self.cache_dir / filename + + def get_latest_price(self, symbol: Literal['BTC', 'ETH', 'SOL']) -> float: + """่Žทๅ–็ฌฆๅท็š„ๅฝ“ๅ‰ไปทๆ ผ + + Args: + symbol: ๅŠ ๅฏ†่ดงๅธ็ฌฆๅท + + Returns: + ๅฝ“ๅ‰USDTไปทๆ ผ + """ + pair = f"{symbol}USDT" + ticker = self.client.get_symbol_ticker(symbol=pair) + return float(ticker['price']) + + +if __name__ == "__main__": + # ๆต‹่ฏ•ๆ•ฐๆฎ่Žทๅ–ๅ™จ + fetcher = BinanceDataFetcher() + + # ่Žทๅ–BTC 1ๅฐๆ—ถๆ•ฐๆฎ๏ผˆ1ๅนด๏ผ‰ + df = fetcher.fetch_ohlcv('BTC', '1h') + print("\nBTC 1ๅฐๆ—ถๆ•ฐๆฎ:") + print(df.head()) + print(f"\nๅฝข็Šถ๏ผš{df.shape}") + print(f"ๆ—ฅๆœŸ่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ่Žทๅ–ๅฝ“ๅ‰ไปทๆ ผ + current_price = fetcher.get_latest_price('BTC') + print(f"\nๅฝ“ๅ‰BTCไปทๆ ผ๏ผš${current_price:,.2f}") diff --git a/data/preprocessor.py b/data/preprocessor.py new file mode 100644 index 0000000..ece5a6d --- /dev/null +++ b/data/preprocessor.py @@ -0,0 +1,329 @@ +"""Data preprocessing: normalization, feature engineering, and sequence creation.""" + +from typing import Tuple, Optional, Literal +import numpy as np +import pandas as pd +from sklearn.preprocessing import MinMaxScaler +import pandas_ta as ta + + +class CryptoPreprocessor: + """Preprocess cryptocurrency data with normalization and feature engineering.""" + + def __init__( + self, + lookback: int = 168, + forecast_horizon: int = 24, + price_change_threshold: float = 0.0 # ๆ”นไธบ0๏ผŒไฝฟ็”จ็œŸๅฎžๆถจ่ทŒ + ): + """Initialize preprocessor. + + Args: + lookback: Number of historical timesteps to use + forecast_horizon: Number of timesteps to predict ahead + price_change_threshold: Threshold for binary classification (e.g., 0.015 = 1.5%) + """ + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.price_change_threshold = price_change_threshold + self.scaler = MinMaxScaler() + self.feature_columns = [] + self.is_fitted = False + + def add_technical_indicators(self, df: pd.DataFrame) -> pd.DataFrame: + """ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ไฝœไธบ็‰นๅพ + + Args: + df: ๅŒ…ๅซOHLCVๆ•ฐๆฎ็š„DataFrame + + Returns: + ๆทปๅŠ ไบ†ๆŠ€ๆœฏๆŒ‡ๆ ‡็š„DataFrame + """ + df = df.copy() + + # ไฝฟ็”จpandas_taๅบ“ + # RSI (14 periods) + df['rsi'] = ta.rsi(df['close'], length=14) + + # MACD + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + # pandas-ta ่ฟ”ๅ›ž็š„ๅˆ—ๅๅฏ่ƒฝไธๅŒ๏ผŒๅŠจๆ€่Žทๅ– + macd_cols = macd.columns.tolist() + if len(macd_cols) >= 3: + df['macd'] = macd.iloc[:, 0] # MACD็บฟ + df['macd_hist'] = macd.iloc[:, 1] # MACDๆŸฑ + df['macd_signal'] = macd.iloc[:, 2] # ไฟกๅท็บฟ + else: + # ๅฆ‚ๆžœๆ ผๅผไธๅฏน๏ผŒไฝฟ็”จNone + df['macd'] = None + df['macd_signal'] = None + df['macd_hist'] = None + else: + df['macd'] = None + df['macd_signal'] = None + df['macd_hist'] = None + + # Bollinger Bands + bbands = ta.bbands(df['close'], length=20) + if bbands is not None and not bbands.empty: + # pandas-ta ่ฟ”ๅ›ž็š„ๅˆ—ๅๅฏ่ƒฝไธๅŒ๏ผŒๅŠจๆ€่Žทๅ– + bb_cols = bbands.columns.tolist() + if len(bb_cols) >= 3: + df['bb_lower'] = bbands.iloc[:, 0] # ็ฌฌไธ€ๅˆ—ๆ˜ฏไธ‹่ฝจ + df['bb_middle'] = bbands.iloc[:, 1] # ็ฌฌไบŒๅˆ—ๆ˜ฏไธญ่ฝจ + df['bb_upper'] = bbands.iloc[:, 2] # ็ฌฌไธ‰ๅˆ—ๆ˜ฏไธŠ่ฝจ + df['bb_bandwidth'] = (df['bb_upper'] - df['bb_lower']) / (df['bb_middle'] + 1e-8) + else: + # ๅฆ‚ๆžœๆ ผๅผไธๅฏน๏ผŒๆ‰‹ๅŠจ่ฎก็ฎ— + sma = df['close'].rolling(window=20).mean() + std = df['close'].rolling(window=20).std() + df['bb_middle'] = sma + df['bb_upper'] = sma + (std * 2) + df['bb_lower'] = sma - (std * 2) + df['bb_bandwidth'] = (df['bb_upper'] - df['bb_lower']) / (df['bb_middle'] + 1e-8) + else: + # pandas-taไธๅฏ็”จ๏ผŒๆ‰‹ๅŠจ่ฎก็ฎ—ๅธƒๆž—ๅธฆ + sma = df['close'].rolling(window=20).mean() + std = df['close'].rolling(window=20).std() + df['bb_middle'] = sma + df['bb_upper'] = sma + (std * 2) + df['bb_lower'] = sma - (std * 2) + df['bb_bandwidth'] = (df['bb_upper'] - df['bb_lower']) / (df['bb_middle'] + 1e-8) + + # Volume indicators + df['volume_sma'] = ta.sma(df['volume'], length=20) + df['volume_ratio'] = df['volume'] / (df['volume_sma'] + 1e-8) + + # Price momentum + df['returns'] = df['close'].pct_change() + df['returns_5'] = df['close'].pct_change(5) + df['returns_10'] = df['close'].pct_change(10) + + # Volatility + df['volatility'] = df['returns'].rolling(window=20).std() + + return df + + def add_time_features(self, df: pd.DataFrame) -> pd.DataFrame: + """Add time-based features. + + Args: + df: DataFrame with timestamp column + + Returns: + DataFrame with added time features + """ + df = df.copy() + + df['hour'] = df['timestamp'].dt.hour + df['day_of_week'] = df['timestamp'].dt.dayofweek + df['is_weekend'] = (df['day_of_week'] >= 5).astype(int) + + # Cyclical encoding for hour + df['hour_sin'] = np.sin(2 * np.pi * df['hour'] / 24) + df['hour_cos'] = np.cos(2 * np.pi * df['hour'] / 24) + + # Cyclical encoding for day of week + df['dow_sin'] = np.sin(2 * np.pi * df['day_of_week'] / 7) + df['dow_cos'] = np.cos(2 * np.pi * df['day_of_week'] / 7) + + return df + + def create_labels( + self, + df: pd.DataFrame, + task: Literal['classification', 'regression'] + ) -> pd.DataFrame: + """Create target labels for classification or regression. + + Args: + df: DataFrame with price data + task: Task type ('classification' or 'regression') + + Returns: + DataFrame with added label column + """ + df = df.copy() + + # Calculate future returns + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['future_return'] = (df['future_price'] - df['close']) / df['close'] + + if task == 'classification': + # Binary classification: 1 if price increases above threshold, 0 otherwise + df['label'] = (df['future_return'] > self.price_change_threshold).astype(int) + else: # regression + # Regression: predict percentage return + df['label'] = df['future_return'] + + # Drop rows without labels (last forecast_horizon rows) + df = df[:-self.forecast_horizon].copy() + + return df + + def fit(self, df: pd.DataFrame) -> 'CryptoPreprocessor': + """Fit the scaler on training data. + + Args: + df: Training DataFrame with features + + Returns: + Self + """ + # Get feature columns (exclude timestamp and label) + exclude_cols = ['timestamp', 'label', 'future_price', 'future_return'] + self.feature_columns = [col for col in df.columns if col not in exclude_cols] + + # Fit scaler + self.scaler.fit(df[self.feature_columns].fillna(0)) + self.is_fitted = True + + return self + + def transform(self, df: pd.DataFrame) -> np.ndarray: + """Transform data using fitted scaler. + + Args: + df: DataFrame with features + + Returns: + Scaled feature array + """ + if not self.is_fitted: + raise ValueError("Preprocessor must be fitted before transform") + + # Fill NaN values + df_filled = df[self.feature_columns].fillna(0) + + # Scale features + scaled = self.scaler.transform(df_filled) + + return scaled + + def fit_transform(self, df: pd.DataFrame) -> np.ndarray: + """Fit and transform in one step. + + Args: + df: DataFrame with features + + Returns: + Scaled feature array + """ + return self.fit(df).transform(df) + + def create_sequences( + self, + features: np.ndarray, + labels: np.ndarray + ) -> Tuple[np.ndarray, np.ndarray]: + """Create sequences for time series prediction. + + Args: + features: Feature array (n_samples, n_features) + labels: Label array (n_samples,) + + Returns: + Tuple of (X, y) where X is (n_sequences, lookback, n_features) + and y is (n_sequences,) + """ + X, y = [], [] + + for i in range(len(features) - self.lookback): + X.append(features[i:i + self.lookback]) + y.append(labels[i + self.lookback]) + + return np.array(X), np.array(y) + + def preprocess_pipeline( + self, + df: pd.DataFrame, + task: Literal['classification', 'regression'], + fit: bool = True + ) -> Tuple[np.ndarray, np.ndarray, pd.DataFrame]: + """Full preprocessing pipeline. + + Args: + df: Raw OHLCV DataFrame + task: Task type + fit: Whether to fit the scaler (True for training data) + + Returns: + Tuple of (X, y, processed_df) where X is sequences, y is labels, + and processed_df is the DataFrame after feature engineering + """ + # Add features + df = self.add_technical_indicators(df) + df = self.add_time_features(df) + df = self.create_labels(df, task) + + # Drop initial NaN rows from indicators + df = df.dropna().reset_index(drop=True) + + # Scale features + if fit: + features = self.fit_transform(df) + else: + features = self.transform(df) + + # Get labels + labels = df['label'].values + + # Create sequences + X, y = self.create_sequences(features, labels) + + print(f"Created {len(X)} sequences with shape {X.shape}") + + return X, y, df + + +def split_data( + X: np.ndarray, + y: np.ndarray, + train_split: float = 0.7, + val_split: float = 0.15 +) -> Tuple[Tuple[np.ndarray, np.ndarray], ...]: + """Split data into train/val/test sets using time-based split. + + Args: + X: Feature sequences + y: Labels + train_split: Fraction for training + val_split: Fraction for validation + + Returns: + Tuple of ((X_train, y_train), (X_val, y_val), (X_test, y_test)) + """ + n = len(X) + train_end = int(n * train_split) + val_end = int(n * (train_split + val_split)) + + X_train, y_train = X[:train_end], y[:train_end] + X_val, y_val = X[train_end:val_end], y[train_end:val_end] + X_test, y_test = X[val_end:], y[val_end:] + + print(f"Train: {len(X_train)} samples") + print(f"Val: {len(X_val)} samples") + print(f"Test: {len(X_test)} samples") + + return (X_train, y_train), (X_val, y_val), (X_test, y_test) + + +if __name__ == "__main__": + # Test the preprocessor + from fetcher import BinanceDataFetcher + + # Fetch data + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h') + + # Preprocess for classification + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification') + + print(f"\nFeatures shape: {X.shape}") + print(f"Labels shape: {y.shape}") + print(f"Label distribution: {np.bincount(y.astype(int))}") + + # Split data + (X_train, y_train), (X_val, y_val), (X_test, y_test) = split_data(X, y) diff --git a/diagnose_bias.py b/diagnose_bias.py new file mode 100644 index 0000000..0e81e5b --- /dev/null +++ b/diagnose_bias.py @@ -0,0 +1,234 @@ +"""่ฏŠๆ–ญๆจกๅž‹ไธบไฝ•ๅ€พๅ‘้ข„ๆต‹ไธŠๆถจ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import numpy as np +import pandas as pd +from models.dlinear.model import DLinear +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders + +def analyze_bias(): + print("="*80) + print("ๅˆ†ๆžๆจกๅž‹้ข„ๆต‹ๅๅทฎ็š„ๅŽŸๅ› ") + print("="*80) + + # 1. ๅŠ ่ฝฝๆ•ฐๆฎ + print("\n[1/5] ๅŠ ่ฝฝๆ•ฐๆฎๅนถๅˆ†ๆžๆ ‡็ญพๅˆ†ๅธƒ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + + # ๅˆ†ๆžๅŽŸๅง‹ไปทๆ ผ่ถ‹ๅŠฟ + df['price_change'] = df['close'].pct_change() + df['future_1h'] = df['close'].shift(-1) + df['future_return_1h'] = (df['future_1h'] - df['close']) / df['close'] + + print(f"\n๐Ÿ“Š ๅŽŸๅง‹ๆ•ฐๆฎๅˆ†ๆž๏ผˆๆœ€่ฟ‘8760ๅฐๆ—ถ๏ผ‰:") + print(f" ๆ•ฐๆฎ่Œƒๅ›ด: {df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + print(f" BTC่ตทๅง‹ไปทๆ ผ: ${df['close'].iloc[0]:,.2f}") + print(f" BTC็ป“ๆŸไปทๆ ผ: ${df['close'].iloc[-1]:,.2f}") + total_return = (df['close'].iloc[-1] - df['close'].iloc[0]) / df['close'].iloc[0] + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {total_return*100:.2f}%") + + up_hours = (df['future_return_1h'] > 0).sum() + down_hours = (df['future_return_1h'] <= 0).sum() + total_hours = up_hours + down_hours + print(f"\n ๅฐๆ—ถK็บฟๆถจ่ทŒ็ปŸ่ฎก:") + print(f" ไธŠๆถจๅฐๆ—ถ: {up_hours}/{total_hours} ({up_hours/total_hours*100:.1f}%)") + print(f" ไธ‹่ทŒๅฐๆ—ถ: {down_hours}/{total_hours} ({down_hours/total_hours*100:.1f}%)") + + # 2. ้ข„ๅค„็†ๅนถๆŸฅ็œ‹่ฎญ็ปƒ้›†ๅˆ†ๅธƒ + print("\n[2/5] ๅˆ†ๆž่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›†็š„ๆ ‡็ญพๅˆ†ๅธƒ...") + preprocessor = CryptoPreprocessor( + lookback=168, + forecast_horizon=1, + price_change_threshold=0.0 + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + # ๅˆ†ๆžๆฏไธชๆ•ฐๆฎ้›†็š„ๆ ‡็ญพๅˆ†ๅธƒ + train_up = (train_data[1] == 1).sum() + train_down = (train_data[1] == 0).sum() + val_up = (val_data[1] == 1).sum() + val_down = (val_data[1] == 0).sum() + test_up = (test_data[1] == 1).sum() + test_down = (test_data[1] == 0).sum() + + print(f"\n ่ฎญ็ปƒ้›†ๆ ‡็ญพๅˆ†ๅธƒ:") + print(f" ไธŠๆถจ: {train_up}/{len(train_data[1])} ({train_up/len(train_data[1])*100:.1f}%)") + print(f" ไธ‹่ทŒ: {train_down}/{len(train_data[1])} ({train_down/len(train_data[1])*100:.1f}%)") + + print(f"\n ้ชŒ่ฏ้›†ๆ ‡็ญพๅˆ†ๅธƒ:") + print(f" ไธŠๆถจ: {val_up}/{len(val_data[1])} ({val_up/len(val_data[1])*100:.1f}%)") + print(f" ไธ‹่ทŒ: {val_down}/{len(val_data[1])} ({val_down/len(val_data[1])*100:.1f}%)") + + print(f"\n ๆต‹่ฏ•้›†ๆ ‡็ญพๅˆ†ๅธƒ:") + print(f" ไธŠๆถจ: {test_up}/{len(test_data[1])} ({test_up/len(test_data[1])*100:.1f}%)") + print(f" ไธ‹่ทŒ: {test_down}/{len(test_data[1])} ({test_down/len(test_data[1])*100:.1f}%)") + + # 3. ๅˆ†ๆž่ฎญ็ปƒ้›†ๅฏนๅบ”็š„ๆ—ถ้—ด่Œƒๅ›ด + print("\n[3/5] ๅˆ†ๆžๅ„ๆ•ฐๆฎ้›†็š„ๆ—ถ้—ด่Œƒๅ›ดๅ’Œไปทๆ ผ่ถ‹ๅŠฟ...") + + # ็”ฑไบŽๅบๅˆ—ๅˆ›ๅปบ๏ผŒ้œ€่ฆๅ็งปlookback + lookback = 168 + train_end_idx = int(len(processed_df) * 0.7) - lookback + val_end_idx = int(len(processed_df) * 0.85) - lookback + + train_df = processed_df.iloc[lookback:train_end_idx+lookback] + val_df = processed_df.iloc[train_end_idx+lookback:val_end_idx+lookback] + test_df = processed_df.iloc[val_end_idx+lookback:] + + print(f"\n ่ฎญ็ปƒ้›†:") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ไปทๆ ผๅ˜ๅŒ–: ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {train_return*100:.2f}%") + + print(f"\n ้ชŒ่ฏ้›†:") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ไปทๆ ผๅ˜ๅŒ–: ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {val_return*100:.2f}%") + + print(f"\n ๆต‹่ฏ•้›†:") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + test_return = (test_df['close'].iloc[-1] - test_df['close'].iloc[0]) / test_df['close'].iloc[0] + print(f" ไปทๆ ผๅ˜ๅŒ–: ${test_df['close'].iloc[0]:,.0f} โ†’ ${test_df['close'].iloc[-1]:,.0f}") + print(f" ๆ”ถ็›Š็Ž‡: {test_return*100:.2f}%") + + # 4. ๅŠ ่ฝฝๆจกๅž‹ๅนถๅˆ†ๆž่พ“ๅ‡บ + print("\n[4/5] ๅŠ ่ฝฝๆจกๅž‹ๅนถๅˆ†ๆž่พ“ๅ‡บๅˆ†ๅธƒ...") + model_path = './models/checkpoints/dlinear_btc_1h_forecast/best_model.pt' + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + # ๅˆ†ๆžๆต‹่ฏ•้›†่พ“ๅ‡บ + _, _, test_loader = create_dataloaders( + test_data, test_data, test_data, + task='classification', + batch_size=64 + ) + + all_logits = [] + all_labels = [] + + with torch.no_grad(): + for batch_X, batch_y in test_loader: + batch_X = batch_X.to(device) + outputs = model(batch_X).squeeze() + all_logits.extend(outputs.cpu().numpy().flatten()) + all_labels.extend(batch_y.numpy().flatten()) + + all_logits = np.array(all_logits) + all_labels = np.array(all_labels) + all_probs = 1 / (1 + np.exp(-all_logits)) # sigmoid + + print(f"\n ๆจกๅž‹่พ“ๅ‡บ็ปŸ่ฎก:") + print(f" Logitsๅ‡ๅ€ผ: {all_logits.mean():.6f}") + print(f" Logitsๆ ‡ๅ‡†ๅทฎ: {all_logits.std():.6f}") + print(f" Logitsไธญไฝๆ•ฐ: {np.median(all_logits):.6f}") + print(f" ๆฆ‚็Ž‡ๅ‡ๅ€ผ: {all_probs.mean():.6f}") + + # ๆŒ‰็œŸๅฎžๆ ‡็ญพๅˆ†็ป„ๅˆ†ๆž + logits_when_up = all_logits[all_labels == 1] + logits_when_down = all_logits[all_labels == 0] + + print(f"\n ๆŒ‰็œŸๅฎžๆ ‡็ญพๅˆ†็ป„:") + print(f" ็œŸๅฎžไธŠๆถจๆ—ถ๏ผŒๅนณๅ‡logit: {logits_when_up.mean():.6f}") + print(f" ็œŸๅฎžไธ‹่ทŒๆ—ถ๏ผŒๅนณๅ‡logit: {logits_when_down.mean():.6f}") + print(f" ๅทฎๅ€ผ: {logits_when_up.mean() - logits_when_down.mean():.6f}") + + # 5. ๅˆ†ๆžไธบไป€ไนˆๅๅ‘ไธŠๆถจ + print("\n[5/5] ๅˆ†ๆž้ข„ๆต‹ๅๅทฎ็š„ๆ นๆœฌๅŽŸๅ› ...") + print("\n" + "="*80) + print("๐Ÿ” ๆ นๆœฌๅŽŸๅ› ๅˆ†ๆž") + print("="*80) + + # ๅŽŸๅ› 1: ๆ•ฐๆฎ่ถ‹ๅŠฟ + if total_return > 0.1: + print(f"\nโœ… ๅŽŸๅ› 1: ่ฎญ็ปƒๆ•ฐๆฎๅค„ไบŽไธŠๆถจ่ถ‹ๅŠฟ") + print(f" - ๆ•ดไฝ“ๆ”ถ็›Š็Ž‡: {total_return*100:.2f}%") + print(f" - ่ฎญ็ปƒ้›†ๆ”ถ็›Š็Ž‡: {train_return*100:.2f}%") + print(f" - ๆจกๅž‹ๅญฆไน ๅˆฐไบ†'็‰›ๅธ‚ๅๅฅฝ'") + elif total_return < -0.1: + print(f"\nโš ๏ธ ๅŽŸๅ› 1: ่ฎญ็ปƒๆ•ฐๆฎๅค„ไบŽไธ‹่ทŒ่ถ‹ๅŠฟ") + print(f" - ๆ•ดไฝ“ๆ”ถ็›Š็Ž‡: {total_return*100:.2f}%") + else: + print(f"\nโšช ๅŽŸๅ› 1: ่ฎญ็ปƒๆ•ฐๆฎ่ถ‹ๅŠฟไธญๆ€ง") + print(f" - ๆ•ดไฝ“ๆ”ถ็›Š็Ž‡: {total_return*100:.2f}%") + + # ๅŽŸๅ› 2: ็ฑปๅˆซไธๅนณ่กก + if train_up > train_down * 1.05: + print(f"\nโœ… ๅŽŸๅ› 2: ่ฎญ็ปƒ้›†ๆ ‡็ญพไธๅนณ่กก") + print(f" - ไธŠๆถจๆ ทๆœฌ: {train_up} ({train_up/len(train_data[1])*100:.1f}%)") + print(f" - ไธ‹่ทŒๆ ทๆœฌ: {train_down} ({train_down/len(train_data[1])*100:.1f}%)") + print(f" - ไธๅนณ่กกๆฏ”ไพ‹: {train_up/train_down:.2f}:1") + else: + print(f"\nโšช ๅŽŸๅ› 2: ่ฎญ็ปƒ้›†ๆ ‡็ญพๅŸบๆœฌๅนณ่กก") + print(f" - ไธŠๆถจ/ไธ‹่ทŒๆฏ”ไพ‹: {train_up/train_down:.2f}:1") + + # ๅŽŸๅ› 3: ๆจกๅž‹่พ“ๅ‡บๅๅทฎ + if all_logits.mean() > 0.01: + print(f"\nโœ… ๅŽŸๅ› 3: ๆจกๅž‹่พ“ๅ‡บๅญ˜ๅœจๆญฃๅๅทฎ") + print(f" - ๅนณๅ‡logit: {all_logits.mean():.6f} > 0") + print(f" - ๅนณๅ‡ๆฆ‚็Ž‡: {all_probs.mean():.6f} > 0.5") + print(f" - ่ฟ™ๅฏผ่‡ดๆ›ดๅคšๆ ทๆœฌ่ขซ้ข„ๆต‹ไธบไธŠๆถจ") + elif all_logits.mean() < -0.01: + print(f"\nโš ๏ธ ๅŽŸๅ› 3: ๆจกๅž‹่พ“ๅ‡บๅญ˜ๅœจ่ดŸๅๅทฎ") + print(f" - ๅนณๅ‡logit: {all_logits.mean():.6f} < 0") + else: + print(f"\nโšช ๅŽŸๅ› 3: ๆจกๅž‹่พ“ๅ‡บๅŸบๆœฌๆ— ๅ") + print(f" - ๅนณๅ‡logit: {all_logits.mean():.6f} โ‰ˆ 0") + + # ๅŽŸๅ› 4: ้˜ˆๅ€ผ้—ฎ้ข˜ + print(f"\nโšช ๅŽŸๅ› 4: ๅ†ณ็ญ–้˜ˆๅ€ผ") + print(f" - ๅฝ“ๅ‰้˜ˆๅ€ผ: 0.5") + print(f" - ๅนณๅ‡ๆฆ‚็Ž‡: {all_probs.mean():.6f}") + if all_probs.mean() > 0.5: + print(f" - ๅ› ไธบๅนณๅ‡ๆฆ‚็Ž‡>0.5๏ผŒๅฏผ่‡ดๅคšๆ•ฐๆ ทๆœฌ่ขซ้ข„ๆต‹ไธบไธŠๆถจ") + + # ่ฎก็ฎ—ๆœ€ไผ˜้˜ˆๅ€ผ + from sklearn.metrics import f1_score + best_threshold = 0.5 + best_f1 = 0 + for threshold in np.arange(0.3, 0.7, 0.01): + preds = (all_probs > threshold).astype(int) + f1 = f1_score(all_labels, preds) + if f1 > best_f1: + best_f1 = f1 + best_threshold = threshold + + print(f"\n๐Ÿ’ก ๅปบ่ฎฎ่ฐƒๆ•ด้˜ˆๅ€ผ:") + print(f" - ๆœ€ไผ˜้˜ˆๅ€ผ: {best_threshold:.3f} (F1={best_f1:.4f})") + print(f" - ๅฝ“ๅ‰้˜ˆๅ€ผ: 0.500 (F1={f1_score(all_labels, (all_probs>0.5).astype(int)):.4f})") + + print("\n" + "="*80) + print("๐Ÿ“Œ ๆ€ป็ป“") + print("="*80) + print(f"\nๆจกๅž‹้ข„ๆต‹ไธŠๆถจ็š„ๆฏ”ไพ‹: {(all_probs > 0.5).sum()}/{len(all_probs)} ({(all_probs>0.5).mean()*100:.1f}%)") + print(f"ไธป่ฆๅŽŸๅ› :") + if total_return > 0.1: + print(f" 1. โœ… ่ฎญ็ปƒๆ•ฐๆฎๅค„ไบŽไธŠๆถจ่ถ‹ๅŠฟ ({total_return*100:.1f}%)") + if train_up > train_down * 1.05: + print(f" 2. โœ… ่ฎญ็ปƒ้›†ไธŠๆถจๆ ทๆœฌๆ›ดๅคš ({train_up/train_down:.2f}:1)") + if all_logits.mean() > 0.01: + print(f" 3. โœ… ๆจกๅž‹ๅญฆไน ๅˆฐไบ†ไธŠๆถจๅๅฅฝ (ๅนณๅ‡logit={all_logits.mean():.4f})") + + print(f"\n่ฟ™ๆ˜ฏๆญฃๅธธ็Žฐ่ฑก๏ผŒๅ› ไธบ:") + print(f" - ๅฆ‚ๆžœ่ฎญ็ปƒๆœŸ้—ดBTCๆ•ดไฝ“ไธŠๆถจ๏ผŒๆจกๅž‹ไผšๅญฆไน ๅˆฐ'ไธŠๆถจๆ›ดๅฏ่ƒฝ'") + print(f" - ่ฟ™็ฑปไผผไบŽ'ๅœจ็‰›ๅธ‚่ฎญ็ปƒ็š„ๆจกๅž‹ไผšๆ›ดไน่ง‚'") + print(f" - ่งฃๅ†ณๆ–นๆกˆ๏ผšไฝฟ็”จๆ›ด้•ฟ็š„่ฎญ็ปƒๆ•ฐๆฎ๏ผˆๅŒ…ๅซ็‰›ๅธ‚ๅ’Œ็†Šๅธ‚๏ผ‰") + +if __name__ == "__main__": + analyze_bias() diff --git a/diagnose_model.py b/diagnose_model.py new file mode 100644 index 0000000..089779e --- /dev/null +++ b/diagnose_model.py @@ -0,0 +1,177 @@ +"""่ฏŠๆ–ญๆจกๅž‹้ข„ๆต‹ๅๅทฎ้—ฎ้ข˜""" + +import torch +import numpy as np +from models.dlinear.model import DLinear, DLinearConfig +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +import matplotlib +matplotlib.use('Agg') +import matplotlib.pyplot as plt + +def diagnose_model(): + """่ฏŠๆ–ญๆจกๅž‹่พ“ๅ‡บๅˆ†ๅธƒๅ’ŒๆŸๅคฑๅ‡ฝๆ•ฐ้—ฎ้ข˜""" + + print("="*80) + print("ๆจกๅž‹่ฏŠๆ–ญๆŠฅๅ‘Š") + print("="*80) + + # 1. ๅŠ ่ฝฝๅทฒ่ฎญ็ปƒ็š„ๆจกๅž‹ + print("\n[1/5] ๅŠ ่ฝฝๅทฒ่ฎญ็ปƒๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_btc_1h_balanced/best_model.pt' + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + config = checkpoint['config'] + + model = DLinear(config) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + print(f"โœ“ ๆจกๅž‹ๅทฒๅŠ ่ฝฝๅˆฐ่ฎพๅค‡: {device}") + print(f"โœ“ ๆจกๅž‹้…็ฝฎ: task={config.task}, input_dim={config.input_dim}") + + # 2. ๅ‡†ๅค‡ๆต‹่ฏ•ๆ•ฐๆฎ + print("\n[2/5] ๅ‡†ๅค‡ๆต‹่ฏ•ๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24, price_change_threshold=0.0) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + + _, _, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + _, _, test_loader = create_dataloaders(test_data, test_data, test_data, batch_size=64) + + # 3. ๅˆ†ๆžๆจกๅž‹่พ“ๅ‡บ + print("\n[3/5] ๅˆ†ๆžๆจกๅž‹ๅŽŸๅง‹่พ“ๅ‡บ...") + all_outputs = [] + all_labels = [] + + with torch.no_grad(): + for batch_X, batch_y in test_loader: + batch_X = batch_X.to(device) + outputs = model(batch_X).squeeze() + + all_outputs.extend(outputs.cpu().numpy().flatten()) + all_labels.extend(batch_y.numpy().flatten()) + + all_outputs = np.array(all_outputs) + all_labels = np.array(all_labels) + + print(f"\n๐Ÿ“Š ๆจกๅž‹่พ“ๅ‡บ็ปŸ่ฎก๏ผˆ็ป่ฟ‡Sigmoid๏ผ‰:") + print(f" ๆœ€ๅฐๅ€ผ: {all_outputs.min():.6f}") + print(f" ๆœ€ๅคงๅ€ผ: {all_outputs.max():.6f}") + print(f" ๅ‡ๅ€ผ: {all_outputs.mean():.6f}") + print(f" ไธญไฝๆ•ฐ: {np.median(all_outputs):.6f}") + print(f" ๆ ‡ๅ‡†ๅทฎ: {all_outputs.std():.6f}") + print(f" > 0.5 ็š„ๆฏ”ไพ‹: {(all_outputs > 0.5).mean()*100:.2f}%") + print(f" > 0.4 ็š„ๆฏ”ไพ‹: {(all_outputs > 0.4).mean()*100:.2f}%") + print(f" > 0.3 ็š„ๆฏ”ไพ‹: {(all_outputs > 0.3).mean()*100:.2f}%") + print(f" > 0.2 ็š„ๆฏ”ไพ‹: {(all_outputs > 0.2).mean()*100:.2f}%") + print(f" > 0.1 ็š„ๆฏ”ไพ‹: {(all_outputs > 0.1).mean()*100:.2f}%") + + print(f"\n๐Ÿ“Š ็œŸๅฎžๆ ‡็ญพๅˆ†ๅธƒ:") + print(f" ไธ‹่ทŒ(0): {(all_labels == 0).sum()} ({(all_labels == 0).mean()*100:.1f}%)") + print(f" ไธŠๆถจ(1): {(all_labels == 1).sum()} ({(all_labels == 1).mean()*100:.1f}%)") + + # 4. ๆฃ€ๆŸฅๆŸๅคฑๅ‡ฝๆ•ฐ้—ฎ้ข˜ + print("\n[4/5] ๆฃ€ๆŸฅๆŸๅคฑๅ‡ฝๆ•ฐๅ…ผๅฎนๆ€ง...") + print("\nโš ๏ธ ๅ‘็Žฐ้—ฎ้ข˜๏ผš") + print(" ๆจกๅž‹ไฝฟ็”จ: nn.Sigmoid() ไฝœไธบ่พ“ๅ‡บๆฟ€ๆดปๅ‡ฝๆ•ฐ") + print(" ๅฝ“ๅ‰ๆŸๅคฑๅ‡ฝๆ•ฐ: BCEWithLogitsLoss (ๆœŸๆœ›logits่พ“ๅ…ฅ)") + print("\n๐Ÿ”ด ่ฟ™ๅฏผ่‡ดไบ†ใ€ๅŒ้‡Sigmoid้—ฎ้ข˜ใ€‘:") + print(" 1. ๆจกๅž‹่พ“ๅ‡บๅฑ‚: output = sigmoid(logits)") + print(" 2. ๆŸๅคฑๅ‡ฝๆ•ฐๅ†…้ƒจ: sigmoid(output) = sigmoid(sigmoid(logits))") + print(" 3. ็ป“ๆžœ: ่พ“ๅ‡บ่ขซ่ฟ‡ๅบฆๅŽ‹็ผฉๅˆฐๆŽฅ่ฟ‘0๏ผŒๆขฏๅบฆๆถˆๅคฑ") + + # ้ชŒ่ฏๅŒ้‡sigmoidๆ•ˆๆžœ + print("\n๐Ÿงช ้ชŒ่ฏๅŒ้‡Sigmoidๆ•ˆๆžœ:") + test_logits = np.array([-2, -1, 0, 1, 2]) + single_sigmoid = 1 / (1 + np.exp(-test_logits)) + double_sigmoid = 1 / (1 + np.exp(-single_sigmoid)) + + print(" ๅŽŸๅง‹logits: ", test_logits) + print(" ๅ•ๆฌกsigmoid: ", np.round(single_sigmoid, 4)) + print(" ๅŒ้‡sigmoid: ", np.round(double_sigmoid, 4)) + print(" โ†’ ๅŒ้‡sigmoidๅŽ๏ผŒๆ‰€ๆœ‰ๅ€ผ้ƒฝๆŽฅ่ฟ‘0.5๏ผˆๅคฑๅŽปๅŒบๅˆ†ๅบฆ๏ผ‰") + + # 5. ๅปบ่ฎฎไฟฎๅคๆ–นๆกˆ + print("\n[5/5] ไฟฎๅคๆ–นๆกˆ:") + print("\nโœ… ๆ–นๆกˆ1๏ผˆๆŽจ่๏ผ‰๏ผš็งป้™คๆจกๅž‹่พ“ๅ‡บๅฑ‚็š„Sigmoid") + print(" - ไฟฎๆ”น models/dlinear/model.py:128") + print(" - ๅฐ† self.output_activation = nn.Sigmoid() ๆ”นไธบ nn.Identity()") + print(" - ไฟๆŒๆŸๅคฑๅ‡ฝๆ•ฐไธบ BCEWithLogitsLoss") + + print("\nโœ… ๆ–นๆกˆ2๏ผšๆ›ดๆขๆŸๅคฑๅ‡ฝๆ•ฐ") + print(" - ไฟฎๆ”น models/base.py:74") + print(" - ๅฐ† BCEWithLogitsLoss ๆ”นไธบ BCELoss") + print(" - ไฟๆŒๆจกๅž‹่พ“ๅ‡บๅฑ‚็š„ Sigmoid") + + print("\n๐Ÿ“Œ ๅ…ถไป–ๅ‘็Žฐ:") + print(f" - ๆจกๅž‹ๅนณๅ‡่พ“ๅ‡บ {all_outputs.mean():.1%}๏ผŒ่ฟœไฝŽไบŽๆœŸๆœ›็š„50%") + print(f" - ๅ‡ ไนŽๆฒกๆœ‰่พ“ๅ‡บ>0.5๏ผˆ{(all_outputs>0.5).sum()}ไธช๏ผ‰") + print(f" - ่ฟ™่งฃ้‡Šไบ†ไธบไป€ไนˆๆจกๅž‹ไปŽไธ้ข„ๆต‹ไธŠๆถจ") + + # 6. ็”Ÿๆˆๅฏ่ง†ๅŒ– + print("\n[6/5] ็”Ÿๆˆ่พ“ๅ‡บๅˆ†ๅธƒๅ›พ...") + fig, axes = plt.subplots(2, 2, figsize=(12, 10)) + + # ่พ“ๅ‡บ็›ดๆ–นๅ›พ + axes[0, 0].hist(all_outputs, bins=50, alpha=0.7, edgecolor='black') + axes[0, 0].axvline(0.5, color='red', linestyle='--', label='ๅ†ณ็ญ–้˜ˆๅ€ผ=0.5') + axes[0, 0].set_xlabel('ๆจกๅž‹่พ“ๅ‡บ๏ผˆ็ป่ฟ‡Sigmoid๏ผ‰') + axes[0, 0].set_ylabel('้ข‘ๆ•ฐ') + axes[0, 0].set_title('ๆจกๅž‹่พ“ๅ‡บๅˆ†ๅธƒ๏ผˆๅŒ้‡Sigmoid้—ฎ้ข˜๏ผ‰') + axes[0, 0].legend() + axes[0, 0].grid(alpha=0.3) + + # ๆŒ‰็œŸๅฎžๆ ‡็ญพๅˆ†็ป„็š„่พ“ๅ‡บๅˆ†ๅธƒ + outputs_down = all_outputs[all_labels == 0] + outputs_up = all_outputs[all_labels == 1] + axes[0, 1].hist([outputs_down, outputs_up], bins=30, alpha=0.6, + label=['็œŸๅฎžไธ‹่ทŒ', '็œŸๅฎžไธŠๆถจ'], edgecolor='black') + axes[0, 1].axvline(0.5, color='red', linestyle='--', label='ๅ†ณ็ญ–้˜ˆๅ€ผ') + axes[0, 1].set_xlabel('ๆจกๅž‹่พ“ๅ‡บ') + axes[0, 1].set_ylabel('้ข‘ๆ•ฐ') + axes[0, 1].set_title('ๆŒ‰็œŸๅฎžๆ ‡็ญพๅˆ†็ป„็š„่พ“ๅ‡บๅˆ†ๅธƒ') + axes[0, 1].legend() + axes[0, 1].grid(alpha=0.3) + + # CDF๏ผˆ็ดฏ็งฏๅˆ†ๅธƒ๏ผ‰ + sorted_outputs = np.sort(all_outputs) + cdf = np.arange(1, len(sorted_outputs)+1) / len(sorted_outputs) + axes[1, 0].plot(sorted_outputs, cdf, linewidth=2) + axes[1, 0].axvline(0.5, color='red', linestyle='--', label='ๅ†ณ็ญ–้˜ˆๅ€ผ=0.5') + axes[1, 0].axhline(0.5, color='green', linestyle='--', alpha=0.5) + axes[1, 0].set_xlabel('ๆจกๅž‹่พ“ๅ‡บ') + axes[1, 0].set_ylabel('็ดฏ็งฏๆฆ‚็Ž‡') + axes[1, 0].set_title('่พ“ๅ‡บ็ดฏ็งฏๅˆ†ๅธƒๅ‡ฝๆ•ฐ๏ผˆCDF๏ผ‰') + axes[1, 0].legend() + axes[1, 0].grid(alpha=0.3) + + # ๅŒ้‡sigmoidๆ•ˆๆžœๆผ”็คบ + x = np.linspace(-5, 5, 100) + sigmoid_1 = 1 / (1 + np.exp(-x)) + sigmoid_2 = 1 / (1 + np.exp(-sigmoid_1)) + axes[1, 1].plot(x, sigmoid_1, label='ๅ•ๆฌกSigmoid', linewidth=2) + axes[1, 1].plot(x, sigmoid_2, label='ๅŒ้‡Sigmoid', linewidth=2, linestyle='--') + axes[1, 1].axhline(0.5, color='red', linestyle=':', alpha=0.5, label='ๅ†ณ็ญ–้˜ˆๅ€ผ') + axes[1, 1].set_xlabel('่พ“ๅ…ฅ๏ผˆlogits๏ผ‰') + axes[1, 1].set_ylabel('่พ“ๅ‡บ') + axes[1, 1].set_title('ๅŒ้‡Sigmoidๆ•ˆๆžœๅฏนๆฏ”') + axes[1, 1].legend() + axes[1, 1].grid(alpha=0.3) + + plt.tight_layout() + output_path = 'model_diagnosis.png' + plt.savefig(output_path, dpi=150, bbox_inches='tight') + print(f"โœ“ ๅฏ่ง†ๅŒ–ๅทฒไฟๅญ˜่‡ณ: {output_path}") + + print("\n" + "="*80) + print("่ฏŠๆ–ญๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + diagnose_model() diff --git a/diagnose_simple.py b/diagnose_simple.py new file mode 100644 index 0000000..41f825b --- /dev/null +++ b/diagnose_simple.py @@ -0,0 +1,134 @@ +"""็ฎ€ๅŒ–็‰ˆๆจกๅž‹่ฏŠๆ–ญ๏ผˆๆ— ้œ€matplotlib๏ผ‰""" + +import torch +import numpy as np +from models.dlinear.model import DLinear, DLinearConfig +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders + +def diagnose(): + print("="*80) + print("๐Ÿ” ๆจกๅž‹้ข„ๆต‹ๅๅทฎ่ฏŠๆ–ญๆŠฅๅ‘Š") + print("="*80) + + # ๅŠ ่ฝฝๆจกๅž‹ + print("\n[1/4] ๅŠ ่ฝฝๅทฒ่ฎญ็ปƒๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_btc_1h_balanced/best_model.pt' + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + + config = checkpoint['config'] + model = DLinear(config) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + print(f"โœ“ ๆจกๅž‹้…็ฝฎ: task={config.task}, hidden_dim={config.hidden_dim}") + + # ๅ‡†ๅค‡ๆ•ฐๆฎ + print("\n[2/4] ๅŠ ่ฝฝๆต‹่ฏ•ๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24, price_change_threshold=0.0) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + _, _, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + _, _, test_loader = create_dataloaders(test_data, test_data, test_data, batch_size=64) + + # ๆ”ถ้›†่พ“ๅ‡บ + print("\n[3/4] ๅˆ†ๆžๆจกๅž‹่พ“ๅ‡บ...") + all_outputs = [] + all_labels = [] + + with torch.no_grad(): + for batch_X, batch_y in test_loader: + batch_X = batch_X.to(device) + outputs = model(batch_X).squeeze() + all_outputs.extend(outputs.cpu().numpy().flatten()) + all_labels.extend(batch_y.numpy().flatten()) + + all_outputs = np.array(all_outputs) + all_labels = np.array(all_labels) + + # ็ปŸ่ฎกๅˆ†ๆž + print("\n" + "="*80) + print("๐Ÿ“Š ๅ…ณ้”ฎๅ‘็Žฐ") + print("="*80) + + print(f"\n1๏ธโƒฃ ๆจกๅž‹่พ“ๅ‡บ็ปŸ่ฎก๏ผˆๅทฒ็ป่ฟ‡Sigmoid๏ผ‰:") + print(f" ๆœ€ๅฐๅ€ผ: {all_outputs.min():.6f}") + print(f" ๆœ€ๅคงๅ€ผ: {all_outputs.max():.6f}") + print(f" ๅ‡ๅ€ผ: {all_outputs.mean():.6f} โ† ๅบ”่ฏฅๆŽฅ่ฟ‘0.5") + print(f" ไธญไฝๆ•ฐ: {np.median(all_outputs):.6f}") + print(f" ๆ ‡ๅ‡†ๅทฎ: {all_outputs.std():.6f}") + + print(f"\n2๏ธโƒฃ ้ข„ๆต‹้˜ˆๅ€ผๅˆ†ๆž:") + for threshold in [0.5, 0.4, 0.3, 0.2, 0.1]: + count = (all_outputs > threshold).sum() + pct = (all_outputs > threshold).mean() * 100 + print(f" ่พ“ๅ‡บ > {threshold}: {count:4d} ไธช ({pct:5.2f}%)") + + print(f"\n3๏ธโƒฃ ็œŸๅฎžๆ ‡็ญพๅˆ†ๅธƒ:") + n_down = (all_labels == 0).sum() + n_up = (all_labels == 1).sum() + print(f" ไธ‹่ทŒ(0): {n_down} ({n_down/len(all_labels)*100:.1f}%)") + print(f" ไธŠๆถจ(1): {n_up} ({n_up/len(all_labels)*100:.1f}%)") + + # ้ชŒ่ฏๅŒ้‡sigmoid้—ฎ้ข˜ + print("\n" + "="*80) + print("๐Ÿ”ด ้—ฎ้ข˜่ฏŠๆ–ญ๏ผšๅŒ้‡Sigmoid Bug") + print("="*80) + + print("\n๐Ÿ“‹ ๅฝ“ๅ‰ๆžถๆž„:") + print(" ๆจกๅž‹่พ“ๅ‡บๅฑ‚: self.output_activation = nn.Sigmoid() (models/dlinear/model.py:128)") + print(" ๆŸๅคฑๅ‡ฝๆ•ฐ: BCEWithLogitsLoss() (models/base.py:74)") + + print("\nโš ๏ธ ้—ฎ้ข˜:") + print(" BCEWithLogitsLoss ๅ†…้ƒจๅŒ…ๅซ Sigmoid๏ผŒๆœŸๆœ›่พ“ๅ…ฅๆ˜ฏ logits๏ผˆๆœชๆฟ€ๆดป๏ผ‰") + print(" ไฝ†ๆจกๅž‹ๅทฒ็ป่พ“ๅ‡บไบ† sigmoid(logits)") + print(" โ†’ ๆŸๅคฑๅ‡ฝๆ•ฐๅ†ๆฌกๅบ”็”จ: sigmoid(sigmoid(logits)) โ† ๅŒ้‡ๆฟ€ๆดป๏ผ") + + print("\n๐Ÿงช ๅŒ้‡Sigmoidๆ•ˆๆžœๆผ”็คบ:") + test_logits = np.array([-3, -1, 0, 1, 3]) + single = 1 / (1 + np.exp(-test_logits)) + double = 1 / (1 + np.exp(-single)) + + print(f" ๅŽŸๅง‹logits: {test_logits}") + print(f" ๅ•ๆฌกsigmoid: {np.round(single, 4)}") + print(f" ๅŒ้‡sigmoid: {np.round(double, 4)} โ† ๅ…จ้ƒจๅŽ‹็ผฉๅˆฐ~0.5") + + print("\n๐Ÿ’ฅ ๅŽๆžœ:") + print(f" - ๆจกๅž‹่พ“ๅ‡บๅ‡ๅ€ผไป… {all_outputs.mean():.1%}๏ผˆๆœŸๆœ›~50%๏ผ‰") + print(f" - {(all_outputs>0.5).sum()} ไธชๆ ทๆœฌ่พ“ๅ‡บ>0.5๏ผˆๅ…ฑ{len(all_outputs)}ไธช๏ผ‰") + print(f" - ๆจกๅž‹ๆฐธ่ฟœ้ข„ๆต‹็ฑปๅˆซ0๏ผˆไธ‹่ทŒ๏ผ‰๏ผŒๅ› ไธบๆฒกๆœ‰่พ“ๅ‡บ่ถ…่ฟ‡้˜ˆๅ€ผ0.5") + print(f" - ๆขฏๅบฆๆถˆๅคฑ๏ผŒๆจกๅž‹ๆ— ๆณ•ๆœ‰ๆ•ˆๅญฆไน ") + + # ่งฃๅ†ณๆ–นๆกˆ + print("\n" + "="*80) + print("โœ… ไฟฎๅคๆ–นๆกˆ") + print("="*80) + + print("\nๆ–นๆกˆ1๏ผˆๆŽจ่๏ผ‰๏ผš็งป้™คๆจกๅž‹็š„Sigmoid่พ“ๅ‡บ") + print(" ๆ–‡ไปถ: models/dlinear/model.py") + print(" ไฝ็ฝฎ: ็ฌฌ127-130่กŒ") + print(" ไฟฎๆ”นๅ‰: if config.task == 'classification':") + print(" self.output_activation = nn.Sigmoid()") + print(" ไฟฎๆ”นๅŽ: if config.task == 'classification':") + print(" self.output_activation = nn.Identity() # ่พ“ๅ‡บlogits") + print(" ่ฏดๆ˜Ž: ไฟๆŒๆŸๅคฑๅ‡ฝๆ•ฐไธบBCEWithLogitsLoss") + + print("\nๆ–นๆกˆ2๏ผšๆ›ดๆขๆŸๅคฑๅ‡ฝๆ•ฐ๏ผˆไธๆŽจ่๏ผ‰") + print(" ๆ–‡ไปถ: models/base.py") + print(" ไฝ็ฝฎ: ็ฌฌ70-76่กŒ") + print(" ไฟฎๆ”น: ๅฐ† BCEWithLogitsLoss ๆ”นไธบ BCELoss") + print(" ่ฏดๆ˜Ž: ไฟๆŒๆจกๅž‹่พ“ๅ‡บSigmoid๏ผŒไฝ†BCELossๆ•ฐๅ€ผ็จณๅฎšๆ€ง่พƒๅทฎ") + + print("\n" + "="*80) + print("๐Ÿ“Œ ็ป“่ฎบ") + print("="*80) + print("โœ“ ้ข„ๆต‹ๅๅทฎ็š„ๆ นๆœฌๅŽŸๅ› ๆ˜ฏใ€ๅŒ้‡Sigmoid Bugใ€‘") + print("โœ“ ไธŽๆ•ฐๆฎๅค„็†ใ€็ฑปๅˆซๅนณ่กกใ€็‰นๅพๅทฅ็จ‹ๆ— ๅ…ณ") + print("โœ“ ไฟฎๅคๅŽ้œ€่ฆ้‡ๆ–ฐ่ฎญ็ปƒๆจกๅž‹") + print("="*80) + +if __name__ == "__main__": + diagnose() diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..b8c2306 --- /dev/null +++ b/environment.yml @@ -0,0 +1,63 @@ +name: crypto_pred +channels: + - pytorch + - conda-forge + - defaults +dependencies: + # Python + - python=3.10 + + # PyTorch (Mac M1 ๆ”ฏๆŒ) + - pytorch + - torchvision + - torchaudio + + # ๆ•ฐๆฎๅค„็† + - pandas>=2.0.0 + - numpy>=1.24.0 + - scikit-learn>=1.3.0 + + # ๅผ€ๅ‘ๅทฅๅ…ท + - jupyter + - ipython + - tqdm + + # ๅฏ่ง†ๅŒ– + - matplotlib + - seaborn + + # ้€š่ฟ‡pipๅฎ‰่ฃ…็š„ๅŒ… + - pip + - pip: + # Binance API + - python-binance>=1.0.19 + + # ็Žฏๅขƒๅ˜้‡ + - python-dotenv>=1.0.0 + + # ๆ—ถๅŒบๅค„็† + - pytz + + # ONNX + - onnx>=1.14.0 + - onnxruntime>=1.15.0 + + # ๆŠ€ๆœฏๆŒ‡ๆ ‡ + - pandas-ta>=0.3.14b + + # ๆจกๅž‹ๅบ“ + - darts>=0.27.0 + - u8darts[torch]>=0.27.0 + - tsfm_public>=0.2.0 + - gluonts[torch]>=0.14.0 + + # FastAPI + - fastapi>=0.104.0 + - uvicorn[standard]>=0.24.0 + - pydantic>=2.0.0 + - python-multipart>=0.0.6 + + # ๆต‹่ฏ• + - pytest>=7.4.0 + - black>=23.0.0 + - flake8>=6.0.0 diff --git a/evaluate_fixed.py b/evaluate_fixed.py new file mode 100644 index 0000000..f2949a0 --- /dev/null +++ b/evaluate_fixed.py @@ -0,0 +1,180 @@ +"""้‡ๆ–ฐ่ฏ„ไผฐๅทฒ่ฎญ็ปƒๆจกๅž‹๏ผˆไฝฟ็”จไฟฎๅคๅŽ็š„evaluator๏ผ‰""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import numpy as np +from models.dlinear.model import DLinear +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from training.evaluator import evaluate_model +import json + +def main(): + print("="*80) + print("้‡ๆ–ฐ่ฏ„ไผฐๆจกๅž‹๏ผˆๅทฒไฟฎๅคSigmoid Bug๏ผ‰") + print("="*80) + + # ๅŠ ่ฝฝๆจกๅž‹ + print("\n[1/4] ๅŠ ่ฝฝๅทฒ่ฎญ็ปƒ็š„ๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_btc_1h_forecast/best_model.pt' + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + config = checkpoint['config'] + + model = DLinear(config) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + print(f"โœ“ ๆจกๅž‹ๅทฒๅŠ ่ฝฝ: {model_path}") + print(f"โœ“ ่ฎพๅค‡: {device}") + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,}") + + # ๅ‡†ๅค‡ๆต‹่ฏ•ๆ•ฐๆฎ + print("\n[2/4] ๅ‡†ๅค‡ๆต‹่ฏ•ๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + + preprocessor = CryptoPreprocessor( + lookback=168, + forecast_horizon=1, # ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ + price_change_threshold=0.0 + ) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + + _, _, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + _, _, test_loader = create_dataloaders( + test_data, test_data, test_data, + task='classification', + batch_size=64 + ) + + print(f"โœ“ ๆต‹่ฏ•้›†ๅคงๅฐ: {len(test_data[0])} ๆ ทๆœฌ") + print(f"โœ“ ็œŸๅฎžๆ ‡็ญพๅˆ†ๅธƒ: ไธ‹่ทŒ={np.sum(test_data[1]==0)}, ไธŠๆถจ={np.sum(test_data[1]==1)}") + + # ๅ…ˆๆŸฅ็œ‹ๆจกๅž‹่พ“ๅ‡บๅˆ†ๅธƒ + print("\n[3/4] ๅˆ†ๆžๆจกๅž‹่พ“ๅ‡บๅˆ†ๅธƒ...") + all_logits = [] + all_probs = [] + all_preds = [] + all_labels = [] + + with torch.no_grad(): + for batch_X, batch_y in test_loader: + batch_X = batch_X.to(device) + outputs = model(batch_X).squeeze() + + # ๆจกๅž‹่พ“ๅ‡บlogits + logits = outputs.cpu().numpy() + probs = torch.sigmoid(outputs).cpu().numpy() + preds = (probs > 0.5).astype(int) + + all_logits.extend(logits.flatten()) + all_probs.extend(probs.flatten()) + all_preds.extend(preds.flatten()) + all_labels.extend(batch_y.numpy().flatten()) + + all_logits = np.array(all_logits) + all_probs = np.array(all_probs) + all_preds = np.array(all_preds) + all_labels = np.array(all_labels) + + print(f"\n๐Ÿ“Š ๆจกๅž‹่พ“ๅ‡บ็ปŸ่ฎก๏ผˆไฟฎๅคๅŽ๏ผ‰:") + print(f" Logits่Œƒๅ›ด: [{all_logits.min():.4f}, {all_logits.max():.4f}]") + print(f" Logitsๅ‡ๅ€ผ: {all_logits.mean():.4f}") + print(f" ๆฆ‚็Ž‡่Œƒๅ›ด: [{all_probs.min():.4f}, {all_probs.max():.4f}]") + print(f" ๆฆ‚็Ž‡ๅ‡ๅ€ผ: {all_probs.mean():.4f} โ† ๅบ”่ฏฅๆŽฅ่ฟ‘0.5") + print(f" ้ข„ๆต‹ไธบไธŠๆถจ: {np.sum(all_preds==1)}/{len(all_preds)} ({np.sum(all_preds==1)/len(all_preds)*100:.1f}%)") + print(f" ้ข„ๆต‹ไธบไธ‹่ทŒ: {np.sum(all_preds==0)}/{len(all_preds)} ({np.sum(all_preds==0)/len(all_preds)*100:.1f}%)") + + # ๆญฃๅผ่ฏ„ไผฐ + print("\n[4/4] ไฝฟ็”จไฟฎๅคๅŽ็š„evaluator่ฟ›่กŒๅฎŒๆ•ด่ฏ„ไผฐ...") + metrics = evaluate_model(model, test_loader, task='classification', device=str(device)) + + # ไฟๅญ˜็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_1h_forecast/test_metrics_fixed.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๅฑ•็คบ็ป“ๆžœ + print("\n" + "="*80) + print("ๆœ€็ปˆ่ฏ„ไผฐ็ป“ๆžœ๏ผˆไฟฎๅคๅŽ๏ผ‰") + print("="*80) + + print(f"\n๐Ÿ“Š ๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f} ({metrics.get('accuracy', 0)*100:.2f}%)") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต:") + tp = metrics['true_positives'] + tn = metrics['true_negatives'] + fp = metrics['false_positives'] + fn = metrics['false_negatives'] + print(f" ็œŸ้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไธ”็œŸๆถจ๏ผ‰: {tp}") + print(f" ็œŸ้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ๏ผ‰: {tn}") + print(f" ๅ‡้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ๏ผ‰: {fp}") + print(f" ๅ‡้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ๏ผ‰: {fn}") + + total = tp + tn + fp + fn + if total > 0: + print(f"\n ้ข„ๆต‹ๅˆ†ๅธƒ:") + print(f" ้ข„ๆต‹ไธŠๆถจ: {tp + fp} ({(tp+fp)/total*100:.1f}%)") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {tn + fn} ({(tn+fn)/total*100:.1f}%)") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + max_dd = metrics.get('backtest_max_drawdown', 0) + if np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: N/A (ๆ— ไบคๆ˜“)") + else: + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print(f"\n๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ:") + acc = metrics.get('accuracy', 0) + if acc > 0.55: + print(f" โœ… ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% > 55%๏ผŒๆจกๅž‹ๆœ‰ไธ€ๅฎš้ข„ๆต‹่ƒฝๅŠ›") + elif acc > 0.50: + print(f" โš ๏ธ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ๏ผˆ50%๏ผ‰๏ผŒ้ข„ๆต‹่ƒฝๅŠ›่พƒๅผฑ") + else: + print(f" โŒ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% โ‰ค 50%๏ผŒๆจกๅž‹้ข„ๆต‹่ƒฝๅŠ›ไธ่ถณ") + + total_return = metrics.get('backtest_total_return', 0) + if total_return > 0.05: + print(f" โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 5%๏ผŒ็ญ–็•ฅๆœ‰่พƒๅฅฝ็›ˆๅˆฉๆฝœๅŠ›") + elif total_return > 0: + print(f" โš ๏ธ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅๆœ‰ๅพฎๅผฑ็›ˆๅˆฉ") + else: + print(f" โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + # ๅฏนๆฏ”ไฟฎๅคๅ‰ๅŽ + print(f"\n๐Ÿ“Š ไฟฎๅคๅ‰ๅŽๅฏนๆฏ”:") + print(f" ไฟฎๅคๅ‰๏ผˆๆœ‰Bug๏ผ‰:") + print(f" - ๅนณๅ‡็ฝฎไฟกๅบฆ: 0.69% (้”™่ฏฏ)") + print(f" - ้ข„ๆต‹ไธŠๆถจ: 0ไธช (0%)") + print(f" - ๅ‡†็กฎ็Ž‡: 50.00% (ๅๅทฎ)") + print(f" ไฟฎๅคๅŽ๏ผˆๆญฃ็กฎ๏ผ‰:") + print(f" - ๅนณๅ‡็ฝฎไฟกๅบฆ: {metrics.get('mean_confidence', 0)*100:.1f}%") + print(f" - ้ข„ๆต‹ไธŠๆถจ: {tp + fp}ไธช ({(tp+fp)/total*100:.1f}%)") + print(f" - ๅ‡†็กฎ็Ž‡: {acc*100:.2f}%") + + print("\n" + "="*80) + print("โœ“ ่ฏ„ไผฐๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/evaluate_model.py b/evaluate_model.py new file mode 100644 index 0000000..2cc0a65 --- /dev/null +++ b/evaluate_model.py @@ -0,0 +1,81 @@ +"""่ฏ„ไผฐๅทฒ่ฎญ็ปƒ็š„DLinearๆจกๅž‹""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import json +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear +from training.evaluator import evaluate_model + +def main(): + print("="*80) + print("่ฏ„ไผฐDLinearๆจกๅž‹๏ผˆ็œŸๅฎžๆ•ฐๆฎ๏ผ‰") + print("="*80) + + # ๅŠ ่ฝฝๆ•ฐๆฎ + print("\nๅŠ ่ฝฝๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + + train_data, val_data, test_data = split_data(X, y) + _, _, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', batch_size=64 + ) + + # ๅŠ ่ฝฝๆจกๅž‹ + print("ๅŠ ่ฝฝๆœ€ไฝณๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_btc_1h_real/best_model.pt' + checkpoint = torch.load(model_path, map_location='cpu') + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + + # ่ฏ„ไผฐ + print("\nๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐ...") + device = 'mps' if torch.backends.mps.is_available() else 'cpu' + metrics = evaluate_model(model, test_loader, 'classification', device) + + # ไฟๅญ˜็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_1h_real/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + # ๆ‰“ๅฐ็ป“ๆžœ + print("\n" + "="*80) + print("ๆต‹่ฏ•้›†่ฏ„ไผฐ็ป“ๆžœ") + print("="*80) + print(f"\n๐Ÿ“Š ๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f}") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง: {metrics['true_positives']}") + print(f" ็œŸ้˜ดๆ€ง: {metrics['true_negatives']}") + print(f" ๅ‡้˜ณๆ€ง: {metrics['false_positives']}") + print(f" ๅ‡้˜ดๆ€ง: {metrics['false_negatives']}") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + print(f" ๆœ€ๅคงๅ›žๆ’ค: {metrics.get('backtest_max_drawdown', 0)*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + print("\n" + "="*80) + print(f"โœ“ ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/models/__init__.py b/models/__init__.py new file mode 100644 index 0000000..749798f --- /dev/null +++ b/models/__init__.py @@ -0,0 +1 @@ +"""Model implementations.""" diff --git a/models/base.py b/models/base.py new file mode 100644 index 0000000..838b99d --- /dev/null +++ b/models/base.py @@ -0,0 +1,182 @@ +"""Base model interface for all prediction models.""" + +from abc import ABC, abstractmethod +from dataclasses import dataclass +from typing import Literal, Optional +import torch +import torch.nn as nn + + +@dataclass +class ModelConfig: + """Base configuration for all models.""" + + input_dim: int # Number of input features + lookback: int # Sequence length + task: Literal['classification', 'regression'] = 'classification' + hidden_dim: int = 512 + dropout: float = 0.1 + + +class BasePredictor(nn.Module, ABC): + """Abstract base class for all prediction models.""" + + def __init__(self, config: ModelConfig): + """Initialize model with configuration. + + Args: + config: Model configuration + """ + super().__init__() + self.config = config + + @abstractmethod + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Forward pass. + + Args: + x: Input tensor of shape (batch_size, lookback, input_dim) + + Returns: + Output tensor. Shape depends on task: + - Classification: (batch_size, 1) with sigmoid output + - Regression: (batch_size, 1) with raw value + """ + pass + + def predict(self, x: torch.Tensor) -> torch.Tensor: + """Make predictions (inference mode). + + Args: + x: Input tensor + + Returns: + Predictions + """ + self.eval() + with torch.no_grad(): + return self.forward(x) + + def get_loss_function(self, pos_weight=None, device='cpu') -> nn.Module: + """Get appropriate loss function for the task. + + Args: + pos_weight: Weight for positive class (for imbalanced data) + device: Device to place tensors on + + Returns: + Loss function + """ + if self.config.task == 'classification': + if pos_weight is not None: + # ไฝฟ็”จfloat32ไปฅๅ…ผๅฎนMPS (Mac M1) + pos_weight_tensor = torch.tensor([pos_weight], dtype=torch.float32).to(device) + return nn.BCEWithLogitsLoss(pos_weight=pos_weight_tensor) + else: + return nn.BCELoss() + else: # regression + return nn.MSELoss() + + def save(self, path: str): + """Save model checkpoint. + + Args: + path: Path to save checkpoint + """ + torch.save({ + 'model_state_dict': self.state_dict(), + 'config': self.config + }, path) + + @classmethod + def load(cls, path: str, device: Optional[str] = None): + """Load model from checkpoint. + + Args: + path: Path to checkpoint + device: Device to load model to + + Returns: + Loaded model + """ + checkpoint = torch.load(path, map_location=device) + model = cls(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + return model + + def to_onnx(self, path: str, dummy_input: Optional[torch.Tensor] = None): + """Export model to ONNX format. + + Args: + path: Path to save ONNX model + dummy_input: Example input tensor. If None, will create default. + """ + # Move to CPU for ONNX export (critical for M1) + self.cpu() + self.eval() + + # Create dummy input if not provided + if dummy_input is None: + dummy_input = torch.randn( + 1, + self.config.lookback, + self.config.input_dim + ) + + # Ensure dummy input is on CPU + dummy_input = dummy_input.cpu() + + # Export to ONNX + torch.onnx.export( + self, + dummy_input, + path, + export_params=True, + opset_version=14, + do_constant_folding=True, + input_names=['input'], + output_names=['output'], + dynamic_axes={ + 'input': {0: 'batch_size'}, + 'output': {0: 'batch_size'} + } + ) + + print(f"Model exported to ONNX: {path}") + + def count_parameters(self) -> int: + """Count trainable parameters. + + Returns: + Number of trainable parameters + """ + return sum(p.numel() for p in self.parameters() if p.requires_grad) + + +if __name__ == "__main__": + # Test base class (with a dummy implementation) + class DummyModel(BasePredictor): + def __init__(self, config: ModelConfig): + super().__init__(config) + self.fc = nn.Linear(config.input_dim * config.lookback, 1) + if config.task == 'classification': + self.activation = nn.Sigmoid() + else: + self.activation = nn.Identity() + + def forward(self, x): + batch_size = x.size(0) + x = x.view(batch_size, -1) + x = self.fc(x) + return self.activation(x) + + # Test + config = ModelConfig(input_dim=10, lookback=168, task='classification') + model = DummyModel(config) + + print(f"Parameters: {model.count_parameters()}") + + # Test forward pass + x = torch.randn(32, 168, 10) + output = model(x) + print(f"Output shape: {output.shape}") diff --git a/models/checkpoints/cross_asset_btc_to_eth/best_model.pt b/models/checkpoints/cross_asset_btc_to_eth/best_model.pt new file mode 100644 index 0000000..01567ba Binary files /dev/null and b/models/checkpoints/cross_asset_btc_to_eth/best_model.pt differ diff --git a/models/checkpoints/cross_asset_btc_to_eth/final_model.pt b/models/checkpoints/cross_asset_btc_to_eth/final_model.pt new file mode 100644 index 0000000..ba5ef51 Binary files /dev/null and b/models/checkpoints/cross_asset_btc_to_eth/final_model.pt differ diff --git a/models/checkpoints/cross_asset_btc_to_eth/test_metrics.json b/models/checkpoints/cross_asset_btc_to_eth/test_metrics.json new file mode 100644 index 0000000..bfc23d8 --- /dev/null +++ b/models/checkpoints/cross_asset_btc_to_eth/test_metrics.json @@ -0,0 +1,13 @@ +{ + "mse": 5.495949517353438e-05, + "rmse": 0.007413467149285439, + "mae": 0.004826944321393967, + "mape": 930.6216430664062, + "directional_accuracy": 0.4907678594167834, + "backtest_total_return": -0.9745769500732422, + "backtest_final_capital": 254.23023986816406, + "backtest_sharpe_ratio": -0.26884937315369317, + "backtest_max_drawdown": -0.978744387626648, + "backtest_win_rate": 0.47166687889978354, + "backtest_num_trades": 3251 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_811_split/best_model.pt b/models/checkpoints/dlinear_811_split/best_model.pt new file mode 100644 index 0000000..33c07cb Binary files /dev/null and b/models/checkpoints/dlinear_811_split/best_model.pt differ diff --git a/models/checkpoints/dlinear_811_split/final_model.pt b/models/checkpoints/dlinear_811_split/final_model.pt new file mode 100644 index 0000000..1fc8fba Binary files /dev/null and b/models/checkpoints/dlinear_811_split/final_model.pt differ diff --git a/models/checkpoints/dlinear_811_split/preprocessor.pkl b/models/checkpoints/dlinear_811_split/preprocessor.pkl new file mode 100644 index 0000000..f4397f2 Binary files /dev/null and b/models/checkpoints/dlinear_811_split/preprocessor.pkl differ diff --git a/models/checkpoints/dlinear_811_split/test_metrics.json b/models/checkpoints/dlinear_811_split/test_metrics.json new file mode 100644 index 0000000..52d2f65 --- /dev/null +++ b/models/checkpoints/dlinear_811_split/test_metrics.json @@ -0,0 +1,10 @@ +{ + "price_mae": 4283.3626861511675, + "price_rmse": 4735.107859758518, + "price_mape": 3.928560493143656, + "direction_accuracy": 0.49637127578304047, + "true_positives": 258, + "true_negatives": 2341, + "false_positives": 255, + "false_negatives": 2382 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_btc_1h_forecast/best_model.pt b/models/checkpoints/dlinear_btc_1h_forecast/best_model.pt new file mode 100644 index 0000000..66dd462 Binary files /dev/null and b/models/checkpoints/dlinear_btc_1h_forecast/best_model.pt differ diff --git a/models/checkpoints/dlinear_btc_1h_forecast/final_model.pt b/models/checkpoints/dlinear_btc_1h_forecast/final_model.pt new file mode 100644 index 0000000..6bbf439 Binary files /dev/null and b/models/checkpoints/dlinear_btc_1h_forecast/final_model.pt differ diff --git a/models/checkpoints/dlinear_btc_1h_forecast/test_metrics.json b/models/checkpoints/dlinear_btc_1h_forecast/test_metrics.json new file mode 100644 index 0000000..0d8fac2 --- /dev/null +++ b/models/checkpoints/dlinear_btc_1h_forecast/test_metrics.json @@ -0,0 +1,18 @@ +{ + "accuracy": 0.5, + "precision": 0.0, + "recall": 0.0, + "f1": 0.0, + "true_negatives": 642, + "false_positives": 0, + "false_negatives": 642, + "true_positives": 0, + "specificity": 1.0, + "mean_confidence": 0.0068817585706710815, + "backtest_total_return": -1.0, + "backtest_final_capital": 0.0, + "backtest_sharpe_ratio": -9.643650760992955, + "backtest_max_drawdown": NaN, + "backtest_win_rate": 0.0, + "backtest_num_trades": 0 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_btc_1h_forecast/test_metrics_fixed.json b/models/checkpoints/dlinear_btc_1h_forecast/test_metrics_fixed.json new file mode 100644 index 0000000..58b43ce --- /dev/null +++ b/models/checkpoints/dlinear_btc_1h_forecast/test_metrics_fixed.json @@ -0,0 +1,18 @@ +{ + "accuracy": 0.5070093457943925, + "precision": 0.5053254437869823, + "recall": 0.6651090342679128, + "f1": 0.574310692669805, + "true_negatives": 224, + "false_positives": 418, + "false_negatives": 215, + "true_positives": 427, + "specificity": 0.34890965732087226, + "mean_confidence": 0.5017203688621521, + "backtest_total_return": -1.0, + "backtest_final_capital": -0.0, + "backtest_sharpe_ratio": 2.314261942010565, + "backtest_max_drawdown": -1.0, + "backtest_win_rate": 0.3325545171339564, + "backtest_num_trades": 136 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_btc_2020_2025/best_model.pt b/models/checkpoints/dlinear_btc_2020_2025/best_model.pt new file mode 100644 index 0000000..81bcbf8 Binary files /dev/null and b/models/checkpoints/dlinear_btc_2020_2025/best_model.pt differ diff --git a/models/checkpoints/dlinear_btc_2020_2025/final_model.pt b/models/checkpoints/dlinear_btc_2020_2025/final_model.pt new file mode 100644 index 0000000..f8b2818 Binary files /dev/null and b/models/checkpoints/dlinear_btc_2020_2025/final_model.pt differ diff --git a/models/checkpoints/dlinear_btc_2020_2025/test_metrics.json b/models/checkpoints/dlinear_btc_2020_2025/test_metrics.json new file mode 100644 index 0000000..34978e5 --- /dev/null +++ b/models/checkpoints/dlinear_btc_2020_2025/test_metrics.json @@ -0,0 +1,18 @@ +{ + "accuracy": 0.49764421240290335, + "precision": 0.502192108409725, + "recall": 0.3185035389282103, + "f1": 0.38979118329466356, + "true_negatives": 2648, + "false_positives": 1249, + "false_negatives": 2696, + "true_positives": 1260, + "specificity": 0.6794970490120605, + "mean_confidence": 0.49758902192115784, + "backtest_total_return": -1.0, + "backtest_final_capital": -0.0, + "backtest_sharpe_ratio": -2.5728736046923655, + "backtest_max_drawdown": NaN, + "backtest_win_rate": 0.16044823634279892, + "backtest_num_trades": 782 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_btc_full_data/best_model.pt b/models/checkpoints/dlinear_btc_full_data/best_model.pt new file mode 100644 index 0000000..fa0ef4d Binary files /dev/null and b/models/checkpoints/dlinear_btc_full_data/best_model.pt differ diff --git a/models/checkpoints/dlinear_btc_full_data/final_metrics.json b/models/checkpoints/dlinear_btc_full_data/final_metrics.json new file mode 100644 index 0000000..559bdbf --- /dev/null +++ b/models/checkpoints/dlinear_btc_full_data/final_metrics.json @@ -0,0 +1,13 @@ +{ + "mse": 2.142045195796527e-05, + "rmse": 0.004628223412710893, + "mae": 0.0030602782499045134, + "mape": 131.8273162841797, + "directional_accuracy": 0.49732620320855614, + "backtest_total_return": 0.2429506778717041, + "backtest_final_capital": 12429.5068359375, + "backtest_sharpe_ratio": 0.19540257211386183, + "backtest_max_drawdown": -0.13858233392238617, + "backtest_win_rate": 0.49732620320855614, + "backtest_num_trades": 0 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_btc_full_data/final_model.pt b/models/checkpoints/dlinear_btc_full_data/final_model.pt new file mode 100644 index 0000000..4ffa295 Binary files /dev/null and b/models/checkpoints/dlinear_btc_full_data/final_model.pt differ diff --git a/models/checkpoints/dlinear_btc_full_data/preprocessor.pkl b/models/checkpoints/dlinear_btc_full_data/preprocessor.pkl new file mode 100644 index 0000000..0e954ba Binary files /dev/null and b/models/checkpoints/dlinear_btc_full_data/preprocessor.pkl differ diff --git a/models/checkpoints/dlinear_btc_regression/best_model.pt b/models/checkpoints/dlinear_btc_regression/best_model.pt new file mode 100644 index 0000000..e0fdea9 Binary files /dev/null and b/models/checkpoints/dlinear_btc_regression/best_model.pt differ diff --git a/models/checkpoints/dlinear_btc_regression/final_model.pt b/models/checkpoints/dlinear_btc_regression/final_model.pt new file mode 100644 index 0000000..924b627 Binary files /dev/null and b/models/checkpoints/dlinear_btc_regression/final_model.pt differ diff --git a/models/checkpoints/dlinear_btc_regression/test_metrics.json b/models/checkpoints/dlinear_btc_regression/test_metrics.json new file mode 100644 index 0000000..1e15352 --- /dev/null +++ b/models/checkpoints/dlinear_btc_regression/test_metrics.json @@ -0,0 +1,13 @@ +{ + "mse": 2.382730417593848e-05, + "rmse": 0.004881321970116137, + "mae": 0.0033776722848415375, + "mape": 780.3690185546875, + "directional_accuracy": 0.5066853431809499, + "backtest_total_return": -0.1671363264322281, + "backtest_final_capital": 8328.63671875, + "backtest_sharpe_ratio": -0.0266775386419239, + "backtest_max_drawdown": -0.40377509593963623, + "backtest_win_rate": 0.48974914045587675, + "backtest_num_trades": 1061 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_classification_2026/best_model.pt b/models/checkpoints/dlinear_classification_2026/best_model.pt new file mode 100644 index 0000000..84a47b2 Binary files /dev/null and b/models/checkpoints/dlinear_classification_2026/best_model.pt differ diff --git a/models/checkpoints/dlinear_classification_2026/final_model.pt b/models/checkpoints/dlinear_classification_2026/final_model.pt new file mode 100644 index 0000000..3149683 Binary files /dev/null and b/models/checkpoints/dlinear_classification_2026/final_model.pt differ diff --git a/models/checkpoints/dlinear_classification_2026/preprocessor.pkl b/models/checkpoints/dlinear_classification_2026/preprocessor.pkl new file mode 100644 index 0000000..74cfb67 Binary files /dev/null and b/models/checkpoints/dlinear_classification_2026/preprocessor.pkl differ diff --git a/models/checkpoints/dlinear_classification_2026/test_2026_results.json b/models/checkpoints/dlinear_classification_2026/test_2026_results.json new file mode 100644 index 0000000..6365a0a --- /dev/null +++ b/models/checkpoints/dlinear_classification_2026/test_2026_results.json @@ -0,0 +1,11 @@ +{ + "accuracy": 0.53099173553719, + "precision": 0.5178571428571429, + "recall": 0.49361702127659574, + "f1_score": 0.505446623093682, + "true_positives": 116, + "true_negatives": 141, + "false_positives": 108, + "false_negatives": 119, + "n_samples": 484 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_predict_price/best_model.pt b/models/checkpoints/dlinear_predict_price/best_model.pt new file mode 100644 index 0000000..98ec007 Binary files /dev/null and b/models/checkpoints/dlinear_predict_price/best_model.pt differ diff --git a/models/checkpoints/dlinear_predict_price/final_model.pt b/models/checkpoints/dlinear_predict_price/final_model.pt new file mode 100644 index 0000000..35129c2 Binary files /dev/null and b/models/checkpoints/dlinear_predict_price/final_model.pt differ diff --git a/models/checkpoints/dlinear_predict_price/metrics.json b/models/checkpoints/dlinear_predict_price/metrics.json new file mode 100644 index 0000000..1d22417 --- /dev/null +++ b/models/checkpoints/dlinear_predict_price/metrics.json @@ -0,0 +1,6 @@ +{ + "price_mae": 528.017854278076, + "price_rmse": 736.6082253699151, + "price_mape": 0.523728600511905, + "direction_accuracy": 0.5022918258212375 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_predict_price/preprocessor.pkl b/models/checkpoints/dlinear_predict_price/preprocessor.pkl new file mode 100644 index 0000000..f4397f2 Binary files /dev/null and b/models/checkpoints/dlinear_predict_price/preprocessor.pkl differ diff --git a/models/checkpoints/dlinear_simple_features/best_model.pt b/models/checkpoints/dlinear_simple_features/best_model.pt new file mode 100644 index 0000000..8337399 Binary files /dev/null and b/models/checkpoints/dlinear_simple_features/best_model.pt differ diff --git a/models/checkpoints/dlinear_simple_features/final_model.pt b/models/checkpoints/dlinear_simple_features/final_model.pt new file mode 100644 index 0000000..64b5e81 Binary files /dev/null and b/models/checkpoints/dlinear_simple_features/final_model.pt differ diff --git a/models/checkpoints/dlinear_simple_features/metrics.json b/models/checkpoints/dlinear_simple_features/metrics.json new file mode 100644 index 0000000..6b1b49f --- /dev/null +++ b/models/checkpoints/dlinear_simple_features/metrics.json @@ -0,0 +1,13 @@ +{ + "mse": 2.1433252186398022e-05, + "rmse": 0.004629606050885758, + "mae": 0.00306295626796782, + "mape": 180.17770385742188, + "directional_accuracy": 0.4992360580595875, + "backtest_total_return": 0.226644828915596, + "backtest_final_capital": 12266.4482421875, + "backtest_sharpe_ratio": 0.18486101832170032, + "backtest_max_drawdown": -0.13858233392238617, + "backtest_win_rate": 0.4977081741787624, + "backtest_num_trades": 38 +} \ No newline at end of file diff --git a/models/checkpoints/dlinear_simple_features/preprocessor.pkl b/models/checkpoints/dlinear_simple_features/preprocessor.pkl new file mode 100644 index 0000000..b1c6b41 Binary files /dev/null and b/models/checkpoints/dlinear_simple_features/preprocessor.pkl differ diff --git a/models/checkpoints/dlinear_test/best_model.pt b/models/checkpoints/dlinear_test/best_model.pt new file mode 100644 index 0000000..f9319f7 Binary files /dev/null and b/models/checkpoints/dlinear_test/best_model.pt differ diff --git a/models/checkpoints/dlinear_test/final_model.pt b/models/checkpoints/dlinear_test/final_model.pt new file mode 100644 index 0000000..6f58d99 Binary files /dev/null and b/models/checkpoints/dlinear_test/final_model.pt differ diff --git a/models/dlinear/__init__.py b/models/dlinear/__init__.py new file mode 100644 index 0000000..3a371b7 --- /dev/null +++ b/models/dlinear/__init__.py @@ -0,0 +1 @@ +"""DLinear model implementation.""" diff --git a/models/dlinear/model.py b/models/dlinear/model.py new file mode 100644 index 0000000..09b67f4 --- /dev/null +++ b/models/dlinear/model.py @@ -0,0 +1,203 @@ +"""DLinear: Decomposition Linear model for time series forecasting. + +Reference: Are Transformers Effective for Time Series Forecasting? (DLinear) +Paper: https://arxiv.org/abs/2205.13504 +""" + +import torch +import torch.nn as nn +from dataclasses import dataclass +from typing import Literal + +from ..base import BasePredictor, ModelConfig + + +@dataclass +class DLinearConfig(ModelConfig): + """Configuration for DLinear model.""" + + moving_avg_kernel: int = 25 # Kernel size for moving average decomposition + individual: bool = False # Whether to use individual linear layers per feature + + +class MovingAvg(nn.Module): + """Moving average block for trend extraction.""" + + def __init__(self, kernel_size: int): + """Initialize moving average layer. + + Args: + kernel_size: Size of the moving average window + """ + super().__init__() + self.kernel_size = kernel_size + self.avg = nn.AvgPool1d( + kernel_size=kernel_size, + stride=1, + padding=kernel_size // 2, + count_include_pad=False + ) + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Apply moving average. + + Args: + x: Input tensor of shape (batch_size, seq_len, features) + + Returns: + Smoothed tensor + """ + # Padding at both ends + front = x[:, 0:1, :].repeat(1, self.kernel_size // 2, 1) + end = x[:, -1:, :].repeat(1, (self.kernel_size - 1) // 2, 1) + x_padded = torch.cat([front, x, end], dim=1) + + # Apply average pooling (swap dimensions for AvgPool1d) + x_padded = x_padded.permute(0, 2, 1) # (batch, features, seq_len) + x_smoothed = self.avg(x_padded) + x_smoothed = x_smoothed.permute(0, 2, 1) # (batch, seq_len, features) + + # Trim to original length + return x_smoothed[:, :x.size(1), :] + + +class SeriesDecomposition(nn.Module): + """Series decomposition block to extract trend and seasonal components.""" + + def __init__(self, kernel_size: int): + """Initialize decomposition layer. + + Args: + kernel_size: Size of the moving average window for trend + """ + super().__init__() + self.moving_avg = MovingAvg(kernel_size) + + def forward(self, x: torch.Tensor) -> tuple: + """Decompose series into trend and seasonal components. + + Args: + x: Input tensor of shape (batch_size, seq_len, features) + + Returns: + Tuple of (seasonal, trend) tensors + """ + trend = self.moving_avg(x) + seasonal = x - trend + return seasonal, trend + + +class DLinear(BasePredictor): + """DLinear model: Decomposition + Linear layers for forecasting.""" + + def __init__(self, config: DLinearConfig): + """Initialize DLinear model. + + Args: + config: Model configuration + """ + super().__init__(config) + + self.decomposition = SeriesDecomposition(config.moving_avg_kernel) + + if config.individual: + # Individual linear layer for each feature + self.linear_seasonal = nn.ModuleList([ + nn.Linear(config.lookback, 1) + for _ in range(config.input_dim) + ]) + self.linear_trend = nn.ModuleList([ + nn.Linear(config.lookback, 1) + for _ in range(config.input_dim) + ]) + else: + # Shared linear layers + self.linear_seasonal = nn.Linear(config.lookback, 1) + self.linear_trend = nn.Linear(config.lookback, 1) + + # Final aggregation layer + self.aggregation = nn.Sequential( + nn.Linear(config.input_dim, config.hidden_dim), + nn.ReLU(), + nn.Dropout(config.dropout), + nn.Linear(config.hidden_dim, 1) + ) + + # Output activation + # ๆณจๆ„๏ผšๅฏนไบŽๅˆ†็ฑปไปปๅŠก๏ผŒไฝฟ็”จIdentity่€Œ้žSigmoid + # ๅ› ไธบBCEWithLogitsLossๅ†…้ƒจๅทฒๅŒ…ๅซSigmoid๏ผŒ้ฟๅ…ๅŒ้‡ๆฟ€ๆดป + if config.task == 'classification': + self.output_activation = nn.Identity() # ่พ“ๅ‡บlogits๏ผŒ็”ฑๆŸๅคฑๅ‡ฝๆ•ฐๅค„็† + else: + self.output_activation = nn.Identity() + + def forward(self, x: torch.Tensor) -> torch.Tensor: + """Forward pass through DLinear. + + Args: + x: Input tensor of shape (batch_size, lookback, input_dim) + + Returns: + Output tensor of shape (batch_size, 1) + """ + # Decompose into seasonal and trend + seasonal, trend = self.decomposition(x) + + # Apply linear layers to each component + if self.config.individual: + seasonal_out = [] + trend_out = [] + for i in range(self.config.input_dim): + # Extract feature i: (batch, seq_len) + s_i = seasonal[:, :, i] + t_i = trend[:, :, i] + + # Apply linear transformation: (batch, seq_len) -> (batch, 1) + seasonal_out.append(self.linear_seasonal[i](s_i)) + trend_out.append(self.linear_trend[i](t_i)) + + # Stack outputs: (batch, input_dim) + seasonal_out = torch.stack(seasonal_out, dim=1).squeeze(-1) + trend_out = torch.stack(trend_out, dim=1).squeeze(-1) + else: + # Shared linear layer + # Swap dimensions: (batch, seq_len, features) -> (batch, features, seq_len) + seasonal = seasonal.permute(0, 2, 1) + trend = trend.permute(0, 2, 1) + + # Apply linear: (batch, features, seq_len) -> (batch, features, 1) + seasonal_out = self.linear_seasonal(seasonal).squeeze(-1) + trend_out = self.linear_trend(trend).squeeze(-1) + + # Combine seasonal and trend + combined = seasonal_out + trend_out # (batch, input_dim) + + # Aggregate and produce final prediction + output = self.aggregation(combined) # (batch, 1) + output = self.output_activation(output) + + return output + + +if __name__ == "__main__": + # Test DLinear model + config = DLinearConfig( + input_dim=30, + lookback=168, + task='classification', + hidden_dim=512, + moving_avg_kernel=25 + ) + + model = DLinear(config) + print(f"DLinear parameters: {model.count_parameters()}") + + # Test forward pass + x = torch.randn(32, 168, 30) + output = model(x) + print(f"Output shape: {output.shape}") + print(f"Output range: [{output.min():.4f}, {output.max():.4f}]") + + # Test ONNX export + model.to_onnx('/tmp/dlinear_test.onnx') + print("ONNX export successful!") diff --git a/predict_2026.py b/predict_2026.py new file mode 100644 index 0000000..4e004e6 --- /dev/null +++ b/predict_2026.py @@ -0,0 +1,263 @@ +"""ไฝฟ็”จๅ…จ้‡่ฎญ็ปƒๆจกๅž‹้ข„ๆต‹2026ๅนดBTCไปทๆ ผๆถจ่ทŒ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import pickle +import numpy as np +import pandas as pd +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear +from training.evaluator import ModelEvaluator + +def main(): + print("="*80) + print("ไฝฟ็”จๅ…จ้‡่ฎญ็ปƒๆจกๅž‹้ข„ๆต‹2026ๅนดBTCๆถจ่ทŒ") + print("="*80) + + # ========== ๆญฅ้ชค1: ๅŠ ่ฝฝๆจกๅž‹ๅ’Œ้ข„ๅค„็†ๅ™จ ========== + print("\n[1/6] ๅŠ ่ฝฝ่ฎญ็ปƒๅฅฝ็š„ๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_btc_full_data/best_model.pt' + preprocessor_path = './models/checkpoints/dlinear_btc_full_data/preprocessor.pkl' + + # ๅŠ ่ฝฝๆจกๅž‹ + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + print(f"โœ“ ๆจกๅž‹ๅŠ ่ฝฝๆˆๅŠŸ (่ฎพๅค‡: {device})") + + # ๅŠ ่ฝฝ้ข„ๅค„็†ๅ™จ + with open(preprocessor_path, 'rb') as f: + preprocessor = pickle.load(f) + print(f"โœ“ ้ข„ๅค„็†ๅ™จๅŠ ่ฝฝๆˆๅŠŸ") + + # ========== ๆญฅ้ชค2: ่Žทๅ–2026ๅนดๆ•ฐๆฎ ========== + print("\n[2/6] ่Žทๅ–2026ๅนดBTCๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + try: + df_2026 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2026-01-01', + end_date='2026-12-31', + use_cache=False # ไธไฝฟ็”จ็ผ“ๅญ˜๏ผŒ่Žทๅ–ๆœ€ๆ–ฐๆ•ฐๆฎ + ) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df_2026)} ่กŒ2026ๅนดๆ•ฐๆฎ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df_2026['timestamp'].min()} ่‡ณ {df_2026['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ่Œƒๅ›ด๏ผš${df_2026['close'].iloc[0]:,.2f} โ†’ ${df_2026['close'].iloc[-1]:,.2f}") + + total_return = (df_2026['close'].iloc[-1] - df_2026['close'].iloc[0]) / df_2026['close'].iloc[0] + print(f"โœ“ 2026ๅนดๆ”ถ็›Š็Ž‡๏ผš{total_return*100:+.2f}%") + + except Exception as e: + print(f"โš ๏ธ ๆ— ๆณ•่Žทๅ–2026ๅนดๅฎŒๆ•ดๆ•ฐๆฎ๏ผš{e}") + print(f"ๅฐ่ฏ•่Žทๅ–2025ๅนด12ๆœˆ่‡ณไปŠ็š„ๆœ€ๆ–ฐๆ•ฐๆฎ...") + + df_2026 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2025-12-01', + use_cache=False + ) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df_2026)} ่กŒๆœ€ๆ–ฐๆ•ฐๆฎ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df_2026['timestamp'].min()} ่‡ณ {df_2026['timestamp'].max()}") + + # ========== ๆญฅ้ชค3: ๆ•ฐๆฎ้ข„ๅค„็† ========== + print("\n[3/6] ้ข„ๅค„็†2026ๅนดๆ•ฐๆฎ...") + + # ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ๅ’Œๆ—ถ้—ด็‰นๅพ + df_processed = preprocessor.add_technical_indicators(df_2026) + df_processed = preprocessor.add_time_features(df_processed) + df_processed = preprocessor.create_labels(df_processed, task='regression') + + # ๅˆ ้™คNaN่กŒ + df_processed = df_processed.dropna().reset_index(drop=True) + + # ็กฎไฟๅŒ…ๅซๆ‰€ๆœ‰่ฎญ็ปƒๆ—ถ็š„ๅˆ— + # ๅฆ‚ๆžœ็ผบๅฐ‘ๆŸไบ›ๅˆ—๏ผŒ็”จ0ๅกซๅ…… + for col in preprocessor.feature_columns: + if col not in df_processed.columns: + df_processed[col] = 0 + print(f" โš ๏ธ ๆทปๅŠ ็ผบๅคฑๅˆ—๏ผš{col}") + + # ไฝฟ็”จ่ฎญ็ปƒๆ—ถ็š„scalerๆ ‡ๅ‡†ๅŒ–็‰นๅพ + scaled_features = preprocessor.transform(df_processed) + + # ๅˆ›ๅปบๅบๅˆ— + X, y = preprocessor.create_sequences( + scaled_features, + df_processed['label'].values + ) + + print(f"โœ“ ้ข„ๆต‹ๅบๅˆ—ๆ•ฐ้‡๏ผš{len(X)}") + print(f"โœ“ ๅบๅˆ—ๅฝข็Šถ๏ผš{X.shape}") + + if len(X) == 0: + print("โŒ ๆฒกๆœ‰่ถณๅคŸ็š„ๆ•ฐๆฎๅˆ›ๅปบๅบๅˆ—๏ผŒ้œ€่ฆ่‡ณๅฐ‘169ๅฐๆ—ถ็š„ๆ•ฐๆฎ") + return + + # ========== ๆญฅ้ชค4: ๆจกๅž‹้ข„ๆต‹ ========== + print("\n[4/6] ไฝฟ็”จๆจกๅž‹้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถๆถจ่ทŒ...") + + X_tensor = torch.FloatTensor(X).to(device) + + with torch.no_grad(): + predictions = model(X_tensor).squeeze().cpu().numpy() + + print(f"โœ“ ้ข„ๆต‹ๅฎŒๆˆ๏ผŒๅ…ฑ {len(predictions)} ไธช้ข„ๆต‹ๅ€ผ") + print(f"โœ“ ้ข„ๆต‹ๆ”ถ็›Š็Ž‡่Œƒๅ›ด๏ผš{predictions.min()*100:.4f}% ~ {predictions.max()*100:.4f}%") + print(f"โœ“ ้ข„ๆต‹ๆ”ถ็›Š็Ž‡ๅ‡ๅ€ผ๏ผš{predictions.mean()*100:.4f}%") + + # ========== ๆญฅ้ชค5: ๆถจ่ทŒๅˆคๆ–ญ ========== + print("\n[5/6] ๆ นๆฎ้ข„ๆต‹็ป“ๆžœๅˆคๆ–ญๆถจ่ทŒ...") + + # ้ข„ๆต‹ๆ–นๅ‘๏ผšๆญฃๅ€ผ=ไธŠๆถจ๏ผŒ่ดŸๅ€ผ=ไธ‹่ทŒ + predicted_direction = (predictions > 0).astype(int) # 1=ๆถจ, 0=่ทŒ + actual_direction = (y > 0).astype(int) + + n_predict_up = (predicted_direction == 1).sum() + n_predict_down = (predicted_direction == 0).sum() + n_actual_up = (actual_direction == 1).sum() + n_actual_down = (actual_direction == 0).sum() + + print(f"\n๐Ÿ“Š ้ข„ๆต‹็ปŸ่ฎก๏ผš") + print(f" ้ข„ๆต‹ไธŠๆถจ๏ผš{n_predict_up} ({n_predict_up/len(predictions)*100:.1f}%)") + print(f" ้ข„ๆต‹ไธ‹่ทŒ๏ผš{n_predict_down} ({n_predict_down/len(predictions)*100:.1f}%)") + + print(f"\n๐Ÿ“Š ๅฎž้™…็ปŸ่ฎก๏ผš") + print(f" ๅฎž้™…ไธŠๆถจ๏ผš{n_actual_up} ({n_actual_up/len(y)*100:.1f}%)") + print(f" ๅฎž้™…ไธ‹่ทŒ๏ผš{n_actual_down} ({n_actual_down/len(y)*100:.1f}%)") + + # ========== ๆญฅ้ชค6: ่ฏ„ไผฐ้ข„ๆต‹ๅ‡†็กฎ็Ž‡ ========== + print("\n[6/6] ่ฏ„ไผฐ้ข„ๆต‹ๅ‡†็กฎ็Ž‡...") + + evaluator = ModelEvaluator(task='regression') + metrics = evaluator.evaluate(y, predictions) + + print("\n" + "="*80) + print("2026ๅนด้ข„ๆต‹็ป“ๆžœ่ฏ„ไผฐ") + print("="*80) + + print(f"\n๐Ÿ“Š ๅ›žๅฝ’ๆŒ‡ๆ ‡๏ผš") + print(f" RMSE (ๅ‡ๆ–นๆ น่ฏฏๅทฎ): {metrics.get('rmse', 0)*100:.4f}%") + print(f" MAE (ๅนณๅ‡็ปๅฏน่ฏฏๅทฎ): {metrics.get('mae', 0)*100:.4f}%") + print(f" MAPE (ๅนณๅ‡็™พๅˆ†ๆฏ”่ฏฏๅทฎ): {metrics.get('mape', 0):.2f}%") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {metrics.get('directional_accuracy', 0)*100:.2f}%") + + # ๆททๆท†็Ÿฉ้˜ต + from sklearn.metrics import confusion_matrix + cm = confusion_matrix(actual_direction, predicted_direction) + tn, fp, fn, tp = cm.ravel() + + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต๏ผˆๆ–นๅ‘้ข„ๆต‹๏ผ‰๏ผš") + print(f" ็œŸ้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไธ”็œŸๆถจ๏ผ‰: {tp} ({tp/len(y)*100:.1f}%)") + print(f" ็œŸ้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ๏ผ‰: {tn} ({tn/len(y)*100:.1f}%)") + print(f" ๅ‡้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ๏ผ‰: {fp} ({fp/len(y)*100:.1f}%)") + print(f" ๅ‡้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ๏ผ‰: {fn} ({fn/len(y)*100:.1f}%)") + + print(f"\n ็ฒพ็กฎ็Ž‡๏ผˆ้ข„ๆต‹ๆถจ็š„ๅ‡†็กฎ็Ž‡๏ผ‰: {tp/(tp+fp)*100 if (tp+fp)>0 else 0:.2f}%") + print(f" ๅฌๅ›ž็Ž‡๏ผˆๅฎž้™…ๆถจ่ขซ้ข„ๆต‹ไธบๆถจ๏ผ‰: {tp/(tp+fn)*100 if (tp+fn)>0 else 0:.2f}%") + + # ๅ›žๆต‹็ญ–็•ฅ + backtest_metrics = evaluator.backtest_strategy( + y, + predictions, + initial_capital=10000.0, + transaction_cost=0.001 + ) + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ๏ผˆ2026ๅนด๏ผ‰๏ผš") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {backtest_metrics.get('total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${backtest_metrics.get('final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {backtest_metrics.get('sharpe_ratio', 0):.4f}") + max_dd = backtest_metrics.get('max_drawdown', 0) + if not np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + print(f" ่ƒœ็Ž‡: {backtest_metrics.get('win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {backtest_metrics.get('num_trades', 0):.0f}") + + # Buy & Holdๅฏนๆฏ” + buy_hold_return = (df_processed['close'].iloc[-1] - df_processed['close'].iloc[168]) / df_processed['close'].iloc[168] + print(f"\n๐Ÿ“Š ็ญ–็•ฅๅฏนๆฏ”๏ผš") + print(f" ๆจกๅž‹็ญ–็•ฅๆ”ถ็›Š: {backtest_metrics.get('total_return', 0)*100:.2f}%") + print(f" Buy & Hold: {buy_hold_return*100:.2f}%") + + if backtest_metrics.get('total_return', 0) > buy_hold_return: + print(f" โœ… ๆจกๅž‹็ญ–็•ฅ่ท‘่ตขBuy & Hold {(backtest_metrics.get('total_return', 0) - buy_hold_return)*100:.2f}%") + else: + print(f" โŒ ๆจกๅž‹็ญ–็•ฅ่ท‘่พ“Buy & Hold {(buy_hold_return - backtest_metrics.get('total_return', 0))*100:.2f}%") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n" + "="*80) + print("๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ") + print("="*80) + + dir_acc = metrics.get('directional_accuracy', 0) + total_return = backtest_metrics.get('total_return', 0) + + print(f"\nๆ–นๅ‘้ข„ๆต‹่ƒฝๅŠ›๏ผš") + if dir_acc > 0.55: + print(f" โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% > 55%๏ผŒๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›") + elif dir_acc > 0.50: + print(f" โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ") + else: + print(f" โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% โ‰ค 50%๏ผŒ้ข„ๆต‹่ƒฝๅŠ›ไธ่ถณ") + + print(f"\n็›ˆๅˆฉ่ƒฝๅŠ›๏ผš") + if total_return > 0.1: + print(f" โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 10%๏ผŒ็ญ–็•ฅ่กจ็Žฐไผ˜็ง€") + elif total_return > 0: + print(f" โš ๏ธ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅๆœ‰ๅพฎๅผฑ็›ˆๅˆฉ") + else: + print(f" โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + print(f"\n้ฃŽ้™ฉๆŽงๅˆถ๏ผš") + sharpe = backtest_metrics.get('sharpe_ratio', 0) + if sharpe > 1.0: + print(f" โœ… ๅคๆ™ฎๆฏ”็Ž‡ {sharpe:.2f} > 1.0๏ผŒ้ฃŽ้™ฉ่ฐƒๆ•ดๅŽๆ”ถ็›Šไผ˜็ง€") + elif sharpe > 0.5: + print(f" โš ๏ธ ๅคๆ™ฎๆฏ”็Ž‡ {sharpe:.2f}๏ผŒ้ฃŽ้™ฉ่ฐƒๆ•ดๅŽๆ”ถ็›Šไธ€่ˆฌ") + else: + print(f" โŒ ๅคๆ™ฎๆฏ”็Ž‡ {sharpe:.2f} < 0.5๏ผŒ้ฃŽ้™ฉ่ฐƒๆ•ดๅŽๆ”ถ็›Š่พƒๅทฎ") + + # ่ฏฆ็ป†้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ + print("\n" + "="*80) + print("๐Ÿ“‹ ้ƒจๅˆ†้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ๏ผˆๅ‰20ไธช๏ผ‰") + print("="*80) + print(f"\n{'ๆ—ถ้—ด':<20} {'้ข„ๆต‹ๆ”ถ็›Š็Ž‡':<12} {'ๅฎž้™…ๆ”ถ็›Š็Ž‡':<12} {'้ข„ๆต‹ๆ–นๅ‘':<8} {'ๅฎž้™…ๆ–นๅ‘':<8} {'ๅ‡†็กฎ':<4}") + print("-"*80) + + for i in range(min(20, len(predictions))): + pred_val = predictions[i] + actual_val = y[i] + pred_dir = "ไธŠๆถจ" if pred_val > 0 else "ไธ‹่ทŒ" + actual_dir = "ไธŠๆถจ" if actual_val > 0 else "ไธ‹่ทŒ" + correct = "โœ“" if (pred_val > 0) == (actual_val > 0) else "โœ—" + + timestamp = df_processed['timestamp'].iloc[i + 168] # +168ๅ› ไธบlookback + print(f"{str(timestamp):<20} {pred_val*100:>10.4f}% {actual_val*100:>10.4f}% {pred_dir:<8} {actual_dir:<8} {correct:<4}") + + print("\n" + "="*80) + print("โœ“ 2026ๅนด้ข„ๆต‹่ฏ„ไผฐๅฎŒๆˆ๏ผ") + print("="*80) + + print("\n๐Ÿ’ก ๆ€ป็ป“๏ผš") + print(f" - ๅœจ2026ๅนด {len(predictions)} ไธชๅฐๆ—ถ็š„้ข„ๆต‹ไธญ") + print(f" - ๆ–นๅ‘ๅ‡†็กฎ็Ž‡่พพๅˆฐ {dir_acc*100:.2f}%") + print(f" - ็ญ–็•ฅๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}%๏ผˆBuy & Hold: {buy_hold_return*100:.2f}%๏ผ‰") + + if dir_acc > 0.52 and total_return > 0: + print(f"\n โœ… ๆจกๅž‹ๅœจ2026ๅนด่กจ็Žฐ่‰ฏๅฅฝ๏ผŒๅฏไปฅ่€ƒ่™‘ๅฎž็›˜ๅฐไป“ไฝๆต‹่ฏ•") + elif dir_acc > 0.50: + print(f"\n โš ๏ธ ๆจกๅž‹้ข„ๆต‹่ƒฝๅŠ›ๆœ‰้™๏ผŒๅปบ่ฎฎ่ฐจๆ…Žไฝฟ็”จ") + else: + print(f"\n โŒ ๆจกๅž‹ๅœจ2026ๅนด้ข„ๆต‹ๅคฑ่ดฅ๏ผŒไธๅปบ่ฎฎๅฎž็›˜ไฝฟ็”จ") + +if __name__ == "__main__": + main() diff --git a/predict_2026_price.py b/predict_2026_price.py new file mode 100644 index 0000000..b7fc700 --- /dev/null +++ b/predict_2026_price.py @@ -0,0 +1,202 @@ +"""2026ๅนดไปทๆ ผ้ข„ๆต‹่„šๆœฌ๏ผš็›ดๆŽฅ้ข„ๆต‹ไปทๆ ผๅนถๅˆคๆ–ญๆถจ่ทŒๆ–นๅ‘""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import pickle +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear + +class PricePreprocessor: + """้ข„ๆต‹ๆœชๆฅไปทๆ ผ็š„้ข„ๅค„็†ๅ™จ""" + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.price_scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + df = df.copy() + df['rsi'] = ta.rsi(df['close'], length=14) + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + return df + + def create_labels(self, df): + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['label'] = df['future_price'] + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + df = self.add_features(df) + df = self.create_labels(df) + df = df.dropna().reset_index(drop=True) + + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + if fit: + scaled_features = self.scaler.fit_transform(df[feature_cols]) + scaled_labels = self.price_scaler.fit_transform(df[['label']]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled_features = self.scaler.transform(df[feature_cols]) + scaled_labels = self.price_scaler.transform(df[['label']]) + + X, y = [], [] + for i in range(len(scaled_features) - self.lookback): + X.append(scaled_features[i:i + self.lookback]) + y.append(scaled_labels[i + self.lookback, 0]) + + return np.array(X), np.array(y), df + + def inverse_transform_price(self, scaled_price): + return self.price_scaler.inverse_transform(scaled_price.reshape(-1, 1)).flatten() + +def main(): + print("="*80) + print("2026ๅนดBTCไปทๆ ผ้ข„ๆต‹ - ็›ดๆŽฅ้ข„ๆต‹ๆœชๆฅไปทๆ ผ") + print("="*80) + + # ========== ๅŠ ่ฝฝๆจกๅž‹ ========== + print("\n[1/4] ๅŠ ่ฝฝๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_predict_price/best_model.pt' + preprocessor_path = './models/checkpoints/dlinear_predict_price/preprocessor.pkl' + + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + with open(preprocessor_path, 'rb') as f: + preprocessor = pickle.load(f) + + print(f"โœ“ ๆจกๅž‹ๅŠ ่ฝฝๆˆๅŠŸ") + + # ========== ่Žทๅ–2026ๅนดๆ•ฐๆฎ ========== + print("\n[2/4] ่Žทๅ–2026ๅนดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + try: + df_2026 = fetcher.fetch_ohlcv('BTC', '1h', start_date='2026-01-01', + end_date='2026-12-31', use_cache=False) + except: + df_2026 = fetcher.fetch_ohlcv('BTC', '1h', start_date='2025-12-01', use_cache=False) + + print(f"โœ“ ๆ•ฐๆฎ้‡: {len(df_2026)} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df_2026['timestamp'].min()} ่‡ณ {df_2026['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df_2026['close'].iloc[0]:,.2f} โ†’ ${df_2026['close'].iloc[-1]:,.2f}") + + # ========== ้ข„ๅค„็† ========== + print("\n[3/4] ้ข„ๅค„็†ๅนถ้ข„ๆต‹...") + X, y, processed_df = preprocessor.preprocess(df_2026, fit=False) + + if len(X) == 0: + print("โŒ ๆ•ฐๆฎไธ่ถณ") + return + + # ๆจกๅž‹้ข„ๆต‹ + X_tensor = torch.FloatTensor(X).to(device) + with torch.no_grad(): + predictions = model(X_tensor).squeeze().cpu().numpy() + + # ่ฟ˜ๅŽŸไธบ็œŸๅฎžไปทๆ ผ + pred_prices = preprocessor.inverse_transform_price(predictions) + true_prices = preprocessor.inverse_transform_price(y) + + # ่Žทๅ–ๅฝ“ๅ‰ไปทๆ ผ + current_prices = processed_df['close'].iloc[168:168+len(pred_prices)].values + + # ========== ๆ–นๅ‘ๅˆคๆ–ญ ========== + print("\n[4/4] ๆถจ่ทŒๆ–นๅ‘่ฏ„ไผฐ...") + + pred_direction = (pred_prices > current_prices).astype(int) + true_direction = (true_prices > current_prices).astype(int) + + correct = (pred_direction == true_direction).sum() + accuracy = correct / len(predictions) + + from sklearn.metrics import confusion_matrix + cm = confusion_matrix(true_direction, pred_direction) + tn, fp, fn, tp = cm.ravel() + + print("\n" + "="*80) + print("๐Ÿ“Š 2026ๅนดไปทๆ ผ้ข„ๆต‹็ป“ๆžœ") + print("="*80) + + print(f"\nไปทๆ ผ้ข„ๆต‹่ฏฏๅทฎ:") + price_mae = np.abs(pred_prices - true_prices).mean() + price_rmse = np.sqrt(((pred_prices - true_prices) ** 2).mean()) + price_mape = np.mean(np.abs((true_prices - pred_prices) / true_prices)) * 100 + print(f" MAE: ${price_mae:,.2f}") + print(f" RMSE: ${price_rmse:,.2f}") + print(f" MAPE: {price_mape:.2f}%") + + print(f"\nๆ–นๅ‘้ข„ๆต‹็ปŸ่ฎก:") + print(f" ้ข„ๆต‹ไธŠๆถจ: {(pred_direction==1).sum()} / ๅฎž้™…ไธŠๆถจ: {(true_direction==1).sum()}") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {(pred_direction==0).sum()} / ๅฎž้™…ไธ‹่ทŒ: {(true_direction==0).sum()}") + + print(f"\nๆ–นๅ‘ๅ‡†็กฎ็Ž‡:") + print(f" ๆญฃ็กฎ: {correct}/{len(predictions)} ({accuracy*100:.2f}%)") + + print(f"\n่ฏฆ็ป†ๅˆ†ๆž:") + print(f" โœ“ ้ข„ๆต‹ๆถจไธ”็œŸๆถจ: {tp} ({tp/len(predictions)*100:.1f}%)") + print(f" โœ“ ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ: {tn} ({tn/len(predictions)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ: {fp} ({fp/len(predictions)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ: {fn} ({fn/len(predictions)*100:.1f}%)") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n" + "="*80) + print("๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ") + print("="*80) + + if accuracy > 0.55: + print(f"\n โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 55%๏ผŒๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›") + elif accuracy > 0.52: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 52%๏ผŒ็•ฅไผ˜ไบŽ้šๆœบ") + elif accuracy >= 0.48: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% โ‰ˆ 50%๏ผŒๆŽฅ่ฟ‘้šๆœบ") + else: + print(f"\n โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% < 48%๏ผŒไฝŽไบŽ้šๆœบ") + + # ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ + print("\n" + "="*80) + print("๐Ÿ“‹ ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ๏ผˆๅ‰30ไธช๏ผ‰") + print("="*80) + print(f"\n{'ๆ—ถ้—ด':<20} {'ๅฝ“ๅ‰ไปทๆ ผ':<12} {'้ข„ๆต‹ไปทๆ ผ':<12} {'ๅฎž้™…ไปทๆ ผ':<12} {'้ข„ๆต‹':<6} {'ๅฎž้™…':<6} {'็ป“ๆžœ':<4}") + print("-"*90) + + for i in range(min(30, len(predictions))): + timestamp = processed_df['timestamp'].iloc[i + 168] + curr = current_prices[i] + pred = pred_prices[i] + true = true_prices[i] + pred_dir = "ไธŠๆถจ" if pred > curr else "ไธ‹่ทŒ" + true_dir = "ไธŠๆถจ" if true > curr else "ไธ‹่ทŒ" + result = "โœ“" if pred_direction[i] == true_direction[i] else "โœ—" + + print(f"{str(timestamp):<20} ${curr:>10,.2f} ${pred:>10,.2f} ${true:>10,.2f} " + f"{pred_dir:<6} {true_dir:<6} {result:<4}") + + print("\n" + "="*80) + print(f"ๆ€ป็ป“: ๅœจ{len(predictions)}ๆฌก้ข„ๆต‹ไธญ๏ผŒๆ–นๅ‘ๆญฃ็กฎ{correct}ๆฌก ({accuracy*100:.2f}%)") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/predict_2026_simple.py b/predict_2026_simple.py new file mode 100644 index 0000000..f51d9d3 --- /dev/null +++ b/predict_2026_simple.py @@ -0,0 +1,230 @@ +"""็ฎ€ๅŒ–้ข„ๆต‹่„šๆœฌ๏ผšๅชๅˆคๆ–ญๆถจ่ทŒๆ–นๅ‘ๆญฃ็กฎๆ€ง""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import pickle +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear + +class SimplePreprocessor: + """็ฎ€ๅŒ–็š„้ข„ๅค„็†ๅ™จ๏ผšๅชไฝฟ็”จOHLCV + RSI + MACD""" + + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + """ๆทปๅŠ RSIๅ’ŒMACD็‰นๅพ""" + df = df.copy() + df['rsi'] = ta.rsi(df['close'], length=14) + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + return df + + def create_labels(self, df): + """ๅˆ›ๅปบๆ ‡็ญพ๏ผšๆœชๆฅ1ๅฐๆ—ถ็š„ๆ”ถ็›Š็Ž‡""" + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['future_return'] = (df['future_price'] - df['close']) / df['close'] + df['label'] = df['future_return'] + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + """ๅฎŒๆ•ด้ข„ๅค„็†ๆต็จ‹""" + df = self.add_features(df) + df = self.create_labels(df) + df = df.dropna().reset_index(drop=True) + + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + if fit: + scaled = self.scaler.fit_transform(df[feature_cols]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled = self.scaler.transform(df[feature_cols]) + + X, y = [], [] + for i in range(len(scaled) - self.lookback): + X.append(scaled[i:i + self.lookback]) + y.append(df['label'].iloc[i + self.lookback]) + + return np.array(X), np.array(y), df + +def main(): + print("="*80) + print("2026ๅนดBTCๆถจ่ทŒๆ–นๅ‘้ข„ๆต‹") + print("="*80) + + # ========== ๆญฅ้ชค1: ๅŠ ่ฝฝๆจกๅž‹ ========== + print("\n[1/5] ๅŠ ่ฝฝๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_simple_features/best_model.pt' + preprocessor_path = './models/checkpoints/dlinear_simple_features/preprocessor.pkl' + + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + with open(preprocessor_path, 'rb') as f: + preprocessor = pickle.load(f) + + print(f"โœ“ ๆจกๅž‹ๅŠ ่ฝฝๆˆๅŠŸ") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡: {len(preprocessor.feature_columns)}") + + # ========== ๆญฅ้ชค2: ่Žทๅ–2026ๅนดๆ•ฐๆฎ ========== + print("\n[2/5] ่Žทๅ–2026ๅนดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + try: + df_2026 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2026-01-01', + end_date='2026-12-31', + use_cache=False + ) + except: + print("โš ๏ธ ่Žทๅ–ๆœ€ๆ–ฐๅฏ็”จๆ•ฐๆฎ...") + df_2026 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2025-12-01', + use_cache=False + ) + + print(f"โœ“ ๆ•ฐๆฎ้‡: {len(df_2026)} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df_2026['timestamp'].min()} ่‡ณ {df_2026['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df_2026['close'].iloc[0]:,.2f} โ†’ ${df_2026['close'].iloc[-1]:,.2f}") + + # ========== ๆญฅ้ชค3: ้ข„ๅค„็† ========== + print("\n[3/5] ้ข„ๅค„็†ๆ•ฐๆฎ...") + X, y, processed_df = preprocessor.preprocess(df_2026, fit=False) + + print(f"โœ“ ้ข„ๆต‹ๅบๅˆ—: {len(X)} ไธช") + print(f"โœ“ ๅฎž้™…ๆถจ่ทŒ: ไธŠๆถจ{(y>0).sum()}ๆฌก, ไธ‹่ทŒ{(y<=0).sum()}ๆฌก") + + if len(X) == 0: + print("โŒ ๆ•ฐๆฎไธ่ถณ") + return + + # ========== ๆญฅ้ชค4: ้ข„ๆต‹ ========== + print("\n[4/5] ๆจกๅž‹้ข„ๆต‹...") + X_tensor = torch.FloatTensor(X).to(device) + + with torch.no_grad(): + predictions = model(X_tensor).squeeze().cpu().numpy() + + print(f"โœ“ ้ข„ๆต‹ๅฎŒๆˆ") + print(f"โœ“ ้ข„ๆต‹ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {predictions.min()*100:.4f}% ~ {predictions.max()*100:.4f}%") + + # ========== ๆญฅ้ชค5: ๆ–นๅ‘ๅˆคๆ–ญ ========== + print("\n[5/5] ๆถจ่ทŒๆ–นๅ‘่ฏ„ไผฐ...") + + # ้ข„ๆต‹ๆ–นๅ‘๏ผšๆญฃๅ€ผ=ไธŠๆถจ๏ผŒ่ดŸๅ€ผ=ไธ‹่ทŒ + pred_direction = (predictions > 0).astype(int) # 1=ๆถจ, 0=่ทŒ + true_direction = (y > 0).astype(int) + + # ็ปŸ่ฎก + n_pred_up = (pred_direction == 1).sum() + n_pred_down = (pred_direction == 0).sum() + n_true_up = (true_direction == 1).sum() + n_true_down = (true_direction == 0).sum() + + # ๅ‡†็กฎ็Ž‡ + correct = (pred_direction == true_direction).sum() + accuracy = correct / len(predictions) + + # ๆททๆท†็Ÿฉ้˜ต + from sklearn.metrics import confusion_matrix + cm = confusion_matrix(true_direction, pred_direction) + tn, fp, fn, tp = cm.ravel() + + print("\n" + "="*80) + print("๐Ÿ“Š ๆถจ่ทŒๆ–นๅ‘้ข„ๆต‹็ป“ๆžœ") + print("="*80) + + print(f"\n้ข„ๆต‹็ปŸ่ฎก:") + print(f" ้ข„ๆต‹ไธŠๆถจ: {n_pred_up} ({n_pred_up/len(predictions)*100:.1f}%)") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {n_pred_down} ({n_pred_down/len(predictions)*100:.1f}%)") + + print(f"\nๅฎž้™…็ปŸ่ฎก:") + print(f" ๅฎž้™…ไธŠๆถจ: {n_true_up} ({n_true_up/len(y)*100:.1f}%)") + print(f" ๅฎž้™…ไธ‹่ทŒ: {n_true_down} ({n_true_down/len(y)*100:.1f}%)") + + print(f"\nๅ‡†็กฎ็Ž‡:") + print(f" ๆ–นๅ‘ๆญฃ็กฎ: {correct}/{len(predictions)} ({accuracy*100:.2f}%)") + + print(f"\n่ฏฆ็ป†ๅˆ†ๆž:") + print(f" โœ“ ้ข„ๆต‹ๆถจไธ”็œŸๆถจ: {tp} ({tp/len(y)*100:.1f}%)") + print(f" โœ“ ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ: {tn} ({tn/len(y)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ: {fp} ({fp/len(y)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ: {fn} ({fn/len(y)*100:.1f}%)") + + # ้ข„ๆต‹ๅๅทฎ + bias = n_pred_up - n_true_up + print(f"\n้ข„ๆต‹ๅๅทฎ:") + if abs(bias) < len(predictions) * 0.05: + print(f" โœ… ้ข„ๆต‹ๅนณ่กก๏ผˆๅๅทฎ{bias}ไธช๏ผ‰") + elif bias > 0: + print(f" โš ๏ธ ๅๅ‘้ข„ๆต‹ไธŠๆถจ๏ผˆๅคš้ข„ๆต‹{bias}ๆฌกไธŠๆถจ๏ผ‰") + else: + print(f" โš ๏ธ ๅๅ‘้ข„ๆต‹ไธ‹่ทŒ๏ผˆๅคš้ข„ๆต‹{-bias}ๆฌกไธ‹่ทŒ๏ผ‰") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n" + "="*80) + print("๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ") + print("="*80) + + if accuracy > 0.55: + print(f"\n โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 55%") + print(f" ๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›๏ผŒๅฏ่€ƒ่™‘ๅฎž็›˜ๆต‹่ฏ•") + elif accuracy > 0.52: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 52%") + print(f" ๆจกๅž‹็•ฅไผ˜ไบŽ้šๆœบ๏ผŒ่ฐจๆ…Žไฝฟ็”จ") + elif accuracy >= 0.48: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% โ‰ˆ 50%") + print(f" ๆŽฅ่ฟ‘้šๆœบ็Œœๆต‹๏ผŒไธๅปบ่ฎฎๅฎž็›˜") + else: + print(f"\n โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% < 48%") + print(f" ไฝŽไบŽ้šๆœบ๏ผŒๆจกๅž‹ๅคฑๆ•ˆ") + + # ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ + print("\n" + "="*80) + print("๐Ÿ“‹ ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ๏ผˆๅ‰30ไธช๏ผ‰") + print("="*80) + print(f"\n{'ๆ—ถ้—ด':<20} {'้ข„ๆต‹':<6} {'ๅฎž้™…':<6} {'็ป“ๆžœ':<4} {'้ข„ๆต‹ๅ€ผ':<10}") + print("-"*60) + + for i in range(min(30, len(predictions))): + timestamp = processed_df['timestamp'].iloc[i + 168] + pred = "ไธŠๆถจ" if pred_direction[i] == 1 else "ไธ‹่ทŒ" + true = "ไธŠๆถจ" if true_direction[i] == 1 else "ไธ‹่ทŒ" + result = "โœ“" if pred_direction[i] == true_direction[i] else "โœ—" + pred_val = predictions[i] + + print(f"{str(timestamp):<20} {pred:<6} {true:<6} {result:<4} {pred_val*100:>8.4f}%") + + print("\n" + "="*80) + print(f"ๆ€ป็ป“: ๅœจ{len(predictions)}ๆฌก้ข„ๆต‹ไธญ๏ผŒๆ–นๅ‘ๆญฃ็กฎ{correct}ๆฌก ({accuracy*100:.2f}%)") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..161f195 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,40 @@ +# Core dependencies +torch>=2.0.0 +torchvision +torchaudio +python-binance>=1.0.19 +pandas>=2.0.0 +numpy>=1.24.0 +scikit-learn>=1.3.0 +pytz +python-dotenv>=1.0.0 + +# ONNX +onnx>=1.14.0 +onnxruntime>=1.15.0 + +# Model-specific dependencies +darts>=0.27.0 +u8darts[torch]>=0.27.0 +tsfm_public>=0.2.0 +gluonts[torch]>=0.14.0 + +# API dependencies +fastapi>=0.104.0 +uvicorn[standard]>=0.24.0 +pydantic>=2.0.0 +python-multipart>=0.0.6 + +# Technical indicators +pandas-ta>=0.3.14b + +# Development tools +jupyter>=1.0.0 +matplotlib>=3.7.0 +seaborn>=0.12.0 +pytest>=7.4.0 +black>=23.0.0 +flake8>=6.0.0 + +# Utilities +tqdm>=4.66.0 diff --git a/scripts/generate_sample_data.py b/scripts/generate_sample_data.py new file mode 100644 index 0000000..837efa8 --- /dev/null +++ b/scripts/generate_sample_data.py @@ -0,0 +1,97 @@ +"""็”Ÿๆˆๆต‹่ฏ•ๆ•ฐๆฎไปฅไพฟๅœจๆ— ๆณ•่ฟžๆŽฅBinanceๆ—ถไฝฟ็”จ""" + +import pandas as pd +import numpy as np +from datetime import datetime, timedelta +from pathlib import Path + + +def generate_sample_data( + symbol: str = 'BTC', + timeframe: str = '1h', + num_days: int = 365 +): + """็”Ÿๆˆๆจกๆ‹Ÿ็š„OHLCVๆ•ฐๆฎ็”จไบŽๆต‹่ฏ• + + Args: + symbol: ๅธ็ง็ฌฆๅท + timeframe: ๆ—ถ้—ดๆก†ๆžถ + num_days: ็”Ÿๆˆๆ•ฐๆฎ็š„ๅคฉๆ•ฐ + """ + # ่ฎก็ฎ—ๆ•ฐๆฎ็‚นๆ•ฐ้‡ + if timeframe == '1h': + periods = num_days * 24 + elif timeframe == '15m': + periods = num_days * 24 * 4 + else: + periods = num_days * 24 + + # ็”Ÿๆˆๆ—ถ้—ดๆˆณ + end_time = datetime.now() + start_time = end_time - timedelta(days=num_days) + + if timeframe == '1h': + timestamps = pd.date_range(start=start_time, end=end_time, freq='h') + else: # 15m + timestamps = pd.date_range(start=start_time, end=end_time, freq='15min') + + # ็”Ÿๆˆไปทๆ ผๆ•ฐๆฎ๏ผˆ้šๆœบๆธธ่ตฐ๏ผ‰ + base_price = { + 'BTC': 45000, + 'ETH': 2500, + 'SOL': 100 + }.get(symbol, 10000) + + np.random.seed(42) # ๅ›บๅฎš็งๅญไปฅไพฟๅค็Žฐ + + # ็”Ÿๆˆๆ”ถ็›Š็Ž‡ + returns = np.random.normal(0.0001, 0.02, len(timestamps)) + prices = base_price * np.exp(np.cumsum(returns)) + + # ็”ŸๆˆOHLCVๆ•ฐๆฎ + data = [] + for i, (ts, close) in enumerate(zip(timestamps, prices)): + # ็”Ÿๆˆ้ซ˜ไฝŽไปท + volatility = close * 0.01 + high = close + np.random.uniform(0, volatility) + low = close - np.random.uniform(0, volatility) + + # ๅผ€็›˜ไปท๏ผˆๅ‰ไธ€ไธชๆ”ถ็›˜ไปท๏ผ‰ + if i == 0: + open_price = close + else: + open_price = prices[i-1] + + # ๆˆไบค้‡ + volume = np.random.uniform(1000, 10000) + + data.append({ + 'timestamp': ts, + 'open': open_price, + 'high': high, + 'low': low, + 'close': close, + 'volume': volume + }) + + df = pd.DataFrame(data) + + # ไฟๅญ˜ๅˆฐ็ผ“ๅญ˜ + cache_dir = Path('./data/cache') + cache_dir.mkdir(parents=True, exist_ok=True) + + cache_file = cache_dir / f"{symbol}_{timeframe}_1y_now.csv" + df.to_csv(cache_file, index=False) + + print(f"โœ“ ๅทฒ็”Ÿๆˆ {len(df)} ่กŒๆจกๆ‹Ÿๆ•ฐๆฎๅนถไฟๅญ˜ๅˆฐ๏ผš{cache_file}") + return df + + +if __name__ == "__main__": + # ็”ŸๆˆBTCใ€ETHใ€SOL็š„ๆต‹่ฏ•ๆ•ฐๆฎ + for symbol in ['BTC', 'ETH', 'SOL']: + for timeframe in ['1h', '15m']: + print(f"\n็”Ÿๆˆ {symbol} {timeframe} ๆ•ฐๆฎ...") + generate_sample_data(symbol, timeframe) + + print("\nโœ“ ๆ‰€ๆœ‰ๆต‹่ฏ•ๆ•ฐๆฎๅทฒ็”Ÿๆˆ๏ผ") diff --git a/test_2026_classification.py b/test_2026_classification.py new file mode 100644 index 0000000..622ce43 --- /dev/null +++ b/test_2026_classification.py @@ -0,0 +1,232 @@ +"""ๅœจ2026ๅนดๆ•ฐๆฎไธŠๆต‹่ฏ•ๅˆ†็ฑปๆจกๅž‹""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import torch +import pickle +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +from sklearn.metrics import confusion_matrix, classification_report +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear + +class ClassificationPreprocessor: + """ๅˆ†็ฑปไปปๅŠก้ข„ๅค„็†ๅ™จ""" + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + df = df.copy() + df['rsi'] = ta.rsi(df['close'], length=14) + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + return df + + def create_labels(self, df): + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['future_return'] = (df['future_price'] - df['close']) / df['close'] + df['label'] = (df['future_return'] > 0).astype(int) + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + df = self.add_features(df) + df = self.create_labels(df) + df = df.dropna().reset_index(drop=True) + + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + if fit: + scaled_features = self.scaler.fit_transform(df[feature_cols]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled_features = self.scaler.transform(df[feature_cols]) + + X, y = [], [] + for i in range(len(scaled_features) - self.lookback): + X.append(scaled_features[i:i + self.lookback]) + y.append(df['label'].iloc[i + self.lookback]) + + return np.array(X), np.array(y), df + +def main(): + print("="*80) + print("2026ๅนดๅˆ†็ฑปๆจกๅž‹ๆต‹่ฏ•") + print("="*80) + + # ========== ๅŠ ่ฝฝๆจกๅž‹ ========== + print("\n[1/4] ๅŠ ่ฝฝๆจกๅž‹...") + model_path = './models/checkpoints/dlinear_classification_2026/best_model.pt' + preprocessor_path = './models/checkpoints/dlinear_classification_2026/preprocessor.pkl' + + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + checkpoint = torch.load(model_path, map_location=device, weights_only=False) + model = DLinear(checkpoint['config']) + model.load_state_dict(checkpoint['model_state_dict']) + model = model.to(device) + model.eval() + + with open(preprocessor_path, 'rb') as f: + preprocessor = pickle.load(f) + + print(f"โœ“ ๆจกๅž‹ๅŠ ่ฝฝๆˆๅŠŸ") + print(f"โœ“ ไปปๅŠก็ฑปๅž‹: ๅˆ†็ฑป๏ผˆ้ข„ๆต‹ๆถจ/่ทŒ๏ผ‰") + + # ========== ่Žทๅ–2026ๅนดๆ•ฐๆฎ ========== + print("\n[2/4] ่Žทๅ–2026ๅนดๆต‹่ฏ•ๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + try: + df_2026 = fetcher.fetch_ohlcv('BTC', '1h', start_date='2026-01-01', + end_date='2026-12-31', use_cache=False) + except: + df_2026 = fetcher.fetch_ohlcv('BTC', '1h', start_date='2025-12-01', use_cache=False) + + print(f"โœ“ ๆต‹่ฏ•ๆ•ฐๆฎ: {len(df_2026)} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df_2026['timestamp'].min()} ่‡ณ {df_2026['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df_2026['close'].iloc[0]:,.2f} โ†’ ${df_2026['close'].iloc[-1]:,.2f}") + + # ========== ้ข„ๅค„็† ========== + print("\n[3/4] ้ข„ๅค„็†ๅนถ้ข„ๆต‹...") + X_test, y_test, processed_df = preprocessor.preprocess(df_2026, fit=False) + + if len(X_test) == 0: + print("โŒ ๆ•ฐๆฎไธ่ถณ") + return + + print(f"โœ“ ๆต‹่ฏ•ๅบๅˆ—: {len(X_test)}") + + # ็œŸๅฎžๆ ‡็ญพ็ปŸ่ฎก + n_true_up = (y_test == 1).sum() + n_true_down = (y_test == 0).sum() + print(f"โœ“ ๅฎž้™…ๆถจ่ทŒ: ไธŠๆถจ{n_true_up}ๆฌก ({n_true_up/len(y_test)*100:.1f}%), " + f"ไธ‹่ทŒ{n_true_down}ๆฌก ({n_true_down/len(y_test)*100:.1f}%)") + + # ๆจกๅž‹้ข„ๆต‹ + X_tensor = torch.FloatTensor(X_test).to(device) + with torch.no_grad(): + logits = model(X_tensor).squeeze().cpu().numpy() + probs = 1 / (1 + np.exp(-logits)) # sigmoid + preds = (probs > 0.5).astype(int) + + # ========== ่ฏ„ไผฐ ========== + print("\n[4/4] ่ฏ„ไผฐ็ป“ๆžœ...") + + # ๅŸบ็ก€็ปŸ่ฎก + n_pred_up = (preds == 1).sum() + n_pred_down = (preds == 0).sum() + accuracy = (preds == y_test).mean() + + # ๆททๆท†็Ÿฉ้˜ต + cm = confusion_matrix(y_test, preds) + tn, fp, fn, tp = cm.ravel() + + print("\n" + "="*80) + print("๐Ÿ“Š 2026ๅนดๆต‹่ฏ•็ป“ๆžœ๏ผˆๅˆ†็ฑปไปปๅŠก๏ผ‰") + print("="*80) + + print(f"\n้ข„ๆต‹็ปŸ่ฎก:") + print(f" ้ข„ๆต‹ไธŠๆถจ: {n_pred_up} ({n_pred_up/len(preds)*100:.1f}%)") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {n_pred_down} ({n_pred_down/len(preds)*100:.1f}%)") + + print(f"\nๅฎž้™…็ปŸ่ฎก:") + print(f" ๅฎž้™…ไธŠๆถจ: {n_true_up} ({n_true_up/len(y_test)*100:.1f}%)") + print(f" ๅฎž้™…ไธ‹่ทŒ: {n_true_down} ({n_true_down/len(y_test)*100:.1f}%)") + + print(f"\nโœจ ๅ‡†็กฎ็Ž‡: {accuracy*100:.2f}%") + + print(f"\n่ฏฆ็ป†ๅˆ†ๆž:") + print(f" โœ“ ้ข„ๆต‹ๆถจไธ”็œŸๆถจ (TP): {tp} ({tp/len(preds)*100:.1f}%)") + print(f" โœ“ ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ (TN): {tn} ({tn/len(preds)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ (FP): {fp} ({fp/len(preds)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ (FN): {fn} ({fn/len(preds)*100:.1f}%)") + + # ็ฒพ็กฎ็Ž‡ใ€ๅฌๅ›ž็Ž‡ใ€F1 + precision = tp / (tp + fp) if (tp + fp) > 0 else 0 + recall = tp / (tp + fn) if (tp + fn) > 0 else 0 + f1 = 2 * precision * recall / (precision + recall) if (precision + recall) > 0 else 0 + + print(f"\nๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ็ฒพ็กฎ็Ž‡ (Precision): {precision*100:.2f}%") + print(f" ๅฌๅ›ž็Ž‡ (Recall): {recall*100:.2f}%") + print(f" F1ๅˆ†ๆ•ฐ: {f1:.4f}") + + # ้ข„ๆต‹ๅๅทฎๅˆ†ๆž + bias = n_pred_up - n_true_up + print(f"\n้ข„ๆต‹ๅๅทฎ:") + if abs(bias) < len(preds) * 0.05: + print(f" โœ… ้ข„ๆต‹ๅนณ่กก๏ผˆๅๅทฎ{bias}ไธช๏ผ‰") + elif bias > 0: + print(f" โš ๏ธ ๅๅ‘้ข„ๆต‹ไธŠๆถจ๏ผˆๅคš้ข„ๆต‹{bias}ๆฌกไธŠๆถจ๏ผ‰") + else: + print(f" โš ๏ธ ๅๅ‘้ข„ๆต‹ไธ‹่ทŒ๏ผˆๅคš้ข„ๆต‹{-bias}ๆฌกไธ‹่ทŒ๏ผ‰") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n" + "="*80) + print("๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ") + print("="*80) + + if accuracy > 0.55: + print(f"\n โœ… ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 55%๏ผŒๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›๏ผ") + elif accuracy > 0.52: + print(f"\n โš ๏ธ ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% > 52%๏ผŒ็•ฅไผ˜ไบŽ้šๆœบ") + elif accuracy >= 0.48: + print(f"\n โš ๏ธ ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% โ‰ˆ 50%๏ผŒๆŽฅ่ฟ‘้šๆœบ") + else: + print(f"\n โŒ ๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}% < 48%๏ผŒไฝŽไบŽ้šๆœบ") + + # ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ + print("\n" + "="*80) + print("๐Ÿ“‹ ้ข„ๆต‹ๆ ทๆœฌๅฑ•็คบ๏ผˆๅ‰30ไธช๏ผ‰") + print("="*80) + print(f"\n{'ๆ—ถ้—ด':<20} {'้ข„ๆต‹ๆฆ‚็Ž‡':<10} {'้ข„ๆต‹':<6} {'ๅฎž้™…':<6} {'็ป“ๆžœ':<4}") + print("-"*60) + + for i in range(min(30, len(preds))): + timestamp = processed_df['timestamp'].iloc[i + 168] + prob = probs[i] + pred = "ไธŠๆถจ" if preds[i] == 1 else "ไธ‹่ทŒ" + true = "ไธŠๆถจ" if y_test[i] == 1 else "ไธ‹่ทŒ" + result = "โœ“" if preds[i] == y_test[i] else "โœ—" + + print(f"{str(timestamp):<20} {prob:>8.4f} {pred:<6} {true:<6} {result:<4}") + + print("\n" + "="*80) + print(f"ๆ€ป็ป“: ๅœจ{len(preds)}ๆฌก้ข„ๆต‹ไธญ๏ผŒๅ‡†็กฎ็Ž‡ {accuracy*100:.2f}%") + print("="*80) + + # ไฟๅญ˜็ป“ๆžœ + results = { + 'accuracy': float(accuracy), + 'precision': float(precision), + 'recall': float(recall), + 'f1_score': float(f1), + 'true_positives': int(tp), + 'true_negatives': int(tn), + 'false_positives': int(fp), + 'false_negatives': int(fn), + 'n_samples': int(len(preds)) + } + + import json + with open('./models/checkpoints/dlinear_classification_2026/test_2026_results.json', 'w') as f: + json.dump(results, f, indent=2) + + print(f"\nโœ“ ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ: ./models/checkpoints/dlinear_classification_2026/test_2026_results.json") + +if __name__ == "__main__": + main() diff --git a/test_binance_api.py b/test_binance_api.py new file mode 100644 index 0000000..d800002 --- /dev/null +++ b/test_binance_api.py @@ -0,0 +1,65 @@ +"""ๆต‹่ฏ•Binance API่ฟžๆŽฅ๏ผˆไฝฟ็”จSOCKS5ไปฃ็†๏ผ‰""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher + +def main(): + print("="*80) + print("ๆต‹่ฏ•Binance API่ฟžๆŽฅ - SOCKS5ไปฃ็†") + print("="*80) + + # ๆต‹่ฏ•่ฟžๆŽฅ + fetcher = BinanceDataFetcher() + + if fetcher.client is None: + print("\nโŒ API่ฟžๆŽฅๅคฑ่ดฅ๏ผŒๅฐ†ไฝฟ็”จ็ผ“ๅญ˜ๆ•ฐๆฎ") + return + + print("\nโœ“ API่ฟžๆŽฅๆˆๅŠŸ๏ผ") + + # ่Žทๅ–ๅฝ“ๅ‰ไปทๆ ผ + try: + btc_price = fetcher.get_latest_price('BTC') + eth_price = fetcher.get_latest_price('ETH') + sol_price = fetcher.get_latest_price('SOL') + + print(f"\nๅฝ“ๅ‰ไปทๆ ผ:") + print(f" BTC: ${btc_price:,.2f}") + print(f" ETH: ${eth_price:,.2f}") + print(f" SOL: ${sol_price:,.2f}") + except Exception as e: + print(f"\nโŒ ่Žทๅ–ไปทๆ ผๅคฑ่ดฅ: {e}") + return + + # ่Žทๅ–ๅŽ†ๅฒๆ•ฐๆฎ๏ผˆ1ๅคฉๆต‹่ฏ•๏ผ‰ + try: + print("\nๆญฃๅœจ่Žทๅ–BTC 1ๅฐๆ—ถๆ•ฐๆฎ๏ผˆๆœ€่ฟ‘1ๅคฉ๏ผ‰...") + from datetime import datetime, timedelta + end_date = datetime.now() + start_date = end_date - timedelta(days=1) + + df = fetcher.fetch_ohlcv( + 'BTC', + '1h', + start_date=start_date.strftime('%Y-%m-%d'), + end_date=end_date.strftime('%Y-%m-%d'), + use_cache=False # ๅผบๅˆถไปŽAPI่Žทๅ– + ) + + print(f"โœ“ ๆˆๅŠŸ่Žทๅ– {len(df)} ่กŒๆ•ฐๆฎ") + print(f"\nๆœ€ๆ–ฐๆ•ฐๆฎ:") + print(df.tail()) + + except Exception as e: + print(f"\nโŒ ่Žทๅ–ๅŽ†ๅฒๆ•ฐๆฎๅคฑ่ดฅ: {e}") + return + + print("\n" + "="*80) + print("โœ“ Binance APIๆต‹่ฏ•้€š่ฟ‡๏ผไปฃ็†ๅทฅไฝœๆญฃๅธธ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/test_dlinear.py b/test_dlinear.py new file mode 100644 index 0000000..5cabc0e --- /dev/null +++ b/test_dlinear.py @@ -0,0 +1,169 @@ +"""ๅŠ ๅฏ†่ดงๅธไปทๆ ผ้ข„ๆต‹็ณป็ปŸ - DLinearๆจกๅž‹็ซฏๅˆฐ็ซฏๆต‹่ฏ•""" + +import sys +import os + +# ๆทปๅŠ ้กน็›ฎๆ น็›ฎๅฝ•ๅˆฐ่ทฏๅพ„ +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig + +def main(): + print("="*80) + print("ๅŠ ๅฏ†่ดงๅธไปทๆ ผ้ข„ๆต‹็ณป็ปŸ - DLINEARๆจกๅž‹ๆต‹่ฏ•") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–ๆ•ฐๆฎ + print("\n[1/7] ไปŽBinance่Žทๅ–BTC 1ๅฐๆ—ถๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒๆ•ฐๆฎ๏ผŒๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็† + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ใ€ๅˆ›ๅปบๅบๅˆ—๏ผ‰...") + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + print(f"โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผšไธ‹่ทŒ(0) = {(y==0).sum()}, ไธŠๆถจ(1) = {(y==1).sum()}") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† + print("\n[3/7] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/7] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', + batch_size=64 + ) + print(f"โœ“ ่ฎญ็ปƒๆ‰นๆฌก๏ผš{len(train_loader)}") + print(f"โœ“ ้ชŒ่ฏๆ‰นๆฌก๏ผš{len(val_loader)}") + print(f"โœ“ ๆต‹่ฏ•ๆ‰นๆฌก๏ผš{len(test_loader)}") + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ + print("\n[6/7] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=20, # ๆต‹่ฏ•็”จ่พƒๅฐ‘่ฝฎๆ•ฐ + learning_rate=0.001, + early_stopping_patience=5, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_test' + ) + + trainer = Trainer(model, train_config, task='classification') + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/7] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ๆ‰“ๅฐ็ป“ๆžœๆ‘˜่ฆ + print("\n" + "="*80) + print("ๆœ€็ปˆๆต‹่ฏ•็ป“ๆžœ") + print("="*80) + print(f"\nๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f}") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\nๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง: {metrics['true_positives']}") + print(f" ็œŸ้˜ดๆ€ง: {metrics['true_negatives']}") + print(f" ๅ‡้˜ณๆ€ง: {metrics['false_positives']}") + print(f" ๅ‡้˜ดๆ€ง: {metrics['false_negatives']}") + + print(f"\nๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + print(f" ๆœ€ๅคงๅ›žๆ’ค: {metrics.get('backtest_max_drawdown', 0)*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ๆต‹่ฏ•ONNXๅฏผๅ‡บ + print("\n" + "="*80) + print("ๆต‹่ฏ•ONNXๅฏผๅ‡บ") + print("="*80) + + try: + import onnx + import onnxruntime as ort + import torch + import numpy as np + + onnx_path = './models/checkpoints/dlinear_test/model.onnx' + os.makedirs(os.path.dirname(onnx_path), exist_ok=True) + + print("\n[1/3] ๅฏผๅ‡บๆจกๅž‹ๅˆฐONNXๆ ผๅผ...") + model.to_onnx(onnx_path) + print(f"โœ“ ONNXๆจกๅž‹ๅทฒไฟๅญ˜่‡ณ๏ผš{onnx_path}") + + print("\n[2/3] ้ชŒ่ฏONNXๆจกๅž‹...") + onnx_model = onnx.load(onnx_path) + onnx.checker.check_model(onnx_model) + print("โœ“ ONNXๆจกๅž‹ๆœ‰ๆ•ˆ") + + print("\n[3/3] ๆต‹่ฏ•ONNXๆŽจ็†ไธŽPyTorchๅฏนๆฏ”...") + # ๅˆ›ๅปบๆต‹่ฏ•่พ“ๅ…ฅ + test_input = torch.randn(1, 168, X.shape[-1]) + + # PyTorchๆŽจ็†๏ผˆๅœจCPUไธŠ๏ผ‰ + model.cpu() + model.eval() + with torch.no_grad(): + pytorch_output = model(test_input).numpy() + + # ONNXๆŽจ็† + ort_session = ort.InferenceSession(onnx_path) + onnx_output = ort_session.run( + None, + {'input': test_input.numpy()} + )[0] + + # ๆฏ”่พƒ่พ“ๅ‡บ + diff = np.abs(pytorch_output - onnx_output).max() + print(f"โœ“ PyTorchไธŽONNX็š„ๆœ€ๅคงๅทฎๅผ‚๏ผš{diff:.8f}") + + if diff < 1e-5: + print("โœ“ ONNXๅฏผๅ‡บๆˆๅŠŸ๏ผ่พ“ๅ‡บๅœจๅฎนๅทฎ่Œƒๅ›ดๅ†…ๅŒน้…ใ€‚") + else: + print("โš  ่ญฆๅ‘Š๏ผšONNX่พ“ๅ‡บไธŽPyTorchๆœ‰ๅทฎๅผ‚๏ผˆไฝ†ๅฏ่ƒฝไปๅฏๆŽฅๅ—๏ผ‰") + + except Exception as e: + print(f"โœ— ONNXๅฏผๅ‡บๅคฑ่ดฅ๏ผš{e}") + + print("\n" + "="*80) + print("ๆต‹่ฏ•ๆˆๅŠŸๅฎŒๆˆ๏ผ") + print("="*80) + print("\nไธ‹ไธ€ๆญฅ:") + print(" 1. ๆŸฅ็œ‹่ฎญ็ปƒๅŽ†ๅฒ๏ผš./models/checkpoints/dlinear_test/") + print(" 2. ๅฎž็ŽฐN-BEATSๆจกๅž‹๏ผˆ้˜ถๆฎต3๏ผ‰") + print(" 3. ๅœจๆ‰€ๆœ‰ๅธ็งไธŠ่ฎญ็ปƒ๏ผˆBTCใ€ETHใ€SOL๏ผ‰") + print(" 4. ๅˆ›ๅปบFastAPI้ข„ๆต‹ๆœๅŠก") + +if __name__ == "__main__": + main() diff --git a/test_historical_data.py b/test_historical_data.py new file mode 100644 index 0000000..77d99b6 --- /dev/null +++ b/test_historical_data.py @@ -0,0 +1,149 @@ +"""ๆต‹่ฏ•่Žทๅ–2020-2023ๅนด็š„ๅŽ†ๅฒๆ•ฐๆฎ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +import pandas as pd + +def test_historical_data(): + print("="*80) + print("ๆต‹่ฏ•Binance APIๅŽ†ๅฒๆ•ฐๆฎ่Žทๅ–่ƒฝๅŠ›") + print("="*80) + + fetcher = BinanceDataFetcher() + + # ๆต‹่ฏ•1: ่Žทๅ–2020ๅนด็š„ๆ•ฐๆฎ + print("\n[ๆต‹่ฏ•1] ๅฐ่ฏ•่Žทๅ–2020ๅนดๅ…จๅนดๆ•ฐๆฎ...") + try: + df_2020 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2020-12-31', + use_cache=False # ไธไฝฟ็”จ็ผ“ๅญ˜๏ผŒๅผบๅˆถไปŽAPI่Žทๅ– + ) + print(f"โœ… ๆˆๅŠŸ่Žทๅ–2020ๅนดๆ•ฐๆฎ") + print(f" ๆ•ฐๆฎ่กŒๆ•ฐ: {len(df_2020)}") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {df_2020['timestamp'].min()} ่‡ณ {df_2020['timestamp'].max()}") + print(f" ไปทๆ ผ่Œƒๅ›ด: ${df_2020['close'].min():,.2f} - ${df_2020['close'].max():,.2f}") + except Exception as e: + print(f"โŒ 2020ๅนดๆ•ฐๆฎ่Žทๅ–ๅคฑ่ดฅ: {e}") + return False + + # ๆต‹่ฏ•2: ่Žทๅ–2021ๅนด็š„ๆ•ฐๆฎ + print("\n[ๆต‹่ฏ•2] ๅฐ่ฏ•่Žทๅ–2021ๅนดๅ…จๅนดๆ•ฐๆฎ...") + try: + df_2021 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2021-01-01', + end_date='2021-12-31', + use_cache=False + ) + print(f"โœ… ๆˆๅŠŸ่Žทๅ–2021ๅนดๆ•ฐๆฎ") + print(f" ๆ•ฐๆฎ่กŒๆ•ฐ: {len(df_2021)}") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {df_2021['timestamp'].min()} ่‡ณ {df_2021['timestamp'].max()}") + print(f" ไปทๆ ผ่Œƒๅ›ด: ${df_2021['close'].min():,.2f} - ${df_2021['close'].max():,.2f}") + except Exception as e: + print(f"โŒ 2021ๅนดๆ•ฐๆฎ่Žทๅ–ๅคฑ่ดฅ: {e}") + return False + + # ๆต‹่ฏ•3: ่Žทๅ–2022ๅนด็š„ๆ•ฐๆฎ + print("\n[ๆต‹่ฏ•3] ๅฐ่ฏ•่Žทๅ–2022ๅนดๅ…จๅนดๆ•ฐๆฎ...") + try: + df_2022 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2022-01-01', + end_date='2022-12-31', + use_cache=False + ) + print(f"โœ… ๆˆๅŠŸ่Žทๅ–2022ๅนดๆ•ฐๆฎ") + print(f" ๆ•ฐๆฎ่กŒๆ•ฐ: {len(df_2022)}") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {df_2022['timestamp'].min()} ่‡ณ {df_2022['timestamp'].max()}") + print(f" ไปทๆ ผ่Œƒๅ›ด: ${df_2022['close'].min():,.2f} - ${df_2022['close'].max():,.2f}") + except Exception as e: + print(f"โŒ 2022ๅนดๆ•ฐๆฎ่Žทๅ–ๅคฑ่ดฅ: {e}") + return False + + # ๆต‹่ฏ•4: ่Žทๅ–2023ๅนด็š„ๆ•ฐๆฎ + print("\n[ๆต‹่ฏ•4] ๅฐ่ฏ•่Žทๅ–2023ๅนดๅ…จๅนดๆ•ฐๆฎ...") + try: + df_2023 = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2023-01-01', + end_date='2023-12-31', + use_cache=False + ) + print(f"โœ… ๆˆๅŠŸ่Žทๅ–2023ๅนดๆ•ฐๆฎ") + print(f" ๆ•ฐๆฎ่กŒๆ•ฐ: {len(df_2023)}") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {df_2023['timestamp'].min()} ่‡ณ {df_2023['timestamp'].max()}") + print(f" ไปทๆ ผ่Œƒๅ›ด: ${df_2023['close'].min():,.2f} - ${df_2023['close'].max():,.2f}") + except Exception as e: + print(f"โŒ 2023ๅนดๆ•ฐๆฎ่Žทๅ–ๅคฑ่ดฅ: {e}") + return False + + # ๆต‹่ฏ•5: ่Žทๅ–ๅฎŒๆ•ด็š„2020-2023ๅนดๆ•ฐๆฎ + print("\n[ๆต‹่ฏ•5] ๅฐ่ฏ•่Žทๅ–2020-2023ๅนดๅฎŒๆ•ดๆ•ฐๆฎ๏ผˆ4ๅนด๏ผ‰...") + try: + df_full = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2023-12-31', + use_cache=False + ) + print(f"โœ… ๆˆๅŠŸ่Žทๅ–2020-2023ๅนดๅฎŒๆ•ดๆ•ฐๆฎ") + print(f" ๆ•ฐๆฎ่กŒๆ•ฐ: {len(df_full)}") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: {df_full['timestamp'].min()} ่‡ณ {df_full['timestamp'].max()}") + print(f" ่ตทๅง‹ไปทๆ ผ: ${df_full['close'].iloc[0]:,.2f}") + print(f" ็ป“ๆŸไปทๆ ผ: ${df_full['close'].iloc[-1]:,.2f}") + total_return = (df_full['close'].iloc[-1] - df_full['close'].iloc[0]) / df_full['close'].iloc[0] + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {total_return*100:.2f}%") + + # ๅˆ†ๆžๆฏๅนด็š„่กจ็Žฐ + print(f"\n ๅนดๅบฆ่กจ็Žฐๅˆ†ๆž:") + df_full['year'] = pd.to_datetime(df_full['timestamp']).dt.year + for year in [2020, 2021, 2022, 2023]: + year_df = df_full[df_full['year'] == year] + if len(year_df) > 0: + year_return = (year_df['close'].iloc[-1] - year_df['close'].iloc[0]) / year_df['close'].iloc[0] + print(f" {year}ๅนด: {year_return*100:+.2f}% (${year_df['close'].iloc[0]:,.0f} โ†’ ${year_df['close'].iloc[-1]:,.0f})") + + except Exception as e: + print(f"โŒ ๅฎŒๆ•ดๆ•ฐๆฎ่Žทๅ–ๅคฑ่ดฅ: {e}") + return False + + # ๆ€ป็ป“ + print("\n" + "="*80) + print("๐Ÿ“Š ๆต‹่ฏ•็ป“ๆžœๆ€ป็ป“") + print("="*80) + print("โœ… Binance APIๅฏไปฅ่Žทๅ–2020-2023ๅนด็š„ๅฎŒๆ•ดๅŽ†ๅฒๆ•ฐๆฎ") + print(f"โœ… ๆ€ปๅ…ฑๅฏ่Žทๅ–็บฆ {len(df_full):,} ๅฐๆ—ถ็š„K็บฟๆ•ฐๆฎ") + print(f"โœ… ๆ•ฐๆฎ่ดจ้‡๏ผš่ฟž็ปญๅฎŒๆ•ด๏ผŒๆ— ๆ˜Žๆ˜พ็ผบๅคฑ") + print(f"\n๐Ÿ’ก ๅปบ่ฎฎ๏ผš") + print(f" - ไฝฟ็”จ2020-2023ๅนดๆ•ฐๆฎ่ฟ›่กŒ่ฎญ็ปƒ๏ผˆๅŒ…ๅซๅฎŒๆ•ด็‰›็†Šๅ‘จๆœŸ๏ผ‰") + print(f" - 2020ๅนด: ็‰›ๅธ‚ๅˆๆœŸ") + print(f" - 2021ๅนด: ็‰›ๅธ‚้กถๅณฐ") + print(f" - 2022ๅนด: ็†Šๅธ‚") + print(f" - 2023ๅนด: ๅค่‹") + print(f" ่ฟ™ๆ ทๆจกๅž‹่ƒฝๅญฆไน ๅˆฐๅ„็งๅธ‚ๅœบ็Žฏๅขƒ") + + return True + +if __name__ == "__main__": + try: + success = test_historical_data() + if success: + print("\n" + "="*80) + print("โœ… ๆ‰€ๆœ‰ๆต‹่ฏ•้€š่ฟ‡๏ผๅฏไปฅ่Žทๅ–2020-2023ๅนด็š„ๆ•ฐๆฎ") + print("="*80) + else: + print("\n" + "="*80) + print("โŒ ้ƒจๅˆ†ๆต‹่ฏ•ๅคฑ่ดฅ") + print("="*80) + except Exception as e: + print(f"\nโŒ ๆต‹่ฏ•่ฟ‡็จ‹ๅ‡บ้”™: {e}") diff --git a/train_811_split.py b/train_811_split.py new file mode 100644 index 0000000..0b7eadd --- /dev/null +++ b/train_811_split.py @@ -0,0 +1,304 @@ +"""8:1:1ๆ•ฐๆฎ้›†ๅˆ’ๅˆ†่ฎญ็ปƒ - ็›ดๆŽฅ้ข„ๆต‹ไปทๆ ผ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +import torch +import torch.nn as nn +from torch.utils.data import DataLoader, TensorDataset + +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import pickle + +class PricePreprocessor: + """้ข„ๆต‹ๆœชๆฅไปทๆ ผ็š„้ข„ๅค„็†ๅ™จ""" + + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.price_scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + """ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡""" + df = df.copy() + df['rsi'] = ta.rsi(df['close'], length=14) + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + return df + + def create_labels(self, df): + """ๅˆ›ๅปบๆ ‡็ญพ๏ผšๆœชๆฅ1ๅฐๆ—ถ็š„ไปทๆ ผ""" + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['label'] = df['future_price'] + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + """ๅฎŒๆ•ด้ข„ๅค„็†ๆต็จ‹""" + df = self.add_features(df) + df = self.create_labels(df) + df = df.dropna().reset_index(drop=True) + + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + if fit: + scaled_features = self.scaler.fit_transform(df[feature_cols]) + scaled_labels = self.price_scaler.fit_transform(df[['label']]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled_features = self.scaler.transform(df[feature_cols]) + scaled_labels = self.price_scaler.transform(df[['label']]) + + X, y = [], [] + for i in range(len(scaled_features) - self.lookback): + X.append(scaled_features[i:i + self.lookback]) + y.append(scaled_labels[i + self.lookback, 0]) + + return np.array(X), np.array(y), df + + def inverse_transform_price(self, scaled_price): + """ๅฐ†ๆ ‡ๅ‡†ๅŒ–็š„ไปทๆ ผ่ฟ˜ๅŽŸไธบ็œŸๅฎžไปทๆ ผ""" + return self.price_scaler.inverse_transform(scaled_price.reshape(-1, 1)).flatten() + +def main(): + print("="*80) + print("8:1:1ๆ•ฐๆฎ้›†ๅˆ’ๅˆ† - ็›ดๆŽฅ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถไปทๆ ผ") + print("="*80) + + # ========== ๆญฅ้ชค1: ่Žทๅ–ๆ•ฐๆฎ ========== + print("\n[1/8] ่Žทๅ–BTC 2020-2025ๅนดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๆ•ฐๆฎ้‡: {len(df):,} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df['close'].iloc[0]:,.2f} โ†’ ${df['close'].iloc[-1]:,.2f}") + + # ========== ๆญฅ้ชค2: ้ข„ๅค„็† ========== + print("\n[2/8] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๅชไฝฟ็”จOHLCV + RSI + MACD๏ผ‰...") + preprocessor = PricePreprocessor(lookback=168, forecast_horizon=1) + X, y, processed_df = preprocessor.preprocess(df, fit=True) + + print(f"โœ“ ๅบๅˆ—ๆ•ฐ้‡: {len(X):,}") + print(f"โœ“ ๅบๅˆ—ๅฝข็Šถ: {X.shape}") + print(f"โœ“ ็‰นๅพๅˆ—่กจ: {preprocessor.feature_columns}") + + # ========== ๆญฅ้ชค3: 8:1:1ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† ========== + print("\n[3/8] 8:1:1ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†...") + n = len(X) + train_end = int(n * 0.8) + val_end = int(n * 0.9) + + X_train = X[:train_end] + y_train = y[:train_end] + X_val = X[train_end:val_end] + y_val = y[train_end:val_end] + X_test = X[val_end:] + y_test = y[val_end:] + + print(f" ๆ€ปๆ ทๆœฌๆ•ฐ: {n:,}") + print(f" ่ฎญ็ปƒ้›†: {len(X_train):,} ({len(X_train)/n*100:.1f}%)") + print(f" ้ชŒ่ฏ้›†: {len(X_val):,} ({len(X_val)/n*100:.1f}%)") + print(f" ๆต‹่ฏ•้›†: {len(X_test):,} ({len(X_test)/n*100:.1f}%)") + + # ๅˆ†ๆžๅ„ๆ•ฐๆฎ้›†ๆ—ถ้—ด่Œƒๅ›ด + lookback = 168 + train_df = processed_df.iloc[lookback:train_end+lookback] + val_df = processed_df.iloc[train_end+lookback:val_end+lookback] + test_df = processed_df.iloc[val_end+lookback:] + + print(f"\n ๆ—ถ้—ด่Œƒๅ›ดๅˆ†ๆž:") + print(f" ่ฎญ็ปƒ้›†: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f} ({train_return*100:+.1f}%)") + + print(f" ้ชŒ่ฏ้›†: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f} ({val_return*100:+.1f}%)") + + print(f" ๆต‹่ฏ•้›†: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + test_return = (test_df['close'].iloc[-1] - test_df['close'].iloc[0]) / test_df['close'].iloc[0] + print(f" ${test_df['close'].iloc[0]:,.0f} โ†’ ${test_df['close'].iloc[-1]:,.0f} ({test_return*100:+.1f}%)") + + # ========== ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[4/8] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_dataset = TensorDataset(torch.FloatTensor(X_train), torch.FloatTensor(y_train)) + val_dataset = TensorDataset(torch.FloatTensor(X_val), torch.FloatTensor(y_val)) + test_dataset = TensorDataset(torch.FloatTensor(X_test), torch.FloatTensor(y_test)) + + train_loader = DataLoader(train_dataset, batch_size=64, shuffle=False) + val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False) + test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False) + + # ========== ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[5/8] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=9, + lookback=168, + task='regression', + hidden_dim=256, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,}") + + # ========== ๆญฅ้ชค6: ่ฎญ็ปƒ ========== + print("\n[6/8] ๅผ€ๅง‹่ฎญ็ปƒ...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=15, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_811_split' + ) + + trainer = Trainer(model, train_config, task='regression') + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค7: ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐ ========== + print("\n[7/8] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐ...") + + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + model = model.to(device) + model.eval() + + test_preds = [] + with torch.no_grad(): + for batch_X, _ in test_loader: + batch_X = batch_X.to(device) + pred = model(batch_X).squeeze() + test_preds.extend(pred.cpu().numpy()) + + test_preds = np.array(test_preds) + + # ่ฟ˜ๅŽŸไธบ็œŸๅฎžไปทๆ ผ + pred_prices = preprocessor.inverse_transform_price(test_preds) + true_prices = preprocessor.inverse_transform_price(y_test) + + # ่Žทๅ–ๅฝ“ๅ‰ไปทๆ ผ + test_start_idx = val_end + lookback + current_prices = processed_df['close'].iloc[test_start_idx:test_start_idx+len(pred_prices)].values + + # ๆ–นๅ‘ๅˆคๆ–ญ + pred_direction = (pred_prices > current_prices).astype(int) + true_direction = (true_prices > current_prices).astype(int) + direction_acc = (pred_direction == true_direction).mean() + + # ไปทๆ ผ้ข„ๆต‹่ฏฏๅทฎ + price_mae = np.abs(pred_prices - true_prices).mean() + price_rmse = np.sqrt(((pred_prices - true_prices) ** 2).mean()) + price_mape = np.mean(np.abs((true_prices - pred_prices) / true_prices)) * 100 + + from sklearn.metrics import confusion_matrix + cm = confusion_matrix(true_direction, pred_direction) + tn, fp, fn, tp = cm.ravel() + + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๆต‹่ฏ•้›†ๆ€ง่ƒฝ๏ผˆ็‹ฌ็ซ‹ๆต‹่ฏ•้›†๏ผ‰") + print("="*80) + + print(f"\n๐Ÿ“Š ไปทๆ ผ้ข„ๆต‹่ฏฏๅทฎ:") + print(f" MAE: ${price_mae:,.2f}") + print(f" RMSE: ${price_rmse:,.2f}") + print(f" MAPE: {price_mape:.2f}%") + + print(f"\n๐Ÿ“ˆ ๆ–นๅ‘้ข„ๆต‹:") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {direction_acc*100:.2f}%") + print(f" ้ข„ๆต‹ไธŠๆถจ: {(pred_direction==1).sum()} / ๅฎž้™…ไธŠๆถจ: {(true_direction==1).sum()}") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {(pred_direction==0).sum()} / ๅฎž้™…ไธ‹่ทŒ: {(true_direction==0).sum()}") + + print(f"\n่ฏฆ็ป†ๅˆ†ๆž:") + print(f" โœ“ ้ข„ๆต‹ๆถจไธ”็œŸๆถจ: {tp} ({tp/len(pred_prices)*100:.1f}%)") + print(f" โœ“ ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ: {tn} ({tn/len(pred_prices)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ: {fp} ({fp/len(pred_prices)*100:.1f}%)") + print(f" โœ— ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ: {fn} ({fn/len(pred_prices)*100:.1f}%)") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n" + "="*80) + print("๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ") + print("="*80) + + if direction_acc > 0.55: + print(f"\n โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {direction_acc*100:.2f}% > 55%๏ผŒๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›") + elif direction_acc > 0.52: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {direction_acc*100:.2f}% > 52%๏ผŒ็•ฅไผ˜ไบŽ้šๆœบ") + elif direction_acc >= 0.48: + print(f"\n โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {direction_acc*100:.2f}% โ‰ˆ 50%๏ผŒๆŽฅ่ฟ‘้šๆœบ") + else: + print(f"\n โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {direction_acc*100:.2f}% < 48%๏ผŒไฝŽไบŽ้šๆœบ") + + # ========== ๆญฅ้ชค8: ไฟๅญ˜ ========== + print("\n[8/8] ไฟๅญ˜ๆจกๅž‹ๅ’Œ็ป“ๆžœ...") + + with open('./models/checkpoints/dlinear_811_split/preprocessor.pkl', 'wb') as f: + pickle.dump(preprocessor, f) + + metrics = { + 'price_mae': float(price_mae), + 'price_rmse': float(price_rmse), + 'price_mape': float(price_mape), + 'direction_accuracy': float(direction_acc), + 'true_positives': int(tp), + 'true_negatives': int(tn), + 'false_positives': int(fp), + 'false_negatives': int(fn) + } + with open('./models/checkpoints/dlinear_811_split/test_metrics.json', 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ๆจกๅž‹ไฟๅญ˜่‡ณ: ./models/checkpoints/dlinear_811_split/") + + # ๅฏนๆฏ”ๅˆ†ๆž + print("\n" + "="*80) + print("๐Ÿ“Š ๆ•ฐๆฎ้›†ๅˆ’ๅˆ†ๅฏนๆฏ”") + print("="*80) + + print("\nไน‹ๅ‰๏ผˆ95:5ๅˆ’ๅˆ†๏ผŒๆ— ็‹ฌ็ซ‹ๆต‹่ฏ•้›†๏ผ‰:") + print(" ่ฎญ็ปƒ้›†: 49,733 (95%)") + print(" ้ชŒ่ฏ้›†: 2,618 (5%)") + print(" ๆต‹่ฏ•้›†: ๆ— ") + print(" ้—ฎ้ข˜: ่ฟ‡ๆ‹Ÿๅˆ๏ผŒ้ชŒ่ฏ้›†ๅคชๅฐ") + + print(f"\nๅฝ“ๅ‰๏ผˆ8:1:1ๅˆ’ๅˆ†๏ผŒๆœ‰็‹ฌ็ซ‹ๆต‹่ฏ•้›†๏ผ‰:") + print(f" ่ฎญ็ปƒ้›†: {len(X_train):,} (80%)") + print(f" ้ชŒ่ฏ้›†: {len(X_val):,} (10%)") + print(f" ๆต‹่ฏ•้›†: {len(X_test):,} (10%)") + print(f" ไผ˜ๅŠฟ: ๆœ‰่ถณๅคŸๅคง็š„็‹ฌ็ซ‹ๆต‹่ฏ•้›†่ฏ„ไผฐๆ€ง่ƒฝ") + + print(f"\nๆต‹่ฏ•้›†ๆ€ง่ƒฝ:") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {direction_acc*100:.2f}%") + print(f" ไปทๆ ผ่ฏฏๅทฎMAPE: {price_mape:.2f}%") + + print("\n" + "="*80) + print("โœ“ ่ฎญ็ปƒๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_classification_full.py b/train_classification_full.py new file mode 100644 index 0000000..c0c1d2e --- /dev/null +++ b/train_classification_full.py @@ -0,0 +1,182 @@ +"""ๅˆ†็ฑปไปปๅŠก๏ผšไฝฟ็”จ2020-2025ๅ…จ้ƒจๆ•ฐๆฎ่ฎญ็ปƒ๏ผŒ2026ๅนดๆต‹่ฏ•""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +import torch +import torch.nn as nn +from torch.utils.data import DataLoader, TensorDataset + +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import pickle + +class ClassificationPreprocessor: + """ๅˆ†็ฑปไปปๅŠก้ข„ๅค„็†ๅ™จ๏ผš้ข„ๆต‹ๆถจ(1)ๆˆ–่ทŒ(0)""" + + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + """ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡""" + df = df.copy() + df['rsi'] = ta.rsi(df['close'], length=14) + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + return df + + def create_labels(self, df): + """ๅˆ›ๅปบไบŒๅˆ†็ฑปๆ ‡็ญพ๏ผš1=ไธŠๆถจ, 0=ไธ‹่ทŒ""" + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['future_return'] = (df['future_price'] - df['close']) / df['close'] + # ไบŒๅˆ†็ฑป๏ผšๅคงไบŽ0ไธบไธŠๆถจ(1)๏ผŒๅฆๅˆ™ไธบไธ‹่ทŒ(0) + df['label'] = (df['future_return'] > 0).astype(int) + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + """ๅฎŒๆ•ด้ข„ๅค„็†ๆต็จ‹""" + df = self.add_features(df) + df = self.create_labels(df) + df = df.dropna().reset_index(drop=True) + + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + if fit: + scaled_features = self.scaler.fit_transform(df[feature_cols]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled_features = self.scaler.transform(df[feature_cols]) + + X, y = [], [] + for i in range(len(scaled_features) - self.lookback): + X.append(scaled_features[i:i + self.lookback]) + y.append(df['label'].iloc[i + self.lookback]) + + return np.array(X), np.array(y), df + +def main(): + print("="*80) + print("ๅˆ†็ฑปไปปๅŠก๏ผš2020-2025ๅ…จ้‡่ฎญ็ปƒ โ†’ 2026ๆต‹่ฏ•") + print("="*80) + + # ========== ๆญฅ้ชค1: ่Žทๅ–่ฎญ็ปƒๆ•ฐๆฎ๏ผˆ2020-2025๏ผ‰ ========== + print("\n[1/6] ่Žทๅ–2020-2025ๅนด่ฎญ็ปƒๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df_train = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ่ฎญ็ปƒๆ•ฐๆฎ้‡: {len(df_train):,} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด: {df_train['timestamp'].min()} ่‡ณ {df_train['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df_train['close'].iloc[0]:,.2f} โ†’ ${df_train['close'].iloc[-1]:,.2f}") + + # ========== ๆญฅ้ชค2: ้ข„ๅค„็†่ฎญ็ปƒๆ•ฐๆฎ ========== + print("\n[2/6] ้ข„ๅค„็†่ฎญ็ปƒๆ•ฐๆฎ๏ผˆๅˆ†็ฑปไปปๅŠก๏ผ‰...") + preprocessor = ClassificationPreprocessor(lookback=168, forecast_horizon=1) + X_train, y_train, processed_train = preprocessor.preprocess(df_train, fit=True) + + print(f"โœ“ ่ฎญ็ปƒๅบๅˆ—: {len(X_train):,}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡: {len(preprocessor.feature_columns)}") + print(f"โœ“ ็‰นๅพๅˆ—่กจ: {preprocessor.feature_columns}") + + # ๆ ‡็ญพๅˆ†ๅธƒ + n_up = (y_train == 1).sum() + n_down = (y_train == 0).sum() + print(f"\nโœ“ ๆ ‡็ญพๅˆ†ๅธƒ:") + print(f" ไธŠๆถจ(1): {n_up:,} ({n_up/len(y_train)*100:.1f}%)") + print(f" ไธ‹่ทŒ(0): {n_down:,} ({n_down/len(y_train)*100:.1f}%)") + + # ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡ + pos_weight = n_down / n_up if n_up > 0 else 1.0 + print(f" pos_weight: {pos_weight:.3f}") + + # ========== ๆญฅ้ชค3: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[3/6] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_dataset = TensorDataset( + torch.FloatTensor(X_train), + torch.FloatTensor(y_train) + ) + # ็”จ10%ไฝœไธบ้ชŒ่ฏ้›†๏ผˆๅ†…้ƒจๅˆ†ๅ‰ฒ๏ผ‰ + train_size = int(0.9 * len(train_dataset)) + val_size = len(train_dataset) - train_size + train_subset, val_subset = torch.utils.data.random_split( + train_dataset, [train_size, val_size] + ) + + train_loader = DataLoader(train_subset, batch_size=64, shuffle=True) + val_loader = DataLoader(val_subset, batch_size=64, shuffle=False) + + print(f" ่ฎญ็ปƒๆ ทๆœฌ: {train_size:,}") + print(f" ้ชŒ่ฏๆ ทๆœฌ: {val_size:,}") + + # ========== ๆญฅ้ชค4: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[4/6] ๅˆ›ๅปบDLinearๅˆ†็ฑปๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=9, + lookback=168, + task='classification', # ๅˆ†็ฑปไปปๅŠก + hidden_dim=256, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,}") + print(f"โœ“ ไปปๅŠก็ฑปๅž‹: ไบŒๅˆ†็ฑป๏ผˆ้ข„ๆต‹ๆถจ/่ทŒ๏ผ‰") + print(f"โœ“ ๆŸๅคฑๅ‡ฝๆ•ฐ: BCEWithLogitsLoss") + + # ========== ๆญฅ้ชค5: ่ฎญ็ปƒ ========== + print("\n[5/6] ๅผ€ๅง‹่ฎญ็ปƒ...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=15, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_classification_2026' + ) + + trainer = Trainer( + model, + train_config, + task='classification', + pos_weight=pos_weight # ไฝฟ็”จ็ฑปๅˆซๆƒ้‡ + ) + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค6: ไฟๅญ˜ ========== + print("\n[6/6] ไฟๅญ˜ๆจกๅž‹...") + with open('./models/checkpoints/dlinear_classification_2026/preprocessor.pkl', 'wb') as f: + pickle.dump(preprocessor, f) + + print(f"โœ“ ๆจกๅž‹ไฟๅญ˜่‡ณ: ./models/checkpoints/dlinear_classification_2026/") + + print("\n" + "="*80) + print("โœ“ ่ฎญ็ปƒๅฎŒๆˆ๏ผๅ‡†ๅค‡ๅœจ2026ๅนดๆ•ฐๆฎไธŠๆต‹่ฏ•...") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_cross_asset.py b/train_cross_asset.py new file mode 100644 index 0000000..f6b06d7 --- /dev/null +++ b/train_cross_asset.py @@ -0,0 +1,240 @@ +"""่ทจ่ต„ไบง่ฟ็งปๅญฆไน ๅฎž้ชŒ - ็”จBTC่ฎญ็ปƒ๏ผŒๅœจETHไธŠ้ชŒ่ฏๅ’Œๆต‹่ฏ•""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("่ทจ่ต„ไบง่ฟ็งปๅญฆไน ๅฎž้ชŒ") + print("่ฎญ็ปƒ๏ผšBTC 2020-2025 | ้ชŒ่ฏ+ๆต‹่ฏ•๏ผšETH 2020-2025") + print("="*80) + + fetcher = BinanceDataFetcher() + + # ========== ๆญฅ้ชค1: ่Žทๅ–BTC่ฎญ็ปƒๆ•ฐๆฎ ========== + print("\n[1/10] ่Žทๅ–BTCๆ•ฐๆฎ๏ผˆ็”จไบŽ่ฎญ็ปƒ๏ผ‰...") + df_btc = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + print(f"โœ“ BTCๆ•ฐๆฎ: {len(df_btc)} ่กŒ") + print(f" ๆ—ถ้—ด: {df_btc['timestamp'].min()} ่‡ณ {df_btc['timestamp'].max()}") + print(f" ไปทๆ ผ: ${df_btc['close'].iloc[0]:,.0f} โ†’ ${df_btc['close'].iloc[-1]:,.0f}") + btc_return = (df_btc['close'].iloc[-1] - df_btc['close'].iloc[0]) / df_btc['close'].iloc[0] + print(f" ๆ”ถ็›Š็Ž‡: {btc_return*100:+.1f}%") + + # ========== ๆญฅ้ชค2: ่Žทๅ–ETH้ชŒ่ฏ/ๆต‹่ฏ•ๆ•ฐๆฎ ========== + print("\n[2/10] ่Žทๅ–ETHๆ•ฐๆฎ๏ผˆ็”จไบŽ้ชŒ่ฏๅ’Œๆต‹่ฏ•๏ผ‰...") + df_eth = fetcher.fetch_ohlcv( + symbol='ETH', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + print(f"โœ“ ETHๆ•ฐๆฎ: {len(df_eth)} ่กŒ") + print(f" ๆ—ถ้—ด: {df_eth['timestamp'].min()} ่‡ณ {df_eth['timestamp'].max()}") + print(f" ไปทๆ ผ: ${df_eth['close'].iloc[0]:,.2f} โ†’ ${df_eth['close'].iloc[-1]:,.2f}") + eth_return = (df_eth['close'].iloc[-1] - df_eth['close'].iloc[0]) / df_eth['close'].iloc[0] + print(f" ๆ”ถ็›Š็Ž‡: {eth_return*100:+.1f}%") + + # ========== ๆญฅ้ชค3: ้ข„ๅค„็†BTCๆ•ฐๆฎ ========== + print("\n[3/10] ้ข„ๅค„็†BTCๆ•ฐๆฎ๏ผˆๅ›žๅฝ’ไปปๅŠก๏ผ‰...") + preprocessor_btc = CryptoPreprocessor( + lookback=168, + forecast_horizon=1, + price_change_threshold=0.0 + ) + X_btc, y_btc, processed_btc = preprocessor_btc.preprocess_pipeline( + df_btc, task='regression', fit=True + ) + print(f"โœ“ BTCๅบๅˆ—: X={X_btc.shape}, y={y_btc.shape}") + + # ========== ๆญฅ้ชค4: ้ข„ๅค„็†ETHๆ•ฐๆฎ ========== + print("\n[4/10] ้ข„ๅค„็†ETHๆ•ฐๆฎ๏ผˆไฝฟ็”จBTC็š„scaler๏ผ‰...") + # ้‡่ฆ๏ผšๅค็”จBTC็š„preprocessor๏ผˆๅทฒfit็š„scaler๏ผ‰ๆฅๅค„็†ETHๆ•ฐๆฎ + # ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ๅ’Œๆ—ถ้—ด็‰นๅพ + df_eth_processed = preprocessor_btc.add_technical_indicators(df_eth) + df_eth_processed = preprocessor_btc.add_time_features(df_eth_processed) + df_eth_processed = preprocessor_btc.create_labels(df_eth_processed, task='regression') + + # ๅˆ ้™คNaN่กŒ + processed_eth = df_eth_processed.dropna().reset_index(drop=True) + + # ไฝฟ็”จBTC่ฎญ็ปƒ็š„scalerๆฅๆ ‡ๅ‡†ๅŒ–ETH็‰นๅพ๏ผˆไธ้‡ๆ–ฐfit๏ผ‰ + scaled_features = preprocessor_btc.transform(processed_eth) + + # ๅˆ›ๅปบๅบๅˆ— + X_eth, y_eth = preprocessor_btc.create_sequences( + scaled_features, + processed_eth['label'].values + ) + print(f"โœ“ ETHๅบๅˆ—: X={X_eth.shape}, y={y_eth.shape}") + + # ========== ๆญฅ้ชค5: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† ========== + print("\n[5/10] ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†...") + + # BTC: ๅช็”จๅ‰70%ไฝœไธบ่ฎญ็ปƒ้›† + n_btc = len(X_btc) + train_end = int(n_btc * 0.7) + X_train = X_btc[:train_end] + y_train = y_btc[:train_end] + + print(f" ่ฎญ็ปƒ้›†๏ผˆBTC๏ผ‰: {len(X_train)} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y_train.min()*100:.4f}% ~ {y_train.max()*100:.4f}%") + + # ETH: 70%้ชŒ่ฏ๏ผŒ30%ๆต‹่ฏ• + n_eth = len(X_eth) + val_end = int(n_eth * 0.7) + X_val = X_eth[:val_end] + y_val = y_eth[:val_end] + X_test = X_eth[val_end:] + y_test = y_eth[val_end:] + + print(f" ้ชŒ่ฏ้›†๏ผˆETH๏ผ‰: {len(X_val)} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y_val.min()*100:.4f}% ~ {y_val.max()*100:.4f}%") + print(f" ๆต‹่ฏ•้›†๏ผˆETH๏ผ‰: {len(X_test)} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y_test.min()*100:.4f}% ~ {y_test.max()*100:.4f}%") + + # ๅˆ†ๆžๆ—ถ้—ด่Œƒๅ›ด + lookback = 168 + train_df = processed_btc.iloc[lookback:train_end+lookback] + val_df = processed_eth.iloc[lookback:val_end+lookback] + test_df = processed_eth.iloc[val_end+lookback:] + + print(f"\n ๆ—ถ้—ด่Œƒๅ›ดๅˆ†ๆž:") + print(f" ่ฎญ็ปƒ๏ผˆBTC๏ผ‰: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + print(f" ้ชŒ่ฏ๏ผˆETH๏ผ‰: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + print(f" ๆต‹่ฏ•๏ผˆETH๏ผ‰: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + + # ========== ๆญฅ้ชค6: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[6/10] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + (X_train, y_train), + (X_val, y_val), + (X_test, y_test), + task='regression', + batch_size=64 + ) + + # ========== ๆญฅ้ชค7: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[7/10] ๅˆ›ๅปบDLinearๅ›žๅฝ’ๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X_btc.shape[-1], + lookback=168, + task='regression', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,} ไธช") + + # ========== ๆญฅ้ชค8: ่ฎญ็ปƒๆจกๅž‹ ========== + print("\n[8/10] ่ฎญ็ปƒๆจกๅž‹๏ผˆBTC่ฎญ็ปƒ๏ผŒETH้ชŒ่ฏ๏ผ‰...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/cross_asset_btc_to_eth' + ) + + trainer = Trainer(model, train_config, task='regression') + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค9: ๅœจETHๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐ ========== + print("\n[9/10] ๅœจETHๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐ...") + metrics_eth = trainer.evaluate(test_loader) + + results_path = './models/checkpoints/cross_asset_btc_to_eth/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics_eth, f, indent=2) + print(f"โœ“ ็ป“ๆžœไฟๅญ˜่‡ณ: {results_path}") + + # ========== ๆญฅ้ชค10: ๅฏนๆฏ”ๅˆ†ๆž ========== + print("\n[10/10] ๆ€ง่ƒฝๅˆ†ๆž...") + print("\n" + "="*80) + print("่ทจ่ต„ไบง่ฟ็งปๅญฆไน ๅฎž้ชŒ็ป“ๆžœ") + print("="*80) + + print("\n๐Ÿ“‹ ๅฎž้ชŒ่ฎพ็ฝฎ:") + print(f" ่ฎญ็ปƒ้›†: BTC 2020-2024 ({len(X_train):,} ๆ ทๆœฌ)") + print(f" ้ชŒ่ฏ้›†: ETH 2020-2024 ({len(X_val):,} ๆ ทๆœฌ)") + print(f" ๆต‹่ฏ•้›†: ETH 2024-2025 ({len(X_test):,} ๆ ทๆœฌ)") + + print("\n๐Ÿ“Š ETHๆต‹่ฏ•้›†ๆ€ง่ƒฝ:") + print(f" RMSE: {metrics_eth.get('rmse', 0)*100:.4f}%") + print(f" MAE: {metrics_eth.get('mae', 0)*100:.4f}%") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {metrics_eth.get('directional_accuracy', 0)*100:.2f}%") + + print(f"\n๐Ÿ’ฐ ETHๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics_eth.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics_eth.get('backtest_sharpe_ratio', 0):.4f}") + max_dd = metrics_eth.get('backtest_max_drawdown', 0) + if not np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics_eth.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics_eth.get('backtest_num_trades', 0):.0f}") + + # ๅฏนๆฏ”ไน‹ๅ‰็š„็ป“ๆžœ + print("\n" + "="*80) + print("๐Ÿ“Š ๆ€ง่ƒฝๅฏนๆฏ”") + print("="*80) + + print("\nๅฎž้ชŒ1๏ผšBTC่ฎญ็ปƒ โ†’ BTCๆต‹่ฏ•๏ผˆไน‹ๅ‰็ป“ๆžœ๏ผ‰") + print(" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: 50.67%") + print(" RMSE: 0.4881%") + print(" ๅ›žๆต‹ๆ”ถ็›Š: -16.71%") + + print(f"\nๅฎž้ชŒ2๏ผšBTC่ฎญ็ปƒ โ†’ ETHๆต‹่ฏ•๏ผˆๅฝ“ๅ‰็ป“ๆžœ๏ผ‰") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {metrics_eth.get('directional_accuracy', 0)*100:.2f}%") + print(f" RMSE: {metrics_eth.get('rmse', 0)*100:.4f}%") + print(f" ๅ›žๆต‹ๆ”ถ็›Š: {metrics_eth.get('backtest_total_return', 0)*100:.2f}%") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print("\n๐ŸŽฏ ่ฟ็งปๅญฆไน ๆ•ˆๆžœ่ฏ„ไผฐ:") + + dir_acc = metrics_eth.get('directional_accuracy', 0) + if dir_acc > 0.52: + print(f" โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% > 52%๏ผŒ่ทจ่ต„ไบง่ฟ็งปๆœ‰ๆ•ˆ") + elif dir_acc > 0.50: + print(f" โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ") + else: + print(f" โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% โ‰ค 50%๏ผŒ่ฟ็งปๅคฑ่ดฅ") + + total_return = metrics_eth.get('backtest_total_return', 0) + if total_return > 0: + print(f" โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅ็›ˆๅˆฉ") + else: + print(f" โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + print("\n๐Ÿ’ก ็ป“่ฎบ:") + if dir_acc > 0.52 and total_return > 0: + print(" โœ… ่ทจ่ต„ไบง่ฟ็งปๅญฆไน ๆˆๅŠŸ๏ผBTCๅญฆๅˆฐ็š„ๆจกๅผๅฏๅบ”็”จไบŽETH") + elif dir_acc > 0.50: + print(" โš ๏ธ ่ทจ่ต„ไบง่ฟ็งป้ƒจๅˆ†ๆœ‰ๆ•ˆ๏ผŒไฝ†ๆ”ถ็›Šไธไฝณ") + else: + print(" โŒ ่ทจ่ต„ไบง่ฟ็งปๅคฑ่ดฅ๏ผŒBTCๅ’ŒETHๅธ‚ๅœบๅŠจๆ€ๅทฎๅผ‚ๅคชๅคง") + + print("\n" + "="*80) + print("โœ“ ๅฎž้ชŒๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_dlinear_1h.py b/train_dlinear_1h.py new file mode 100644 index 0000000..bc1cb78 --- /dev/null +++ b/train_dlinear_1h.py @@ -0,0 +1,156 @@ +"""่ฎญ็ปƒDLinearๆจกๅž‹ - ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถๆถจ่ทŒ๏ผˆๅทฒไฟฎๅคๅŒ้‡Sigmoid Bug๏ผ‰""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("DLinearๆจกๅž‹่ฎญ็ปƒ - ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถๆถจ่ทŒ๏ผˆๅทฒไฟฎๅคๅŒ้‡Sigmoid Bug๏ผ‰") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–็œŸๅฎžๆ•ฐๆฎ + print("\n[1/7] ไปŽBinance่Žทๅ–BTC 1h็œŸๅฎžๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒ็œŸๅฎžๆ•ฐๆฎ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ๏ผ‰ + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ็š„ๆถจ่ทŒ๏ผ‰...") + preprocessor = CryptoPreprocessor( + lookback=168, # ่พ“ๅ…ฅ๏ผš่ฟ‡ๅŽป168ๅฐๆ—ถ๏ผˆ7ๅคฉ๏ผ‰ + forecast_horizon=1, # โ† ๆ”นไธบ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ + price_change_threshold=0.0 # ไปปไฝ•ๆถจๅน…>0้ƒฝ็ฎ—ไธŠๆถจ + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + + # ่ฎก็ฎ—็ฑปๅˆซๅˆ†ๅธƒ + n_down = (y == 0).sum() + n_up = (y == 1).sum() + print(f"โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผšไธ‹่ทŒ(0) = {n_down} ({n_down/len(y)*100:.1f}%), ไธŠๆถจ(1) = {n_up} ({n_up/len(y)*100:.1f}%)") + + # ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡ + pos_weight = n_down / n_up if n_up > 0 else 1.0 + print(f"โœ“ ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡๏ผšpos_weight = {pos_weight:.2f}") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† + print("\n[3/7] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + print(f" ่ฎญ็ปƒ้›†๏ผšไธ‹่ทŒ {(train_data[1]==0).sum()}, ไธŠๆถจ {(train_data[1]==1).sum()}") + print(f" ้ชŒ่ฏ้›†๏ผšไธ‹่ทŒ {(val_data[1]==0).sum()}, ไธŠๆถจ {(val_data[1]==1).sum()}") + print(f" ๆต‹่ฏ•้›†๏ผšไธ‹่ทŒ {(test_data[1]==0).sum()}, ไธŠๆถจ {(test_data[1]==1).sum()}") + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/7] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', + batch_size=64 + ) + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹๏ผˆๅทฒไฟฎๅคๅŒ้‡Sigmoid Bug๏ผ‰...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + print(f"โœ“ Bugไฟฎๅค๏ผš่พ“ๅ‡บๅฑ‚ไฝฟ็”จIdentity๏ผˆ่พ“ๅ‡บlogits๏ผ‰๏ผŒ็”ฑBCEWithLogitsLossๅค„็†Sigmoid") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ + print("\n[6/7] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_1h_forecast' + ) + + trainer = Trainer( + model, + train_config, + task='classification', + pos_weight=pos_weight + ) + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/7] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ไฟๅญ˜่ฏ„ไผฐ็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_1h_forecast/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๆ‰“ๅฐ็ป“ๆžœๆ‘˜่ฆ + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๆœ€็ปˆๆต‹่ฏ•็ป“ๆžœ๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถๆถจ่ทŒ๏ผ‰") + print("="*80) + + print(f"\n๐Ÿ“Š ๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f} ({metrics.get('accuracy', 0)*100:.2f}%)") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไธ”็œŸๆถจ๏ผ‰: {metrics['true_positives']}") + print(f" ็œŸ้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ๏ผ‰: {metrics['true_negatives']}") + print(f" ๅ‡้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ๏ผ‰: {metrics['false_positives']}") + print(f" ๅ‡้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ๏ผ‰: {metrics['false_negatives']}") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + print(f" ๆœ€ๅคงๅ›žๆ’ค: {metrics.get('backtest_max_drawdown', 0)*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ๆ€ง่ƒฝๅˆ†ๆž + print(f"\n๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ:") + acc = metrics.get('accuracy', 0) + if acc > 0.55: + print(f" โœ… ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% > 55%๏ผŒๆจกๅž‹ๆœ‰ไธ€ๅฎš้ข„ๆต‹่ƒฝๅŠ›") + elif acc > 0.50: + print(f" โš ๏ธ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ๏ผˆ50%๏ผ‰๏ผŒ้ข„ๆต‹่ƒฝๅŠ›่พƒๅผฑ") + else: + print(f" โŒ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% โ‰ค 50%๏ผŒๆจกๅž‹้ข„ๆต‹่ƒฝๅŠ›ไธ่ถณ") + + total_return = metrics.get('backtest_total_return', 0) + if total_return > 0: + print(f" โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅๆœ‰็›ˆๅˆฉๆฝœๅŠ›") + else: + print(f" โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + print("\n" + "="*80) + print("โœ“ ่ฎญ็ปƒๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_dlinear_balanced.py b/train_dlinear_balanced.py new file mode 100644 index 0000000..758422f --- /dev/null +++ b/train_dlinear_balanced.py @@ -0,0 +1,190 @@ +"""ไฝฟ็”จ็œŸๅฎžBinanceๆ•ฐๆฎ่ฎญ็ปƒDLinearๆจกๅž‹ - ไผ˜ๅŒ–็‰ˆ๏ผˆๅนณ่กก็ฑปๅˆซ + ็ฑปๅˆซๆƒ้‡๏ผ‰""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("DLinearๆจกๅž‹่ฎญ็ปƒ - ไผ˜ๅŒ–็‰ˆ๏ผˆๅนณ่กก็ฑปๅˆซ + ็ฑปๅˆซๆƒ้‡๏ผ‰") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–็œŸๅฎžๆ•ฐๆฎ + print("\n[1/8] ไปŽBinance่Žทๅ–BTC 1h็œŸๅฎžๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒ็œŸๅฎžๆ•ฐๆฎ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆไฝฟ็”จ็œŸๅฎžๆถจ่ทŒ๏ผšthreshold=0.0๏ผ‰ + print("\n[2/8] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆไฝฟ็”จ็œŸๅฎžๆถจ่ทŒๆ ‡็ญพ๏ผŒthreshold=0.0๏ผ‰...") + preprocessor = CryptoPreprocessor( + lookback=168, + forecast_horizon=24, + price_change_threshold=0.0 # ไปปไฝ•ๆถจๅน…>0้ƒฝ็ฎ—ไธŠๆถจ + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + + # ่ฎก็ฎ—็ฑปๅˆซๅˆ†ๅธƒ + n_down = (y == 0).sum() + n_up = (y == 1).sum() + print(f"โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผˆไผ˜ๅŒ–ๅŽ๏ผ‰๏ผšไธ‹่ทŒ(0) = {n_down} ({n_down/len(y)*100:.1f}%), ไธŠๆถจ(1) = {n_up} ({n_up/len(y)*100:.1f}%)") + + # ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡ + pos_weight = n_down / n_up if n_up > 0 else 1.0 + print(f"โœ“ ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡๏ผšpos_weight = {pos_weight:.2f} (็ป™ไธŠๆถจ็ฑป{pos_weight:.2f}ๅ€ๆƒ้‡)") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† + print("\n[3/8] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + # ๆ˜พ็คบๅ„ๆ•ฐๆฎ้›†็š„็ฑปๅˆซๅˆ†ๅธƒ + print(f" ่ฎญ็ปƒ้›†๏ผšไธ‹่ทŒ {(train_data[1]==0).sum()}, ไธŠๆถจ {(train_data[1]==1).sum()}") + print(f" ้ชŒ่ฏ้›†๏ผšไธ‹่ทŒ {(val_data[1]==0).sum()}, ไธŠๆถจ {(val_data[1]==1).sum()}") + print(f" ๆต‹่ฏ•้›†๏ผšไธ‹่ทŒ {(test_data[1]==0).sum()}, ไธŠๆถจ {(test_data[1]==1).sum()}") + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/8] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', + batch_size=64 + ) + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/8] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹๏ผˆไฝฟ็”จ็ฑปๅˆซๆƒ้‡๏ผ‰ + print("\n[6/8] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹๏ผˆไฝฟ็”จๅŠ ๆƒๆŸๅคฑๅ‡ฝๆ•ฐ๏ผ‰...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_1h_balanced' + ) + + trainer = Trainer( + model, + train_config, + task='classification', + pos_weight=pos_weight # ไผ ๅ…ฅ็ฑปๅˆซๆƒ้‡ + ) + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/8] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ไฟๅญ˜่ฏ„ไผฐ็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_1h_balanced/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๆ‰“ๅฐ็ป“ๆžœๆ‘˜่ฆ + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๆœ€็ปˆๆต‹่ฏ•็ป“ๆžœ๏ผˆไผ˜ๅŒ–็‰ˆ๏ผ‰") + print("="*80) + print(f"\n๐Ÿ“Š ๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f}") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไธ”็œŸๆถจ๏ผ‰: {metrics['true_positives']}") + print(f" ็œŸ้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ๏ผ‰: {metrics['true_negatives']}") + print(f" ๅ‡้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ๏ผ‰: {metrics['false_positives']}") + print(f" ๅ‡้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ๏ผ‰: {metrics['false_negatives']}") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + print(f" ๆœ€ๅคงๅ›žๆ’ค: {metrics.get('backtest_max_drawdown', 0)*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ๆญฅ้ชค8: ONNXๅฏผๅ‡บ + print("\n[8/8] ๆต‹่ฏ•ONNXๅฏผๅ‡บ...") + try: + import onnx + import onnxruntime as ort + import torch + + onnx_path = './models/checkpoints/dlinear_btc_1h_balanced/model.onnx' + + print(" ๅฏผๅ‡บๆจกๅž‹ๅˆฐONNXๆ ผๅผ...") + model.to_onnx(onnx_path) + print(f" โœ“ ONNXๆจกๅž‹ๅทฒไฟๅญ˜่‡ณ๏ผš{onnx_path}") + + print(" ้ชŒ่ฏONNXๆจกๅž‹...") + onnx_model = onnx.load(onnx_path) + onnx.checker.check_model(onnx_model) + print(" โœ“ ONNXๆจกๅž‹ๆœ‰ๆ•ˆ") + + # ๆต‹่ฏ•ๆŽจ็† + test_input = torch.randn(1, 168, X.shape[-1]) + model.cpu() + model.eval() + with torch.no_grad(): + pytorch_output = model(test_input).numpy() + + ort_session = ort.InferenceSession(onnx_path) + onnx_output = ort_session.run(None, {'input': test_input.numpy()})[0] + + diff = np.abs(pytorch_output - onnx_output).max() + print(f" โœ“ PyTorchไธŽONNX็š„ๆœ€ๅคงๅทฎๅผ‚๏ผš{diff:.8f}") + + if diff < 1e-5: + print(" โœ“ ONNXๅฏผๅ‡บๆˆๅŠŸ๏ผ") + else: + print(" โš  ONNX่พ“ๅ‡บๆœ‰ๅทฎๅผ‚๏ผˆๅฏ่ƒฝไปๅฏๆŽฅๅ—๏ผ‰") + + except Exception as e: + print(f" โœ— ONNXๅฏผๅ‡บๅคฑ่ดฅ๏ผš{e}") + + print("\n" + "="*80) + print("โœ“ DLinearๆจกๅž‹่ฎญ็ปƒๅฎŒๆˆ๏ผˆไผ˜ๅŒ–็‰ˆ๏ผ‰") + print("="*80) + + # ๅฏนๆฏ”ๆ—ง็‰ˆๆœฌ + print("\n๐Ÿ“Š ไผ˜ๅŒ–ๆ•ˆๆžœๅฏนๆฏ”:") + print(" ๆ—ง็‰ˆๆœฌ๏ผˆ1.5%้˜ˆๅ€ผ๏ผ‰๏ผš") + print(" - ็ฑปๅˆซๅˆ†ๅธƒ๏ผšไธŠๆถจ 15.5%, ไธ‹่ทŒ 84.5%") + print(" - ๅ‡†็กฎ็Ž‡๏ผš84.47% F1๏ผš0.00 ๅฌๅ›ž็Ž‡๏ผš0.00") + print(" - ๆจกๅž‹็ญ–็•ฅ๏ผšๆฐธ่ฟœ้ข„ๆต‹ไธ‹่ทŒ") + print(" ") + print(" ๆ–ฐ็‰ˆๆœฌ๏ผˆ0%้˜ˆๅ€ผ + ็ฑปๅˆซๆƒ้‡๏ผ‰๏ผš") + print(f" - ็ฑปๅˆซๅˆ†ๅธƒ๏ผšไธŠๆถจ {n_up/len(y)*100:.1f}%, ไธ‹่ทŒ {n_down/len(y)*100:.1f}%") + print(f" - ๅ‡†็กฎ็Ž‡๏ผš{metrics.get('accuracy', 0):.2%} F1๏ผš{metrics.get('f1', 0):.2f} ๅฌๅ›ž็Ž‡๏ผš{metrics.get('recall', 0):.2f}") + print(f" - ๅ›žๆต‹ๆ”ถ็›Š๏ผš{metrics.get('backtest_total_return', 0)*100:.2f}%") + +if __name__ == "__main__": + main() diff --git a/train_dlinear_long_term.py b/train_dlinear_long_term.py new file mode 100644 index 0000000..337d221 --- /dev/null +++ b/train_dlinear_long_term.py @@ -0,0 +1,242 @@ +"""ไฝฟ็”จ2020-2025ๅนดๆ•ฐๆฎ่ฎญ็ปƒDLinearๆจกๅž‹ - ๅŒ…ๅซๅฎŒๆ•ด็‰›็†Šๅ‘จๆœŸ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("DLinearๆจกๅž‹่ฎญ็ปƒ - ไฝฟ็”จ2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ๏ผˆ5ๅนด๏ผŒๅŒ…ๅซ็‰›็†Šๅ‘จๆœŸ๏ผ‰") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ + print("\n[1/8] ไปŽBinance่Žทๅ–BTC 2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + # ่Žทๅ–5ๅนดๆ•ฐๆฎ + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒๆ•ฐๆฎ๏ผˆ็บฆ{len(df)/8760:.1f}ๅนด๏ผ‰") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๅˆ†ๆžๆ•ฐๆฎ่ฆ†็›–็š„ๅธ‚ๅœบๅ‘จๆœŸ + print(f"\nโœ“ ไปทๆ ผๅ˜ๅŒ–ๅˆ†ๆž๏ผš") + print(f" ่ตทๅง‹ไปทๆ ผ: ${df['close'].iloc[0]:,.2f} (2020ๅนด)") + print(f" ็ป“ๆŸไปทๆ ผ: ${df['close'].iloc[-1]:,.2f} (2025ๅนด)") + total_return = (df['close'].iloc[-1] - df['close'].iloc[0]) / df['close'].iloc[0] + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {total_return*100:+.2f}%") + + # ๆŒ‰ๅนดๅˆ†ๆž + df['year'] = df['timestamp'].dt.year + print(f"\nโœ“ ๅนดๅบฆ่กจ็Žฐๅˆ†ๆž๏ผˆ็กฎไฟๅŒ…ๅซ็‰›็†Šๅ‘จๆœŸ๏ผ‰๏ผš") + for year in sorted(df['year'].unique()): + year_df = df[df['year'] == year] + if len(year_df) > 100: # ็กฎไฟๆœ‰่ถณๅคŸๆ•ฐๆฎ + year_return = (year_df['close'].iloc[-1] - year_df['close'].iloc[0]) / year_df['close'].iloc[0] + trend = "๐Ÿš€ ็‰›ๅธ‚" if year_return > 0.3 else ("๐Ÿ”ด ็†Šๅธ‚" if year_return < -0.3 else "๐Ÿ“Š ้œ‡่ก") + print(f" {year}ๅนด: {year_return*100:+7.2f}% {trend}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ๏ผ‰ + print("\n[2/8] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ็š„ๆถจ่ทŒ๏ผ‰...") + preprocessor = CryptoPreprocessor( + lookback=168, # ่พ“ๅ…ฅ๏ผš่ฟ‡ๅŽป168ๅฐๆ—ถ๏ผˆ7ๅคฉ๏ผ‰ + forecast_horizon=1, # ้ข„ๆต‹๏ผšๆœชๆฅ1ๅฐๆ—ถ + price_change_threshold=0.0 + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + + # ่ฎก็ฎ—็ฑปๅˆซๅˆ†ๅธƒ + n_down = (y == 0).sum() + n_up = (y == 1).sum() + print(f"โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผšไธ‹่ทŒ(0) = {n_down} ({n_down/len(y)*100:.1f}%), ไธŠๆถจ(1) = {n_up} ({n_up/len(y)*100:.1f}%)") + + # ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡ + pos_weight = n_down / n_up if n_up > 0 else 1.0 + print(f"โœ“ ่ฎก็ฎ—็ฑปๅˆซๆƒ้‡๏ผšpos_weight = {pos_weight:.2f}") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆๆ—ถ้—ดๅบๅˆ—ๅˆ†ๅ‰ฒ๏ผ‰ + print("\n[3/8] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + print(f" ่ฎญ็ปƒ้›†๏ผš{len(train_data[0])} ๆ ทๆœฌ") + print(f" ไธ‹่ทŒ: {(train_data[1]==0).sum()}, ไธŠๆถจ: {(train_data[1]==1).sum()}") + print(f" ้ชŒ่ฏ้›†๏ผš{len(val_data[0])} ๆ ทๆœฌ") + print(f" ไธ‹่ทŒ: {(val_data[1]==0).sum()}, ไธŠๆถจ: {(val_data[1]==1).sum()}") + print(f" ๆต‹่ฏ•้›†๏ผš{len(test_data[0])} ๆ ทๆœฌ") + print(f" ไธ‹่ทŒ: {(test_data[1]==0).sum()}, ไธŠๆถจ: {(test_data[1]==1).sum()}") + + # ๅˆ†ๆžๅ„ๆ•ฐๆฎ้›†ๅฏนๅบ”็š„ๆ—ถ้—ด่Œƒๅ›ด + lookback = 168 + train_end_idx = int(len(processed_df) * 0.7) - lookback + val_end_idx = int(len(processed_df) * 0.85) - lookback + + train_df = processed_df.iloc[lookback:train_end_idx+lookback] + val_df = processed_df.iloc[train_end_idx+lookback:val_end_idx+lookback] + test_df = processed_df.iloc[val_end_idx+lookback:] + + print(f"\n ่ฎญ็ปƒ้›†ๆ—ถ้—ด่Œƒๅ›ด: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f} ({train_return*100:+.1f}%)") + + print(f" ้ชŒ่ฏ้›†ๆ—ถ้—ด่Œƒๅ›ด: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f} ({val_return*100:+.1f}%)") + + print(f" ๆต‹่ฏ•้›†ๆ—ถ้—ด่Œƒๅ›ด: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + test_return = (test_df['close'].iloc[-1] - test_df['close'].iloc[0]) / test_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${test_df['close'].iloc[0]:,.0f} โ†’ ${test_df['close'].iloc[-1]:,.0f} ({test_return*100:+.1f}%)") + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/8] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', + batch_size=64 + ) + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/8] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ + print("\n[6/8] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹๏ผˆๆ•ฐๆฎ้‡ๅคง๏ผŒ้ข„่ฎก้œ€่ฆๆ›ด้•ฟๆ—ถ้—ด๏ผ‰...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_2020_2025' + ) + + trainer = Trainer( + model, + train_config, + task='classification', + pos_weight=pos_weight + ) + + print(f"โœ“ ่ฎญ็ปƒๆ•ฐๆฎ่ง„ๆจก๏ผš{len(train_data[0]):,} ๆ ทๆœฌ๏ผˆๆ˜ฏไน‹ๅ‰็š„ {len(train_data[0])/5990:.1f}x๏ผ‰") + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/8] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ไฟๅญ˜่ฏ„ไผฐ็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_2020_2025/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๆญฅ้ชค8: ๅฏนๆฏ”ๅˆ†ๆž + print("\n[8/8] ๆ€ง่ƒฝๅฏนๆฏ”ๅˆ†ๆž...") + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๆœ€็ปˆๆต‹่ฏ•็ป“ๆžœ๏ผˆไฝฟ็”จ2020-2025ๅนดๆ•ฐๆฎ๏ผ‰") + print("="*80) + + print(f"\n๐Ÿ“Š ๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f} ({metrics.get('accuracy', 0)*100:.2f}%)") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + tp = metrics['true_positives'] + tn = metrics['true_negatives'] + fp = metrics['false_positives'] + fn = metrics['false_negatives'] + + print(f"\n๐Ÿ“ˆ ๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไธ”็œŸๆถจ๏ผ‰: {tp}") + print(f" ็œŸ้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไธ”็œŸ่ทŒ๏ผ‰: {tn}") + print(f" ๅ‡้˜ณๆ€ง๏ผˆ้ข„ๆต‹ๆถจไฝ†็œŸ่ทŒ๏ผ‰: {fp}") + print(f" ๅ‡้˜ดๆ€ง๏ผˆ้ข„ๆต‹่ทŒไฝ†็œŸๆถจ๏ผ‰: {fn}") + + total = tp + tn + fp + fn + if total > 0: + print(f"\n ้ข„ๆต‹ๅˆ†ๅธƒ:") + print(f" ้ข„ๆต‹ไธŠๆถจ: {tp + fp} ({(tp+fp)/total*100:.1f}%)") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {tn + fn} ({(tn+fn)/total*100:.1f}%)") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + max_dd = metrics.get('backtest_max_drawdown', 0) + if not np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + else: + print(f" ๆœ€ๅคงๅ›žๆ’ค: N/A") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print(f"\n๐ŸŽฏ ๆ€ง่ƒฝ่ฏ„ไผฐ:") + acc = metrics.get('accuracy', 0) + if acc > 0.55: + print(f" โœ… ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% > 55%๏ผŒๆจกๅž‹ๆœ‰ไธ€ๅฎš้ข„ๆต‹่ƒฝๅŠ›") + elif acc > 0.50: + print(f" โš ๏ธ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ๏ผˆ50%๏ผ‰๏ผŒ้ข„ๆต‹่ƒฝๅŠ›่พƒๅผฑ") + else: + print(f" โŒ ๅ‡†็กฎ็Ž‡ {acc*100:.1f}% โ‰ค 50%๏ผŒๆจกๅž‹้ข„ๆต‹่ƒฝๅŠ›ไธ่ถณ") + + total_return = metrics.get('backtest_total_return', 0) + if total_return > 0.05: + print(f" โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 5%๏ผŒ็ญ–็•ฅๆœ‰่พƒๅฅฝ็›ˆๅˆฉๆฝœๅŠ›") + elif total_return > 0: + print(f" โš ๏ธ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅๆœ‰ๅพฎๅผฑ็›ˆๅˆฉ") + else: + print(f" โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + # ๅฏนๆฏ”ไน‹ๅ‰็š„็ป“ๆžœ + print(f"\n๐Ÿ“Š ไธŽไน‹ๅ‰็ป“ๆžœๅฏนๆฏ”:") + print(f" ไฝฟ็”จ1ๅนดๆ•ฐๆฎ๏ผˆ2025ๅนด๏ผ‰:") + print(f" - ่ฎญ็ปƒ้›†: 2025.02-10 (็‰›ๅธ‚+16%)") + print(f" - ๆต‹่ฏ•้›†: 2025.12-2026.01 (็†Šๅธ‚-2%)") + print(f" - ๅ‡†็กฎ็Ž‡: 50.7%") + print(f" - ้ข„ๆต‹ไธŠๆถจ: 65.8% (ๅๅ‘ไธŠๆถจ)") + print(f" - ้—ฎ้ข˜: ่ฎญ็ปƒๆต‹่ฏ•ๅˆ†ๅธƒไธไธ€่‡ด") + + print(f"\n ไฝฟ็”จ5ๅนดๆ•ฐๆฎ๏ผˆ2020-2025ๅนด๏ผ‰:") + print(f" - ่ฎญ็ปƒ้›†: ๅŒ…ๅซ็‰›ๅธ‚(2020-2021)ๅ’Œ็†Šๅธ‚(2022)") + print(f" - ๆต‹่ฏ•้›†: 2024-2025ๆ•ฐๆฎ") + print(f" - ๅ‡†็กฎ็Ž‡: {acc*100:.1f}%") + if total > 0: + print(f" - ้ข„ๆต‹ไธŠๆถจ: {(tp+fp)/total*100:.1f}%") + print(f" - ๆ”น่ฟ›: ่ง่ฟ‡ๅฎŒๆ•ดๅธ‚ๅœบๅ‘จๆœŸ๏ผŒๆณ›ๅŒ–ๆ›ดๅฅฝ") + + print("\n" + "="*80) + print("โœ“ ่ฎญ็ปƒๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_dlinear_real.py b/train_dlinear_real.py new file mode 100644 index 0000000..cfbbb52 --- /dev/null +++ b/train_dlinear_real.py @@ -0,0 +1,163 @@ +"""ไฝฟ็”จ็œŸๅฎžBinanceๆ•ฐๆฎ่ฎญ็ปƒDLinearๆจกๅž‹""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json + +def main(): + print("="*80) + print("DLinearๆจกๅž‹่ฎญ็ปƒ - ็œŸๅฎžBinanceๆ•ฐๆฎ") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–็œŸๅฎžๆ•ฐๆฎ + print("\n[1/7] ไปŽBinance่Žทๅ–BTC 1h็œŸๅฎžๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h', use_cache=True) + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒ็œŸๅฎžๆ•ฐๆฎ") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็† + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๆŠ€ๆœฏๆŒ‡ๆ ‡ + ็‰นๅพๅทฅ็จ‹๏ผ‰...") + preprocessor = CryptoPreprocessor(lookback=168, forecast_horizon=24) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + print(f"โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผšไธ‹่ทŒ(0) = {(y==0).sum()}, ไธŠๆถจ(1) = {(y==1).sum()}") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† + print("\n[3/7] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/7] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='classification', + batch_size=64 + ) + print(f"โœ“ ่ฎญ็ปƒๆ‰นๆฌก๏ผš{len(train_loader)}") + print(f"โœ“ ้ชŒ่ฏๆ‰นๆฌก๏ผš{len(val_loader)}") + print(f"โœ“ ๆต‹่ฏ•ๆ‰นๆฌก๏ผš{len(test_loader)}") + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ + print("\n[6/7] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_1h_real' + ) + + trainer = Trainer(model, train_config, task='classification') + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/7] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ไฟๅญ˜่ฏ„ไผฐ็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_1h_real/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๆ‰“ๅฐ็ป“ๆžœๆ‘˜่ฆ + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๆœ€็ปˆๆต‹่ฏ•็ป“ๆžœ") + print("="*80) + print(f"\nๅˆ†็ฑปๆŒ‡ๆ ‡:") + print(f" ๅ‡†็กฎ็Ž‡: {metrics.get('accuracy', 0):.4f}") + print(f" F1ๅˆ†ๆ•ฐ: {metrics.get('f1', 0):.4f}") + print(f" ็ฒพ็กฎ็Ž‡: {metrics.get('precision', 0):.4f}") + print(f" ๅฌๅ›ž็Ž‡: {metrics.get('recall', 0):.4f}") + + if 'true_positives' in metrics: + print(f"\nๆททๆท†็Ÿฉ้˜ต:") + print(f" ็œŸ้˜ณๆ€ง: {metrics['true_positives']}") + print(f" ็œŸ้˜ดๆ€ง: {metrics['true_negatives']}") + print(f" ๅ‡้˜ณๆ€ง: {metrics['false_positives']}") + print(f" ๅ‡้˜ดๆ€ง: {metrics['false_negatives']}") + + print(f"\nๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + print(f" ๆœ€ๅคงๅ›žๆ’ค: {metrics.get('backtest_max_drawdown', 0)*100:.2f}%") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ONNXๅฏผๅ‡บๆต‹่ฏ• + print("\n" + "="*80) + print("ๆต‹่ฏ•ONNXๅฏผๅ‡บ") + print("="*80) + + try: + import onnx + import onnxruntime as ort + import torch + import numpy as np + + onnx_path = './models/checkpoints/dlinear_btc_1h_real/model.onnx' + + print("\n[1/3] ๅฏผๅ‡บๆจกๅž‹ๅˆฐONNXๆ ผๅผ...") + model.to_onnx(onnx_path) + print(f"โœ“ ONNXๆจกๅž‹ๅทฒไฟๅญ˜่‡ณ๏ผš{onnx_path}") + + print("\n[2/3] ้ชŒ่ฏONNXๆจกๅž‹...") + onnx_model = onnx.load(onnx_path) + onnx.checker.check_model(onnx_model) + print("โœ“ ONNXๆจกๅž‹ๆœ‰ๆ•ˆ") + + print("\n[3/3] ๆต‹่ฏ•ONNXๆŽจ็†ไธŽPyTorchๅฏนๆฏ”...") + test_input = torch.randn(1, 168, X.shape[-1]) + + model.cpu() + model.eval() + with torch.no_grad(): + pytorch_output = model(test_input).numpy() + + ort_session = ort.InferenceSession(onnx_path) + onnx_output = ort_session.run(None, {'input': test_input.numpy()})[0] + + diff = np.abs(pytorch_output - onnx_output).max() + print(f"โœ“ PyTorchไธŽONNX็š„ๆœ€ๅคงๅทฎๅผ‚๏ผš{diff:.8f}") + + if diff < 1e-5: + print("โœ“ ONNXๅฏผๅ‡บๆˆๅŠŸ๏ผ่พ“ๅ‡บๅœจๅฎนๅทฎ่Œƒๅ›ดๅ†…ๅŒน้…ใ€‚") + else: + print("โš  ่ญฆๅ‘Š๏ผšONNX่พ“ๅ‡บไธŽPyTorchๆœ‰ๅทฎๅผ‚") + + except Exception as e: + print(f"โœ— ONNXๅฏผๅ‡บๅคฑ่ดฅ๏ผš{e}") + + print("\n" + "="*80) + print("โœ“ DLinearๆจกๅž‹่ฎญ็ปƒๅฎŒๆˆ๏ผˆ็œŸๅฎžๆ•ฐๆฎ๏ผ‰") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_dlinear_regression.py b/train_dlinear_regression.py new file mode 100644 index 0000000..d0066e2 --- /dev/null +++ b/train_dlinear_regression.py @@ -0,0 +1,258 @@ +"""ไฝฟ็”จๅ›žๅฝ’ไปปๅŠก่ฎญ็ปƒDLinearๆจกๅž‹ - ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ็š„ๅฎž้™…ไปทๆ ผๅ˜ๅŒ–็™พๅˆ†ๆฏ”""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("DLinearๅ›žๅฝ’ๆจกๅž‹่ฎญ็ปƒ - ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถไปทๆ ผๅ˜ๅŒ–็™พๅˆ†ๆฏ”") + print("="*80) + + # ๆญฅ้ชค1: ่Žทๅ–2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ + print("\n[1/8] ไปŽBinance่Žทๅ–BTC 2020-2025ๅนดๅฎŒๆ•ดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๅทฒ่Žทๅ– {len(df)} ่กŒๆ•ฐๆฎ๏ผˆ็บฆ{len(df)/8760:.1f}ๅนด๏ผ‰") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + + # ๅˆ†ๆžๆ•ฐๆฎ่ฆ†็›–็š„ๅธ‚ๅœบๅ‘จๆœŸ + print(f"\nโœ“ ไปทๆ ผๅ˜ๅŒ–ๅˆ†ๆž๏ผš") + print(f" ่ตทๅง‹ไปทๆ ผ: ${df['close'].iloc[0]:,.2f} (2020ๅนด)") + print(f" ็ป“ๆŸไปทๆ ผ: ${df['close'].iloc[-1]:,.2f} (2025ๅนด)") + total_return = (df['close'].iloc[-1] - df['close'].iloc[0]) / df['close'].iloc[0] + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {total_return*100:+.2f}%") + + # ๆŒ‰ๅนดๅˆ†ๆž + df['year'] = df['timestamp'].dt.year + print(f"\nโœ“ ๅนดๅบฆ่กจ็Žฐๅˆ†ๆž๏ผˆ็กฎไฟๅŒ…ๅซ็‰›็†Šๅ‘จๆœŸ๏ผ‰๏ผš") + for year in sorted(df['year'].unique()): + year_df = df[df['year'] == year] + if len(year_df) > 100: + year_return = (year_df['close'].iloc[-1] - year_df['close'].iloc[0]) / year_df['close'].iloc[0] + trend = "๐Ÿš€ ็‰›ๅธ‚" if year_return > 0.3 else ("๐Ÿ”ด ็†Šๅธ‚" if year_return < -0.3 else "๐Ÿ“Š ้œ‡่ก") + print(f" {year}ๅนด: {year_return*100:+7.2f}% {trend}") + + # ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๅ›žๅฝ’ไปปๅŠก๏ผ‰ + print("\n[2/8] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๅ›žๅฝ’ไปปๅŠก - ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ็š„ๆ”ถ็›Š็Ž‡๏ผ‰...") + preprocessor = CryptoPreprocessor( + lookback=168, # ่พ“ๅ…ฅ๏ผš่ฟ‡ๅŽป168ๅฐๆ—ถ๏ผˆ7ๅคฉ๏ผ‰ + forecast_horizon=1, # ้ข„ๆต‹๏ผšๆœชๆฅ1ๅฐๆ—ถ + price_change_threshold=0.0 # ๅ›žๅฝ’ไปปๅŠกไธไฝฟ็”จ้˜ˆๅ€ผ + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='regression', fit=True) + print(f"โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = {X.shape}, yๅฝข็Šถ = {y.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + + # ๅˆ†ๆžๆ ‡็ญพๅˆ†ๅธƒ๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰ + print(f"\nโœ“ ๆ ‡็ญพ็ปŸ่ฎก๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰๏ผš") + print(f" ๆœ€ๅฐๅ€ผ: {y.min()*100:.4f}%") + print(f" ๆœ€ๅคงๅ€ผ: {y.max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {y.mean()*100:.4f}%") + print(f" ๆ ‡ๅ‡†ๅทฎ: {y.std()*100:.4f}%") + print(f" ไธญไฝๆ•ฐ: {np.median(y)*100:.4f}%") + + # ๆ–นๅ‘็ปŸ่ฎก + n_positive = (y > 0).sum() + n_negative = (y <= 0).sum() + print(f"\nโœ“ ๆ–นๅ‘ๅˆ†ๅธƒ๏ผš") + print(f" ๆญฃๆ”ถ็›Š๏ผˆไธŠๆถจ๏ผ‰: {n_positive} ({n_positive/len(y)*100:.1f}%)") + print(f" ่ดŸๆ”ถ็›Š๏ผˆไธ‹่ทŒ๏ผ‰: {n_negative} ({n_negative/len(y)*100:.1f}%)") + + # ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›† + print("\n[3/8] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)...") + train_data, val_data, test_data = split_data(X, y, train_split=0.7, val_split=0.15) + + print(f" ่ฎญ็ปƒ้›†๏ผš{len(train_data[0])} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {train_data[1].min()*100:.4f}% ~ {train_data[1].max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {train_data[1].mean()*100:.4f}%") + + print(f" ้ชŒ่ฏ้›†๏ผš{len(val_data[0])} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {val_data[1].min()*100:.4f}% ~ {val_data[1].max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {val_data[1].mean()*100:.4f}%") + + print(f" ๆต‹่ฏ•้›†๏ผš{len(test_data[0])} ๆ ทๆœฌ") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {test_data[1].min()*100:.4f}% ~ {test_data[1].max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {test_data[1].mean()*100:.4f}%") + + # ๅˆ†ๆžๅ„ๆ•ฐๆฎ้›†ๅฏนๅบ”็š„ๆ—ถ้—ด่Œƒๅ›ด + lookback = 168 + train_end_idx = int(len(processed_df) * 0.7) - lookback + val_end_idx = int(len(processed_df) * 0.85) - lookback + + train_df = processed_df.iloc[lookback:train_end_idx+lookback] + val_df = processed_df.iloc[train_end_idx+lookback:val_end_idx+lookback] + test_df = processed_df.iloc[val_end_idx+lookback:] + + print(f"\n ่ฎญ็ปƒ้›†ๆ—ถ้—ด่Œƒๅ›ด: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f} ({train_return*100:+.1f}%)") + + print(f" ้ชŒ่ฏ้›†ๆ—ถ้—ด่Œƒๅ›ด: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f} ({val_return*100:+.1f}%)") + + print(f" ๆต‹่ฏ•้›†ๆ—ถ้—ด่Œƒๅ›ด: {test_df['timestamp'].min()} ่‡ณ {test_df['timestamp'].max()}") + test_return = (test_df['close'].iloc[-1] - test_df['close'].iloc[0]) / test_df['close'].iloc[0] + print(f" ไปทๆ ผ: ${test_df['close'].iloc[0]:,.0f} โ†’ ${test_df['close'].iloc[-1]:,.0f} ({test_return*100:+.1f}%)") + + # ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ + print("\n[4/8] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + task='regression', # ๅ›žๅฝ’ไปปๅŠก + batch_size=64 + ) + + # ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ + print("\n[5/8] ๅˆ›ๅปบDLinearๅ›žๅฝ’ๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='regression', # ๅ›žๅฝ’ไปปๅŠก + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + print(f"โœ“ ไปปๅŠก็ฑปๅž‹๏ผšๅ›žๅฝ’๏ผˆ้ข„ๆต‹ๆ”ถ็›Š็Ž‡็™พๅˆ†ๆฏ”๏ผ‰") + print(f"โœ“ ๆŸๅคฑๅ‡ฝๆ•ฐ๏ผšMSELoss") + + # ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ + print("\n[6/8] ๅผ€ๅง‹่ฎญ็ปƒๅ›žๅฝ’ๆจกๅž‹...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=10, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_regression' + ) + + trainer = Trainer( + model, + train_config, + task='regression' # ๅ›žๅฝ’ไปปๅŠก๏ผŒไธ้œ€่ฆpos_weight + ) + + print(f"โœ“ ่ฎญ็ปƒๆ•ฐๆฎ่ง„ๆจก๏ผš{len(train_data[0]):,} ๆ ทๆœฌ") + history = trainer.fit(train_loader, val_loader) + + # ๆญฅ้ชค7: ่ฏ„ไผฐๆจกๅž‹ + print("\n[7/8] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹...") + metrics = trainer.evaluate(test_loader) + + # ไฟๅญ˜่ฏ„ไผฐ็ป“ๆžœ + results_path = './models/checkpoints/dlinear_btc_regression/test_metrics.json' + with open(results_path, 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ่ฏ„ไผฐ็ป“ๆžœๅทฒไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๆญฅ้ชค8: ็ป“ๆžœๅˆ†ๆž + print("\n[8/8] ๅ›žๅฝ’ๆจกๅž‹ๆ€ง่ƒฝๅˆ†ๆž...") + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ๅ›žๅฝ’ๆจกๅž‹ๆต‹่ฏ•็ป“ๆžœ") + print("="*80) + + print(f"\n๐Ÿ“Š ๅ›žๅฝ’ๆŒ‡ๆ ‡:") + print(f" RMSE (ๅ‡ๆ–นๆ น่ฏฏๅทฎ): {metrics.get('rmse', 0):.6f} ({metrics.get('rmse', 0)*100:.4f}%)") + print(f" MAE (ๅนณๅ‡็ปๅฏน่ฏฏๅทฎ): {metrics.get('mae', 0):.6f} ({metrics.get('mae', 0)*100:.4f}%)") + print(f" MAPE (ๅนณๅ‡็ปๅฏน็™พๅˆ†ๆฏ”่ฏฏๅทฎ): {metrics.get('mape', 0):.2f}%") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {metrics.get('directional_accuracy', 0)*100:.2f}%") + + print(f"\n๐Ÿ’ฐ ๅ›žๆต‹็ป“ๆžœ:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๆœ€็ปˆ่ต„้‡‘: ${metrics.get('backtest_final_capital', 0):,.2f}") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {metrics.get('backtest_sharpe_ratio', 0):.4f}") + max_dd = metrics.get('backtest_max_drawdown', 0) + if not np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + else: + print(f" ๆœ€ๅคงๅ›žๆ’ค: N/A") + print(f" ่ƒœ็Ž‡: {metrics.get('backtest_win_rate', 0)*100:.2f}%") + print(f" ไบคๆ˜“ๆฌกๆ•ฐ: {metrics.get('backtest_num_trades', 0)}") + + # ไธŽๅˆ†็ฑปไปปๅŠกๅฏนๆฏ” + print("\n" + "="*80) + print("๐Ÿ“Š ๅ›žๅฝ’ vs ๅˆ†็ฑปไปปๅŠกๅฏนๆฏ”") + print("="*80) + + print(f"\nไบŒๅˆ†็ฑปๆจกๅž‹๏ผˆไน‹ๅ‰็š„็ป“ๆžœ๏ผ‰:") + print(f" ๅ‡†็กฎ็Ž‡: 49.76%") + print(f" F1ๅˆ†ๆ•ฐ: 0.3898") + print(f" ้ข„ๆต‹ๅๅทฎ: 68.1%้ข„ๆต‹ไธ‹่ทŒ๏ผˆ่ฟ‡ๅบฆๆ‚ฒ่ง‚๏ผ‰") + print(f" ๅ›žๆต‹ๆ”ถ็›Š: -3.29%") + + print(f"\nๅ›žๅฝ’ๆจกๅž‹๏ผˆๅฝ“ๅ‰็ป“ๆžœ๏ผ‰:") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {metrics.get('directional_accuracy', 0)*100:.2f}%") + print(f" RMSE: {metrics.get('rmse', 0)*100:.4f}%") + print(f" MAE: {metrics.get('mae', 0)*100:.4f}%") + print(f" ๅ›žๆต‹ๆ”ถ็›Š: {metrics.get('backtest_total_return', 0)*100:.2f}%") + + # ๆ€ง่ƒฝ่ฏ„ไผฐ + print(f"\n๐ŸŽฏ ๅ›žๅฝ’ๆจกๅž‹ๆ€ง่ƒฝ่ฏ„ไผฐ:") + + dir_acc = metrics.get('directional_accuracy', 0) + if dir_acc > 0.55: + print(f" โœ… ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% > 55%๏ผŒๆจกๅž‹ๆœ‰้ข„ๆต‹่ƒฝๅŠ›") + elif dir_acc > 0.50: + print(f" โš ๏ธ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% ็•ฅไผ˜ไบŽ้šๆœบ๏ผŒ้ข„ๆต‹่ƒฝๅŠ›่พƒๅผฑ") + else: + print(f" โŒ ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ {dir_acc*100:.1f}% โ‰ค 50%๏ผŒๆ–นๅ‘้ข„ๆต‹่ƒฝๅŠ›ไธ่ถณ") + + rmse = metrics.get('rmse', 0) + mae = metrics.get('mae', 0) + print(f"\n ่ฏฏๅทฎๅˆ†ๆž:") + print(f" RMSE = {rmse*100:.4f}% - ๅนณๅ‡้ข„ๆต‹่ฏฏๅทฎ็š„ๅนณๆ–นๆ น") + print(f" MAE = {mae*100:.4f}% - ๅนณๅ‡็ปๅฏน่ฏฏๅทฎ") + if rmse < 0.01: # ๅฐไบŽ1% + print(f" โœ… RMSE < 1%๏ผŒ้ข„ๆต‹็ฒพๅบฆ่พƒ้ซ˜") + elif rmse < 0.02: # ๅฐไบŽ2% + print(f" โš ๏ธ RMSEๅœจ1-2%ไน‹้—ด๏ผŒ้ข„ๆต‹็ฒพๅบฆไธญ็ญ‰") + else: + print(f" โŒ RMSE > 2%๏ผŒ้ข„ๆต‹่ฏฏๅทฎ่พƒๅคง") + + total_return = metrics.get('backtest_total_return', 0) + if total_return > 0.05: + print(f"\n โœ… ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 5%๏ผŒ็ญ–็•ฅๆœ‰็›ˆๅˆฉๆฝœๅŠ›") + elif total_return > 0: + print(f"\n โš ๏ธ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% > 0๏ผŒ็ญ–็•ฅๅพฎๅผฑ็›ˆๅˆฉ") + else: + print(f"\n โŒ ๅ›žๆต‹ๆ”ถ็›Š {total_return*100:.2f}% โ‰ค 0๏ผŒ็ญ–็•ฅไบๆŸ") + + print("\n๐Ÿ’ก ๅ›žๅฝ’ไปปๅŠก็š„ไผ˜ๅŠฟ:") + print(" โœ… ๆไพ›้ข„ๆต‹ๅน…ๅบฆไฟกๆฏ๏ผˆๅฏ็”จไบŽๅŠจๆ€ไป“ไฝ็ฎก็†๏ผ‰") + print(" โœ… ่ฏ„ไผฐ้ฃŽ้™ฉๆ”ถ็›Šๆฏ”") + print(" โœ… ๆ›ด้€‚ๅˆ้‡ๅŒ–ไบคๆ˜“็ญ–็•ฅ") + + print("\n๐Ÿ’ก ๅ›žๅฝ’ไปปๅŠก็š„ๆŒ‘ๆˆ˜:") + print(" โŒ ้ข„ๆต‹ๅ…ทไฝ“ๆ•ฐๅ€ผๆฏ”้ข„ๆต‹ๆ–นๅ‘ๆ›ด้šพ") + print(" โŒ ๅฏนๅผ‚ๅธธๅ€ผๆ•ๆ„Ÿ") + print(" โŒ ้œ€่ฆๆ›ดๅคš่ฎญ็ปƒๆ•ฐๆฎๆ‰่ƒฝ็จณๅฎš") + + print("\n" + "="*80) + print("โœ“ ๅ›žๅฝ’ๆจกๅž‹่ฎญ็ปƒๅฎŒๆˆ๏ผ") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_full_data.py b/train_full_data.py new file mode 100644 index 0000000..9123598 --- /dev/null +++ b/train_full_data.py @@ -0,0 +1,233 @@ +"""ๆ–นๆกˆA๏ผšไฝฟ็”จ2020-2025ๅนดBTCๅ…จ้ƒจๆ•ฐๆฎ่ฎญ็ปƒ - ๅ‡†ๅค‡ๅฎž็›˜ไฝฟ็”จ""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +from data.fetcher import BinanceDataFetcher +from data.preprocessor import CryptoPreprocessor, split_data +from data.dataset import create_dataloaders +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import numpy as np + +def main(): + print("="*80) + print("ๆ–นๆกˆA๏ผšBTCๅ…จ้‡ๆ•ฐๆฎ่ฎญ็ปƒ (2020-2025)") + print("่ฎญ็ปƒ้›†๏ผš95% | ้ชŒ่ฏ้›†๏ผš5%๏ผˆไป…็”จไบŽearly stopping๏ผ‰| ๆต‹่ฏ•้›†๏ผšๆ— ") + print("="*80) + + # ========== ๆญฅ้ชค1: ่Žทๅ–ๅ…จ้ƒจBTCๆ•ฐๆฎ ========== + print("\n[1/7] ่Žทๅ–BTC 2020-2025ๅนดๅ…จ้ƒจๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๅทฒ่Žทๅ– {len(df):,} ่กŒๆ•ฐๆฎ๏ผˆ็บฆ{len(df)/8760:.1f}ๅนด๏ผ‰") + print(f"โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš{df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ่Œƒๅ›ด๏ผš${df['close'].iloc[0]:,.2f} โ†’ ${df['close'].iloc[-1]:,.2f}") + total_return = (df['close'].iloc[-1] - df['close'].iloc[0]) / df['close'].iloc[0] + print(f"โœ“ ๆ€ปๆ”ถ็›Š็Ž‡๏ผš{total_return*100:+.2f}%") + + # ๅธ‚ๅœบๅ‘จๆœŸๅˆ†ๆž + df['year'] = df['timestamp'].dt.year + print(f"\nโœ“ ๅธ‚ๅœบๅ‘จๆœŸ่ฆ†็›–๏ผš") + for year in sorted(df['year'].unique()): + year_df = df[df['year'] == year] + if len(year_df) > 100: + year_return = (year_df['close'].iloc[-1] - year_df['close'].iloc[0]) / year_df['close'].iloc[0] + trend = "๐Ÿš€ ็‰›ๅธ‚" if year_return > 0.3 else ("๐Ÿ”ด ็†Šๅธ‚" if year_return < -0.3 else "๐Ÿ“Š ้œ‡่ก") + print(f" {year}ๅนด: {year_return*100:+7.2f}% {trend}") + + # ========== ๆญฅ้ชค2: ๆ•ฐๆฎ้ข„ๅค„็† ========== + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๅ›žๅฝ’ไปปๅŠก๏ผ‰...") + preprocessor = CryptoPreprocessor( + lookback=168, # ่พ“ๅ…ฅ๏ผš่ฟ‡ๅŽป7ๅคฉ + forecast_horizon=1, # ้ข„ๆต‹๏ผšๆœชๆฅ1ๅฐๆ—ถ + price_change_threshold=0.0 + ) + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='regression', fit=True) + + print(f"โœ“ ๅบๅˆ—ๆ•ฐ้‡๏ผš{len(X):,}") + print(f"โœ“ ๅบๅˆ—ๅฝข็Šถ๏ผš{X.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + + print(f"\nโœ“ ๆ ‡็ญพ็ปŸ่ฎก๏ผˆๆ”ถ็›Š็Ž‡๏ผ‰๏ผš") + print(f" ๆœ€ๅฐๅ€ผ: {y.min()*100:.4f}%") + print(f" ๆœ€ๅคงๅ€ผ: {y.max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {y.mean()*100:.4f}%") + print(f" ๆ ‡ๅ‡†ๅทฎ: {y.std()*100:.4f}%") + print(f" ไธญไฝๆ•ฐ: {np.median(y)*100:.4f}%") + + n_positive = (y > 0).sum() + n_negative = (y <= 0).sum() + print(f"\nโœ“ ๆ–นๅ‘ๅˆ†ๅธƒ๏ผš") + print(f" ไธŠๆถจ: {n_positive:,} ({n_positive/len(y)*100:.1f}%)") + print(f" ไธ‹่ทŒ: {n_negative:,} ({n_negative/len(y)*100:.1f}%)") + + # ========== ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95% ่ฎญ็ปƒ + 5% ้ชŒ่ฏ๏ผ‰========== + print("\n[3/7] ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95%่ฎญ็ปƒ + 5%้ชŒ่ฏ๏ผ‰...") + print("โš ๏ธ ๆณจๆ„๏ผšๆญคๆฌก่ฎญ็ปƒไฝฟ็”จๅ‡ ไนŽๅ…จ้ƒจๆ•ฐๆฎ๏ผŒๆ— ็‹ฌ็ซ‹ๆต‹่ฏ•้›†") + print(" ้ชŒ่ฏ้›†ไป…็”จไบŽearly stopping้˜ฒๆญข่ฟ‡ๆ‹Ÿๅˆ") + + n = len(X) + train_end = int(n * 0.95) + + X_train = X[:train_end] + y_train = y[:train_end] + X_val = X[train_end:] + y_val = y[train_end:] + + print(f"\n ่ฎญ็ปƒ้›†๏ผš{len(X_train):,} ๆ ทๆœฌ ({len(X_train)/n*100:.1f}%)") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y_train.min()*100:.4f}% ~ {y_train.max()*100:.4f}%") + + print(f" ้ชŒ่ฏ้›†๏ผš{len(X_val):,} ๆ ทๆœฌ ({len(X_val)/n*100:.1f}%)") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y_val.min()*100:.4f}% ~ {y_val.max()*100:.4f}%") + + # ๆ—ถ้—ด่Œƒๅ›ดๅˆ†ๆž + lookback = 168 + train_df = processed_df.iloc[lookback:train_end+lookback] + val_df = processed_df.iloc[train_end+lookback:] + + print(f"\n ๆ—ถ้—ด่Œƒๅ›ด๏ผš") + print(f" ่ฎญ็ปƒ้›†: {train_df['timestamp'].min()} ่‡ณ {train_df['timestamp'].max()}") + train_return = (train_df['close'].iloc[-1] - train_df['close'].iloc[0]) / train_df['close'].iloc[0] + print(f" ${train_df['close'].iloc[0]:,.0f} โ†’ ${train_df['close'].iloc[-1]:,.0f} ({train_return*100:+.1f}%)") + + print(f" ้ชŒ่ฏ้›†: {val_df['timestamp'].min()} ่‡ณ {val_df['timestamp'].max()}") + val_return = (val_df['close'].iloc[-1] - val_df['close'].iloc[0]) / val_df['close'].iloc[0] + print(f" ${val_df['close'].iloc[0]:,.0f} โ†’ ${val_df['close'].iloc[-1]:,.0f} ({val_return*100:+.1f}%)") + + # ========== ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[4/7] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_loader, val_loader, _ = create_dataloaders( + (X_train, y_train), + (X_val, y_val), + (X_val, y_val), # ๆต‹่ฏ•้›†็”จ้ชŒ่ฏ้›†ๆ›ฟไปฃ๏ผˆไธไฝฟ็”จ๏ผ‰ + task='regression', + batch_size=64 + ) + + # ========== ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[5/7] ๅˆ›ๅปบDLinearๅ›žๅฝ’ๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='regression', + hidden_dim=512, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ๏ผš{model.count_parameters():,} ไธช") + print(f"โœ“ ไปปๅŠก็ฑปๅž‹๏ผšๅ›žๅฝ’๏ผˆ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถๆ”ถ็›Š็Ž‡๏ผ‰") + print(f"โœ“ ๆŸๅคฑๅ‡ฝๆ•ฐ๏ผšMSELoss") + + # ========== ๆญฅ้ชค6: ่ฎญ็ปƒๆจกๅž‹ ========== + print("\n[6/7] ๅผ€ๅง‹ๅ…จ้‡ๆ•ฐๆฎ่ฎญ็ปƒ...") + print(f"โœ“ ่ฎญ็ปƒๆ ทๆœฌ๏ผš{len(X_train):,} ๏ผˆไฝฟ็”จไบ†{len(X_train)/len(X)*100:.1f}%็š„ๆ•ฐๆฎ๏ผ‰") + print(f"โœ“ ๅฏนๆฏ”ไน‹ๅ‰๏ผšไน‹ๅ‰่ฎญ็ปƒ้›†36,645ๆ ทๆœฌ๏ผŒ็Žฐๅœจ{len(X_train):,}ๆ ทๆœฌ๏ผˆ+{(len(X_train)-36645)/36645*100:.1f}%๏ผ‰") + + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=15, # ๅขžๅŠ patience๏ผŒๅ…่ฎธๆ›ดๅ……ๅˆ†่ฎญ็ปƒ + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_btc_full_data' + ) + + trainer = Trainer(model, train_config, task='regression') + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค7: ไฟๅญ˜ๆœ€็ปˆๆจกๅž‹ ========== + print("\n[7/7] ไฟๅญ˜ๆœ€็ปˆๆจกๅž‹...") + + # ๅœจ้ชŒ่ฏ้›†ไธŠๅฟซ้€Ÿ่ฏ„ไผฐ + print("\nๅœจ้ชŒ่ฏ้›†ไธŠ่ฟ›่กŒsanity check...") + val_metrics = trainer.evaluate(val_loader) + + results_path = './models/checkpoints/dlinear_btc_full_data/final_metrics.json' + with open(results_path, 'w') as f: + json.dump(val_metrics, f, indent=2) + print(f"โœ“ ็ป“ๆžœไฟๅญ˜่‡ณ๏ผš{results_path}") + + # ๅŒๆ—ถไฟๅญ˜้ข„ๅค„็†ๅ™จ๏ผˆๅฎž็›˜ไฝฟ็”จๆ—ถ้œ€่ฆ๏ผ‰ + import pickle + preprocessor_path = './models/checkpoints/dlinear_btc_full_data/preprocessor.pkl' + with open(preprocessor_path, 'wb') as f: + pickle.dump(preprocessor, f) + print(f"โœ“ ้ข„ๅค„็†ๅ™จไฟๅญ˜่‡ณ๏ผš{preprocessor_path}") + + # ========== ๆœ€็ปˆๆŠฅๅ‘Š ========== + print("\n" + "="*80) + print("ๅ…จ้‡ๆ•ฐๆฎ่ฎญ็ปƒๅฎŒๆˆ - ๆœ€็ปˆๆŠฅๅ‘Š") + print("="*80) + + print(f"\n๐Ÿ“Š ่ฎญ็ปƒๆฆ‚ๅ†ต๏ผš") + print(f" ๆ•ฐๆฎๆ—ถ้—ด่Œƒๅ›ด๏ผš2020-01-01 ่‡ณ 2025-12-31 (6ๅนด)") + print(f" ่ฎญ็ปƒๆ ทๆœฌๆ•ฐ้‡๏ผš{len(X_train):,} (95%)") + print(f" ้ชŒ่ฏๆ ทๆœฌๆ•ฐ้‡๏ผš{len(X_val):,} (5%)") + print(f" ็‰นๅพๆ•ฐ้‡๏ผš{X.shape[-1]}") + print(f" ๆจกๅž‹ๅ‚ๆ•ฐ๏ผš{model.count_parameters():,}") + + print(f"\n๐Ÿ“ˆ ้ชŒ่ฏ้›†ๆ€ง่ƒฝ๏ผˆไป…ไพ›ๅ‚่€ƒ๏ผŒ้ž็‹ฌ็ซ‹ๆต‹่ฏ•๏ผ‰๏ผš") + print(f" RMSE: {val_metrics.get('rmse', 0)*100:.4f}%") + print(f" MAE: {val_metrics.get('mae', 0)*100:.4f}%") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {val_metrics.get('directional_accuracy', 0)*100:.2f}%") + + print(f"\n๐Ÿ’ฐ ้ชŒ่ฏ้›†ๅ›žๆต‹๏ผˆไป…ไพ›ๅ‚่€ƒ๏ผ‰๏ผš") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {val_metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {val_metrics.get('backtest_sharpe_ratio', 0):.4f}") + max_dd = val_metrics.get('backtest_max_drawdown', 0) + if not np.isnan(max_dd): + print(f" ๆœ€ๅคงๅ›žๆ’ค: {max_dd*100:.2f}%") + print(f" ่ƒœ็Ž‡: {val_metrics.get('backtest_win_rate', 0)*100:.2f}%") + + print("\n" + "="*80) + print("๐ŸŽฏ ๅ…จ้‡่ฎญ็ปƒ vs ไน‹ๅ‰่ฎญ็ปƒๅฏนๆฏ”") + print("="*80) + + print("\nไน‹ๅ‰่ฎญ็ปƒ๏ผˆ70/15/15ๅˆ†ๅ‰ฒ๏ผ‰๏ผš") + print(" ่ฎญ็ปƒๆ ทๆœฌ: 36,645") + print(" ๆ—ถ้—ด่Œƒๅ›ด: 2020-01 ่‡ณ 2024-03") + print(" ๆต‹่ฏ•้›†ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: 50.67%") + print(" ๆต‹่ฏ•้›†ๅ›žๆต‹ๆ”ถ็›Š: -16.71%") + + print(f"\nๅฝ“ๅ‰ๅ…จ้‡่ฎญ็ปƒ๏ผˆ95/5ๅˆ†ๅ‰ฒ๏ผ‰๏ผš") + print(f" ่ฎญ็ปƒๆ ทๆœฌ: {len(X_train):,} (+{(len(X_train)-36645)/36645*100:.1f}%)") + print(f" ๆ—ถ้—ด่Œƒๅ›ด: 2020-01 ่‡ณ {train_df['timestamp'].max().strftime('%Y-%m')}") + print(f" ้ชŒ่ฏ้›†ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {val_metrics.get('directional_accuracy', 0)*100:.2f}%") + print(f" ้ชŒ่ฏ้›†ๅ›žๆต‹ๆ”ถ็›Š: {val_metrics.get('backtest_total_return', 0)*100:.2f}%") + + print("\n" + "="*80) + print("โš ๏ธ ้‡่ฆ่ฏดๆ˜Ž") + print("="*80) + print("\n1. ๆญคๆจกๅž‹ไฝฟ็”จไบ†95%็š„ๅŽ†ๅฒๆ•ฐๆฎ่ฎญ็ปƒ") + print("2. ้ชŒ่ฏ้›†ไป…ๅ 5%๏ผŒๆ€ง่ƒฝๆŒ‡ๆ ‡ไป…ไพ›ๅ‚่€ƒ๏ผŒไธไปฃ่กจ็œŸๅฎžๆณ›ๅŒ–่ƒฝๅŠ›") + print("3. ๆจกๅž‹ๅทฒ้’ˆๅฏน2020-2025ๅนดๅธ‚ๅœบ็Žฏๅขƒๅ……ๅˆ†ไผ˜ๅŒ–") + print("4. ้€‚็”จๅœบๆ™ฏ๏ผš") + print(" โœ… ็”จไบŽ2026ๅนดๆœชๆฅๆ•ฐๆฎ็š„้ข„ๆต‹") + print(" โœ… ็”จไบŽๅฎž็›˜ไบคๆ˜“๏ผˆๅ‡่ฎพๆœชๆฅๅธ‚ๅœบ็‰นๅพไธŽๅŽ†ๅฒ็›ธไผผ๏ผ‰") + print(" โŒ ไธ้€‚ๅˆ่ฏ„ไผฐๅœจๆœช่ง่ฟ‡ๆ•ฐๆฎไธŠ็š„ๆณ›ๅŒ–ๆ€ง่ƒฝ") + + print("\n๐Ÿ’ก ไธ‹ไธ€ๆญฅๅปบ่ฎฎ๏ผš") + print(" 1. ไฝฟ็”จๆญคๆจกๅž‹้ข„ๆต‹2026ๅนด1ๆœˆ็š„BTCไปทๆ ผ") + print(" 2. ๅœจๅฎž็›˜ไธญๅฐไป“ไฝๆต‹่ฏ•็ญ–็•ฅ") + print(" 3. ๅฎšๆœŸ๏ผˆๆฏๆœˆ/ๅญฃๅบฆ๏ผ‰็”จๆ–ฐๆ•ฐๆฎ้‡ๆ–ฐ่ฎญ็ปƒๆจกๅž‹") + print(" 4. ็›‘ๆŽงๅฎž็›˜ๆ€ง่ƒฝ๏ผŒๅฆ‚ๆžœๅๅทฎๅคง่ฏดๆ˜Žๅธ‚ๅœบ็Žฏๅขƒๅ˜ๅŒ–") + + print("\n" + "="*80) + print("โœ“ ่ฎญ็ปƒๅฎŒๆˆ๏ผๆจกๅž‹ๅทฒไฟๅญ˜ๅˆฐ ./models/checkpoints/dlinear_btc_full_data/") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_predict_price.py b/train_predict_price.py new file mode 100644 index 0000000..03e9e34 --- /dev/null +++ b/train_predict_price.py @@ -0,0 +1,260 @@ +"""็›ดๆŽฅ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถ็š„ไปทๆ ผ๏ผˆ่€Œ้žๆ”ถ็›Š็Ž‡๏ผ‰""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +import torch +import torch.nn as nn +from torch.utils.data import DataLoader, TensorDataset + +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import pickle + +class PricePreprocessor: + """้ข„ๆต‹ๆœชๆฅไปทๆ ผ็š„้ข„ๅค„็†ๅ™จ""" + + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.price_scaler = StandardScaler() # ๅ•็‹ฌ็š„ไปทๆ ผ็ผฉๆ”พๅ™จ + self.is_fitted = False + + def add_features(self, df): + """ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡""" + df = df.copy() + + # RSI + df['rsi'] = ta.rsi(df['close'], length=14) + + # MACD + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + + return df + + def create_labels(self, df): + """ๅˆ›ๅปบๆ ‡็ญพ๏ผšๆœชๆฅ1ๅฐๆ—ถ็š„ไปทๆ ผ๏ผˆ็ปๅฏนไปทๆ ผ๏ผ‰""" + df = df.copy() + # ๆ ‡็ญพๆ˜ฏๆœชๆฅ1ๅฐๆ—ถ็š„ๆ”ถ็›˜ไปท + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['label'] = df['future_price'] + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + """ๅฎŒๆ•ด้ข„ๅค„็†ๆต็จ‹""" + # ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ + df = self.add_features(df) + df = self.create_labels(df) + + # ๅˆ ้™คNaN + df = df.dropna().reset_index(drop=True) + + # ็‰นๅพๅˆ— + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + # ๆ ‡ๅ‡†ๅŒ–็‰นๅพ + if fit: + scaled_features = self.scaler.fit_transform(df[feature_cols]) + # ๅ•็‹ฌๆ ‡ๅ‡†ๅŒ–ไปทๆ ผๆ ‡็ญพ๏ผˆ็”จไบŽ่ฎญ็ปƒ๏ผ‰ + scaled_labels = self.price_scaler.fit_transform(df[['label']]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled_features = self.scaler.transform(df[feature_cols]) + scaled_labels = self.price_scaler.transform(df[['label']]) + + # ๅˆ›ๅปบๅบๅˆ— + X, y = [], [] + for i in range(len(scaled_features) - self.lookback): + X.append(scaled_features[i:i + self.lookback]) + y.append(scaled_labels[i + self.lookback, 0]) # ๆ ‡ๅ‡†ๅŒ–ๅŽ็š„ไปทๆ ผ + + return np.array(X), np.array(y), df + + def inverse_transform_price(self, scaled_price): + """ๅฐ†ๆ ‡ๅ‡†ๅŒ–็š„ไปทๆ ผ่ฟ˜ๅŽŸไธบ็œŸๅฎžไปทๆ ผ""" + return self.price_scaler.inverse_transform(scaled_price.reshape(-1, 1)).flatten() + +def main(): + print("="*80) + print("่ฎญ็ปƒๆจกๅž‹๏ผš็›ดๆŽฅ้ข„ๆต‹ๆœชๆฅ1ๅฐๆ—ถไปทๆ ผ") + print("="*80) + + # ========== ๆญฅ้ชค1: ่Žทๅ–ๆ•ฐๆฎ ========== + print("\n[1/7] ่Žทๅ–BTC 2020-2025ๅนดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๆ•ฐๆฎ้‡: {len(df):,} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df['close'].iloc[0]:,.2f} โ†’ ${df['close'].iloc[-1]:,.2f}") + + # ========== ๆญฅ้ชค2: ้ข„ๅค„็† ========== + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆ้ข„ๆต‹็ปๅฏนไปทๆ ผ๏ผ‰...") + preprocessor = PricePreprocessor(lookback=168, forecast_horizon=1) + X, y, processed_df = preprocessor.preprocess(df, fit=True) + + print(f"โœ“ ๅบๅˆ—ๆ•ฐ้‡: {len(X):,}") + print(f"โœ“ ๅบๅˆ—ๅฝข็Šถ: {X.shape}") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡: {len(preprocessor.feature_columns)}") + + # ่ฟ˜ๅŽŸ็œŸๅฎžไปทๆ ผ็œ‹็œ‹็ปŸ่ฎก + y_real = preprocessor.inverse_transform_price(y) + print(f"\nโœ“ ็›ฎๆ ‡ไปทๆ ผ็ปŸ่ฎก๏ผˆ็œŸๅฎžๅ€ผ๏ผ‰:") + print(f" ๆœ€ๅฐๅ€ผ: ${y_real.min():,.2f}") + print(f" ๆœ€ๅคงๅ€ผ: ${y_real.max():,.2f}") + print(f" ๅ‡ๅ€ผ: ${y_real.mean():,.2f}") + + # ========== ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95/5๏ผ‰========== + print("\n[3/7] ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95%่ฎญ็ปƒ + 5%้ชŒ่ฏ๏ผ‰...") + n = len(X) + train_end = int(n * 0.95) + + X_train, y_train = X[:train_end], y[:train_end] + X_val, y_val = X[train_end:], y[train_end:] + + print(f" ่ฎญ็ปƒ้›†: {len(X_train):,} ๆ ทๆœฌ") + print(f" ้ชŒ่ฏ้›†: {len(X_val):,} ๆ ทๆœฌ") + + # ========== ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[4/7] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_dataset = TensorDataset( + torch.FloatTensor(X_train), + torch.FloatTensor(y_train) + ) + val_dataset = TensorDataset( + torch.FloatTensor(X_val), + torch.FloatTensor(y_val) + ) + + train_loader = DataLoader(train_dataset, batch_size=64, shuffle=False) + val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False) + + # ========== ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=9, + lookback=168, + task='regression', # ไป็„ถๆ˜ฏๅ›žๅฝ’๏ผŒไฝ†้ข„ๆต‹ไปทๆ ผ่€Œ้žๆ”ถ็›Š็Ž‡ + hidden_dim=256, + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,}") + print(f"โœ“ ้ข„ๆต‹็›ฎๆ ‡: ๆœชๆฅ1ๅฐๆ—ถ็š„็ปๅฏนไปทๆ ผ") + + # ========== ๆญฅ้ชค6: ่ฎญ็ปƒ ========== + print("\n[6/7] ๅผ€ๅง‹่ฎญ็ปƒ...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=15, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_predict_price' + ) + + trainer = Trainer(model, train_config, task='regression') + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค7: ่ฏ„ไผฐ ========== + print("\n[7/7] ่ฏ„ไผฐๆจกๅž‹...") + + # ๅœจ้ชŒ่ฏ้›†ไธŠ้ข„ๆต‹ + device = torch.device('mps' if torch.backends.mps.is_available() else 'cpu') + model = model.to(device) + model.eval() + + val_preds = [] + with torch.no_grad(): + for batch_X, _ in val_loader: + batch_X = batch_X.to(device) + pred = model(batch_X).squeeze() + val_preds.extend(pred.cpu().numpy()) + + val_preds = np.array(val_preds) + + # ่ฟ˜ๅŽŸไธบ็œŸๅฎžไปทๆ ผ + pred_prices = preprocessor.inverse_transform_price(val_preds) + true_prices = preprocessor.inverse_transform_price(y_val) + + # ่ฎก็ฎ—ๅฝ“ๅ‰ไปทๆ ผ๏ผˆ็”จไบŽๅˆคๆ–ญๆ–นๅ‘๏ผ‰ + val_start_idx = train_end + 168 # +168ๆ˜ฏlookback + current_prices = processed_df['close'].iloc[val_start_idx:val_start_idx+len(pred_prices)].values + + # ๆ–นๅ‘ๅ‡†็กฎ็Ž‡ + pred_direction = (pred_prices > current_prices).astype(int) + true_direction = (true_prices > current_prices).astype(int) + direction_acc = (pred_direction == true_direction).mean() + + # ไปทๆ ผ้ข„ๆต‹่ฏฏๅทฎ + price_mae = np.abs(pred_prices - true_prices).mean() + price_rmse = np.sqrt(((pred_prices - true_prices) ** 2).mean()) + price_mape = np.mean(np.abs((true_prices - pred_prices) / true_prices)) * 100 + + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ - ้ชŒ่ฏ้›†ๆ€ง่ƒฝ") + print("="*80) + + print(f"\n๐Ÿ“Š ไปทๆ ผ้ข„ๆต‹่ฏฏๅทฎ:") + print(f" MAE: ${price_mae:,.2f}") + print(f" RMSE: ${price_rmse:,.2f}") + print(f" MAPE: {price_mape:.2f}%") + + print(f"\n๐Ÿ“ˆ ๆ–นๅ‘้ข„ๆต‹:") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {direction_acc*100:.2f}%") + print(f" ้ข„ๆต‹ไธŠๆถจ: {(pred_direction==1).sum()} / ๅฎž้™…ไธŠๆถจ: {(true_direction==1).sum()}") + print(f" ้ข„ๆต‹ไธ‹่ทŒ: {(pred_direction==0).sum()} / ๅฎž้™…ไธ‹่ทŒ: {(true_direction==0).sum()}") + + print(f"\n๐Ÿ’ก ไปทๆ ผ้ข„ๆต‹็คบไพ‹๏ผˆๅ‰10ไธช๏ผ‰:") + print(f"{'ๅฝ“ๅ‰ไปทๆ ผ':<12} {'้ข„ๆต‹ไปทๆ ผ':<12} {'ๅฎž้™…ไปทๆ ผ':<12} {'้ข„ๆต‹ๆ–นๅ‘':<8} {'ๅฎž้™…ๆ–นๅ‘':<8}") + print("-"*70) + for i in range(min(10, len(pred_prices))): + pred_dir = "ไธŠๆถจ" if pred_prices[i] > current_prices[i] else "ไธ‹่ทŒ" + true_dir = "ไธŠๆถจ" if true_prices[i] > current_prices[i] else "ไธ‹่ทŒ" + print(f"${current_prices[i]:<11,.2f} ${pred_prices[i]:<11,.2f} ${true_prices[i]:<11,.2f} " + f"{pred_dir:<8} {true_dir:<8}") + + # ไฟๅญ˜ๆจกๅž‹ๅ’Œ้ข„ๅค„็†ๅ™จ + with open('./models/checkpoints/dlinear_predict_price/preprocessor.pkl', 'wb') as f: + pickle.dump(preprocessor, f) + + # ไฟๅญ˜่ฏ„ไผฐๆŒ‡ๆ ‡ + metrics = { + 'price_mae': float(price_mae), + 'price_rmse': float(price_rmse), + 'price_mape': float(price_mape), + 'direction_accuracy': float(direction_acc) + } + with open('./models/checkpoints/dlinear_predict_price/metrics.json', 'w') as f: + json.dump(metrics, f, indent=2) + + print(f"\nโœ“ ๆจกๅž‹ไฟๅญ˜่‡ณ: ./models/checkpoints/dlinear_predict_price/") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/train_simple_features.py b/train_simple_features.py new file mode 100644 index 0000000..6e047ac --- /dev/null +++ b/train_simple_features.py @@ -0,0 +1,206 @@ +"""็ฎ€ๅŒ–็‰นๅพ่ฎญ็ปƒ๏ผšๅชไฝฟ็”จOHLCV + RSI + MACD""" + +import sys +import os +sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) + +import numpy as np +import pandas as pd +import pandas_ta as ta +from sklearn.preprocessing import StandardScaler +import torch +import torch.nn as nn +from torch.utils.data import DataLoader, TensorDataset + +from data.fetcher import BinanceDataFetcher +from models.dlinear.model import DLinear, DLinearConfig +from training.trainer import Trainer +from training.config import TrainingConfig +import json +import pickle + +class SimplePreprocessor: + """็ฎ€ๅŒ–็š„้ข„ๅค„็†ๅ™จ๏ผšๅชไฝฟ็”จOHLCV + RSI + MACD""" + + def __init__(self, lookback=168, forecast_horizon=1): + self.lookback = lookback + self.forecast_horizon = forecast_horizon + self.scaler = StandardScaler() + self.is_fitted = False + + def add_features(self, df): + """ๆทปๅŠ RSIๅ’ŒMACD็‰นๅพ""" + df = df.copy() + + # RSI (14 periods) + df['rsi'] = ta.rsi(df['close'], length=14) + + # MACD + macd = ta.macd(df['close']) + if macd is not None and not macd.empty: + df['macd'] = macd.iloc[:, 0] + df['macd_hist'] = macd.iloc[:, 1] + df['macd_signal'] = macd.iloc[:, 2] + + return df + + def create_labels(self, df): + """ๅˆ›ๅปบๆ ‡็ญพ๏ผšๆœชๆฅ1ๅฐๆ—ถ็š„ๆ”ถ็›Š็Ž‡""" + df = df.copy() + df['future_price'] = df['close'].shift(-self.forecast_horizon) + df['future_return'] = (df['future_price'] - df['close']) / df['close'] + df['label'] = df['future_return'] + return df[:-self.forecast_horizon] + + def preprocess(self, df, fit=True): + """ๅฎŒๆ•ด้ข„ๅค„็†ๆต็จ‹""" + # ๆทปๅŠ ๆŠ€ๆœฏๆŒ‡ๆ ‡ + df = self.add_features(df) + df = self.create_labels(df) + + # ๅˆ ้™คNaN + df = df.dropna().reset_index(drop=True) + + # ้€‰ๆ‹ฉ็‰นๅพๅˆ—๏ผšOHLCV + RSI + MACD + feature_cols = ['open', 'high', 'low', 'close', 'volume', + 'rsi', 'macd', 'macd_hist', 'macd_signal'] + + # ๆ ‡ๅ‡†ๅŒ– + if fit: + scaled = self.scaler.fit_transform(df[feature_cols]) + self.is_fitted = True + self.feature_columns = feature_cols + else: + if not self.is_fitted: + raise ValueError("Must fit before transform") + scaled = self.scaler.transform(df[feature_cols]) + + # ๅˆ›ๅปบๅบๅˆ— + X, y = [], [] + for i in range(len(scaled) - self.lookback): + X.append(scaled[i:i + self.lookback]) + y.append(df['label'].iloc[i + self.lookback]) + + return np.array(X), np.array(y), df + +def main(): + print("="*80) + print("็ฎ€ๅŒ–็‰นๅพ่ฎญ็ปƒ๏ผšOHLCV + RSI + MACD") + print("="*80) + + # ========== ๆญฅ้ชค1: ่Žทๅ–ๆ•ฐๆฎ ========== + print("\n[1/7] ่Žทๅ–BTC 2020-2025ๅนดๆ•ฐๆฎ...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv( + symbol='BTC', + timeframe='1h', + start_date='2020-01-01', + end_date='2025-12-31', + use_cache=True + ) + + print(f"โœ“ ๆ•ฐๆฎ้‡: {len(df):,} ่กŒ") + print(f"โœ“ ๆ—ถ้—ด: {df['timestamp'].min()} ่‡ณ {df['timestamp'].max()}") + print(f"โœ“ ไปทๆ ผ: ${df['close'].iloc[0]:,.2f} โ†’ ${df['close'].iloc[-1]:,.2f}") + + # ========== ๆญฅ้ชค2: ้ข„ๅค„็† ========== + print("\n[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๅชไฝฟ็”จ9ไธช็‰นๅพ๏ผ‰...") + preprocessor = SimplePreprocessor(lookback=168, forecast_horizon=1) + X, y, processed_df = preprocessor.preprocess(df, fit=True) + + print(f"โœ“ ๅบๅˆ—ๆ•ฐ้‡: {len(X):,}") + print(f"โœ“ ๅบๅˆ—ๅฝข็Šถ: {X.shape}") + print(f"โœ“ ็‰นๅพๅˆ—่กจ:") + for i, col in enumerate(preprocessor.feature_columns, 1): + print(f" {i}. {col}") + + print(f"\nโœ“ ๆ ‡็ญพ็ปŸ่ฎก:") + print(f" ๆ”ถ็›Š็Ž‡่Œƒๅ›ด: {y.min()*100:.4f}% ~ {y.max()*100:.4f}%") + print(f" ๅ‡ๅ€ผ: {y.mean()*100:.4f}%") + print(f" ไธŠๆถจๆ ทๆœฌ: {(y>0).sum()} ({(y>0).sum()/len(y)*100:.1f}%)") + print(f" ไธ‹่ทŒๆ ทๆœฌ: {(y<=0).sum()} ({(y<=0).sum()/len(y)*100:.1f}%)") + + # ========== ๆญฅ้ชค3: ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95/5๏ผ‰========== + print("\n[3/7] ๅˆ’ๅˆ†ๆ•ฐๆฎ้›†๏ผˆ95%่ฎญ็ปƒ + 5%้ชŒ่ฏ๏ผ‰...") + n = len(X) + train_end = int(n * 0.95) + + X_train, y_train = X[:train_end], y[:train_end] + X_val, y_val = X[train_end:], y[train_end:] + + print(f" ่ฎญ็ปƒ้›†: {len(X_train):,} ๆ ทๆœฌ") + print(f" ้ชŒ่ฏ้›†: {len(X_val):,} ๆ ทๆœฌ") + + # ========== ๆญฅ้ชค4: ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ ========== + print("\n[4/7] ๅˆ›ๅปบๆ•ฐๆฎๅŠ ่ฝฝๅ™จ...") + train_dataset = TensorDataset( + torch.FloatTensor(X_train), + torch.FloatTensor(y_train) + ) + val_dataset = TensorDataset( + torch.FloatTensor(X_val), + torch.FloatTensor(y_val) + ) + + train_loader = DataLoader(train_dataset, batch_size=64, shuffle=False) + val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False) + + # ========== ๆญฅ้ชค5: ๅˆ›ๅปบๆจกๅž‹ ========== + print("\n[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹...") + model_config = DLinearConfig( + input_dim=9, # OHLCV + RSI + MACD(3ไธช) + lookback=168, + task='regression', + hidden_dim=256, # ๅ‡ๅฐ้š่—ๅฑ‚ + dropout=0.1, + moving_avg_kernel=25 + ) + model = DLinear(model_config) + print(f"โœ“ ๆจกๅž‹ๅ‚ๆ•ฐ: {model.count_parameters():,}") + + # ========== ๆญฅ้ชค6: ่ฎญ็ปƒ ========== + print("\n[6/7] ๅผ€ๅง‹่ฎญ็ปƒ...") + train_config = TrainingConfig( + batch_size=64, + max_epochs=50, + learning_rate=0.001, + early_stopping_patience=15, + lr_scheduler='plateau', + save_best=True, + checkpoint_dir='./models/checkpoints/dlinear_simple_features' + ) + + trainer = Trainer(model, train_config, task='regression') + history = trainer.fit(train_loader, val_loader) + + # ========== ๆญฅ้ชค7: ่ฏ„ไผฐๅนถไฟๅญ˜ ========== + print("\n[7/7] ่ฏ„ไผฐๅนถไฟๅญ˜...") + val_metrics = trainer.evaluate(val_loader) + + # ไฟๅญ˜็ป“ๆžœ + with open('./models/checkpoints/dlinear_simple_features/metrics.json', 'w') as f: + json.dump(val_metrics, f, indent=2) + + # ไฟๅญ˜้ข„ๅค„็†ๅ™จ + with open('./models/checkpoints/dlinear_simple_features/preprocessor.pkl', 'wb') as f: + pickle.dump(preprocessor, f) + + print("\n" + "="*80) + print("่ฎญ็ปƒๅฎŒๆˆ") + print("="*80) + + print(f"\n๐Ÿ“Š ้ชŒ่ฏ้›†ๆ€ง่ƒฝ:") + print(f" RMSE: {val_metrics.get('rmse', 0)*100:.4f}%") + print(f" MAE: {val_metrics.get('mae', 0)*100:.4f}%") + print(f" ๆ–นๅ‘ๅ‡†็กฎ็Ž‡: {val_metrics.get('directional_accuracy', 0)*100:.2f}%") + + print(f"\n๐Ÿ’ฐ ้ชŒ่ฏ้›†ๅ›žๆต‹:") + print(f" ๆ€ปๆ”ถ็›Š็Ž‡: {val_metrics.get('backtest_total_return', 0)*100:.2f}%") + print(f" ๅคๆ™ฎๆฏ”็Ž‡: {val_metrics.get('backtest_sharpe_ratio', 0):.4f}") + + print(f"\nโœ“ ๆจกๅž‹ไฟๅญ˜่‡ณ: ./models/checkpoints/dlinear_simple_features/") + print(f"โœ“ ็‰นๅพๆ•ฐ้‡: 9 (OHLCV + RSI + MACD)") + print("="*80) + +if __name__ == "__main__": + main() diff --git a/training/__init__.py b/training/__init__.py new file mode 100644 index 0000000..5e787eb --- /dev/null +++ b/training/__init__.py @@ -0,0 +1 @@ +"""Training and evaluation utilities.""" diff --git a/training/config.py b/training/config.py new file mode 100644 index 0000000..dbeb49f --- /dev/null +++ b/training/config.py @@ -0,0 +1,58 @@ +"""Training configuration.""" + +from dataclasses import dataclass +from typing import Literal + + +@dataclass +class TrainingConfig: + """Configuration for model training.""" + + # Training parameters + batch_size: int = 64 + max_epochs: int = 100 + learning_rate: float = 0.001 + weight_decay: float = 1e-5 + + # Early stopping + early_stopping_patience: int = 10 + early_stopping_min_delta: float = 1e-4 + + # Learning rate scheduler + lr_scheduler: Literal['plateau', 'cosine', 'none'] = 'plateau' + lr_patience: int = 5 + lr_factor: float = 0.5 + + # Device + device: str = 'auto' # 'auto', 'mps', 'cuda', or 'cpu' + + # Logging + log_interval: int = 10 # Log every N batches + + # Checkpointing + save_best: bool = True + checkpoint_dir: str = './models/checkpoints' + + def get_device(self) -> str: + """Get the device to use for training. + + Returns: + Device string ('mps', 'cuda', or 'cpu') + """ + import torch + + if self.device != 'auto': + return self.device + + # Auto-detect best available device + if torch.backends.mps.is_available(): + return 'mps' + elif torch.cuda.is_available(): + return 'cuda' + else: + return 'cpu' + + +if __name__ == "__main__": + config = TrainingConfig() + print(f"Using device: {config.get_device()}") diff --git a/training/evaluator.py b/training/evaluator.py new file mode 100644 index 0000000..6a3a5fb --- /dev/null +++ b/training/evaluator.py @@ -0,0 +1,296 @@ +"""Model evaluation metrics and utilities.""" + +from typing import Dict, Literal +import numpy as np +import torch +from sklearn.metrics import ( + accuracy_score, + precision_score, + recall_score, + f1_score, + confusion_matrix, + mean_squared_error, + mean_absolute_error +) + + +class ModelEvaluator: + """Evaluate model performance with task-specific metrics.""" + + def __init__(self, task: Literal['classification', 'regression']): + """Initialize evaluator. + + Args: + task: Task type ('classification' or 'regression') + """ + self.task = task + + def evaluate( + self, + y_true: np.ndarray, + y_pred: np.ndarray, + y_prob: np.ndarray = None + ) -> Dict[str, float]: + """Compute evaluation metrics. + + Args: + y_true: True labels + y_pred: Predicted labels/values + y_prob: Prediction probabilities (for classification) + + Returns: + Dictionary of metrics + """ + if self.task == 'classification': + return self._evaluate_classification(y_true, y_pred, y_prob) + else: + return self._evaluate_regression(y_true, y_pred) + + def _evaluate_classification( + self, + y_true: np.ndarray, + y_pred: np.ndarray, + y_prob: np.ndarray = None + ) -> Dict[str, float]: + """Compute classification metrics. + + Args: + y_true: True labels (0 or 1) + y_pred: Predicted labels (0 or 1) + y_prob: Prediction probabilities + + Returns: + Dictionary of classification metrics + """ + metrics = { + 'accuracy': accuracy_score(y_true, y_pred), + 'precision': precision_score(y_true, y_pred, zero_division=0), + 'recall': recall_score(y_true, y_pred, zero_division=0), + 'f1': f1_score(y_true, y_pred, zero_division=0) + } + + # Confusion matrix + cm = confusion_matrix(y_true, y_pred) + if cm.shape == (2, 2): + tn, fp, fn, tp = cm.ravel() + metrics['true_negatives'] = int(tn) + metrics['false_positives'] = int(fp) + metrics['false_negatives'] = int(fn) + metrics['true_positives'] = int(tp) + + # Specificity + if (tn + fp) > 0: + metrics['specificity'] = tn / (tn + fp) + + # Directional accuracy (if probabilities provided) + if y_prob is not None: + metrics['mean_confidence'] = float(np.mean(y_prob)) + + return metrics + + def _evaluate_regression( + self, + y_true: np.ndarray, + y_pred: np.ndarray + ) -> Dict[str, float]: + """Compute regression metrics. + + Args: + y_true: True values + y_pred: Predicted values + + Returns: + Dictionary of regression metrics + """ + # Basic regression metrics + mse = mean_squared_error(y_true, y_pred) + mae = mean_absolute_error(y_true, y_pred) + rmse = np.sqrt(mse) + + # MAPE (Mean Absolute Percentage Error) + # Avoid division by zero + epsilon = 1e-8 + mape = np.mean(np.abs((y_true - y_pred) / (np.abs(y_true) + epsilon))) * 100 + + # Directional accuracy (sign agreement) + directional_accuracy = np.mean(np.sign(y_true) == np.sign(y_pred)) + + metrics = { + 'mse': float(mse), + 'rmse': float(rmse), + 'mae': float(mae), + 'mape': float(mape), + 'directional_accuracy': float(directional_accuracy) + } + + return metrics + + def backtest_strategy( + self, + y_true: np.ndarray, + y_pred: np.ndarray, + initial_capital: float = 10000.0, + transaction_cost: float = 0.001 + ) -> Dict[str, float]: + """Simple backtesting with long/short strategy. + + Args: + y_true: True returns + y_pred: Predicted labels (classification) or returns (regression) + initial_capital: Starting capital + transaction_cost: Transaction cost per trade (e.g., 0.001 = 0.1%) + + Returns: + Dictionary of backtest metrics + """ + capital = initial_capital + positions = [] + returns_list = [] + + for i in range(len(y_pred)): + if self.task == 'classification': + # Classification: y_predๅทฒ็ปๆ˜ฏ0/1็š„ๆ ‡็ญพ๏ผˆไธๆ˜ฏๆฆ‚็Ž‡๏ผ‰ + # 1 = buy, 0 = sell/short + position = 1 if y_pred[i] == 1 else -1 + else: + # Regression: positive prediction = buy, negative = sell + position = 1 if y_pred[i] > 0 else -1 + + # Calculate return based on position + actual_return = y_true[i] + strategy_return = position * actual_return + + # Apply transaction cost if position changes + if i > 0 and positions[-1] != position: + strategy_return -= transaction_cost + + # Update capital + capital *= (1 + strategy_return) + positions.append(position) + returns_list.append(strategy_return) + + # Calculate metrics + returns_array = np.array(returns_list) + total_return = (capital - initial_capital) / initial_capital + + # Sharpe ratio (annualized, assuming hourly data) + # For hourly data: sqrt(24 * 365) โ‰ˆ 93 + if len(returns_array) > 0 and returns_array.std() > 0: + sharpe_ratio = (returns_array.mean() / returns_array.std()) * np.sqrt(93) + else: + sharpe_ratio = 0.0 + + # Maximum drawdown + cumulative = np.cumprod(1 + returns_array) + running_max = np.maximum.accumulate(cumulative) + drawdown = (cumulative - running_max) / running_max + max_drawdown = float(drawdown.min()) + + # Win rate + win_rate = np.mean(returns_array > 0) + + return { + 'total_return': float(total_return), + 'final_capital': float(capital), + 'sharpe_ratio': float(sharpe_ratio), + 'max_drawdown': float(max_drawdown), + 'win_rate': float(win_rate), + 'num_trades': int(np.sum(np.diff(positions) != 0)) + } + + +def evaluate_model( + model: torch.nn.Module, + dataloader: torch.utils.data.DataLoader, + task: Literal['classification', 'regression'], + device: str = 'cpu' +) -> Dict[str, float]: + """Evaluate a model on a dataset. + + Args: + model: PyTorch model + dataloader: DataLoader with evaluation data + task: Task type + device: Device to run evaluation on + + Returns: + Dictionary of evaluation metrics + """ + model.eval() + model = model.to(device) + + all_preds = [] + all_probs = [] + all_labels = [] + + with torch.no_grad(): + for batch_X, batch_y in dataloader: + batch_X = batch_X.to(device) + batch_y = batch_y.to(device) + + # Forward pass + outputs = model(batch_X).squeeze() + + if task == 'classification': + # ๆณจๆ„๏ผšไฟฎๅคๅŽ็š„ๆจกๅž‹่พ“ๅ‡บlogits๏ผŒ้œ€่ฆๅบ”็”จsigmoidๅพ—ๅˆฐๆฆ‚็Ž‡ + probs = torch.sigmoid(outputs).cpu().numpy() + preds = (probs > 0.5).astype(int) + # ็กฎไฟๆ˜ฏ1็ปดๆ•ฐ็ป„ + if probs.ndim == 0: + probs = np.array([probs]) + if preds.ndim == 0: + preds = np.array([preds]) + all_probs.extend(probs.flatten()) + all_preds.extend(preds.flatten()) + else: + # Regression predictions + preds = outputs.cpu().numpy() + if preds.ndim == 0: + preds = np.array([preds]) + all_preds.extend(preds.flatten()) + + # Labels + labels = batch_y.cpu().numpy() + if labels.ndim == 0: + labels = np.array([labels]) + all_labels.extend(labels.flatten()) + + # Convert to arrays + y_true = np.array(all_labels) + y_pred = np.array(all_preds) + y_prob = np.array(all_probs) if task == 'classification' else None + + # Evaluate + evaluator = ModelEvaluator(task) + metrics = evaluator.evaluate(y_true, y_pred, y_prob) + + # Add backtesting metrics + backtest = evaluator.backtest_strategy(y_true, y_pred) + metrics.update({f'backtest_{k}': v for k, v in backtest.items()}) + + return metrics + + +if __name__ == "__main__": + # Test classification evaluation + y_true = np.array([0, 1, 1, 0, 1, 0, 1, 1, 0, 0]) + y_pred = np.array([0, 1, 1, 0, 0, 1, 1, 1, 0, 1]) + y_prob = np.array([0.3, 0.8, 0.9, 0.2, 0.4, 0.6, 0.7, 0.85, 0.1, 0.55]) + + evaluator = ModelEvaluator('classification') + metrics = evaluator.evaluate(y_true, y_pred, y_prob) + + print("Classification metrics:") + for k, v in metrics.items(): + print(f" {k}: {v}") + + # Test regression evaluation + y_true_reg = np.random.randn(100) * 0.02 + y_pred_reg = y_true_reg + np.random.randn(100) * 0.01 + + evaluator_reg = ModelEvaluator('regression') + metrics_reg = evaluator_reg.evaluate(y_true_reg, y_pred_reg) + + print("\nRegression metrics:") + for k, v in metrics_reg.items(): + print(f" {k}: {v}") diff --git a/training/trainer.py b/training/trainer.py new file mode 100644 index 0000000..0596bbe --- /dev/null +++ b/training/trainer.py @@ -0,0 +1,361 @@ +"""Training orchestration and utilities.""" + +import os +from pathlib import Path +from typing import Optional, Dict +import torch +import torch.nn as nn +from torch.utils.data import DataLoader +from tqdm import tqdm +import json + +from .config import TrainingConfig +from .evaluator import evaluate_model + + +class EarlyStopping: + """Early stopping to stop training when validation loss doesn't improve.""" + + def __init__(self, patience: int = 10, min_delta: float = 1e-4): + """Initialize early stopping. + + Args: + patience: Number of epochs to wait before stopping + min_delta: Minimum change to qualify as improvement + """ + self.patience = patience + self.min_delta = min_delta + self.counter = 0 + self.best_loss = None + self.should_stop = False + + def __call__(self, val_loss: float) -> bool: + """Check if training should stop. + + Args: + val_loss: Current validation loss + + Returns: + True if training should stop + """ + if self.best_loss is None: + self.best_loss = val_loss + elif val_loss > self.best_loss - self.min_delta: + self.counter += 1 + if self.counter >= self.patience: + self.should_stop = True + else: + self.best_loss = val_loss + self.counter = 0 + + return self.should_stop + + +class Trainer: + """Model trainer with support for MPS/CUDA/CPU.""" + + def __init__( + self, + model: nn.Module, + config: TrainingConfig, + task: str = 'classification', + pos_weight: float = None # ๆทปๅŠ ็ฑปๅˆซๆƒ้‡ๅ‚ๆ•ฐ + ): + """Initialize trainer. + + Args: + model: PyTorch model to train + config: Training configuration + task: Task type ('classification' or 'regression') + pos_weight: Positive class weight for imbalanced data + """ + self.model = model + self.config = config + self.task = task + self.pos_weight = pos_weight + + # Set device + self.device = config.get_device() + self.model = self.model.to(self.device) + print(f"Training on device: {self.device}") + + # Loss function (with class weight if provided) + if hasattr(model, 'get_loss_function'): + self.criterion = model.get_loss_function(pos_weight=pos_weight, device=self.device) + else: + if task == 'classification': + if pos_weight is not None: + # ไฝฟ็”จfloat32ไปฅๅ…ผๅฎนMPS + pos_weight_tensor = torch.tensor([pos_weight], dtype=torch.float32).to(self.device) + self.criterion = nn.BCEWithLogitsLoss(pos_weight=pos_weight_tensor) + else: + self.criterion = nn.BCELoss() + else: + self.criterion = nn.MSELoss() + + if pos_weight is not None: + print(f"Using weighted loss - positive class weight: {pos_weight:.2f}") + + # Optimizer + self.optimizer = torch.optim.AdamW( + model.parameters(), + lr=config.learning_rate, + weight_decay=config.weight_decay + ) + + # Learning rate scheduler + if config.lr_scheduler == 'plateau': + self.scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau( + self.optimizer, + mode='min', + factor=config.lr_factor, + patience=config.lr_patience, + verbose=True + ) + elif config.lr_scheduler == 'cosine': + self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( + self.optimizer, + T_max=config.max_epochs + ) + else: + self.scheduler = None + + # Early stopping + self.early_stopping = EarlyStopping( + patience=config.early_stopping_patience, + min_delta=config.early_stopping_min_delta + ) + + # Training history + self.history = { + 'train_loss': [], + 'val_loss': [], + 'learning_rates': [] + } + + # Best model tracking + self.best_val_loss = float('inf') + self.best_model_path = None + + def train_epoch(self, train_loader: DataLoader) -> float: + """Train for one epoch. + + Args: + train_loader: Training data loader + + Returns: + Average training loss + """ + self.model.train() + total_loss = 0.0 + num_batches = 0 + + pbar = tqdm(train_loader, desc='Training') + for batch_X, batch_y in pbar: + batch_X = batch_X.to(self.device) + batch_y = batch_y.to(self.device) + + # Forward pass + self.optimizer.zero_grad() + outputs = self.model(batch_X).squeeze() + + # Handle different output shapes + if self.task == 'classification': + batch_y = batch_y.float() + + loss = self.criterion(outputs, batch_y) + + # Backward pass + loss.backward() + self.optimizer.step() + + # Track loss + total_loss += loss.item() + num_batches += 1 + + # Update progress bar + pbar.set_postfix({'loss': f'{loss.item():.4f}'}) + + return total_loss / num_batches + + def validate(self, val_loader: DataLoader) -> float: + """Validate the model. + + Args: + val_loader: Validation data loader + + Returns: + Average validation loss + """ + self.model.eval() + total_loss = 0.0 + num_batches = 0 + + with torch.no_grad(): + for batch_X, batch_y in val_loader: + batch_X = batch_X.to(self.device) + batch_y = batch_y.to(self.device) + + outputs = self.model(batch_X).squeeze() + + if self.task == 'classification': + batch_y = batch_y.float() + + loss = self.criterion(outputs, batch_y) + + total_loss += loss.item() + num_batches += 1 + + return total_loss / num_batches + + def fit( + self, + train_loader: DataLoader, + val_loader: DataLoader, + save_dir: Optional[str] = None + ) -> Dict: + """Train the model. + + Args: + train_loader: Training data loader + val_loader: Validation data loader + save_dir: Directory to save checkpoints + + Returns: + Training history + """ + if save_dir is None: + save_dir = self.config.checkpoint_dir + + save_dir = Path(save_dir) + save_dir.mkdir(parents=True, exist_ok=True) + + print(f"Starting training for {self.config.max_epochs} epochs...") + print(f"Model parameters: {self.model.count_parameters()}") + + for epoch in range(self.config.max_epochs): + # Train + train_loss = self.train_epoch(train_loader) + + # Validate + val_loss = self.validate(val_loader) + + # Update history + self.history['train_loss'].append(train_loss) + self.history['val_loss'].append(val_loss) + current_lr = self.optimizer.param_groups[0]['lr'] + self.history['learning_rates'].append(current_lr) + + # Print progress + print(f"Epoch {epoch + 1}/{self.config.max_epochs}") + print(f" Train loss: {train_loss:.4f}") + print(f" Val loss: {val_loss:.4f}") + print(f" LR: {current_lr:.6f}") + + # Save best model + if val_loss < self.best_val_loss: + self.best_val_loss = val_loss + if self.config.save_best: + self.best_model_path = save_dir / 'best_model.pt' + self.model.save(str(self.best_model_path)) + print(f" Saved best model (val_loss: {val_loss:.4f})") + + # Learning rate scheduling + if self.scheduler is not None: + if self.config.lr_scheduler == 'plateau': + self.scheduler.step(val_loss) + else: + self.scheduler.step() + + # Early stopping + if self.early_stopping(val_loss): + print(f"Early stopping at epoch {epoch + 1}") + break + + # Save final model + final_model_path = save_dir / 'final_model.pt' + self.model.save(str(final_model_path)) + + # Save training history + history_path = save_dir / 'training_history.json' + with open(history_path, 'w') as f: + json.dump(self.history, f, indent=2) + + print(f"\nTraining completed!") + print(f"Best validation loss: {self.best_val_loss:.4f}") + print(f"Best model saved to: {self.best_model_path}") + + return self.history + + def evaluate(self, test_loader: DataLoader) -> Dict[str, float]: + """Evaluate the model on test data. + + Args: + test_loader: Test data loader + + Returns: + Dictionary of evaluation metrics + """ + # Load best model if available + if self.best_model_path is not None and self.best_model_path.exists(): + print(f"Loading best model from {self.best_model_path}") + checkpoint = torch.load(self.best_model_path, map_location=self.device) + self.model.load_state_dict(checkpoint['model_state_dict']) + + # Evaluate + metrics = evaluate_model(self.model, test_loader, self.task, self.device) + + print("\nTest Metrics:") + for key, value in metrics.items(): + print(f" {key}: {value:.4f}") + + return metrics + + +if __name__ == "__main__": + # Test the trainer + from ..models.dlinear.model import DLinear, DLinearConfig + from ..data.fetcher import BinanceDataFetcher + from ..data.preprocessor import CryptoPreprocessor, split_data + from ..data.dataset import create_dataloaders + + # Fetch data + print("Fetching data...") + fetcher = BinanceDataFetcher() + df = fetcher.fetch_ohlcv('BTC', '1h') + + # Preprocess + print("\nPreprocessing...") + preprocessor = CryptoPreprocessor(lookback=168) + X, y, _ = preprocessor.preprocess_pipeline(df, task='classification') + + # Split + train_data, val_data, test_data = split_data(X, y) + + # Create dataloaders + train_loader, val_loader, test_loader = create_dataloaders( + train_data, val_data, test_data, + batch_size=32 + ) + + # Create model + print("\nCreating model...") + config = DLinearConfig( + input_dim=X.shape[-1], + lookback=168, + task='classification' + ) + model = DLinear(config) + + # Train + train_config = TrainingConfig( + batch_size=32, + max_epochs=5, # Short test + early_stopping_patience=3 + ) + + trainer = Trainer(model, train_config, task='classification') + history = trainer.fit(train_loader, val_loader, save_dir='/tmp/test_training') + + # Evaluate + metrics = trainer.evaluate(test_loader) diff --git a/training_log.txt b/training_log.txt new file mode 100644 index 0000000..cc10234 --- /dev/null +++ b/training_log.txt @@ -0,0 +1,45 @@ +Traceback (most recent call last): + File "/Users/xxz/miniforge3/envs/crypto_pred_312/lib/python3.12/site-packages/pandas/core/indexes/base.py", line 3641, in get_loc + return self._engine.get_loc(casted_key) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "pandas/_libs/index.pyx", line 168, in pandas._libs.index.IndexEngine.get_loc + File "pandas/_libs/index.pyx", line 197, in pandas._libs.index.IndexEngine.get_loc + File "pandas/_libs/hashtable_class_helper.pxi", line 7668, in pandas._libs.hashtable.PyObjectHashTable.get_item + File "pandas/_libs/hashtable_class_helper.pxi", line 7676, in pandas._libs.hashtable.PyObjectHashTable.get_item +KeyError: 'BBU_20_2.0' + +The above exception was the direct cause of the following exception: + +Traceback (most recent call last): + File "/Users/xxz/PycharmProjects/crypto_predictor/train_dlinear_real.py", line 163, in + main() + File "/Users/xxz/PycharmProjects/crypto_predictor/train_dlinear_real.py", line 30, in main + X, y, processed_df = preprocessor.preprocess_pipeline(df, task='classification', fit=True) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/xxz/PycharmProjects/crypto_predictor/data/preprocessor.py", line 225, in preprocess_pipeline + df = self.add_technical_indicators(df) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/xxz/PycharmProjects/crypto_predictor/data/preprocessor.py", line 58, in add_technical_indicators + df['bb_upper'] = bbands['BBU_20_2.0'] + ~~~~~~^^^^^^^^^^^^^^ + File "/Users/xxz/miniforge3/envs/crypto_pred_312/lib/python3.12/site-packages/pandas/core/frame.py", line 4378, in __getitem__ + indexer = self.columns.get_loc(key) + ^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/xxz/miniforge3/envs/crypto_pred_312/lib/python3.12/site-packages/pandas/core/indexes/base.py", line 3648, in get_loc + raise KeyError(key) from err +KeyError: 'BBU_20_2.0' + +ERROR conda.cli.main_run:execute(127): `conda run python train_dlinear_real.py` failed. (See above for error) +================================================================================ +DLinearๆจกๅž‹่ฎญ็ปƒ - ็œŸๅฎžBinanceๆ•ฐๆฎ +================================================================================ + +[1/7] ไปŽBinance่Žทๅ–BTC 1h็œŸๅฎžๆ•ฐๆฎ... +โœ“ ไฝฟ็”จSOCKS5ไปฃ็†: socks5://127.0.0.1:7890 +โœ“ ๅทฒๆˆๅŠŸ่ฟžๆŽฅๅˆฐBinance API +ไปŽ็ผ“ๅญ˜ๅŠ ่ฝฝๆ•ฐๆฎ๏ผšdata/cache/BTC_1h_1y_now.csv +โœ“ ๅทฒ่Žทๅ– 8760 ่กŒ็œŸๅฎžๆ•ฐๆฎ +โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš2025-01-28 15:00:00 ่‡ณ 2026-01-28 14:00:00 + +[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๆŠ€ๆœฏๆŒ‡ๆ ‡ + ็‰นๅพๅทฅ็จ‹๏ผ‰... + diff --git a/training_log_new.txt b/training_log_new.txt new file mode 100644 index 0000000..72e18ce --- /dev/null +++ b/training_log_new.txt @@ -0,0 +1,1349 @@ +/Users/xxz/miniforge3/envs/crypto_pred_312/lib/python3.12/site-packages/torch/optim/lr_scheduler.py:62: UserWarning: The verbose parameter is deprecated. Please use get_last_lr() to access the learning rate. + warnings.warn( + +Training: 0%| | 0/94 [00:00 + main() + File "/Users/xxz/PycharmProjects/crypto_predictor/train_dlinear_real.py", line 80, in main + metrics = trainer.evaluate(test_loader) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/xxz/PycharmProjects/crypto_predictor/training/trainer.py", line 289, in evaluate + metrics = evaluate_model(self.model, test_loader, self.task, self.device) + ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + File "/Users/xxz/PycharmProjects/crypto_predictor/training/evaluator.py", line 248, in evaluate_model + all_preds.extend(preds) +TypeError: 'numpy.int64' object is not iterable + +ERROR conda.cli.main_run:execute(127): `conda run python train_dlinear_real.py` failed. (See above for error) +================================================================================ +DLinearๆจกๅž‹่ฎญ็ปƒ - ็œŸๅฎžBinanceๆ•ฐๆฎ +================================================================================ + +[1/7] ไปŽBinance่Žทๅ–BTC 1h็œŸๅฎžๆ•ฐๆฎ... +โœ“ ไฝฟ็”จSOCKS5ไปฃ็†: socks5://127.0.0.1:7890 +โœ“ ๅทฒๆˆๅŠŸ่ฟžๆŽฅๅˆฐBinance API +ไปŽ็ผ“ๅญ˜ๅŠ ่ฝฝๆ•ฐๆฎ๏ผšdata/cache/BTC_1h_1y_now.csv +โœ“ ๅทฒ่Žทๅ– 8760 ่กŒ็œŸๅฎžๆ•ฐๆฎ +โœ“ ๆ—ถ้—ด่Œƒๅ›ด๏ผš2025-01-28 15:00:00 ่‡ณ 2026-01-28 14:00:00 + +[2/7] ๆ•ฐๆฎ้ข„ๅค„็†๏ผˆๆŠ€ๆœฏๆŒ‡ๆ ‡ + ็‰นๅพๅทฅ็จ‹๏ผ‰... +Created 8535 sequences with shape (8535, 168, 26) +โœ“ ๅทฒๅˆ›ๅปบๅบๅˆ—๏ผšXๅฝข็Šถ = (8535, 168, 26), yๅฝข็Šถ = (8535,) +โœ“ ็‰นๅพๆ•ฐ้‡๏ผš26 +โœ“ ๆ ‡็ญพๅˆ†ๅธƒ๏ผšไธ‹่ทŒ(0) = 6970, ไธŠๆถจ(1) = 1565 + +[3/7] ๅˆ’ๅˆ†่ฎญ็ปƒ/้ชŒ่ฏ/ๆต‹่ฏ•้›† (70/15/15)... +Train: 5974 samples +Val: 1280 samples +Test: 1281 samples + +[4/7] ๅˆ›ๅปบPyTorchๆ•ฐๆฎๅŠ ่ฝฝๅ™จ... +โœ“ ่ฎญ็ปƒๆ‰นๆฌก๏ผš94 +โœ“ ้ชŒ่ฏๆ‰นๆฌก๏ผš20 +โœ“ ๆต‹่ฏ•ๆ‰นๆฌก๏ผš21 + +[5/7] ๅˆ›ๅปบDLinearๆจกๅž‹... +โœ“ ๆจกๅž‹ๅทฒๅˆ›ๅปบ๏ผŒๅฏ่ฎญ็ปƒๅ‚ๆ•ฐ๏ผš14,675 ไธช + +[6/7] ๅผ€ๅง‹่ฎญ็ปƒๆจกๅž‹... +Training on device: mps +Starting training for 50 epochs... +Model parameters: 14675 +Epoch 1/50 + Train loss: 0.4835 + Val loss: 0.4939 + LR: 0.001000 + Saved best model (val_loss: 0.4939) +Epoch 2/50 + Train loss: 0.4628 + Val loss: 0.4833 + LR: 0.001000 + Saved best model (val_loss: 0.4833) +Epoch 3/50 + Train loss: 0.4444 + Val loss: 0.5080 + LR: 0.001000 +Epoch 4/50 + Train loss: 0.4312 + Val loss: 0.4956 + LR: 0.001000 +Epoch 5/50 + Train loss: 0.4169 + Val loss: 0.5220 + LR: 0.001000 +Epoch 6/50 + Train loss: 0.4070 + Val loss: 0.5491 + LR: 0.001000 +Epoch 7/50 + Train loss: 0.3995 + Val loss: 0.5842 + LR: 0.001000 +Epoch 8/50 + Train loss: 0.3922 + Val loss: 0.5482 + LR: 0.001000 +Epoch 9/50 + Train loss: 0.3773 + Val loss: 0.5535 + LR: 0.000500 +Epoch 10/50 + Train loss: 0.3690 + Val loss: 0.5738 + LR: 0.000500 +Epoch 11/50 + Train loss: 0.3653 + Val loss: 0.6210 + LR: 0.000500 +Epoch 12/50 + Train loss: 0.3603 + Val loss: 0.5912 + LR: 0.000500 +Early stopping at epoch 12 + +Training completed! +Best validation loss: 0.4833 +Best model saved to: models/checkpoints/dlinear_btc_1h_real/best_model.pt + +[7/7] ๅœจๆต‹่ฏ•้›†ไธŠ่ฏ„ไผฐๆจกๅž‹... +Loading best model from models/checkpoints/dlinear_btc_1h_real/best_model.pt +