Skip to content

Vol Normalization Plotting

Percentage vs vol-normalized comparison plots and regime analysis.

volnorm

Visualization for volatility normalization and regime analysis.

plot_percent_vs_volnorm(trades, figsize=(14, 5))

Side-by-side scatter plots: % space vs vol-normalized space.

Parameters:

Name Type Description Default
trades TradeSet

Trade geometry data (must have vol_at_entry)

 required
figsize tuple

Figure size (width, height)

 (14, 5)

Returns:

Type Description
Figure

Matplotlib figure object
Source code in signal_analyzer/plotting/volnorm.py 
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def plot_percent_vs_volnorm(
    trades: TradeSet,
    figsize: tuple = (14, 5),
) -> Figure:
    """
    Side-by-side scatter plots: % space vs vol-normalized space.

    Parameters
    ----------
    trades : TradeSet
        Trade geometry data (must have vol_at_entry)
    figsize : tuple
        Figure size (width, height)

    Returns
    -------
    Figure
        Matplotlib figure object
    """
    norm_trades = normalize_metrics(trades)

    fig, axes = plt.subplots(1, 2, figsize=figsize)

    # Left: % space
    ax = axes[0]
    ax.scatter(trades.mfe, trades.mae, s=6, alpha=0.3, color="C0")
    ax.axhline(0, color="black", lw=1, ls="--", alpha=0.5)
    ax.axvline(0, color="black", lw=1, ls="--", alpha=0.5)
    ax.set_title(f"{trades.side.capitalize()}: Percent Space\nn={trades.n_trades}")
    ax.set_xlabel("MFE (%)")
    ax.set_ylabel("MAE (%)")
    ax.grid(alpha=0.3)

    # Right: Vol-normalized space
    ax = axes[1]
    ax.scatter(norm_trades.mfe, norm_trades.mae, s=6, alpha=0.3, color="C1")
    ax.axhline(0, color="black", lw=1, ls="--", alpha=0.5)
    ax.axvline(0, color="black", lw=1, ls="--", alpha=0.5)
    ax.set_title(
        f"{trades.side.capitalize()}: Vol-Normalized Space\nn={norm_trades.n_trades}"
    )
    ax.set_xlabel("MFE (vol units)")
    ax.set_ylabel("MAE (vol units)")
    ax.grid(alpha=0.3)

    plt.tight_layout()
    return fig

plot_regime_comparison(trades, n_regimes=3, figsize=(14, 5))

Compare trade geometry across volatility regimes.

Parameters:

Name Type Description Default
trades TradeSet

Trade geometry data (must have vol_at_entry)

 required
n_regimes int

Number of regimes

 3
figsize tuple

Figure size (width, height)

 (14, 5)

Returns:

Type Description
Figure

Matplotlib figure object
Source code in signal_analyzer/plotting/volnorm.py 
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
def plot_regime_comparison(
    trades: TradeSet,
    n_regimes: int = 3,
    figsize: tuple = (14, 5),
) -> Figure:
    """
    Compare trade geometry across volatility regimes.

    Parameters
    ----------
    trades : TradeSet
        Trade geometry data (must have vol_at_entry)
    n_regimes : int
        Number of regimes
    figsize : tuple
        Figure size (width, height)

    Returns
    -------
    Figure
        Matplotlib figure object
    """
    regimes = split_by_vol_regime(trades, n_regimes=n_regimes)

    fig, axes = plt.subplots(1, n_regimes, figsize=figsize, sharex=True, sharey=True)

    if n_regimes == 1:
        axes = [axes]

    colors = ["blue", "orange", "green", "red", "purple"]

    for i, (regime_name, regime_trades) in enumerate(regimes.items()):
        ax = axes[i]

        ax.scatter(
            regime_trades.mfe,
            regime_trades.mae,
            s=6,
            alpha=0.3,
            color=colors[i % len(colors)],
        )

        ax.axhline(0, color="black", lw=1, ls="--", alpha=0.5)
        ax.axvline(0, color="black", lw=1, ls="--", alpha=0.5)

        avg_vol = np.mean(regime_trades.vol_at_entry)
        ax.set_title(
            f"{regime_name.capitalize()} Vol\n"
            f"n={regime_trades.n_trades}, avg_vol={avg_vol:.2f}%"
        )
        ax.set_xlabel("MFE (%)")

        if i == 0:
            ax.set_ylabel("MAE (%)")

        ax.grid(alpha=0.3)

    plt.suptitle(f"{trades.side.capitalize()}: Regime Comparison", y=1.02)
    plt.tight_layout()
    return fig

