एल्गो स्ट्रेटेजी: मोमेंटम स्ट्रेटेजी (momentum strategy) - राइड द वेव (ride the wave)

क्या आपने कभी गौर किया है कि कुछ स्टॉक्स एक लेवल तोड़ने के बाद लगातार ऊपर जाते रहते हैं? या सपोर्ट क्रॉस करने के बाद अचानक क्रैश हो जाते हैं?

यह है मोमेंटम – जब प्राइस एक निश्चित दिशा में ताकत के साथ मूव करते हैं। अल्गो ट्रेडर्स इस वेव को पसंद करते हैं।

मोमेंटम ट्रेडिंग क्या है? (What is Momentum Trading?)

साधारण शब्दों में:

"ऊंचे खरीदो, और ऊंचे बेचो।"
"नीचे बेचो, और और नीचे कवर करो।"

मोमेंटम स्ट्रेटेजीज डिप्स का इंतज़ार नहीं करतीं — वे तब एंटर करती हैं जब प्राइस तेज़ी से (ऊपर या नीचे) बढ़ते हैं, मानते हुए कि ट्रेंड जारी रहेगा।

अल्गो मोमेंटम को कैसे ट्रेड करता है? (How Does an Algo Trade Momentum?)

यहाँ कुछ कॉमन सिग्नल्स हैं:

• मूविंग एवरेज क्रॉसओवर (Moving Average Crossover)

जब एक शॉर्ट-टर्म एमए (जैसे 10-दिन) एक लॉन्ग-टर्म एमए (जैसे 50-दिन) के ऊपर क्रॉस करता है, तो यह ऊपर की ओर मोमेंटम का संकेत देता है।

आपका अल्गो यहाँ खरीद सकता है और जब क्रॉसओवर रिवर्स हो जाए तब बाहर निकल सकता है।

import pandas as pd
import talib

close_prices = df['Close']   
# <-- Add this line before SMA
short_ma = talib.SMA(close_prices, timeperiod=10)
long_ma = talib.SMA(close_prices, timeperiod=50)

#Buy signal when short MA > long MA
if short_ma[-1] > long_ma[-1] and short_ma[-2] <= long_ma[-2]:
    print("Buy Signal: Moving Average Crossover")

नोट:

इस कोड में TA-Lib लाइब्रेरी का उपयोग मूविंग एवरेज क्रॉसओवर का पता लगाने के लिए किया गया है — जो एक सामान्य ट्रेडिंग सिग्नल है।

• short_ma & long_ma: TA-Lib के SMA() फंक्शन का उपयोग करके गणना की जाती है। यहाँ, शॉर्ट-टर्म मूविंग एवरेज 10-पिरियड विंडो का उपयोग करता है, और लॉन्ग-टर्म मूविंग एवरेज 50-पिरियड विंडो का उपयोग करता है। दोनों को close_prices पर आधारित माना जाता है, जो क्लोजिंग प्राइसेस की एक पांडा सीरीज है।

• सिग्नल लॉजिक:

  o short_ma[-1] > long_ma[-1] → सबसे हाल के कैंडल में, शॉर्ट-टर्म एमए लॉन्ग-टर्म एमए के ऊपर है (बुलिश)।
  o short_ma[-2] <= long_ma[-2] → पिछले कैंडल में, शॉर्ट-टर्म एमए लॉन्ग-टर्म एमए पर या उसके नीचे था।
  o मिलकर, ये कंडीशंस उस सटीक क्षण का पता लगाते हैं जब शॉर्ट एमए लॉन्ग एमए के ऊपर क्रॉस करता है — एक "गोल्डन क्रॉस" जो संभावित खरीदारी की ओर इशारा करता है।
  o print(): क्रॉसओवर इवेंट की पुष्टि करने के लिए सिग्नल टेक्स्ट आउटपुट करता है।
  

यह संरचना सुनिश्चित करती है कि आप केवल क्रॉसओवर पर ही खरीदारी सिग्नल को ट्रिगर करें, न कि हर बार जब शॉर्ट एमए लॉन्ग एमए के ऊपर रहता है।

