algoritmus

[Алексей Неботов]

Как и обещал, публикую победившие в http://algoritmus.ru/?p=1578
алгоритмы.
Сильно за них прошу не бить :) цель была победить в конкурсе, а не
написать супер-пупер робота.

Для начала минимальный код:

namespace WealthLab{class s:WealthScript{protected override void
Execute(){ShortAtClose(1);}}}

Buy конечно короче чем Short, но на данных конкурса рынок падал. Кто
придумает код короче?

И код показавший максимальную доходность:

// автор: Алексей Неботов aneb...@gmail.com
// суть: нейронная сеть

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using WealthLab;
using WealthLab.Indicators;

namespace WealthLab.Strategies
{
public class MyStrategy : WealthScript
{
protected override void Execute()
{
// инициирую нейронную сеть нужными весами
int inputCount = 4;
int neuronCount = 4;
Double[] weights = new double[40]

{-0.234391127,0.005477465,0.179729621,0.67232494,0.780287698,-0.882130606,-0.625063675,0.868360098,-0.06888919,0.751613796,-0.07344293,-0.483252362,-0.247726919,0.444970934,-1.356432509,0.296293832,-0.44089387,-0.310897062,-1.119197795,-0.352616012,0.473288896,0.949454739,-0.539533811,0.918220693,-0.121565104,-0.577103315,1.315583346,0.20812379,0.581224783,-0.922218205,0.415265231,0.700044057,-0.113543515,-0.887448077,0.564094936,1.041751663,-0.314661488,0.935658027,0.242620719,-0.923390746};
NeuralNetwork NN = new NeuralNetwork(inputCount,neuronCount);
NN.SetWeights(weights);

for(int bar = 3; bar < Bars.Count; ++bar)
{
// рассчитываю нейронную сеть
NN.Calc(
100*(1-High[bar-1]/High[bar-2]),100*(1-High[bar]/High[bar-1]),
100*(1-Low[bar-1]/Low[bar-2]),100*(1-Low[bar]/Low[bar-1])
);

// рассчитываю цены лимитированных заявок на покупку и продажу
double OpenSPrice = High[bar]*NN.results[0];
double OpenBPrice = Low[bar]*NN.results[1];

// наверное этот иф никогдане сработает, но на всякий пожарный
if (Double.IsNaN(OpenSPrice) || Double.IsNaN(OpenBPrice))
continue;

if (IsLastPositionActive)
{
// закрываю позицию, и открываю противоположную по направлению
switch (LastPosition.PositionType)
{
case PositionType.Long:
SellAtLimit( bar+1, LastPosition, OpenSPrice);
ShortAtLimit( bar+1,OpenSPrice);
break;
case PositionType.Short:
CoverAtLimit(bar+1, LastPosition, OpenBPrice);
BuyAtLimit( bar+1,OpenBPrice);
break;
default:
// нифига себе, а что тогда?
throw new Exception("Неизвестный PositionType");
break;
}
}
else
{
// открываю позицию (а может сразу и закрываю)
if (OpenBPrice<OpenSPrice)
if (! SellAtLimit( bar+1, BuyAtLimit( bar
+1,OpenBPrice,OpenBPrice.ToString()),
OpenSPrice,OpenSPrice.ToString()) )
CoverAtLimit(bar+1, ShortAtLimit( bar+1,OpenSPrice),
OpenBPrice);
}
}
}
}

/// <summary>
/// Перцептрон
/// http://ru.wikipedia.org/wiki/%D0%9F%D0%B5%D1%80%D1%86%D0%B5%D0%BF%D1%82%D1%80%D0%BE%D0%BD
/// </summary>
class NeuralNetwork
{
private int inputCount;
private int neuronCount;
private int resultCount;

private Double[] weights;
private Double[] neurons;
public Double[] results = new Double[2];

public NeuralNetwork(int inputCount, int neuronCount)
{
this.inputCount = inputCount;
this.neuronCount = neuronCount;
neurons = new double[2 * neuronCount];
}

public void SetWeights(Double[] weights)
{
this.weights = weights;
}

public void Calc(params double[] inputVector)
{
// рассчитываю сигнал на выходах нейронов слой1
for (int i = 0; i < neuronCount; ++i)
{
neurons[i] = 0;
for (int j = 0; j < inputCount; ++j)
{
neurons[i] = neurons[i] + inputVector[j] * weights[i *
neuronCount + j];
}
//сигмоид
neurons[i] = (2 * Math.Exp(neurons[i]) / (1 +
Math.Exp(neurons[i]))) - 1;
}
// рассчитываю сигнал на выходах нейронов слой2
for (int i = 0; i < neuronCount; ++i)
{
neurons[neuronCount + i] = 0;
for (int j = 0; j < neuronCount; ++j)
{
neurons[neuronCount + i] = neurons[neuronCount + i] + neurons[j]
* weights[neuronCount * inputCount + i * neuronCount + j];
}
//сигмоид
neurons[neuronCount + i] = (2 * Math.Exp(neurons[neuronCount +
i]) / (1 + Math.Exp(neurons[neuronCount + i]))) - 1;
}

// рассчитываю сигнал на выходах нейронной сети
for (int i = 0; i < results.Length; ++i)
{
results[i] = 0;
for (int j = 0; j < neuronCount; ++j)
{
results[i] = results[i] + neurons[neuronCount + j] *
weights[inputCount * neuronCount + neuronCount * neuronCount + i *
neuronCount + j];
}
//сигмоид
results[i] = (Math.Exp(results[i]) / (1 + Math.Exp(results[i]))) +
0.5;
}
return;
}
}
}