Handelseinblicke durch Volumen: Mehr als OHLC-Charts

Einführung

Im Bereich der technischen Analyse haben sich die Händler in der Vergangenheit auf Kursschwankungen als Hauptindikator für die Marktaktivität verlassen. In dieser Arbeit wird eine einzigartige Methodik vorgestellt, die eine fortgeschrittene, mathematische Analyse des Volumens mit Techniken des maschinellen Lernens kombiniert, wobei der Schwerpunkt darauf liegt, wie Volumenmuster tiefere Einblicke in die Marktdynamik geben können. Wir bieten ein ausgeklügeltes System, das herkömmliche technische Analysemethoden übertrifft, indem wir neuronale LSTM-Netze mit kalkülbasierten Volumenableitungen kombinieren.

Der Artikel gliedert sich in drei Hauptabschnitte: Im ersten werden die grundlegende Bedeutung der Volumenanalyse und ihre mathematischen Grundlagen erörtert; im zweiten werden die praktischen Anwendungen von Volumenderivaten und LSTM-Vorhersagen bei der Identifizierung von Marktchancen untersucht; und im dritten wird erläutert, wie die Analyse von Volumendivergenzen, die Trendbestätigung und die Ausbruchsvalidierung zur Verbesserung von Handelsentscheidungen genutzt werden können.

Verstehen der Kernfunktion des Volumens

Die Gesamtzahl der während eines bestimmten Zeitraums gehandelten Aktien oder Kontrakte wird als Volumen bezeichnet und ist ein wichtiger Indikator für die Marktaktivität und Liquidität. Während der Preis die Richtung des Marktes angibt, zeigt das Volumen die Zuversicht, die hinter einer Marktbewegung steht, und hebt die zugrunde liegende Stärke und Dauerhaftigkeit von Trends hervor. Sie ist die treibende Kraft hinter dem Kursgeschehen und hat die Fähigkeit, Kursbewegungen zu unterstützen oder ihnen zu widersprechen, da signifikante Kursänderungen mit hohem Volumen häufig ein höheres Marktvertrauen anzeigen als solche mit geringem Volumen. Darüber hinaus sagen Volumenmuster häufig Kursänderungen voraus, was sie zu wertvollen Anhaltspunkten für Händler macht, die sie in Verbindung mit der Kursentwicklung und dem Marktkontext zu nutzen verstehen.

Warum Volumen wichtig ist

Einfaches Beispiel:

Die entscheidende Bedeutung der Volumenanalyse lässt sich anhand einer ausgefeilten mathematischen Technik aufzeigen, die über die Standardanalyse hinausgeht und Händlern einen fortschrittlicheren Rahmen für das Verständnis der Marktdynamik bietet, als dies mit herkömmlichen Indikatoren allein möglich ist. Indem wir uns nur auf die Volumendynamik konzentrieren, unabhängig von OHLC-Daten, können wir durch den Einsatz von Kalkül und maschinellem Lernen, mit besonderem Schwerpunkt auf Volumenderivaten und neuronalen LSTM-Netzen, wichtige Markterkenntnisse gewinnen. Diese neuartige Methode nutzt ausgefeilte mathematische Ideen, um winzige Verschiebungen im Handel und in der Marktbeteiligung zu erkennen und so frühzeitig vor möglichen Marktbewegungen zu warnen, bevor sie sich im Kursgeschehen niederschlagen.

Händler können neue Trends und mögliche Umkehrungen präziser erkennen, als dies mit herkömmlichen Volumenanalysetechniken möglich ist, indem sie die Änderungsrate des Volumens (erste Ableitung) und seine Beschleunigung (zweite Ableitung) in Verbindung mit maschinellen Lernprognosen betrachten. Bei richtiger Anwendung bietet diese mathematische Grundlage einen soliden Ansatz für die Marktanalyse, der insbesondere auf den heutigen algorithmisch gesteuerten Märkten hilfreich sein kann, wenn die herkömmliche technische Analyse nicht ausreicht.

Bei dieser Methode werden drei wichtige Volumenkomponenten berücksichtigt: die erste Ableitung (Rate der Volumenänderung), die zweite Ableitung (Beschleunigung der Volumenänderung) und LSTM-Projektionen des zukünftigen Volumens, die dieselben Volumenableitungen bestätigen. Durch die Beseitigung des Preisrauschens konzentriert sich dieser Ansatz ausschließlich auf die Dynamik der Marktteilnahme. 

