हाल ही में AI बहुत गर्म है।

पिछले दो वर्षों में बाजार की सबसे मजबूत मुख्य लाइन, चाहे कितना भी घूमें, AI से बच नहीं सकते। NVIDIA, AMD, Broadcom, TSMC, Micron, Microsoft, Google, Meta, CoreWeave, Supermicro... हर थोड़ी देर में, कोई न कोई कंपनी कमाई, ऑर्डर, पूंजीगत व्यय, HBM, GPU, क्लाउड कंप्यूटिंग, डेटा सेंटर जैसे कीवर्ड के कारण अचानक तेजी से बढ़ती है।

इससे भी दिलचस्प बात यह है कि वे अक्सर अकेले नहीं बढ़ते।

कभी-कभी पहले NVIDIA चलता है, फिर बाजार ASIC, ऑप्टिकल मॉड्यूल, सर्वर, लिक्विड कूलिंग, बिजली की खोज शुरू करता है; कभी-कभी Micron की कमाई उम्मीदों से बेहतर आती है, फिर पैसा HBM, स्टोरेज, सेमीकंडक्टर उपकरण, एडवांस्ड पैकेजिंग की ओर जाता है; कभी-कभी क्लाउड विक्रेता पूंजीगत व्यय बढ़ाते हैं, और पूरी AI बुनियादी ढांचा श्रृंखला फिर से मूल्यांकित होती है।

यह AI थीम के भीतर एक प्रकार का परिसंपत्ति रोटेशन है। बाजार केवल एक स्टॉक नहीं खरीद रहा है, बल्कि एक बड़ी कहानी के तहत लगातार नई शाखाओं, नई व्याख्याओं और नए अपेक्षाकृत कम मूल्य वाले लक्ष्यों की तलाश कर रहा है।

समस्या यह आती है: यदि इन संबंधों को पूरी तरह मैन्युअल रूप से व्यवस्थित किया जाए, तो यह बहुत थका देने वाला है।

एक व्यक्ति NVIDIA, AMD, Micron, Microsoft, Google को जान सकता है, लेकिन दर्जनों या सैकड़ों TradFi स्टॉक कॉन्ट्रैक्ट के व्यावसायिक परिवर्तनों, समाचार परिवर्तनों, सेक्टर असाइनमेंट और शेयर मूल्य सह-गति को लगातार ट्रैक करना मुश्किल है। अधिक परेशानी की बात यह है कि कई कंपनियां एकल-गुण वाली नहीं हैं। Google एक ही समय में AI क्लाउड, Gemini और विज्ञापन प्लेटफॉर्म है; Microsoft एक ही समय में क्लाउड, Copilot और एंटरप्राइज सॉफ्टवेयर है; Broadcom के पास ASIC और नेटवर्किंग चिप्स दोनों हैं और यह AI डेटा सेंटर से भी संबंधित है।

इसलिए मैंने प्रयास करना शुरू किया: क्या हम बड़े मॉडल को एक AI स्टॉक मैप बनाने में मदद करने दे सकते हैं?

बड़े मॉडल को सीधे यह न बताने दें कि क्या खरीदना है, बल्कि इसे वह करने दें जो यह बेहतर करता है: कंपनी के व्यवसाय को समझना, AI उप-सेक्टरों को वर्गीकृत करना, समाचारों को व्यवस्थित करना, घटनाओं की व्याख्या करना, और यह निर्धारित करना कि किसी कंपनी में असामान्य हलचल उसी थीम के किन अन्य स्टॉक को प्रभावित कर सकती है। वास्तविक ट्रेडिंग निर्णय अभी भी कीमत, सांख्यिकी और जोखिम प्रबंधन पर छोड़ दें।

पहले स्टॉक को सही बास्केट में रखें

रणनीति का पहला कदम ट्रेडिंग नहीं, बल्कि मैप बनाना है।

