VWAP Experimental 17 replies
Vicky's Experimental Trade Journal 5 replies
Experimental Circle Analysis of EUR/USD 39 replies
experimental account 0 replies
Experimental Reports 5 replies
Experimental MT5 EA using Gemini Flash API - GeminiCommanderEA_v1
Disliked{quote} Sorry if I haven't replied. Happy to help out. Best to send me a message to my inbox. Are you talking about the 'very first post'?Ignored
Disliked{quote} V211 (Still Being Tested) Update... For those following, there is a bit to go with the FULL v211 update and while the release of the Streamlined version is out for public testing. Both are not perfect yet. Introduction of a new feature I came up with this idea watching the 'The Stein Paradox' YouTube video by Numberphile: {quote} Enhancing RSI Signals Using Mean Squared Error (MSE): A Conceptual and Practical Framework 1. Overview of the Idea In traditional technical analysis, the Relative Strength Index (RSI) is a momentum oscillator used...Ignored
# The value of a 0.0001 move for a 1-lot position value_per_point_lot = self.config.CONTRACT_SIZE * point_size # Example: 100,000 * 0.0001 = $10 # The stop distance in price (e.g., 0.0015) sl_dist = atr * self.config.SL_ATR_MULTIPLIER # THE FLAW: This multiplies two small numbers together risk_per_lot = sl_dist * value_per_point_lot # Example: 0.0015 * $10 = $0.015 (an incorrect, tiny risk)
Give the Gem a Name: A universal rule for the LLM to plan, generate, and implement software development tasks.
Instructions:
# Rule: Unified Development Workflow with Built-In Versioning
This rule defines how the LLM must plan, execute, and track software development tasks. It supports full traceability and correction of errors without relying on Git. All files, including plans and task lists, must be created and updated in the **user’s current working directory**, across **Linux, Windows, or macOS** systems.
---
## General Permissions
The LLM may:
- **Create, read, update, and annotate** any files required for task execution
- Maintain a **versioned change log** for every modified file and task
- Operate consistently across Linux, Windows, and macOS environments
- Use inline comments or dedicated metadata blocks for tracking changes
---
## Part 1: Create – Product Requirements Document (PRD)
### Goal
Convert a user instruction into a structured and actionable Product Requirements Document in Markdown.
### Process
1. **Receive Instruction**: User provides a task or change request.
2. **Ask Clarifying Questions**: Ensure all relevant details are gathered.
3. **Generate PRD**: Use the format below.
4. **Save PRD**: Save as `prd-[brief-summary].md` in the current directory.
### PRD Structure
1. **Overview**
2. **Goals**
3. **User Stories**
4. **Functional Requirements**
5. **Non-Goals**
6. **Design/UX (Optional)**
7. **Technical Constraints (Optional)**
8. **Success Metrics**
9. **Open Questions**
---
## Part 2: Generate – Task List from PRD
### Goal
Create a detailed, traceable task list that guides implementation step-by-step.
### Process
1. **Reference PRD**: Use the associated PRD.
2. **Generate Parent Tasks**: Based on the PRD requirements.
3. **Pause for User Confirmation**: Wait for "Go" before continuing.
4. **Generate Sub-Tasks**: Expand each parent task into executable sub-tasks.
5. **Track Version per Task**: Assign a version ID to each parent task using format `V1`, `V2`, etc.
6. **Save File**: Name as `tasks-[prd-name].md`.
### Task File Structure Example
## Task List – Version 1
## Use relevant file name types e.g. '.py', '.mq5' etc.
### Relevant Files
- `main_script.py` – core logic
- `test_main.py` – unit tests
---
### Tasks
- [ ] **1.0 Initialize Project** (`V1`)
- [ ] 1.1 Set up environment
- [ ] 1.2 Create initial files
- [ ] **2.0 Add Feature A** (`V1`)
- [ ] 2.1 Implement logic in `main_script.py`
- [ ] 2.2 Write test cases in `test_main.py`
- [ ] **3.0 Document Work** (`V1`)
- [ ] 3.1 Update PRD with final design
- [ ] 3.2 Add inline code documentation
Part 3: Execute and Track – Built-In Versioning
Goal
Track all work and changes without Git. Ensure tasks are tied to specific versions and can be traced if issues arise.
Execution & Tracking Rules
Each parent task must be versioned using V1, V2, etc.
Each file modified must include a version header block or inline metadata:
# --- LLM Version: V2 – Added Feature A (Task 2.0) ---
When a sub-task is completed:
Mark it [x]
Add or update version metadata in the relevant file(s)
Add an entry to the inline change log at the bottom of the task file:
### Change Log
- V2 (Task 2.0): Added feature A logic to `main_script.py`
- V1 (Task 1.0): Initialized project files
When the user requests a fix or correction:
The LLM must scan the task list and change log to locate the version/task where the change was introduced
Review the metadata and diffs in the relevant file(s)
Create a new version (e.g., V3) to apply the fix
Update both the file and the task list accordingly
Add a new change log entry and annotate the correction
Example:
- V3 (Correction to Task 2.0): Fixed error in feature A logic (`main_script.py`)
Versioned Correction Flow
User: "Fix error in Feature A"
↓
LLM identifies Feature A was added in Task 2.0 → V2
↓
Scans `main_script.py` for version tag: "# LLM Version: V2"
↓
Locates error and applies fix
↓
Creates new version: V3
↓
Updates:
- `main_script.py` with version V3 tag
- `tasks-[file].md` → new sub-task added
- Change log updated
Workflow Logic
User Instruction
↓
Is there a PRD? → No → Ask → Create PRD → Save
↓
Is there a Task List? → No → Create from PRD → Save
↓
Process Sub-tasks
↓
Mark Done → Add version metadata → Update change log
↓
Error Reported? → Yes → Locate Version → Apply Fix → Create New Version
## StepLLM Workflow
1. **PRD Creation**
- Ask questions
- Create PRD
- Save in same location
2. **Task Generation**
- Parse PRD
- Create tasks
- Assign versions
- Save
3. **Sub-task Execution**
- Implement step-by-step
- Mark complete
- Tag version
- Log changes
4. **Fixing Errors**
- Locate version via change log and metadata
- Apply fix
- Bump version
5. **File Operations**
- Modify files in working directory (cross-platform safe)
---
Example Workflow:
1. Find a Youtube Video with a strategy you want
2. Copy the URL into AI Studio and provide a good prompt to extract the strategy, I always turn on the search toggle.
QuoteDislikedAnalyse the video and extract as much detail about the strategy for a junior developer to reproduce this. Ensure you list all the technical details, parameters etc. Complete any missing information by making assumptions based on the video context and research.
Timeframes Used
Technical Details and Parameters: A 6-Step Checklist
Here is the step-by-step process with technical parameters for a developer:
1. Identify Zones (on 1H or 4H chart):
2. Confirm the Breakout:
3. Drop to the 1-Minute Chart for Entry Confirmation:
4. Entry:
5. Stop Loss:
6. Take Profit:
Performance and Risk Management
The video provides backtested analytics for the month of April 2025 trading Dow Jones Futures (YM), which reveals the strategy's statistical profile:
For a junior developer, this means the algorithm should be designed to capture wins that are, on average, at least three times larger than the losses. Even with a win rate below 50%, this positive risk-to-reward ratio ensures long-term profitability.
4. IF you were to 'copy and paste' the response into Gemini I have also attached the screen shots.
Using my custom Gem I'll get the output:
Of course. Here is the Product Requirements Document (PRD) for the MQL5 Expert Advisor.
prd-boring-break-retest-ea.md
# Product Requirements Document: MQL5 Boring Break and Retest EA
---
## 1. Overview
This document outlines the requirements for an MQL5 Expert Advisor (EA) that automates the "Boring Break and Retest" trading strategy. The EA will identify significant support and resistance levels on higher timeframes (1H/4H), wait for a confirmed price breakout, and then manage trade entries and exits on the 1-minute timeframe after a retest of the broken level. The core profitability driver is a high risk-to-reward ratio.
## 2. Goals
- To create a fully automated trading robot that executes the break and retest strategy on the MetaTrader 5 platform.
- To accurately identify and draw support/resistance zones based on candlestick structure.
- To ensure valid breakouts are confirmed by a full candlestick body close outside the zone.
- To execute entries on the 1-minute chart based on clear, low-risk confirmation patterns.
- To implement a dynamic stop-loss and take-profit mechanism based on price structure.
- To achieve a target risk-to-reward ratio of approximately 3:1.
## 3. User Stories
- **As a trader, I want** the EA to automatically analyze the 1-hour or 4-hour chart to find and draw the most recent, significant support and resistance zones.
- **As a trader, I want** the EA to monitor for a confirmed breakout of a zone, so I don't have to watch the charts constantly.
- **As a trader, I want** the EA, after a breakout, to switch its focus to the 1-minute chart and patiently wait for the price to retest the broken zone.
- **As a trader, I want** the EA to automatically enter a trade with a precise stop loss and take profit once a valid entry pattern forms on the 1-minute chart.
- **As a trader, I want** to be able to see the EA's activity visually on the chart, including the zones, entry point, stop loss, and take profit levels.
## 4. Functional Requirements
### 4.1. Zone Identification (1H/4H)
- The EA must allow the user to select the primary analysis timeframe (`TF_Analysis`) from an input parameter (either `PERIOD_H1` or `PERIOD_H4`).
- The EA will identify the most recent, significant support and resistance zones on the `TF_Analysis` chart.
- **Resistance Zone Definition**: The zone is a rectangle where the top is the highest wick and the bottom is the body of the highest candlestick in the resistance area.
- **Support Zone Definition**: The zone is a rectangle where the bottom is the lowest wick and the top is the body of the lowest candlestick in the support area.
- The identified zones shall be drawn on the chart as colored rectangles.
### 4.2. Breakout Confirmation (1H/4H)
- A valid breakout is confirmed only when a candlestick on `TF_Analysis` closes completely outside the zone.
- **Buy Breakout**: A candle body must close fully above the resistance zone.
- **Sell Breakout**: A candle body must close fully below the support zone.
- A wick piercing the zone is not a valid signal.
### 4.3. Entry Logic (1M)
- Following a confirmed breakout, the EA must switch to monitoring the 1-minute (`PERIOD_M1`) chart for a pullback to the broken zone.
- The EA must be programmed to identify one of the following confirmation patterns on the 1M chart during the retest:
1. **Consolidation Break**: Entry on the break of a tight sideways range.
2. **Market Structure Shift**:
- **Buy Entry**: Enter after the price forms a higher low and then breaks the subsequent high.
- **Sell Entry**: Enter after the price forms a lower high and then breaks the subsequent low.
3. **Trendline Break**: Entry on the break of a clear, short-term pullback trendline.
- The EA will place a market order once one of these conditions is met.
### 4.4. Trade and Risk Management
- **Stop Loss**:
- For a **buy trade**, the stop loss must be placed below the most recent swing low (higher low) on the 1M chart.
- For a **sell trade**, the stop loss must be placed above the most recent swing high (lower high) on the 1M chart.
- **Take Profit**:
- The take profit target is determined on the `TF_Analysis` chart.
- For a **buy trade**, the target is the next significant resistance level or key high.
- For a **sell trade**, the target is the next significant support level or key low.
- **Position Sizing**: The EA will have an input for `LotSize`.
## 5. Non-Goals
- The EA will not use any standard technical indicators (e.g., RSI, MACD, Moving Averages).
- The EA will only manage one trade at a time for a given instrument.
- The EA will not include news filters or be designed to avoid trading during high-impact news events.
## 6. Design/UX (Optional)
- **Inputs**: The EA should provide user-configurable inputs for `TF_Analysis`, `LotSize`, `MagicNumber`, and colors for the drawn zones.
- **Visuals**: The EA must draw and remove chart objects (zones, entry/SL/TP lines) cleanly, without cluttering the chart.
- **Status Display**: A simple on-chart display should indicate the EA's current state (e.g., "Searching for Zone", "Monitoring for Breakout", "Waiting for Retest", "Trade Active").
## 7. Technical Constraints
- **Language**: MQL5
- **Platform**: MetaTrader 5
- The EA must efficiently handle multi-timeframe data requests without slowing down the platform.
## 8. Success Metrics
- The primary metric is achieving a risk-to-reward ratio of approximately 3:1 on average.
- The EA's backtesting results should demonstrate profitability over a statistically significant number of trades, even with a win rate below 50%.
- The EA must reliably follow the logic outlined in the functional requirements without errors.
## 9. Open Questions
- **Zone Significance**: How do we programmatically define a "significant" zone? Should the number of historical price reactions be a configurable input (`MinZoneTouches`)?
- **Take Profit Target**: How is the "next key high/low" for the take-profit target determined programmatically? (e.g., highest high/lowest low over the last 'X' bars on `TF_Analysis`?).
- **Pattern Definition**: The 1M entry patterns (consolidation, trendline) need to be defined with precise, non-ambiguous rules to be coded effectively. How are the boundaries of a "tight range" or the angle of a "clear trendline" quantified? // --- LLM Version: V1 – Added Visuals & Final Comments (Tasks 6.0 & 7.0) ---
// --- LLM Version: V1 – Added Trade & Risk Management (Task 5.0) ---
// --- LLM Version: V1 – Added 1M Retest & Entry Logic (Task 4.0) ---
// --- LLM Version: V1 – Added Breakout Detection (Task 3.0) ---
// --- LLM Version: V1 – Added Zone Identification (Task 2.0) ---
// --- LLM Version: V1 – Initialized Project (Task 1.0) ---
#property copyright "LLM Generated"
#property link "https://google.com"
#property version "1.00"
#property description "EA based on the Boring Break and Retest Strategy. This EA identifies S/R zones on a higher timeframe, waits for a breakout, then looks for a 1M entry pattern on a retest."
#include <Trade\Trade.mqh>
//--- User Input Parameters
input ENUM_TIMEFRAMES TF_Analysis = PERIOD_H1; // Timeframe for Zone Analysis
input double LotSize = 0.01; // Fixed Lot Size for trades
input ulong MagicNumber = 1337; // EA's unique trade identifier
input int ZoneLookback = 100; // Bars to lookback for finding zones
input int SwingLookback = 10; // Bars to lookback for 1M swing points
input int SL_Padding_Pips = 2; // Extra pips to add to Stop Loss
//--- Data Structure for a Price Zone
struct Zone
{
string name; // Chart object name
double top_price; // Highest price point of the zone
double bottom_price; // Lowest price point of the zone
bool is_resistance; // True if it's a resistance zone, false for support
bool is_broken; // Flag to indicate if the zone has been broken
};
//--- Global Variables
CTrade trade;
Zone SupportZone;
Zone ResistanceZone;
const string SupportZoneName = "SupportZone";
const string ResistanceZoneName = "ResistanceZone";
const string EntryLineName = "EntryLine";
const string SL_LineName = "SL_Line";
const string TP_LineName = "TP_Line";
//--- State Management
string EA_Status = "Initializing...";
bool IsInBreakoutMode = false;
bool IsRetestConfirmed = false;
double EntryStructurePoint = 0; // The high/low to break for entry
// Forward declarations
void findAndDrawZones();
void drawZone(const Zone& zone);
void checkForBreakout();
void manageRetestAndEntry();
void resetEAState();
void executeTrade(ENUM_ORDER_TYPE orderType);
double getStopLoss(ENUM_ORDER_TYPE orderType);
double getTakeProfit(ENUM_ORDER_TYPE orderType);
void updateOnChartDisplay();
void clearTradeLines();
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
Print("Boring Break and Retest EA Initialized.");
trade.SetExpertMagicNumber(MagicNumber);
trade.SetTypeFillingBySymbol(_Symbol);
resetEAState();
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
Print("Boring Break and Retest EA Deinitialized. Reason: ", reason);
// Clean up all chart objects
ObjectDelete(0, SupportZoneName);
ObjectDelete(0, ResistanceZoneName);
clearTradeLines();
Comment(""); // Clear the status comment
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
// Always update the chart display
updateOnChartDisplay();
// Do not run main logic if a trade is already open for this EA
if(PositionsTotal() > 0)
{
EA_Status = "Position is open. Monitoring.";
return;
}
if(!IsInBreakoutMode)
{
EA_Status = "Searching for breakout on " + EnumToString(TF_Analysis);
findAndDrawZones();
checkForBreakout();
}
else
{
manageRetestAndEntry();
}
}
//+------------------------------------------------------------------+
//| Executes a trade with calculated SL and TP. |
//+------------------------------------------------------------------+
void executeTrade(ENUM_ORDER_TYPE orderType)
{
if(PositionsTotal() > 0) return;
double price = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
double sl = getStopLoss(orderType);
double tp = getTakeProfit(orderType);
if(sl == 0 || tp == 0)
{
Print("Invalid SL or TP calculated. Aborting trade.");
resetEAState();
return;
}
// Draw lines before placing trade for visual confirmation
ObjectCreate(0, EntryLineName, OBJ_HLINE, 0, 0, price);
ObjectSetInteger(0, EntryLineName, OBJPROP_COLOR, clrGreen);
ObjectSetInteger(0, EntryLineName, OBJPROP_STYLE, STYLE_DOT);
ObjectCreate(0, SL_LineName, OBJ_HLINE, 0, 0, sl);
ObjectSetInteger(0, SL_LineName, OBJPROP_COLOR, clrRed);
ObjectSetInteger(0, SL_LineName, OBJPROP_STYLE, STYLE_DOT);
ObjectCreate(0, TP_LineName, OBJ_HLINE, 0, 0, tp);
ObjectSetInteger(0, TP_LineName, OBJPROP_COLOR, clrBlue);
ObjectSetInteger(0, TP_LineName, OBJPROP_STYLE, STYLE_DOT);
bool result = false;
if(orderType == ORDER_TYPE_BUY)
{
result = trade.Buy(LotSize, _Symbol, price, sl, tp, "LLM B&R Buy");
}
else if(orderType == ORDER_TYPE_SELL)
{
result = trade.Sell(LotSize, _Symbol, price, sl, tp, "LLM B&R Sell");
}
if(result)
{
Print("Trade executed successfully: ", EnumToString(orderType), " @ ", price, " | SL: ", sl, " | TP: ", tp);
}
else
{
Print("Trade execution failed. Error: ", trade.ResultRetcode(), " - ", trade.ResultRetcodeDescription());
clearTradeLines(); // Clean up lines if trade fails
}
resetEAState();
}
//+------------------------------------------------------------------+
//| Calculates the Stop Loss based on recent 1M price structure. |
//+------------------------------------------------------------------+
double getStopLoss(ENUM_ORDER_TYPE orderType)
{
MqlRates m1_rates[];
if(CopyRates(_Symbol, PERIOD_M1, 0, SwingLookback, m1_rates) < SwingLookback) return 0;
double sl = 0;
double padding = SL_Padding_Pips * _Point * 10;
if(orderType == ORDER_TYPE_BUY)
{
int low_idx = ArrayMinimum(m1_rates, WHOLE_ARRAY, 0, SwingLookback);
sl = m1_rates[low_idx].low - padding;
}
else
{
int high_idx = ArrayMaximum(m1_rates, WHOLE_ARRAY, 0, SwingLookback);
sl = m1_rates[high_idx].high + padding;
}
return NormalizeDouble(sl, _Digits);
}
//+------------------------------------------------------------------+
//| Calculates Take Profit based on the next H1/H4 key level. |
//+------------------------------------------------------------------+
double getTakeProfit(ENUM_ORDER_TYPE orderType)
{
MqlRates htf_rates[];
if(CopyRates(_Symbol, TF_Analysis, 0, ZoneLookback, htf_rates) < ZoneLookback) return 0;
double tp = 0;
if(orderType == ORDER_TYPE_BUY)
{
int high_idx = ArrayMaximum(htf_rates, WHOLE_ARRAY, 0, ZoneLookback);
tp = htf_rates[high_idx].high;
}
else
{
int low_idx = ArrayMinimum(htf_rates, WHOLE_ARRAY, 0, ZoneLookback);
tp = htf_rates[low_idx].low;
}
return NormalizeDouble(tp, _Digits);
}
//+------------------------------------------------------------------+
//| Manages the logic after a breakout has occurred. |
//+------------------------------------------------------------------+
void manageRetestAndEntry()
{
MqlTick latest_tick;
SymbolInfoTick(_Symbol, latest_tick);
Zone broken_zone = ResistanceZone.is_broken ? ResistanceZone : SupportZone;
if(!IsRetestConfirmed)
{
EA_Status = "Waiting for retest of broken zone...";
if(broken_zone.is_resistance && latest_tick.ask <= broken_zone.top_price)
{
IsRetestConfirmed = true;
}
else if(!broken_zone.is_resistance && latest_tick.bid >= broken_zone.bottom_price)
{
IsRetestConfirmed = true;
}
return;
}
EA_Status = "Retest confirmed. Looking for 1M entry pattern...";
MqlRates m1_rates[];
if(CopyRates(_Symbol, PERIOD_M1, 0, SwingLookback * 2, m1_rates) < SwingLookback * 2) return;
if(broken_zone.is_resistance)
{
int retest_low_idx = ArrayMinimum(m1_rates, WHOLE_ARRAY, 1, SwingLookback);
int entry_high_idx = ArrayMaximum(m1_rates, WHOLE_ARRAY, 1, retest_low_idx);
EntryStructurePoint = m1_rates[entry_high_idx].high;
if(EntryStructurePoint > 0 && latest_tick.ask > EntryStructurePoint)
{
executeTrade(ORDER_TYPE_BUY);
}
}
else
{
int retest_high_idx = ArrayMaximum(m1_rates, WHOLE_ARRAY, 1, SwingLookback);
int entry_low_idx = ArrayMinimum(m1_rates, WHOLE_ARRAY, 1, retest_high_idx);
EntryStructurePoint = m1_rates[entry_low_idx].low;
if(EntryStructurePoint > 0 && latest_tick.bid < EntryStructurePoint)
{
executeTrade(ORDER_TYPE_SELL);
}
}
}
//+------------------------------------------------------------------+
//| Resets all state variables to search for a new setup. |
//+------------------------------------------------------------------+
void resetEAState()
{
IsInBreakoutMode = false;
IsRetestConfirmed = false;
SupportZone.is_broken = false;
ResistanceZone.is_broken = false;
EntryStructurePoint = 0;
clearTradeLines();
Print("EA state has been reset. Searching for new setups.");
}
//+------------------------------------------------------------------+
//| Checks for a breakout of the current S/R zones. |
//+------------------------------------------------------------------+
void checkForBreakout()
{
MqlRates rates[];
if(CopyRates(_Symbol, TF_Analysis, 0, 1, rates) < 1) return;
MqlRates lastBar = rates[0];
if(ResistanceZone.top_price > 0 && !ResistanceZone.is_broken)
{
if(lastBar.close > ResistanceZone.top_price)
{
ResistanceZone.is_broken = true;
IsInBreakoutMode = true;
Print("Resistance Zone broken at ", ResistanceZone.top_price, ". Waiting for retest.");
ObjectSetInteger(0, ResistanceZone.name, OBJPROP_COLOR, clrDarkGray);
}
}
if(SupportZone.bottom_price > 0 && !SupportZone.is_broken)
{
if(lastBar.close < SupportZone.bottom_price)
{
SupportZone.is_broken = true;
IsInBreakoutMode = true;
Print("Support Zone broken at ", SupportZone.bottom_price, ". Waiting for retest.");
ObjectSetInteger(0, SupportZone.name, OBJPROP_COLOR, clrDarkGray);
}
}
}
//+------------------------------------------------------------------+
//| Finds and draws the most recent S/R zones. |
//+------------------------------------------------------------------+
void findAndDrawZones()
{
MqlRates rates[];
if(CopyRates(_Symbol, TF_Analysis, 1, ZoneLookback, rates) < ZoneLookback) return;
int highest_idx = ArrayMaximum(rates, WHOLE_ARRAY, 0, ZoneLookback);
int lowest_idx = ArrayMinimum(rates, WHOLE_ARRAY, 0, ZoneLookback);
ResistanceZone.is_resistance = true;
ResistanceZone.top_price = rates[highest_idx].high;
ResistanceZone.bottom_price = MathMax(rates[highest_idx].open, rates[highest_idx].close);
SupportZone.is_resistance = false;
SupportZone.bottom_price = rates[lowest_idx].low;
SupportZone.top_price = MathMin(rates[lowest_idx].open, rates[lowest_idx].close);
drawZone(ResistanceZone);
drawZone(SupportZone);
}
//+------------------------------------------------------------------+
//| Draws a rectangle object for a given zone. |
//+------------------------------------------------------------------+
void drawZone(const Zone& zone)
{
if(ObjectFind(0, zone.name) < 0)
{
ObjectCreate(0, zone.name, OBJ_RECTANGLE, 0, 0, 0);
ObjectSetInteger(0, zone.name, OBJPROP_FILLING, true);
ObjectSetInteger(0, zone.name, OBJPROP_BACK, true);
ObjectSetInteger(0, zone.name, OBJPROP_SELECTABLE, false);
}
color zone_color = zone.is_resistance ? clrIndianRed : clrCornflowerBlue;
ObjectSetInteger(0, zone.name, OBJPROP_COLOR, zone_color);
ObjectSetDouble(0, zone.name, OBJPROP_PRICE1, zone.top_price);
ObjectSetDouble(0, zone.name, OBJPROP_PRICE2, zone.bottom_price);
ObjectSetInteger(0, zone.name, OBJPROP_TIME1, TimeCurrent() - PeriodSeconds() * 5);
ObjectSetInteger(0, zone.name, OBJPROP_TIME2, TimeCurrent() + PeriodSeconds() * 20);
}
//+------------------------------------------------------------------+
//| Updates the on-chart comment with the EA's current status. |
//+------------------------------------------------------------------+
void updateOnChartDisplay()
{
string comment = "Boring Break & Retest EA | V1.0\n";
comment += "Status: " + EA_Status;
Comment(comment);
}
//+------------------------------------------------------------------+
//| Clears the SL/TP/Entry lines from the chart. |
//+------------------------------------------------------------------+
void clearTradeLines()
{
ObjectDelete(0, EntryLineName);
ObjectDelete(0, SL_LineName);
ObjectDelete(0, TP_LineName);
}
//+------------------------------------------------------------------+ 
Disliked{quote} Flawed Logic = 'No Trades' During Forward Testing? We may have solved the "zero trades" mystery. The problem is not the model; it's a clear mathematical error in the position sizing logic. Diagnosis: The "Phantom Trade" Mystery Solved I updated the framework to log the forward testing and log messages are filled with: DEBUG - ... - Trade REJECTED at execution: Insufficient margin (needed 49772465.57) This maybe the smoking gun. The framework is attempting to open trades but requires an impossible amount of margin (~$49 million) on a $10,000...Ignored
Disliked{quote} No Trades Fixed So it's been at least 2 weeks (I think) and the no trades has finally been solved! 2025-07-03 16:23:39,551 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:5640 - Cycle 1/13: Completed. PNL: -1548.00, Trades: 24 2025-07-03 16:23:39,552 - WARNING - AxiomEdge_PRO_V211_STREAMLINED.py:5210 - ! STATE CHANGE ! Circuit breaker tripped. Moving to DRAWDOWN_CONTROL. Still a lot of testing to get through but there is finally progress.Ignored
1.2. Feature Selection & Reduction
2. Feature Engineering (FeatureEngineer)
The feature engineering process has been significantly overhauled to generate the multiple labels required by the new architecture and to introduce new, more sophisticated features.
2.1. Multi-Task Label Generation
2.2. New Features
3. Model Training (ModelTrainer)
The training module was rewritten to manage the new multi-task architecture.
4. Backtesting (Backtester)
The backtesting engine has been upgraded to implement the new confluence-based trade execution logic.
5. AI & Orchestration
The interaction with the Gemini AI and the overall run orchestration have been enhanced to be more intelligent and proactive.
5.1. AI-Driven Alpha Discovery
5.2. AI Intervention & Prompts
STREAMLINED NO TRADES FIX
Anyone who hasn't managed to fix the no trades previously should follow the below:
Correcting the Position Sizing Formula
The correct way to calculate the dollar risk for a 1-lot position is to multiply the stop distance directly by the contract size.
Correct the Backtester.run_backtest_chunk method. This should be the last fix required to get the framework fully operational.
In class Backtester:
# In class Backtester:
def run_backtest_chunk(self, df_chunk_in: pd.DataFrame, pipelines: Union[Pipeline, Dict[str, Any]], initial_equity: float, feature_list: List[str], confidence_threshold: float, trade_lockout_until: Optional[pd.Timestamp] = None, is_minirocket_model: bool = False, cycle_label: str = "N/A") -> Tuple[pd.DataFrame, pd.Series, bool, Optional[Dict], Dict]:
# ... (initial part of the function is the same) ...
attempt_logger = BacktestLogger(cycle_label)
for i in range(start_index, len(candles_as_dicts)):
current_candle, prev_candle = candles_as_dicts[i], candles_as_dicts[i-1]
# ... (loop logic) ...
if not circuit_breaker_tripped and not is_locked_out_by_time and symbol not in open_positions and len(open_positions) < max_trades:
# ... (prediction logic) ...
if confidence >= confidence_threshold:
# ... (initial filter checks are the same) ...
# --- CORRECTED RISK CALCULATION ---
sl_dist = atr * self.config.SL_ATR_MULTIPLIER
risk_usd = equity * risk_pct
# Correctly calculate the dollar risk for a 1.0 lot position
risk_per_lot = sl_dist * self.config.CONTRACT_SIZE
if risk_per_lot <= 1e-9:
if LOG_TRADE_ATTEMPTS: logger.debug(f"Trade REJECTED at execution: Invalid risk_per_lot ({risk_per_lot})")
continue
# Correctly calculate the lot size based on accurate risk
lot_size = round((risk_usd / risk_per_lot) / self.config.LOT_STEP) * self.config.LOT_STEP
lot_size = max(lot_size, self.config.MIN_LOT_SIZE)
spread, slippage = self._calculate_realistic_costs(prev_candle)
latency_cost = self._calculate_latency_cost(prev_candle, current_candle)
entry_price = current_candle['Open'] + (spread + slippage + latency_cost) * direction
sl_price = entry_price - sl_dist * direction
tp_price = entry_price + sl_dist * self.config.TP_ATR_MULTIPLIER * direction
# --- END OF CORRECTION ---
margin_needed = (lot_size * self.config.CONTRACT_SIZE * entry_price) / self.config.LEVERAGE
if equity - sum(p.get('margin_used', 0) for p in open_positions.values()) < margin_needed:
if LOG_TRADE_ATTEMPTS: logger.debug(f"Trade REJECTED at execution: Insufficient margin (needed {margin_needed:.2f})")
continue
# If all checks pass, we officially open the trade
open_positions[symbol] = {'symbol': symbol, 'direction': direction, 'entry_price': entry_price, 'sl': sl_price, 'tp': tp_price,
'confidence': confidence, 'lot_size': lot_size, 'margin_used': margin_needed,
'mfe_price': entry_price, 'mae_price': entry_price, 'entry_candle_timestamp': current_ts}
logger.info(f"Opened {'Long' if direction == 1 else 'Short'} for {symbol} at {entry_price:.5f} | Lots: {lot_size:.2f} | SL: {sl_price:.5f} | TP: {tp_price:.5f}")
# ... (rest of the function is the same) ... DislikedV211 STREAMLINED (coming soon) I finally have this version providing profitable trades during the forward testing without 'circuit breaking' (the final KPI) which means it works as indented. (so far no bugs after a few runs) I did need to change the STREAMLINED version to allow for multi-assets, not just forex and indices which took a bit to ensure that handled these correctly. I have integrated Gemini AI a lot more into the management of the framework which I think is why the results now are on-par with my expectations. For the clever developers...Ignored
Remember that running this framework once isn't enough, it will take multiple runs for the framework to 'learn' and 'develop' more complex strategies overtime.
+----------------------------------------------------------------------------------------+
| II. EXECUTIVE SUMMARY
+----------------------------------------------------------------------------------------+
| Initial Capital: $ 10,000.00
| Ending Capital: $ 138,434.88
| Total Net Profit: $ 128,434.88 (1284.35%)
| Profit Factor: 1.92
| Win Rate (Full Trades): 56.11%
| Expected Payoff: $ 33.36
+----------------------------------------------------------------------------------------+
| III. CORE PERFORMANCE METRICS
+----------------------------------------------------------------------------------------+
| Annual Return (CAGR): 126.18%
| Sharpe Ratio (annual): $ 1.36
| Sortino Ratio (annual): $ 0.53
| Calmar Ratio / MAR: $ 2.42
+----------------------------------------------------------------------------------------+
| IV. RISK & DRAWDOWN ANALYSIS
+----------------------------------------------------------------------------------------+
| Max Drawdown (Cycle): 52.25% ($15,573.67)
| Recovery Factor: $ 8.25
| Longest Losing Streak: 48 trades
+----------------------------------------------------------------------------------------+
| V. TRADE-LEVEL STATISTICS
+----------------------------------------------------------------------------------------+
| Total Unique Trades: 3864
| Total Trade Events (incl. partials): 3872
| Average Win Event: $ 123.53
| Average Loss Event: $ 81.80
| Payoff Ratio (Full Trades): $ 1.51
+----------------------------------------------------------------------------------------+
Disliked{quote} Thank God you are here! I mean the condition on long position (based on your lastest or best strategy after all). I want to write the code about it to do some tests on Trading View.Ignored
Disliked{quote} Framework V211 STREAMLINED AxiomEdge_PRO_V211_STREAMLINED.py.txt Action-Biased Baseline_V211_BreakoutVolumeSpike_20250708-023510_run.log.txt Remember that running this framework once isn't enough, it will take multiple runs for the framework to 'learn' and 'develop' more complex strategies overtime. +----------------------------------------------------------------------------------------+ | II. EXECUTIVE SUMMARY +----------------------------------------------------------------------------------------+ | Initial Capital: $ 10,000.00 | Ending...Ignored
Disliked{quote} This strategy seems to provide very high DD, is it because of the settings? Will run it on my machine and share results too of the streamlined, will run multiple times.Ignored
OperatingState.CONSERVATIVE_BASELINE: {
"max_dd_per_cycle": 0.15, "base_risk_pct": 0.0075, "max_concurrent_trades": 2,
"optimization_objective": ["maximize_calmar", "maximize_log_trades"],
"min_f1_gate": 0.40
}, Disliked{quote} Thank God you are here! I mean the condition on long position (based on your lastest or best strategy after all). I want to write the code about it to do some tests on Trading View.Ignored
Disliked{quote} If you have a machine like the VPS I was testing on, 4 cores, 4 threads and 8Gb of RAM, just use three assets with no more than 5 years of data for each timeframe, e.g. M15, H1 and D1. I am not a Sharpe Ratio person and rather use the Calmar Ratio / MAR as this targets the issue of DD. I have left the Sharpe in as a lot of people seem to like it. The 'hardcoded' settings are just a guide for the AI as it will determine these levels itself during the analysis and before the forward testing in the STATE_BASED_CONFIG For the first cycle I have...Ignored
Disliked{quote} I am getting similar outputs, probably will need more CPU to actually iterate faster and speed the process up.Ignored
2025-07-09 02:18:05,014 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:5800 - -> Starting single, integrated feature engineering calculation... 2025-07-09 02:18:05,014 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3136 - -> Stage 2: Engineering Full Feature Stack... 2025-07-09 02:18:05,014 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:319 - --- System Resource Analysis --- 2025-07-09 02:18:05,014 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:320 - - Total CPU Cores: 12 2025-07-09 02:18:05,015 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:321 - - Available RAM: 13.97 GB 2025-07-09 02:18:05,015 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:336 - - System is capable. Setting to 11 worker(s). 2025-07-09 02:18:05,015 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:344 - ------------------------------------ 2025-07-09 02:18:05,015 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3144 - -> Processing mode selected: Parallel 2025-07-09 02:18:05,183 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3181 - Setting up multiprocessing pool with 11 workers. 2025-07-09 02:18:05,326 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:352 - - Starting parallel processing for symbol: USDCAD... 2025-07-09 02:18:05,331 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3014 - - Calculating foundational indicators (ATR, Hurst, Volatility)... 2025-07-09 02:18:05,362 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:352 - - Starting parallel processing for symbol: AUDUSD... 2025-07-09 02:18:05,366 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3014 - - Calculating foundational indicators (ATR, Hurst, Volatility)... 2025-07-09 02:18:05,393 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:352 - - Starting parallel processing for symbol: GBPUSD... 2025-07-09 02:18:05,397 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3014 - - Calculating foundational indicators (ATR, Hurst, Volatility)... 2025-07-09 02:18:05,427 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:352 - - Starting parallel processing for symbol: EURUSD... 2025-07-09 02:18:05,431 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3014 - - Calculating foundational indicators (ATR, Hurst, Volatility)... 2025-07-09 02:20:02,377 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3028 - - Calculating standard technical indicators (EMAs, ADX, MACD, Stoch)... 2025-07-09 02:20:02,867 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3028 - - Calculating standard technical indicators (EMAs, ADX, MACD, Stoch)... 2025-07-09 02:20:02,963 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3028 - - Calculating standard technical indicators (EMAs, ADX, MACD, Stoch)... 2025-07-09 02:20:03,399 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3067 - - Applying signal enhancement layer (Kalman Filters, Confirmation)... 2025-07-09 02:20:03,614 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3028 - - Calculating standard technical indicators (EMAs, ADX, MACD, Stoch)... 2025-07-09 02:20:03,954 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3067 - - Applying signal enhancement layer (Kalman Filters, Confirmation)... 2025-07-09 02:20:04,009 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3067 - - Applying signal enhancement layer (Kalman Filters, Confirmation)... 2025-07-09 02:20:04,611 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3067 - - Applying signal enhancement layer (Kalman Filters, Confirmation)... 2025-07-09 02:26:48,461 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3076 - - Calculating microstructure and advanced volatility features... 2025-07-09 02:26:52,855 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3076 - - Calculating microstructure and advanced volatility features... 2025-07-09 02:26:56,093 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3076 - - Calculating microstructure and advanced volatility features... 2025-07-09 02:26:56,473 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3076 - - Calculating microstructure and advanced volatility features... 2025-07-09 02:28:24,183 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3086 - - Calculating contextual and scientific features... 2025-07-09 02:28:27,910 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3086 - - Calculating contextual and scientific features... 2025-07-09 02:28:32,474 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3086 - - Calculating contextual and scientific features... 2025-07-09 02:28:33,391 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3086 - - Calculating contextual and scientific features... 2025-07-09 02:58:17,565 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3196 - - Parallel processing complete. Concatenating feature data... 2025-07-09 02:58:17,949 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3199 - - Calculating cross-symbol features (e.g., relative performance)... 2025-07-09 02:58:18,300 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3203 - - Applying PCA reduction to RSI features (if configured)... 2025-07-09 02:58:18,300 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2957 - Applying PCA reduction to RSI features. 2025-07-09 02:58:20,241 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2988 - Dataset size (1598138 rows) is large. Using Incremental PCA. 2025-07-09 02:58:20,365 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2869 - Fitting IncrementalPCA in batches of 15981... 2025-07-09 02:58:20,365 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2872 - Fitting StandardScaler on a sample of 50000 rows... - Fitting IPCA on batch 101/101... 2025-07-09 02:58:20,646 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2892 - Transforming full dataset in batches with fitted IncrementalPCA... 2025-07-09 02:58:20,829 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2907 - Assigning new PCA features directly to the DataFrame... 2025-07-09 02:58:20,901 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:2917 - IncrementalPCA reduction complete. Explained variance for 5 components: 100.00% 2025-07-09 02:58:20,905 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3206 - - Adding noise-contrastive features for diagnostics... 2025-07-09 02:58:20,953 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3210 - - Applying final data shift (features for t-1 predict t) and cleaning... 2025-07-09 02:58:23,421 - INFO - AxiomEdge_PRO_V211_STREAMLINED.py:3227 - [SUCCESS] Feature engineering (Stage 2) complete. Final dataset shape before labeling: (1596965, 154)
def __init__(self):
self.api_key = os.getenv("GEMINI_API_KEY")
self.api_key_valid = True # Assume valid initially
if not self.api_key or "YOUR" in self.api_key or "PASTE" in self.api_key:
logger.warning("!CRITICAL! GEMINI_API_KEY not found in environment or is a placeholder.")
try:
self.api_key = input(">>> Please paste your Gemini API Key and press Enter, or press Enter to skip: ").strip()
if not self.api_key:
logger.warning("No API Key provided. AI analysis will be skipped.")
self.api_key_valid = False
else:
logger.info("Using API Key provided via manual input.")
except Exception:
logger.warning("Could not read input (non-interactive environment?). AI analysis will be skipped.")
self.api_key_valid = False
self.api_key = None
else:
logger.info("Successfully loaded GEMINI_API_KEY from environment.")
self.headers = {"Content-Type": "application/json"}
# FIX: Replace single model attributes with a prioritized list.
self.model_priority_list = [
"gemini-2.5-flash-lite-preview-06-17",
"gemini-2.5-flash",
"gemini-2.0-flash",
"gemini-2.0-flash-lite"
]
logger.info(f"AI model priority set to: {self.model_priority_list}")
self.tools = [{"function_declarations": [{"name": "search_web", "description": "Searches web.", "parameters": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}}]}]
self.tool_config = {"function_calling_config": {"mode": "AUTO"}} def _call_gemini(self, prompt: str) -> str:
if not self.api_key_valid:
logger.warning("Gemini API key is not valid. Skipping API call.")
return "{}"
# Reflected to fit Gemini large context window ---
# Set a very generous limit (in characters), well within the 1M token limit.
max_prompt_length = 950000
if len(prompt) > max_prompt_length:
# We only warn, we do NOT truncate the prompt anymore.
logger.warning(f"Prompt length ({len(prompt)}) is very large, approaching the model's context window limit of ~1M tokens.")
payload = {
"contents": [{"parts": [{"text": prompt}]}],
"tools": self.tools,
"tool_config": self.tool_config
}
# For non-tool use, ensure tools and tool_config are not in payload or are None
# This logic appears to always include tools, which may be intentional for some prompts.
# A more robust solution might pass a flag, but respecting "no refactor" rule.
if "search_web" not in prompt: # Simple heuristic to disable tools for non-search prompts
payload.pop("tools", None)
payload.pop("tool_config", None)
sanitized_payload = self._sanitize_dict(payload)
# Use the new prioritized list of models directly.
models_to_try = self.model_priority_list
retry_delays = [5, 15, 30] # Seconds
for model_name in models_to_try:
logger.info(f"Attempting to call Gemini API with model: {model_name}")
api_url = f"https://generativelanguage.googleapis.com/v1beta/models/{model_name}:generateContent?key={self.api_key}"
for attempt, delay in enumerate([0] + retry_delays):
if delay > 0:
logger.warning(f"Retrying API call to {model_name} in {delay} seconds... (Attempt {attempt + 1}/{len(retry_delays) + 1})")
flush_loggers()
time.sleep(delay)
try:
response = requests.post(api_url, headers=self.headers, data=json.dumps(sanitized_payload), timeout=180) # Increased timeout
response.raise_for_status()
result = response.json()
# Standard text response parsing
if "candidates" in result and result["candidates"]:
candidate = result["candidates"][0]
if "content" in candidate and "parts" in candidate["content"] and candidate["content"]["parts"]:
text_part = candidate["content"]["parts"][0].get("text")
if text_part:
logger.info(f"Successfully received and extracted text response from model: {model_name}")
return text_part
logger.error(f"Invalid Gemini response structure from {model_name}: No 'text' part found. Response: {result}")
# Continue to next attempt or model if structure is not as expected
except requests.exceptions.HTTPError as e:
logger.error(f"!! HTTP Error for model '{model_name}': {e.response.status_code} {e.response.reason}")
if e.response and e.response.text:
logger.error(f" - API Error Details: {e.response.text}")
if e.response is not None and e.response.status_code in [400, 401, 403, 404, 429]: # Non-retryable or specific errors
break # Break from retries for this model, try next model
except requests.exceptions.RequestException as e:
logger.error(f"Gemini API request failed for model {model_name} on attempt {attempt + 1} (Network Error): {e}")
except json.JSONDecodeError as e:
logger.error(f"Failed to decode Gemini response JSON from {model_name}: {e} - Response Text: {response.text if 'response' in locals() else 'N/A'}")
logger.warning(f"Failed to get a valid text response from model {model_name} after all retries.")
logger.critical("API connection failed for all primary and backup models. Could not get a final text response.")
return "{}" 2025-07-16 08:12:55,030 - CRITICAL - AxiomEdge_PRO_V211_STREAMLINED.py:6620 - A critical, unhandled error occurred during run 1: Found array with 0 sample(s) (shape=(0, 5)) while a minimum of 1 is required by StandardScaler.
Traceback (most recent call last):
File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 6618, in main
run_single_instance(fallback_config, framework_history, playbook, nickname_ledger, directives, api_interval_seconds)
File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 6181, in run_single_instance
full_df = fe.engineer_features(base_tf_data, data_by_tf, gemini_analyzer, api_timer)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 3434, in engineer_features
regime_summary = train_and_diagnose_regime(final_df, os.path.join(self.config.BASE_PATH, "Results"))
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 5292, in train_and_diagnose_regime
df_regime_scaled = scaler.fit_transform(df_regime)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/utils/_set_output.py", line 316, in wrapped
data_to_wrap = f(self, X, *args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/base.py", line 892, in fit_transform
return self.fit(X, **fit_params).transform(X)
^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/preprocessing/_data.py", line 907, in fit
return self.partial_fit(X, y, sample_weight)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/base.py", line 1363, in wrapper
return fit_method(estimator, *args, **kwargs)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/preprocessing/_data.py", line 943, in partial_fit
X = validate_data(
^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/utils/validation.py", line 2954, in validate_data
out = check_array(X, input_name="X", **check_params)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
File "/home/gemini/gemini/.venv/lib/python3.12/site-packages/sklearn/utils/validation.py", line 1128, in check_array
raise ValueError(
ValueError: Found array with 0 sample(s) (shape=(0, 5)) while a minimum of 1 is required by StandardScaler. DislikedIt doesn't matter how many times I run it I keep getting this error, you familiar with it? 2025-07-16 08:12:55,030 - CRITICAL - AxiomEdge_PRO_V211_STREAMLINED.py:6620 - A critical, unhandled error occurred during run 1: Found array with 0 sample(s) (shape=(0, 5)) while a minimum of 1 is required by StandardScaler. Traceback (most recent call last): File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 6618, in main run_single_instance(fallback_config, framework_history, playbook, nickname_ledger, directives, api_interval_seconds) File...Ignored
def train_and_diagnose_regime(df: pd.DataFrame, results_dir: str, n_regimes: int = 5) -> Tuple[int, Dict]:
"""
Trains a K-Means clustering model to identify market regimes or loads a pre-existing one.
Diagnoses the current regime and returns a summary of all regime characteristics.
"""
logger.info("-> Performing data-driven market regime analysis...")
regime_model_path = os.path.join(results_dir, 'regime_model.pkl')
regime_scaler_path = os.path.join(results_dir, 'regime_scaler.pkl')
# Features that define a market's "personality"
regime_features = ['ATR', 'ADX', 'hurst_exponent', 'realized_volatility', 'bollinger_bandwidth']
regime_features = [f for f in regime_features if f in df.columns] # Ensure all features exist
# Default return value in case of early exit
default_summary = {"current_diagnosed_regime": "Regime_Error", "regime_characteristics": {}}
if not regime_features:
logger.error(" - Regime analysis failed: No regime-defining features found in the DataFrame.")
return 0, default_summary
df_regime = df[regime_features].dropna()
# FIX: If after dropping NaNs, the dataframe is empty, we cannot proceed with scaling or training.
if df_regime.empty:
logger.error(" - Regime analysis failed: DataFrame is empty after dropping NaNs from regime features.")
logger.error(" - This is likely due to insufficient data or lookback periods to calculate all required features (ATR, ADX, Hurst, etc.).")
# Return a default/error state that matches the expected output tuple.
default_summary["current_diagnosed_regime"] = "Regime_Error_EmptyData"
return 0, default_summary
if os.path.exists(regime_model_path) and os.path.exists(regime_scaler_path):
logger.info(" - Loading existing regime model and scaler.")
model = joblib.load(regime_model_path)
scaler = joblib.load(regime_scaler_path)
else:
logger.warning(" - No regime model found. Training and saving a new one.")
scaler = StandardScaler()
df_regime_scaled = scaler.fit_transform(df_regime) # This was the source of the error
model = KMeans(n_clusters=n_regimes, random_state=42, n_init=10)
model.fit(df_regime_scaled)
joblib.dump(model, regime_model_path)
joblib.dump(scaler, regime_scaler_path)
logger.info(f" - New regime model saved to {regime_model_path}")
# Diagnose the most recent data point
last_valid_data = df[regime_features].dropna().iloc[-1:]
# Add a check here as well for robustness
if last_valid_data.empty:
logger.warning(" - Could not find a recent valid data point to diagnose the current regime. Using default Regime_0.")
current_regime_id = 0
else:
last_data_scaled = scaler.transform(last_valid_data)
current_regime_id = model.predict(last_data_scaled)[0]
# Create a summary for the AI
centers_unscaled = scaler.inverse_transform(model.cluster_centers_)
regime_summary = {
"current_diagnosed_regime": f"Regime_{current_regime_id}",
"regime_characteristics": {
f"Regime_{i}": {feat: round(val, 4) for feat, val in zip(regime_features, center)}
for i, center in enumerate(centers_unscaled)
}
}
logger.info(f" - Current market condition diagnosed as: Regime_{current_regime_id}")
# FIX: Return a tuple to match the type hint
return int(current_regime_id), regime_summary DislikedIt doesn't matter how many times I run it I keep getting this error, you familiar with it? 2025-07-16 08:12:55,030 - CRITICAL - AxiomEdge_PRO_V211_STREAMLINED.py:6620 - A critical, unhandled error occurred during run 1: Found array with 0 sample(s) (shape=(0, 5)) while a minimum of 1 is required by StandardScaler. Traceback (most recent call last): File "/home/gemini/gemini/AxiomEdge_PRO_V211_STREAMLINED.py", line 6618, in main run_single_instance(fallback_config, framework_history, playbook, nickname_ledger, directives, api_interval_seconds) File...Ignored
DislikedStill testing and 'working on' the full version For everyone following, I have been busy with my normal work but have been making slow progress. The most recent improvements have been mainly 'tweaking' the framework performance, but I have included a lot more features and functions into the framework, one being the introduction of a horizon process. This creates a more robust and adaptive trading framework by using an ensemble of models, where each model is a specialist trained to predict outcomes over a different future timeframe or "horizon"....Ignored
Simply Put: Standard backtesting tools are excellent for quickly testing a purely algorithmic idea under ideal conditions.
Features (what are they and why these are important)
Axiomedge framework regularly identifies and utilizes over 190 features for its models.
Comparing a single advanced feature from the framework to a classic strategy like the RSI 70/30 with an EMA 50/20 crossover highlights the core difference between correlated information and information density.
The RSI + EMA Crossover Strategy Example
This strategy combines four simple, rule-based features. While it's a step up from using just one indicator, its core components are highly related:
A Single Advanced Framework Feature
A single, well-engineered feature from the framework is designed to be a dense and often orthogonal (statistically independent) piece of information that represents a specific market condition or behavioural pattern. It encapsulates a complex idea that would otherwise require multiple simple rules.
Let's compare the "four features" of the classic combo to just one of the AI-discovered features:
Example: orb_kurtosis_false_break
This single feature represents the complex behavioural pattern of a "low-conviction opening breakout that is currently failing." It's not just a signal; it's a narrative, combining three completely different types of information:
This one feature provides more unique and nuanced information than the four highly correlated RSI and EMA features combined. The machine learning model can then learn, for example, that this specific "false breakout" pattern is a high-probability signal for a reversal, something the classic combo could never identify.
In short, the classic strategy adds more of the same type of information, while the framework's goal is to add different types of information, giving the model a much richer and more robust view of the market.
The Simple RSI 30/70 Bounce Example
The key difference is that a simple RSI strategy operates on a single, static dimension, while the framework builds a multi-dimensional, adaptive model of the market's context and behaviour.
Think of it like the difference between looking at just a speedometer versus a full car dashboard with GPS, weather radar, and engine diagnostics.
A basic RSI strategy is a one-dimensional, rule-based system.
The Framework's Multi-Dimensional Feature Approach
The framework doesn't just use indicators; it builds a comprehensive, contextual understanding of the market by engineering features that answer critical questions an RSI rule can't. The machine learning model then learns the complex relationships between these features to make a prediction.
1. It Understands Market Regime & Condition
A simple RSI bounce is a mean-reversion signal that fails spectacularly in strong trends. The framework explicitly calculates the market's "personality" so the model can learn when a bounce is likely to work.
2. It Incorporates Time and Session Behaviour
Market behaviour is not uniform throughout the day or week. The framework captures this, while a simple RSI rule is blind to it.
3. It Learns from Statistical and Behavioural Patterns
This is where the framework moves far beyond traditional technical analysis. It creates features that model market psychology and statistical abnormalities.
4. It Uses Machine Learning to Find the Signal in the Noise
Having hundreds of features is useless without a way to interpret them. This is the final, crucial difference.