मैक्रो संकेतों के साथ एल्गोरिथम ट्रेडिंग: एक संपूर्ण FX रणनीति मार्गदर्शिका

मैक्रो सिग्नल एफएक्स अल्गो ट्रेडिंग का आधार क्यों हैं?

विदेशी मुद्रा दरें यादृच्छिक रूप से नहीं चलती हैं। वे दो अर्थव्यवस्थाओं के सापेक्ष आकर्षण को दर्शाती हैंः कौन सा केंद्रीय बैंक तेजी से कस रहा है, जहां वास्तविक उपज अधिक है, कौन सा मुद्रास्फीति शासन क्रय शक्ति को खराब कर रहा है और जिसके परिणामस्वरूप पूंजी प्रवाह हो रहा है। EUR/USD, AUD/JPY, या GBP/USD में प्रत्येक प्रमुख बहु-सप्ताहिक प्रवृत्ति को इन मूलभूत में बदलावों के कारण देखा जा सकता है बदलाव जो एक ज्ञात कार्यक्रम पर घोषित किए जाते हैं और सार्वजनिक डेटा के माध्यम से अवलोकन योग्य होते हैं।

विवेकाधीन व्यापारियों इन संकेतों को मैन्युअल रूप से संसाधित करते हैं। एल्गोरिथमिक व्यापारियों उन्हें कोडित करते हैं. यह गाइड पायथन में FXMacroData को डेटा परत के रूप में उपयोग करके एक पूर्ण मैक्रो-सिग्नल-संचालित FX रणनीति के निर्माण के माध्यम से चलता है। अंत तक आपके पास एक कार्य प्रणाली होगी जोः

• FXMacroData API के माध्यम से दो मुद्राओं के लिए नीतिगत दरों, मुद्रास्फीति, रोजगार और बांड उपज अंतर को प्राप्त करता है
• दिशागत पूर्वाग्रह की पहचान करने के लिए एक समग्र मैक्रो शासन स्कोर की गणना करता है
• तकनीकी संदर्भ प्रदान करने के लिए विदेशी मुद्रा स्पॉट दर इतिहास खींचता है
• उच्च प्रभाव रिलीज कैलेंडर घटनाओं के आसपास अनुसूची संकेत अद्यतन
• स्थिति आकार मार्गदर्शन के साथ लंबे/छोटे/तटस्थ संकेत उत्सर्जित करता है
• मूल जोखिम नियंत्रण लागू करता हैः स्टॉप-लॉस, आकार सीमा, और समाचार विंडो ब्लैकआउट

पूर्व शर्तें

शुरू करने से पहले, सुनिश्चित करें कि आपके पास निम्नलिखित हैं:

• पायथन 3.9+ सभी स्निपेट्स मानक प्रकार के एनोटेशन का उपयोग करते हैं
• FXMacroData एपीआई कुंजी पर साइन अप करें /अपना नाम लिखें और खाता डैशबोर्ड से अपनी कुंजी की प्रतिलिपि
• पायथन पैकेज requests, pandas, numpy

pip install requests pandas numpy

स्रोत फ़ाइलों में अपने एपीआई कुंजी को पर्यावरण चर के रूप में स्टोर करें कभी हार्ड-कोड क्रेडेंशियल्स नहींः

export FXMACRO_API_KEY="YOUR_API_KEY"

नीचे दिए गए उदाहरण व्यापार के हैं। EUR/USD, लेकिन एक ही पैटर्न FXMacroData में उपलब्ध किसी भी जोड़ी के लिए लागू होता है। बस स्वैप EUR और USD मुद्राओं के लिए आप मॉडल करना चाहते हैं.

चरण 1: कोर मैक्रो संकेतक प्राप्त करें

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

FXMacroData एक सुसंगत REST अंत बिंदु के माध्यम से इन सभी प्रदान करता हैः GET /api/v1/announcements/{currency}/{indicator}प्रत्येक अवलोकन में एक date, एक val (निर्देशक का मूल्य) और एक announcement_datetime सही सेकंड तो आप हमेशा पता है कि बाजार पता चला जब।

