2 posts tagged with "trading-strategies"

View All Tags

Chiến Lược Giao Dịch Đảo Chiều

June 5, 2025 · 6 min read

admin Hướng Nghiệp Dữ Liệu

Fullstack

Trong bài viết này, chúng ta sẽ tìm hiểu về các chiến lược giao dịch đảo chiều và cách áp dụng chúng hiệu quả.

Chiến lược giao dịch đảo chiều

Mô Hình Đảo Chiều

1. Double Top/Bottom

class DoubleTopBottom:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh và đáy
        peaks = df['high'].rolling(window=self.window, center=True).max()
        troughs = df['low'].rolling(window=self.window, center=True).min()
        
        # Xác định Double Top
        double_top = (
            (abs(peaks.shift(1) - peaks) / peaks.shift(1) < self.threshold) &  # Hai đỉnh gần bằng nhau
            (df['close'] < peaks.shift(1)) &  # Giá đóng cửa dưới đỉnh
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        # Xác định Double Bottom
        double_bottom = (
            (abs(troughs.shift(1) - troughs) / troughs.shift(1) < self.threshold) &  # Hai đáy gần bằng nhau
            (df['close'] > troughs.shift(1)) &  # Giá đóng cửa trên đáy
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        return pd.DataFrame({
            'Double_Top': double_top,
            'Double_Bottom': double_bottom
        })

2. Head and Shoulders

class HeadAndShoulders:
    def __init__(self, window=20, threshold=0.02):
        self.window = window
        self.threshold = threshold
    
    def identify(self, df):
        # Tìm các đỉnh
        peaks = df['high'].rolling(window=self.window, center=True).max()
        
        # Xác định mô hình Head and Shoulders
        left_shoulder = peaks.shift(2)
        head = peaks.shift(1)
        right_shoulder = peaks
        
        # Kiểm tra điều kiện
        pattern = (
            (abs(left_shoulder - right_shoulder) / left_shoulder < self.threshold) &  # Hai vai cân đối
            (head > left_shoulder) &  # Đỉnh đầu cao hơn vai
            (head > right_shoulder) &  # Đỉnh đầu cao hơn vai
            (df['close'] < right_shoulder) &  # Giá đóng cửa dưới vai phải
            (df['volume'] > df['volume'].rolling(window=20).mean())  # Khối lượng tăng
        )
        
        return pattern

Phân Kỳ

1. RSI Divergence

class RSIDivergence:
    def __init__(self, period=14, lookback=10):
        self.period = period
        self.lookback = lookback
    
    def identify(self, df):
        # Tính toán RSI
        rsi = self.calculate_rsi(df)
        
        # Tìm các đỉnh và đáy của giá và RSI
        price_peaks = df['high'].rolling(window=self.lookback, center=True).max()
        price_troughs = df['low'].rolling(window=self.lookback, center=True).min()
        rsi_peaks = rsi.rolling(window=self.lookback, center=True).max()
        rsi_troughs = rsi.rolling(window=self.lookback, center=True).min()
        
        # Xác định phân kỳ
        bearish_divergence = (
            (price_peaks > price_peaks.shift(1)) &  # Giá tạo đỉnh cao hơn
            (rsi_peaks < rsi_peaks.shift(1))  # RSI tạo đỉnh thấp hơn
        )
        
        bullish_divergence = (
            (price_troughs < price_troughs.shift(1)) &  # Giá tạo đáy thấp hơn
            (rsi_troughs > rsi_troughs.shift(1))  # RSI tạo đáy cao hơn
        )
        
        return pd.DataFrame({
            'Bearish_Divergence': bearish_divergence,
            'Bullish_Divergence': bullish_divergence
        })
    
    def calculate_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

2. MACD Divergence

class MACDDivergence:
    def __init__(self, fast_period=12, slow_period=26, signal_period=9, lookback=10):
        self.fast_period = fast_period
        self.slow_period = slow_period
        self.signal_period = signal_period
        self.lookback = lookback
    
    def identify(self, df):
        # Tính toán MACD
        macd = self.calculate_macd(df)
        
        # Tìm các đỉnh và đáy của giá và MACD
        price_peaks = df['high'].rolling(window=self.lookback, center=True).max()
        price_troughs = df['low'].rolling(window=self.lookback, center=True).min()
        macd_peaks = macd['MACD'].rolling(window=self.lookback, center=True).max()
        macd_troughs = macd['MACD'].rolling(window=self.lookback, center=True).min()
        
        # Xác định phân kỳ
        bearish_divergence = (
            (price_peaks > price_peaks.shift(1)) &  # Giá tạo đỉnh cao hơn
            (macd_peaks < macd_peaks.shift(1))  # MACD tạo đỉnh thấp hơn
        )
        
        bullish_divergence = (
            (price_troughs < price_troughs.shift(1)) &  # Giá tạo đáy thấp hơn
            (macd_troughs > macd_troughs.shift(1))  # MACD tạo đáy cao hơn
        )
        
        return pd.DataFrame({
            'Bearish_Divergence': bearish_divergence,
            'Bullish_Divergence': bullish_divergence
        })
    
    def calculate_macd(self, df):
        exp1 = df['close'].ewm(span=self.fast_period, adjust=False).mean()
        exp2 = df['close'].ewm(span=self.slow_period, adjust=False).mean()
        macd = exp1 - exp2
        signal = macd.ewm(span=self.signal_period, adjust=False).mean()
        histogram = macd - signal
        
        return pd.DataFrame({
            'MACD': macd,
            'Signal': signal,
            'Histogram': histogram
        })

Quá Mua/Quá Bán

1. RSI Strategy

class RSIStrategy:
    def __init__(self, period=14, overbought=70, oversold=30):
        self.period = period
        self.overbought = overbought
        self.oversold = oversold
    
    def identify_signals(self, df):
        # Tính toán RSI
        rsi = self.calculate_rsi(df)
        
        # Xác định tín hiệu
        sell_signal = (
            (rsi > self.overbought) &  # RSI quá mua
            (rsi.shift(1) <= self.overbought)  # RSI vừa vượt ngưỡng quá mua
        )
        
        buy_signal = (
            (rsi < self.oversold) &  # RSI quá bán
            (rsi.shift(1) >= self.oversold)  # RSI vừa vượt ngưỡng quá bán
        )
        
        return pd.DataFrame({
            'Sell_Signal': sell_signal,
            'Buy_Signal': buy_signal
        })
    
    def calculate_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

2. Stochastic Strategy

class StochasticStrategy:
    def __init__(self, k_period=14, d_period=3, overbought=80, oversold=20):
        self.k_period = k_period
        self.d_period = d_period
        self.overbought = overbought
        self.oversold = oversold
    
    def identify_signals(self, df):
        # Tính toán Stochastic
        k, d = self.calculate_stochastic(df)
        
        # Xác định tín hiệu
        sell_signal = (
            (k > self.overbought) &  # %K quá mua
            (d > self.overbought) &  # %D quá mua
            (k < d) &  # %K cắt xuống %D
            (k.shift(1) >= d.shift(1))  # Xác nhận cắt
        )
        
        buy_signal = (
            (k < self.oversold) &  # %K quá bán
            (d < self.oversold) &  # %D quá bán
            (k > d) &  # %K cắt lên %D
            (k.shift(1) <= d.shift(1))  # Xác nhận cắt
        )
        
        return pd.DataFrame({
            'Sell_Signal': sell_signal,
            'Buy_Signal': buy_signal
        })
    
    def calculate_stochastic(self, df):
        low_min = df['low'].rolling(window=self.k_period).min()
        high_max = df['high'].rolling(window=self.k_period).max()
        
        k = 100 * ((df['close'] - low_min) / (high_max - low_min))
        d = k.rolling(window=self.d_period).mean()
        
        return k, d

Xác Nhận

1. Volume Confirmation

class VolumeConfirmation:
    def __init__(self, volume_ma_period=20, volume_threshold=1.5):
        self.volume_ma_period = volume_ma_period
        self.volume_threshold = volume_threshold
    
    def confirm(self, df, signal):
        # Tính toán trung bình khối lượng
        volume_ma = df['volume'].rolling(window=self.volume_ma_period).mean()
        
        # Xác nhận tín hiệu với khối lượng
        confirmed_signal = (
            signal &  # Có tín hiệu
            (df['volume'] > volume_ma * self.volume_threshold)  # Khối lượng tăng mạnh
        )
        
        return confirmed_signal

2. Multiple Timeframe Confirmation

class MultiTimeframeConfirmation:
    def __init__(self, higher_tf_period=4):
        self.higher_tf_period = higher_tf_period
    
    def confirm(self, df, signal):
        # Tính toán giá trung bình cho khung thời gian cao hơn
        higher_tf_close = df['close'].rolling(window=self.higher_tf_period).mean()
        
        # Xác nhận tín hiệu với khung thời gian cao hơn
        confirmed_signal = (
            signal &  # Có tín hiệu
            (df['close'] > higher_tf_close)  # Giá trên trung bình khung cao hơn
        )
        
        return confirmed_signal

Best Practices

Kết hợp nhiều chỉ báo
Xác nhận tín hiệu với khối lượng
Sử dụng nhiều khung thời gian
Đặt mức cắt lỗ phù hợp
Quản lý rủi ro chặt chẽ

Kết luận

Giao dịch đảo chiều là một chiến lược phức tạp nhưng có thể mang lại lợi nhuận cao nếu được thực hiện đúng cách. Điều quan trọng là phải có sự kiên nhẫn và kỷ luật trong việc chờ đợi các tín hiệu xác nhận.

Chiến Lược Giao Dịch Theo Xu Hướng

June 5, 2025 · 5 min read

admin Hướng Nghiệp Dữ Liệu

Fullstack

Trong bài viết này, chúng ta sẽ tìm hiểu về các chiến lược giao dịch theo xu hướng và cách áp dụng chúng hiệu quả.

Chiến lược giao dịch theo xu hướng

Xác Định Xu Hướng

1. Moving Averages

class TrendIdentifier:
    def __init__(self, short_period=20, long_period=50):
        self.short_period = short_period
        self.long_period = long_period
    
    def identify_trend(self, df):
        # Tính toán các đường trung bình
        short_ma = df['close'].rolling(window=self.short_period).mean()
        long_ma = df['close'].rolling(window=self.long_period).mean()
        
        # Xác định xu hướng
        trend = pd.Series(index=df.index)
        trend[short_ma > long_ma] = 1  # Xu hướng tăng
        trend[short_ma < long_ma] = -1  # Xu hướng giảm
        trend[short_ma == long_ma] = 0  # Không có xu hướng rõ ràng
        
        return trend

2. ADX

class ADXIndicator:
    def __init__(self, period=14):
        self.period = period
    
    def calculate(self, df):
        # Tính toán True Range
        tr1 = df['high'] - df['low']
        tr2 = abs(df['high'] - df['close'].shift(1))
        tr3 = abs(df['low'] - df['close'].shift(1))
        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
        
        # Tính toán Directional Movement
        up_move = df['high'] - df['high'].shift(1)
        down_move = df['low'].shift(1) - df['low']
        
        plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)
        minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)
        
        # Tính toán ADX
        tr_smoothed = tr.rolling(window=self.period).mean()
        plus_di = 100 * pd.Series(plus_dm).rolling(window=self.period).mean() / tr_smoothed
        minus_di = 100 * pd.Series(minus_dm).rolling(window=self.period).mean() / tr_smoothed
        
        dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)
        adx = dx.rolling(window=self.period).mean()
        
        return pd.DataFrame({
            'ADX': adx,
            'Plus_DI': plus_di,
            'Minus_DI': minus_di
        })

