Невронни мрежи и изкувствен интелект

[kypa]

Това дали ще е достатъчно случайно за теглене на четни/нечетни?

int слочаенътикъино()
  {
   int yu=1;
   if(MathMod(muhrand(),2)>0.2) yu=-1;
   return(yu);
  }

int muhrand()
  {   
   return((int)MathFloor(MathAbs(MathRand()*MathRand()*MathSin(0-MathSin(MathRand())))));
  }

Легендата гласи, че синуси от супер малки стойности можели да минат за хаотични.
Графиката дето рисуват прилича на тая дето ми се иска да излезе, предимно затова питам.

Аз тръгнах да я пиша като цяло за случайни числа, обаче то със синус няма как да стане, най-много за четни/нечетни.

[Mateev]

Функцията MathRand генерира псевдослучайни числа, които започват да се повтарят след 2 на степен 15 броя (32768). Ако обаче с тези числа се XOR-ва някаква друга неповтаряща се редица, то крайната последователност също ще е неповтаряща се.


Най-лесната реализация е да използваш един int брояч, започващ от 0 и въртящ се дотогава, докато ни трябва. Този брояч ще генерира НЕПОВТАРЯЩИ се числа, в които бройката на нулите и единиците е приблизително равна така, както го изисква случайноста. Остава само да ги разбъркаме, и това вече може да го извърши функцията MathRand на MetaTrader-а. Нейната повторяемост няма да се прояви в крайната редица, защото XOR-ването ще е върху неповтаряща се редица, но фактора случайност ще се запази, защото и в редицата MathRand броя на нулите и единиците е приблизително еднакъв.


Аз бих написал следния алгоритъм:
1. Тегля 3 последователни MathRand числа, всяко от които е дълго 15 бита
2. От тях формирам 32 битово случайно число, като лепя битовете един до друг или дори леко ги припокривам посредством XOR
3. Това 32 битово число го XOR-вам със стойноста на брояча, и получавам ново 32 битово число, което няма да се повтори дори и след милиарди превъртания.
4. От това число използваме абсолютно всички битове, теглейки ги един по един, а не само най-младшия.

[Mateev]

Направих си труда да измисля един верен според мене алгоритъм за теглене на случаен тик, при който никога няма да се появи повторяемост в редицата от числа. Използвам алгоритъм, подобен на описания по горе. Използвам един брояч counter, който го XOR-вам с GetMicrosecondCount(), и така получавам на практика една безкрайна редица от 64-битови числа, които никога няма да се повторят. На всяко едно от тези числа XOR-вам всички битове с 5 поредни тегления на MathRand(). Резултата е напълно случайно 64 битово число, последователноста на което никога няма да се повтори.


Това число го деля на 8 байта от по 8 бита, като всеки байт има в себе си по едно случайно число с диапазон от 0 до 255. Това число го преобразувам в double и го мащабирам в диапазона от 0.0 до 1.0. След това вече сравнявам това число с търсената вероятност и така генерирам изход или +1 или -1.


Така написаната от мене функция може да тегли случайни числа не само с вероятност 50%, но и с произволна друга желана вероятност, която трябва да се предаде като параметър на функцията.


Написания код не съм го тествал, защото жена ми ме кара да ходим из града по магазините, така че за днеска само това можах да направя. Надявам се kura да пробва неговата си програма с моята случайна финкция. Ето го кода:

//=============================================================
// Функцията връща +1 или -1 с вероятност probability, като гарантира,
// че няма да се появи повторяемост дори и след милиарди извиквания.
// Променливата probability трябва да е в диапазона от 0 до 1
int RandomTick(double probability)
  {
    if (probability <=0) return(-1); // При вероятност 0 (  0%) винаги връщаме -1
    if (probability >=1) return( 1); // При вероятност 1 (100%) винаги връщаме +1
    
    // Статични променливи, инициализацията на които се изпълнява само веднъж в хода на програмата,
    // и след това си пазят стойноста между отделните извиквания на функцията
    static ulong counter=0; // Брояч, който нараства с 1-ца при всяко едно теглене на нов тик
    static ulong random =0; // Случайно число, от байтовете на което ще се теглят тиковете
    
    // Младшите 3 бита на counter са индекса на байта, от който ще се тегли следващия тик
    ulong byteID = counter & ulong(B'111'); 
    
    // Веднъж на всеки 8 извиквания на функцията се преизчислява 64-битовото случайно число random,
    // от 8-те байта на което в 8 последователни извиквания ще се изтегли по 1 случаен тик 
    if (byteID == 0) // Ако индекса на байта е равен на 0, значи е време за преизчисляване на random
      {
        // Осигуряваме си неповтаряща се последователност от числа в променливата random,
        // при която броя на нулите и единиците е приблизително еднакъв в безкрайноста
        random = GetMicrosecondCount() ^ counter; 
        
        // XOR-ваме 64-те бита на random посредством няколко псевдослучайни 15 битови числа
        random = random ^ (ulong(MathRand()));     // XOR-ваме първите    15 бита (битове  0..14)
        random = random ^ (ulong(MathRand())<<15); // XOR-ваме следващите 15 бита (битове 15..29)
        random = random ^ (ulong(MathRand())<<30); // XOR-ваме следващите 15 бита (битове 30..44)
        random = random ^ (ulong(MathRand())<<45); // XOR-ваме следващите 15 бита (битове 45..59)
        random = random ^ (ulong(MathRand())<<60); // XOR-ваме следващите  4 бита (битове 60..63)
      }
    counter++;        
    
    // Вземане на 8-те бита на този байт от random, който е определен с byteID
    // В резултат на операцията (местене на дясно и AND-ване), в младшите 8 бита остава случайно число от 0 до 255
    ulong byte = (random >> (byteID*8)) & B'11111111'; 
    
    // Мащабиране на случайно число byte така, щото диапазона му да стане double от 0.0 до 1.0,       
    double rnd = double(byte) / 256.0;
    
    // Изчисляване на тик с вероятност probability
    if (probability > rnd) return(1);
    else return(-1);
  }

