Multi-Factor Backtesting: Przykłady Kodów Python

Chcesz przetestować strategię inwestycyjną w Pythonie? Oto jak to zrobić krok po kroku.

W artykule znajdziesz:

• Wyjaśnienie inwestowania wieloczynnikowego (value, momentum, quality, zmienność).
• Narzędzia w Pythonie, takie jak pandas, numpy, backtrader, yfinance.
• Przykłady kodów obliczających wskaźniki finansowe i tworzących portfel.
• Instrukcję konfiguracji środowiska (instalacja bibliotek, struktura projektu).
• Metody optymalizacji i analizy wyników strategii.

Kluczowe punkty:

1. Czynniki inwestycyjne: Value (np. P/E), Momentum, Quality (np. ROE), Zmienność.
2. Narzędzia: pandas, numpy, backtrader, yfinance, TA-Lib.
3. Kod strategii: Obliczanie wskaźników, punktacja czynników, reguły portfela.
4. Backtesting: Testowanie strategii na danych historycznych, analiza wyników (CAGR, Sharpe Ratio).
5. Zaawansowane techniki: Optymalizacja wag, analiza kosztów transakcyjnych, testy wielookresowe.

Szybkie porównanie narzędzi:

Dzięki tym narzędziom możesz efektywnie tworzyć i testować strategie wieloczynnikowe.

Backtesting.py – Full course in python

Python Setup Guide

Aby rozpocząć proces backtestingu, najpierw przygotuj środowisko Pythona.

Wymagana instalacja oprogramowania

Poniżej znajdziesz listę niezbędnych komponentów do konfiguracji środowiska:

Najpierw pobierz Python ze strony python.org, a następnie zainstaluj wymagane biblioteki za pomocą pip:

pip install pandas numpy backtrader yfinance

Instalacja TA-Lib na Windows

Dla użytkowników systemu Windows instalacja TA-Lib wymaga dodatkowego kroku:

1. Pobierz skompilowaną wersję pliku .whl ze strony https://www.lfd.uci.edu/~gohlke/pythonlibs/#ta-lib.
2. Zainstaluj plik za pomocą poniższej komendy:

pip install TA_Lib‑0.4.24‑cp38‑cp38‑win_amd64.whl

Po zakończeniu instalacji wszystkich wymaganych bibliotek możesz przejść do konfiguracji środowiska programistycznego.

Konfiguracja środowiska programistycznego

Wybierz odpowiednie środowisko IDE w zależności od swoich potrzeb:

Instalacja Jupyter Lab

Aby zainstalować i uruchomić Jupyter Lab, użyj poniższych komend:

pip install jupyterlab
jupyter lab

Konfiguracja pliku .env

Stwórz plik .env i zdefiniuj w nim podstawowe zmienne środowiskowe:

DATA_PATH="./data"
RESULTS_PATH="./results"
LOG_LEVEL="INFO"

Struktura katalogów projektu

Dla lepszej organizacji kodu i danych, zastosuj poniższą strukturę katalogów:

project/
├── data/
│   ├── raw/
│   └── processed/
├── strategies/
├── results/
└── notebooks/

Po poprawnym skonfigurowaniu środowiska, możesz rozpocząć tworzenie i testowanie strategii opisanych w dalszych częściach artykułu.

Tworzenie Strategii Czynnikowych

Wybrane czynniki, omówione wcześniej, są teraz przedstawione w formie implementacji kodu.

Wybór Czynników

Dobór czynników to kluczowy element strategii. Oto przykład implementacji trzech podstawowych czynników:

import pandas as pd
import numpy as np

def calculate_value_factor(df):
    # Obliczanie wskaźnika P/E (Price to Earnings)
    df['PE'] = df['close'] / df['earnings_per_share']
    # Normalizacja wskaźnika
    df['value_score'] = -1 * (df['PE'] - df['PE'].mean()) / df['PE'].std()
    return df

def calculate_momentum_factor(df):
    # Momentum 12-miesięczny z pominięciem ostatniego miesiąca
    df['momentum'] = df['close'].pct_change(periods=252) - df['close'].pct_change(periods=21)
    df['momentum_score'] = (df['momentum'] - df['momentum'].mean()) / df['momentum'].std()
    return df