import os
import requests
from datetime import date, timedelta

BASE_URL = "https://fxmacrodata.com/api/v1"
API_KEY  = os.environ["FXMACRO_API_KEY"]


def fetch_indicator(currency: str, indicator: str, lookback_days: int = 400) -> list[dict]:
    """Fetch the most recent observations for a macro indicator."""
    start = (date.today() - timedelta(days=lookback_days)).isoformat()
    resp = requests.get(
        f"{BASE_URL}/announcements/{currency}/{indicator}",
        params={"api_key": API_KEY, "start": start},
        timeout=10,
    )
    resp.raise_for_status()
    return resp.json().get("data", [])


# Pull the four core series for both sides of EUR/USD
usd_rate      = fetch_indicator("usd", "policy_rate")
eur_rate      = fetch_indicator("eur", "policy_rate")
usd_inflation = fetch_indicator("usd", "inflation")
eur_inflation = fetch_indicator("eur", "inflation")
usd_nfp       = fetch_indicator("usd", "non_farm_payrolls")
usd_unemp     = fetch_indicator("usd", "unemployment")
usd_yield     = fetch_indicator("usd", "gov_bond_10y")
eur_yield     = fetch_indicator("eur", "gov_bond_10y")

नीति दर और दस साल के बांड की उपज ब्याज दर के आयाम को सीधे पकड़ सकते हैं। मुद्रास्फीति यह श्रृंखला बताती है कि क्या किसी केंद्रीय बैंक को और सख्त करना होगा या उसे ढील देने की जगह है। गैर-खेती पगार और बेरोजगारी अमरीकी डालर के लिए श्रम बाजार की तस्वीर को पूरा करें।

चरण 2: मैक्रो रेजिमेंट स्कोर की गणना करें

एक शासन स्कोर कई संकेतकों को एक एकल दिशात्मक संकेत में ढह जाता है। यहां दृष्टिकोण जानबूझकर सरल हैः प्रत्येक मुद्रा के लिए, नवीनतम नीति दर, मुद्रास्फीति दर और बांड उपज की तुलना अपने स्वयं के 12 महीने के औसत के साथ करें। एक मुद्रा जिसका मूलभूत उनके प्रवृत्ति से ऊपर है एक में है सुदृढीकरण व्यवस्था; एक नीचे की प्रवृत्ति में है कमजोर करने की व्यवस्था. दो स्कोर के बीच फैलाव आपको जोड़ी के दिशात्मक पूर्वाग्रह देता है.

import pandas as pd
import numpy as np


def latest_val(series: list[dict]) -> float | None:
    """Return the most recent value from a sorted indicator series."""
    if not series:
        return None
    return series[-1]["val"]


def rolling_zscore(series: list[dict], window: int = 12) -> float | None:
    """Z-score of the latest value relative to the last `window` observations."""
    vals = [r["val"] for r in series if r.get("val") is not None]
    if len(vals) < 2:
        return None
    arr = np.array(vals[-window:], dtype=float)
    mu, sigma = arr.mean(), arr.std()
    if sigma == 0:
        return 0.0
    return float((arr[-1] - mu) / sigma)


def macro_score(
    policy_rate: list[dict],
    inflation:   list[dict],
    bond_yield:  list[dict],
) -> float:
    """
    Composite macro score for one currency.
    Positive → strengthening macro backdrop.
    Negative → weakening macro backdrop.
    """
    weights = {"policy_rate": 0.40, "inflation": 0.30, "bond_yield": 0.30}
    scores = {
        "policy_rate": rolling_zscore(policy_rate),
        "inflation":   rolling_zscore(inflation),
        "bond_yield":  rolling_zscore(bond_yield),
    }
    total, weight_sum = 0.0, 0.0
    for key, w in weights.items():
        z = scores[key]
        if z is not None:
            total      += w * z
            weight_sum += w
    return total / weight_sum if weight_sum > 0 else 0.0


