Neural Network Factory API

The Neural Network Factory provides a comprehensive framework for creating and managing various neural network architectures for Hurst parameter estimation. This module implements train-once, apply-many workflows with proper GPU memory management and model persistence.

Neural Network Factory for Hurst Parameter Estimation

This module provides a factory for creating various neural network architectures suitable for benchmarking Hurst parameter estimation in time series data.

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NNArchitecture(value)

Available neural network architectures.

FFN = 'feedforward'

CNN = 'convolutional'

LSTM = 'lstm'

BILSTM = 'bidirectional_lstm'

GRU = 'gru'

TRANSFORMER = 'transformer'

HYBRID_CNN_LSTM = 'hybrid_cnn_lstm'

RESNET = 'resnet'

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NNConfig(architecture: NNArchitecture, input_length: int, hidden_dims: List[int] = None, dropout_rate: float = 0.2, learning_rate: float = 0.001, batch_size: int = 32, epochs: int = 50, activation: str = 'relu', optimizer: str = 'adam', weight_decay: float = 0.0001, conv_filters: int = 64, conv_kernel_size: int = 3, lstm_units: int = 64, transformer_heads: int = 8, transformer_layers: int = 2, resnet_blocks: int = 2)

Configuration for neural network architecture.

architecture: NNArchitecture

input_length: int

hidden_dims: List[int] = None

dropout_rate: float = 0.2

learning_rate: float = 0.001

batch_size: int = 32

epochs: int = 50

activation: str = 'relu'

optimizer: str = 'adam'

weight_decay: float = 0.0001

conv_filters: int = 64

conv_kernel_size: int = 3

lstm_units: int = 64

transformer_heads: int = 8

transformer_layers: int = 2

resnet_blocks: int = 2

__init__(architecture: NNArchitecture, input_length: int, hidden_dims: List[int] = None, dropout_rate: float = 0.2, learning_rate: float = 0.001, batch_size: int = 32, epochs: int = 50, activation: str = 'relu', optimizer: str = 'adam', weight_decay: float = 0.0001, conv_filters: int = 64, conv_kernel_size: int = 3, lstm_units: int = 64, transformer_heads: int = 8, transformer_layers: int = 2, resnet_blocks: int = 2) → None

class lrdbenchmark.analysis.machine_learning.neural_network_factory.BaseNeuralNetwork(*args: Any, **kwargs: Any)

Base class for all neural network architectures with train-once, apply-many workflow.

__init__(config: NNConfig, model_name: str = None)

_get_optimal_device()

Select optimal device with CUDA compatibility check.

forward(x)

predict(x: ndarray, batch_size: int = 32) → ndarray

Make predictions on new data with automatic device handling.

train_model(X: ndarray, y: ndarray, validation_split: float = 0.2) → Dict[str, List[float]]

Train the neural network model.

_get_optimizer()

Get optimizer based on configuration.

save_model()

Save the trained model and configuration.

load_model(model_path: str = None)

Load a trained model with automatic device handling.

is_model_trained() → bool

Check if model is trained.

class lrdbenchmark.analysis.machine_learning.neural_network_factory.FeedforwardNetwork(*args: Any, **kwargs: Any)

Basic feedforward neural network.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.ConvolutionalNetwork(*args: Any, **kwargs: Any)

Convolutional neural network for time series.

__init__(config: NNConfig)

_get_conv_output_size(input_length)

Calculate the output size after convolutions.

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.LSTMNetwork(*args: Any, **kwargs: Any)

LSTM neural network for time series.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.BidirectionalLSTMNetwork(*args: Any, **kwargs: Any)

Bidirectional LSTM neural network.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.GRUNetwork(*args: Any, **kwargs: Any)

GRU neural network for time series.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.TransformerNetwork(*args: Any, **kwargs: Any)

Transformer encoder network for time series.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.HybridCNNLSTMNetwork(*args: Any, **kwargs: Any)

Hybrid CNN-LSTM network.

__init__(config: NNConfig)

_get_lstm_input_size(input_length)

Calculate LSTM input size after convolutions.

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.ResNetBlock(*args: Any, **kwargs: Any)

