Kereskedési automatizálás: kódold le az előnyödet, vedd ki az érzelmet

Hajnali 3. A sweep setupod jelez. Te alszol.

A botod beadja az ügyletet, kiteszi a stopot, 3R-t céloz. Miközben te álmodsz.

Reggel 6. Felébredsz. A pozíció lezárva. +2,8R nyereség. A kávé is jobban esik.

Az emberi probléma a kereskedésben

6 hónapot töltöttél egy stratégia csiszolásával. Backtestelted. Előre tesztelted. Találati arány: 62 %. Átlagos R: 2,3. Az előny igazolva.

Elkezded élesben kereskedni. Az eredmény?

A kellemetlen igazság: Van egy nyereséges stratégiád. De a gyenge láncszem TE vagy.

A végrehajtás három gyilkosa

1. Habozás (félelemből való kihagyás)

• Épp két veszteséget szedtél össze. Megjelenik a 3. setup. Azt gondolod: «Talán megvárom a megerősítést…»
• Vársz. Az ár elmegy nélküled. 4R-es nyertes volt. Félelemből maradtál le róla.
• Hatás: A nyertesek kihagyása szétveri a pozitív várható értéket

2. Túlkereskedés (FOMO-belépők)

• A piac elszalad felfelé. A stratégiád azt mondja: «nincs setup». De nem bírod nézni. Beszállsz mégis.
• Nincs stop. Nincs terv. Csak remény. Megfordul. Veszítesz.
• Hatás: A véletlenszerű belépők zajjal hígítják az előnyödet

3. Következetlen pozícióméret

• A setup: 1 %-ot kockáztatsz (óvatos vagy a legutóbbi veszteség után)
• B setup: 5 %-ot kockáztatsz (magabiztos vagy, «ezt érzem»)
• Az A setup 3R-t hoz. Csinálsz 3 %-ot. A B setup 1R-t bukik. Veszítesz 5 %-ot. Nettó: -2 %.
• Hatás: Egyetlen rossz méretezési döntés kitöröl 3 jó ügyletet

A méretezés problémája (a kézi kereskedés korlátai)

A kézi kereskedés plafont tesz a lehetőségeidre:

Példa: Egy kézi kereskedő az ES-t (S&P határidős) nézi 15 perces grafikonon. Hetente nagyjából 8 setupot kap el. Átlagosan 3200 dollárt keres havonta — setuponként körülbelül 92 dollárt.

Ugyanez a kereskedő automatizálva: A bot az ES, NQ és RTY (indexhatáridős) mellett a GC-t és a CL-t (fém és energia) pásztázza 5p, 15p és 1ó időtávon. Hetente nagyjából 24 setupot kap el. Ugyanazon 92 dolláros setupértékkel ez havi 9600 dollár.

Amit ez felold: Nem jobban kereskedsz. TÖBBET kereskedsz — anélkül, hogy kiégnél.

És a plafon: Az ES, MES, SPY és QQQ nagyrészt ugyanaz az ügylet. Korrelált szimbólumok hozzáadása a jelzések számát sokszorozza, nem az előnyödet — a kockázatodat viszont igen, ha négy egyszerre lő. Korrelálatlan lehetőségeket számolj, ne tickereket.

Mikor van értelme automatizálni (és mikor nincs)

Az automatizálás ezekre a legjobb:

• Szabályalapú stratégiák: Világos be- és kilépési feltételek (pl. «vásárolj, ha az ár lesöpör egy alját, majd visszaveszi»)
• Gyakori setupok: Olyan stratégiák, amelyek hetente több mint 10-szer jeleznek (a darabszám indokolja a kódolást)
• Unalmas végrehajtás: Olyan stratégiák, ahol a mérlegelés nem ad hozzá semmit (mechanikus előnyök)

Az automatizálás ezekkel küzd:

• Diszkrecionális setupok: «Csak akkor kereskedem, amikor *jónak érzem*» (az ösztön nem kódolható)
• Kontextusfüggő ügyletek: «Ez a kitörés akkor működik, ha a forgalom az átlag 2-szerese fölött van ÉS van hírkatalizátor» (az összetett kontextust nehéz számszerűsíteni)
• Ritka stratégiák: Setupok, amelyek havonta 1-2-szer jeleznek (nem éri meg lekódolni)

Bróker-API-k összehasonlítása

Nem minden bróker támogatja az automatizált kereskedést. Amelyek igen, azok is nagyon eltérnek minőségben, költségben és funkcióban.

A legjobb bróker-API-k automatizált kereskedéshez

Gyors döntési útmutató