usd_score = macro_score(usd_rate, usd_inflation, usd_yield)
eur_score = macro_score(eur_rate, eur_inflation, eur_yield)

# Positive → USD macro stronger → bias SHORT EUR/USD
# Negative → EUR macro stronger → bias LONG EUR/USD
regime_spread = usd_score - eur_score
print(f"USD macro score: {usd_score:+.3f}")
print(f"EUR macro score: {eur_score:+.3f}")
print(f"Regime spread (USD − EUR): {regime_spread:+.3f}")

चरण 3: अमरीकी डालर के लिए श्रम बाजार संदर्भ जोड़ें

विशेष रूप से यूएसडी जोड़े के लिए, श्रम बाजार अक्सर अल्पकालिक में दर संकेत को ओवरराइड करता है। एक ब्लोआउट पेरोल प्रिंट फेड को मुद्रास्फीति गिरने पर भी कटौती को रोकने के लिए धक्का दे सकता है; बेरोजगारी में एक आश्चर्यजनक छलांग ढील की उम्मीदों को तेज कर सकती है। रोजगार घटक को शामिल करने से उच्च प्रभाव डेटा खिड़कियों के आसपास यूएसडी स्कोर तेज हो जाता है।

def employment_score(nfp: list[dict], unemployment: list[dict]) -> float:
    """
    Labour market contribution to the USD score.
    Positive NFP momentum + falling unemployment → bullish.
    """
    nfp_z   = rolling_zscore(nfp)
    unemp_z = rolling_zscore(unemployment)

    if nfp_z is None and unemp_z is None:
        return 0.0
    score = 0.0
    count = 0
    if nfp_z is not None:
        score += 0.60 * nfp_z   # NFP gets more weight
        count += 1
    if unemp_z is not None:
        # Unemployment is inverse: a rising z-score is bearish for USD
        score -= 0.40 * unemp_z
        count += 1
    return score


usd_employment = employment_score(usd_nfp, usd_unemp)

# Rebuild USD score including labour market
usd_score_full = (
    0.35 * (rolling_zscore(usd_rate) or 0.0) +
    0.25 * (rolling_zscore(usd_inflation) or 0.0) +
    0.25 * (rolling_zscore(usd_yield) or 0.0) +
    0.15 * usd_employment
)

regime_spread_full = usd_score_full - eur_score
print(f"USD score (with labour): {usd_score_full:+.3f}")
print(f"Regime spread (full):    {regime_spread_full:+.3f}")

चरण 4: विदेशी मुद्रा स्पॉट दर इतिहास निकालें

मैक्रो रेजिमेंट स्कोर दिशागत विश्वास प्रदान करते हैं, लेकिन प्रवेश समय अभी भी मूल्य-आधारित फ़िल्टर से लाभान्वित होता है। जब युग्म अपने 50-दिवसीय औसत से 3 मानक विचलन से ऊपर होता है, तो मजबूत USD रेजिमेन्ट में EUR/USD के लिए एक छोटा प्रवेश करना एक अलग जोखिम प्रोफ़ाइल है जब यह पहले से ही कम ट्रेंड कर रहा होता है. विदेशी मुद्रा अंत बिंदु दैनिक समापन दरें प्रदान करता है जिसका उपयोग आप मूल मूल्य संदर्भ की गणना करने के लिए कर सकते हैं।

def fetch_spot_rates(base: str, quote: str, lookback_days: int = 200) -> pd.Series:
    """Fetch FX spot rate history and return as a date-indexed Series."""
    start = (date.today() - timedelta(days=lookback_days)).isoformat()
    resp = requests.get(
        f"{BASE_URL}/forex/{base}/{quote}",
        params={"api_key": API_KEY, "start": start},
        timeout=10,
    )
    resp.raise_for_status()
    data = resp.json().get("data", [])
    if not data:
        return pd.Series(dtype=float)
    df = pd.DataFrame(data).set_index("date").sort_index()
    return df["close"].astype(float)