• रेसिस्टेंस से ब्रेकआउट (Breakout from Resistance)
  

प्राइस पिछले उच्च स्तर को तोड़ता है और फिर कंसोलिडेशन के बाद = ब्रेकआउट। आपका अल्गो जैसे ही ब्रेकआउट कैंडल रेसिस्टेंस के ऊपर बंद होता है, लॉन्ग एंटर करता है।

resistance = max(close_prices[-20:-1])  
#Highest price in last 20 candles
if close_prices[-1] > resistance: 
    print("Buy Signal: Breakout from Resistance")

नोट: पिछले 20 कैंडल्स में सबसे उच्चतम क्लोज को ढूंढता है। अगर आज की क्लोज उच्च है, तो यह एक ब्रेकआउट खरीद सिग्नल है।

• RSI क्रॉसिंग 60 या 70 (RSI Crossing 60 or 70)
  अगर RSI 60 को पार करता है, तो यह अक्सर ताकत दिखाता है। कुछ अल्गोस RSI > 70 का उपयोग मोमेंटम लॉन्ग एंट्री के लिए करते हैं।
  

import talib

rsi = talib.RSI(df['Close'], timeperiod=14) </br>
if rsi[-1] > 60 and rsi[-2] <= 60: 
    </br>
    print("Buy Signal: RSI Crossing 60") 
    </br>
elif rsi[-1] > 70 and rsi[-2] <= 70: 
    </br>
    print("Strong Buy Signal: RSI Crossing 70") 
    </br>

नोट:

• talib.RSI() → रिलेटिव स्ट्रेंथ इंडेक्स (momentum indicator) को कैल्कुलेट करता है।
• timeperiod=14 → 14 कैंडल्स का उपयोग करता है।
• rsi[-1] → नवीनतम RSI वैल्यू।
• rsi[-2] → पिछले कैंडल की RSI वैल्यू।
• पहली कंडीशन → जब RSI 60 के ऊपर क्रॉस करता है (संभावित ऊपर की ओर ट्रेंड)।
• दूसरी कंडीशन → जब RSI 70 के ऊपर क्रॉस करता है (मजबूत बुलिश मोमेंटम)।

अल्गो में मोमेंटम कैसे ट्रेड करें? (How to Trade Momentum in Algo?)

मान लीजिए आप परिभाषित करते हैं:

• खरीदें अगर प्राइस 20-दिन के उच्च स्तर के ऊपर बंद होता है
• बेचें अगर प्राइस 10-दिन के निम्न स्तर से नीचे गिरता है

आप यह स्ट्रेटेजी हर दिन NIFTY स्टॉक्स पर चलाते हैं। आपका अल्गो सभी 50 स्टॉक्स को सुबह 9:30 बजे स्कैन करता है, सिग्नल्स चेक करता है, और ट्रेड्स में एंटर करता है।

इस तरह, आपका कोड हमेशा मोमेंटम ब्रेकआउट्स की खोज में रहता है, स्वचालित रूप से।

import yfinance as yf

# Define universe
stocks = ["RELIANCE.NS", "TCS.NS", "INFY.NS", "HDFCBANK.NS", "ICICIBANK.NS"]

# Store signals as (symbol, side)
signals = []

for s in stocks:
    # Download last 1 month daily data
    df = yf.download(s, period="1mo", interval="1d")

    # Skip if data is missing or too short
    if df is None or df.empty or len(df) < 21:
        continue

    last_close = df['Close'].iloc[-1]

    # Highest High of last 20 days (excluding current bar)
    prev_20_high = df['High'].iloc[-21:-1].max()

    # Lowest Low of last 10 days (excluding current bar)
    prev_10_low = df['Low'].iloc[-11:-1].min()

    # Momentum BUY condition
    if last_close > prev_20_high:
        signals.append((s, "BUY"))

    # Momentum SELL condition
    elif last_close < prev_10_low:
        signals.append((s, "SELL"))