def calculate_quality_factor(df):
    # ROE jako wskaźnik jakości
    df['quality_score'] = (df['net_income'] / df['equity']).rolling(window=252).mean()
    df['quality_score'] = (df['quality_score'] - df['quality_score'].mean()) / df['quality_score'].std()
    return df

System Punktacji Czynników

System punktacji wymaga odpowiedniego ważenia i normalizacji. Poniżej przykład implementacji:

def calculate_combined_score(df, weights={'value': 0.4, 'momentum': 0.3, 'quality': 0.3}):
    df['combined_score'] = (
        weights['value'] * df['value_score'] +
        weights['momentum'] * df['momentum_score'] +
        weights['quality'] * df['quality_score']
    )
    return df

Wagi czynników mogą być dostosowane w zależności od preferencji:

Na podstawie punktacji łączonej definiowane są reguły portfela.

Reguły Portfelowe

Reguły portfelowe obejmują wybór akcji i zasady rebalancingu:

def create_portfolio(df, top_n=10, rebalance_freq='M'):
    # Wybór top N akcji na podstawie combined_score
    portfolio = df.groupby(pd.Grouper(freq=rebalance_freq)).apply(
        lambda x: x.nlargest(top_n, 'combined_score')
    )

    # Równe ważenie pozycji
    portfolio['weight'] = 1.0 / top_n

    # Obliczanie zwrotów portfela
    portfolio['portfolio_return'] = portfolio['returns'] * portfolio['weight']

    return portfolio

Przykładowe parametry strategii portfelowej:

Podczas implementacji strategii uwzględnij koszty transakcyjne oraz filtry płynności, takie jak minimalny dzienny obrót wynoszący 100 000 PLN.

Metody Backtestingu w Pythonie

Przy wdrażaniu strategii inwestycyjnych warto przetestować je za pomocą narzędzi backtestingu dostępnych w Pythonie.

Narzędzia Backtestingu

Biblioteka Backtesting.py oferuje możliwości testowania strategii opartych na wielu czynnikach. Przykład implementacji:

from backtesting import Backtest, Strategy
import pandas as pd
import numpy as np

class MultiFactorStrategy(Strategy):
    def init(self):
        # Inicjalizacja wskaźników
        self.value = self.I(calculate_value_factor)
        self.momentum = self.I(calculate_momentum_factor)
        self.quality = self.I(calculate_quality_factor)

        # Obliczanie combined_score
        self.combined_score = self.I(lambda x: (
            0.4 * self.value + 
            0.3 * self.momentum + 
            0.3 * self.quality
        ))

    def next(self):
        if self.data.combined_score[-1] > 0.5:
            self.buy()
        elif self.data.combined_score[-1] < -0.5:
            self.sell()

Przykładowa Strategia

Poniżej znajduje się kompletny przykład kodu do uruchomienia testów:

def run_backtest(data, params):
    # params musi zawierać 'top_n' i 'rebalance_freq'
    bt = Backtest(
        data,
        MultiFactorStrategy,
        cash=100000,
        commission=0.001,
        exclusive_orders=True
    )

    stats = bt.run(
        top_n=params['top_n'],
        rebalance_freq=params['rebalance_freq']
    )
    return stats

W tym przykładzie ustawiono kapitał początkowy na 100 000 PLN, prowizję na poziomie 0,1%, rebalancing co 21 dni oraz minimalną transakcję w wysokości 1 000 PLN.

Analiza Wyników

Do oceny skuteczności strategii można wykorzystać kluczowe wskaźniki:

def analyze_performance(stats):
    metrics = {
        'CAGR': stats['Return [%]'],
        'Sharpe Ratio': stats['Sharpe Ratio'],
        'Max Drawdown': stats['Max. Drawdown [%]'],
        'Win Rate': stats['Win Rate [%]']
    }
    return pd.DataFrame(metrics)

Przykładowe wyniki strategii testowanej na danych WIG20 (2020-2024):

Strategia powinna być testowana w różnych okresach, aby sprawdzić jej działanie w zmiennych warunkach rynkowych.