एक्सचेंज में अब काफी सारे TradFi स्टॉक कॉन्ट्रैक्ट उपलब्ध हैं, जिनसे सीधे NVDA, AMD, MU, MSFT, GOOGL, SMCI जैसे स्टॉक कॉन्ट्रैक्ट का एक सेट प्राप्त किया जा सकता है। सिस्टम पहले स्टॉक-प्रकार के कॉन्ट्रैक्ट को फ़िल्टर करता है और केवल वास्तविक EQUITY लक्ष्यों को रखता है।

यहां एक बहुत महत्वपूर्ण विवरण है: ETF, इंडेक्स, लीवरेज्ड ETF को मिश्रित नहीं किया जा सकता है। उदाहरण के लिए, QQQ, SOXL, EWT जैसी चीजें, भले ही वे कॉन्ट्रैक्ट सूची में दिखाई दें, वे कंपनी के स्टॉक नहीं हैं। यदि उन्हें AI स्टॉक बास्केट में रखा जाता है, तो बाद के सांख्यिकीय संबंध दूषित हो जाएंगे।

मुख्य फ़िल्टरिंग तर्क कुछ इस प्रकार है:

            python
            
            
def refresh_equity_universe(store, force_reanalyze):
    ms = exchange.GetMarkets()
    symbols = []

    for key, market in ms.items():
        info = market.get("Info", {}) or {}
        sub_type = info.get("underlyingSubType", []) or []
        underlying_type = info.get("underlyingType", "")

        if ".swap" not in key:
            continue
        if "TradFi" not in sub_type:
            continue
        if underlying_type != "EQUITY":
            continue

        symbol = normalize_symbol(key)
        store["markets"][symbol] = {
            "symbol": symbol,
            "contract": key,
            "underlyingType": underlying_type,
            "amountPrecision": market.get("AmountPrecision", 0),
            "pricePrecision": market.get("PricePrecision", 2),
            "ctVal": market.get("CtVal", 1) or 1,
            "minQty": market.get("MinQty", 0) or 0,
        }
        symbols.append(symbol)

स्टॉक पूल प्राप्त करने के बाद, सिस्टम बड़े मॉडल को प्रत्येक स्टॉक का प्रोफाइल बनाने देता है।

प्रोफाइल का मतलब केवल "यह एक टेक स्टॉक है" लिखना नहीं है, बल्कि यह निर्धारित करना है कि यह किन AI उप-सेक्टरों से संबंधित है। उदाहरण के लिए, एक स्टॉक एक साथ कई बास्केट से संबंधित हो सकता है। Google AI क्लाउड, AI मॉडल एप्लिकेशन, AI प्लेटफॉर्म विज्ञापन से संबंधित हो सकता है; Microsoft क्लाउड और एंटरप्राइज AI एप्लिकेशन से संबंधित हो सकता है; NVIDIA AI कंप्यूटिंग और AI सर्वर से संबंधित हो सकता है; Micron AI स्टोरेज से संबंधित हो सकता है।

इस चरण का मुख्य बिंदु यह है: AI युग में स्टॉक एकल-लेबल नहीं, बल्कि बहु-लेबल वाले होते हैं।

प्रत्येक स्टॉक में कई विशेषताएं होती हैं: यह किन बास्केट से संबंधित है, एक्सपोजर कितना अधिक है, इस बास्केट में यह लीडर या फॉलोअर की तरह है, यह किन कंपनियों से प्रभावित हो सकता है, और यह किन कंपनियों को प्रभावित कर सकता है।

मैंने बड़े मॉडल के आउटपुट संरचना पर सख्त बाधाएं लगाईं:

            python
            
            
schema = {
    "symbol": symbol,
    "asset_type": "stock|adr|etf|leveraged_etf|index|fund|other",
    "company_name": "",
    "sector": "",
    "business_summary": "",
    "tradable": False,
    "model_confidence": 0,
    "baskets": [
        {
            "id": "ai_cloud",
            "exposure": 0.0,
            "role": "leader|follower|both|observer",
            "sub_theme": "",
            "reason": ""
        }
    ],
    "search_names": [],
    "event_keywords": [],
    "negative_keywords": [],
    "possible_leaders": [],
    "possible_followers": [],
    "brave_queries": [],
    "reason": ""
}

