quantmllibrary 0.1.0__py3-none-any.whl

quantmllibrary-0.1.0.dist-info/METADATA

@@ -0,0 +1,536 @@
+Metadata-Version: 2.4
+Name: quantmllibrary
+Version: 0.1.0
+Summary: A clean, minimal ML library optimized for quantitative trading, streaming data, and online learning
+Author: QuantML Contributors
+Author-email: Sritej Bommaraju <bommaraju@berkeley.edu>
+License: MIT
+Project-URL: Homepage, https://github.com/SritejBommaraju/quantmllibrary
+Project-URL: Documentation, https://github.com/SritejBommaraju/quantmllibrary#readme
+Project-URL: Repository, https://github.com/SritejBommaraju/quantmllibrary
+Project-URL: Issues, https://github.com/SritejBommaraju/quantmllibrary/issues
+Keywords: machine-learning,quantitative-trading,streaming-data,online-learning,autograd,tensor,hft,quant
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.20.0; extra == "numpy"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: black>=22.0.0; extra == "dev"
+Requires-Dist: mypy>=0.950; extra == "dev"
+Dynamic: license-file
+
+# QuantML
+
+A clean, minimal, hackable machine learning library optimized specifically for quantitative trading, streaming data, online learning, and low-latency CPU inference.
+
+## Table of Contents
+
+- [Installation](#installation)
+- [Dependencies](#dependencies)
+- [Quick Start](#quick-start)
+- [Directory Structure](#directory-structure)
+- [Usage for Research](#usage-for-research)
+- [Features](#features)
+- [Architecture](#architecture)
+- [Performance](#performance)
+- [Examples](#examples)
+- [Documentation](#documentation)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Installation
+
+### From PyPI (when published)
+```bash
+pip install quantmllibrary
+```
+
+### From Source
+
+```bash
+git clone https://github.com/SritejBommaraju/quantmllibrary.git
+cd quantmllibrary
+pip install -e .
+```
+
+### With Optional Dependencies
+
+```bash
+# With NumPy for performance
+pip install quantmllibrary[numpy]
+
+# Development dependencies
+pip install -r requirements-dev.txt
+```
+
+### Using Conda
+
+```bash
+conda env create -f environment.yml
+conda activate quantml
+```
+
+## Dependencies
+
+### Core Dependencies
+
+- **Python**: >=3.8, <3.13
+- **NumPy**: >=1.20.0, <2.0.0 (optional, but recommended for performance)
+
+### Optional Dependencies
+
+- **pandas**: >=1.3.0 (for data loading and manipulation)
+- **pyyaml**: >=6.0 (for YAML config support)
+- **pyarrow**: (for Parquet feature caching)
+
+### Development Dependencies
+
+See `requirements-dev.txt` for testing, linting, and documentation tools.
+
+**Note**: The library works without NumPy, but performance is significantly better (2-5x faster) with NumPy installed.
+
+## Quick Start
+
+### Complete Working Example
+
+```python
+from quantml import Tensor
+from quantml.models import Linear
+from quantml.optim import Adam
+from quantml.training import QuantTrainer, FeaturePipeline
+from quantml.training.losses import mse_loss
+from quantml.training.features import normalize_features
+
+# 1. Load your data (replace with your data source)
+prices = [100.0, 101.0, 102.0, 103.0, 104.0, 105.0]
+volumes = [100.0, 110.0, 105.0, 120.0, 115.0, 125.0]
+
+# 2. Create features
+pipeline = FeaturePipeline()
+pipeline.add_lagged_feature('price', lags=[1, 5, 10])
+pipeline.add_rolling_feature('price', window=20, func='mean')
+pipeline.add_time_series_feature('price', 'returns')
+
+features = pipeline.transform({'price': prices})
+features = normalize_features(features, method='zscore')
+
+# 3. Create targets (forward returns)
+targets = [(prices[i+1] - prices[i]) / prices[i] for i in range(len(prices)-1)]
+features = features[:-1]  # Align
+
+# 4. Train model
+model = Linear(in_features=len(features[0]), out_features=1, bias=True)
+optimizer = Adam(model.parameters(), lr=0.001)
+trainer = QuantTrainer(model, optimizer, mse_loss)
+
+# Train
+for i in range(len(features)):
+    x = Tensor([features[i]])
+    y = Tensor([[targets[i]]])
+    trainer.train_step(x, y)
+
+# 5. Generate predictions
+predictions = []
+for feat in features:
+    x = Tensor([feat])
+    pred = model.forward(x)
+    pred_val = pred.data[0][0] if isinstance(pred.data[0], list) else pred.data[0]
+    predictions.append(pred_val)
+
+print(f"Generated {len(predictions)} predictions")
+```
+
+### Basic Tensor Operations
+
+```python
+from quantml import Tensor
+
+# Create tensors
+x = Tensor([1.0, 2.0, 3.0], requires_grad=True)
+y = Tensor([4.0, 5.0, 6.0], requires_grad=True)
+
+# Operations
+z = x + y
+z.backward()
+
+print(x.grad)  # [1.0, 1.0, 1.0]
+```
+
+### Quant Operations
+
+```python
+from quantml import Tensor
+from quantml import time_series
+
+# Price data
+prices = Tensor([100.0, 101.0, 102.0, 103.0, 104.0])
+
+# Exponential Moving Average
+ema_20 = time_series.ema(prices, n=20)
+
+# Rolling volatility
+vol = time_series.volatility(prices, n=20)
+
+# Returns
+rets = time_series.returns(prices)
+
+# VWAP
+volumes = Tensor([100.0, 110.0, 105.0, 120.0, 115.0])
+vwap = time_series.vwap(prices, volumes)
+```
+
+## Directory Structure
+
+```
+quantmllibrary/
+├── quantml/                    # Main library package
+│   ├── __init__.py            # Package initialization
+│   ├── tensor.py              # Core Tensor class
+│   ├── autograd.py            # Automatic differentiation
+│   ├── ops.py                 # Operations (NumPy-optimized)
+│   ├── functional.py          # Functional API
+│   ├── time_series.py         # Quant-specific operations
+│   ├── streaming.py           # Streaming tensors
+│   ├── online.py              # Online learning
+│   ├── config/                # Configuration management
+│   │   ├── __init__.py
+│   │   └── config.py          # YAML/JSON config support
+│   ├── data/                  # Data management
+│   │   ├── __init__.py
+│   │   ├── validators.py      # Data validation
+│   │   ├── loaders.py         # Data loaders
+│   │   ├── feature_store.py   # Feature caching
+│   │   └── memory_optimizer.py # Memory optimization
+│   ├── models/                # Neural network models
+│   │   ├── linear.py
+│   │   ├── rnn.py
+│   │   └── tcn.py
+│   ├── optim/                  # Optimizers and schedulers
+│   │   ├── sgd.py
+│   │   ├── adam.py
+│   │   ├── rmsprop.py
+│   │   ├── adagrad.py
+│   │   ├── adafactor.py
+│   │   ├── lookahead.py
+│   │   ├── radam.py
+│   │   ├── quant_optimizer.py
+│   │   └── schedulers.py
+│   ├── training/               # Training utilities
+│   │   ├── trainer.py
+│   │   ├── losses.py
+│   │   ├── metrics.py
+│   │   ├── features.py
+│   │   ├── walk_forward.py
+│   │   ├── backtest.py
+│   │   ├── alpha_eval.py
+│   │   └── ...
+│   ├── experiments/            # Experiment tracking
+│   │   └── ...
+│   └── utils/                  # Utilities
+│       ├── logging.py
+│       ├── reproducibility.py
+│       └── profiling.py
+├── examples/                   # Example scripts
+│   ├── quick_alpha.py         # Quick alpha generation
+│   ├── production_alpha.py   # Production pipeline
+│   ├── alpha_training.py      # Alpha training example
+│   └── ...
+├── tests/                      # Test suite
+│   ├── test_tensor.py
+│   ├── test_ops.py
+│   ├── test_models.py
+│   └── integration/
+├── configs/                   # Configuration files
+│   ├── base.yaml
+│   └── experiments/
+├── docs/                       # Documentation
+│   └── ...
+├── benchmarks/                 # Performance benchmarks
+├── requirements.txt            # Core dependencies
+├── requirements-dev.txt        # Dev dependencies
+├── environment.yml            # Conda environment
+├── pyproject.toml             # Package configuration
+└── README.md                  # This file
+```
+
+## Usage for Research
+
+### Overnight Gap Prediction
+
+```python
+from quantml.config import load_config, ExperimentConfig
+from quantml.data import load_csv_data, validate_price_data
+from quantml.training import FeaturePipeline, QuantTrainer
+from quantml.models import Linear
+from quantml.optim import Adam
+
+# Load configuration
+config = load_config('configs/experiments/overnight_gap.yaml')
+
+# Load and validate data
+data = load_csv_data(
+    config.data.data_path,
+    price_column='close',
+    volume_column='volume'
+)
+
+is_valid, errors = validate_price_data(data['prices'], data['volumes'])
+if not is_valid:
+    print(f"Data validation errors: {errors}")
+
+# Create features for gap prediction
+pipeline = FeaturePipeline()
+pipeline.add_lagged_feature('price', lags=[1, 5, 10, 20])
+pipeline.add_rolling_feature('price', window=20, func='mean')
+pipeline.add_time_series_feature('price', 'volatility', n=20)
+
+features = pipeline.transform({'price': data['prices']})
+
+# Train model (see examples/alpha_training.py for full example)
+```
+
+### Multi-Instrument Support (ES, MES, NQ, MNQ)
+
+```python
+from quantml.config import load_config
+
+# Load instrument-specific config
+es_config = load_config('configs/instruments/ES.yaml')
+mes_config = load_config('configs/instruments/MES.yaml')
+
+# Run experiments for each instrument
+for instrument, config in [('ES', es_config), ('MES', mes_config)]:
+    # Load data for instrument
+    # Create features
+    # Train model
+    # Evaluate
+    pass
+```
+
+### Walk-Forward Optimization
+
+```python
+from quantml.training import WalkForwardOptimizer, WindowType
+
+wfo = WalkForwardOptimizer(
+    window_type=WindowType.EXPANDING,
+    train_size=500,  # 500 days training
+    test_size=100    # 100 days testing
+)
+
+for train_idx, test_idx in wfo.split(features, n_splits=5):
+    # Train on train_idx (past data only)
+    # Test on test_idx (future data)
+    # No lookahead bias!
+    pass
+```
+
+## Features
+
+### Core Components
+- **Tensor Operations**: Full-featured tensor class with automatic differentiation
+- **Autograd Engine**: Dynamic computation graphs with backpropagation
+- **NumPy-Optimized**: 2-5x faster operations with optional NumPy acceleration
+- **Zero Dependencies**: Pure Python with optional NumPy for performance
+
+### Quant-Specific Operations
+- **Time-Series Ops**: EMA, WMA, rolling mean/std, volatility, z-score
+- **Market Data**: VWAP, order flow imbalance, microprice
+- **Returns**: Returns, log returns calculations
+- **Streaming Support**: Ring buffer tensors for tick-level market data
+
+### Neural Network Models
+- **Linear**: Fully connected layer
+- **SimpleRNN**: Recurrent neural network
+- **TCN**: Temporal Convolutional Network
+
+### Optimizers (8 Total)
+- **SGD**: Stochastic Gradient Descent with momentum and weight decay
+- **Adam**: Adaptive Moment Estimation
+- **RMSProp**: Root Mean Square Propagation
+- **AdaGrad**: Adaptive Gradient
+- **AdaFactor**: Memory-efficient Adam variant
+- **Lookahead**: Wrapper optimizer for training stability
+- **RAdam**: Rectified Adam with variance rectification
+- **QuantOptimizer**: Custom optimizer with volatility-aware learning rates
+
+### Learning Rate Schedulers (6 Types)
+- **StepLR**: Step decay by factor
+- **CosineAnnealingLR**: Cosine annealing schedule
+- **WarmupLR**: Linear/cosine warmup
+- **ReduceLROnPlateau**: Reduce on metric plateau
+- **CyclicLR**: Cyclic learning rates
+- **OneCycleLR**: One cycle policy
+
+### Training Utilities
+- **QuantTrainer**: Training loop with early stopping, checkpointing, metrics tracking
+- **Gradient Clipping**: Norm clipping, value clipping, adaptive clipping
+- **Gradient Accumulation**: Effective larger batch sizes
+- **Learning Rate Finder**: Automatic optimal LR discovery
+- **Model Ensembling**: Weighted averaging, voting, stacking
+- **Feature Importance**: Gradient-based and permutation-based importance
+- **Cross-Validation**: TimeSeriesSplit, PurgedKFold for time-series data
+- **Regularization**: Dropout layer
+
+### Quant-Specific Loss Functions
+- **Sharpe Loss**: Optimize for Sharpe ratio
+- **Quantile Loss**: For quantile regression
+- **Information Ratio Loss**: Optimize for information ratio
+- **Huber Loss**: Robust to outliers
+- **Asymmetric Loss**: Different penalties for over/under-prediction
+- **Max Drawdown Loss**: Optimize to reduce drawdowns
+- **Combined Quant Loss**: Multi-objective quant loss
+
+### Financial Metrics
+- **Performance**: Sharpe, Sortino, Calmar ratios, max drawdown
+- **Alpha Metrics**: Information Coefficient (IC), Rank IC, hit rate
+- **Risk Metrics**: VaR, CVaR, turnover
+- **Backtesting**: Complete backtesting engine with transaction costs
+
+### Feature Engineering
+- **FeaturePipeline**: Reproducible feature creation
+- **Lagged Features**: Multiple lag periods
+- **Rolling Windows**: Mean, std, min, max over windows
+- **Normalization**: Z-score, min-max, robust scaling
+
+### Walk-Forward & Backtesting
+- **WalkForwardOptimizer**: Time-series aware train/test splits
+- **BacktestEngine**: Strategy backtesting with P&L tracking
+- **AlphaEvaluator**: Comprehensive alpha signal evaluation
+
+## Architecture
+
+```
+quantml/
+├── tensor.py              # Core Tensor class with NumPy optimization
+├── autograd.py            # Automatic differentiation
+├── ops.py                 # Operations (NumPy-optimized)
+├── functional.py          # Functional API
+├── time_series.py         # Quant-specific operations
+├── streaming.py           # Streaming tensors with ring buffer
+├── online.py              # Online learning utilities
+├── config/                # Configuration management
+│   └── config.py          # YAML/JSON config support
+├── data/                  # Data management
+│   ├── validators.py      # Data validation
+│   ├── loaders.py         # Data loaders
+│   ├── feature_store.py   # Feature caching (Parquet)
+│   └── memory_optimizer.py # Memory optimization
+├── models/                # Neural network models
+│   ├── linear.py
+│   ├── rnn.py
+│   └── tcn.py
+├── optim/                 # Optimizers and schedulers
+│   ├── sgd.py
+│   ├── adam.py
+│   └── ... (8 optimizers total)
+├── training/              # Training utilities
+│   ├── trainer.py
+│   ├── losses.py
+│   ├── metrics.py
+│   ├── features.py
+│   ├── walk_forward.py
+│   ├── backtest.py
+│   └── ... (15+ modules)
+├── experiments/           # Experiment tracking
+│   └── ...
+└── utils/                 # Utilities
+    ├── logging.py
+    ├── reproducibility.py
+    └── profiling.py
+```
+
+## Performance
+
+**Measured Benchmarks** (see `docs/benchmark_results.md` for details):
+
+- **Inference Latency**: 0.02-0.07ms average (sub-millisecond, suitable for HFT)
+- **Training Throughput**: 7,000-14,000 steps/second
+- **Tensor Operations**: 250,000+ ops/sec (100x100 tensors)
+- **Matrix Multiplication**: 2,000-14,000 ops/sec (depending on size)
+
+**Optimization Benefits**:
+- **NumPy-optimized**: Direct array operations eliminate conversion overhead
+- **Memory Efficient**: NumPy arrays reduce memory footprint vs Python lists
+- **Low Latency**: Sub-millisecond inference enables real-time trading
+- **High Throughput**: Optimized training loops for rapid iteration
+
+## Examples
+
+See the `examples/` directory for complete examples:
+
+- **`quick_alpha.py`**: Generate alpha signals immediately
+- **`alpha_training.py`**: Complete alpha generation pipeline
+- **`production_alpha.py`**: Production-ready pipeline with walk-forward
+- **`walk_forward_training.py`**: Walk-forward optimization example
+- **`backtest_strategy.py`**: Strategy backtesting
+- **`futures_model.py`**: Complete futures trading pipeline
+- **`online_regression.py`**: Online learning with streaming data
+- **`streaming_training.py`**: Per-tick model updates
+- **`live_alpha_generator.py`**: Real-time alpha generation
+
+## Documentation
+
+- **`ALPHA_GUIDE.md`**: Complete guide to generating alpha
+- **`examples/config_example.yaml`**: Configuration file example
+- **API Documentation**: See docstrings in each module
+
+## Design Philosophy
+
+1. **Clean & Hackable**: Code is readable and easy to modify (micrograd-level clarity)
+2. **Minimal Dependencies**: Pure Python with optional NumPy
+3. **Quant-First**: Operations designed for trading workflows
+4. **Streaming Native**: Built for tick-level data from the ground up
+5. **Low Latency**: CPU-optimized for fast inference
+6. **Performance**: NumPy-optimized operations throughout
+7. **Reproducible**: Random seed management, experiment tracking, version control
+
+## Comparison to PyTorch/JAX
+
+QuantML is designed specifically for quant trading use cases:
+
+- **Smaller footprint**: No CUDA, no complex backends
+- **Streaming-first**: Native support for ring buffers and tick data
+- **Quant ops**: Built-in EMA, VWAP, order flow, etc.
+- **Online learning**: Per-tick updates out of the box
+- **Simpler API**: Easier to understand and modify
+- **Quant-specific**: Optimizers, losses, and metrics for trading
+- **Walk-forward**: Built-in time-series cross-validation
+- **Backtesting**: Integrated backtesting engine
+
+## Key Use Cases
+
+1. **Alpha Generation**: Train models to predict returns
+2. **Signal Processing**: Real-time feature engineering on streaming data
+3. **Online Learning**: Update models on every tick
+4. **Strategy Backtesting**: Test trading strategies with realistic costs
+5. **Feature Engineering**: Create reproducible quant features
+6. **Model Ensembling**: Combine multiple models for robust predictions
+7. **Futures Trading**: Overnight gap prediction, multi-instrument support
+8. **Research**: Reproducible experiments for academic papers
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+
+MIT License - see LICENSE file for details.
+
+## Status
+
+This is an alpha release. The API may change in future versions.

quantmllibrary-0.1.0.dist-info/RECORD

@@ -0,0 +1,79 @@
+quantml/__init__.py,sha256=lILQXXzEURJiVU7hexV1uMlnQn9acnkMWvVrxlSAOH0,1508
+quantml/autograd.py,sha256=o8SRJCg3FBXjm1Y9--VznUBuGU2KBR1dLCmyUASetlU,5006
+quantml/functional.py,sha256=6iV5kIaGfPG1_-TaV7Q2mMnVxVPxYuRW0gIDIjsxvkY,742
+quantml/online.py,sha256=nqkIJWmQsVwtwjhM6YXrb5Iiu4Kag-PDlQYnLkFbf1w,6337
+quantml/ops.py,sha256=Be2Pero4PeNvWi9SYjjtlkxoqj6pfOUeVC6p6iLgJEs,63780
+quantml/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+quantml/streaming.py,sha256=EShD2WEgmZxNa5HZ1NIb5C81bEGtwS0FyjMEPZdW0pc,5384
+quantml/tensor.py,sha256=bonoOlwUigZopDMUWlgmAl4LAfZDOAelgQ_t3CqsyPU,17727
+quantml/time_series.py,sha256=ORoFgxv_Ih4BFdrl4DqSCWZhzuma4nYdpoe410iVZcY,12840
+quantml/cli/__init__.py,sha256=XsRVZ7IhpF_DvRGCOoA5LyHgrSm2vY9uRwoQu7Ktn20,176
+quantml/cli/run_experiment.py,sha256=uFBwqf_w3CcrBVVSTJ5qRi_V415Ms_a5ujH2o8we14M,13955
+quantml/config/__init__.py,sha256=RbeUHar3kK9_szE0djWB6jmADP1cKX2ska4j7bX74m8,482
+quantml/config/config.py,sha256=cb6bYrJcs2jGS1YWXzBRv-7m73va73h8N3oSjVYR4Bo,9100
+quantml/data/__init__.py,sha256=lPPaLFod54S0XL4i3zoUAfaoveBpHAsA4VDUMKmAaSU,633
+quantml/data/cache.py,sha256=ernv2iRuvgl7Zf5FU1YJMs4BL_1LL4N_OrIvLUPSnXw,4425
+quantml/data/feature_store.py,sha256=WXrx5Ryl15mIcYKxizjOyaAu0EUyqQRF_HEZqJlWOVU,7222
+quantml/data/futures.py,sha256=mvfiKE7KBkrrf2xrUqqqV9drgXdHSyxa2DfTmnxt7Vo,7972
+quantml/data/loaders.py,sha256=T4F0Mwg-AXV4xZlUhletA-Xpp-mjwYOUl97ADfPDP8c,7111
+quantml/data/memory_optimizer.py,sha256=4xuRlfC-C3vdZxZ10GV6M71ZhwtR8FboMTQeYuTkjf0,6307
+quantml/data/validators.py,sha256=rXvomR4zMlDVwTuwzDBelqskwP0RrZHHhhtImfLbEjo,11708
+quantml/experiments/__init__.py,sha256=4sEYP3qdsQOdDcwLfBavoWlUAriaChanVmsqn0lU8eg,623
+quantml/experiments/logger.py,sha256=CmiNKOvujaX1fRUtQJxSGxGi5hRX-NxDlGKRrcNY7mo,6389
+quantml/experiments/results.py,sha256=nCenrQZAZ_gyKeDLKGwjXI358ZOLiyz4GFmxTfTM1o0,5024
+quantml/experiments/tracker.py,sha256=wCVS61_xcdJ3t0ZzV_mQDmGu1wI-SzOoRf3G53oqNFs,7564
+quantml/features/__init__.py,sha256=mlojJt0vLT2DHYmvGPd6c4gXclicfRF9LUjnB-8C744,760
+quantml/features/base.py,sha256=NCcgrBznG0x9he4URAffPrwmubX7fAkstaE56o-W9H8,2757
+quantml/features/gap_features.py,sha256=5fFgluu3YwBwl_2VsFYQnEpmaPes9HX0HRuMHviSZ4w,4126
+quantml/features/registry.py,sha256=6Nqk65DxNQQAsTup6O6LKbGU5dXqIvWIkIhgmeh-vHI,3475
+quantml/features/volatility_features.py,sha256=bTxu1cuzw1OY2ZLTQAalHV96OJIo-3VRPOQRc5IceEw,4722
+quantml/features/volume_features.py,sha256=kNgHvIxj4RXxG9WMpWXV03gl6FiLmD-pepWyf3cgrgg,4774
+quantml/models/__init__.py,sha256=BAbJlq0QWgLuiBXxGadMb4iSXQ5N_90H56Nn0b3YCas,807
+quantml/models/attention.py,sha256=9DLluZmQLPhcUwew6EJAIVLX-yJWT39oyt_mj1Htzks,9653
+quantml/models/dropout.py,sha256=Hb5TgeEU-_LoUowXqLNSwRfQOYJ2JD2XivA9TsTJ_fA,4168
+quantml/models/gru.py,sha256=ii-nftZMXF9A_FaGwZXar1te9lTFJtwPBv1UFOTDQhY,10778
+quantml/models/linear.py,sha256=HPi6-t8AcEr2xBqCEAxn_Ug5-BTXPzZOqSYZjKC5DXU,3484
+quantml/models/lstm.py,sha256=KgALKjd3vsPelzU-ZMFD3RG3t4W_OBJAs5kLtCyu-V0,12420
+quantml/models/mlp.py,sha256=OySHwKp782rdAo2u3qcDS8V1ig4WrX0S5aLIFAcm13c,9440
+quantml/models/normalization.py,sha256=ZuT3kRUo6_b_z3r2AmFGe0nfxC5_nv8Yp9E29mne7nQ,10055
+quantml/models/rnn.py,sha256=FB9wFVv12j0tJ6DOnrBtPwGRRbHNgoj49phxE15Av1Y,5029
+quantml/models/tcn.py,sha256=c9kLOUfuwyObCIbYtP2nxwLJbveH1VoeUUw4Qa0DFb0,7696
+quantml/optim/__init__.py,sha256=d7HKTseqYUOYzkMINtkpwrBiEszOrR4RUq3v1HPieBw,872
+quantml/optim/adafactor.py,sha256=pwyMFFE9_7O3-uTGvJT8w4XgIvBduxu8ePZ2oPvPpNA,7714
+quantml/optim/adagrad.py,sha256=jazAIu05Yta3mdfCntoqR0J0mi4khQp5EOugZpHtyno,5093
+quantml/optim/adam.py,sha256=F6H46nfNix5hW8gxf0OUrOFEiqFlXq_bTbpddsOjvx0,9281
+quantml/optim/lookahead.py,sha256=mr7-9VtyYrBohgXd5ucs1HsRbdHvWsWM4U9HHEObAvE,3479
+quantml/optim/quant_optimizer.py,sha256=O5m24IMg5MXLkz-JwzHq_jIPwYXZLtJ20GrSHcy9Bkc,8609
+quantml/optim/radam.py,sha256=bcEYYQt_deVp6ms-GyDaC656tPtMqbYEIzflHL2j7I4,6816
+quantml/optim/rmsprop.py,sha256=KPX8hcZDWsblMb8uXyo15QGxNHPW8ah-Ipydkhc-BOA,7144
+quantml/optim/schedulers.py,sha256=oCKKu-UKAI_H98HpYlnx9xIyxWAm_gHiUmHnq4KgdPw,10548
+quantml/optim/sgd.py,sha256=kI_QjOLlxsTb7WP65GvbBMPO8c_piFX-sBddTnvR9qA,5974
+quantml/training/__init__.py,sha256=j6cuBz3VOdEDwYBvLSL46NSF_-hUNwoA1Z1cYpAWVyo,2773
+quantml/training/alpha_eval.py,sha256=Ggo7jeELBogTA-deLBB2Hdkn0oboob7tahQlqQphtQk,6417
+quantml/training/backtest.py,sha256=PuVqjh3NBWPI46WF4nVe00YDxlLFey8HBg0YBe3Iq0I,11146
+quantml/training/backtest_analysis.py,sha256=JVBlq2iqnm6vNRI3c2DVEk1xixt5v4y8EE2dGWvFBmE,5080
+quantml/training/cv.py,sha256=Si-XD1hhAMVEkroyMc-HiK7oJBDlivcQCuPZGVpnWF8,3092
+quantml/training/data_loader.py,sha256=l2rQnDMOLZ_jsWCPyaizknfZ6kAnGiOcVQB_AoK9PjM,5231
+quantml/training/ensemble.py,sha256=QqAtq6RxnDu1NaBepA_x4jKUWPVaZBlnJ9L5Dcsi8PA,2837
+quantml/training/feature_importance.py,sha256=iMmCGO1s7JWCmCYwaeA7ccZTIHYTLU8dumzkZC9AAzI,4297
+quantml/training/features.py,sha256=m6louCh__tvDpo1td37MrFxVmvTwAiGZdkIFRfhmdLc,12417
+quantml/training/futures_backtest.py,sha256=PtBjA4vGlZKVVy0fNjVfZ-pN-PAyrGV87WYEuWFovBg,10167
+quantml/training/gradient_clipping.py,sha256=_GebZM5bulKQKL1Sgn0nE-NAqHMYkYKKJp4ARa4x3ts,7239
+quantml/training/losses.py,sha256=90pxsoNGXHESM4kbM1MH11EYWGU8IQG8lJpMKxmVY8o,6690
+quantml/training/lr_finder.py,sha256=m20J0ICAA417nycBd_vtBy3tWkDQvmYOzChonjN6rRU,3653
+quantml/training/metrics.py,sha256=W4u5x_tVO9Htty0NI5niKeccW6_G5oFdP2a4-xs0i90,10678
+quantml/training/regularization.py,sha256=uJ5F7qLUw7q-AUoF1RS5dDyEloi4XCQ6D683U-R_GLc,2607
+quantml/training/trainer.py,sha256=Ivb1Mme8872Tf8rfKARKtkCT36vXxWy4wUv9P8ZBntk,8086
+quantml/training/walk_forward.py,sha256=0UHvnO3kEBF79qAepWlBUMt-2MnzYQawLetJj_2UaDQ,6257
+quantml/utils/__init__.py,sha256=Z9IVACjqz4WPW2ol0aCzO8xwBKx0u8shmRHEsGHlYAQ,1065
+quantml/utils/gradient_check.py,sha256=JF2CvNkMUdyDN6nFxPpTIQMzdreT38PNtqRS060A5wo,8316
+quantml/utils/logging.py,sha256=EE6pP-9tkn_Iguwy1SB0OgAgcsL5x2OZW99JcuhA63E,4759
+quantml/utils/ops_cpu.py,sha256=l0iztlXiYHfanIAG7K-8G_g80N76dGiwvFNy0dBKFJ0,7131
+quantml/utils/profiling.py,sha256=KlwnHKZR8UhF6c0CbDuXHeZ57b9YWvFBJEY1H2pZOek,10802
+quantml/utils/reproducibility.py,sha256=EVO2cyNI7RTjj7FRhS22CPyw9HIGsI4P6BIdE1zfIks,5509
+quantml/utils/serialization.py,sha256=puzfy1Z5JRrKfbLFldKalAOkkAPFKMl7ATbuV2cBsfs,9791
+quantmllibrary-0.1.0.dist-info/licenses/LICENSE,sha256=O72pW8FNah_i6YbFFNTb_dzlAS1Lvwce_dPxFDc4Dnw,1078
+quantmllibrary-0.1.0.dist-info/METADATA,sha256=UgkYdf7yE8UTAA5rnO8uoeahVx26CQwUcWrCpKXPqPQ,18685
+quantmllibrary-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+quantmllibrary-0.1.0.dist-info/top_level.txt,sha256=Bw_CMshUABCzP3PzMZdKw9NHNTbHG79iZXpG2uborOo,8
+quantmllibrary-0.1.0.dist-info/RECORD,,

quantmllibrary-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

quantmllibrary-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 QuantML Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

quantmllibrary-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+quantml