Zaawansowane Techniki Backtestingu

Poniżej znajdziesz bardziej zaawansowane metody, które mogą pomóc w precyzyjnym testowaniu i doskonaleniu strategii inwestycyjnych.

Optymalizacja Strategii

Dostosowanie parametrów strategii wieloczynnikowej można przeprowadzić za pomocą modułu scipy.optimize. Oto przykład optymalizacji wag portfela:

from scipy.optimize import minimize

def optimize_weights(data, initial_weights):
    def objective(weights):
        # Minimalizacja ujemnej wartości Sharpe Ratio
        return -calculate_sharpe_ratio(data, weights)

    constraints = {
        'type': 'eq',
        'fun': lambda w: np.sum(w) - 1.0
    }

    bounds = tuple((0, 1) for _ in range(len(initial_weights)))

    result = minimize(
        objective,
        initial_weights,
        method='SLSQP',
        bounds=bounds,
        constraints=constraints
    )

    return result.x

Testowanie na Wielu Przedziałach Czasowych

Aby ocenić skuteczność strategii w różnych warunkach rynkowych, warto przeprowadzić testy na kilku przedziałach czasowych:

def multi_period_test(data, periods):
    results = {}
    for start_date, end_date in periods:
        period_data = data[start_date:end_date]
        bt = Backtest(
            period_data,
            MultiFactorStrategy,
            cash=100000,
            commission=0.001
        )
        results[(start_date, end_date)] = bt.run()
    return results

Przykład wyników dla indeksu WIG20 w różnych okresach:

Analiza Kosztów Transakcyjnych

Koszty transakcyjne mogą znacząco wpłynąć na wyniki strategii. Warto je oszacować i uwzględnić w analizie:

def calculate_transaction_costs(price, volume, commission_rate=0.001, 
                             min_commission=5.0):
    base_commission = price * volume * commission_rate
    return max(base_commission, min_commission)

def apply_slippage(price, volume, avg_daily_volume, 
                  slippage_factor=0.1):
    impact = (volume / avg_daily_volume) * slippage_factor
    return price * (1 + impact)

Przykład wpływu kosztów na wyniki strategii dla portfela o wartości 100 000 PLN:

Podsumowanie i Materiały Dodatkowe

Kluczowe Wnioski

Przygotowanie do backtestingu strategii wieloczynnikowych wymaga solidnej wiedzy technicznej. Oto najważniejsze elementy:

Szczególnie istotne jest dokładne uwzględnienie kosztów transakcyjnych. Ich niedoszacowanie może prowadzić do błędnych wniosków o rentowności strategii.

Te podstawy są niezbędne dla dalszego doskonalenia strategii inwestycyjnych.

Kolejne Kroki

Aby rozwijać swoje umiejętności i strategie, warto skupić się na kilku kluczowych działaniach:

• Rozwijanie umiejętności technicznych
  Naucz się korzystać z zaawansowanych narzędzi analitycznych, w tym tych opartych na sztucznej inteligencji. Automatyzacja analiz historycznych pozwala na bardziej precyzyjne wnioski.
• Ulepszanie strategii
  Zrozumienie różnic między ETF-ami a funduszami inwestycyjnymi może pomóc w wyborze odpowiednich metod testowania strategii.
• Unikanie typowych błędów
  Przed wdrożeniem strategii w realnym środowisku, upewnij się, że:
  • Portfel jest odpowiednio zdywersyfikowany.
  • Ryzyko jest pod kontrolą, a pozycje są właściwie zarządzane.
  • Regularnie weryfikujesz założenia swojej strategii.

Dodatkowo, warto rozważyć zapisanie się na newsletter edukacyjny, który oferuje praktyczne przykłady tworzenia i testowania strategii inwestycyjnych, nawet dla osób bez doświadczenia w programowaniu.

Related posts

• ETF vs Fundusz Inwestycyjny: Co Wybrać w 2025?
• Lista Kontrolna Przed Pierwszą Inwestycją w 2025
• Jak budować portfel ETF dla wysokiego ryzyka
• Anomalie na rynku Forex: Jak je identyfikować i analizować