Chiến Lược Vào Lệnh

1. Breakout Strategy

class BreakoutStrategy:
    def __init__(self, period=20, threshold=0.02):
        self.period = period
        self.threshold = threshold
    
    def identify_breakouts(self, df):
        # Tính toán các mức kháng cự và hỗ trợ
        resistance = df['high'].rolling(window=self.period).max()
        support = df['low'].rolling(window=self.period).min()
        
        # Xác định các điểm breakout
        bullish_breakout = (
            (df['close'] > resistance.shift(1)) &  # Giá đóng cửa vượt kháng cự
            (df['close'] - resistance.shift(1)) / resistance.shift(1) > self.threshold  # Vượt quá ngưỡng
        )
        
        bearish_breakout = (
            (df['close'] < support.shift(1)) &  # Giá đóng cửa dưới hỗ trợ
            (support.shift(1) - df['close']) / support.shift(1) > self.threshold  # Giảm quá ngưỡng
        )
        
        return pd.DataFrame({
            'Bullish_Breakout': bullish_breakout,
            'Bearish_Breakout': bearish_breakout
        })

2. Pullback Strategy

class PullbackStrategy:
    def __init__(self, ma_period=50, rsi_period=14, rsi_oversold=30):
        self.ma_period = ma_period
        self.rsi_period = rsi_period
        self.rsi_oversold = rsi_oversold
    
    def identify_pullbacks(self, df):
        # Tính toán các chỉ báo
        ma = df['close'].rolling(window=self.ma_period).mean()
        rsi = self.calculate_rsi(df)
        
        # Xác định các điểm pullback
        bullish_pullback = (
            (df['close'] > ma) &  # Giá trên MA
            (df['close'].shift(1) < df['close']) &  # Giá tăng
            (rsi < self.rsi_oversold)  # RSI quá bán
        )
        
        return bullish_pullback
    
    def calculate_rsi(self, df):
        delta = df['close'].diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=self.rsi_period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=self.rsi_period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

