name: Quantitative Backtesting Laboratory slug: security-quant-backtest description: AI-powered quantitative backtesting laboratory for China A-share — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quantitative analysts, algorithmic traders, and Python-based backtesting. Keywords: quantitative backtesting, algorithmic trading, strategy research, Python backtest, China A-share, performance analysis, 量化回測, 演算法交易, 策略研究, Python回測, 績效歸因, 量化策略, 蒙特卡洛, 趨勢跟蹤, 均值迴歸, 統計套利. version: "3.0.1"

Quantitative Backtesting Laboratory / 量化回測實驗室

English: AI-powered quantitative backtesting laboratory — covers strategy design, historical backtesting, performance attribution, walk-forward analysis, and Monte Carlo simulation. Built for quant analysts and algorithmic traders.

中文: 量化回測實驗室——覆蓋策略設計、歷史回測、績效歸因、前向分析、蒙特卡洛模擬。適用：量化分析師、演算法交易者、Python回測開發。

證券監管最新動態 [2026-05-25更新]

資料截止: 2026-05-25 | 來源：證監會、NFRA、中證協、安永Q1分析 宣告: 以上動態供參考，具體以官方最新發布為準

Industry Pain Points / 行業痛點

Trigger Keywords / 觸發關鍵詞

English Triggers: quantitative backtesting, algorithmic trading, strategy research, Python backtest, performance analysis, Monte Carlo, walk-forward analysis, A-share strategy

中文觸發詞（優先）： 量化回測 / 演算法交易 / 策略研究 / Python回測 / 績效歸因 / 蒙特卡洛 / 前向分析 / 趨勢跟蹤 / 均值迴歸 / 配對交易 / 雙均線 / 海龜策略 / RSI策略 / 布林帶策略 / 策略最佳化 / 引數尋優 / 機器學習選股 / Alpha因子 / 多因子策略

Core Capabilities / 核心能力

1. Backtesting Engine / 回測引擎

import pandas as pd
import numpy as np
from datetime import datetime
import warnings
warnings.filterwarnings('ignore')

class BacktestEngine:
    """量化回測引擎"""

    def __init__(self, initial_capital: float = 1000000,
                 commission_rate: float = 0.0003,
                 stamp_tax: float = 0.001,
                 slippage: float = 0.001):
        """
        Args:
            initial_capital: 初始資金
            commission_rate: 佣金費率（含規費）
            stamp_tax: 印花稅率（僅賣出）
            slippage: 滑點（百分比）
        """
        self.initial_capital = initial_capital
        self.commission_rate = commission_rate
        self.stamp_tax = stamp_tax
        self.slippage = slippage

        # 持倉狀態
        self.cash = initial_capital
        self.position = {}  # {stock_code: shares}
        self.equity_curve = []
        self.trades = []

    def run(self, data: pd.DataFrame, signals: pd.DataFrame,
            strategy_name: str = "Strategy") -> dict:
        """
        執行回測
        Args:
            data: 價格資料（含收盤價、開盤價、最高、最低價）
            signals: 交易訊號（1=買入, -1=賣出, 0=持有）
            strategy_name: 策略名稱
        """
        results = []

        for date in data.index:
            price = data.loc[date, "close"]

            # 獲取當日訊號
            if date in signals.index:
                signal = signals.loc[date]
                if signal == 1:  # 買入訊號
                    self._buy(date, price, self.cash * 0.95)  # 保留5%現金
                elif signal == -1:  # 賣出訊號
                    self._sell(date, price)

            # 更新權益
            portfolio_value = self._calculate_portfolio_value(price)
            self.equity_curve.append({
                "date": date,
                "portfolio_value": portfolio_value,
                "cash": self.cash
            })

        return self._generate_report(strategy_name)

    def _buy(self, date, price, target_amount):
        """買入執行（含滑點+佣金）"""
        buy_price = price * (1 + self.slippage)
        shares = int(target_amount / buy_price / 100) * 100  # 100股整數

        if shares > 0:
            cost = shares * buy_price
            commission = cost * self.commission_rate

            if cost + commission <= self.cash:
                self.cash -= (cost + commission)
                self.trades.append({
                    "date": date, "action": "BUY",
                    "price": buy_price, "shares": shares,
                    "commission": commission
                })

    def _sell(self, date, price):
        """賣出執行（含滑點+佣金+印花稅）"""
        sell_price = price * (1 - self.slippage)

        for stock, shares in list(self.position.items()):
            if shares > 0:
                proceeds = shares * sell_price
                commission = proceeds * self.commission_rate
                tax = proceeds * self.stamp_tax

                self.cash -= (commission + tax)
                self.cash += proceeds
                self.trades.append({
                    "date": date, "action": "SELL",
                    "price": sell_price, "shares": shares,
                    "commission": commission, "tax": tax
                })

    def _calculate_portfolio_value(self, current_price):
        """計算組合市值"""
        position_value = sum(
            shares * current_price 
            for stock, shares in self.position.items()
        )
        return self.cash + position_value

    def _generate_report(self, strategy_name: str) -> dict:
        """生成回測報告"""
        equity_df = pd.DataFrame(self.equity_curve)
        equity_df.set_index("date", inplace=True)
        equity_df["returns"] = equity_df["portfolio_value"].pct_change()

        # 核心指標計算
        total_return = (equity_df["portfolio_value"].iloc[-1] / 
                       self.initial_capital - 1) * 100

        annual_return = ((1 + total_return/100) ** 
                        (252/len(equity_df)) - 1) * 100

        volatility = equity_df["returns"].std() * np.sqrt(252) * 100

        sharpe_ratio = (annual_return - 2.75) / volatility  # 假設無風險利率2.75%

        # 最大回撤
        cummax = equity_df["portfolio_value"].cummax()
        drawdown = (equity_df["portfolio_value"] - cummax) / cummax
        max_drawdown = drawdown.min() * 100

        # 卡爾瑪比率
        calmar_ratio = annual_return / abs(max_drawdown) if max_drawdown != 0 else 0

        return {
            "strategy": strategy_name,
            "period": f"{equity_df.index[0].date()} to {equity_df.index[-1].date()}",
            "total_return": round(total_return, 2),
            "annual_return": round(annual_return, 2),
            "volatility": round(volatility, 2),
            "sharpe_ratio": round(sharpe_ratio, 2),
            "max_drawdown": round(max_drawdown, 2),
            "calmar_ratio": round(calmar_ratio, 2),
            "total_trades": len([t for t in self.trades if t["action"] == "BUY"]),
            "win_rate": self._calculate_win_rate(),
            "equity_curve": equity_df
        }

    def _calculate_win_rate(self) -> float:
        """計算勝率"""
        if len(self.trades) < 2:
            return 0

        buy_trades = [t for t in self.trades if t["action"] == "BUY"]
        sell_trades = [t for t in self.trades if t["action"] == "SELL"]

        if len(sell_trades) == 0:
            return 0

        wins = sum(
            1 for i, sell in enumerate(sell_trades)
            if i < len(buy_trades) and 
            sell["price"] > buy_trades[i]["price"]
        )

        return wins / len(sell_trades) * 100