यहां सबसे महत्वपूर्ण asset_type है। केवल stock और adr बास्केट में प्रवेश कर सकते हैं, ETF, लीवरेज्ड ETF, इंडेक्स, फंड, कमोडिटी या क्षेत्रीय ETF को सीधे फ़िल्टर कर दिया जाता है।

इसके अलावा, reason चीनी भाषा में होना चाहिए, फ़ील्ड नाम समान होने चाहिए, और कॉन्फिडेंस को एक समान 0 से 100 पर सेट किया जाना चाहिए। अन्यथा बाद में लाइव ट्रेडिंग पेज अव्यवस्थित दिखाई देगा।

सेक्टर की जानकारी केवल अनुमान पर आधारित नहीं हो सकती

सिर्फ स्टॉक वर्गीकरण पर्याप्त नहीं है।

AI सेक्टर बहुत तेज़ी से बदलता है। आज बाजार GPU पर चर्चा कर रहा है, कल HBM पर, परसों ऑप्टिकल मॉड्यूल पर, और फिर कुछ दिनों बाद लिक्विड कूलिंग, बिजली, क्लाउड विक्रेता पूंजीगत व्यय पर चर्चा शुरू हो सकती है।

यदि केवल बड़े मॉडल के अपने ज्ञान पर निर्भर रहा जाए, तो यह जल्दी पुराना हो सकता है। इसलिए सिस्टम को रीयल-टाइम सूचना स्रोतों की भी आवश्यकता है।

मैंने यहां BraveSearch को एकीकृत किया है। सिस्टम नियमित रूप से प्रत्येक AI बास्केट की सेक्टर जानकारी खोजता है, और बास्केट के भीतर प्रमुख स्टॉक के समाचार भी खोजता है।

उदाहरण के लिए, AI स्टोरेज बास्केट में, यह Micron, Western Digital, SanDisk, HBM, DRAM, NAND जैसे कीवर्ड देखता है; AI ऑप्टिकल कम्युनिकेशन बास्केट में, यह Ciena, Credo, Lumentum, AAOI, 800G, 1.6T ऑप्टिकल मॉड्यूल जैसी जानकारी देखता है।

सेक्टर इंटेलिजेंस की मुख्य प्रक्रिया है:

            python
            
            
def refresh_basket_intelligence(store):
    if not BRAVE_KEY:
        return
    if not LLM_API_KEY:
        return

    intel = {}

    for bid, basket in store["baskets"].items():
        members = sorted(
            basket["members"],
            key=lambda x: x.get("exposure", 0),
            reverse=True
        )
        top_symbols = [m["symbol"] for m in members[:8]]

        basket_news = fetch_basket_news(basket, top_symbols)
        stock_news = {}

        for symbol in top_symbols[:6]:
            profile = store["profiles"].get(symbol, {})
            stock_news[symbol] = fetch_stock_news(profile, bid)
            Sleep(800)

        analysis = analyze_basket_intel_with_llm(
            store, basket, top_symbols, basket_news, stock_news
        )

        if analysis:
            analysis["basket"] = bid
            analysis["basket_name"] = basket["name"]
            analysis["symbols"] = top_symbols
            analysis["updatedAt"] = int(time.time())
            intel[bid] = analysis

    store["basket_intel"] = intel

इस चरण का उद्देश्य प्रत्येक AI उप-क्षेत्र के लिए एक गतिशील पृष्ठभूमि बनाना है।

बड़ा मॉडल BraveSearch से लाई गई खबरों के आधार पर क्षेत्र की प्रवृत्ति, मुख्य उत्प्रेरक, मुख्य जोखिम, संभावित leader, संभावित follower, और बाद में ध्यान देने योग्य संबंधों का आउटपुट देगा।

यह सीधे बड़े मॉडल से "AI स्टोरेज के बारे में क्या कहना है?" पूछने से अलग है। हम पहले इसे रीयल-टाइम समाचार खिलाते हैं, फिर इसे सारांशित करने देते हैं।