Quản Lý Vị Thế

1. Stop Loss và Take Profit

class PositionManager:
    def __init__(self, risk_percent=0.02, reward_ratio=2):
        self.risk_percent = risk_percent
        self.reward_ratio = reward_ratio
    
    def calculate_levels(self, df, entry_price, position_type):
        # Tính toán ATR
        atr = self.calculate_atr(df)
        
        if position_type == 'long':
            stop_loss = entry_price - (atr * 2)
            take_profit = entry_price + (atr * 2 * self.reward_ratio)
        else:
            stop_loss = entry_price + (atr * 2)
            take_profit = entry_price - (atr * 2 * self.reward_ratio)
        
        return {
            'stop_loss': stop_loss,
            'take_profit': take_profit
        }
    
    def calculate_atr(self, df, period=14):
        high_low = df['high'] - df['low']
        high_close = np.abs(df['high'] - df['close'].shift(1))
        low_close = np.abs(df['low'] - df['close'].shift(1))
        ranges = pd.concat([high_low, high_close, low_close], axis=1)
        true_range = np.max(ranges, axis=1)
        return true_range.rolling(window=period).mean()

2. Trailing Stop

class TrailingStop:
    def __init__(self, atr_multiplier=2):
        self.atr_multiplier = atr_multiplier
    
    def calculate_trailing_stop(self, df, position_type):
        atr = self.calculate_atr(df)
        
        if position_type == 'long':
            trailing_stop = df['high'].rolling(window=20).max() - (atr * self.atr_multiplier)
        else:
            trailing_stop = df['low'].rolling(window=20).min() + (atr * self.atr_multiplier)
        
        return trailing_stop
    
    def calculate_atr(self, df, period=14):
        high_low = df['high'] - df['low']
        high_close = np.abs(df['high'] - df['close'].shift(1))
        low_close = np.abs(df['low'] - df['close'].shift(1))
        ranges = pd.concat([high_low, high_close, low_close], axis=1)
        true_range = np.max(ranges, axis=1)
        return true_range.rolling(window=period).mean()

