Selamlar, hazır stratejiler içinde bulunan Logistic regression stratejisinin içindeki RSİ değerini optimize etmek istiyorum. bunun için gerekli kodu paylaşabilirmisiniz tşk.

Merhaba, LogisticReg kodunu kullanıcı stratejilerine kopyaladıktan sonra aşağıdaki işlemleri gerçekleştiriniz. *Parametre tanımlamaları kısmına alttaki kodu yapıştırınız. [Parameter(14)] public int Period; *OnInit içerisinde bulunan Rsi indikatörünün tanımlandığı kodu aşağıdaki şekilde değiştiriniz. rsi = RSIIndicator(Symbol, SymbolPeriod, OHLCType.Close, Period); Bu işlemleri gerçekleştirdikten sonra Rsi indikatörünün periyodunu dinamik şekilde kullanabilirsiniz. İyi çalışmalar

Rsi logistic regression indikatörü backtest

selamlar,

dediğiniz gibi düzenledim fakat backtest e soktuğumda ve opt ayarlarından tüm barları seçtiğimde. aşağıdaki gibi hata alıyorum.

" birden fazla hata oluştu"

Tüm barlar değil de bar sayısını kendim belirleyeceğim OPT yaptığımda ise. ne yaparsam yapıyım sadece 1 işleme giriyor ve zarar.

incelemeniz için KOD aşağıdaki gibidir;

using System;

using System.Collections.Generic;

using System.Linq;

using Accord;

using Accord.Statistics.Models.Regression;

using Accord.Statistics.Models.Regression.Fitting;

using Matriks.Data.Symbol;

using Matriks.Engines;

using Matriks.Indicators;

using Matriks.Lean.Algotrader.AlgoBase;

using Matriks.Lean.Algotrader.Models;

using Matriks.Trader.Core;

using Matriks.Trader.Core.Fields;

namespace Matriks.Lean.Algotrader

