צוואר הבקבוק במחקר כמותי: התאמת-יתר ובעיית שתי השפות
// מדוע אופטימיזציית אינדיקטורים נכשלת במבחני מציאות ומדוע שכתוב ידני ב-C# מחסל את גמישות הפיתוח
פיתוח אסטרטגיות מסחר כמותיות בשוק החוזים העתידיים סובל היסטורית משני צווארי בקבוק הנדסיים מרכזיים: התאמת-יתר סטטיסטית (Curve Fitting) ובעיית שתי השפות (The Two-Language Problem).
ראשית, תהליכי בדיקה מסורתיים לאחור (Backtesting) מתמקדים בשינוי אינסופי של פרמטרי כניסה באינדיקטורים (דוגמת כוונון אורכי ממוצעים נעים או מדדי RSI) עד שגרף הרווח ההיסטורי נראה מפתה. גישה זו מתאימה את האסטרטגיה לרעש אקראי ולא למבנה השוק, מה שמוביל לקריסתה ברגע שהיא מופעלת במסחר חי. כדי לבנות מודלים יציבים, על חוקרי נתונים להפסיק לבצע אופטימיזציית יתר לכניסות, ולהתמקד במציאת מסננים הגנתיים: חוקים מבניים המטילים וטו ומונעים עסקאות במשטר שוק עוין.
שנית, בעוד שמחקר כמותי פורח בפייתון (באמצעות ספריות NumPy, Pandas ו-SciPy), פלטפורמות ביצוע מתקדמות כמו NinjaTrader 8 דורשות קוד C# הרץ על .NET Framework 4.8. שכתוב ידני של אסטרטגיות מפייתון ל-C# אורך שבועות, מכניס שגיאות חישוב עדינות (הבדלים בחישובי נקודה צפה או אינדוקס נרות) ומעכב את הפריסה. הנדסנו את Smartush כדי לפתור את שני האתגרים: מנוע מחקר אוטונומי המגלה חוקי וטו הגנתיים ומהדר אותם ישירות לקוד C# NinjaScript מוכן לייצור בעזרת עצי תחביר מופשטים (AST).
- ▪חיסול התאמת-יתר על ידי הקפאת חוקי הכניסה ואימון אשכולות למידת מכונה לאיתור תנאי וטו הגנתיים.
- ▪פתרון ישיר לבעיית שתי השפות באמצעות מהדר AST אוטומטי המייצר מחלקות C# מאומתות תוך מילי-שניות.
- ▪יעילות זיכרון קיצונית בעזרת אפיק נתונים ללא העתקה (Zero-Copy) המשתף גיגה-בייטים של נתוני טיקים בין תהליכי מעבד מקבילים.
אפיק נתוני שוק ללא העתקה: פריסת סדרות עתירות נפח ואגרגציה רב-תקופתית
// קליטת טיקים גולמיים מבורסת ה-CME, סינתזת נרות דקה ו-N-טיקים, ואגרגציה לסדרות זמן גבוהות למיטוב ביצועים
בדיקת אלפי גרסאות אסטרטגיה על פני 10 שנות נתוני נרות של דקה וציטוטי טיק בחוזי הנאסד"ק (NQ) דורשת עיבוד מיליארדי נקודות מידע. בארכיטקטורות עיבוד מקבילי רגילות בפייתון (Multiprocessing), העברת טבלאות נתונים גדולות (DataFrames) בין תהליכים דורשת סריאליזציה כבדה (Pickle), המכפילה את צריכת הזיכרון וחונקת את רוחב הפס של המעבד.
כדי לעקוף צוואר בקבוק זה, Smartush מיישמת אפיק נתונים בזיכרון ללא העתקה (Zero-Copy Data Bus) המבוסס על חוצצי זיכרון משותף של פייתון (multiprocessing.shared_memory) ומערכים מובנים רציפים של NumPy. נתוני השוק ההיסטוריים (זמן, פתיחה, גבוה, נמוך, סגירה, נפח וכמות עסקאות) נטענים לזיכרון הפיזי המשותף פעם אחת בלבד בעת הפעלת המערכת.
מכיוון שהמערכת נשענת בבסיסה על נתוני טיקים גולמיים (Tick Data), היא מסוגלת לסנתז סדרות נרות אטומיות גמישות: החל מנרות דקה (1-Minute Bars), דרך נרות נפח, ועד נרות מבוססי טיקים בדידים (כגון גרף של 10 טיקים או 100 טיקים). מתוך סדרת הבסיס של נרות הדקה, אפיק הנתונים מפעיל צינור אגרגציה מובנה בזיכרון המאחד נרות דקה לסדרות זמן גבוהות יותר של 5 דקות, 10 דקות ו-60 דקות (נרות שעה).
בעולם האמיתי ובמונחי אופטימיזציה של מודלים כמותיים, ביצוע חישובים על גבי סדרות נרות גבוהות (כמו 5 או 10 דקות) עדיף במקרים רבים על פני חישוב בכל טיק בודד. אגרגציה לסדרות זמן גבוהות מסננת רעשי מיקרו-מבנה שוק אקראיים, מייצרת אינדיקטורים יציבים יותר מבחינה מתמטית, ומאיצה את קצב הבדיקות לאחור בסדרי גודל במהלך סריקת פרמטרים נרחבת. המערכת שומרת על דואליות מלאה: החוקר יכול לבצע בדיקות ברמת הטיק הבודד כאשר נדרשת רמת דיוק מרבית במילוי פקודות ושיהוי תוך-נרי, או להריץ את אלגוריתמי האשכול על גבי סדרות נרות מאוחדות (1m, 5m, 10m, 60m) לצורך אופטימיזציה מהירה של אסטרטגיות מאקרו.
אינדיקטורים טכניים (EMA, RSI, ATR, VWAP) מחושבים פעם אחת בלבד ברזולוציות הזמן הנדרשות באמצעות ספריות C ממוטבות (TA-Lib) וממופים ישירות לחוצץ המשותף. תהליכי העיבוד המקבילים מקבלים תצוגות זיכרון קריאה-בלבד ללא העתקת בייט בודד. ארכיטקטורה זו מצמצמת את צריכת הזיכרון הכוללת ביותר מ-80% ומאיצה את קצב הבדיקות לאחור פי 4.8 לעומת ארכיטקטורת עיבוד מקבילי סטנדרטית.
עיבוד מקבילי רגיל (סריאליזציית Pickle)
סריאליזציית טבלאות נתונים גדולות בין תהליכים סותמת את אפיקי הזיכרון ומפעילה שימוש כבד בזיכרון הווירטואלי בדיסק.
ריבוי תהליכונים באותו תהליך (GIL-Constrained)
למרות שהזיכרון משותף, מנעול ה-GIL של פייתון מבצע חישובים נומריים בזה אחר זה ומונע האצה אמיתית בריבוי ליבות.
אפיק זיכרון משותף ללא העתקה של Smartush
מערכי זיכרון משותפים מאפשרים לתהליכים מקבילים לקרוא מקטעי אינדיקטורים בו-זמנית ללא נעילות GIL וללא שכפול זיכרון.
טופולוגיית הקוד ומבנה צינור ההידור
// מאיסוף טיקים גולמיים ווקטוריזציה גיאומטרית ועד אשכולות הגנה ופליטת קוד C#
מאגר הקוד של Smartush מפריד באופן מוחלט בין מחקר כמותי אמפירי לבין הפקת קוד דטרמיניסטית. נתוני שוק גולמיים זורמים באופן ליניארי דרך וקטוריזציית מאפיינים, סימולציית בדיקה לאחור, אשכול תנאי שוק, ולבסוף סינתזת קוד.
כל רכיב עומד בחוזים מוגדרים: אפיק הנתונים חושף תצוגות זיכרון בלתי ניתנות לשינוי; מנוע הגיאומטריה מפיק תצלומי מצב וקטוריים; מנוע האשכולות מבודד יתרון סטטיסטי; והמהדר מתרגם לוגיקה מאומתת למחלקות NinjaScript ללא תלויות חיצוניות.
- 📁 quant-generator/# תיקיית הבסיס למחקר כמותי והידור קוד
- 📁 data_bus/# מנהל זיכרון משותף ואחסון סדרות עיתיות ללא העתקה
- 📄 shared_buffer.py# מקצה זיכרון משותף בסביבת POSIX ו-Windows
- 📄 indicator_cache.py# מאגר וקטורי אינדיקטורים מחושבים מראש ב-TA-Lib
- 📄 tick_normalizer.py# קליטת טיקים וסינתזת נרות דקה ו-N-טיקים
- 📄 bar_aggregator.py# אגרגציה היררכית של נרות דקה ל-5, 10 ו-60 דקות
- 📁 geometry/# חילוץ וקטורי של תנועות מחיר וגיאומטריית נרות
- 📄 candle_features.py# יחסי פתילות, התרחבות גוף נר ומדדי נפח
- 📄 vwap_bands.py# רצועות סטיית תקן של מחיר ממוצע משוקלל נפח (VWAP)
- 📄 snapshot_vectorizer.py# מחולל תצלומי מצב רב-תקופתיים של השוק
- 📁 clustering/# גילוי חוקי וטו הגנתיים ואשכול תנאי כשל
- 📄 loss_cohort_cluster.py# אשכול בלתי מונחה על עסקאות כושלות
- 📄 veto_scorer.py# מודל ניקוד פשטות וקנסות על התאמת-יתר
- 📄 recursive_gate.py# לולאת אימות רקורסיבית מחוץ למדגם
- 📁 compiler/# מפענח עצי תחביר (AST) ומחולל קוד C# NinjaScript
- 📄 ast_parser.py# פירוק חוקי אסטרטגיה בפייתון לעצי תחביר
- 📄 type_mapper.py# מיפוי טיפוסי פייתון לטיפוסי C# .NET
- 📄 csharp_emitter.py# סינתזה של מחלקות אסטרטגיה מלאות ב-NinjaTrader 8
- 📄 templates.py# תבניות קוד בסיס תקניות ב-NinjaScript
- 📁 tests/# בדיקות יחידה מקיפות ואימות תקינות מהדר
- 📄 test_ast_compiler.py# אימות התאמה מדויקת של קוד ה-C# המופק
- 📄 test_data_bus.py# בדיקות שלמות זיכרון ומניעת דליפות
וקטוריזציה של גיאומטריית נרות: תצלומי מצב טכניים רב-תקופתיים
// לכידת מצב השוק המלא ברגע הכניסה לעסקה כדי להבין מדוע עסקאות נכשלות
במקום להסתמך על איתות פשטני מאינדיקטור בודד, Smartush בונה תצלום מצב רב-ממדי מקיף של השוק בדיוק בחותמת הזמן שבה בוצעה כניסה מדומה לעסקה.
מנוע הגיאומטריה מחשב יחסי גוף נר לפתילות, תאוצת מומנטום על פני מרווחי זמן של 1 עד 30 נרות, סטיית תקן של נפח ביחס לממוצע, ומרחק מממוצעים נעים מרובי תקופות. בעת ביצוע עסקה מדומה, המערכת לוכדת וקטור קבוע של 48 פרמטרים מנורמלים.
תצלום מצב זה משמש בסיס לגילוי חוקי הגנה. על ידי התייחסות לכל עסקת עבר כתצפית אמפירית במרחב פרמטרים רב-ממדי, צינור למידת המכונה מסוגל לבודד במדויק את המאפיינים הגיאומטריים המקדימים עסקאות כושלות.
import numpy as np
from typing import NamedTuple
class CandleSnapshot(NamedTuple):
body_to_wick_ratio: float
upper_wick_percentage: float
volume_surge_factor: float
vwap_distance_atr_multiple: float
momentum_delta_5bar: float
momentum_delta_20bar: float
def extract_candle_geometry(opens: np.ndarray, highs: np.ndarray, lows: np.ndarray,
closes: np.ndarray, volumes: np.ndarray, vwap: np.ndarray,
idx: int) -> CandleSnapshot:
"""
Extracts a zero-allocation vectorized geometric snapshot of the market state
at bar index [idx] without generating intermediary Pandas objects.
"""
c_open, c_high, c_low, c_close = opens[idx], highs[idx], lows[idx], closes[idx]
c_vol = volumes[idx]
# Candle structural metrics
candle_range = max(c_high - c_low, 1e-6)
candle_body = abs(c_close - c_open)
upper_wick = c_high - max(c_open, c_close)
body_ratio = candle_body / candle_range
upper_wick_pct = upper_wick / candle_range
# 20-period rolling volume surge factor
lookback_start = max(0, idx - 20)
avg_vol = np.mean(volumes[lookback_start:idx]) if idx > 0 else c_vol
vol_surge = c_vol / max(avg_vol, 1.0)
# Price distance from session VWAP normalized by rolling 14-bar true range
tr = np.maximum(highs[lookback_start:idx] - lows[lookback_start:idx], 1e-6)
atr = np.mean(tr) if len(tr) > 0 else 1.0
vwap_dist = (c_close - vwap[idx]) / atr
# Multi-lookback momentum deltas
mom_5 = (c_close - closes[max(0, idx - 5)]) / c_close
mom_20 = (c_close - closes[max(0, idx - 20)]) / c_close
return CandleSnapshot(
body_to_wick_ratio=float(body_ratio),
upper_wick_percentage=float(upper_wick_pct),
volume_surge_factor=float(vol_surge),
vwap_distance_atr_multiple=float(vwap_dist),
momentum_delta_5bar=float(mom_5),
momentum_delta_20bar=float(mom_20)
)גילוי חוקי וטו הגנתיים: אשכול תנאי כשל מול ניחוש כניסות
// חיסול שיטתי של קבוצות עסקאות מפסידות באמצעות ניקוד מרובה פרמטרים ואימות רקורסיבי
הפילוסופיה המדעית העומדת בבסיס Smartush גורסת שמסחר אלגוריתמי רווחי אינו מושג על ידי גילוי איתותי כניסה מופלאים, אלא באמצעות ביטול שיטתי של עסקאות הנפתחות במשטר שוק רעיל מבחינה סטטיסטית.
מנוע האשכולות מנתח את כלל אוכלוסיית העסקאות שנוצרה על ידי חוק כניסה בסיסי ופשוט. הוא מבודד את כל העסקאות שהסתיימו בהפסד, ומפעיל אשכול מבוסס צפיפות על גבי תצלומי המצב הגיאומטריים של מועדי הכניסה. המנוע מזהה דפוסי כשל חוזרים: לדוגמה, זיהוי שעסקאות פריצה מסוג Long נכשלות ב-82% מהמקרים כאשר המומנטום ב-5 נרות חורג ב-3.2 סטיות תקן בעוד נפח המסחר נמוך מהממוצע.
כל חוק וטו מועמד מוערך באמצעות פונקציית כשירות המטילה קנס כבד על מורכבות יתר (מספר התנאים הלוגיים). אך ורק חוקים המציגים מובהקות סטטיסטית גבוהה ומשפרים את שורת הרווח במדגמי בדיקה עיוורים מאושרים לתהליך ההידור.
- ▪אשכול כשלים בלתי מונחה: קיבוץ אוטומטי של עסקאות מפסידות לזיהוי סביבות טכניות החוזרות על עצמן ופוגעות בביצועים.
- ▪פונקציית קנס על מורכבות: ניקוד פשטות (Parsimony) מתגמל תנאי אי-שוויון בסיסיים ופוסל שילובים שבירים ומרובי שכבות.
- ▪אימות רקורסיבי מחוץ למדגם: חוקי וטו מועמדים חייבים להוכיח צמצום משיכת הון עקבי במדגמים עיוורים לפני אישורם הסופי.
מהדר ה-AST האוניברסלי: הפרדת לוגיקת האסטרטגיה מפלטפורמת הביצוע
// סריקת עצי תחביר בפייתון, מיפוי סדרות רב-תקופתיות והפקת קוד מאומת ל-NinjaTrader, MetaTrader וממשקי API ייעודיים
לאחר שאסטרטגיית מסחר וחוקי הווטו ההגנתיים שלה אומתו מתמטית, פריסת המודל למסחר חי בשווקים דרשה בעבר ממתכנת לשכתב את האלגוריתם מחדש מאפס. שלב תרגום ידני זה יצר לעיתים קרובות פערי חישוב בלתי מורגשים (כגון שונות באינדוקס נרות או בדיוק נקודה צפה) ועיכב משמעותית את העלייה לאוויר.
מערכת Smartush מייתרת שכתובים ידניים באמצעות מהדר עצי תחביר מופשטים (AST) מודולרי. המהדר קולט את מפרט האסטרטגיה שנחקר בפייתון, מפרק אותו לעץ תחביר בזיכרון באמצעות ספריית ast, ומתרגם את המבנים הלוגיים, סדרות הנרות הרב-תקופתיות ותלויות האינדיקטורים לקוד טבעי של פלטפורמת היעד.
מכיוון שמנוע הפייתון בונה סדרות נרות ברזולוציות מרובות (כגון נרות דקה כבסיס לצד אגרגציות של 5, 10 ו-60 דקות, או גרפי N-טיקים), המהדר מפיק באופן אוטומטי את הגדרות מחזור החיים של סדרות אלו בקוד היעד. ב-NinjaScript, המהדר מייצר קריאות AddDataSeries() ומקשר אינדיקטורים לסדרות המשניות המתאימות (כגון BarsArray[1] או BarsArray[2]) ללא צורך בהגדרה ידנית של הגרפים.
חשוב מכך, ארכיטקטורת המהדר הינה אגנוסטית לפלטפורמה (Platform-Agnostic). בעוד ש-C# ו-NinjaTrader 8 שימשו כמנוע הפריסה המרכזי למסחר בחוזים עתידיים ומניות, ייצוג הביניים (AST) מנתק את הלוגיקה מסביבת ריצה ספציפית. בהינתן הבנת מודל הביצוע והמגבלות של פלטפורמת היעד, ניתן להרחיב את המהדר עם פולטי קוד (Emitters) נוספים עבור MetaTrader (בשפות MQL4/MQL5), שפת C++, או ממשקי REST ו-WebSocket ישירים של ברוקרים. תכנון זה מבטיח שאותה אסטרטגיה מדויקת, אותה אגרגציה רב-תקופתית ואותם חוקי וטו הגנתיים יוכלו לפעול בעקביות מלאה על פני מגוון רחב של נכסים (חוזים, מניות, מט"ח, קריפטו) ללא תלות במערכת בודדת.
import ast
from typing import List
class CSharpNinjaScriptEmitter(ast.NodeVisitor):
"""
Translates validated Python strategy AST nodes into production-ready
C# NinjaScript class code adhering to NinjaTrader 8 standards.
"""
def __init__(self, strategy_name: str, veto_rules: List[str]):
self.strategy_name = strategy_name
self.veto_rules = veto_rules
self.output_lines: List[str] = []
self._indent_level = 0
def emit(self, text: str):
indent = " " * self._indent_level
self.output_lines.append(f"{indent}{text}")
def generate_csharp_class(self) -> str:
self.emit("using System;")
self.emit("using NinjaTrader.NinjaScript;")
self.emit("using NinjaTrader.NinjaScript.Strategies;")
self.emit("using NinjaTrader.NinjaScript.Indicators;")
self.emit("")
self.emit("namespace NinjaTrader.NinjaScript.Strategies")
self.emit("{")
self._indent_level += 1
self.emit(f"public class {self.strategy_name} : Strategy")
self.emit("{")
self._indent_level += 1
# Indicator field declarations
self.emit("private EMA _fastEma;")
self.emit("private EMA _slowEma;")
self.emit("private ATR _atr;")
self.emit("private EMA _macroEma;")
self.emit("")
# OnStateChange lifecycle
self.emit("protected override void OnStateChange()")
self.emit("{")
self._indent_level += 1
self.emit("if (State == State.SetDefaults)")
self.emit("{")
self.emit(" Description = "Auto-generated by Smartush Quant Compiler";")
self.emit(" Name = "" + self.strategy_name + "";")
self.emit(" Calculate = Calculate.OnBarClose;")
self.emit(" EntriesPerDirection = 1;")
self.emit("}")
self.emit("else if (State == State.Configure)")
self.emit("{")
self.emit(" // Register multi-timeframe bar series synthesized from tick stream")
self.emit(" AddDataSeries(BarsPeriodType.Minute, 5); // 5-minute secondary bar series")
self.emit(" AddDataSeries(BarsPeriodType.Minute, 60); // 60-minute macro bar series")
self.emit("}")
self.emit("else if (State == State.DataLoaded)")
self.emit("{")
self.emit(" _fastEma = EMA(14);")
self.emit(" _slowEma = EMA(50);")
self.emit(" _atr = ATR(14);")
self.emit(" _macroEma = EMA(BarsArray[2], 20); // Computed on 60m aggregated series")
self.emit("}")
self._indent_level -= 1
self.emit("}")
self.emit("")
# OnBarUpdate with synthesized defensive veto gates
self.emit("protected override void OnBarUpdate()")
self.emit("{")
self._indent_level += 1
self.emit("if (CurrentBar < 50 || CurrentBars[1] < 20) return;")
self.emit("")
self.emit("// --- Automated Defensive Veto Gates ---")
for idx, rule in enumerate(self.veto_rules):
self.emit(f"bool vetoGate_{idx} = ({rule});")
self.emit(f"if (vetoGate_{idx}) return; // Suppress trade entry")
self.emit("")
self.emit("// --- Core Strategy Execution ---")
self.emit("if (CrossAbove(_fastEma, _slowEma, 1))")
self.emit("{")
self.emit(" EnterLong("LongEntry");")
self.emit("}")
self._indent_level -= 1
self.emit("}")
self._indent_level -= 1
self.emit("}")
self._indent_level -= 1
self.emit("}")
return "\n".join(self.output_lines)הפקת קוד NinjaScript לייצור ושערי בטיחות לפני שידור פקודות
// הבטחת עמידת קוד ה-C# בדרישות הבורסה, חלונות זמני מסחר ובקרת קצב ביצוע
הקוד המופק על ידי מהדר Smartush אינו רק סקריפט תיאורטי לבדיקות עבר; הוא מוקשח לחלוטין לפעילות מסחר אמיתית מול ברוקרים. המחלקות המופקות כוללות סריאליזציה מובנית של פרמטרים, הגדרות משתמש הניתנות לכיול דרך תכונות ייעודיות ב-NinjaScript (כגון [NinjaScriptProperty] ו-[Range]), ובדיקות בטיחות קפדניות.
לפני שמתודה כלשהי לשידור פקודה (EnterLong או EnterShort) מופעלת, קוד ה-NinjaScript מריץ שערי בטיחות ישירות בתוך פונקציית OnBarUpdate(). שערים אלו בודקים את תקרת ההפסד היומית המרבית, מוודאים שדרישות הביטחונות של הברוקר עומדות בתקן, ומוודאים ששעת המסחר הנוכחית נמצאת בחלון הזמנים המאושר.
על ידי הטמעת הלוגיקה האלגוריתמית וגבולות הסיכון ההגנתיים בתוך מחלקת C# יחידה ומאומתת, צינור הפריסה מבטיח התאמה מתמטית של 100% בין סביבת המחקר בפייתון לבין ביצוע המסחר החי בפועל.
- ▪מוכנות מיידית להידור: קבצי ה-cs. המופקים מתקמפלים ישירות בתוך NinjaTrader 8 ללא צורך בהתאמות תחביר ידניות או תלויות חסרות.
- ▪שערי בטיחות מוטמעים בקוד: בדיקות ביטחונות, סינון חלונות זמן ותנאי וטו דינמיים רצים באופן טבעי לפני שידור כל פקודה.
- ▪אפס סטיית ביצוע: התאמה מושלמת של נתוני הבדיקה לאחור להערכת הטיקים במסחר החי בדיוק של שבר עשרוני.
לקחים הנדסיים למערכות מחקר כמותי ומהדרים
// עקרונות ארכיטקטוניים מרכזיים לגישור בין סביבות מחקר מדעי לפלטפורמות ביצוע דטרמיניסטיות
גישור הפער בין מחקר כמותי מדעי לבין ביצוע דטרמיניסטי בעולם האמיתי מחייב תכנון תוכנה קפדני. אלו ארבעת עקרונות המפתח:
- ▪העדיפו חוקי וטו הגנתיים על פני אופטימיזציית כניסות: בידוד תנאי שוק הגורמים להפסדים מייצר עמידות גבוהה בהרבה במבחני אמת מאשר שינוי פרמטרי כניסה.
- ▪השתמשו בזיכרון משותף ללא העתקה לסדרות עיתיות: חוצצי זיכרון משותפים מחסלים צווארי בקבוק של סריאליזציה ומאיצים תהליכי בדיקה לאחור.
- ▪תמכו באגרגציית נרות רב-שכבתית מנתוני טיק: שמרו על דיוק טיקים מרבי לביצוע עסקאות, לצד בנייה דינמית של נרות דקה, 5, 10 ו-60 דקות למיטוב ביצועים וסינון רעשי שוק.
- ▪נתקו את לוגיקת האסטרטגיה מפלטפורמת הביצוע באמצעות מהדר AST אוניברסלי: פליטת קוד מייצוג ביניים מאפשרת לאותה אסטרטגיה ולסדרות הרב-תקופתיות שלה לפעול ב-NinjaTrader (ב-C#), ב-MetaTrader (ב-MQL) או בממשקי ברוקרים ללא שכתוב ידני.
- ▪הטמיעו שערי סיכון ישירות בקוד המופק: ודאו שהמודלים הכמותיים אוכפים את גבולות הבטיחות של עצמם ללא תלות ביציבות הפלטפורמה החיצונית.
מהנדסים מחקר כמותי אוטומטי או מהדרי קוד AST?
אנו בונים צנרות עיבוד סדרות עיתיות מהירות, מנועי אשכול וטו הגנתיים וסביבות ייצור אוטומטיות של קוד אסטרטגיות.