समाचार-चालित व्यापार नहीं, बल्कि पहले मूल्य असामान्य होता है

पहले मैंने भी समाचार-चालित दृष्टिकोण के बारे में सोचा था।

जैसे, जब किसी कंपनी के वित्तीय परिणाम उम्मीद से बेहतर आते हैं, तो बड़ा मॉडल बताए कि यह किन शेयरों के लिए लाभदायक है और सीधे सिग्नल उत्पन्न करे। लेकिन वास्तव में सोचने पर यह बहुत शोरगुल वाला है। बहुत सारी खबरें होती हैं, कई महत्वपूर्ण लगती हैं, लेकिन बाजार उन पर ध्यान नहीं देता।

इसलिए मैंने तर्क को उलट दिया।

पहले कीमत देखो, फिर खबर।

यदि किसी basket के सभी शेयर अपेक्षाकृत स्थिर हैं, तो सिस्टम केवल निरीक्षण करता है। जब कोई शेयर स्पष्ट रूप से क्षेत्र के औसत प्रदर्शन से भटककर वर्तमान leader बन जाता है, तभी सिस्टम पूछताछ शुरू करता है: यह क्यों चला?

यह basket के भीतर ZScore का उपयोग करके किया जाता है।

सीधे शब्दों में समझें, यह देखना है कि क्या कोई शेयर उसी क्षेत्र के अन्य शेयरों की तुलना में असामान्य रूप से मजबूत या कमजोर है। यदि कोई शेयर अचानक उभरता है, जबकि उसी basket के अन्य शेयर अभी तक प्रतिक्रिया नहीं कर पाए हैं, तो संभावित प्रसार का अवसर हो सकता है।

basket ZScore की गणना का मुख्य तर्क इस प्रकार है:

            python
            
            
def calc_basket_zscores(store, symbols):
    returns = {}
    min_len = 999999

    for symbol in symbols:
        bars = get_records(
            store["markets"][symbol]["contract"],
            KLINE_PERIOD,
            SYNC_WINDOW + 10
        )
        if len(bars) < SYNC_WINDOW + 2:
            return None

        r = calc_returns(bars)[-SYNC_WINDOW:]
        returns[symbol] = r
        min_len = min(min_len, len(r))

    latest = {s: returns[s][-1] for s in symbols}
    avg_latest = mean(list(latest.values()))
    dev_series = {s: [] for s in symbols}

    for i in range(min_len):
        row = [returns[s][-min_len + i] for s in symbols]
        row_avg = mean(row)
        for s in symbols:
            dev_series[s].append(returns[s][-min_len + i] - row_avg)

    zscores = {}
    max_abs = 0
    for s in symbols:
        sigma = std(dev_series[s])
        z = (latest[s] - avg_latest) / sigma if sigma > 0 else 0
        zscores[s] = round(z, 3)
        max_abs = max(max_abs, abs(z))

    return {"zscores": zscores, "maxAbs": max_abs}

यदि किसी basket का अधिकतम विचलन ब्रेकआउट थ्रेशोल्ड से अधिक हो जाता है, तो सिस्टम BREAKOUT_DETECTED स्थिति में प्रवेश करता है।

इस बिंदु पर सिस्टम तुरंत व्यापार नहीं करता, बल्कि कारण की खोज शुरू करता है।

समाचार केवल स्पष्टीकरण देता है, सांख्यिकीय संबंध सत्यापित करते हैं

जब leader में मूल्य ब्रेकआउट होता है, तो सिस्टम उसके नवीनतम समाचार को प्राप्त करता है और फिर बड़े मॉडल से यह निर्णय करने को कहता है कि क्या यह समाचार मूल्य असामान्यता की व्याख्या कर सकता है।

लेकिन यहाँ सिर्फ "क्या यह समाचार तेजी वाला है?" नहीं पूछा जाता।

सिस्टम वर्तमान basket, क्षेत्रीय खुफिया जानकारी, रीयल-टाइम मूल्य स्थिति, leader का ZScore, संभावित follower, पहले से सत्यापित सांख्यिकीय संबंध, और BraveSearch से लाए गए समाचार को एक साथ बड़े मॉडल को देता है।