Der EA beginnt mit den üblichen MetaTrader-Deklarationen. Sie enthalten die Bibliothek „Trade“ für die Auftragsverwaltung und die nutzerdefinierte Bibliothek Volume_LSTM für Vorhersagen. Die Eigenschaft indicator_separate_window zeigt an, dass dies in einem separaten Fenster angezeigt wird, und weist drei Indikatorpuffer für die Visualisierung zu.

#property copyright "Your Name"
#property version   "1.00"
#property strict
#property indicator_separate_window
#property indicator_buffers 3
#include <Trade\Trade.mqh>
#include <Volume_LSTM.mqh>
CTrade trade;

Die Parameter sind in logischen Gruppen organisiert. Der Abschnitt LSTM-Konfiguration steuert das Verhalten des neuronalen Netzes, während die Eingabeparameter die Handelsregeln verwalten. Jeder Parameter hat einen bestimmten Zweck: Die LSTM-Parameter steuern die Komplexität und den Speicher des Vorhersagemodells. Die Handelsparameter legen die Positionsgröße und die Gewinnziele fest, während die Parameter für das Risikomanagement Verlustlimits und Trailing-Stops vorgeben.

input group "Configuración LSTM"
input bool     UseLSTM = true;              
input int      LSTMHiddenSize = 32;         
input int      LSTMLookback = 10;           

input group "Entry Parameters"
input double   Lots = 0.1;         
input double   TPPoints = 100;      
input int      Periods = 4;         
input int      AccelBars = 4;       
input int      MaxBarsInTrade = 2; 
input double   ProfitClose = 15;    
input double   MaxDailyLoss = -25; 
input double   TrailingStart = 5;  
input double   TrailingStep = 5;

Diese Funktion berechnet die Rate der Volumenänderung (erste Ableitung) und die Beschleunigung der Volumenänderung (zweite Ableitung). Es verschiebt bestehende Ableitungen, um die Historie beizubehalten, berechnet die neue erste Ableitung als Differenz zwischen dem aktuellen und dem vorherigen Volumen, berechnet die neue zweite Ableitung als Änderung der ersten Ableitungen und bietet Einblicke in Volumenimpuls und -beschleunigung.

Durch die Betrachtung der ersten Ableitung des Volumens können wir im Wesentlichen feststellen, ob die Handelsaktivität im Laufe der Zeit zu- oder abnimmt. Dieses Muster der Volumenschwankung gibt uns einen ersten Einblick in die Marktdynamik. Eine durchweg positive erste Ableitung deutet auf ein steigendes Marktinteresse hin, während eine negative Ableitung auf ein sinkendes Engagement schließen lässt.

void CalculateDerivatives() {
    for(int i = 0; i < ArraySize(volumes)-1; i++) {
        firstDerivative[i] = firstDerivative[i+1];
        secondDerivative[i] = secondDerivative[i+1];
    }

    firstDerivative[ArraySize(volumes)-1] = volumes[ArraySize(volumes)-1] - volumes[ArraySize(volumes)-2];
    secondDerivative[ArraySize(volumes)-1] = firstDerivative[ArraySize(volumes)-1] - firstDerivative[ArraySize(volumes)-2];
}

Diese Funktionen verwalten den Lebenszyklus eines Geschäfts: TrackNewTrade zeichnet neue Positionen im ersten verfügbaren Slot auf, RemoveTrade löscht den Datensatz, wenn Positionen geschlossen werden. Beide Funktionen gewährleisten die Integrität des Handelsverfolgungssystems.

void TrackNewTrade(ulong ticket) {
    for(int i = 0; i < ArraySize(openTrades); i++) {
        if(openTrades[i].ticket == 0) {
            openTrades[i].ticket = ticket;
            openTrades[i].openTime = TimeCurrent();
            openTrades[i].barsOpen = 0;
            break;
        }
    }
}

void RemoveTrade(ulong ticket) {
    for(int i = 0; i < ArraySize(openTrades); i++) {
        if(openTrades[i].ticket == ticket) {
            openTrades[i].ticket = 0;
            openTrades[i].openTime = 0;
            openTrades[i].barsOpen = 0;
            break;
        }
    }
}