{

public class RsiLogisticReg : MatriksAlgo

{

[SymbolParameter("ASELS")]

public string Symbol;

[Parameter(1)]

public decimal BuyOrderQuantity;

[Parameter(1)]

public decimal SellOrderQuantity;

[Parameter(SymbolPeriod.Min)]

public SymbolPeriod SymbolPeriod;

[Parameter(14)]

public int Period;

[Output]

public string TahminYonu;

[Output]

public string Olasilik;

[Output]

public string DogrulukOrani;

[Output]

public string TahminSonucu;

LogisticRegression model;

int updateCount = 0;

private const int barCount = 5000;

int windowSize = 6;

bool isStandardize = true;

double[][] input;

bool[] output;

int OrderFlag = 2;

List<bool> predictList = new List<bool>();

List<bool> real = new List<bool>();

List<double> featureMeans = new List<double>();

List<double> featureStandardDeviations = new List<double>();

List<decimal> barDataClose;

RSI rsi;

public override void OnInit()

{

rsi = RSIIndicator(Symbol, SymbolPeriod, OHLCType.Close, Period);

AddSymbol(Symbol, SymbolPeriod);

SendOrderSequential(true);

WorkWithPermanentSignal(true);

//SetTimerInterval(180);

}

/// <summary>

/// Init islemleri tamamlaninca, bardatalar kullanmaya hazir hale gelince bu fonksiyon tetiklenir. Data uzerinde bir defa yapilacak islemler icin kullanilir

/// </summary>

public override void OnInitComplated()

{

PrepareTrainingInput();

PrepareTrainingTarget();

Train();

}

public override void OnTimer()

{

}

/// <summary>

/// Eklenen sembollerin bardata'ları ve indikatorler güncellendikçe bu fonksiyon tetiklenir.

/// </summary>

/// <param name="barData">Bardata ve hesaplanan gerçekleşen işleme ait detaylar</param>

public override void OnDataUpdate(BarDataEventArgs barData)

{

double[] predictionFeatures = PreparePredictionInput();

if (updateCount > 0)

{

Debug("Gerçek kapanış (t) fiyatı: " + barDataClose[barDataClose.Count - 2]);

bool actual = barDataClose[barDataClose.Count - 3] < barDataClose[barDataClose.Count - 2];

real.Add(actual);

if (real[real.Count - 1] == predictList[predictList.Count - 1])

{

Debug("Önceki kapanış için yön tahmini DOĞRU");

TahminSonucu = "DOĞRU";

}

else

{

Debug("Önceki kapanış için yön tahmini YANLIŞ");

TahminSonucu = "YANLIŞ";

}

var rate = Math.Round(100 * Accuracy(real.ToArray(), predictList.ToArray()), 2);

Debug("Anlık Doğruluk Oranı: " + rate + "%");

DogrulukOrani = Convert.ToString("%" + Math.Round(100 * Accuracy(real.ToArray(), predictList.ToArray()), 2));

}

Predict(predictionFeatures);

updateCount++;

if (OrderFlag == 1)

{

SendMarketOrder(Symbol, BuyOrderQuantity, OrderSide.Buy);

Debug("Alış Emri Gönderildi");

}

if (OrderFlag == 0)

{

SendMarketOrder(Symbol, SellOrderQuantity, OrderSide.Sell);

Debug("Satış Emri Gönderildi");

}

}

/// <summary>

/// Gönderilen emirlerin son durumu değiştikçe bu fonksiyon tetiklenir.

/// </summary>

/// <param name="barData">Emrin son durumu</param>

public override void OnOrderUpdate(IOrder order)

{

if (order.OrdStatus.Obj == OrdStatus.Filled)

{

}

}

public List<List<double>> GetInputFeatures(int numberOfBars)

{

List<List<decimal>> features = new List<List<decimal>>();

var allBarData = GetBarData();

barDataClose = allBarData.Close.Values.ToList();

features.Add(ReturnRate(barDataClose));

var rsiDict = rsi.Value[0];

features.Add(rsiDict.Values.ToList());

return GetLastNValues(features, numberOfBars);

}

public void Train()

{

var learner = new IterativeReweightedLeastSquares<LogisticRegression>()

{

Iterations = 100, // maximum number of iterations to perform

};

model = learner.Learn(input, output);

}

public void Predict(double[] raw)

{

bool prediction = model.Decide(raw);

double probability = model.Probability(raw);

string pred = "";

Debug("********************************");

if (prediction)

{

pred = $"Fiyat YUKARI yönlü tahmin edildi (Olasılık: %{probability*100})";

Debug(pred);

OrderFlag = 1;

TahminYonu = "YUKARI";

Olasilik = Convert.ToString("%" + Math.Round(probability * 100, 2));

}

else

{

pred = $"Fiyat AŞAĞI yönlü tahmin edildi (Olasılık: %{(1 - probability)*100})";

Debug(pred);

OrderFlag = 0;

TahminYonu = "AŞAĞI";

Olasilik = Convert.ToString("%" + Math.Round((1 - probability) * 100, 2));

}

Debug("Önceki kapanış (t-1) fiyatı: " + barDataClose[barDataClose.Count - 2]);

predictList.Add(prediction);

}

public double Accuracy(bool[] real, bool[] prediction)

{

double correct = 0;

for (int i = 0; i < real.Length; i++)

{

if (real[i] == prediction[i]) correct++;

}

return correct / real.Length;

}

/// <summary>

/// </summary>

/// <param name="features">Modelin eğitim ve tahmin için kullanacağı değerler</param>

/// <param name="count">Istenen veri noktası sayısı</param>

/// <returns></returns>

public List<List<double>> GetLastNValues(List<List<decimal>> features, int count)

{

var mostRecent = new List<List<double>>();

foreach (List<decimal> feature in features)

{

feature.Reverse();

feature.RemoveAt(0);

List<double> recentFeature = feature.Take(count).ToList().ConvertAll(Convert.ToDouble);

mostRecent.Add(recentFeature);

}

return mostRecent;

}

public void PrepareTrainingInput()

{

int numRequiredBars = barCount + windowSize;

List<List<double>> inputFeatures = GetInputFeatures(numRequiredBars);

foreach (List<double> feature in inputFeatures)

{

feature.RemoveAt(0);

}

if (isStandardize)

{

CalculateStandardizationParameters(inputFeatures);

for (int i = 0; i < inputFeatures.Count; i++)

{

inputFeatures[i] = StandardizeData(inputFeatures[i], featureMeans[i], featureStandardDeviations[i]);

}

}

double[][] inputArray = FeatureListToArray(inputFeatures);

input = windowSize > 1 ? ApplyWindow(inputArray) : inputArray;

}

public double[] PreparePredictionInput()

{

List<List<double>> inputFeatures = GetInputFeatures(windowSize);

if (isStandardize)

{

for (int i = 0; i < inputFeatures.Count; i++)

{

inputFeatures[i] = StandardizeData(inputFeatures[i], featureMeans[i], featureStandardDeviations[i]);

}

}

double[][] inputArray = FeatureListToArray(inputFeatures);

double[][] predictionInput = windowSize > 1 ? ApplyWindow(inputArray) : inputArray;

return predictionInput[0];

}

public void PrepareTrainingTarget()

{

var targetValues = new bool[barCount];

int lastCloseIndex = barDataClose.Count - 2;

for (int i = 0; i < barCount; i++)

{

int closeIndex = lastCloseIndex - i;

targetValues[i] = barDataClose[closeIndex] > barDataClose[closeIndex - 1];

}

output = targetValues;

}

/// <summary>

/// </summary>

/// <param name="featureSet">Eğitimde kullanılacak özelliklerin değerlerinin listesi</param>

/// <returns>Eğitim için uygun forma getirilmiş veri</returns>

public double[][] FeatureListToArray(List<List<double>> featureSet)

{

int numberOfFeatures = featureSet.Count;

int featureLength = featureSet[0].Count;

var featureArray = new double[featureLength][];

for (int i = 0; i < featureLength; i++)

{

featureArray[i] = new double[numberOfFeatures];

}

for (int i = 0; i < numberOfFeatures; i++)

{

List<double> feature = featureSet[i];

for (int j = 0; j < featureLength; j++)

{

featureArray[j][i] = feature[j];

}

}

return featureArray;

}

/// <summary>

/// </summary>

/// <param name="featureArray">Eğitim ve tahmin için kullanılacak özellikler.</param>

/// <returns>Pencerelenmiş özellikler</returns>

public double[][] ApplyWindow(double[][] featureArray)

{

int sizeAfterWindowing = featureArray.Length - windowSize + 1;

int numberOfFeatures = featureArray[0].Length;

var windowed = new double[sizeAfterWindowing][];

for (int i = 0; i < sizeAfterWindowing; i++)

{

windowed[i] = new double[numberOfFeatures * windowSize];

}

for (int i = 0; i < sizeAfterWindowing; i++)

{

// Windowsize ile belirlenen sayıdaki bara ait değerler yanyana eklenerek

// modelin istenen periyot içindeki veriyi kullanması sağlanıyor.

int copyStartIndex = 0;

for (int j = 0; j < windowSize; j++)

{

var sourceArray = featureArray[i + j];

Array.Copy(sourceArray, 0, windowed[i], copyStartIndex, numberOfFeatures);

copyStartIndex += numberOfFeatures;

}

}

return windowed;

}

/// <summary>

/// </summary>

/// <param name="list">Standardize edilecek özellik</param>

/// <param name="mean">Özelliğe ait ortalama</param>

/// <param name="standardDeviation">Özelliğe ait standart sapma</param>

/// <returns>Standardize edilmiş özellik</returns>

public List<double> StandardizeData(List<double> list, double mean, double standardDeviation)

{

List<double> standardized = list.Select(value => (value - mean) / standardDeviation).ToList();

return standardized;

}

/// <summary>

/// </summary>

/// <param name="featureList"></param>

public void CalculateStandardizationParameters(List<List<double>> featureList)

{

foreach (List<double> list in featureList)

{

double mean = list.Average();

List<double> differenceFromMean = list.Select(value => value - mean).ToList();

List<double> squaredDifference = differenceFromMean.Select(value => Math.Pow(value, 2)).ToList();

double variance = squaredDifference.Sum() / (squaredDifference.Count - 1);

double standardDeviation = Math.Sqrt(variance);

featureMeans.Add(mean);

featureStandardDeviations.Add(standardDeviation);

}

}

public List<decimal> ReturnRate(List<decimal> values)

{

var returnValue = new List<decimal>();

for (int i = 1; i < values.Count; i++)

{

returnValue.Add((values[i] / values[i - 1]) - 1);

}

return returnValue;

}

}

}

Rsi logistic regression indikatörü backtest

1 Cevap

Yorumlar (1)

Cevabınız

Çerez tercihleri