Residual block for ResNet architecture.

__init__(in_channels, out_channels, kernel_size=3)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.ResNetNetwork(*args: Any, **kwargs: Any)

ResNet architecture for time series.

__init__(config: NNConfig)

forward(x)

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NeuralNetworkFactory

Factory for creating neural network architectures.

classmethod create_network(config: NNConfig) → BaseNeuralNetwork

Create a neural network with the specified architecture.

classmethod get_available_architectures() → List[NNArchitecture]

Get list of available architectures.

classmethod create_benchmark_networks(input_length: int, architectures: List[NNArchitecture] | None = None) → Dict[str, BaseNeuralNetwork]

Create a set of networks for benchmarking.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_feedforward_network(input_length: int, hidden_dims: List[int] = [64, 32]) → BaseNeuralNetwork

Create a feedforward neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_cnn_network(input_length: int, conv_filters: int = 64) → BaseNeuralNetwork

Create a convolutional neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_lstm_network(input_length: int, lstm_units: int = 64) → BaseNeuralNetwork

Create an LSTM neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_all_benchmark_networks(input_length: int) → Dict[str, BaseNeuralNetwork]

Create all available neural network architectures for benchmarking.

Neural Network Architectures

The factory supports 8 different neural network architectures:

Feedforward Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.FeedforwardNetwork(*args: Any, **kwargs: Any)

Basic feedforward neural network.

__init__(config: NNConfig)

forward(x)

Convolutional Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.ConvolutionalNetwork(*args: Any, **kwargs: Any)

Convolutional neural network for time series.

__init__(config: NNConfig)

_get_conv_output_size(input_length)

Calculate the output size after convolutions.

forward(x)

LSTM Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.LSTMNetwork(*args: Any, **kwargs: Any)

LSTM neural network for time series.

__init__(config: NNConfig)

forward(x)

Bidirectional LSTM Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.BidirectionalLSTMNetwork(*args: Any, **kwargs: Any)

Bidirectional LSTM neural network.

__init__(config: NNConfig)

forward(x)

GRU Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.GRUNetwork(*args: Any, **kwargs: Any)

GRU neural network for time series.

__init__(config: NNConfig)

forward(x)

Transformer Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.TransformerNetwork(*args: Any, **kwargs: Any)

Transformer encoder network for time series.

__init__(config: NNConfig)

forward(x)

ResNet Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.ResNetNetwork(*args: Any, **kwargs: Any)

ResNet architecture for time series.

__init__(config: NNConfig)

forward(x)

Hybrid CNN-LSTM Network

class lrdbenchmark.analysis.machine_learning.neural_network_factory.HybridCNNLSTMNetwork(*args: Any, **kwargs: Any)

Hybrid CNN-LSTM network.

__init__(config: NNConfig)

_get_lstm_input_size(input_length)

Calculate LSTM input size after convolutions.

forward(x)

Factory Class

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NeuralNetworkFactory

Factory for creating neural network architectures.

classmethod create_network(config: NNConfig) → BaseNeuralNetwork

Create a neural network with the specified architecture.

classmethod get_available_architectures() → List[NNArchitecture]

Get list of available architectures.

classmethod create_benchmark_networks(input_length: int, architectures: List[NNArchitecture] | None = None) → Dict[str, BaseNeuralNetwork]

Create a set of networks for benchmarking.

Configuration

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NNConfig(architecture: NNArchitecture, input_length: int, hidden_dims: List[int] = None, dropout_rate: float = 0.2, learning_rate: float = 0.001, batch_size: int = 32, epochs: int = 50, activation: str = 'relu', optimizer: str = 'adam', weight_decay: float = 0.0001, conv_filters: int = 64, conv_kernel_size: int = 3, lstm_units: int = 64, transformer_heads: int = 8, transformer_layers: int = 2, resnet_blocks: int = 2)

Configuration for neural network architecture.

architecture: NNArchitecture

input_length: int

hidden_dims: List[int] = None

dropout_rate: float = 0.2

learning_rate: float = 0.001

batch_size: int = 32

epochs: int = 50

activation: str = 'relu'