बड़े मॉडल को उत्तर देना होता है:

(1) क्या यह समाचार leader की मूल्य असामान्यता को समझा सकता है।
(2) क्या समाचार की दिशा मूल्य दिशा के अनुरूप है।
(3) क्या व्यापार की अनुमति है।
(4) यह किन follower को प्रभावित करता है।
(5) प्रत्येक follower पर कितना प्रभाव है।
(6) ये follower प्रभावित क्यों हो सकते हैं।

कारण खोज का मुख्य तर्क इस प्रकार है:

            python
            
            
def explain_breakout_with_news(store, bid, leader, direction, leader_z, followers, edges):
    if not BRAVE_KEY:
        return None
    if not LLM_API_KEY:
        return None

    profile = store["profiles"].get(leader, {})
    news = fetch_stock_news(profile, bid)
    if not news:
        return None

    event = analyze_breakout_news_with_llm(
        store, bid, leader, direction, leader_z,
        followers, edges, news
    )
    if not event:
        return None

    if not event.get("explains_price_move"):
        return None

    expected_direction = "bullish" if direction == "long" else "bearish"
    if event.get("direction") != expected_direction:
        return None

    event["confidence"] = normalize_confidence(event.get("confidence", 0))
    if event["confidence"] < MIN_NEWS_CONFIDENCE:
        return None

    if not event.get("trade_allowed"):
        return None

    return event

लेकिन अगर बड़ा मॉडल यह कहे कि कोई follower प्रभावित हो सकता है, तब भी तुरंत ट्रेड नहीं किया जा सकता।

K-लाइन सांख्यिकीय संबंध को भी देखना होता है।

सिस्टम हर basket के अंदर शेयरों के बीच ऐतिहासिक सहसंबंध की गणना करता है, जैसे कि source के breakout के बाद target कितनी बार उसका अनुसरण करता है, सहसंबंध कितना है, सबसे अच्छा lag अवधि क्या है, और औसत अनुवर्ती रिटर्न कितना है।

सिर्फ वे source -> target जो सांख्यिकीय संबंध की परीक्षा पास करते हैं, active edge बनते हैं।

            python
            
            
def rebuild_basket_stats(store):
    edges = []

    for bid, basket in store["baskets"].items():
        symbols = [
            m["symbol"] for m in basket["members"]
            if m["symbol"] in store["markets"]
        ]

        for source in symbols:
            for target in symbols:
                if source == target:
                    continue

                metric = validate_pair(store, source, target)
                if not metric:
                    continue

                source_exp = basket_member_info(basket, source).get("exposure", 0)
                target_exp = basket_member_info(basket, target).get("exposure", 0)

                score = clamp(
                    metric["corr"] * 0.3 +
                    metric["follow"] * 0.4 +
                    min(source_exp, target_exp) * 0.3,
                    0, 1
                )

                edge = {
                    "basket": bid,
                    "source": source,
                    "target": target,
                    "corr": round(metric["corr"], 3),
                    "follow": round(metric["follow"], 3),
                    "lag": metric["lag"],
                    "avgReturn": round(metric["avgReturn"], 6),
                    "sample": metric["sample"],
                    "score": round(score, 3),
                    "active": (
                        score >= MIN_EDGE_SCORE and
                        metric["corr"] >= MIN_CORR and
                        metric["follow"] >= MIN_FOLLOW_SUCCESS
                    ),
                    "updatedAt": int(time.time()),
                }
                edges.append(edge)

    store["edges"] = edges

यह कदम बहुत महत्वपूर्ण है।

बड़ा मॉडल तर्क को समझने में माहिर है, लेकिन बाजार हमेशा तर्क पर नहीं चलता। सांख्यिकीय संबंध यह सत्यापित करने का काम करता है: क्या यह तर्क अतीत में बाजार द्वारा ट्रेड किया गया है?

