Português PT
Ver no GitHub

Estratégia Slime Mold RSI

Uma conversão direta do assessor especialista MQL4 "Slime_Mold_RSI_v1.1". A estratégia constrói um único perceptron combinando quatro leituras de RSI (12, 36, 108 e 324) calculadas sobre o preço mediano. Cada valor de RSI é normalizado do intervalo original 0–100 para -1…+1 e multiplicado por um peso configurável. Um cruzamento por zero da soma ponderada inverte a posição.

Como Funciona

  • Calcular o preço mediano de cada vela finalizada e alimentá-lo em quatro indicadores de Índice de Força Relativa com comprimentos de 12, 36, 108 e 324.
  • Normalizar cada valor de RSI para o intervalo -1…+1 e aplicar o peso correspondente. Os valores padrão (-100) reproduzem os coeficientes originais do perceptron (x - 100).
  • Somar as quatro entradas ponderadas para produzir a saída do perceptron da vela atual.
  • Comparar o valor mais recente com a saída do perceptron da vela anterior para detectar cruzamentos por zero e gerar sinais de trading.

Regras de Trading

  • Entrada comprada: O valor anterior do perceptron está abaixo de zero e o valor atual sobe acima de zero. A estratégia fecha qualquer exposição vendida e estabelece uma posição comprada de tamanho Volume.
  • Entrada vendida: O valor anterior do perceptron está acima de zero e o valor atual cai abaixo de zero. A estratégia sai de qualquer posição comprada e abre uma posição vendida de tamanho Volume.
  • Gestão de posições: Não há alvos de lucro explícitos nem ordens de stop-loss. As posições só são alteradas quando ocorre um novo cruzamento por zero.

Parâmetros

  • Weight1 – coeficiente aplicado à entrada de RSI normalizada de 12 períodos.
  • Weight2 – coeficiente aplicado à entrada de RSI normalizada de 36 períodos.
  • Weight3 – coeficiente aplicado à entrada de RSI normalizada de 108 períodos.
  • Weight4 – coeficiente aplicado à entrada de RSI normalizada de 324 períodos.
  • CandleType – período das velas fornecidas à estratégia. O padrão são velas de 1 hora.

Detalhes

  • Critérios de entrada: Cruzamento por zero do perceptron RSI ponderado.
  • Comprado/Vendido: Ambos (sempre no mercado após o primeiro sinal).
  • Critérios de saída: O cruzamento oposto por zero inverte a posição.
  • Stops: Nenhum.
  • Valores padrão:
    • Weight1 = -100
    • Weight2 = -100
    • Weight3 = -100
    • Weight4 = -100
    • CandleType = velas de 1 hora
  • Filtros:
    • Categoria: Perceptron / Oscilador
    • Direção: Bidirecional
    • Indicadores: RSI (preço mediano)
    • Stops: Não
    • Complexidade: Intermediário (requer quatro indicadores de longo horizonte)
    • Período: Configurável (padrão intradiário por hora)
    • Sazonalidade: Não
    • Redes neurais: Perceptron linear
    • Divergência: Não
    • Nível de risco: Depende do volume e pesos escolhidos

Notas

  • A implementação mantém o registro da saída prévia do perceptron mesmo quando o trading está desabilitado para garantir a continuidade do estado assim que o trading for retomado.
  • O preço mediano é usado para corresponder à configuração PRICE_MEDIAN do script original do MetaTrader.
  • A estratégia inverte posições instantaneamente, portanto considere o potencial deslizamento ao escolher pesos e volume.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Slime Mold RSI perceptron strategy converted from MQL4.
/// The strategy sums weighted RSI inputs to generate zero-crossing signals.
/// </summary>
public class SlimeMoldRsiStrategy : Strategy
{
	private readonly StrategyParam<decimal> _weight1;
	private readonly StrategyParam<decimal> _weight2;
	private readonly StrategyParam<decimal> _weight3;
	private readonly StrategyParam<decimal> _weight4;
	private readonly StrategyParam<DataType> _candleType;

	private RelativeStrengthIndex _rsi12 = null!;
	private RelativeStrengthIndex _rsi36 = null!;
	private RelativeStrengthIndex _rsi108 = null!;
	private RelativeStrengthIndex _rsi324 = null!;

	private decimal? _previousPerceptron;

	/// <summary>
	/// Weight applied to the 12-period RSI input.
	/// </summary>
	public decimal Weight1
	{
		get => _weight1.Value;
		set => _weight1.Value = value;
	}

	/// <summary>
	/// Weight applied to the 36-period RSI input.
	/// </summary>
	public decimal Weight2
	{
		get => _weight2.Value;
		set => _weight2.Value = value;
	}