Diese Gewinnverfolgungsfunktion:

1. Identifiziert den aktuellen Handelstag.
2. Berechnet den realisierten Gewinn aus abgeschlossenen Geschäften.
3. Addiert den nicht realisierten Gewinn aus offenen Positionen.
4. Tägliche Gewinnverfolgung bei mehreren Geschäften.
5. Hilft bei der Einhaltung der täglichen Verlustgrenzen.

double GetDailyProfit() {
    datetime today = StringToTime(TimeToString(TimeCurrent(), TIME_DATE));

    if(lastDayChecked != today) {
        lastDayChecked = today;
        dailyProfit = 0;

        HistorySelect(today, TimeCurrent());
        int deals = HistoryDealsTotal();

        for(int i = 0; i < deals; i++) {
            ulong ticket = HistoryDealGetTicket(i);
            if(ticket > 0) {
                if(HistoryDealGetString(ticket, DEAL_SYMBOL) == _Symbol)
                    dailyProfit += HistoryDealGetDouble(ticket, DEAL_PROFIT);
            }
        }
    }
    
    // Add floating P/L
    double floatingProfit = 0;
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if(ticket > 0 && PositionSelectByTicket(ticket)) {
            if(PositionGetString(POSITION_SYMBOL) == _Symbol)
                floatingProfit += PositionGetDouble(POSITION_PROFIT);
        }
    }

    return dailyProfit + floatingProfit;
}

Die Trailing-Stop-Funktion:

1. Iteriert durch alle offenen Positionen.
2. Berechnet den Gewinn in Punkten für jede Position.
3. Aktualisiert Stop-Loss-Levels basierend auf dem Gewinn.
4. Setzt einen Trailing-Mechanismus ein, um Gewinne zu sichern.
5. Behandelt Kauf- und Verkaufspositionen unterschiedlich.

void ApplyTrailingStop(double point) {
    for(int i = PositionsTotal() - 1; i >= 0; i--) {
        ulong ticket = PositionGetTicket(i);
        if(ticket <= 0) continue;

        if(PositionSelectByTicket(ticket)) {
            double openPrice = PositionGetDouble(POSITION_PRICE_OPEN);
            double currentPrice = PositionGetDouble(POSITION_PRICE_CURRENT);
            double currentSL = PositionGetDouble(POSITION_SL);
            long posType = PositionGetInteger(POSITION_TYPE);

            // Calculate and update trailing stop
            double profitPoints;
            if(posType == POSITION_TYPE_BUY) {
                profitPoints = (currentPrice - openPrice) / point;
                if(profitPoints >= TrailingStart) {
                    double newSL = openPrice + (profitPoints - TrailingStep) * point;
                    if(currentSL < newSL || currentSL == 0) {
                        trade.PositionModify(ticket, newSL, PositionGetDouble(POSITION_TP));
                    }
                }
            }
            // Similar logic for SELL positions
        }
    }
}

Die zweite Ableitung des Handelsvolumens liefert noch detailliertere Informationen, da sie die Beschleunigung oder Verlangsamung der Handelstätigkeit anzeigt. Ein positiver Wert für diese zweite Ableitung ist ein starkes Indiz für eine wachsende Marktdynamik, da er zeigt, dass das Volumen ansteigt und zwar mit zunehmender Geschwindigkeit. Da sie auf ein schnell wachsendes Interesse der Marktteilnehmer hinweist, tritt diese Volumenbeschleunigung häufig vor nennenswerten Marktbewegungen auf. Wir bieten einen soliden Rahmen für die Vorhersage des Marktverhaltens, indem wir diese Derivate mit Vorhersagen zukünftiger Volumenmuster durch neuronale LSTM-Netzwerke kombinieren. Unsere Studie erhält eine zusätzliche Validierungsebene durch die Fähigkeit des LSTM, komplizierte Muster in Volumensequenzen zu erkennen, was dabei hilft, festzustellen, ob die beobachteten Volumentrends wahrscheinlich anhalten werden.

Die wichtigste Handelslogik:

1. Kontrolliert die Bildung neuer Balken.
2. Überprüft die täglichen Verlustgrenzen.
3. Aktualisiert Handelsinformationen.
4. Führt eine Volumenanalyse durch.
5. Erzeugt LSTM-Vorhersagen, falls aktiviert.
6. Trifft Handelsentscheidungen auf der Grundlage mehrerer Faktoren.
7. Öffnet Positionen, wenn die Bedingungen übereinstimmen.

void OnTick() {
    static datetime lastBar = 0;
    datetime currentBar = iTime(_Symbol, PERIOD_CURRENT, 0);

    if(lastBar == currentBar) return;
    lastBar = currentBar;

    if(GetDailyProfit() < MaxDailyLoss) {
        CloseAllPositions();
        return;
    }

    // Update and calculate
    UpdateTradesInfo();
    CheckTimeBasedClose();
    
    if(!CanTrade()) return;

    // Volume analysis and LSTM prediction
    // ... volume calculations ...
    
    if(UseLSTM && volumePredictor != NULL) {
        // LSTM prediction logic
        // ... prediction calculations ...
    }

    CalculateDerivatives();
    
    // Trading decisions based on calculations
    if(consecutiveAccel >= AccelBars) {
        if((!UseADX && !UseOBV) || ConfirmLongSignal()) {
            // Open buy position
        }
    }
    else if(consecutiveAccel <= -AccelBars) {
        if(!UseADX && !UseOBV || ConfirmShortSignal()) {
            // Open sell position
        }
    }
}

Die Berechnungen der technischen Indikatoren:

1. Richtet die Datenpuffer für die Indikatorwerte ein.
2. Kopiert die Indikatordaten.
3. Aktualisiert die lokale Arrays mit neuen Werten.
4. Pflegt die Indikatordaten für die Entscheidungsfindung.

void CalculateADX() {
    if(!UseADX) return;

    double adx_buffer[];
    double plusdi_buffer[];
    double minusdi_buffer[];
    ArraySetAsSeries(adx_buffer, true);
    ArraySetAsSeries(plusdi_buffer, true);
    ArraySetAsSeries(minusdi_buffer, true);

    CopyBuffer(adx_handle, MAIN_LINE, 0, ArraySize(adx_main), adx_buffer);
    CopyBuffer(adx_handle, PLUSDI_LINE, 0, ArraySize(adx_plus), plusdi_buffer);
    CopyBuffer(adx_handle, MINUSDI_LINE, 0, ArraySize(adx_minus), minusdi_buffer);

    ArrayCopy(adx_main, adx_buffer);
    ArrayCopy(adx_plus, plusdi_buffer);
    ArrayCopy(adx_minus, minusdi_buffer);
}

Jede Komponente arbeitet zusammen, um ein umfassendes Handelssystem zu schaffen, das Volumenanalyse, LSTM-Vorhersagen und traditionelle technische Indikatoren kombiniert und gleichzeitig robuste Risikomanagementpraktiken beibehält.

Die Datei Volume_LSTM.mqh implementiert ein neuronales Netzwerk mit langem Kurzzeitgedächtnis (LSTM), das speziell für die Vorhersage von Handelsvolumen entwickelt wurde.

Der Code beginnt mit einer grundlegenden Matrix2D-Struktur, die 2D-Matrixoperationen verarbeitet:

struct Matrix2D {
    double values[];
    int rows;
    int cols;
    
    void Init(int r, int c) {
        rows = r;
        cols = c;
        ArrayResize(values, rows * cols);
        ArrayInitialize(values, 0);
    }
    // ... other methods
}

Die LSTM-Zelle ist als eine umfassende Struktur implementiert:

struct LSTMCell {
    double forget_gate[];
    double input_gate[];
    double cell_state[];
    double output_gate[];
    double hidden_state[];
    
    Matrix2D Wf;  // Forget gate weights
    Matrix2D Wi;  // Input gate weights
    Matrix2D Wc;  // Cell state weights
    Matrix2D Wo;  // Output gate weights
    
    double bf[];  // Forget gate bias
    double bi[];  // Input gate bias
    double bc[];  // Cell state bias
    double bo[];  // Output gate bias
    
    int hidden_size;
    int input_size;
};

Die Implementierung umfasst standardmäßige Aktivierungsfunktionen für neuronale Netze:

double Sigmoid(double x) {
    return 1.0 / (1.0 + MathExp(-x));
}

double Tanh(double x) {
    return (MathExp(x) - MathExp(-x)) / (MathExp(x) + MathExp(-x));
}

Die Gewichte werden mit einer Variante der Xavier/Glorot-Initialisierung initialisiert:

void InitializeWeights() {
    double scale = MathSqrt(2.0 / (lstm.input_size + lstm.hidden_size));
    
    // Initialize weight matrices
    lstm.Wf.Init(lstm.hidden_size, lstm.input_size);
    lstm.Wi.Init(lstm.hidden_size, lstm.input_size);
    // ... other initializations

    // Random initialization with scaling
    for(int i = 0; i < lstm.hidden_size; i++) {
        for(int j = 0; j < lstm.input_size; j++) {
            lstm.Wf.Set(i, j, (MathRand() / 32768.0 - 0.5) * scale);
            // ... other weight initializations
        }
    }
}

Die Implementierung umfasst die Normalisierung der Daten:

void NormalizeVolumes() {
    volume_mean = 0;
    double sum_squared = 0;
    
    // Calculate mean
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        volume_mean += historical_volumes[i];
    }
    volume_mean /= ArraySize(historical_volumes);
    
    // Calculate standard deviation
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        sum_squared += MathPow(historical_volumes[i] - volume_mean, 2);
    }
    volume_std = MathSqrt(sum_squared / ArraySize(historical_volumes));
    
    // Normalize volumes
    if(volume_std == 0) volume_std = 1;  // Prevent division by zero
    for(int i = 0; i < ArraySize(historical_volumes); i++) {
        historical_volumes[i] = (historical_volumes[i] - volume_mean) / volume_std;
    }
}

Die zentrale Vorhersagelogik:

double PredictNextVolume() {
    if(!is_initialized) return 0;
    
    double input1 = historical_volumes[ArraySize(historical_volumes)-1];
    
    // LSTM forward pass
    for(int h = 0; h < lstm.hidden_size; h++) {
        double ft = 0, it = 0, ct = 0, ot = 0;
        
        // Calculate gates
        for(int i = 0; i < lstm.input_size; i++) {
            ft += lstm.Wf.Get(h, i) * input1;
            it += lstm.Wi.Get(h, i) * input1;
            ct += lstm.Wc.Get(h, i) * input1;
            ot += lstm.Wo.Get(h, i) * input1;
        }
        
        // Apply gates and calculate states
        lstm.forget_gate[h] = Sigmoid(ft + lstm.bf[h]);
        lstm.input_gate[h] = Sigmoid(it + lstm.bi[h]);
        double c_tilde = Tanh(ct + lstm.bc[h]);
        lstm.cell_state[h] = lstm.forget_gate[h] * lstm.cell_state[h] + 
                            lstm.input_gate[h] * c_tilde;
        lstm.output_gate[h] = Sigmoid(ot + lstm.bo[h]);
        lstm.hidden_state[h] = lstm.output_gate[h] * Tanh(lstm.cell_state[h]);
    }
    
    // Calculate final prediction
    double prediction = 0;
    for(int h = 0; h < lstm.hidden_size; h++)
        prediction += lstm.hidden_state[h];
    prediction /= lstm.hidden_size;
    
    return prediction * volume_std + volume_mean;  // Denormalize
}

Ergebnisse

EURUSD, dies sind die Ergebnisse für EURUSD mit dem Zeitrahmen 30-Minuten. Dies sind die Einstellungen setting_eurusd.set

setting_eurusd.set

GBPUSD mit einem 30-minütigen Zeitrahmen.

gbpusd_settings.set

Eine umfangreichere Optimierung könnte zu besseren Ergebnissen bei großen Paaren führen, und Zeitmangel hilft nicht, diesen Artikel zu erweitern. Ich empfehle dringend, eine große Optimierung für jedes Paar zu machen, und hoffe, dass einige Nutzer Kommentare mit neuen möglichen Setups in den Kommentaren hinzufügen.

Fortgeschrittene Techniken

Trendbestätigung