ट्रेड डिफ्यूज़न पर होता है, न कि पीछा करने पर

यह रणनीति leader का पीछा करने के लिए नहीं है।

leader पहले ही breakout कर चुका होता है, सीधे उसमें प्रवेश करना पीछा करने जैसा हो सकता है। रणनीति असल में एक ही AI basket के अंदर डिफ्यूज़न के अवसरों को पकड़ना चाहती है।

यानी: leader पहले ही चल चुका है, खबर भी तार्किक लगती है, लेकिन कुछ followers ने अभी पूरी प्रतिक्रिया नहीं दी है। अगर इन followers का leader के साथ ऐतिहासिक रूप से सहसंबंध है, तो अल्पकालिक अनुवर्ती अवसर हो सकता है।

Breakout स्कैन में पहले active edge खोजी जाती है, फिर पिछड़े हुए follower ढूंढे जाते हैं:

            python
            
            
def scan_price_breakouts(store):
    for bid, rt in store["realtime"].items():
        if rt["state"] != "BREAKOUT_DETECTED":
            continue

        leader = rt["leader"]
        z = 0
        for m in rt["members"]:
            if m["symbol"] == leader:
                z = m["z"]

        direction = "long" if z > 0 else "short"

        edges = [
            e for e in store["edges"]
            if e["active"] and e["basket"] == bid and e["source"] == leader
        ]

        followers = []
        for e in edges:
            target_rt = find_realtime_member(rt, e["target"])
            if target_rt and abs(target_rt["z"]) < BREAKOUT_THRESHOLD * 0.75:
                followers.append(e["target"])

        if not followers:
            continue

सिर्फ जब समाचार कारण-खोज भी पास हो जाती है, तब confirmed signal जनरेट होता है।

ट्रेड का मुख्य विषय follower होते हैं।

अगर वर्तमान में कोई पोजीशन नहीं है, तो signal की दिशा में नई पोजीशन खोली जाती है। अगर उसी कॉन्ट्रैक्ट पर पहले से उसी दिशा की पोजीशन है, तो उसमें जोड़ा जाता है। अगर पहले से विपरीत दिशा की पोजीशन है, तो पहले उसे बंद किया जाता है, फिर नई दिशा में पोजीशन खोली जाती है।

            python
            
            
def execute_symbol_trade(store, signal, symbol, detail):
    direction = signal["direction"]

    if TRADE_MODE != "trade":
        return open_or_add_position(store, signal, symbol, detail, add_mode=False)

    pos = get_position_by_symbol(symbol)
    if pos:
        pos_dir = position_direction(pos)

        if pos_dir == direction:
            return open_or_add_position(store, signal, symbol, detail, add_mode=True)

        close_existing_position(store, symbol, pos, "reverse_signal")
        Sleep(1000)

    return open_or_add_position(store, signal, symbol, detail, add_mode=False)

ऐसा इसलिए भी है क्योंकि कई शेयर एक साथ कई baskets में मौजूद होते हैं। एक शेयर AI Cloud basket में follower हो सकता है, और AI Application में किसी दूसरे तर्क का सदस्य। अलग-अलग baskets से आने वाले सिग्नल एक साथ उसे प्रभावित कर सकते हैं, इसलिए एक ही कॉन्ट्रैक्ट की दिशा को एकीकृत तरीके से संभालना ज़रूरी है।

जोखिम प्रबंधन पहले सरल रखें, लेकिन होना चाहिए

जोखिम प्रबंधन के मामले में, फिलहाल हार्ड स्टॉप-लॉस और ट्रेलिंग स्टॉप-लॉस का उपयोग किया जाता है।

नुकसान एक निश्चित सीमा तक पहुँचने पर बाहर निकल जाते हैं; लाभ एक निश्चित स्तर तक पहुँचने के बाद ट्रेलिंग स्टॉप-लॉस सक्रिय हो जाता है, और अगर अधिकतम फ्लोटिंग लाभ से बहुत अधिक गिरावट होती है, तो लाभ लॉक करके बाहर निकल जाते हैं।

            python
            
            
