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;
}
}
}