spot = fetch_spot_rates("EUR", "USD")
sma50  = spot.rolling(50).mean()
sma200 = spot.rolling(200).mean()

latest_price  = spot.iloc[-1]
latest_sma50  = sma50.iloc[-1]
latest_sma200 = sma200.iloc[-1]

# Simple trend filter: is price above or below key moving averages?
price_trend = "bullish" if latest_price > latest_sma50 > latest_sma200 else (
              "bearish" if latest_price < latest_sma50 < latest_sma200 else "mixed")

print(f"EUR/USD latest: {latest_price:.5f}  SMA50: {latest_sma50:.5f}  SMA200: {latest_sma200:.5f}")
print(f"Price trend: {price_trend}")

चरण 5: रिलीज कैलेंडर की सदस्यता लें

एक खुली विदेशी मुद्रा स्थिति रखने के लिए सबसे खतरनाक समय एक प्रमुख निर्धारित रिलीज के आसपास 15 मिनट है। नीति दर निर्णय, सीपीआई प्रिंट और वेतन डेटा सभी 3080 पाइप अंतराल की क्षमता रखते हैं। एक अच्छी तरह से अनुशासित एल्गो इन खिड़कियों में नई स्थिति दर्ज करने से बचता है और वैकल्पिक रूप से मौजूदा बंद या हेज कर सकता है।

FXMacroData रिलीज़ कैलेंडर एंडपॉइंट प्रत्येक आगामी अनुसूचित रिलीज को इसके संकेतक नाम और अपेक्षित घोषणा तिथि के साथ लौटाता है, जिससे ब्लैकआउट शेड्यूलर बनाना आसान हो जाता हैः

from datetime import datetime, timezone

def fetch_upcoming_releases(currency: str, days_ahead: int = 14) -> list[dict]:
    """Return scheduled macro releases for a currency over the next N days."""
    resp = requests.get(
        f"{BASE_URL}/calendar/{currency}",
        params={"api_key": API_KEY},
        timeout=10,
    )
    resp.raise_for_status()
    events = resp.json().get("data", [])
    cutoff = datetime.now(timezone.utc) + timedelta(days=days_ahead)
    upcoming = []
    for evt in events:
        dt_str = evt.get("announcement_datetime") or evt.get("date")
        if not dt_str:
            continue
        try:
            evt_dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        except ValueError:
            continue
        if datetime.now(timezone.utc) <= evt_dt <= cutoff:
            upcoming.append(evt)
    return upcoming


HIGH_IMPACT = {"policy_rate", "inflation", "non_farm_payrolls", "unemployment", "gdp"}
BLACKOUT_MINUTES = 20  # minutes before/after release to block new entries


def is_in_blackout_window(releases: list[dict], now: datetime | None = None) -> bool:
    """Return True if the current moment falls inside any high-impact release window."""
    if now is None:
        now = datetime.now(timezone.utc)
    window = timedelta(minutes=BLACKOUT_MINUTES)
    for evt in releases:
        if evt.get("indicator") not in HIGH_IMPACT:
            continue
        dt_str = evt.get("announcement_datetime") or evt.get("date")
        if not dt_str:
            continue
        try:
            evt_dt = datetime.fromisoformat(dt_str.replace("Z", "+00:00"))
        except ValueError:
            continue
        if abs(now - evt_dt) <= window:
            return True
    return False


usd_releases = fetch_upcoming_releases("usd")
eur_releases = fetch_upcoming_releases("eur")
all_releases = usd_releases + eur_releases

print(f"Upcoming high-impact releases (next 14 days): {len(all_releases)}")
print(f"Currently in blackout window: {is_in_blackout_window(all_releases)}")

चरण 6: एक लाइव सिग्नल उत्पन्न करें

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

from dataclasses import dataclass
from typing import Literal


@dataclass
class Signal:
    direction: Literal["long", "short", "neutral"]
    confidence: float        # 0.0 → 1.0
    regime_spread: float     # positive → USD stronger
    price_trend: str
    in_blackout: bool
    reason: str