Ein hohes Volumen bei Kurssteigerungen deutet auf eine starke Marktunterstützung und eine wahrscheinliche Fortsetzung des Trends hin. Umgekehrt spiegelt ein hohes Volumen bei Kursrückgängen einen starken Verkaufsdruck wider und bestätigt einen negativen Trend. Geringe Volumina während der Kursbewegungen weisen auf schwache oder nicht nachhaltige Trends hin und signalisieren oft falsche Ausbrüche oder Manipulationen.

Breakout-Validierung

Ausbrüche bei hohem Volumen bestätigen die Überzeugung des Marktes und führen zu anhaltenden Kursveränderungen. Ausbrüche mit geringem Volumen führen oft zu falschen Signalen, wie z. B. „Bullenfallen“ oder „Bärenfallen“, und sind wahrscheinlich zum Scheitern verurteilt. Volumenspitzen bei Ausbrüchen bestätigen die Bewegung und weisen auf eine solide Marktunterstützung hin.

Volumensdivergenz

Die Volumensdivergenz, bei der Preis- und Volumentrends voneinander abweichen, signalisiert potenzielle Trendumkehrungen oder Schwächen. Ein sinkendes Volumen bei steigenden Kursen deutet auf eine Abschwächung des Aufwärtstrends hin, während ein sinkendes Volumen bei fallenden Kursen auf einen geringeren Verkaufsdruck und eine mögliche Bodenbildung des Marktes hindeutet. In Kombination mit anderen Indikatoren können diese Muster helfen, Wendepunkte zu erkennen.

Schlussfolgerung

Durch die Verschmelzung modernster Methoden des maschinellen Lernens mit der herkömmlichen Volumenanalyse bietet der Volume-Based Trading EA eine fortschrittliche Methode des algorithmischen Handels. Das System bietet einen starken Ansatz für Marktforschung und Handelsausführung, indem es zusätzlich zu den traditionellen technischen Indikatoren wie ADX und OBV neuronale Netze für die Volumenvorhersage verwendet.

Der vielschichtige Ansatz des EA für das Risikomanagement mit einer strengen täglichen Verlustbegrenzung, mit dynamischen Trailing-Stops und eine gründliche Positionskontrolle, ist sein stärkster Punkt. Diese Betonung des Risikomanagements, zusammen mit den einstellbaren Einstiegsparametern und dem variablen Sitzungsmanagement, gibt den Händlern ein flexibles Werkzeug an die Hand, das sich an verschiedene Marktsituationen anpassen kann, während es gleichzeitig disziplinierte Handelsverfahren beibehält.

Vor allem wird ein spezielles hybrides System durch die Kombination der Analyse von Volumenderivaten mit LSTM-Vorhersagen erstellt. Dank dieser Kombination ist der EA in der Lage, Marktveränderungen zu erkennen, bevor sie vollständig eintreten, und die Validierung der konventionellen Indikatoren hilft, falsche Signale zu vermeiden. Künftige Verbesserungen und einfache Wartung werden durch die modulare Codestruktur ebenfalls ermöglicht.

Die Nutzer sollten sich jedoch darüber im Klaren sein, dass aufgrund der Komplexität des Systems vor dem Live-Einsatz ein sorgfältiges Backtesting und Parameter-Tuning erforderlich sind. Trotz ihrer Stärke benötigt die LSTM-Komponente eine große Menge an Rechenleistung und geeignete Trainingsdaten. Trotz dieser Probleme ist der EA ein nützliches Werkzeug für Händler, die ihre volumenbasierten Handelsmethoden automatisieren möchten, da er modernste Technologie mit bewährten Handelskonzepten verbindet.

Ich hoffe, dieser Artikel hilft Ihnen, die Verwendung von OHLCV und nicht nur die Preise zu berücksichtigen.

Datei Name	Beschreibung
MQL5/Profiles/Tester/Setting_eurusd.set	Einstellungen für das Beispiel EURUSD
MQL5/Profiles/Tester/GBPUSD_settings.set	Einstellungen für das Beispiel GBPUSD
MQL5/Experts/Volume_high_low_difference_LSTM.mq5	Expert Advisor zur Verwendung der Beispiele
MQL5/Include/Volume_LSTM.mqh	Einzubindende mqh-Datei. Denken Sie daran, den Pfad im EA so zu ändern, wie Sie ihn gespeichert haben