def monitor_positions(store):
    for pos in exchange.GetPosition() or []:
        symbol = position_symbol(pos)
        if symbol not in store["markets"]:
            continue

        state = _G(position_state_key(symbol)) or {}
        market = store["markets"][symbol]
        ticker = exchange.GetTicker(market["contract"])

        direction = position_direction(pos)
        pnl_pct = (
            (ticker["Last"] - pos["Price"]) /
            pos["Price"] * 100 *
            (1 if direction == "long" else -1)
        )

        if pnl_pct > state.get("peakPnlPct", 0):
            state["peakPnlPct"] = pnl_pct

        if not state.get("trailActive") and state.get("peakPnlPct", 0) >= TRAIL_ACTIVATE_PCT:
            state["trailActive"] = True

        hard_stop = False
        if state.get("stop"):
            hard_stop = (
                ticker["Last"] <= state["stop"]
                if direction == "long"
                else ticker["Last"] >= state["stop"]
            )

        trail_hit = False
        if state.get("trailActive"):
            giveback = state.get("peakPnlPct", 0) - pnl_pct
            allowed = max(
                1.5,
                state.get("peakPnlPct", 0) * TRAIL_GIVEBACK_PCT / 100.0
            )
            trail_hit = giveback >= allowed

        if hard_stop or trail_hit:
            close_existing_position(
                store, symbol, pos,
                "hard_stop" if hard_stop else "trailing_stop"
            )

यह अंतिम संस्करण का जोखिम नियंत्रण नहीं है, लेकिन पहले संस्करण के वास्तविक व्यापार अवलोकन के लिए पर्याप्त है।

आगे खाता-स्तरीय कुल स्थिति, एकल क्षेत्र जोखिम, एकल दिवसीय हानि सीमा, व्यापार पुष्टि और स्थिति जोड़ने की सीमा जोड़ने की आवश्यकता है।

अब यह सिस्टम किस हद तक पहुँच गया है

अब यह सिस्टम एक पूर्ण अनुसंधान चक्र पूरा करने में सक्षम है।

यह स्वचालित रूप से TradFi स्टॉक कॉन्ट्रैक्ट्स को स्कैन कर सकता है, स्वचालित रूप से बड़े मॉडल को स्टॉक की लॉन्ग बास्केट प्रोफ़ाइल बनाने देता है, स्वचालित रूप से AI उप-क्षेत्रों का निर्माण करता है, स्वचालित रूप से BraveSearch के माध्यम से क्षेत्र और स्टॉक जानकारी प्राप्त करता है, स्वचालित रूप से क्षेत्र की खुफिया जानकारी का सारांश बनाता है, स्वचालित रूप से प्रत्येक बास्केट की वास्तविक समय की ताकत का पता लगाता है, स्वचालित रूप से बास्केट के भीतर स्टॉक के फ़ॉलो संबंधों का सांख्यिकीय विश्लेषण करता है, और लीडर मूल्य ब्रेकआउट के बाद समाचार कारण विश्लेषण करता है।

यदि समाचार स्पष्टीकरण मान्य है, दिशा सुसंगत है, और सांख्यिकीय संबंध भी इसका समर्थन करता है, तो सिस्टम एक confirmed signal उत्पन्न करेगा। डिफ़ॉल्ट मोड में केवल सूचना दी जाती है, वास्तविक व्यापार नहीं होता; trade मोड पर स्विच करने पर ही व्यापार होता है।

वास्तविक व्यापार पृष्ठ पर अब केवल लॉग नहीं हैं, बल्कि सिस्टम का सिंहावलोकन, बास्केट की वास्तविक समय स्थिति, क्षेत्र की खुफिया जानकारी, नवीनतम सिग्नल, नवीनतम व्यापार, नवीनतम चरण तालिका के रूप में प्रदर्शित होते हैं। इससे स्पष्ट रूप से देखा जा सकता है कि सिस्टम किस चरण में अटका है: केवल मूल्य असामान्यता है, या समाचार की कोई व्याख्या नहीं है, या फ़ॉलोअर शर्त पूरी नहीं करता, या जोखिम नियंत्रण द्वारा रोक दिया गया है।