	/// <summary>
	/// Weight applied to the 108-period RSI input.
	/// </summary>
	public decimal Weight3
	{
		get => _weight3.Value;
		set => _weight3.Value = value;
	}

	/// <summary>
	/// Weight applied to the 324-period RSI input.
	/// </summary>
	public decimal Weight4
	{
		get => _weight4.Value;
		set => _weight4.Value = value;
	}

	/// <summary>
	/// Candle type used for RSI calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="SlimeMoldRsiStrategy"/> class.
	/// </summary>
	public SlimeMoldRsiStrategy()
	{
		_weight1 = Param(nameof(Weight1), -100m)
			.SetDisplay("Weight 1", "Weight applied to the 12-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight2 = Param(nameof(Weight2), -100m)
			.SetDisplay("Weight 2", "Weight applied to the 36-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight3 = Param(nameof(Weight3), -100m)
			.SetDisplay("Weight 3", "Weight applied to the 108-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_weight4 = Param(nameof(Weight4), -100m)
			.SetDisplay("Weight 4", "Weight applied to the 324-period RSI input", "Perceptron")
			
			.SetOptimize(-200m, 200m, 10m);

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Timeframe for candles used in calculations", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		return [(Security, CandleType)];
	}

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();

		// Drop cached indicator instances and perceptron history.
		_rsi12 = null!;
		_rsi36 = null!;
		_rsi108 = null!;
		_rsi324 = null!;
		_previousPerceptron = null;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		// Create RSI indicators for each horizon used by the original perceptron.
		_rsi12 = new RelativeStrengthIndex { Length = 12 };
		_rsi36 = new RelativeStrengthIndex { Length = 36 };
		_rsi108 = new RelativeStrengthIndex { Length = 108 };
		_rsi324 = new RelativeStrengthIndex { Length = 324 };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(ProcessCandle)
			.Start();
	}

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

		if (_rsi12 is null || _rsi36 is null || _rsi108 is null || _rsi324 is null)
			return;

		// Median price replicates PRICE_MEDIAN used in the original script.
		var medianPrice = (candle.HighPrice + candle.LowPrice) / 2m;

		var input = new DecimalIndicatorValue(_rsi12, medianPrice, candle.ServerTime) { IsFinal = true };
		_rsi12.Process(input);
		_rsi36.Process(new DecimalIndicatorValue(_rsi36, medianPrice, candle.ServerTime) { IsFinal = true });
		_rsi108.Process(new DecimalIndicatorValue(_rsi108, medianPrice, candle.ServerTime) { IsFinal = true });
		_rsi324.Process(new DecimalIndicatorValue(_rsi324, medianPrice, candle.ServerTime) { IsFinal = true });

		// Wait until every RSI is fully formed before evaluating signals.
		if (!_rsi12.IsFormed || !_rsi36.IsFormed || !_rsi108.IsFormed || !_rsi324.IsFormed)
			return;

		var rsi12Value = _rsi12.GetCurrentValue();
		var rsi36Value = _rsi36.GetCurrentValue();
		var rsi108Value = _rsi108.GetCurrentValue();
		var rsi324Value = _rsi324.GetCurrentValue();

		var currentPerceptron =
			(Weight1 * NormalizeRsi(rsi12Value)) +
			(Weight2 * NormalizeRsi(rsi36Value)) +
			(Weight3 * NormalizeRsi(rsi108Value)) +
			(Weight4 * NormalizeRsi(rsi324Value));

		// Initialize the history with the first complete value.
		if (_previousPerceptron is null)
		{
			_previousPerceptron = currentPerceptron;
			return;
		}

		var previousPerceptron = _previousPerceptron.Value;

		// Even if trading is disabled, keep the state in sync with the incoming data.
		// indicators already checked above via IsFormed

		// Zero-crossing from negative to positive triggers a long entry.
		if (previousPerceptron < 0m && currentPerceptron > 0m && Position <= 0m)
		{
				BuyMarket();
				LogInfo($"Long entry. Previous perceptron: {previousPerceptron:F2}, current: {currentPerceptron:F2}");
		}
		// Zero-crossing from positive to negative triggers a short entry.
		else if (previousPerceptron > 0m && currentPerceptron < 0m && Position >= 0m)
		{
				SellMarket();
				LogInfo($"Short entry. Previous perceptron: {previousPerceptron:F2}, current: {currentPerceptron:F2}");
		}

		// Store the latest perceptron value for the next signal evaluation.
		_previousPerceptron = currentPerceptron;
	}

	private static decimal NormalizeRsi(decimal rsiValue)
	{
		// Transform RSI from [0,100] into [-1,+1] as in the original script.
		return ((rsiValue / 100m) - 0.5m) * 2m;
	}
}