feature-engineering Checked

| Feature | Source | Lookback |

|---------|--------|----------|

| rsi | RSI(14) | 14 bars |

| macd_histogram | MACD(12,26,9) histogram | 33 bars |

| bb_position | (close - BB_lower) / (BB_upper - BB_lower) | 20 bars |

| bb_width | (BB_upper - BB_lower) / BB_mid | 20 bars |

| atr_ratio | ATR(14) / close | 14 bars |

| adx | ADX(14) | 14 bars |

| stoch_k | Stochastic %K(14,3) | 14 bars |

| cci | CCI(20) | 20 bars |

| mfi | MFI(14) | 14 bars |

| supertrend_direction | Supertrend direction (+1/-1) | 10 bars |

### 4. Microstructure Features

Derived from trade-level data (individual swaps/transactions). Require on-chain

or DEX API data.

| Feature | Description |

|---------|-------------|

| trade_count_ratio | Trades this bar / avg trades per bar |

| avg_trade_size | Mean trade size in USD |

| large_trade_pct | % of volume from trades > $10k |

| unique_traders | Count of distinct wallet addresses |

| buy_count_ratio | Buy trades / total trades |

| trade_size_entropy | Shannon entropy of trade size distribution |

### 5. On-Chain Features

Derived from blockchain state changes. Require Helius or Solana RPC data.

| Feature | Description |

|---------|-------------|

| holder_count_change | Change in unique holders over N periods |

| whale_net_flow | Net tokens moved by top-10 holders |

| token_velocity | Transfer volume / circulating supply |

| liquidity_change | Change in DEX liquidity pool TVL |

### 6. Cross-Asset Features

Capture relationships between the target token and broader market.

| Feature | Description |

|---------|-------------|

| sol_correlation | Rolling correlation with SOL price |

| btc_beta | Rolling beta to BTC returns |

| sector_momentum | Average return of tokens in same sector |

### 7. Time Features

Cyclical encoding of calendar time. Use sin/cos encoding to preserve cyclical

continuity (hour 23 is close to hour 0).

import numpy as np

hour_sin = np.sin(2 * np.pi * hour / 24)
hour_cos = np.cos(2 * np.pi * hour / 24)
day_of_week = np.sin(2 * np.pi * day / 7)

Stationarity

**Non-stationary features will cause your model to fail on new data.** A feature

is stationary if its statistical properties (mean, variance) don't change over time.

### Testing for Stationarity

Use the Augmented Dickey-Fuller (ADF) test:

from scipy.stats import adfuller

result = adfuller(feature_series.dropna())
p_value = result[1]
is_stationary = p_value < 0.05

### Making Features Stationary

| Non-Stationary | Stationary Transform |

|----------------|---------------------|

| Price | Log return |

| Volume | Volume ratio (vol / avg vol) |

| OBV | OBV slope (regression coefficient) |

| Holder count | Holder count change |

| RSI | Already stationary (bounded 0-100) |

| Dollar volume | Dollar volume / rolling mean |

**Rule**: If a feature trends upward or downward over time, it is non-stationary.

Transform it into a ratio, difference, or rate of change.

Normalization

After computing features, normalize them so that all features have comparable

scales. This is critical for distance-based models (KNN, SVM) and helpful for

tree models.

| Method | Formula | When to Use |

|--------|---------|-------------|

| Z-score | (x - mean) / std | Gaussian-like distributions |

| Min-max | (x - min) / (max - min) | Bounded features (RSI, BB position) |

| Rank | rank(x) / len(x) | Heavy-tailed distributions |

**Critical**: Use **rolling** statistics for normalization. Never use full-sample

mean/std — that introduces lookahead bias.

# CORRECT: rolling z-score
z = (feature - feature.rolling(60).mean()) / feature.rolling(60).std()

# WRONG: full-sample z-score (lookahead bias!)
z = (feature - feature.mean()) / feature.std()

No-Lookahead Guarantee

The most dangerous bug in trading ML is lookahead bias — using future information

to compute features or targets. Follow these rules absolutely:

1. **Rolling calculations only**: Never use .mean() or .std() on the full

series. Always use .rolling(N).mean().

2. **Shift targets forward, not features backward**: The target is

close.shift(-N) / close - 1 (future return), not close / close.shift(N) - 1

(past return used as target).

3. **No future index alignment**: When joining feature and target DataFrames,

verify that feature row t is paired with target row t (where target already

contains the forward shift).

4. **Train/test split by time**: Never random split. Always

train = data[:split_idx], test = data[split_idx:].

Feature Selection

After computing many features, select the most predictive and least redundant:

### Step 1: Remove Low-Variance Features

from sklearn.feature_selection import VarianceThreshold
selector = VarianceThreshold(threshold=0.01)
X_filtered = selector.fit_transform(X)

### Step 2: Correlation Filter

Remove features with > 0.9 correlation to another feature (keep the one with

higher target correlation):

corr_matrix = X.corr().abs()
upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
to_drop = [col for col