Abstract
This paper explores the intersection of advanced neural information processing techniques and computational finance, with a particular focus on two innovative approaches presented at ICONIP 2024: the use of neural networks for estimating minimum-phase signals and the Style Miner framework for identifying stable risk factors through constrained reinforcement learning. We present detailed practical implementations that demonstrate how these theoretical concepts can be applied to real-world financial problems, from denoising financial time series to the dynamic selection of style factors for portfolio management.
- Introduction
Modern computational finance requires increasingly sophisticated tools to manage the complexity and inherent noise in financial markets. Neural information processing techniques offer innovative solutions to problems traditionally addressed with classic statistical methods. In this paper, we explore two complementary approaches:
- Minimum-phase signal processing: How the mathematical properties of minimum-phase signals can be leveraged to improve the analysis of financial time series.
- Style Miner: A constrained reinforcement learning framework for the automatic identification of stable and significant risk factors.
- Theoretical Foundations
2.1 Minimum-Phase Signals in Finance
Minimum-phase signals have unique properties that make them particularly suitable for financial analysis:
MINIMUM PHASE SIGNAL PROCESSOR FOR FINANCIAL TIME SERIES
This module implements a comprehensive minimum-phase signal processing framework
specifically designed for financial time series analysis. The minimum-phase
transformation offers several advantages: - Noise reduction while preserving causality
- Stable invertibility for signal reconstruction
- Unique phase-magnitude relationship for predictability
The implementation uses cepstral analysis and Hilbert transform techniques
to ensure mathematical rigor while maintaining computational efficiency.
“””
import numpy as np
import pandas as pd
from scipy import signal
from scipy.fft import fft, ifft
import matplotlib.pyplot as plt
class MinimumPhaseProcessor:
“””
Advanced processor for analyzing and transforming financial signals
into minimum-phase representations with enhanced stability properties
“””
def init(self, sampling_rate=1.0):
“””
Initialize the processor with configurable sampling parameters
Args:
sampling_rate (float): Data sampling frequency (default: 1.0 for daily data)
“””
self.sampling_rate = sampling_rate
def to_minimum_phase(self, input_signal):
“””
Convert any signal to its minimum-phase equivalent using complex cepstrum
This method implements the fundamental theorem that any signal can be
decomposed into minimum-phase and all-pass components. We extract only
the minimum-phase component for enhanced stability.
Args:
input_signal (np.array): Original time series data
Returns:
np.array: Minimum-phase transformed signal
“””
# Step 1: Compute FFT of the input signal
spectrum = fft(input_signal)
# Step 2: Calculate logarithm of magnitude (avoid log(0) with small epsilon)
log_spectrum = np.log(np.abs(spectrum) + 1e-10)
# Step 3: Compute complex cepstrum via inverse FFT
cepstrum = ifft(log_spectrum).real
# Step 4: Apply causal window to extract minimum-phase component
# This is the key step that enforces minimum-phase property
n = len(cepstrum)
window = np.zeros(n)
window[0] = 1 # DC component
window[1:n//2] = 2 # Positive frequencies doubled
window[n//2] = 1 if n % 2 == 0 else 2 # Nyquist frequency
# Step 5: Reconstruct minimum-phase signal
min_phase_cepstrum = cepstrum * window
min_phase_spectrum = np.exp(fft(min_phase_cepstrum))
min_phase_signal = ifft(min_phase_spectrum).real
return min_phase_signal[:len(input_signal)]
def extract_phase_from_magnitude(self, magnitude_response):
“””
Extract minimum-phase response from magnitude using Hilbert transform
This implements the Hilbert transform relationship between log-magnitude
and phase for minimum-phase systems, crucial for financial applications
where we often only have magnitude information.
Args:
magnitude_response (np.array): Frequency domain magnitude
Returns:
np.array: Corresponding minimum-phase response
“””
# Apply logarithm to magnitude
log_mag = np.log(magnitude_response + 1e-10)
# Hilbert transform to obtain phase
# Negative sign ensures causality
phase = -signal.hilbert(log_mag).imag
return phase
def apply_to_financial_series(self, price_series, window_size=252):
“””
Apply minimum-phase processing to financial time series with rolling windows
This method is specifically designed for financial data, using typical
trading year windows (252 days) and computing stability metrics relevant
for risk management and signal quality assessment.
Args:
price_series (pd.Series): Time series of asset prices with DatetimeIndex
window_size (int): Rolling window size (default: 252 trading days)
Returns:
pd.DataFrame: Processed results with stability metrics
“””
results = []
for i in range(window_size, len(price_series)):
# Extract rolling window
window_data = price_series[i-window_size:i]
# Calculate log returns (standard in finance)
returns = np.diff(np.log(window_data))
# Convert to minimum-phase representation
min_phase_returns = self.to_minimum_phase(returns)
# Calculate stability improvement metric
# Lower variance in minimum-phase domain indicates better stability
stability_metric = np.var(min_phase_returns) / np.var(returns)
results.append({
‘date’: price_series.index[i],
‘original_return’: returns[-1],
‘min_phase_return’: min_phase_returns[-1],
‘stability’: stability_metric
})
return pd.DataFrame(results)
CONCLUSION – MinimumPhaseProcessor Implementation:
This implementation provides a robust framework for applying minimum-phase
theory to financial time series. Key achievements:
- Numerical Stability: Use of epsilon values prevents computational issues
- Financial Relevance: Window sizes and metrics aligned with trading practices
- Interpretability: Stability metric directly relates to risk reduction
- Efficiency: FFT-based implementation ensures O(n log n) complexity
The processor can be extended with additional features like:
- Multi-resolution analysis for different time scales
- Adaptive window sizing based on market volatility
- Integration with risk management systems
Example usage demonstrating practical application
np.random.seed(42)
dates = pd.date_range(‘2020-01-01′, periods=1000, freq=’D’)
prices = 100 * np.exp(np.cumsum(np.random.normal(0.0005, 0.02, 1000)))
price_series = pd.Series(prices, index=dates)
Process the series
processor = MinimumPhaseProcessor()
results = processor.apply_to_financial_series(price_series)
print(“Minimum-phase stabilization statistics:”)
print(f”Average variance reduction: {(1 – results[‘stability’].mean()):.2%}”)
2.2 Neural Network for Multi-Channel
Deconvolution The neural approach to estimating minimum-phase signals from multi-channel observations offers significant advantages over traditional methods:
NEURAL NETWORK ARCHITECTURE FOR MULTI-CHANNEL MINIMUM-PHASE ESTIMATION
This module implements a deep learning approach to estimate clean minimum-phase
signals from corrupted multi-channel observations. The architecture leverages:
- Channel-specific encoders to capture unique distortion patterns
- Information fusion layers for optimal combination of channels
- Custom phase constraint layers to enforce minimum-phase properties
- Stability-aware loss functions for financial applications
The design is motivated by the multi-microphone deconvolution problem but
adapted for financial multi-asset scenarios where each “channel” represents
a different but correlated asset observation.
“””
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
class MinimumPhaseEstimator(nn.Module):
“””
Deep neural network for estimating minimum-phase signals from
multi-channel corrupted observations in financial markets
“””
def init(self, n_channels, signal_length, hidden_dim=256):
“””
Initialize the multi-channel minimum-phase estimator
Args:
n_channels (int): Number of input channels (correlated assets)
signal_length (int): Length of time series window
hidden_dim (int): Hidden layer dimension for feature extraction
“””
super(MinimumPhaseEstimator, self).init()
self.n_channels = n_channels
self.signal_length = signal_length
# Individual encoder for each channel to capture channel-specific patterns
self.channel_encoders = nn.ModuleList([
nn.Sequential(
nn.Conv1d(1, 32, kernel_size=7, padding=3),
nn.ReLU(),
nn.BatchNorm1d(32), # Stabilize training
nn.Conv1d(32, 64, kernel_size=5, padding=2),
nn.ReLU(),
nn.BatchNorm1d(64),
nn.Conv1d(64, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.BatchNorm1d(128)
) for _ in range(n_channels)
])
# Fusion layer to optimally combine multi-channel information
self.fusion = nn.Sequential(
nn.Conv1d(128 * n_channels, hidden_dim, kernel_size=1),
nn.ReLU(),
nn.BatchNorm1d(hidden_dim),
nn.Dropout(0.1) # Prevent overfitting
)
# Decoder with transpose convolutions for signal reconstruction
self.decoder = nn.Sequential(
nn.ConvTranspose1d(hidden_dim, 128, kernel_size=3, padding=1),
nn.ReLU(),
nn.BatchNorm1d(128),
nn.ConvTranspose1d(128, 64, kernel_size=5, padding=2),
nn.ReLU(),
nn.BatchNorm1d(64),
nn.ConvTranspose1d(64, 32, kernel_size=7, padding=3),
nn.ReLU(),
nn.BatchNorm1d(32),
nn.Conv1d(32, 1, kernel_size=1)
)
# Custom layer to enforce minimum-phase constraints
self.phase_constraint = PhaseConstraintLayer()
def forward(self, multi_channel_input):
“””
Forward pass through the network
Args:
multi_channel_input (torch.Tensor): Shape (batch, channels, time)
Returns:
torch.Tensor: Estimated minimum-phase signal (batch, 1, time)
“””
# Process each channel independently to extract features
encoded_channels = []
for i, encoder in enumerate(self.channel_encoders):
channel_data = multi_channel_input[:, i:i+1, :]
encoded = encoder(channel_data)
encoded_channels.append(encoded)
# Concatenate all channel features
fused = torch.cat(encoded_channels, dim=1)
# Fuse information across channels
fused = self.fusion(fused)
# Decode to reconstruct signal
reconstructed = self.decoder(fused)
# Apply minimum-phase constraint
min_phase_signal = self.phase_constraint(reconstructed)
return min_phase_signal
class PhaseConstraintLayer(nn.Module):
“””
Custom layer that enforces minimum-phase constraints on the output signal
using differentiable operations suitable for backpropagation
“””
def forward(self, x):
“””
Apply minimum-phase constraint to input signal
This layer ensures the output satisfies minimum-phase properties
by projecting the signal onto the minimum-phase manifold in a
differentiable manner.
Args:
x (torch.Tensor): Input signal (batch, 1, time)
Returns:
torch.Tensor: Minimum-phase constrained signal
“””
# Transform to frequency domain
x_fft = torch.fft.rfft(x, dim=-1)
# Extract magnitude (always non-negative)
magnitude = torch.abs(x_fft)
# Compute minimum-phase response from magnitude
# Using log-magnitude for numerical stability
log_mag = torch.log(magnitude + 1e-10)
# Apply causal filter in cepstral domain (approximation for efficiency)
# This ensures minimum-phase property
cepstrum = torch.fft.irfft(log_mag, dim=-1)
# Window to make causal
batch_size, channels, time_len = cepstrum.shape
window = torch.zeros_like(cepstrum)
window[:, :, 0] = 1
window[:, :, 1:time_len//2] = 2
# Reconstruct with minimum-phase constraint
windowed_cepstrum = cepstrum * window
min_phase_spectrum = torch.exp(torch.fft.rfft(windowed_cepstrum, dim=-1))
# Combine with original magnitude for stability
constrained_spectrum = magnitude * torch.exp(1j * torch.angle(min_phase_spectrum))
# Transform back to time domain
min_phase_signal = torch.fft.irfft(constrained_spectrum, n=x.shape[-1], dim=-1)
return min_phase_signal
TRAINING INFRASTRUCTURE FOR FINANCIAL MULTI-ASSET DENOISING
The training loop implements several key innovations for financial data:
- Stability-aware loss function that penalizes excessive variations
- Multi-scale evaluation for different time horizons
- Adaptive learning rate based on validation performance
- Special handling of financial data characteristics (fat tails, volatility clustering)
“””
def train_minimum_phase_estimator(model, train_data, val_data, epochs=100):
“””
Train the model on financial multi-asset data with stability constraints
This training procedure is specifically designed for financial applications,
incorporating domain-specific loss functions and evaluation metrics.
Args:
model: MinimumPhaseEstimator instance
train_data: DataLoader with training samples
val_data: DataLoader with validation samples
epochs: Number of training epochs
“””
optimizer = optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-5)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer, patience=10)
# Base reconstruction loss
mse_criterion = nn.MSELoss()
def stability_aware_loss(pred, target):
“””
Custom loss function that combines reconstruction accuracy
with temporal stability requirements for financial signals
“””
# Primary objective: accurate reconstruction
mse = mse_criterion(pred, target)
# Secondary objective: temporal smoothness
# Penalize large variations between consecutive time points
smoothness = torch.mean(torch.abs(pred[:, :, 1:] – pred[:, :, :-1]))
# Financial-specific: penalize extreme values (fat tail awareness)
extreme_penalty = torch.mean(torch.relu(torch.abs(pred) – 3))
# Weighted combination
total_loss = mse + 0.1 * smoothness + 0.05 * extreme_penalty
return total_loss
best_val_loss = float(‘inf’)
for epoch in range(epochs):
# Training phase
model.train()
train_loss = 0
train_batches = 0
for batch_idx, (data, target) in enumerate(train_data):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Compute loss
loss = stability_aware_loss(output, target)
# Backward pass
loss.backward()
# Gradient clipping for stability
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
optimizer.step()
train_loss += loss.item()
train_batches += 1
# Validation phase
model.eval()
val_loss = 0
val_batches = 0
with torch.no_grad():
for data, target in val_data:
output = model(data)
loss = mse_criterion(output, target) # Use only MSE for validation
val_loss += loss.item()
val_batches += 1
# Calculate epoch metrics
avg_train_loss = train_loss / train_batches
avg_val_loss = val_loss / val_batches
# Learning rate scheduling
scheduler.step(avg_val_loss)
# Save best model
if avg_val_loss < best_val_loss:
best_val_loss = avg_val_loss
torch.save(model.state_dict(), ‘best_minimum_phase_model.pth’)
# Progress reporting
if epoch % 10 == 0:
print(f’Epoch {epoch}: Train Loss: {avg_train_loss:.4f}, ‘
f’Val Loss: {avg_val_loss:.4f}, ‘
f’LR: {optimizer.param_groups[0][“lr”]:.6f}’)
DATA PREPARATION UTILITIES FOR MULTI-ASSET SCENARIOS
These utilities handle the specific challenges of preparing financial data
for neural network training, including:
- Correlation structure preservation
- Proper train/test splitting respecting temporal order
- Normalization appropriate for financial returns
- Synthetic data generation for testing
“””
def prepare_financial_data(assets, lookback=60):
“””
Prepare multi-channel financial data for neural network training
This function simulates realistic multi-asset scenarios where each asset
acts as a “noisy channel” observing an underlying factor or signal.
Args:
assets: Not used in this simulation, kept for API compatibility
lookback: Time window size for each training sample
Returns:
TensorDataset: PyTorch dataset ready for training
“””
# Simulation parameters
n_samples = 1000
n_assets = 5
# Generate true underlying minimum-phase signal
true_signal = np.random.randn(n_samples)
processor = MinimumPhaseProcessor()
true_signal = processor.to_minimum_phase(true_signal)
# Generate corrupted observations for each asset
observations = []
for i in range(n_assets):
# Asset-specific noise level
noise_level = 0.1 * (1 + i * 0.05) # Increasing noise per channel
noise = np.random.randn(n_samples) * noise_level
# Asset-specific distortion filter
# Simulates different market microstructure effects
filter_cutoff = 0.5 – i * 0.08 # Different frequency responses
channel_filter = signal.firwin(10, filter_cutoff)
# Apply convolution (distortion) and add noise
distorted = signal.convolve(true_signal, channel_filter, mode=’same’)
observations.append(distorted + noise)
# Create windowed samples for training
X = [] # Multi-channel inputs
y = [] # Clean targets
for i in range(lookback, n_samples):
# Extract window from each channel
window_data = np.array([obs[i-lookback:i] for obs in observations])
X.append(window_data)
# Target is the true signal window
y.append(true_signal[i-lookback:i])
# Convert to PyTorch tensors
X = torch.FloatTensor(X)
y = torch.FloatTensor(y).unsqueeze(1) # Add channel dimension
return TensorDataset(X, y)
CONCLUSION – Neural Minimum-Phase Estimation:
This implementation demonstrates how deep learning can be applied to the
classical signal processing problem of minimum-phase estimation, adapted
for financial time series analysis. Key innovations include:
- Multi-channel architecture: Leverages correlations between assets
- Phase constraint layer: Ensures mathematical properties are preserved
- Stability-aware training: Addresses financial data characteristics
- Modular design: Easy to extend for different asset classes
Future enhancements could include:
- Attention mechanisms for dynamic channel weighting
- Adversarial training for robustness
- Online learning capabilities for real-time adaptation
3. Style Miner: Constrained Reinforcement Learning for Finance
3.1 Complete System Architecture
“””
STYLE MINER: CONSTRAINED REINFORCEMENT LEARNING FOR DYNAMIC FACTOR SELECTION
This comprehensive implementation provides a production-ready framework for
discovering and maintaining stable financial style factors using constrained
reinforcement learning. The system addresses key challenges in quantitative
finance:
