3 posts tagged with "algorithmic trading"

import pandas as pd
import numpy as np

def ma_crossover_strategy(data, short_window=50, long_window=200):
    """
    Chiến lược giao dịch dựa trên đường trung bình động
    """
    # Tính toán MA ngắn hạn và dài hạn
    data['MA_Short'] = data['Close'].rolling(window=short_window).mean()
    data['MA_Long'] = data['Close'].rolling(window=long_window).mean()
    
    # Tín hiệu mua: MA ngắn cắt lên MA dài
    data['Signal'] = 0
    data['Signal'][short_window:] = np.where(
        data['MA_Short'][short_window:] > data['MA_Long'][short_window:], 1, 0
    )
    
    # Tín hiệu giao dịch
    data['Position'] = data['Signal'].diff()
    
    return data

def rsi_strategy(data, period=14, oversold=30, overbought=70):
    """
    Chiến lược dựa trên RSI
    """
    delta = data['Close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
    
    rs = gain / loss
    data['RSI'] = 100 - (100 / (1 + rs))
    
    # Tín hiệu mua khi RSI < oversold
    # Tín hiệu bán khi RSI > overbought
    data['Signal'] = 0
    data.loc[data['RSI'] < oversold, 'Signal'] = 1
    data.loc[data['RSI'] > overbought, 'Signal'] = -1
    
    return data

def mean_reversion_strategy(data, lookback=20, entry_threshold=2, exit_threshold=0.5):
    """
    Chiến lược Mean Reversion sử dụng Bollinger Bands
    """
    # Tính toán Bollinger Bands
    data['MA'] = data['Close'].rolling(window=lookback).mean()
    data['STD'] = data['Close'].rolling(window=lookback).std()
    data['Upper'] = data['MA'] + (data['STD'] * entry_threshold)
    data['Lower'] = data['MA'] - (data['STD'] * entry_threshold)
    
    # Tín hiệu: Mua khi giá chạm Lower Band, bán khi chạm Upper Band
    data['Signal'] = 0
    data.loc[data['Close'] < data['Lower'], 'Signal'] = 1
    data.loc[data['Close'] > data['Upper'], 'Signal'] = -1
    
    return data

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from sklearn.preprocessing import MinMaxScaler

def build_lstm_model(sequence_length=60):
    """
    Xây dựng mô hình LSTM để dự đoán giá
    """
    model = Sequential([
        LSTM(50, return_sequences=True, input_shape=(sequence_length, 1)),
        Dropout(0.2),
        LSTM(50, return_sequences=True),
        Dropout(0.2),
        LSTM(50),
        Dropout(0.2),
        Dense(1)
    ])
    
    model.compile(optimizer='adam', loss='mean_squared_error')
    return model

def prepare_lstm_data(data, sequence_length=60):
    """
    Chuẩn bị dữ liệu cho LSTM
    """
    scaler = MinMaxScaler()
    scaled_data = scaler.fit_transform(data[['Close']].values)
    
    X, y = [], []
    for i in range(sequence_length, len(scaled_data)):
        X.append(scaled_data[i-sequence_length:i, 0])
        y.append(scaled_data[i, 0])
    
    return np.array(X), np.array(y), scaler

def pairs_trading_strategy(asset1, asset2, lookback=20, entry_threshold=2, exit_threshold=0.5):
    """
    Chiến lược Pairs Trading
    """
    # Tính toán spread
    spread = asset1['Close'] - asset2['Close']
    spread_mean = spread.rolling(window=lookback).mean()
    spread_std = spread.rolling(window=lookback).std()
    
    # Z-score
    z_score = (spread - spread_mean) / spread_std
    
    # Tín hiệu giao dịch
    signals = pd.DataFrame(index=asset1.index)
    signals['Z_Score'] = z_score
    signals['Signal'] = 0
    
    # Mua spread khi z-score < -entry_threshold
    # Bán spread khi z-score > entry_threshold
    signals.loc[z_score < -entry_threshold, 'Signal'] = 1
    signals.loc[z_score > entry_threshold, 'Signal'] = -1
    signals.loc[abs(z_score) < exit_threshold, 'Signal'] = 0
    
    return signals

def calculate_sharpe_ratio(returns, risk_free_rate=0.02):
    """
    Tính toán Sharpe Ratio
    Sharpe Ratio = (Lợi nhuận trung bình - Lãi suất phi rủi ro) / Độ lệch chuẩn
    """
    excess_returns = returns - (risk_free_rate / 252)  # 252 ngày giao dịch/năm
    sharpe_ratio = np.sqrt(252) * excess_returns.mean() / returns.std()
    return sharpe_ratio

def calculate_max_drawdown(equity_curve):
    """
    Tính toán Maximum Drawdown
    """
    peak = equity_curve.expanding().max()
    drawdown = (equity_curve - peak) / peak
    max_drawdown = drawdown.min()
    return max_drawdown

def calculate_performance_metrics(trades):
    """
    Tính toán các chỉ số hiệu suất
    """
    winning_trades = trades[trades['PnL'] > 0]
    losing_trades = trades[trades['PnL'] < 0]
    
    win_rate = len(winning_trades) / len(trades) * 100
    avg_win = winning_trades['PnL'].mean()
    avg_loss = abs(losing_trades['PnL'].mean())
    
    profit_factor = (win_rate / 100 * avg_win) / ((1 - win_rate / 100) * avg_loss)
    
    return {
        'Win Rate': win_rate,
        'Profit Factor': profit_factor,
        'Average Win': avg_win,
        'Average Loss': avg_loss
    }

def backtest_strategy(data, strategy_func, initial_capital=10000):
    """
    Framework backtesting cơ bản
    """
    # Áp dụng chiến lược
    signals = strategy_func(data)
    
    # Tính toán vị thế và lợi nhuận
    positions = signals['Signal'].fillna(0)
    data['Position'] = positions
    
    # Tính toán lợi nhuận
    data['Returns'] = data['Close'].pct_change()
    data['Strategy_Returns'] = data['Position'].shift(1) * data['Returns']
    
    # Tính toán equity curve
    data['Equity'] = (1 + data['Strategy_Returns']).cumprod() * initial_capital
    
    # Tính toán các chỉ số
    total_return = (data['Equity'].iloc[-1] / initial_capital - 1) * 100
    sharpe = calculate_sharpe_ratio(data['Strategy_Returns'].dropna())
    mdd = calculate_max_drawdown(data['Equity'])
    
    return {
        'Total Return': total_return,
        'Sharpe Ratio': sharpe,
        'Max Drawdown': mdd,
        'Equity Curve': data['Equity']
    }

from itertools import product

def optimize_strategy_parameters(data, strategy_func, param_grid):
    """
    Tối ưu hóa tham số bằng Grid Search
    """
    best_sharpe = -np.inf
    best_params = None
    results = []
    
    # Tạo tất cả các tổ hợp tham số
    param_combinations = list(product(*param_grid.values()))
    
    for params in param_combinations:
        param_dict = dict(zip(param_grid.keys(), params))
        
        # Backtest với tham số này
        result = backtest_strategy(data, lambda x: strategy_func(x, **param_dict))
        
        results.append({
            'params': param_dict,
            'sharpe': result['Sharpe Ratio'],
            'return': result['Total Return'],
            'mdd': result['Max Drawdown']
        })
        
        # Cập nhật tham số tốt nhất
        if result['Sharpe Ratio'] > best_sharpe:
            best_sharpe = result['Sharpe Ratio']
            best_params = param_dict
    
    return best_params, results

def walk_forward_analysis(data, strategy_func, train_period=252, test_period=63):
    """
    Walk-Forward Analysis để tránh overfitting
    """
    results = []
    total_periods = len(data) // (train_period + test_period)
    
    for i in range(total_periods):
        train_start = i * (train_period + test_period)
        train_end = train_start + train_period
        test_start = train_end
        test_end = test_start + test_period
        
        # Dữ liệu training
        train_data = data.iloc[train_start:train_end]
        
        # Tối ưu trên dữ liệu training
        best_params = optimize_strategy_parameters(train_data, strategy_func, param_grid)
        
        # Test trên dữ liệu test
        test_data = data.iloc[test_start:test_end]
        test_result = backtest_strategy(test_data, lambda x: strategy_func(x, **best_params))
        
        results.append(test_result)
    
    return results

def kelly_criterion(win_rate, avg_win, avg_loss):
    """
    Kelly Criterion để tính toán kích thước vị thế tối ưu
    """
    win_loss_ratio = avg_win / avg_loss
    kelly_percent = (win_rate * win_loss_ratio - (1 - win_rate)) / win_loss_ratio
    return max(0, min(kelly_percent, 0.25))  # Giới hạn tối đa 25%

def fixed_fractional_position_sizing(equity, risk_per_trade=0.02):
    """
    Fixed Fractional Position Sizing
    """
    risk_amount = equity * risk_per_trade
    return risk_amount

def apply_risk_management(data, signals, stop_loss_pct=0.02, take_profit_pct=0.04):
    """
    Áp dụng Stop Loss và Take Profit
    """
    positions = []
    current_position = None
    
    for i in range(len(data)):
        price = data['Close'].iloc[i]
        signal = signals['Signal'].iloc[i]
        
        if current_position is None and signal != 0:
            # Mở vị thế mới
            current_position = {
                'entry_price': price,
                'entry_index': i,
                'direction': signal,
                'stop_loss': price * (1 - stop_loss_pct) if signal > 0 else price * (1 + stop_loss_pct),
                'take_profit': price * (1 + take_profit_pct) if signal > 0 else price * (1 - take_profit_pct)
            }
        elif current_position is not None:
            # Kiểm tra Stop Loss và Take Profit
            if current_position['direction'] > 0:  # Long position
                if price <= current_position['stop_loss']:
                    # Stop Loss hit
                    positions.append({
                        'entry': current_position['entry_index'],
                        'exit': i,
                        'pnl': (price - current_position['entry_price']) / current_position['entry_price']
                    })
                    current_position = None
                elif price >= current_position['take_profit']:
                    # Take Profit hit
                    positions.append({
                        'entry': current_position['entry_index'],
                        'exit': i,
                        'pnl': (price - current_position['entry_price']) / current_position['entry_price']
                    })
                    current_position = None
            else:  # Short position
                if price >= current_position['stop_loss']:
                    positions.append({
                        'entry': current_position['entry_index'],
                        'exit': i,
                        'pnl': (current_position['entry_price'] - price) / current_position['entry_price']
                    })
                    current_position = None
                elif price <= current_position['take_profit']:
                    positions.append({
                        'entry': current_position['entry_index'],
                        'exit': i,
                        'pnl': (current_position['entry_price'] - price) / current_position['entry_price']
                    })
                    current_position = None
    
    return pd.DataFrame(positions)

class TradingBot:
    def __init__(self, strategy, risk_manager, initial_capital=10000):
        self.strategy = strategy
        self.risk_manager = risk_manager
        self.capital = initial_capital
        self.positions = []
        self.equity_curve = [initial_capital]
    
    def run(self, data):
        """
        Chạy bot trading trên dữ liệu
        """
        signals = self.strategy.generate_signals(data)
        
        for i in range(len(data)):
            signal = signals.iloc[i]
            current_price = data['Close'].iloc[i]
            
            # Quản lý vị thế hiện tại
            self.manage_positions(current_price, i)
            
            # Mở vị thế mới nếu có tín hiệu
            if signal['Signal'] != 0:
                position_size = self.risk_manager.calculate_position_size(
                    self.capital, 
                    current_price,
                    signal['Signal']
                )
                
                if position_size > 0:
                    self.open_position(
                        entry_price=current_price,
                        size=position_size,
                        direction=signal['Signal'],
                        timestamp=i
                    )
            
            # Cập nhật equity curve
            self.update_equity()
    
    def manage_positions(self, current_price, timestamp):
        """
        Quản lý các vị thế đang mở
        """
        for position in self.positions[:]:
            if position['direction'] > 0:  # Long
                pnl_pct = (current_price - position['entry_price']) / position['entry_price']
            else:  # Short
                pnl_pct = (position['entry_price'] - current_price) / position['entry_price']
            
            # Kiểm tra Stop Loss
            if pnl_pct <= -self.risk_manager.stop_loss_pct:
                self.close_position(position, current_price, timestamp, 'Stop Loss')
            
            # Kiểm tra Take Profit
            elif pnl_pct >= self.risk_manager.take_profit_pct:
                self.close_position(position, current_price, timestamp, 'Take Profit')
    
    def open_position(self, entry_price, size, direction, timestamp):
        """
        Mở vị thế mới
        """
        position = {
            'entry_price': entry_price,
            'size': size,
            'direction': direction,
            'entry_time': timestamp,
            'stop_loss': entry_price * (1 - self.risk_manager.stop_loss_pct) if direction > 0 
                        else entry_price * (1 + self.risk_manager.stop_loss_pct),
            'take_profit': entry_price * (1 + self.risk_manager.take_profit_pct) if direction > 0 
                          else entry_price * (1 - self.risk_manager.take_profit_pct)
        }
        self.positions.append(position)
        self.capital -= size * entry_price  # Trừ vốn
    
    def close_position(self, position, exit_price, timestamp, reason):
        """
        Đóng vị thế
        """
        if position['direction'] > 0:
            pnl = (exit_price - position['entry_price']) * position['size']
        else:
            pnl = (position['entry_price'] - exit_price) * position['size']
        
        self.capital += position['size'] * exit_price + pnl
        self.positions.remove(position)
    
    def update_equity(self):
        """
        Cập nhật equity curve
        """
        current_equity = self.capital
        for position in self.positions:
            # Tính toán unrealized PnL (giả định giá hiện tại)
            current_equity += position['size'] * position['entry_price']
        
        self.equity_curve.append(current_equity)

pip install pandas numpy matplotlib yfinance ta-lib

pip install pandas-ta

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

def calculate_ema(data, period):
    """
    Tính toán Exponential Moving Average (EMA)
    """
    return data.ewm(span=period, adjust=False).mean()

def calculate_macd(data, fast_period=12, slow_period=26, signal_period=9):
    """
    Tính toán MACD và MACD Histogram
    """
    # Tính EMA nhanh và chậm
    ema_fast = calculate_ema(data['Close'], fast_period)
    ema_slow = calculate_ema(data['Close'], slow_period)
    
    # MACD Line
    macd_line = ema_fast - ema_slow
    
    # Signal Line (EMA của MACD Line)
    signal_line = calculate_ema(macd_line, signal_period)
    
    # MACD Histogram
    histogram = macd_line - signal_line
    
    return macd_line, signal_line, histogram

# Sử dụng
data = pd.read_csv('price_data.csv')  # Hoặc tải từ API
macd, signal, histogram = calculate_macd(data)

data['MACD'] = macd
data['Signal'] = signal
data['Histogram'] = histogram

import talib

def calculate_macd_talib(data):
    """
    Tính toán MACD sử dụng TA-Lib (nhanh và chính xác hơn)
    """
    macd, signal, histogram = talib.MACD(
        data['Close'].values,
        fastperiod=12,
        slowperiod=26,
        signalperiod=9
    )
    
    data['MACD'] = macd
    data['Signal'] = signal
    data['Histogram'] = histogram
    
    return data

import pandas_ta as ta

def calculate_macd_pandas_ta(data):
    """
    Tính toán MACD sử dụng pandas_ta
    """
    macd_data = ta.macd(
        data['Close'],
        fast=12,
        slow=26,
        signal=9
    )
    
    data = pd.concat([data, macd_data], axis=1)
    return data

def macd_histogram_strategy_basic(data, fast=12, slow=26, signal=9):
    """
    Chiến lược cơ bản: Mua khi Histogram đổi từ âm sang dương,
    Bán khi Histogram đổi từ dương sang âm
    """
    # Tính toán MACD
    macd, signal_line, histogram = calculate_macd(
        data, fast, slow, signal
    )
    
    data['MACD'] = macd
    data['Signal_Line'] = signal_line
    data['Histogram'] = histogram
    
    # Xác định tín hiệu
    data['Signal'] = 0
    
    # Mua: Histogram đổi từ âm sang dương
    data.loc[
        (data['Histogram'] > 0) & 
        (data['Histogram'].shift(1) <= 0), 
        'Signal'
    ] = 1
    
    # Bán: Histogram đổi từ dương sang âm
    data.loc[
        (data['Histogram'] < 0) & 
        (data['Histogram'].shift(1) >= 0), 
        'Signal'
    ] = -1
    
    # Vị thế
    data['Position'] = data['Signal'].replace(0, method='ffill').fillna(0)
    
    return data

def macd_histogram_strategy_advanced(data, fast=12, slow=26, signal=9, 
                                     min_histogram_change=0.5):
    """
    Chiến lược nâng cao với điều kiện bổ sung:
    - Histogram đổi dấu
    - MACD Line phải cùng hướng với Histogram
    - Histogram phải có sự thay đổi đáng kể
    """
    # Tính toán MACD
    macd, signal_line, histogram = calculate_macd(data, fast, slow, signal)
    
    data['MACD'] = macd
    data['Signal_Line'] = signal_line
    data['Histogram'] = histogram
    
    # Điều kiện 1: Histogram đổi dấu
    histogram_cross_up = (histogram > 0) & (histogram.shift(1) <= 0)
    histogram_cross_down = (histogram < 0) & (histogram.shift(1) >= 0)
    
    # Điều kiện 2: MACD Line cùng hướng
    macd_above_signal = macd > signal_line
    macd_below_signal = macd < signal_line
    
    # Điều kiện 3: Histogram thay đổi đáng kể
    histogram_change = abs(histogram - histogram.shift(1))
    significant_change = histogram_change >= min_histogram_change
    
    # Tín hiệu mua
    buy_signal = (
        histogram_cross_up & 
        macd_above_signal & 
        significant_change
    )
    
    # Tín hiệu bán
    sell_signal = (
        histogram_cross_down & 
        macd_below_signal & 
        significant_change
    )
    
    data['Signal'] = 0
    data.loc[buy_signal, 'Signal'] = 1
    data.loc[sell_signal, 'Signal'] = -1
    
    # Vị thế
    data['Position'] = data['Signal'].replace(0, method='ffill').fillna(0)
    
    return data

def detect_histogram_divergence(data, lookback=20):
    """
    Phát hiện Divergence giữa giá và Histogram
    Divergence là tín hiệu mạnh cho đảo chiều
    """
    # Tính toán Histogram
    _, _, histogram = calculate_macd(data)
    data['Histogram'] = histogram
    
    # Tìm đỉnh và đáy của giá
    price_peaks = data['High'].rolling(window=lookback, center=True).max() == data['High']
    price_troughs = data['Low'].rolling(window=lookback, center=True).min() == data['Low']
    
    # Tìm đỉnh và đáy của Histogram
    hist_peaks = histogram.rolling(window=lookback, center=True).max() == histogram
    hist_troughs = histogram.rolling(window=lookback, center=True).min() == histogram
    
    # Bearish Divergence: Giá tạo đỉnh cao hơn, Histogram tạo đỉnh thấp hơn
    bearish_divergence = (
        price_peaks & 
        hist_peaks & 
        (data['High'] > data['High'].shift(lookback)) &
        (histogram < histogram.shift(lookback))
    )
    
    # Bullish Divergence: Giá tạo đáy thấp hơn, Histogram tạo đáy cao hơn
    bullish_divergence = (
        price_troughs & 
        hist_troughs & 
        (data['Low'] < data['Low'].shift(lookback)) &
        (histogram > histogram.shift(lookback))
    )
    
    data['Bearish_Divergence'] = bearish_divergence
    data['Bullish_Divergence'] = bullish_divergence
    
    # Tín hiệu
    data['Signal'] = 0
    data.loc[bullish_divergence, 'Signal'] = 1
    data.loc[bearish_divergence, 'Signal'] = -1
    
    return data

import pandas as pd
import numpy as np
from datetime import datetime
import time

class MACDHistogramBot:
    """
    Bot Trading sử dụng chiến lược MACD Histogram
    """
    
    def __init__(self, initial_capital=10000, fast=12, slow=26, signal=9,
                 stop_loss_pct=0.02, take_profit_pct=0.04):
        self.initial_capital = initial_capital
        self.capital = initial_capital
        self.fast = fast
        self.slow = slow
        self.signal = signal
        self.stop_loss_pct = stop_loss_pct
        self.take_profit_pct = take_profit_pct
        
        self.positions = []
        self.trades = []
        self.equity_curve = [initial_capital]
        
    def calculate_macd(self, data):
        """Tính toán MACD Histogram"""
        ema_fast = data['Close'].ewm(span=self.fast, adjust=False).mean()
        ema_slow = data['Close'].ewm(span=self.slow, adjust=False).mean()
        macd_line = ema_fast - ema_slow
        signal_line = macd_line.ewm(span=self.signal, adjust=False).mean()
        histogram = macd_line - signal_line
        
        return macd_line, signal_line, histogram
    
    def generate_signals(self, data):
        """Tạo tín hiệu giao dịch"""
        macd, signal_line, histogram = self.calculate_macd(data)
        
        data['MACD'] = macd
        data['Signal_Line'] = signal_line
        data['Histogram'] = histogram
        
        # Tín hiệu: Histogram đổi dấu
        data['Signal'] = 0
        
        # Mua: Histogram đổi từ âm sang dương
        buy_condition = (
            (histogram > 0) & 
            (histogram.shift(1) <= 0) &
            (macd > signal_line)  # MACD trên Signal Line
        )
        
        # Bán: Histogram đổi từ dương sang âm
        sell_condition = (
            (histogram < 0) & 
            (histogram.shift(1) >= 0) &
            (macd < signal_line)  # MACD dưới Signal Line
        )
        
        data.loc[buy_condition, 'Signal'] = 1
        data.loc[sell_condition, 'Signal'] = -1
        
        return data
    
    def calculate_position_size(self, price, risk_pct=0.02):
        """
        Tính toán kích thước vị thế dựa trên rủi ro
        """
        risk_amount = self.capital * risk_pct
        stop_loss_distance = price * self.stop_loss_pct
        position_size = risk_amount / stop_loss_distance
        
        return min(position_size, self.capital / price * 0.95)  # Giới hạn 95% vốn
    
    def execute_trade(self, signal, price, timestamp):
        """Thực thi giao dịch"""
        if signal == 0:
            return
        
        # Đóng vị thế ngược chiều nếu có
        if self.positions:
            for position in self.positions[:]:
                if (position['direction'] > 0 and signal < 0) or \
                   (position['direction'] < 0 and signal > 0):
                    self.close_position(position, price, timestamp)
        
        # Mở vị thế mới
        if signal != 0 and not self.positions:
            position_size = self.calculate_position_size(price)
            
            if position_size > 0:
                position = {
                    'entry_price': price,
                    'size': position_size,
                    'direction': signal,
                    'entry_time': timestamp,
                    'stop_loss': price * (1 - self.stop_loss_pct) if signal > 0 \
                                else price * (1 + self.stop_loss_pct),
                    'take_profit': price * (1 + self.take_profit_pct) if signal > 0 \
                                 else price * (1 - self.take_profit_pct)
                }
                self.positions.append(position)
                self.capital -= position_size * price
    
    def close_position(self, position, exit_price, exit_time, reason='Signal'):
        """Đóng vị thế"""
        if position['direction'] > 0:  # Long
            pnl = (exit_price - position['entry_price']) * position['size']
        else:  # Short
            pnl = (position['entry_price'] - exit_price) * position['size']
        
        pnl_pct = pnl / (position['entry_price'] * position['size']) * 100
        
        # Ghi lại giao dịch
        trade = {
            'entry_time': position['entry_time'],
            'exit_time': exit_time,
            'entry_price': position['entry_price'],
            'exit_price': exit_price,
            'direction': 'Long' if position['direction'] > 0 else 'Short',
            'size': position['size'],
            'pnl': pnl,
            'pnl_pct': pnl_pct,
            'exit_reason': reason
        }
        self.trades.append(trade)
        
        # Cập nhật vốn
        self.capital += position['size'] * exit_price + pnl
        self.positions.remove(position)
    
    def check_stop_loss_take_profit(self, current_price, timestamp):
        """Kiểm tra Stop Loss và Take Profit"""
        for position in self.positions[:]:
            if position['direction'] > 0:  # Long
                if current_price <= position['stop_loss']:
                    self.close_position(position, current_price, timestamp, 'Stop Loss')
                elif current_price >= position['take_profit']:
                    self.close_position(position, current_price, timestamp, 'Take Profit')
            else:  # Short
                if current_price >= position['stop_loss']:
                    self.close_position(position, current_price, timestamp, 'Stop Loss')
                elif current_price <= position['take_profit']:
                    self.close_position(position, current_price, timestamp, 'Take Profit')
    
    def run_backtest(self, data):
        """Chạy backtest"""
        data = self.generate_signals(data.copy())
        
        for i in range(len(data)):
            current_price = data['Close'].iloc[i]
            signal = data['Signal'].iloc[i]
            timestamp = data.index[i]
            
            # Kiểm tra Stop Loss và Take Profit
            self.check_stop_loss_take_profit(current_price, timestamp)
            
            # Thực thi giao dịch
            self.execute_trade(signal, current_price, timestamp)
            
            # Cập nhật equity curve
            current_equity = self.capital
            for position in self.positions:
                if position['direction'] > 0:
                    unrealized_pnl = (current_price - position['entry_price']) * position['size']
                else:
                    unrealized_pnl = (position['entry_price'] - current_price) * position['size']
                current_equity += position['size'] * position['entry_price'] + unrealized_pnl
            
            self.equity_curve.append(current_equity)
        
        # Đóng tất cả vị thế còn lại
        final_price = data['Close'].iloc[-1]
        for position in self.positions[:]:
            self.close_position(position, final_price, data.index[-1], 'End of Data')
        
        return pd.DataFrame(self.trades), pd.Series(self.equity_curve, index=data.index)
    
    def get_performance_metrics(self, trades_df, equity_curve):
        """Tính toán các chỉ số hiệu suất"""
        if len(trades_df) == 0:
            return {}
        
        total_return = (equity_curve.iloc[-1] / self.initial_capital - 1) * 100
        
        winning_trades = trades_df[trades_df['pnl'] > 0]
        losing_trades = trades_df[trades_df['pnl'] < 0]
        
        win_rate = len(winning_trades) / len(trades_df) * 100 if len(trades_df) > 0 else 0
        avg_win = winning_trades['pnl'].mean() if len(winning_trades) > 0 else 0
        avg_loss = abs(losing_trades['pnl'].mean()) if len(losing_trades) > 0 else 0
        
        profit_factor = (avg_win * len(winning_trades)) / (avg_loss * len(losing_trades)) \
                       if avg_loss > 0 and len(losing_trades) > 0 else 0
        
        # Sharpe Ratio
        returns = equity_curve.pct_change().dropna()
        sharpe_ratio = np.sqrt(252) * returns.mean() / returns.std() if returns.std() > 0 else 0
        
        # Maximum Drawdown
        peak = equity_curve.expanding().max()
        drawdown = (equity_curve - peak) / peak
        max_drawdown = drawdown.min() * 100
        
        return {
            'Total Return (%)': round(total_return, 2),
            'Win Rate (%)': round(win_rate, 2),
            'Profit Factor': round(profit_factor, 2),
            'Average Win': round(avg_win, 2),
            'Average Loss': round(avg_loss, 2),
            'Sharpe Ratio': round(sharpe_ratio, 2),
            'Max Drawdown (%)': round(max_drawdown, 2),
            'Total Trades': len(trades_df)
        }