Español ES
Ver en GitHub

Estrategia Perceptron AC

Esta estrategia implementa un perceptrón simple sobre el Accelerator Oscillator (AC). El valor de AC de la vela actual y de tres desplazamientos pasados se multiplican por pesos ajustables. La suma de estos productos forma la salida del perceptrón que determina la dirección de la operación.

Cómo funciona

  1. Calcular el Accelerator Oscillator (AC) a partir de la diferencia entre el Awesome Oscillator y su SMA de 5 períodos.
  2. Almacenar los últimos 22 valores de AC para acceder a desplazamientos de 0, 7, 14 y 21 barras.
  3. Calcular la salida del perceptrón: P = (X1-100)*AC[0] + (X2-100)*AC[7] + (X3-100)*AC[14] + (X4-100)*AC[21].
  4. Si P > 0 abrir o mantener una posición larga; si P < 0 abrir o mantener una posición corta.
  5. Cuando una posición gana al menos StopLoss puntos más allá del nivel de stop inicial:
    • Si el perceptrón cambia de dirección, invertir la posición.
    • De lo contrario, trailar el stop al nuevo precio menos/más StopLoss.

Parámetros

  • X1 – peso para el valor AC actual (predeterminado 288).
  • X2 – peso para AC de 7 barras atrás (predeterminado 216).
  • X3 – peso para AC de 14 barras atrás (predeterminado 144).
  • X4 – peso para AC de 21 barras atrás (predeterminado 72).
  • Stop Loss – umbral de seguimiento e inversión en unidades de precio (predeterminado 300).
  • Volume – volumen de la orden (predeterminado 1).
  • Candle Type – serie de velas a la que suscribirse (predeterminado 5 minutos).

Reglas de trading

  • Entrar largo cuando P > 0 y no hay posición abierta.
  • Entrar corto cuando P < 0 y no hay posición abierta.
  • Para posiciones abiertas, mover el stop-loss después de que el precio se mueva Stop Loss * 2 en beneficio.
  • Invertir la posición si la salida del perceptrón cambia de signo en ese momento.

Versión original

Convertido del script MQL4 auto_m5.mq4 ubicado en MQL/11102.

using System;
using System.Collections.Generic;

using Ecng.Common;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Perceptron-based strategy using EMA crossover.
/// </summary>
public class PerceptronAcStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<DataType> _candleType;

	private decimal _prevFast;
	private decimal _prevSlow;
	private bool _hasPrev;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public PerceptronAcStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 12)
			.SetGreaterThanZero()
			.SetDisplay("Fast Period", "Fast EMA period", "Perceptron");
		_slowPeriod = Param(nameof(SlowPeriod), 26)
			.SetGreaterThanZero()
			.SetDisplay("Slow Period", "Slow EMA period", "Perceptron");
		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
			.SetDisplay("Candle Type", "Candle type", "General");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	protected override void OnReseted()
	{
		base.OnReseted();
		_prevFast = 0;
		_prevSlow = 0;
		_hasPrev = false;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		var fast = new ExponentialMovingAverage { Length = FastPeriod };
		var slow = new ExponentialMovingAverage { Length = SlowPeriod };

		SubscribeCandles(CandleType)
			.Bind(fast, slow, ProcessCandle)
			.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastVal, decimal slowVal)
	{
		if (candle.State != CandleStates.Finished) return;

		if (!_hasPrev)
		{
			_prevFast = fastVal;
			_prevSlow = slowVal;
			_hasPrev = true;
			return;
		}

		var crossUp = _prevFast <= _prevSlow && fastVal > slowVal;
		var crossDown = _prevFast >= _prevSlow && fastVal < slowVal;

		if (crossUp && Position <= 0)
		{
			if (Position < 0) BuyMarket();
			BuyMarket();
		}
		else if (crossDown && Position >= 0)
		{
			if (Position > 0) SellMarket();
			SellMarket();
		}

		_prevFast = fastVal;
		_prevSlow = slowVal;
	}
}