2. Strategy Examples / 策略示例

# 示例策略：雙均線交叉策略
class DualMovingAverageStrategy:
    """雙均線策略"""

    def __init__(self, short_window: int = 20, long_window: int = 60):
        self.short_window = short_window
        self.long_window = long_window

    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:
        """生成交易訊號"""
        signals = pd.Series(index=data.index, dtype=int)

        # 計算均線
        ma_short = data["close"].rolling(self.short_window).mean()
        ma_long = data["close"].rolling(self.long_window).mean()

        # 金叉買入，死叉賣出
        position = 0
        for i in range(self.long_window, len(data)):
            if ma_short.iloc[i] > ma_long.iloc[i] and position == 0:
                signals.iloc[i] = 1  # 買入
                position = 1
            elif ma_short.iloc[i] < ma_long.iloc[i] and position == 1:
                signals.iloc[i] = -1  # 賣出
                position = 0

        return signals

# RSI均值迴歸策略
class RSIMeanReversionStrategy:
    """RSI均值迴歸策略"""

    def __init__(self, period: int = 14, 
                 oversold: float = 30, 
                 overbought: float = 70):
        self.period = period
        self.oversold = oversold
        self.overbought = overbought

    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:
        """RSI超賣買入，超買賣出"""
        delta = data["close"].diff()
        gain = (delta.where(delta > 0, 0)).rolling(self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(self.period).mean()

        rs = gain / loss
        rsi = 100 - (100 / (1 + rs))

        signals = pd.Series(index=data.index, dtype=int)
        position = 0

        for i in range(self.period, len(data)):
            if rsi.iloc[i] < self.oversold and position == 0:
                signals.iloc[i] = 1  # 買入
                position = 1
            elif rsi.iloc[i] > self.overbought and position == 1:
                signals.iloc[i] = -1  # 賣出
                position = 0

        return signals
小蔥技能7w4.net有完整的技能分類。

3. Monte Carlo Simulation / 蒙特卡洛模擬

class MonteCarloSimulation:
    """蒙特卡洛模擬"""

    def run_simulation(self, historical_returns: pd.Series,
                      n_simulations: int = 1000,
                      n_periods: int = 252,
                      initial_value: float = 1000000) -> dict:
        """
        執行蒙特卡洛模擬
        """
        mu = historical_returns.mean()
        sigma = historical_returns.std()

        simulations = np.zeros((n_simulations, n_periods))
        simulations[:, 0] = initial_value

        for t in range(1, n_periods):
            random_returns = np.random.normal(mu, sigma, n_simulations)
            simulations[:, t] = simulations[:, t-1] * (1 + random_returns)

        # 統計結果
        final_values = simulations[:, -1]

        percentiles = {
            "5th": np.percentile(final_values, 5),
            "25th": np.percentile(final_values, 25),
            "50th": np.percentile(final_values, 50),
            "75th": np.percentile(final_values, 75),
            "95th": np.percentile(final_values, 95)
        }

        # 機率分析
        prob_loss = (final_values < initial_value).mean() * 100

        return {
            "percentiles": {k: round(v, 2) for k, v in percentiles.items()},
            "probability_of_loss": round(prob_loss, 2),
            "expected_return": round(final_values.mean() - initial_value, 2),
            "var_95": round(initial_value - percentiles["5th"], 2),
            "simulations": simulations
        }

Quick Command Templates / 快速指令模板

回測雙均線策略：

回測雙均線策略（MA20/MA60）：
- 初始資金：100萬
- 回測期：2020-01-01至2025-12-31
- 關注指標：收益率、夏普比率、最大回撤

蒙特卡洛模擬：

對當前持倉做蒙特卡洛模擬：
- 模擬次數：10000次
- 模擬期限：1年
- 置信區間：95%

Disclaimer

This skill provides backtesting tools for educational and research purposes. Backtesting results do not guarantee future performance. Past performance is not indicative of future results. Algorithmic trading involves substantial risk of loss.

這個量化回測工具質量中等偏上。文件結構清晰、中英雙語、策略示例實用，包含完整的交易成本計算。但存在一些明顯不足：程式碼實現比較基礎，缺少高階分析功能；某些函式實現有缺陷；只有單個文件，沒有配套的示例資料或更詳細的教程。總體適合有一定基礎的量化交易者使用，但初學者可能會感到資料不夠豐富。