# Print signals
print("Momentum Signals:")
for sym, side in signals:
    print(f"{sym}: {side}")

# -Order placement (placeholder) -
# Replace with your broker API call
def place_market_order(api_client, symbol, qty, side):
    """
    Example placeholder for broker order placement.
    Modify according to your broker API.
    """
    print(f"Placing {side} order for {qty} shares of {symbol}")

# Example loop to place trades
api_client = None  
# <-- initialize with your broker client
for sym, side in signals:
    symbol_for_broker = sym.replace(".NS", "")  
    # adjust if your broker needs NSE suffix dropped
    place_market_order(api_client, symbol_for_broker, qty=1, side=side)

नोट:

1. stocks → अल्गो जिन स्टॉक टिकर्स (सिंबल्स) को स्कैन करेगा उनकी सूची। उदाहरण: रिलायंस, TCS।
   

2. df = yf.download(...) → Yahoo Finance से प्राइस डेटा डाउनलोड करता है।
   a. period="1mo" → पिछले 1 महीने का डेटा प्राप्त करता है।
   b. interval="1d" → प्रत्येक डेटा पॉइंट 1 दिन का है (डेली कैंडल्स)।
   

3. df['Close'].iloc[-1] → last_close → सबसे हाल की क्लोजिंग प्राइस (अगर सुबह में रन करते हैं तो कल की क्लोज)।
   

4. df['High'].iloc[-21:-1].max() → prev_20_high
   a. पिछले 20 दिनों को (नवीनतम दिन को छोड़कर) देखता है।
   b. उस अवधि में सबसे उच्चतम प्राइस को ढूंढता है।
   c. हाल की उच्चताओं के ऊपर ब्रेकआउट का पता लगाने के लिए उपयोग किया जाता है।
   

5. df['Low'].iloc[-11:-1].min() → prev_10_low
   a. पिछले 10 दिनों को (नवीनतम दिन को छोड़कर) देखता है।
   b. उस अवधि में निम्नतम प्राइस को ढूंढता है।
   c. हाल के निम्न स्तरों के नीचे ब्रेकडाउन का पता लगाने के लिए उपयोग किया जाता है।
   

6. signals.append((s, "BUY")) → last_close > prev_20_high होने पर खरीद सिग्नल को स्टोर करता है।

7. signals.append((s, "SELL")) → last_close < prev_10_low होने पर बेच सिग्नल को स्टोर करता है।
   

8. print("Momentum Signals:") → प्रिंट करता है कि कौन से स्टॉक्स को खरीद/बेच सिग्नल मिले हैं।
   

9. place_market_order(api_client, symbol, qty, side) →
   प्लेसहोल्डर फंक्शन जो आपके ब्रोकर्स के API को ऑर्डर भेजता है।
   a. api_client → ब्रोकर्स के साथ कनेक्शन (आपके ब्रोकर्स के साथ इनिशियलाइज़ किया जाना चाहिए)।
   b. symbol → स्टॉक टिकर, आपके ब्रोकर्स के लिए फॉर्मेट किया गया।
   c. qty → खरीदने/बेचने के लिए शेयरों की संख्या (वर्तमान में 1 पर फिक्स्ड)।
   d. side → BUY या SELL, सिग्नल के आधार पर।
   

ब्रेकआउट डिटेक्शन के बाद ऑर्डर्स प्लेस करना (Placing Orders After Breakout Detection)

# Assume you have already authenticated with your broker's API
# and have an 'api_client' object ready for placing orders.

def place_market_order(api_client, symbol, qty, side="BUY", exchange="NSE", product="CNC"):
    """
    Places a market order for the given symbol.

    Parameters:
    api_client : object - Your broker API client instance
    symbol     : str    - Trading symbol (e.g., 'RELIANCE' or 'RELIANCE.NS')
    qty        : int    - Quantity to buy/sell
    side       : str    - "BUY" or "SELL"
    exchange   : str    - Market exchange (default NSE)
    product    : str    - Product type ("CNC" for delivery, "MIS" for intraday)
    """
    try:
        response = api_client.place_order(
            tradingsymbol=symbol,
            exchange=exchange,
            transaction_type=side,
            quantity=qty,
            order_type="MARKET",
            product=product  # <- changed from product_type to product
        )
        print(f"Order placed for {symbol}: {response}")
    except Exception as e:
        print(f"Error placing order for {symbol}: {repr(e)}")

