Soci blog

Informatikai elemzés, mitől volt a tőzsdebeszakadás.
Egészen megdöbbentő. Kb. arról szól, hogy a New Yorki tőzsdéről elkezdtek késni az adatok, amitől megborult a tőzsdék közötti, legjobb árat szabályozó replikációs rendszer. A késés oka az lehetett, hogy túlterhelődött a tőzsde adatelosztója, és az ajánlatok időbélyegét (elég furcsa módon) nem az ajánlat beadásakor írják be, hanem amikor kijön a csőből. Emiatt kívülről nem látszik a csúszás. De ami érdekesebb, mitől dugult be a tőzsde?
Ma már nagyon sok nagyfrekvenciás algoritmus fut, amelyek már ms alatti idők alatt döntenek és reagálnak (ezek a szerverek a tőzsde LAN-ján vannak, nagyon közel a fő számítógépek hálózatához, így a hálózati késeltetés csak mikrosec nagyságrendű).
Ezek egymással persze versenyeznek. És itt jön a buli. Valamelyik algoritmus elkezd mpeknként több ezer ajánlatot beküldeni. Ő persze nem elemzi ezeket, hisz ő küldte be. De a többiek ezt elemzik, és amíg ezzel töltik az időt, ő ráér kisajtolni a profitot. Spamelik a tőzsdét. Ez persze destabilizálja az egész rendszert. A skynet ébredezik.

Kósa shortol:

Bmeg, ezeknek szerintem elment az esze. Vagy tényleg shortolnak. Nem tudom, melyik a veszélyesebb.
Ami leginkább felháborít a dologban, az az, hogy nem vállalják a felelősséget a szavaikért. Á, miattunk nem esik a tőzsde. Persze, hogy most az egész világban idegesek a befektetők, morog a maci, de pont ilyenkor kell ésszel beszélni.
Mint a kisgyerek, amikor tűzzel játszik, leég a ház, aztán néz kerek szemekkel, hogy ő nem így gondolta. De ez egy ország, nem egy ház!

Ma majdnem 10%-ot esett a Dow index, a többi is olyat zuhant, amilyet még nem láttam.
Az egyik cég részvényei (ACN) pár perc alatt beestek 40$-ról 0,01-ra, aztán vissza kb. 40-re. Gondolj bele, valaki megvette ekkor mondjuk 1$-ért a részvényeket, majd 5 perc múlva eladta 40x haszonnal.

Az okok között szerepel, hogy a görögök miatt be van mindenki tojva, de, és most jön az érdekes. Ekkora visszaesést mint az előbbi részvénynél nem tud okozni a pánik eladás. A pletykák szerint egy trader b-t írt be véletlenül m helyett, így az eladás (vagy short) billion lett million helyett. :) Pár nap múlva kiderül, mi volt pontosan.

Update: Kérdezték, mi történt volna, ha már menne a kereskedő algoritmusom?
Ez teljesen attól függ milyen az alg, és éppen pozícióban volt-e a zutty előtt. Vagy nagyon sokat keres, vagy sokat bukik. Waterfall profit vagy loss, az ilyen volatilitású napokon ez kiszámíthatatlan. Egyébként már rollbackelik vissza keményen a tőzsdei adatbázisokat, a tegnapi kritikus 20 perc kereskedéseit, a borokerek meg mozgatják vissza a pénzeket az accountok között, azokat, amelyek által érintett trade-k több mint 60%-kal kimásztak a korábbi árból. A tegnapi 1 centre leesett 40$-os részvény is ma már 17$-ra vissza van húzva, akinek volt pár százszoros profitja és pezsgőzött éjszaka, ma már csak 60%-os haszna maradt. Az se rossz. :)

A legtöbb riport item az RS-ben intuitív, na, ez nem az. Ezzel a chart fajtával nagyon jól lehet szemléltetni nagyszámú minta eloszlását, jól látszik pl. hol tömörödnek az értékek csoportokba (clusterekbe).

Nekem pl. intraday trade-ek elemzésére kiváló (példaként itt a rendszerem egyik riportja, a pötyösek a scatterek), mivel több mint ezer trade történik 2-3 évnyi adat tesztelése során, amelyek teljesítményét jól lehet vizualizálni a scatter chart segítségével valamely változó függvényében.

A chart beélesztésében ez segített.