optimizer: str = 'adam'

weight_decay: float = 0.0001

conv_filters: int = 64

conv_kernel_size: int = 3

lstm_units: int = 64

transformer_heads: int = 8

transformer_layers: int = 2

resnet_blocks: int = 2

__init__(architecture: NNArchitecture, input_length: int, hidden_dims: List[int] = None, dropout_rate: float = 0.2, learning_rate: float = 0.001, batch_size: int = 32, epochs: int = 50, activation: str = 'relu', optimizer: str = 'adam', weight_decay: float = 0.0001, conv_filters: int = 64, conv_kernel_size: int = 3, lstm_units: int = 64, transformer_heads: int = 8, transformer_layers: int = 2, resnet_blocks: int = 2) → None

Architecture Enumeration

class lrdbenchmark.analysis.machine_learning.neural_network_factory.NNArchitecture(value)

Available neural network architectures.

FFN = 'feedforward'

CNN = 'convolutional'

LSTM = 'lstm'

BILSTM = 'bidirectional_lstm'

GRU = 'gru'

TRANSFORMER = 'transformer'

HYBRID_CNN_LSTM = 'hybrid_cnn_lstm'

RESNET = 'resnet'

Convenience Functions

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_feedforward_network(input_length: int, hidden_dims: List[int] = [64, 32]) → BaseNeuralNetwork

Create a feedforward neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_cnn_network(input_length: int, conv_filters: int = 64) → BaseNeuralNetwork

Create a convolutional neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_lstm_network(input_length: int, lstm_units: int = 64) → BaseNeuralNetwork

Create an LSTM neural network.

lrdbenchmark.analysis.machine_learning.neural_network_factory.create_all_benchmark_networks(input_length: int) → Dict[str, BaseNeuralNetwork]

Create all available neural network architectures for benchmarking.

Usage Examples

Creating a Single Network

from lrdbenchmark.analysis.machine_learning.neural_network_factory import (
    NeuralNetworkFactory, NNArchitecture, NNConfig
)

# Create configuration
config = NNConfig(
    architecture=NNArchitecture.TRANSFORMER,
    input_length=500,
    hidden_dims=[64, 32],
    learning_rate=0.001,
    epochs=50
)

# Create network
factory = NeuralNetworkFactory()
network = factory.create_network(config)

Creating All Benchmark Networks

from lrdbenchmark.analysis.machine_learning.neural_network_factory import create_all_benchmark_networks

# Create all available networks
networks = create_all_benchmark_networks(input_length=500)

for name, network in networks.items():
    print(f"Created {name} network")

Training and Prediction

import numpy as np

# Generate training data
X_train = np.random.randn(100, 500)
y_train = np.random.uniform(0.2, 0.8, 100)

# Train the network
history = network.train_model(X_train, y_train)

# Make predictions
new_data = np.random.randn(1, 500)
prediction = network.predict(new_data)

print(f"Prediction: {prediction[0]:.3f}")

Model Persistence

# Models are automatically saved after training
# To load a saved model:
network.load_model()  # Loads from default path

# Or specify a custom path:
network.load_model("path/to/model.pth")

Performance Characteristics

Based on comprehensive benchmarking, the neural network architectures show the following performance:

Architecture	MAE	Execution Time	Success Rate
Transformer	0.1802	0.7ms	100%
LSTM	0.1833	0.3ms	100%
Bidirectional LSTM	0.1834	0.3ms	100%
Convolutional	0.1844	0.0ms	100%
GRU	0.1849	0.2ms	100%
ResNet	0.1859	0.1ms	100%
Feedforward	0.1946	0.0ms	100%

Key Features

• Train-once, Apply-many: Models are trained once and can be used for multiple predictions

• GPU Memory Management: Batch processing prevents CUDA out-of-memory issues

• Model Persistence: Automatic saving and loading of trained models

• Device Management: Automatic GPU/CPU selection and device placement

• Consistent Performance: All architectures achieve similar accuracy levels

• Fast Inference: Ultra-fast prediction times (0.0-0.7ms per sample)

• Production Ready: Robust error handling and memory management