अब भी जो अपरिपक्व है

सच कहूँ तो, यह सिस्टम अभी तक एक परिपक्व स्वचालित व्यापार रणनीति नहीं मानी जा सकती।

यह एक AI थीम रोटेशन अनुसंधान फ्रेमवर्क की तरह अधिक है, जो पहले से ही "स्टॉक प्रोफ़ाइलिंग, क्षेत्र खुफिया, मूल्य विसंगति, समाचार कारण विश्लेषण, सांख्यिकीय सत्यापन, व्यापार संकेत" को एक श्रृंखला में जोड़ चुका है, लेकिन अभी भी सत्यापन की आवश्यकता है।

सबसे अधिक सुधार की आवश्यकता कुछ पहलुओं में है।

(1) स्टॉक प्रोफ़ाइलिंग गुणवत्ता। बड़ा मॉडल कभी-कभी सीमांत स्टॉक को बास्केट में डाल सकता है, इसलिए ETF, इंडेक्स, क्षेत्रीय फंड के मिश्रण से बचने के लिए asset_type को अनिवार्य रूप से लागू किया जाना चाहिए।

(2) समाचार गुणवत्ता। BraveSearch द्वारा प्राप्त समाचार हमेशा मुख्य समाचार नहीं होते, मॉडल को यह निर्णय करने की आवश्यकता है कि कौन से समाचार वास्तव में मूल्य की व्याख्या कर सकते हैं।

(3) सांख्यिकीय संबंध। ऐतिहासिक फ़ॉलो संबंध भविष्य में प्रभावी रहेंगे, इसकी कोई गारंटी नहीं है; निरंतर समीक्षा की आवश्यकता है।

(4) व्यापार जोखिम नियंत्रण। स्वचालित व्यापार से पहले, खाता-स्तरीय स्थिति, क्षेत्र जोखिम, दैनिक हानि और व्यापार पुष्टि को पूरा करना आवश्यक है।

इसलिए अभी के लिए पहले notify मोड चलाना अधिक उपयुक्त है, confirmed signal की गुणवत्ता देखने के लिए।

यदि कुछ समय बाद पता चलता है कि सिग्नल वास्तव में बाजार की असामान्य गतिविधियों की व्याख्या कर सकते हैं, और बाद में फ़ॉलोअर अक्सर प्रतिक्रिया देते हैं, तभी छोटी स्थिति के साथ वास्तविक व्यापार पर विचार करें।

अंत में

यह रणनीति AI को सीधे ऑर्डर देने के लिए नहीं है।

मैं हमेशा से मानता रहा हूँ कि व्यापार प्रणाली में बड़े मॉडल के लिए सबसे उपयुक्त स्थान "मुझे बताओ क्या खरीदना है" नहीं है, बल्कि हमें उन सूचना संरचनाओं को संसाधित करने में मदद करना है जिन्हें मैन्युअल रूप से बनाए रखना मुश्किल है: कंपनी का व्यवसाय, क्षेत्रीय संबद्धता, वास्तविक समय समाचार, घटना स्पष्टीकरण, पूंजी रोटेशन पथ, संभावित प्रभावित वस्तुएँ।

वास्तविक व्यापार अभी भी मूल्य, सांख्यिकी और जोखिम नियंत्रण पर छोड़ा जाना चाहिए।

AI युग की मात्रात्मक रणनीति, केवल एक और बड़े मॉडल इंटरफ़ेस को जोड़ना नहीं होनी चाहिए, बल्कि वास्तविक समय डेटा, थीम ग्राफ़, समाचार घटनाओं, मूल्य संरचना, व्यापार निष्पादन और पुनरावलोकन स्पष्टीकरण को एक साथ जोड़ना चाहिए।

यह AI स्टॉक ग्राफ़ रणनीति, इस दिशा में एक प्रयास है।

**रणनीति स्रोत: **AI 产业链 TradFi 合约图谱交易系统