vectorbt Checked

From CSV

df = pd.read_csv("ohlcv.csv", parse_dates=["timestamp"], index_col="timestamp")

close = df["close"]

From Yahoo Finance (traditional markets)

btc = vbt.YFData.download("BTC-USD", start="2023-01-01", end="2025-01-01")

close = btc.get("Close")

For Solana tokens, fetch data via the `birdeye-api` skill and load into a DataFrame.

### Step 2: Compute Indicators

import pandas_ta as ta

Using pandas-ta (see pandas-ta skill)

df.ta.ema(length=12, append=True)

df.ta.ema(length=26, append=True)

df.ta.rsi(length=14, append=True)

df.ta.bbands(length=20, std=2, append=True)

Or using vectorbt built-ins

rsi = vbt.RSI.run(close, window=14)

bbands = vbt.BBANDS.run(close, window=20, alpha=2)

### Step 3: Generate Entry/Exit Signals

EMA crossover

entries = df["EMA_12"] > df["EMA_26"]

exits = df["EMA_12"] < df["EMA_26"]

RSI mean reversion

entries = rsi.rsi_below(30)

exits = rsi.rsi_above(70)

### Step 4: Run Backtest

pf = vbt.Portfolio.from_signals(

close=close,

entries=entries,

exits=exits,

init_cash=10_000,

fees=0.003,

slippage=0.005,

size=0.95, # use 95% of available cash

size_type="percent",

freq="1h",

)

### Step 5: Analyze Results

Summary statistics

print(pf.stats())

Trade-level analysis

trades = pf.trades.records_readable

print(f"\nTrade count: {len(trades)}")

print(f"Avg holding period: {trades['Duration'].mean()}")

Equity curve

pf.plot().show()

Drawdown chart

pf.drawdowns.plot().show()

## Key Portfolio Parameters

| Parameter | Description | Example |
|-----------|-------------|---------|
| `close` | Price series (pd.Series or DataFrame) | `df["close"]` |
| `entries` | Boolean entry signals | `fast > slow` |
| `exits` | Boolean exit signals | `fast < slow` |
| `init_cash` | Starting capital | `10_000` |
| `fees` | Fee per trade (fraction) | `0.003` (0.3%) |
| `slippage` | Slippage per trade (fraction) | `0.005` (0.5%) |
| `size` | Position size | `0.95` |
| `size_type` | How to interpret size | `"percent"`, `"amount"`, `"value"` |
| `freq` | Data frequency | `"1h"`, `"4h"`, `"1d"` |
| `direction` | Trade direction | `"both"`, `"longonly"`, `"shortonly"` |
| `accumulate` | Allow adding to positions | `False` |
| `sl_stop` | Stop-loss level (fraction) | `0.05` (5%) |
| `tp_stop` | Take-profit level (fraction) | `0.10` (10%) |

## Performance Metrics

### Returns
- `total_return()` — cumulative return over the period
- `annualized_return()` — annualized compound return
- `daily_returns()` — Series of daily returns

### Risk
- `max_drawdown()` — maximum peak-to-trough decline
- `annualized_volatility()` — annualized standard deviation of returns
- `value_at_risk()` — VaR at specified confidence level

### Risk-Adjusted
- `sharpe_ratio()` — excess return per unit volatility
- `sortino_ratio()` — excess return per unit downside deviation
- `calmar_ratio()` — annualized return / max drawdown
- `omega_ratio()` — probability-weighted gain/loss ratio

### Trade Statistics
- `trades.win_rate()` — fraction of profitable trades
- `trades.profit_factor()` — gross profit / gross loss
- `trades.expectancy()` — average P&L per trade
- `trades.avg_winning_trade()` — mean profit on winners
- `trades.avg_losing_trade()` — mean loss on losers
- `trades.count()` — total number of completed trades

## Parameter Optimization

### Grid Search

fast_windows = [5, 8, 12, 15, 20]

slow_windows = [20, 26, 30, 40, 50]

Run all 25 combos at once

fast_ma = vbt.MA.run(close, fast_windows, short_name="fast")

slow_ma = vbt.MA.run(close, slow_windows, short_name="slow")

entries = fast_ma.ma_crossed_above(slow_ma)

exits = fast_ma.ma_crossed_below(slow_ma)

pf = vbt.Portfolio.from_signals(close, entries, exits, fees=0.003)

Find best params by Sharpe

sharpe = pf.sharpe_ratio()

best_idx = sharpe.idxmax()

print(f"Best params: {best_idx}, Sharpe: {sharpe[best_idx]:.3f}")

### Walk-Forward Validation

Always validate optimized parameters on out-of-sample data:

Split: 70% train, 30% test

split_idx = int(len(close) * 0.7)

train_close = close.iloc[:split_idx]

test_close = close.iloc[split_idx:]

Optimize on training data

... (run grid search on train_close)

Validate best params on test data

... (run single backtest on test_close with best params)

See `references/optimization_guide.md` for detailed walk-forward methodology and overfitting prevention.

## Crypto-Specific Considerations

### 24/7 Markets
Crypto markets never close. Use hourly or minute-based frequencies, not business-day frequencies:

Correct for crypto

pf = vbt.Portfolio.from_signals(close, entries, exits, freq="1h")

Wrong — business days assume market closures

pf = vbt.Portfolio.from_signals(close, entries, exits, freq="1B")

### Realistic Fees
DEX swaps on Solana typically cost 0.25–1% including AMM fees. CEX spot fees are 0.05–0.1%.

Solana DEX (conservative)

pf = vbt.Portfolio.from_signals(close, entries, exits, fees=0.005)

CEX spot

pf = vbt.Portfolio.from_signals(close, entries, exits, fees=0.001)

### Slippage
Low-liquidity tokens can have 1–5% slippa