Az Alpacát válaszd, ha: most tanulod az automatizálást (a legkönnyebb API, ingyenes papírkereskedés, a legjobb dokumentáció). Az Interactive Brokerst válaszd, ha: opció, határidős vagy globális piac kell (minden eszközosztály, 0,005 dollár/darab, intézményi színvonal). A Binance-t válaszd, ha: csak kriptóval foglalkozol (megszakítás nélküli piac, több mint 600 pár, 0,1 % díj).

A kereskedési ötlettől a futtatható kódig

Van egy kézi stratégiád. Hogyan fordítod le olyan kódra, amelyet egy bot végre tud hajtani?

Az 5 lépéses stratégiafordítási keret

1. lépés: a belépési feltételek meghatározása (csak explicit szabályok)

A kézi kereskedő így gondolkodik: «Akkor veszek, ha az ár lesöpör egy alját, és visszapattan.»

Ez egy botnak túl homályos. A botnak pontos logika kell:

• Mi az a «sweep»? → Az aktuális gyertya alja legalább 0,3 %-kal a korábbi swing-alj alá süllyed
• Mit jelent a «visszapattan»? → Az ár 1-3 gyertyán belül újra a swing-alj fölött zár
• Mi az a «swing-alj»? → Az elmúlt 20 gyertya legalacsonyabb alja

Kódolva:

swing_low = min([bar.low for bar in last_20_bars])
current_low = current_bar.low
current_close = current_bar.close

if current_low < swing_low * 0.997:  # 0,3 %-kal alasoport
    if current_close > swing_low:     # visszavette
        ENTRY = True  # sweep setup megerositve

2. lépés: a kilépési feltételek meghatározása (stop és cél)

A kézi kereskedő: «A stopot a lesöprés alá teszem, és 3:1 kockázat-hozam aránynál realizálok.»

Kódolva:

entry_price = current_close
stop_loss = swing_low * 0.995  # kozvetlenul a lesopres alatt
stop_distance = entry_price - stop_loss
target = entry_price + (stop_distance * 3)  # 3R-es cel

3. lépés: a pozícióméret meghatározása (kockázatkezelés)

A kézi kereskedő: «Ügyletenként körülbelül 2 %-ot kockáztatok.»

Kódolva:

account_equity = 100000  # 100 000 dollaros szamla
risk_per_trade = 0.02    # 2 %
risk_amount = account_equity * risk_per_trade  # 2000 dollar

stop_distance = entry_price - stop_loss
position_size = risk_amount / stop_distance  # megveendo reszvenyek

# Pelda: belepo 520 dollar, stop 518 dollar, tavolsag 2 dollar
# Poziciomeret = 2000 dollar / 2 dollar = 1000 reszveny
# ...ami 520 000 dollarnyi SPY egy 100 000 dollaros szamlan. A 2 %-os
# kockazati szabaly semmit nem mond a nevertekrol: a szuk stop attetelt vesz.
max_notional = account_equity * 1.5   # kemeny plafon: a sajat toke 1,5-szerese
position_size = min(position_size, max_notional / entry_price)
# Plafonnal: 288 reszveny. A valos kockazat 576 dollar, nem 2000 -
# ez az ara, es pont ez tart benn a jatekban.

4. lépés: az ügyletkezelés meghatározása (opcionális)

Részletekben szállsz ki? Húzod a stopot? Realizálsz részlegesen?

Példa: «2R-nél 50 % nyereséget realizálok, a többit hagyom futni 3R-ig.»

if current_price >= entry_price + (stop_distance * 2):
    SELL_HALF = True  # 2R-nel 50 % zarasa
    # A maradek 50 % stopjat nullszaldora huzni

5. lépés: a szűrők meghatározása (rossz setupok kizárása)

Milyen körülmények érvénytelenítik a setupot?

• Időszűrő: Csak a tőzsdenap első 2 órájában kereskedj (keleti idő szerint 9:30-11:30)
• Volatilitásszűrő: Hagyd ki az ügyleteket, ha a VIX 30 fölött van (túl szaggatott)
• Trendszűrő: Csak long setupok, ha az ár az 50 periódusos EMA fölött van

if VIX > 30:
    SKIP_TRADE = True  # tul volatilis a piac

if current_time < "09:30" or current_time > "11:30":
    SKIP_TRADE = True  # a kereskedesi ablakon kivul

# 1. lepes: belepesi feltetelek
swing_low = min([bar.low for bar in last_20_bars])
if current_bar.low < swing_low * 0.997:  # sweep
    if current_bar.close > swing_low:     # visszavette

        # 2. lepes: kilepesek
        entry = current_bar.close
        stop = swing_low * 0.995
        target = entry + ((entry - stop) * 3)

        # 3. lepes: poziciomeret
        risk_amount = account_equity * 0.02
        size = risk_amount / (entry - stop)

        # 4. lepes: ugyletkezeles (50 % 2R-nel)
        profit_target_partial = entry + ((entry - stop) * 2)

        # 5. lepes: szurok
        if VIX < 30 and time_in_window():
            PLACE_ORDER(symbol, size, entry, stop, target)