REGIME_THRESHOLD = 0.45   # minimum spread magnitude to take a position
TREND_CONFIRMATION = True  # require price trend to agree with regime signal


def generate_signal(
    regime_spread: float,
    price_trend:   str,
    releases:      list[dict],
) -> Signal:
    """
    Combine macro regime spread and price trend into a trade signal.

    regime_spread > 0  → USD stronger → short EUR/USD (quote currency up)
    regime_spread < 0  → EUR stronger → long  EUR/USD (base currency up)
    """
    in_blackout = is_in_blackout_window(releases)

    if in_blackout:
        return Signal("neutral", 0.0, regime_spread, price_trend, True,
                      "Blackout window: high-impact release imminent.")

    magnitude = abs(regime_spread)

    if magnitude < REGIME_THRESHOLD:
        return Signal("neutral", 0.0, regime_spread, price_trend, False,
                      f"Regime spread {regime_spread:+.3f} below threshold {REGIME_THRESHOLD}.")

    # Determine raw macro direction
    macro_dir = "short" if regime_spread > 0 else "long"

    # Price trend confirmation
    if TREND_CONFIRMATION:
        if macro_dir == "short" and price_trend == "bullish":
            return Signal("neutral", 0.20, regime_spread, price_trend, False,
                          "Macro bearish EUR/USD but price trend still bullish — wait for confirmation.")
        if macro_dir == "long" and price_trend == "bearish":
            return Signal("neutral", 0.20, regime_spread, price_trend, False,
                          "Macro bullish EUR/USD but price trend still bearish — wait for confirmation.")

    # Confidence scales with regime magnitude (capped at 0.90)
    confidence = min(0.90, magnitude / 1.5)

    return Signal(macro_dir, confidence, regime_spread, price_trend, False,
                  f"Macro {'USD' if macro_dir == 'short' else 'EUR'} outperformance confirmed by price trend.")


signal = generate_signal(regime_spread_full, price_trend, all_releases)
print(f"Signal: {signal.direction.upper()}  confidence: {signal.confidence:.0%}")
print(f"Reason: {signal.reason}")

चरण 7: जोखिम नियंत्रण और आकार की स्थिति लागू करें

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

@dataclass
class RiskConfig:
    account_equity:      float = 10_000.0   # USD
    risk_per_trade_pct:  float = 1.0        # percent of equity risked per trade
    stop_loss_pips:      float = 30.0       # maximum allowed loss in pips
    pip_value_per_lot:   float = 10.0       # USD per pip per standard lot (EUR/USD)
    max_lots:            float = 2.0        # hard cap on position size
    daily_loss_limit_pct: float = 3.0       # pause trading if daily loss exceeds this


def compute_position_size(signal: Signal, config: RiskConfig) -> float:
    """
    Return lot size based on risk per trade and stop-loss.
    Scales with signal confidence — higher confidence allows up to full risk.
    """
    if signal.direction == "neutral":
        return 0.0

    risk_amount = config.account_equity * (config.risk_per_trade_pct / 100)
    # Scale risk by confidence
    adjusted_risk = risk_amount * signal.confidence
    # Max loss per lot at this stop = stop_loss_pips * pip_value_per_lot
    max_loss_per_lot = config.stop_loss_pips * config.pip_value_per_lot
    if max_loss_per_lot == 0:
        return 0.0
    raw_lots = adjusted_risk / max_loss_per_lot
    return round(min(raw_lots, config.max_lots), 2)


risk   = RiskConfig()
lots   = compute_position_size(signal, risk)
dollar_risk = lots * risk.stop_loss_pips * risk.pip_value_per_lot

print(f"Recommended position: {lots} lots  ({signal.direction.upper()} EUR/USD)")
print(f"Max risk at {risk.stop_loss_pips}-pip stop: ${dollar_risk:.2f}")

चरण 8: सब कुछ एक साथ रखना दैनिक रणनीति लूप

