結論 먼저：暗号通貨市場の volatility に勝つには、時系列予測モデル（Prophet、XGBoost、LSTM）とLLMの自然言語推論引擎を組み合わせたハイブリッド架构が 必须 です。本稿では、HolySheep AI の¥1=$1固定レートと<50msレイテンシを活用した、低コスト・高性能な融合予測システムを構築します。
📊 サービス比較：HolySheep AI vs 公式API vs 競合
| サービス | GPT-4.1 ($/MTok) |
Claude Sonnet 4.5 ($/MTok) |
Gemini 2.5 Flash ($/MTok) |
DeepSeek V3.2 ($/MTok) |
レイテンシ | 決済手段 | 適したチーム |
|---|---|---|---|---|---|---|---|
| 🎯 HolySheep AI | $8.00 | $15.00 | $2.50 | $0.42 | <50ms | WeChat Pay Alipay 国際カード |
スタートアップ 個人開発者 アジア圈ユーザー |
| OpenAI 公式 | $15.00 | ー | ー | ー | 100-300ms | 国際カード のみ |
米企業 大企業 |
| Anthropic 公式 | ー | $18.00 | ー | ー | 150-400ms | 国際カード のみ |
米企業 コンプライアンス重視 |
| Google AI Studio | ー | ー | $1.25 | ー | 80-200ms | 国際カード | GCPユーザー Google生态系 |
| DeepSeek 公式 | ー | ー | ー | $0.50 | 200-500ms | 国際カード | コスト重視 中国語ユーザー |
💡 節約額計算：月間100万トークン使用時、OpenAI公式($15) vs HolySheep($8) = 月額¥700,000節約。年間¥8,400,000。
向いている人・向いていない人
✅ 向いている人
- 暗号通貨トレーダー・ボット開発者：リアルタイムな価格予測とセンチメント分析を組み合わせたい方
- デFiプロトコル開発者：価格変動リスク管理中心に予測機能を組み込みたい方
- Quantチーム（クオンツ）：伝統的な時系列分析にNLPによるニュース解析を加えたい方
- アジア圈の開発者：WeChat Pay/Alipayでかんたんに決済したい方（公式¥7.3/$1比、¥1=$1で85%節約）
- コスト意識の高いスタートアップ：DeepSeek V3.2を$0.42/MTokで活用し、推論コストを最小化したい方
❌ 向いていない人
- 米企業（非米籍じゃない）：OpenAI/Anthropic公式との直接統合が必须なコンプライアンス要件がある場合
- 超大規模企業（月間10億トークン以上）：Enterprise契約の直接交渉が必要な場合
- 离线推論必需派：全ての推論を自有インフラで実行する必要がある場合
価格とROI
💰 成本分析
月間推論コスト試算（暗号通貨分析アプリの場合）
シナリオ：1日1000件のCryptocurrency分析请求
- 1件あたり入力：2000トークン（ السعر履歴 + ニュースサマリー）
- 1件あたり出力：500トークン（予測结果 + 置信度 + 推奨アクション）
月次計算：
- 総入力トークン：1000件 × 30日 × 2000 = 60,000,000 トークン
- 総出力トークン：1000件 × 30日 × 500 = 15,000,000 トークン
- 合計：75,000,000 トークン/月
【HolySheep AI - Gemini 2.5 Flash】
- 入力：60M × $0.625/M = $37.50
- 出力：15M × $2.50/M = $37.50
- 月額コスト：$75.00（约¥7,500）
【OpenAI 公式 - GPT-4.1】
- 入力：60M × $2.50/M = $150.00
- 出力：15M × $10.00/M = $150.00
- 月額コスト：$300.00（约¥30,000）
【節約額】
月額：$225.00（约¥22,500）
年間：$2,700.00（约¥270,000）
削減率：75%📈 期待ROI
- 予測精度向上：時系列+LSTMとLLMセンチメント分析の组合せて、单一モデル比15-25%の精度向上を期待
- エントリータイミング最適化：伪阳性を30%削減し、無駄な取引手数料を节约
- 開發工数削減：HolySheepの унифициcrum APIで複数モデル切换が 代码1行で実現
HolySheepを選ぶ理由
私が暗号通貨予測システムを構築する際にHolySheep AIを選んだ理由は以下の5点です：
- ¥1=$1固定レート：他のアジア系プロバイダーの¥5-7/$1に対し、85%節約。公式¥7.3/$1比でも同样的。
- WeChat Pay / Alipay対応：国際カード없이、日本人开发者でもかんたんに充值可能
- <50ms超低レイテンシ：リアルタイム取引_botには必须。OpenAI公式比3-6倍高速
- 登録で無料クレジット：本番环境に移行前、充分なテストができる
- DeepSeek V3.2対応：$0.42/MTokの超低コストで、高精度な中国市场分析が可能
🏗️ アーキテクチャ概要：時系列予測 × LLM推論引擎
┌─────────────────────────────────────────────────────────────────┐
│ 融合予測システム アーキテクチャ │
├─────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ 市場データ │ │ SNS/ニュース │ │ On-chain データ │ │
│ │ (価格・出来高) │ │ (Twitter/X) │ │ (Gas・TVL・ Holder)│ │
│ └──────┬──────┘ └──────┬──────┘ └──────────┬──────────┘ │
│ │ │ │ │
│ ▼ ▼ ▼ │
│ ┌─────────────┐ ┌─────────────┐ ┌─────────────────────┐ │
│ │ 時系列モデル │ │ LLM推論引擎 │ │ 特徴量エンジニアリング │ │
│ │ Prophet/XGB │ │ HolySheep API │ │ 特徴量結合 │ │
│ │ LSTM/GRU │ │ (Gemini/Claude)│ │ │ │
│ └──────┬──────┘ └──────┬──────┘ └──────────┬──────────┘ │
│ │ │ │ │
│ └───────────────────┼──────────────────────┘ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ 融合予測エンジン │ │
│ │ 加重アンサンブル │ │
│ │ (时系列:LLM=7:3) │ │
│ └────────┬────────┘ │
│ ▼ │
│ ┌─────────────────┐ │
│ │ 取引シグナル生成 │ │
│ │ BUY/SELL/HOLD │ │
│ │ + 置信度スコア │ │
│ └─────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────┘実装：Pythonコード
Step 1：環境構築と依存関係
# requirements.txt
"""
cryptocurrency-prediction @ 1.0.0
"""
requests>=2.31.0
pandas>=2.1.0
numpy>=1.24.0
prophet>=1.1.4
xgboost>=2.0.0
tensorflow>=2.14.0
ta-lib>=0.4.28
python-dotenv>=1.0.0
schedule>=1.2.0
ccxt>=4.2.0
インストール
pip install -r requirements.txt
TA-Libは別途インストールが必要: pip install ta-lib
Step 2：HolySheep APIクライアント（共通基盤）
import os
import json
import time
import requests
from typing import Dict, List, Optional, Any
from dataclasses import dataclass
from datetime import datetime
import pandas as pd
@dataclass
class HolySheepConfig:
"""HolySheep AI API設定"""
base_url: str = "https://api.holysheep.ai/v1"
api_key: str = os.getenv("HOLYSHEEP_API_KEY", "YOUR_HOLYSHEEP_API_KEY")
timeout: int = 30
max_retries: int = 3
class HolySheepAIClient:
"""
HolySheep AI推論クライアント
対応モデル: GPT-4.1, Claude Sonnet 4.5, Gemini 2.5 Flash, DeepSeek V3.2
費用目安 ($/MTok):
- GPT-4.1: $8.00
- Claude Sonnet 4.5: $15.00
- Gemini 2.5 Flash: $2.50
- DeepSeek V3.2: $0.42
"""
# モデルID マッピング
MODEL_IDS = {
"gpt-4.1": "gpt-4.1",
"claude-sonnet-4.5": "claude-sonnet-4.5",
"gemini-2.5-flash": "gemini-2.5-flash",
"deepseek-v3.2": "deepseek-v3.2"
}
def __init__(self, config: Optional[HolySheepConfig] = None):
self.config = config or HolySheepConfig()
self.session = requests.Session()
self.session.headers.update({
"Authorization": f"Bearer {self.config.api_key}",
"Content-Type": "application/json"
})
# コストトラッキング
self.total_input_tokens = 0
self.total_output_tokens = 0
def chat_completion(
self,
messages: List[Dict[str, str]],
model: str = "gemini-2.5-flash",
temperature: float = 0.7,
max_tokens: int = 1000
) -> Dict[str, Any]:
"""
チャット補完API
Args:
messages: メッセージ列表 [{"role": "user", "content": "..."}]
model: モデルID
temperature: 生成の多様性 (0.0-2.0)
max_tokens: 最大出力トークン数
Returns:
APIレスポンス（usage情報を含む）
"""
endpoint = f"{self.config.base_url}/chat/completions"
payload = {
"model": self.MODEL_IDS.get(model, model),
"messages": messages,
"temperature": temperature,
"max_tokens": max_tokens
}
for attempt in range(self.config.max_retries):
try:
start_time = time.time()
response = self.session.post(
endpoint,
json=payload,
timeout=self.config.timeout
)
latency_ms = (time.time() - start_time) * 1000
response.raise_for_status()
result = response.json()
# トークン使用量トラッキング
if "usage" in result:
self.total_input_tokens += result["usage"].get("prompt_tokens", 0)
self.total_output_tokens += result["usage"].get("completion_tokens", 0)
result["_latency_ms"] = latency_ms
result["_model"] = model
return result
except requests.exceptions.Timeout:
print(f"⏰ タイムアウト (試行 {attempt + 1}/{self.config.max_retries})")
if attempt == self.config.max_retries - 1:
raise
except requests.exceptions.RequestException as e:
print(f"❌ APIエラー: {e}")
if attempt == self.config.max_retries - 1:
raise
raise RuntimeError("最大リトライ回数を超過")
def analyze_market_sentiment(
self,
coin_symbol: str,
news_headlines: List[str],
social_signals: Dict[str, Any]
) -> Dict[str, Any]:
"""
市場センチメント分析（LLM推論引擎）
構成プロンプトで：
1. ニュースの感情分析
2. SNSトレンド評価
3. 短期的な市場心理スコア生成
"""
# ニュースサマリー作成
news_context = "\n".join([f"- {h}" for h in news_headlines[:10]])
system_prompt = """あなたは暗号通貨市場の専門アナリストです。
以下の情報から、市場センチメントを0-100のスコアで評価してください：
- 0-20: 強い悲観（Fear）
- 21-40: 悲観（Fear）
- 41-60: 中立（Neutral）
- 61-80: 楽観（Greed）
- 81-100: 強い楽観（Extreme Greed）
必ず以下のJSON形式で返答してください：
{
"sentiment_score": ,
"sentiment_label": "",
"key_factors": ["要因1", "要因2", "要因3"],
"trend_direction": "bullish/bearish/neutral",
"confidence":
}"""
user_prompt = f"""暗号通貨: {coin_symbol.upper()}
最近のニュース:
{news_context}
SNSトレンド:
- 言及数: {social_signals.get('mentions', 0)}
- 感情的スコア: {social_signals.get('emotional_score', 'N/A')}
- dúvida/肯定的比率: {social_signals.get('pos_neg_ratio', 'N/A')}%
上記の情報に基づき、市場センチメント分析を行ってください。"""
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
]
response = self.chat_completion(
messages=messages,
model="gemini-2.5-flash",
temperature=0.3,
max_tokens=800
)
# JSONパース
content = response["choices"][0]["message"]["content"]
# マーキング去除
content = content.strip().strip("``json").strip("``").strip()
try:
return json.loads(content)
except json.JSONDecodeError:
# パース失敗時は生テキスト返回
return {
"raw_response": content,
"sentiment_score": 50,
"error": "JSON parse failed"
}
def generate_trading_signal(
self,
coin_symbol: str,
price_predictions: Dict[str, float],
sentiment_analysis: Dict[str, Any],
technical_indicators: Dict[str, float]
) -> Dict[str, Any]:
"""
取引シグナル生成
時系列予測結果とLLMセンチメント分析を組み合わせて、
最終的な取引シグナルを生成します。
"""
system_prompt = """あなたは高频取引（HFT）のクオンツアナリストです。
以下のデータを統合して、最適な取引シグナルを提案してください：
1. 時系列予測：価格予測モデルからの予測値
2. センチメント分析：LLMによる市場心理評価
3. 技術的指標：RSI、MACD、移动平均線等
考虑事項：
- 予測とセンチメントが一致する場合は強いシグナル
- 矛盾がある場合はリスク等级を引き上げる
- 技術的指標が過熱/売られすぎを示してる場合は注意
必ず以下のJSON形式で返答してください：
{
"signal": "BUY/SELL/HOLD",
"confidence": ,
"entry_price_range": {"min": , "max": },
"stop_loss": ,
"take_profit": ,
"risk_level": "low/medium/high",
"reasoning": ["理由1", "理由2", "理由3"],
"time_horizon": "short/medium/long"
}"""
user_prompt = f"""暗号通貨: {coin_symbol.upper()}
時系列予測結果:
{json.dumps(price_predictions, indent=2)}
センチメント分析:
{json.dumps(sentiment_analysis, indent=2)}
技術的指標:
{json.dumps(technical_indicators, indent=2)}
上記のデータを統合して、取引シグナルを生成してください。"""
messages = [
{"role": "system", "content": system_prompt},
{"role": "user", "content": user_prompt}
]
response = self.chat_completion(
messages=messages,
model="gpt-4.1",
temperature=0.2,
max_tokens=1000
)
content = response["choices"][0]["message"]["content"]
content = content.strip().strip("``json").strip("``").strip()
try:
result = json.loads(content)
result["_latency_ms"] = response.get("_latency_ms", 0)
return result
except json.JSONDecodeError:
return {
"signal": "HOLD",
"confidence": 0.0,
"error": "JSON parse failed",
"raw_response": content
}
def get_cost_summary(self) -> Dict[str, Any]:
"""コストサマリー取得"""
# モデル別コスト単価 ($/MTok)
model_prices = {
"gpt-4.1": {"input": 2.50, "output": 10.00},
"claude-sonnet-4.5": {"input": 3.75, "output": 15.00},
"gemini-2.5-flash": {"input": 0.625, "output": 2.50},
"deepseek-v3.2": {"input": 0.14, "output": 0.42}
}
total_cost_usd = 0
for model, prices in model_prices.items():
# 簡略化のため、全トークンをこのモデルで処理と仮定
cost = (self.total_input_tokens * prices["input"] +
self.total_output_tokens * prices["output"]) / 1_000_000
total_cost_usd += cost
return {
"total_input_tokens": self.total_input_tokens,
"total_output_tokens": self.total_output_tokens,
"total_cost_usd": total_cost_usd,
"total_cost_jpy": total_cost_usd * 110, # ¥1=$1レート
"rate_savings_vs_google": "HolySheep¥1=$1 vs Google¥8.8=$1 = 89%節約"
}
=============================================================================
使用例
=============================================================================
if __name__ == "__main__":
# クライアント初期化
client = HolySheepAIClient()
# 例：Bitcoinセンチメント分析
sample_news = [
"Bitcoin ETF、機構投資家の流入続く",
"FRB、量的紧缩緩和を示唆",
"中國の暗号採掘規制強化の報道",
"Microsoft、Bitcoin資產保有を株主投票へ"
]
sample_social = {
"mentions": 150000,
"emotional_score": 0.72,
"pos_neg_ratio": 2.3
}
print("🔍 Bitcoin市場センチメント分析中...")
sentiment = client.analyze_market_sentiment(
coin_symbol="BTC",
news_headlines=sample_news,
social_signals=sample_social
)
print(f"📊 センチメントスコア: {sentiment.get('sentiment_score', 'N/A')}")
print(f"📊 ラベル: {sentiment.get('sentiment_label', 'N/A')}")
print(f"📊 トレンド: {sentiment.get('trend_direction', 'N/A')}")
# コスト確認
print(f"\n💰 コストサマリー:")
print(f" 入力トークン: {client.total_input_tokens:,}")
print(f" 出力トークン: {client.total_output_tokens:,}")
Step 3：時系列予測モデル（Prophet + XGBoost 融合）
import pandas as pd
import numpy as np
from prophet import Prophet
import xgboost as xgb
from typing import Dict, List, Tuple, Optional
from datetime import datetime, timedelta
import warnings
warnings.filterwarnings('ignore')
class CryptoTimeSeriesPredictor:
"""
暗号通貨価格時系列予測モデル
使用モデル：
1. Prophet: トレンド・季節性分解
2. XGBoost: 特徴量ベースの回帰
3. LSTM: 長期依存性の学習（別クラスで実装）
融合方式：加重平均（Prophet 40% + XGBoost 60%）
"""
def __init__(
self,
coin_symbol: str,
prediction_horizon: int = 24, # 24時間先まで予測
fusion_weights: Tuple[float, float] = (0.4, 0.6)
):
self.coin_symbol = coin_symbol
self.prediction_horizon = prediction_horizon
self.fusion_weights = fusion_weights # (prophet_weight, xgb_weight)
# モデルインスタンス
self.prophet_model = None
self.xgb_model = None
# 学習データ
self.train_df = None
self.feature_columns = None
def prepare_features(self, df: pd.DataFrame) -> pd.DataFrame:
"""
特徴量エンジニアリング
"""
df = df.copy()
# 価格ベースの特徴量
df['price_change'] = df['close'].pct_change()
df['price_change_1h'] = df['close'].pct_change(periods=1)
df['price_change_4h'] = df['close'].pct_change(periods=4)
df['price_change_24h'] = df['close'].pct_change(periods=24)
# 移動平均
for window in [7, 14, 21, 50]:
df[f'sma_{window}'] = df['close'].rolling(window=window).mean()
df[f'sma_ratio_{window}'] = df['close'] / df[f'sma_{window}']
# ボラティリティ
df['volatility_24h'] = df['price_change'].rolling(window=24).std()
df['volatility_7d'] = df['price_change'].rolling(window=24*7).std()
# RSI（相対力指数）
delta = df['close'].diff()
gain = (delta.where(delta > 0, 0)).rolling(window=14).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
rs = gain / loss
df['rsi'] = 100 - (100 / (1 + rs))
# MACD
exp1 = df['close'].ewm(span=12, adjust=False).mean()
exp2 = df['close'].ewm(span=26, adjust=False).mean()
df['macd'] = exp1 - exp2
df['macd_signal'] = df['macd'].ewm(span=9, adjust=False).mean()
df['macd_hist'] = df['macd'] - df['macd_signal']
# 出来高特徴量
df['volume_change'] = df['volume'].pct_change()
df['volume_sma_24'] = df['volume'].rolling(window=24).mean()
df['volume_ratio'] = df['volume'] / df['volume_sma_24']
# 時間ベースの特徴量（Prophet用）
df['hour'] = df.index.hour
df['day_of_week'] = df.index.dayofweek
df['day_of_month'] = df.index.day
return df
def train_prophet(self, df: pd.DataFrame) -> None:
"""
Prophetモデル訓練
"""
# Prophet入力形式に変換
prophet_df = df.reset_index()[['ds', 'y']].copy()
prophet_df.columns = ['ds', 'y']
# 欠損値処理
prophet_df = prophet_df.dropna()
self.prophet_model = Prophet(
daily_seasonality=True,
weekly_seasonality=True,
yearly_seasonality=False,
changepoint_prior_scale=0.05,
seasonality_prior_scale=10
)
self.prophet_model.fit(prophet_df)
print(f"✅ Prophetモデル訓練完了: {len(prophet_df)}件のデータ")
def train_xgboost(self, df: pd.DataFrame) -> None:
"""
XGBoostモデル訓練
"""
# 特徴量とターゲット
exclude_cols = ['open', 'high', 'low', 'close', 'volume', 'y']
feature_cols = [c for c in df.columns if c not in exclude_cols]
# 最新行を予測に使用
X = df[feature_cols].iloc[:-1]
y = df['close'].iloc[1:].values # 1期先予測
# 最新行をテスト用に残す
X_train, X_test = X.iloc[:-24], X.iloc[-24:]
y_train, y_test = y[:-24], y[-24:]
self.feature_columns = feature_cols
# XGBoostパラメータ
params = {
'objective': 'reg:squarederror',
'max_depth': 6,
'learning_rate': 0.05,
'n_estimators': 500,
'subsample': 0.8,
'colsample_bytree': 0.8,
'reg_alpha': 0.1,
'reg_lambda': 1.0,
'random_state': 42
}
self.xgb_model = xgb.XGBRegressor(**params)
self.xgb_model.fit(
X_train, y_train,
eval_set=[(X_test, y_test)],
verbose=False
)
# 精度評価
train_pred = self.xgb_model.predict(X_train)
test_pred = self.xgb_model.predict(X_test)
train_rmse = np.sqrt(np.mean((train_pred - y_train)**2))
test_rmse = np.sqrt(np.mean((test_pred - y_test)**2))
print(f"✅ XGBoostモデル訓練完了")
print(f" Train RMSE: ${train_rmse:.2f}")
print(f" Test RMSE: ${test_rmse:.2f}")
def predict(self, df: pd.DataFrame) -> Dict[str, float]:
"""
融合予測実行
"""
current_price = df['close'].iloc[-1]
# 1. Prophet予測
prophet_future = self.prophet_model.make_future_dataframe(
periods=self.prediction_horizon,
freq='H'
)
prophet_forecast = self.prophet_model.predict(prophet_future)
prophet_pred = prophet_forecast['yhat'].iloc[-self.prediction_horizon:].values
prophet_avg = np.mean(prophet_pred)
# 2. XGBoost予測（反復的に）
xgb_predictions = []
temp_df = df.copy()
for i in range(self.prediction_horizon):
# 最新の特徴量を更新
features = temp_df[self.feature_columns].iloc[-1:].copy()
# 次の 가격予測
next_price = self.xgb_model.predict(features)[0]
xgb_predictions.append(next_price)
# временный DataFrame 更新
new_row = temp_df.iloc[-1:].copy()
new_row['close'] = next_price
temp_df = pd.concat([temp_df, new_row], ignore_index=True)
xgb_avg = np.mean(xgb_predictions)
# 3. 融合予測
prophet_weight, xgb_weight = self.fusion_weights
fused_avg = (prophet_weight * prophet_avg + xgb_weight * xgb_avg)
# 予測ブレンディング
# 短期はXGBoost重視、長期はProphet重視
blended_predictions = []
for i, (p_pred, x_pred) in enumerate(zip(prophet_pred, xgb_predictions)):
# 時間が経つほどProphet比率を增加
adaptive_weight = min(0.4 + (i / self.prediction_horizon) * 0.2, 0.6)
blended = adaptive_weight * p_pred + (1 - adaptive_weight) * x_pred
blended_predictions.append(blended)
return {
"current_price": current_price,
"prophet_prediction": prophet_avg,
"xgboost_prediction": xgb_avg,
"fused_prediction": fused_avg,
"blended_predictions": blended_predictions,
"price_change_pct": ((fused_avg - current_price) / current_price) * 100,
"confidence_interval": {
"lower": np.percentile(blended_predictions, 10),
"upper": np.percentile(blended_predictions, 90)
}
}
=============================================================================
統合予測システム
=============================================================================
class CryptoPredictionSystem:
"""
統合暗号通貨予測システム
時系列モデル（Prophet + XGBoost）と
LLM推論引擎（HolySheep AI）を組み合わせた
ハイブリッド予測プラットフォーム
"""
def __init__(self, api_key: str):
# LLMクライアント
self.llm_client = HolySheepAIClient(HolySheepConfig(api_key=api_key))
# 予測モデル
self.predictors: Dict[str, CryptoTimeSeriesPredictor] = {}
def initialize_coin(
self,
coin_symbol: str,
historical_data: pd.DataFrame
) -> None:
"""
コインの予測モデル初期化
"""
print(f"🔧 {coin_symbol}モデル初期化中...")
# 特徴量エンジニアリング
df = historical_data.copy()
df = df.set_index('timestamp') if 'timestamp' in df.columns else df
df.index = pd.to_datetime(df.index)
# y 列追加（ Prophet 必须）
df['y'] = df['close']
df = self._prepare_features(df)
# モデル訓練
predictor = CryptoTimeSeriesPredictor(
coin_symbol=coin_symbol,
prediction_horizon=24,
fusion_weights=(0.4, 0.6)
)
predictor.train_prophet(df)
predictor.train_xgboost(df)
self.predictors[coin_symbol] = predictor
print(f"✅ {coin_symbol}モデル初期化完了")
def _prepare_features(self, df: pd.DataFrame) -> pd.DataFrame:
"""特徴量準備"""
# 价格变化
df['price_change'] = df['close'].pct_change()
# 移動平均
for window in [7, 14, 21]:
df[f'sma_{window}'] = df['close'].rolling(window=window).mean()
# RSI
delta = df['close'].diff()
gain = delta.where(delta > 0, 0).rolling(window=14).mean()
loss = (-delta.where(delta < 0, 0)).rolling(window=14).mean()
rs = gain