Tin tức

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

26/09/2026 Đặng Trí Thanh 65 lượt xem ~5 phút đọc
Mục lục bài viết
    Chiến Lược Giao Dịch Đảo Chiều

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

    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

    1. Kết hợp nhiều chỉ báo
    2. Xác nhận tín hiệu với khối lượng
    3. Sử dụng nhiều khung thời gian
    4. Đặt mức cắt lỗ phù hợp
    5. 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.

    Đặng Trí Thanh

    Đặng Trí Thanh

    Giám đốc Công nghệ · DNT Digital · Giảng viên HNDL Hướng Nghiệp Dữ Liệu
    1.398 Bài viết
    15.4k Người theo dõi
    120k+ Lượt đọc

    Đặng Trí Thanh — Founder & CTO · Hướng Nghiệp Dữ Liệu - DNT Digital. Chuyên đào tạo và triển khai thực chiến Python, MT5 và hệ thống bot auto trading / IB cho học viên và doanh nghiệp.

    Thẻ: (chưa gắn thẻ)

    Bài viết liên quan

    DNT DIGITAL

    🤖 AI CODE: Vibe Code NEEDED! 🚀 🏦 SSI • DNSE • MT5 • Bitget ⚡

    Zalo 0934145100
    Khóa đào tạo
    Hỗ trợ

    Được học lại miễn phí · Hỗ trợ trọn đời · Cập nhật miễn phí

    Đội ngũ hỗ trợ

    Đặng Trí Thanh
    Đặng Trí Thanh
    Giám đốc Công nghệ DNT Digital
    Zalo 0934145100
    Mộng Cầm
    Mộng Cầm
    Hỗ trợ khách hàng · Huấn luyện viên
    Zalo 0927909257
    Khánh Linh
    Khánh Linh
    Hỗ trợ khách hàng · Huấn luyện viên
    Zalo 0927909582