अंतिम चरण एक निष्पादन लूप में सब कुछ इकट्ठा करता है जो प्रति दिन एक बार चलता है, सभी मैक्रो डेटा को ताज़ा करता है, संकेत का मूल्यांकन करता है , रिलीज कैलेंडर की जांच करता है और ऑर्डर सिफारिश करता है। एक लाइव वातावरण में, आप आउटपुट को एक ब्रोकर एपीआई या पेपर ट्रेडिंग सिस्टम से जोड़ेंगे; यहां हम इसे ब्रोकर्स-अज्ञेय रखते हैं और कंसोल को निर्णय लॉग करते हैं।

import logging
from datetime import date, datetime, timedelta, timezone

logging.basicConfig(level=logging.INFO, format="%(asctime)s  %(message)s")
log = logging.getLogger(__name__)


def run_daily_strategy():
    """Main strategy loop — call once per trading day."""
    log.info("─── Daily macro strategy update ───")

    # 1. Fetch macro data
    log.info("Fetching macro indicators...")
    usd_rate_data  = fetch_indicator("usd", "policy_rate")
    eur_rate_data  = fetch_indicator("eur", "policy_rate")
    usd_inf_data   = fetch_indicator("usd", "inflation")
    eur_inf_data   = fetch_indicator("eur", "inflation")
    usd_nfp_data   = fetch_indicator("usd", "non_farm_payrolls")
    usd_unemp_data = fetch_indicator("usd", "unemployment")
    usd_bond_data  = fetch_indicator("usd", "gov_bond_10y")
    eur_bond_data  = fetch_indicator("eur", "gov_bond_10y")

    # 2. Compute regime scores
    usd_emp    = employment_score(usd_nfp_data, usd_unemp_data)
    usd_s      = (
        0.35 * (rolling_zscore(usd_rate_data) or 0.0) +
        0.25 * (rolling_zscore(usd_inf_data) or 0.0) +
        0.25 * (rolling_zscore(usd_bond_data) or 0.0) +
        0.15 * usd_emp
    )
    eur_s = macro_score(eur_rate_data, eur_inf_data, eur_bond_data)
    spread = usd_s - eur_s
    log.info(f"USD score: {usd_s:+.3f}  EUR score: {eur_s:+.3f}  Spread: {spread:+.3f}")

    # 3. Fetch spot rates and compute trend
    log.info("Fetching spot rates...")
    spot_series = fetch_spot_rates("EUR", "USD")
    sma50_val   = spot_series.rolling(50).mean().iloc[-1] if len(spot_series) >= 50 else None
    sma200_val  = spot_series.rolling(200).mean().iloc[-1] if len(spot_series) >= 200 else None
    last_price  = spot_series.iloc[-1]
    trend = "mixed"
    if sma50_val and sma200_val:
        trend = ("bullish" if last_price > sma50_val > sma200_val else
                 "bearish" if last_price < sma50_val < sma200_val else "mixed")
    log.info(f"EUR/USD {last_price:.5f}  trend: {trend}")

    # 4. Fetch release calendar
    log.info("Fetching release calendars...")
    releases = fetch_upcoming_releases("usd") + fetch_upcoming_releases("eur")
    log.info(f"Upcoming events: {len(releases)}")

    # 5. Generate signal
    sig  = generate_signal(spread, trend, releases)
    lots = compute_position_size(sig, RiskConfig())
    log.info(f"Signal: {sig.direction.upper()}  confidence: {sig.confidence:.0%}  lots: {lots}")
    log.info(f"Reason: {sig.reason}")

    return sig, lots


if __name__ == "__main__":
    run_daily_strategy()

अगले कदम: रणनीति का विस्तार

ऊपर का ढांचा जानबूझकर दुबला है ताकि आप कच्चे डेटा से अंतिम आउटपुट तक हर निर्णय का पता लगा सकें। एक बार जब आप ऐतिहासिक डेटा पर तर्क को मान्य कर लेते हैं, तो कई प्राकृतिक एक्सटेंशन सिग्नल गुणवत्ता और निष्पादन मजबूती दोनों में सुधार करते हैंः