A bot teljes megvalósítása (sweep-fordulós stratégia)

import alpaca_trade_api as tradeapi
from alpaca_trade_api.rest import TimeFrame
import os, time

# Beallitas
API_KEY = os.getenv('ALPACA_API_KEY')  # SOHA ne ird bele a kodba!
API_SECRET = os.getenv('ALPACA_API_SECRET')
api = tradeapi.REST(API_KEY, API_SECRET, 'https://paper-api.alpaca.markets')

MAX_NOTIONAL_MULT = 1.5   # soha ne tarts a sajat toke 1,5-szeresenel tobbet
MAX_DAILY_LOSS = 0.03     # veszleallito: -3 %-nal aznapra leallunk

def get_swing_low(bars, lookback=20):
    # Hagyd ki az aktualis gyertyat. Ha benne van, a swing-alj MAGA az
    # aktualis alj, a sweep-teszt sosem igaz, es a bot sosem lo el.
    lows = [bar.l for bar in bars[-(lookback + 1):-1]]
    return min(lows)

def check_sweep(current_price, current_low, swing_low):
    # Sweep = aktualis alj < swing-alj (0,3 %), majd vissza fole
    if current_low < swing_low * 0.997 and current_price > swing_low:
        return True
    return False

def calculate_position_size(api, entry, stop):
    equity = float(api.get_account().equity)
    risk_amount = equity * 0.02                        # 2 % kockazat
    by_risk = risk_amount / (entry - stop)
    by_notional = (equity * MAX_NOTIONAL_MULT) / entry  # a kontroll, amit Mike kihagyott
    return int(min(by_risk, by_notional))

def kill_switch_tripped(api):
    acct = api.get_account()
    move = (float(acct.equity) - float(acct.last_equity)) / float(acct.last_equity)
    return move <= -MAX_DAILY_LOSS

def in_position(api, symbol):
    # Kerdezd meg a brokert; ne bizz egy lokalis valtozoban. Egy bracket, ami
    # ejjel teljesult es lezarult, ne blokkolja a holnapi setupot.
    try:
        api.get_position(symbol)
        return True
    except Exception:
        return False

def place_bracket_order(api, symbol, size, entry, stop, target):
    try:
        order = api.submit_order(
            symbol=symbol, qty=size, side='buy', type='limit',
            limit_price=entry, time_in_force='gtc',
            order_class='bracket',
            stop_loss={'stop_price': stop},
            take_profit={'limit_price': target}
        )
        print(f"✓ Megbizas: {size} reszveny @ ${entry} | Stop: ${stop} | Cel: ${target}")
        return order
    except Exception as e:
        print(f"✗ A megbizas nem ment at: {e}")
        return None

def run_bot(symbol='SPY'):
    print(f"A bot elindult. Figyelem a(z) {symbol} sweep setupjait...")

    while True:
        try:
            if not api.get_clock().is_open:      # 1. kontroll: tozsdeidő
                time.sleep(60)
                continue
            if kill_switch_tripped(api):         # 2. kontroll: napi veszteseglimit
                print("🛑 Elertuk a napi veszteseglimitet. Leallok.")
                break

            bars = api.get_bars(symbol, TimeFrame.Minute, limit=50)
            current_price = bars[-1].c
            current_low = bars[-1].l
            swing_low = get_swing_low(bars)

            if not in_position(api, symbol) and check_sweep(current_price, current_low, swing_low):
                print(f"🎯 Sweep eszlelve @ ${current_price}")
                entry = current_price
                stop = swing_low * 0.995
                target = entry + (entry - stop) * 3  # 3R
                size = calculate_position_size(api, entry, stop)   # 3. kontroll: neverték-plafon
                if size > 0:
                    place_bracket_order(api, symbol, size, entry, stop, target)

            time.sleep(60)  # percenkent ellenorizzuk
        except Exception as e:
            print(f"Hiba: {e}")
            time.sleep(60)

run_bot()  # ~75 sor - es a harom legfontosabb kozuluk a kontroll.

Mit csinál ez: Csatlakozik az Alpacához, lehúzza a SPY 1 perces gyertyáit, felismeri a sweep utáni fordulókat (az alj lesöpör a swing-alj alá, majd visszaveszi), 2 %-os kockázat alapján méretez névérték-plafonnal korlátozva, bracket megbízást ad be (belépő + stop + 3R-es cél), és mindezt 60 másodpercenként megismétli — de csak nyitott piac mellett, csak akkor, ha a bróker szerint nincs pozíció, és soha, ha a nap -3 %-ban áll. Tökéletes fegyelem, nulla érzelem, három fék.