[kypa]

Това със сигурност ще даде многократно по-добър резултат от моя снощния ред. Който между другото не знам с какъв акъл точно съм писал, за да работи що-годе трябва няколко синуса да се умножат и от тях да се дръпне основния. И (очевидно) не е необходимо да се вади каквото и да било от 0.

И графиката добре изглежда с таз функция, от 15 минутки нагоре почти не мога да си харесам сетъп и потвърждение към него.

Може да му се добавят променливи за стойностите. Да може да се задава да връща 1 или 0 и да се ползва и за обема.

int RandomTick(double probability,
               int yes=1,
               int no=-1)
  {
   ...
   if (probability > rnd) return(yes);
   else return(no);
  }

За обема трябва още да се мисли обаче.

[Mateev]

Това с Yes и No ми хареса, и си го поправих и при мене. Направих още една корекция, която още по-добре ще гарантира случайноста. В момента има проблем с това, че в ulong числата counter и random голяма част от старшите битове ще си стоят на 0 през цялото време на работа на компютъра. Вярно е, че ги XOR-ваме с MathRand, но за тези битове остава само това и никакво друго рандомизиране. Затова предлагам реда:
random = GetMicrosecondCount() ^ counter;
да се промени на:
random = random ^ counter ^ GetMicrosecondCount();

Тоест идеята е да не започваме изчисляването на random всеки път от чистата нула, а да използваме старата му стойност, върху която да налагаме новите XOR-вания. По този начин буквално всеки един бит ще се променя почти на всяко едно преизчисляване.

Още една промяна, която е продиктувана от вероятноста counter да се препълни при много интензивно използване на функцията, и да изхвръкне в Overflow грешка. Предлагам реда:
counter++;
да се замени с реда:
if(counter<ULONG_MAX) counter++; else counter=0;

[kypa]

Аз със битови операции въобще не съм се занимавал, и да има нещо да трябва да се подобрява или да се внимава за грешки трудно ще го видя. Едно 20 пъти трябваше да я прочета докато започна да схващам принципа и последователността.
byte може да се ползва за симулация на милисекунди между тикове. Теглим последователно byte, събираме ги и броим колко пъти трябва докато прескочи 60 000.

Туй пробвал ли си:
https://userstyles.org/styles/135310/theme

[kypa]

Тъй май вече става за обществено ползване:

СЛОЧАЕНОС-2.00.mq5.zip

Турих го да смята 2 000 000 бара по подразбиране, не знам колко време ще отнеме за 5 000 000 на що-годе нормален компютър (при мене отива почти минута ).
Нагласил съм го да принтира (в Лента с инструменти/Експерти) времето за основните операции.
Броя на баровете може да се променя в настройките на експерта. Единствения параметър изкаран като настройка всъщност.
Турих го да смята обем между 1 и 512, обикновено между 1 и 256. На 1 минутка флуктуациите в обема между баровете са големи, с качването на фрейма намаляват все повече. Да може и тоз аспект да се разгледа.
Може да се експериментира с различна формула за обем в ред 118.

[K_W]

Невронните мрежи не са подходящи за търсене на зависимости по финансовите пазари, защото:
1. Невронните мрежи ЗАБРАВЯТ старата информация, за да могат да запомнят по-новата в ОГРАНИЧЕНИЯ СИ КАПАЦИТЕТ.
2. Въпреки това неронните мрежи ВИНАГИ ДАВАТ ОТГОВОР, дори и когато той е ГРЕШЕН.
3. Горните две точки важат и за човешкия мозък, който също е невронна мрежа.

Най-големия проблем при търсенето на зависимости е да се разпознае разликата между ФЛУКТУАЦИИТЕ НА СЛУЧАЙНОСТА и истинското движение, породено от ИСТИНСКА ЗАВИСИМОСТ. Това невронната мрежа (и хората) не могат да го направят, в резултат на което вземат ГРЕШНИ РЕШЕНИЯ за търговия.