Feliratkoztam egy-két angol nyelvű trading (tőzsde) blogra, és az egyikben látom, hogy egy táblázatban ki van emelve Magyarország és a környező országok. Kiemelték, mert akkora az államadósság, hogy garantáltan lehet fogadni pl. a Ft esésre vagy a hazai blue-chipek esésére. Kérdezi is valaki egy kommentben, hogy van-e kelet-európai ETF (Exchage Traded Fund, olyan több részvényt magába foglaló alap, amivel lehet kereskedni), amin lehetne egy jót shortolni.
Szomorú ez, kívülről végül is csak pár kis diagram vagyunk, ami szépen zuhan lefelé, elég biztosan lehet az esésre fogadni. De, hogy közben mi lesz itthon velünk, akik ennek részesei vagyunk, azt nem tudom.
Okos politikusaink szépen bevezetnek minket a mocsár közepére, ahol elsüllyedhetünk. Mi meg megyünk mint a birkák. :(

Az utóbbi pár hétben rendkívül intenzíven egy programot írok - egy Automated Trading System-et, így mondják ezeket angolul. Azaz egy olyan programot, amely real-time tőzsdei adatok alapján automatikusan döntéseket hoz, ad-vesz. Persze a dolog a valóságban elképesztően bonyolult tud lenni, de programozási gyakorlatnak mindenképpen érdekes.

A rendszer részleteiről egyelőre nem akarok írni, majd ha működik, beszélek róla - bár lehet, hogy pont akkor nem kellene, mi? :)

No, a lényeg, hogy az ilyen rendszereket az ember csak akkor indít el, ha nagyon hosszú múltbeli adatokon végigpróbálva elég jó a nyereség/veszteség aránya, és nem csinál zsinórban annyi veszteséget, ami már pszichológialiag fáj, vagy akár le is nullázza az erre szánt pénzt.
Ezt a tesztelést hívják backtest-nek. Ehhez adatok kellenek, amit persze pénzért adnak, de ez már csak ilyen, ha ez ember pénzt akar keresni, ahhoz be is kell fektetni.
Nekem most már van több mint 10 évnyi perces adatom a legnagyobb likviditású futures-ökhöz (S&P 500 E-Mini, Nasdaq E-Mini, stb.).
Jöhet a szakma. A backtest írásakor kialakult a következő kódrészlet:

class BackTestSession
{
...
  for (int i = 0; i < bars.Count; i++)
  {
    foreach (TradingAlgorithm alg in algs)
    {
       StepOne(alg, i);
    }
  }

private void StepOne(TradingAlgorithm alg, int i)
{
    if (!alg.InLong && !alg.InShort)
    {
        decimal entryPrice;
        TradeActionReason reason = alg.WantToBuyLong(i, out entryPrice);
        if (reason != TradeActionReason.None)
        {
            return;
        }

        reason = alg.WantToSellShort(i, out entryPrice);
        if (reason != TradeActionReason.None)
        {
            return;
        }
        return;
    }

    if (alg.InLong)
    {
        TradeActionReason reason = alg.WantToSellLong(i);
        if (reason != TradeActionReason.None)
        {
            return;
        }
    }

    if (alg.InShort)
    {
        TradeActionReason reason = alg.WantToCoverShort(i);
        if (reason != TradeActionReason.None)
        {
            return;
        }
    }
    return;
}
...
}

Ez a kód messziről bűzlik. Mi a gond vele? Nem jó helyen lakik. Figyeljük meg, hogy egyfolytában egy másik típuson (TradingAlgorithm) végez műveleteket, átnyúlkál oda adatokért és műveleteket végezve rajta.
Ez egy code smell a refactoringok házatáján, amire megoldás, ha elköltöztetjük a metódust a helyére. Move method refactoring.

class BackTestSession
{
  for (int i = 0; i < bars.Count; i++)
  {
      foreach (TradingAlgorithm alg in algs)
      {
          alg.StepOne(i);
      }
  }
}

class TradingAlgorithm
{
    public void StepOne(int i)
    {
        if (!InLong && !InShort)
        {
            decimal entryPrice;
            TradeActionReason reason = WantToBuyLong(i, out entryPrice);
            if (reason != TradeActionReason.None)
            {
                return;
            }

            reason = WantToSellShort(i, out entryPrice);
            if (reason != TradeActionReason.None)
            {
                return;
            }
            return;
        }

        if (InLong)
        {
            TradeActionReason reason = WantToSellLong(i);
            if (reason != TradeActionReason.None)
            {
                return;
            }
        }

        if (InShort)
        {
            TradeActionReason reason = WantToCoverShort(i);
            if (reason != TradeActionReason.None)
            {
                return;
            }
        }
        return;
    }
}

Látható a különbség? Sokkal direktebb lett a kód, oda került a metódus, ahová való. Erről szól az első GRASP pattern, az Information Expert.

Következő refactoring lenne az out paraméterek kiirtása, lecserélése member változóra. Erre még a VS is ad refactoring támogatást.

És most jön a shameless plug (bár nem ezért kezdem el írni a cikket, de ki nem hagynám a lehetőséget :): A Netacademiában márciusban lesz újra Design Patterns tanfolyamom, ahol az objektumorientált programozás praktikáit mutatom meg 4 napban, ilyen egyszerűeket mint a fenti, és sokkal bonyolultabbakat is. A régi tananyagot átírom a következő hetekben, kiegészítve .NET Fw. 3.5-ös példákkal (WCF-ben és WPF-ben nagyon szép példákat látni a patternekre).