A papírkereskedés ≠ éles kereskedés

A botod papíron tökéletesen fut. Élesíted. Összeomlik. Megbízásokat utasítanak vissza. Nem érted, mi történik.

Üdv az éles üzemben.

Gyakori hibák (és hogyan kezeld őket)

Gyakori hibák: Kapcsolati időtúllépés, elutasított megbízás, részteljesülések, kéréskorlátok, zárva tartó piac. Megoldások: Újrapróbálkozási logika (3×, exponenciális várakozással), előzetes ellenőrzések (fedezet, nyitvatartás, ár), részteljesülések kezelése, kéréskorlátozás (percenként 200), tőzsdeidő-ellenőrzés (keleti idő szerint 9:30-16). A profi botok elegánsan kezelik a hibákat.

Újrapróbálkozási logika (elengedhetetlen)

import uuid

def place_order_with_retry(api, **order_params):
    """A megbizas kuldesenek ujraprobalasa legfeljebb 3-szor"""
    max_retries = 3

    # Minden probalkozasnal ugyanaz az azonosito. Ha az elso keres tenyleg
    # elert a brokerhez, es csak a valasz veszett el, az ujraprobalast
    # duplikatumkent utasitjak vissza a pozicio megduplazasa helyett.
    order_params.setdefault('client_order_id', f"bot-{uuid.uuid4()}")

    for attempt in range(max_retries):
        try:
            order = api.submit_order(**order_params)
            return order  # Sikerult!

        except Exception as e:
            if attempt < max_retries - 1:
                wait = 2 ** attempt  # 1s, majd 2s (exponencialis varakozas)
                print(f"A megbizas nem ment at: {e}. Ujraprobalas {wait}s mulva...")
                time.sleep(wait)
            else:
                # Az utolso probalkozas is elbukott
                print(f"A megbizas {max_retries} probalkozas utan sem ment at: {e}")
                # Riasztas kuldese (e-mail, SMS)
                raise  # A kivetel ujradobasa

Felügyelet és riasztások (kritikus)

A botod egy felhős VPS-en fut. Te vacsorázol. A bot hibába ütközik.

Honnan tudod meg?

Válasz: Riasztásokból.

import smtplib
from email.mime.text import MIMEText

def send_alert(subject, message):
    """Riasztas kuldese e-mailben"""
    msg = MIMEText(message)
    msg['Subject'] = subject
    msg['From'] = 'bot@yourbot.com'
    msg['To'] = 'you@gmail.com'

    # Kuldes a Gmail SMTP-jen at - ehhez Gmail-alkalmazasjelszo kell,
    # nem a fiokod jelszava; az alap hitelesitest 2022-ben kikapcsoltak.
    with smtplib.SMTP('smtp.gmail.com', 587) as server:
        server.starttls()
        server.login('bot@yourbot.com', os.getenv('EMAIL_PASSWORD'))
        server.send_message(msg)

# Hasznalat
try:
    # Kereskedesi logika
    pass
except Exception as e:
    send_alert(
        subject="🚨 Hiba a kereskedesi botban",
        message=f"A bot hibaba utkozott: {e}"
    )
    raise

Mostantól perceken belül megtudod, ha valami elromlik.

Üzemeltetés: hol fusson a botod

Az automatizálás nem «beállítom és elfelejtem»

Élesíted a botodat. Egy hónapig kereskedik. Sikeraránya: 65 %. Pont mint a backtestben. Odavagy tőle.

2. hónap: a sikerarány 48 %-ra esik. Nem érted.

Mi történt?

Megváltozott a piaci rezsim. A stratégiád trendelő piacon működik. A piac oldalazásba váltott. A botod tovább kereskedett. Az eredmények megsínylették.

A bot havi karbantartási listája

1. Teljesítménymutatók: A találati arány a backtest 5 %-án belül van? Az átlagos R pozitív? A drawdown elfogadható? Romlott a slippage? 2. Hibanaplók: Kapcsolati hibák, elutasított megbízások, szélsőséges esetek. 3. Rezsimellenőrzés: A piac még mindig kedvez a stratégiának? Magas VIX → szüneteltetés. Alacsony volatilitás → a kitörések nehezen mennek.

Ha idáig eljutottál, megértetted: az automatizálás nem varázslat, hanem fegyelmezett végrehajtás nagy léptékben. Kódold le az előnyödet. Teszteld szigorúan. Élesíts óvatosan. Figyeld folyamatosan.

Kapcsolódó leckék