• अधिक मुद्राएँ जोड़ें समान संकेतक अंत बिंदुओं का उपयोग करके GBP, AUD, JPY या CAD तक विस्तारित करें। प्रत्येक एक नई जोड़ी और विचलन के अवसरों का एक नया सेट जोड़ता है। GBP नीति दर और एयूडी मुद्रास्फीति श्रृंखला एक ही डेटा अनुबंध का पालन करती है।
• सीओटी पोजिशनिंग डेटा जोड़ें CFTC COT रिपोर्ट से बड़े सट्टेबाजों की स्थिति एक उपयोगी भावना फिल्टर है। जब मैक्रो शासन कहता है कि लंबी USD लेकिन सट्टੇबाजी लंबी पहले से ही चरम हैं, एक नई प्रविष्टि का जोखिम / पुरस्कार कम है। FXMacroData उसी एपीआई के माध्यम से COT डेटा प्रदान करता है।
• ऐतिहासिक घोषणा के आंकड़ों के विरुद्ध बैकटेस्ट क्योंकि प्रत्येक FXMacroData अवलोकन एक announcement_datetime सेकंड तक सटीक, आप ठीक से पुनर्निर्माण कर सकते हैं कि बाजार किसी भी समय क्या जानता था और लुकहेड पूर्वाग्रह के बिना रणनीति प्रविष्टियों का अनुकरण कर सकता है।
• एक शेड्यूलर के साथ स्वचालित करें लपेटें run_daily_strategy() एक क्रॉन नौकरी या क्लाउड फ़ंक्शन में। विशिष्ट मैक्रो संकेतों को केवल प्रमुख डेटा रिलीज़ के बाद अपडेट करने की आवश्यकता होती है, इसलिए दैनिक या यहां तक कि साप्ताहिक ताज़ाकरण मध्यम अवधि की स्थिति के लिए पर्याप्त हैं।
• ब्रोकर एपीआई से कनेक्ट करें सिग्नल और लॉट आकार आउटपुट ब्रोकर-अज्ञेय हैं। direction और lots अपने पसंदीदा निष्पादन परत (OANDA v20, इंटरएक्टिव ब्रोकर TWS, या एक कागज-व्यापार सिम्युलेटर) में बाजार आदेशों को।

सारांश

मैक्रो सिग्नल किसी एल्गो के लिए सजावट नहीं हैं वे किनारे हैं। इस गाइड ने दिखाया कि कैसेः

1. एफएक्समैक्रोडाटा एपीआई से नीतिगत दरों, मुद्रास्फीति, रोजगार और बांड उपज को एक सुसंगत पैटर्न के साथ प्राप्त करें
2. Z-स्कोर सामान्यीकरण और भारित सूचक मिश्रण का उपयोग करके प्रत्येक मुद्रा के लिए एक मिश्रित शासन स्कोर की गणना करें
3. प्रवेश करने से पहले मैक्रो और तकनीकी समझौते की आवश्यकता के लिए विदेशी मुद्रा स्पॉट दर इतिहास से मूल्य प्रवृत्ति फ़िल्टर जोड़ें
4. एक साधारण ब्लैकआउट शेड्यूलर के साथ उच्च प्रभाव डेटा विंडो के शोर से बचने के लिए रिलीज कैलेंडर का उपयोग करें
5. फिक्स्ड-फ्रैक्शनल जोखिम मॉडल का उपयोग करके संकेत विश्वास और खाता स्वामित्व के अनुपात में स्थिति का आकार
6. एक ही दोहराया दैनिक पाश में सभी घटकों को इकट्ठा

पूर्ण स्रोत एक ही सत्र में अनुकूलित करने के लिए पर्याप्त कॉम्पैक्ट है। डेटा परत FXMacroData की लगातार संरचित, टाइमस्टैम्प-सटीक घोषणा श्रृंखला प्रत्येक संकेत को सत्यापित बाजार तथ्यों में जमी हुई रखने का भारी भार उठाती है।