Ще ви го обясня с един пример. Нека да хвърляме монетка, за която точно и ясно знаем, че е с 50% вероятност. Ако се падне стотинка, рисуваме един тик нагоре, а ако се падне герб - тик надолу. Получава се някаква графика, която е буквално същата като тази, която всеки ежедневно гледа на МетаТрадер-a.

Ако преброим колко герба и колко стотинки са паднали, ще открием например съотношение 57:43, или например 60:40, а не 50:50. Това ще подведе всички невронни мрежи (и хората), че са намерили зависимост. И ще започнат да търгуват по нея (нагоре), но в действителност всички знаем, че вероятноста е 50:50 и в безкрайноста графиката ще се приближи до нея. Тоест тренда няма да продължи нагоре, а след много колебания ще се върне в точка нула.

Та това е причината за самозаблудата на хората, а и на всички невронни мрежи, колкото и добри да са те. За да не се изпада в такава самозаблуда е необходим някакъв инструмент, който ДА РАЗПОЗНАВА ИСТИНСКАТА ЗАВИСИМОСТ и да не я бърка с псевдозависимостите, породени от естествените флуктуации на чистата случайност.

Математиката разполага с такива инструменти, като например ДОВЕРИТЕЛНИЯ ИНТЕРВАЛ. Чрез него можем да проверим каква е вероятноста една зависимост да е истинска, и да продължи и в бъдещето да бъде такава, каквато сме я наблюдавали в миналото. И понеже бъдещето е неопределено, то решението на задачата ще ни даде някакъв ИНТЕРВАЛ, в който с някаква вероятност ще се движи ПМО-то, намерено в миналото. И ако долната граница на този интервал е отрицателна, то тогава е само въпрос на време да си загубим акаунта.

Та това е накратко базовата концепция за печелившост на всяка една търговия (дори и извън финансовите пазари). Трябва да се намери зависимост и да се направи стратегия върху нея така, щото долната граница на доверителния интервал да е положителна. Не успеем ли да го постигнем това, въпрос на време е да си загубим акаунта (или бизнеса). И ако масовия трейдер (или търговец в бизнеса) си направи тези сметки върху историческите си сделки, с ужас ще открие, че неговата долна граница на доверителния интервал е отрицателна. Това е и причината само 5% от хората да успяват да направят стабилен бизнес (печеливша търговия).

Матеев, пак говориш смислени неща

Я обясни как да си сметнем доверителния интервал най лесно?

[K_W]

Другия проблем на повечето хора, търсещи стратегии, е НАДНИЧАНЕТО В БЪДЕЩЕТО. Те го правят това НЕВОЛНО, без дори да се усетят. Най-явната форма е да направят някакъв исторически тест и да видят положителни резултати, след което да си помислят, че са хванали господа за дръжката.

Правилния подход е друг:
1. Тества се стратегията например за първите 2-3 години
2. Подбира се най-добрата комбинация от параметри.
3. Търгува се с тези параметри 1 година.
4. В края на годината се правят нови тестове и се подбира нов комплект от параметри, и отново се връщаме в т.3 (търгува се 1 година).

Този цикъл се развърта по програмен път, и след това анализираме резултатите от търговията по т.3. За тези резултати вече е ясно, че не сме надничали в бъдещето, когато сме преоптимизирали стратегията. Това е паравилния път, но ако го реализирате като код, с ужас ще откриете, че нито една от потенциално печелившите ваши стратегии не е търгувала успешно по този метод.

Между другото тука можете да използвате невронна мрежа, просто за да се убедите, че тя наистина не може да върши никаква работа. Постъпвате по следния начин:
1. Обучавате невронната мрежа с първите 2-3 години от данните.
2. Търгувате 1 година с нея.
3. Преобучавате мрежата, като вече включвате и изминалата година
4. Връщате се в т.2

Метода може да се доразвие, като преобучаването (или новото търсене на зависимости) се извършва не веднъж годишно, а веднъж седмично (в уйкенда) или дори след всяка една сделка (преоптимизиране в реално време). При всички случаи в един и същи експерт ще се наложи да сложите както търговската част, така и часта за търсене на зависимости. Такъв един експерт ако се тества в исторически план, вече ще имате 100% гаранция, че НЕ СТЕ НАДНИЧАЛИ В БЪДЕЩЕТО.

Това тук не ми харесва. Постоянното напасване към пазара според мен си е чиста проба кървене фитинги.
Пазара има цикличност, година 1 и 2 може да са като година 4 и 5 а 3 да е нещо по рядко срещано и рядко повтаряемо събитие.
Ако напасваме системата по година 3 може просто да я влошим.

[K_W]

https://image.ibb.co/bs9qwd/Screenshot_3.png
Матеев нещо такова ли имаш предвид под доверителен интервал?