# Example usage: Place buy orders for all breakout stocks
for stock in breakout_stocks:
    # keep .NS if broker expects it, strip only if necessary
    broker_symbol = stock.replace(".NS", "")  
    place_market_order(api_client, broker_symbol, qty=1, side="BUY")

नोट:
यह फंक्शन आपके ब्रोकर्स के Python client का उपयोग करके मार्केट ऑर्डर भेजने के लिए एक शॉर्टकट है।

• आप विवरण पास करते हैं:
  o symbol → स्टॉक का नाम (जैसे, "RELIANCE")
  o qty → कितने शेयर
  o side → "BUY" या "SELL"
  o exchange → डिफॉल्ट "NSE"
  o product → "CNC" डिलीवरी के लिए, "MIS" इंट्राडे के लिए बदलें

• api_client.place_order(...) केवल एक प्लेसहोल्डर है — आपके ब्रोकर्स के SDK के अनुसार फ़ील्ड नामों को बदलें।
  

• try/except यह सुनिश्चित करता है कि अगर कोई ऑर्डर फेल होता है तो कोड क्रैश नहीं होता; यह त्रुटि को प्रिंट करता है।
  

• stock.replace(".NS","") Yahoo का प्रत्यय हटाता है ताकि "RELIANCE.NS" "RELIANCE" बन जाए (जो ब्रोकर्स आमतौर पर स्वीकार करते हैं)।
  

• यहाँ के ऑर्डर मार्केट ऑर्डर्स हैं (मार्केट प्राइस पर तुरंत)। अगर आप प्राइस कंट्रोल चाहते हैं, तो लिमिट ऑर्डर्स का उपयोग करें।
  

• लाइव जाने से पहले सुरक्षा टिप्स:
  

  o सुनिश्चित करें qty > 0
  o केवल मार्केट ऑवर्स के दौरान रन करें
  o पहले पेपर/सैंडबॉक्स मोड पर टेस्ट करें
  

क्यों यह काम करता है (Why It Works)

• मोमेंटम ट्रेंडिंग मार्केट्स में अच्छी तरह से काम करता है
  
• मजबूत मार्केट सेंटिमेंट के दौरान सबसे अच्छा काम करता है – जैसे अर्निंग्स सीज़न या बजट वीक
  
• अल्गोस इन मूव्स को इंसानों की तुलना में तेजी से पकड़ सकते हैं
  

सावधानियाँ (Watchouts)

• साइडवेज मार्केट्स में मोमेंटम स्ट्रेटेजीज फेल होती हैं
  
• टाइट स्टॉपलॉस की जरूरत होती है – अचानक रिवर्सल्स मुनाफे को मिटा सकते हैं
  
• गैप-अप/गैप-डाउन दिनों के लिए उपयुक्त नहीं है जब तक कि समायोजित न किया जाए
  

विविधताएँ (Variations)

• इंट्राडे मोमेंटम (जैसे, प्राइस पिछले दिन के उच्च स्तर को तोड़ता है)
  
• सेक्टर रोटेशन मोमेंटम (जैसे, IT से Auto में शिफ्ट)
  
• न्यूज़-बेस्ड मोमेंटम (जैसे, RBI रेट कट = बैंक स्टॉक्स में उछाल)
  

संक्षेप में: मोमेंटम अल्गोस वेव को राइड करने की कोशिश करते हैं, उसका विरोध नहीं। अगले चैप्टर में, हम मोमेंटम के विपरीत — मीन रिवर्शन स्ट्रेटेजीज पर नजर डालेंगे।