plot_frontiers_percent_vs_volnorm(trades, figsize=(14, 10))

Compare frontiers in % space vs vol-normalized space.

Parameters:

Name Type Description Default
trades TradeSet

Trade geometry data (must have vol_at_entry)

 required
figsize tuple

Figure size (width, height)

 (14, 10)

Returns:

Type Description
Figure

Matplotlib figure object
Source code in signal_analyzer/plotting/volnorm.py 
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
def plot_frontiers_percent_vs_volnorm(
    trades: TradeSet,
    figsize: tuple = (14, 10),
) -> Figure:
    """
    Compare frontiers in % space vs vol-normalized space.

    Parameters
    ----------
    trades : TradeSet
        Trade geometry data (must have vol_at_entry)
    figsize : tuple
        Figure size (width, height)

    Returns
    -------
    Figure
        Matplotlib figure object
    """
    norm_trades = normalize_metrics(trades)

    # Compute frontiers for both
    frontiers_pct = compute_frontiers(trades)
    frontiers_norm = compute_frontiers(norm_trades)

    fig, axes = plt.subplots(2, 2, figsize=figsize)

    # Top-left: Risk-constrained (%)
    ax = axes[0, 0]
    risk_data = frontiers_pct["risk_constrained"]
    ax.plot(
        risk_data["dd"],
        risk_data["mfe"],
        marker="o",
        markersize=4,
        linewidth=2,
        color="C0",
    )
    knee_dd, knee_mfe = risk_data["knee"]
    ax.plot(knee_dd, knee_mfe, marker="*", markersize=15, color="red")
    ax.set_title(f"{trades.side.capitalize()}: Risk Frontier (% space)")
    ax.set_xlabel("Drawdown Cap (%)")
    ax.set_ylabel("MFE 90th pct (%)")
    ax.grid(alpha=0.3)

    # Top-right: Risk-constrained (vol-norm)
    ax = axes[0, 1]
    risk_data = frontiers_norm["risk_constrained"]
    ax.plot(
        risk_data["dd"],
        risk_data["mfe"],
        marker="o",
        markersize=4,
        linewidth=2,
        color="C1",
    )
    knee_dd, knee_mfe = risk_data["knee"]
    ax.plot(knee_dd, knee_mfe, marker="*", markersize=15, color="red")
    ax.set_title(f"{trades.side.capitalize()}: Risk Frontier (vol-norm)")
    ax.set_xlabel("Drawdown Cap (vol units)")
    ax.set_ylabel("MFE 90th pct (vol units)")
    ax.grid(alpha=0.3)

    # Bottom-left: Opportunity-constrained (%)
    ax = axes[1, 0]
    opp_data = frontiers_pct["opportunity_constrained"]
    ax.plot(
        opp_data["tp"],
        opp_data["dd"],
        marker="o",
        markersize=4,
        linewidth=2,
        color="C0",
    )
    knee_tp, knee_dd = opp_data["knee"]
    ax.plot(knee_tp, knee_dd, marker="*", markersize=15, color="red")
    ax.set_title(f"{trades.side.capitalize()}: Opportunity Frontier (% space)")
    ax.set_xlabel("Profit Target (%)")
    ax.set_ylabel("DD 80th pct (%)")
    ax.grid(alpha=0.3)

    # Bottom-right: Opportunity-constrained (vol-norm)
    ax = axes[1, 1]
    opp_data = frontiers_norm["opportunity_constrained"]
    ax.plot(
        opp_data["tp"],
        opp_data["dd"],
        marker="o",
        markersize=4,
        linewidth=2,
        color="C1",
    )
    knee_tp, knee_dd = opp_data["knee"]
    ax.plot(knee_tp, knee_dd, marker="*", markersize=15, color="red")
    ax.set_title(f"{trades.side.capitalize()}: Opportunity Frontier (vol-norm)")
    ax.set_xlabel("Profit Target (vol units)")
    ax.set_ylabel("DD 80th pct (vol units)")
    ax.grid(alpha=0.3)

    plt.tight_layout()
    return fig