Quản Lý Rủi Ro

1. Position Sizing

class RiskManager:
    def __init__(self, account_size, max_risk_percent=0.02):
        self.account_size = account_size
        self.max_risk_percent = max_risk_percent
    
    def calculate_position_size(self, entry_price, stop_loss):
        # Tính toán khoảng cách stop loss
        risk_amount = abs(entry_price - stop_loss)
        
        # Tính toán số lượng hợp đồng
        risk_per_contract = risk_amount
        max_risk_amount = self.account_size * self.max_risk_percent
        position_size = max_risk_amount / risk_per_contract
        
        return int(position_size)

2. Risk/Reward Ratio

class RiskRewardCalculator:
    def calculate_ratio(self, entry_price, stop_loss, take_profit):
        # Tính toán risk và reward
        risk = abs(entry_price - stop_loss)
        reward = abs(take_profit - entry_price)
        
        # Tính toán tỷ lệ risk/reward
        ratio = reward / risk
        
        return ratio

Best Practices

Luôn xác định xu hướng chính
Sử dụng nhiều khung thời gian
Kết hợp các chỉ báo kỹ thuật
Quản lý rủi ro chặt chẽ
Theo dõi và điều chỉnh chiến lược

Kết luận

Giao dịch theo xu hướng là một chiến lược hiệu quả nếu được thực hiện đúng cách. Điều quan trọng là phải có kỷ luật trong việc tuân thủ các quy tắc giao dịch và quản lý rủi ro.

Mô Hình Đảo Chiều​

1. Double Top/Bottom​

2. Head and Shoulders​

Phân Kỳ​

1. RSI Divergence​

2. MACD Divergence​

Quá Mua/Quá Bán​

1. RSI Strategy​

2. Stochastic Strategy​

Xác Nhận​

1. Volume Confirmation​

2. Multiple Timeframe Confirmation​

Best Practices​

Kết luận​

Xác Định Xu Hướng​

1. Moving Averages​

2. ADX​

Chiến Lược Vào Lệnh​

1. Breakout Strategy​

2. Pullback Strategy​

Quản Lý Vị Thế​

1. Stop Loss và Take Profit​

2. Trailing Stop​

Quản Lý Rủi Ro​

1. Position Sizing​

2. Risk/Reward Ratio​

Best Practices​

Kết luận​

Mô Hình Đảo Chiều

1. Double Top/Bottom

2. Head and Shoulders

Phân Kỳ

1. RSI Divergence

2. MACD Divergence

Quá Mua/Quá Bán

1. RSI Strategy

2. Stochastic Strategy

Xác Nhận

1. Volume Confirmation

2. Multiple Timeframe Confirmation

Best Practices

Kết luận

Xác Định Xu Hướng

1. Moving Averages

2. ADX

Chiến Lược Vào Lệnh

1. Breakout Strategy

2. Pullback Strategy

Quản Lý Vị Thế

1. Stop Loss và Take Profit

2. Trailing Stop

Quản Lý Rủi Ro

1. Position Sizing

2. Risk/Reward Ratio

Best Practices

Kết luận