diff --git a/.github/NAMING_CONVENTION_REFACTOR.md b/.github/NAMING_CONVENTION_REFACTOR.md new file mode 100644 index 00000000..e83088c4 --- /dev/null +++ b/.github/NAMING_CONVENTION_REFACTOR.md @@ -0,0 +1,321 @@ +# Naming Convention Refactor for v2.0 + +## Overview + +The current codebase uses non-standard naming conventions that violate PEP 8 guidelines. This document outlines a plan to refactor the naming conventions in a future major version (v2.0) to align with Python best practices. + +## Current State + +### PEP 8 Violations + +The codebase currently uses **PascalCase for method names** instead of the recommended **snake_case**: + +**Examples:** +- `initAll()` → should be `init_all()` +- `run_Bootstrap()` → should be `run_bootstrap()` +- `run_Interpolate()` → should be `run_interpolate()` +- `run_Stats()` → should be `run_stats()` +- `StatsSingle()` → should be `stats_single()` (function, not class) +- `get_TrainingResults_recipe()` → should be `get_training_results_recipe()` +- `get_TrainingStats_recipe()` → should be `get_training_stats_recipe()` + +### Why This Exists + +This appears to be a deliberate design choice made early in the project. The naming convention is: +- Consistent throughout the codebase +- Used in all examples and documentation +- Part of the public API +- Not a bug, just a stylistic deviation from PEP 8 + +## Why Change It? + +### Benefits + +1. **PEP 8 Compliance**: Aligns with Python community standards +2. **Better Tooling**: Many linters/formatters expect snake_case for methods +3. **Consistency**: Matches Python standard library conventions +4. **Readability**: snake_case is more readable for longer method names +5. **Professional**: Shows adherence to Python best practices + +### Costs + +1. **Breaking Change**: Existing code using the library will break +2. **Documentation Update**: All examples, tutorials, and docs need updating +3. **Migration Effort**: Users need to update their code +4. **Testing**: Extensive testing needed to ensure nothing breaks + +## Refactor Plan + +### Phase 1: Inventory (v1.x) + +- [ ] Create comprehensive list of all public API methods with non-standard naming +- [ ] Categorize by module (stochastic_benchmark, bootstrap, stats, etc.) +- [ ] Identify which methods are most commonly used (check examples) +- [ ] Document current usage patterns + +### Phase 2: Deprecation Period (v1.x → v2.0) + +**Option A: Dual API (Recommended)** +```python +# Add new snake_case methods alongside old PascalCase ones +def init_all(self, ...): + """New naming convention.""" + # implementation + +def initAll(self, ...): + """Deprecated: Use init_all() instead.""" + warnings.warn( + "initAll() is deprecated and will be removed in v2.0. " + "Use init_all() instead.", + DeprecationWarning, + stacklevel=2 + ) + return self.init_all(...) +``` + +**Timeline:** +- v1.x: Add new methods, deprecate old ones with warnings +- v1.x+1: Update all examples to use new naming +- v1.x+2: Update documentation to recommend new naming +- v2.0: Remove deprecated methods (breaking change) + +**Option B: Direct Migration (Faster but riskier)** +- v2.0: Rename all methods, publish migration guide +- Provide automated migration script + +### Phase 3: Implementation (v2.0) + +#### Core Methods to Rename + +**stochastic_benchmark.py:** +```python +# Current → New +initAll() → init_all() +run_Bootstrap() → run_bootstrap() +run_Interpolate() → run_interpolate() +run_Stats() → run_stats() +get_TrainingResults_recipe() → get_training_results_recipe() +get_TrainingStats_recipe() → get_training_stats_recipe() +``` + +**Other modules:** +```python +# bootstrap.py +Bootstrap() → bootstrap() +BootstrapSingle() → bootstrap_single() +Bootstrap_reduce_mem() → bootstrap_reduce_mem() + +# stats.py +Stats() → stats() +StatsSingle() → stats_single() + +# interpolate.py +Interpolate() → interpolate() +Interpolate_reduce_mem() → interpolate_reduce_mem() +``` + +#### Files to Update + +1. **Source Code:** + - [ ] `src/stochastic_benchmark.py` + - [ ] `src/bootstrap.py` + - [ ] `src/stats.py` + - [ ] `src/interpolate.py` + - [ ] `src/training.py` + - [ ] `src/random_exploration.py` + - [ ] `src/sequential_exploration.py` + - [ ] Other modules as needed + +2. **Tests:** + - [ ] `tests/test_bootstrap.py` + - [ ] `tests/test_stats.py` + - [ ] `tests/test_stochastic_benchmark.py` (if exists) + - [ ] All integration tests + - [ ] All other test files + +3. **Examples:** + - [ ] `examples/QAOA_iterative/` + - [ ] `examples/QAOA_multipleSplits/` + - [ ] `examples/wishart_n_50_alpha_0.5/` + - [ ] Any other example directories + +4. **Documentation:** + - [ ] `README.md` + - [ ] `TESTING.md` + - [ ] API documentation + - [ ] Tutorial notebooks + - [ ] Inline code comments + +### Phase 4: Migration Support + +#### Provide Migration Tools + +**Option 1: Automated Script** +```python +# migrate_naming.py +""" +Script to automatically update code from v1.x to v2.0 naming conventions. + +Usage: + python migrate_naming.py path/to/your/code +""" + +import re +import sys +from pathlib import Path + +REPLACEMENTS = { + r'\.initAll\(': '.init_all(', + r'\.run_Bootstrap\(': '.run_bootstrap(', + r'\.run_Interpolate\(': '.run_interpolate(', + r'\.run_Stats\(': '.run_stats(', + # Add all other replacements +} + +def migrate_file(filepath): + """Update a single file to v2.0 naming.""" + with open(filepath, 'r') as f: + content = f.read() + + original = content + for old, new in REPLACEMENTS.items(): + content = re.sub(old, new, content) + + if content != original: + with open(filepath, 'w') as f: + f.write(content) + return True + return False + +# Implementation continues... +``` + +**Option 2: Migration Guide** +Create a comprehensive guide in `MIGRATION_v1_to_v2.md`: +```markdown +# Migration Guide: v1.x to v2.0 + +## Breaking Changes + +### Method Naming + +All public API methods now use snake_case instead of PascalCase. + +| Old (v1.x) | New (v2.0) | +|------------|------------| +| `sb.initAll()` | `sb.init_all()` | +| `sb.run_Bootstrap()` | `sb.run_bootstrap()` | +| ... | ... | + +## Quick Migration Steps + +1. Find and replace in your codebase +2. Run tests +3. Update any custom extensions +``` + +### Phase 5: Release Strategy + +**v1.x (Current):** +- Continue bug fixes and critical updates +- No new features with old naming +- Document deprecation plan + +**v1.x+1 (Deprecation Start):** +- Add all new snake_case methods +- Old methods remain but emit DeprecationWarning +- Update all examples to use new naming +- Release migration guide + +**v1.x+2 (Final Warning):** +- Increase warning visibility +- Update all documentation +- Provide automated migration script +- Set firm v2.0 release date + +**v2.0 (Breaking Release):** +- Remove all deprecated methods +- Only snake_case API available +- Clean, PEP 8 compliant codebase + +## Success Criteria + +- [ ] All public methods use snake_case +- [ ] All tests pass with new naming +- [ ] All examples updated and working +- [ ] Documentation completely updated +- [ ] Migration guide published +- [ ] Migration script tested on example codebases +- [ ] No reduction in test coverage +- [ ] User feedback incorporated + +## Timeline Estimate + +- **Phase 1 (Inventory)**: 1-2 weeks +- **Phase 2 (Deprecation)**: 3-6 months across multiple releases +- **Phase 3 (Implementation)**: 2-3 weeks +- **Phase 4 (Migration Support)**: 2 weeks +- **Phase 5 (Release)**: Following standard release cycle + +**Total**: ~6-9 months from start to v2.0 release + +## Risks and Mitigations + +### Risk: Breaking User Code +**Mitigation**: Long deprecation period with clear warnings + +### Risk: Incomplete Migration +**Mitigation**: Automated testing, comprehensive checklists + +### Risk: Documentation Drift +**Mitigation**: Update docs simultaneously with code + +### Risk: User Confusion +**Mitigation**: Clear communication, migration tools + +## Alternative Approaches + +### Keep Current Naming +**Pros**: No breaking changes, existing code continues to work +**Cons**: Continues to violate PEP 8, may confuse Python developers + +### Gradual Module-by-Module +**Pros**: Smaller, more manageable changes +**Cons**: Inconsistent API during transition, longer timeline + +### Aliases Forever +**Pros**: Backward compatible +**Cons**: Maintains technical debt, larger codebase + +## Decision + +**Recommended Approach**: Option A (Dual API with Deprecation Period) + +This provides the best balance of: +- User experience (time to adapt) +- Code quality (eventual PEP 8 compliance) +- Project maintainability (clean v2.0 codebase) + +## Next Steps + +1. Get stakeholder buy-in on this plan +2. Create GitHub issue to track this work +3. Begin Phase 1 (Inventory) when ready to start v2.0 planning +4. Communicate plan to users via: + - GitHub issue/discussion + - Release notes + - Documentation + - Email/blog if applicable + +## References + +- [PEP 8 - Style Guide for Python Code](https://peps.python.org/pep-0008/) +- [PEP 8 - Naming Conventions](https://peps.python.org/pep-0008/#naming-conventions) +- [Semantic Versioning](https://semver.org/) + +--- + +**Status**: Proposed +**Created**: 2025-10-21 +**Author**: GitHub Copilot +**Version**: Draft 1.0 diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md index 7c2689d0..4a3c0ec4 100644 --- a/.github/copilot-instructions.md +++ b/.github/copilot-instructions.md @@ -49,10 +49,10 @@ stochastic-benchmark/ ## Code Standards and Guidelines ### Python Version Compatibility -- **Minimum Python version**: 3.9 -- **Tested versions**: 3.9, 3.10, 3.11, 3.12 -- **Type hints**: Use `from typing import List, Dict, DefaultDict, ...` for compatibility -- **Avoid**: Modern syntax like `list[str]` or `dict[str, int]` (use `List[str]`, `Dict[str, int]`) +- **Minimum Python version**: 3.10 +- **Tested versions**: 3.10, 3.11, 3.12 +- **Type hints**: Use `from typing import List, Dict, DefaultDict, ...` for compatibility with older versions +- **Note**: You can use modern syntax like `list[str]` or `dict[str, int]` as Python 3.10+ supports it, but `List[str]`, `Dict[str, int]` is also acceptable ### Code Quality Standards - **Linting**: Code is linted with flake8 (max line length: 120 characters) @@ -181,7 +181,7 @@ def test_bootstrap_with_metrics(self, mock_evaluate): 5. **Handle edge cases** and error conditions 6. **Maintain backward compatibility** with existing APIs 7. **Document complex algorithms** with clear comments -8. **Test on multiple Python versions** (3.9-3.12) +8. **Test on multiple Python versions** (3.10-3.12) 9. **Keep functions focused** with single responsibilities 10. **Use descriptive variable names** and function signatures diff --git a/.github/copilot-setup-steps.yml b/.github/copilot-setup-steps.yml index 56fe4b9c..c8e53667 100644 --- a/.github/copilot-setup-steps.yml +++ b/.github/copilot-setup-steps.yml @@ -5,7 +5,7 @@ description: Automated setup steps for GitHub Copilot development in stochastic- setup_steps: environment: - python_version: "3.9+" + python_version: "3.10+" required_packages: core: - pandas @@ -49,7 +49,7 @@ setup_steps: - "pytest tests/ -v --cov=src" # Run with coverage 3_development: - - "Follow type annotation standards (Python 3.9+)" + - "Follow type annotation standards (Python 3.10+)" - "Write tests before implementing features" - "Use proper mocking for multiprocessing and external dependencies" - "Maintain docstring standards (NumPy style)" @@ -165,8 +165,8 @@ setup_steps: type_annotation_errors: - "Import required types from typing module" - - "Use Python 3.9+ compatible syntax" - - "Avoid using built-in generics (list[str] -> List[str])" + - "Use Python 3.10+ compatible syntax" + - "Can use built-in generics (list[str]) or typing module (List[str])" multiprocessing_issues: - "Mock Pool at correct module level" @@ -180,7 +180,7 @@ setup_steps: - "pull requests to main/develop" test_matrix: - python_versions: ["3.9", "3.10", "3.11", "3.12"] + python_versions: ["3.10", "3.11", "3.12"] operating_systems: ["ubuntu-latest"] required_checks: diff --git a/.gitignore b/.gitignore index f61ac7f4..590a9c80 100644 --- a/.gitignore +++ b/.gitignore @@ -155,3 +155,9 @@ notebooks/example_data/wishart* notebooks/example_data/max_clique* notebooks/example_data/sk_pleiades_n=200/* notebooks/example_data/sk_pleiades_n=100/checkpoints/*.DS_Store + +# Example checkpoints and large generated files +examples/**/checkpoints/*.pkl +examples/**/checkpoints/**/*.pkl +examples/**/*.pkl +!examples/**/*demo*.pkl diff --git a/CI-TESTING.md b/CI-TESTING.md new file mode 100644 index 00000000..0fcb58d5 --- /dev/null +++ b/CI-TESTING.md @@ -0,0 +1,188 @@ +# Local CI Testing Setup + +This directory contains files to replicate the GitHub Actions CI environment locally for testing the `stochastic-benchmark` package. + +## Files Created + +1. **`environment-ci.yml`** - Conda environment specification that matches CI dependencies +2. **`setup-ci-env.sh`** - Script to create and configure the conda environment +3. **`run-ci-tests.sh`** - Script to run tests exactly as the CI does + +## Quick Start + +### Option 1: Automated Setup (Recommended) + +```bash +# Create environment with Python 3.10 (default) +./setup-ci-env.sh + +# Or create environment with a specific Python version +./setup-ci-env.sh 3.11 # Python 3.11 +./setup-ci-env.sh 3.12 # Python 3.12 +``` + +### Option 2: Manual Setup + +```bash +# Create the conda environment +conda env create -f environment-ci.yml + +# Activate the environment +conda activate stochastic-benchmark-ci + +# Install the package in development mode +pip install -e . +``` + +## Running Tests + +Once the environment is set up and activated: + +```bash +# Activate the environment (if not already active) +conda activate stochastic-benchmark-ci-py310 # or py311, py312 + +# Run all tests exactly as CI does +./run-ci-tests.sh +``` + +This script will: +1. ✅ Lint code with flake8 +2. ✅ Run unit tests with pytest and coverage +3. ✅ Generate coverage reports (XML, HTML, terminal) +4. ✅ Run integration tests +5. ✅ Run smoke tests to verify module imports + +### Manual Test Commands + +If you prefer to run tests manually: + +```bash +# Set PYTHONPATH (important!) +export PYTHONPATH="${PYTHONPATH}:${PWD}/src" + +# Run all tests with coverage +pytest tests/ -v --cov=src --cov-report=xml --cov-report=html --cov-report=term + +# Run specific test files +pytest tests/test_bootstrap.py -v + +# Run with parallel execution (faster) +pytest tests/ -n auto + +# Run only integration tests +pytest tests/integration/ -v + +# Lint the code +flake8 src --count --select=E9,F63,F7,F82 --show-source --statistics +flake8 src --count --exit-zero --max-complexity=10 --max-line-length=120 --statistics +``` + +## Testing Multiple Python Versions (Like CI) + +The CI tests against Python 3.10, 3.11, and 3.12. To replicate this locally: + +```bash +# Create environments for each Python version +./setup-ci-env.sh 3.10 +./setup-ci-env.sh 3.11 +./setup-ci-env.sh 3.12 + +# Test each version +conda activate stochastic-benchmark-ci-py310 +./run-ci-tests.sh + +conda activate stochastic-benchmark-ci-py311 +./run-ci-tests.sh + +conda activate stochastic-benchmark-ci-py312 +./run-ci-tests.sh +``` + +## Viewing Coverage Reports + +After running tests, coverage reports are generated: + +- **Terminal**: Displayed automatically after test run +- **HTML**: Open `htmlcov/index.html` in your browser + ```bash + firefox htmlcov/index.html # or chrome, etc. + ``` +- **XML**: `coverage.xml` (for tools like codecov) + +## Troubleshooting + +### Import Errors + +Make sure `PYTHONPATH` is set correctly: +```bash +export PYTHONPATH="${PYTHONPATH}:${PWD}/src" +``` + +### Environment Already Exists + +If you need to recreate an environment: +```bash +conda env remove -n stochastic-benchmark-ci-py310 +./setup-ci-env.sh 3.10 +``` + +### Dependency Issues + +Update the environment with new dependencies: +```bash +conda env update -f environment-ci.yml -n stochastic-benchmark-ci-py310 +``` + +## CI Workflow Comparison + +| CI Step | Local Equivalent | +|---------|------------------| +| Install system dependencies | Handled by conda | +| Install Python dependencies | `conda env create -f environment-ci.yml` | +| Install package | `pip install -e .` | +| Lint with flake8 | Included in `run-ci-tests.sh` | +| Run tests with pytest | Included in `run-ci-tests.sh` | +| Generate coverage | Included in `run-ci-tests.sh` | +| Run integration tests | Included in `run-ci-tests.sh` | +| Smoke tests | Included in `run-ci-tests.sh` | + +## Environment Details + +The CI environment includes: + +**Core Dependencies:** +- numpy >= 2.0 +- pandas >= 2.3 +- scipy >= 1.11 +- matplotlib >= 3.7 +- seaborn >= 0.13.2 +- networkx >= 3.5 +- tqdm >= 4.66 + +**Additional Dependencies:** +- cloudpickle >= 2.2 +- dill >= 0.3.5 +- hyperopt >= 0.2.7 +- multiprocess >= 0.70.18 +- munkres >= 1.1.4 + +**Testing Tools:** +- pytest +- pytest-cov +- pytest-xdist +- flake8 +- coverage + +## Cleaning Up + +To remove the conda environment: +```bash +conda deactivate +conda env remove -n stochastic-benchmark-ci-py310 +``` + +To remove coverage reports and test artifacts: +```bash +rm -rf htmlcov/ .coverage coverage.xml .pytest_cache/ +``` diff --git a/Makefile b/Makefile new file mode 100644 index 00000000..963a30fe --- /dev/null +++ b/Makefile @@ -0,0 +1,98 @@ +# Makefile for stochastic-benchmark CI testing +# Provides convenient commands for setting up and running CI tests locally + +.PHONY: help setup-ci test lint coverage clean clean-all test-all quick-ref + +# Default Python version for CI environment +PYTHON_VERSION ?= 3.10 +ENV_NAME = stochastic-benchmark-ci-py$(subst .,,$(PYTHON_VERSION)) + +help: + @echo "════════════════════════════════════════════════════════════════" + @echo " Stochastic Benchmark - CI Testing Makefile" + @echo "════════════════════════════════════════════════════════════════" + @echo "" + @echo "Available commands:" + @echo "" + @echo " make setup-ci Create CI conda environment (Python $(PYTHON_VERSION))" + @echo " make test Run full CI test suite" + @echo " make test-all Test all Python versions (3.10, 3.11, 3.12)" + @echo " make lint Run flake8 linting" + @echo " make coverage Generate coverage report" + @echo " make clean Remove coverage reports and cache" + @echo " make clean-all Remove environments and all generated files" + @echo " make quick-ref Display quick reference card" + @echo "" + @echo "Environment management:" + @echo " make setup-ci PYTHON_VERSION=3.11 Setup with Python 3.11" + @echo " make setup-ci PYTHON_VERSION=3.12 Setup with Python 3.12" + @echo "" + @echo "Current settings:" + @echo " Python version: $(PYTHON_VERSION)" + @echo " Environment name: $(ENV_NAME)" + @echo "" + +setup-ci: + @echo "Creating CI environment with Python $(PYTHON_VERSION)..." + ./setup-ci-env.sh $(PYTHON_VERSION) + +test: + @echo "Running CI tests..." + @if ! conda env list | grep -q "$(ENV_NAME)"; then \ + echo "Environment $(ENV_NAME) not found. Run 'make setup-ci' first."; \ + exit 1; \ + fi + @bash -c "source $$(conda info --base)/etc/profile.d/conda.sh && conda activate $(ENV_NAME) && ./run-ci-tests.sh" + +test-all: + @echo "Testing all Python versions..." + ./test-all-python-versions.sh + +lint: + @echo "Running flake8 linting..." + @which flake8 > /dev/null || (echo "flake8 not found. Run 'make setup-ci' first." && exit 1) + flake8 src --count --select=E9,F63,F7,F82 --show-source --statistics + flake8 src --count --exit-zero --max-complexity=10 --max-line-length=120 --statistics + +coverage: + @echo "Generating coverage report..." + @export PYTHONPATH="$${PYTHONPATH}:$${PWD}/src" && \ + pytest tests/ --cov=src --cov-report=html --cov-report=term + @echo "" + @echo "HTML coverage report: htmlcov/index.html" + +clean: + @echo "Cleaning coverage reports and cache..." + rm -rf htmlcov/ .coverage coverage.xml .pytest_cache/ + find . -type d -name __pycache__ -exec rm -rf {} + 2>/dev/null || true + find . -type f -name "*.pyc" -delete 2>/dev/null || true + @echo "Done!" + +clean-all: clean + @echo "Removing all CI environments..." + @for py_ver in 310 311 312; do \ + env_name="stochastic-benchmark-ci-py$$py_ver"; \ + if conda env list | grep -q "$$env_name"; then \ + echo "Removing $$env_name..."; \ + conda env remove -n "$$env_name" -y; \ + fi; \ + done + @echo "All environments removed!" + +quick-ref: + @./quick-reference.sh + +# Shorthand aliases +test-py310: + @$(MAKE) setup-ci PYTHON_VERSION=3.10 + @$(MAKE) test PYTHON_VERSION=3.10 + +test-py311: + @$(MAKE) setup-ci PYTHON_VERSION=3.11 + @$(MAKE) test PYTHON_VERSION=3.11 + +test-py312: + @$(MAKE) setup-ci PYTHON_VERSION=3.12 + @$(MAKE) test PYTHON_VERSION=3.12 + +.DEFAULT_GOAL := help diff --git a/README.md b/README.md index 53bd2d2a..bc6bc582 100644 --- a/README.md +++ b/README.md @@ -2,7 +2,7 @@ [![CI](https://github.com/bernalde/stochastic-benchmark/actions/workflows/ci.yml/badge.svg)](https://github.com/bernalde/stochastic-benchmark/actions/workflows/ci.yml) [![codecov](https://codecov.io/gh/bernalde/stochastic-benchmark/branch/main/graph/badge.svg)](https://codecov.io/gh/bernalde/stochastic-benchmark) -[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/release/python-390/) +[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/release/python-3100/) [![License](https://img.shields.io/github/license/bernalde/stochastic-benchmark)](LICENSE) Repository for Stochastic Optimization Solvers Benchmark code @@ -62,6 +62,11 @@ The current package implements the following functionality: pip install -r requirements.txt ``` +4. **Optional: Install Example Dependencies** (needed for some example notebooks): + ```bash + pip install -r requirements-examples.txt + ``` + ### Method 2: Downloading as a Zip Archive 1. **Download the Repository**: @@ -81,6 +86,11 @@ The current package implements the following functionality: pip install -r requirements.txt ``` +4. **Optional: Install Example Dependencies** (needed for some example notebooks): + ```bash + pip install -r requirements-examples.txt + ``` + diff --git a/TESTING.md b/TESTING.md index dfe55a67..aa7ad182 100644 --- a/TESTING.md +++ b/TESTING.md @@ -54,7 +54,7 @@ pytest tests/ --cov=src --cov-report=html The repository includes automated testing via GitHub Actions: -- **Matrix Testing**: Tests across Python versions 3.8, 3.9, 3.10, 3.11, 3.12 +- **Matrix Testing**: Tests across Python versions 3.10, 3.11, 3.12 - **Linting**: Code quality checks with flake8 - **Coverage**: Automated coverage reporting via Codecov - **Integration Tests**: Cross-module functionality verification diff --git a/environment-ci.yml b/environment-ci.yml new file mode 100644 index 00000000..b5d0cf46 --- /dev/null +++ b/environment-ci.yml @@ -0,0 +1,48 @@ +# Conda environment file to replicate CI testing conditions +# This environment matches the GitHub Actions CI setup for local testing +# +# Usage: +# conda env create -f environment-ci.yml +# conda activate stochastic-benchmark-ci +# +# To test with different Python versions (like CI does with 3.10, 3.11, 3.12): +# conda env create -f environment-ci.yml -n stochastic-benchmark-ci-py311 python=3.11 +# conda env create -f environment-ci.yml -n stochastic-benchmark-ci-py312 python=3.12 + +name: stochastic-benchmark-ci +channels: + - conda-forge + - defaults + +dependencies: + # Python version (CI tests 3.10, 3.11, 3.12) + - python=3.10 + + # Only install pip from conda, everything else via pip for consistency with CI + - pip + + # Install all packages via pip to match CI exactly + - pip: + # Core dependencies from requirements.txt + - numpy>=2.0 + - pandas>=2.3 + - scipy>=1.11 + - matplotlib>=3.7 + - seaborn>=0.13.2 + - networkx>=3.0 + - tqdm>=4.66 + - cloudpickle>=2.2 + - dill>=0.3.5 + - fonttools>=4.25 + - mkl-service>=2.5.2 + - multiprocess>=0.70.18 + - hyperopt>=0.2.7 + - munkres>=1.1.4 + # Testing dependencies from requirements-dev.txt + - pytest + - pytest-cov + - pytest-xdist + # Linting (used in CI) + - flake8 + # Coverage tools + - coverage diff --git a/examples/QAOA_iterative/qaoa_demo.ipynb b/examples/QAOA_iterative/qaoa_demo.ipynb index 95a9ea13..69527b87 100644 --- a/examples/QAOA_iterative/qaoa_demo.ipynb +++ b/examples/QAOA_iterative/qaoa_demo.ipynb @@ -41,8 +41,25 @@ "metadata": {}, "source": [ "## Creating a `stochastic_benchmark` object\n", - "The primary class we will use is the `stochastic_benchmark` class in the `stochastic_benchmark` module. \n", - "Run the cell below to instantiate it." + "\n", + "The primary class we will use is the `stochastic_benchmark` class in the `stochastic_benchmark` module. This object orchestrates the entire benchmarking workflow.\n", + "\n", + "### Configuration Parameters:\n", + "\n", + "**Problem Parameters:**\n", + "- `parameter_names`: The algorithm parameters being tuned (e.g., iterations, shots, rounds)\n", + "- `instance_cols`: Columns used to group problem instances (default: `['instance']`)\n", + "\n", + "**Response Configuration:**\n", + "- `response_key`: The column containing the optimization objective (e.g., `approx_ratio`)\n", + "- `response_dir`: Optimization direction - use `1` for maximization, `-1` for minimization\n", + "\n", + "**Performance Optimizations:**\n", + "- `recover`: If `True`, loads existing dataframes when available instead of recomputing\n", + "- `reduce_mem`: If `True`, uses memory-efficient segmented processing for bootstrap and interpolation\n", + "- `smooth`: If `True`, ensures the virtual best performance curve is monotone (non-decreasing for maximization)\n", + "\n", + "Run the cell below to instantiate the benchmark object with these configurations." ] }, { @@ -51,25 +68,35 @@ "metadata": {}, "outputs": [], "source": [ + "# Working directory for storing checkpoints and results\n", "here = os.getcwd()\n", + "\n", + "# Algorithm parameters to analyze across different resource levels\n", + "# These are the \"knobs\" we can tune to improve performance\n", "parameter_names = [\n", - " \"iterations\",\n", - " \"shots\",\n", - " \"rounds\",\n", - "] # think about whether iterations should be a parameter or not.\n", - "instance_cols = [\n", - " \"instance\"\n", - "] # indicates how instances should be grouped, default is ['instance']\n", - "\n", - "## Response information\n", - "response_key = \"approx_ratio\" # Column with the response\n", - "response_dir = 1 # whether we want to maximize (1) or minimize (-1), default is 1\n", - "\n", - "## Optimizations informations\n", - "recover = True # Whether we want to read dataframes when available, default is True\n", - "reduce_mem = True # Whether we want to segment bootstrapping and interpolation to reduce memory usage, default is True\n", - "smooth = True # Whether virtual best should be monontonized, default is True\n", + " \"iterations\", # Number of COBYLA optimizer iterations\n", + " \"shots\", # Number of quantum circuit measurements per iteration\n", + " \"rounds\", # Number of QAOA rounds (p parameter)\n", + "]\n", + "\n", + "# Column(s) defining unique problem instances\n", + "# Each unique value identifies a separate optimization problem\n", + "instance_cols = [\"instance\"]\n", + "\n", + "# ============================================================\n", + "# Response Configuration\n", + "# ============================================================\n", + "response_key = \"approx_ratio\" # Optimization objective to maximize\n", + "response_dir = 1 # 1 = maximize, -1 = minimize\n", + "\n", + "# ============================================================\n", + "# Performance Options\n", + "# ============================================================\n", + "recover = True # Load cached results when available (faster restarts)\n", + "reduce_mem = True # Use memory-efficient processing for large datasets\n", + "smooth = True # Enforce monotone virtual best curve\n", "\n", + "# Create the stochastic_benchmark object\n", "sb = SB.stochastic_benchmark(\n", " parameter_names=parameter_names,\n", " here=here,\n", @@ -84,30 +111,66 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Load Bootstrap data\n", - "The cell below can be used to generate bootstrapped data from raw data. In this demo however, bootstrapped data for 10 problem instances is already stored in the `checkpoints` folder. Running the cell below will load that data into memory." + "## Load Bootstrap Data\n", + "\n", + "Bootstrap resampling quantifies the uncertainty in performance measurements by creating multiple resampled datasets. This provides confidence intervals for the approximation ratio at each resource level.\n", + "\n", + "### What happens in this step:\n", + "- **Loads pre-computed bootstrap data** from the `checkpoints` folder (for 10 problem instances)\n", + "- **Computes confidence intervals** at the specified confidence level (68% ≈ 1 standard deviation)\n", + "- **Iterates over multiple restart counts** to understand performance vs. computational budget tradeoffs\n", + "\n", + "### Configuration:\n", + "- `boots_range = [1, 2, 5, 10, 20, 50, 100]`: Number of algorithm restarts to analyze\n", + "- `confidence_level = 68`: Confidence level for intervals (68% ≈ ±1σ, 95% ≈ ±2σ)\n", + "- `response_col = \"approx_ratio\"`: The performance metric being bootstrapped\n", + "- `resource_col = \"resource\"`: The computational budget measure\n", + "\n", + "**Note:** In practice, you would generate bootstrap data from raw experimental runs. Here we load pre-computed results for efficiency." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading and bootstrapping experimental data...\n" + ] + } + ], "source": [ - "# Load Bootstrap data.\n", - "# The data is already boostrapped, but needs to be loaded into memory\n", + "# ============================================================\n", + "# Bootstrap Configuration\n", + "# ============================================================\n", + "# Common arguments for all bootstrap computations\n", "shared_args = {\n", - " \"response_col\": \"approx_ratio\",\n", - " \"resource_col\": \"resource\",\n", - " \"response_dir\": 1,\n", - " \"confidence_level\": 68,\n", + " \"response_col\": \"approx_ratio\", # Performance metric to bootstrap\n", + " \"resource_col\": \"resource\", # Computational budget column\n", + " \"response_dir\": 1, # 1 = maximize performance\n", + " \"confidence_level\": 68, # Confidence level for intervals (68% ≈ ±1σ)\n", "}\n", + "\n", + "# Range of restart counts to analyze\n", + "# Explores tradeoff: few restarts (fast) vs many restarts (better statistics)\n", "boots_range = [1, 2, 5, 10, 20, 50, 100]\n", + "\n", + "# Create bootstrap parameters object\n", + "# update_rule allows custom transformations; None = use data as-is\n", "bsParams = bootstrap.BootstrapParameters(\n", - " shared_args=shared_args, update_rule=lambda df: None\n", + " shared_args=shared_args, \n", + " update_rule=lambda df: None # No preprocessing needed\n", ")\n", + "\n", + "# Create iterator to process each restart count\n", "bs_iter_class = bootstrap.BSParams_range_iter()\n", "bsParams_iter = bs_iter_class(bsParams, boots_range)\n", + "\n", + "# Load and process bootstrap data from checkpoints\n", + "# Results stored in sb.boots_results (accessible after this call)\n", "sb.run_Bootstrap(bsParams_iter)" ] }, @@ -115,12 +178,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Interpolation\n", - "The data from each instance might be available at different values of resource. Using interpolation, obtain estimates for the performance and parameters at the same grid of resource values for each instance. \n", + "## Interpolation: Creating a Common Resource Grid\n", + "\n", + "Different experimental runs may have data at different resource levels, making direct comparison difficult. Interpolation creates estimates at a common grid of resource values across all instances.\n", + "\n", + "### Why Interpolation?\n", + "- **Alignment**: Ensures all instances have performance estimates at the same resource levels\n", + "- **Comparison**: Enables fair comparison across instances with different sampling patterns\n", + "- **Visualization**: Makes plotting and analysis more straightforward\n", + "\n", + "### Defining \"Resource\"\n", + "For QAOA, we measure computational resources as the **total number of quantum circuit evaluations**:\n", + "\n", + "$$\\text{Resource} = \\text{boots} \\times \\text{iterations} \\times \\text{shots}$$\n", "\n", - "To that end, it is necessary to define a notion of the amount of resources used for each run. In the iterative QAOA, a reasonable measure of the amount of resources used is the number of times the quantum hardware was accessed. That is, we define the amount of resources to be equal to the product of the number of shots, the number of restarts (called `boots` in the bootstrap `pkl` data), and the number of minimizer iterations, COBYLA for this demo. The resource calculation should be specified as a function (`resource_fun` in the cell below), which will then be passed to the interpolation method. Other ways of defining the resource are also valid (for example, in terms of the amount of QPU time), but we use the function below for this demo.\n", + "Where:\n", + "- `boots`: Number of algorithm restarts (bootstrap samples)\n", + "- `iterations`: Number of classical optimizer (COBYLA) iterations\n", + "- `shots`: Number of quantum circuit measurements per iteration\n", "\n", - "The results of the interpolation for all instances are stored in a single file- `checkpoints/interpolated_results.pkl`, and are loaded into memory in the form of a dataframe that can be accessed using `sb.interp_results`." + "**Alternative resource definitions** could include:\n", + "- Wall-clock time\n", + "- QPU time (quantum processing unit time)\n", + "- Total number of gates executed\n", + "\n", + "### Output\n", + "Results are saved to `checkpoints/interpolated_results.pkl` and accessible via `sb.interp_results`." ] }, { @@ -128,30 +211,69 @@ "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Interpolating results across resource budgets...\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 540/540 [00:00<00:00, 739.27it/s] \n", - "100%|██████████| 540/540 [00:00<00:00, 964.50it/s] \n", - "100%|██████████| 540/540 [00:00<00:00, 1003.41it/s]\n", - "100%|██████████| 540/540 [00:00<00:00, 784.09it/s]\n", - "100%|██████████| 540/540 [00:00<00:00, 884.73it/s]\n", - "100%|██████████| 540/540 [00:00<00:00, 848.63it/s]\n", - "100%|██████████| 540/540 [00:00<00:00, 900.88it/s]\n", - "100%|██████████| 540/540 [00:00<00:00, 825.56it/s] \n", - "100%|██████████| 540/540 [00:00<00:00, 915.13it/s] \n", - "100%|██████████| 540/540 [00:00<00:00, 816.02it/s]\n" + "100%|██████████| 540/540 [00:00<00:00, 865.22it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 865.22it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 927.03it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 927.03it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 846.27it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 846.27it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 932.43it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 932.43it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 819.74it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 819.74it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 943.66it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 943.66it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 787.41it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 787.41it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 856.20it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 856.20it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 853.96it/s] \n", + "100%|██████████| 540/540 [00:00<00:00, 853.96it/s]\n", + "100%|██████████| 540/540 [00:00<00:00, 846.97it/s] \n", + "\n" ] } ], "source": [ - "# Interpolate\n", + "# ============================================================\n", + "# Define Resource Metric\n", + "# ============================================================\n", "def resource_fcn(df):\n", + " \"\"\"\n", + " Calculate total quantum circuit evaluations as the resource metric.\n", + " \n", + " Resource = (restarts) × (optimizer iterations) × (measurements per iteration)\n", + " \n", + " This represents the total number of times we queried the quantum hardware.\n", + " \"\"\"\n", " return df[\"boots\"] * df[\"iterations\"] * df[\"shots\"]\n", "\n", "\n", - "iParams = interpolate.InterpolationParameters(resource_fcn, parameters=parameter_names)\n", + "# ============================================================\n", + "# Configure and Run Interpolation\n", + "# ============================================================\n", + "# Create interpolation parameters\n", + "# - resource_fcn: Function defining what \"resource\" means for this problem\n", + "# - parameters: Which algorithm parameters to interpolate alongside performance\n", + "iParams = interpolate.InterpolationParameters(\n", + " resource_fcn, \n", + " parameters=parameter_names # interpolate iterations, shots, rounds\n", + ")\n", + "\n", + "# Execute interpolation across all instances\n", + "# Creates a common resource grid for fair comparison\n", + "# Results: sb.interp_results DataFrame with aligned resource levels\n", "sb.run_Interpolate(iParams)" ] }, @@ -159,11 +281,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Split the data into test and train instances\n", - "If `train_test_split=0.8`, $80\\%$ of the instances will be labeled as train instances, while the remaining will form the test data.\n", - "The `run_Stats` method will implement this splitting, adding a column called `train` to `sb.interp_results`. The updated dataframe is also stored in `checkpoints/interpolated_results.pkl`.\n", + "## Train/Test Split and Statistical Aggregation\n", + "\n", + "To evaluate parameter recommendation strategies, we split instances into **training** (for learning parameter strategies) and **testing** (for evaluating recommendations) sets.\n", "\n", - "In addition, `run_Stats` computes various statistics for the test and train sets separately and stores the data in the form of dataframes, in `checkpoints/testng_stats.pkl` and `checkpoints/training_stats.pkl` respectively. They are also stored in memory and can be accessed as `sb.testing_stats` and `sb.training_stats`. The statistic of interest can be specified by instantiating `stats.StatsParameters` appropriately. For this demo, we prefer to compute the median, $75\\%$ quantile and the $25\\%$ quantile for the response (the approximation ratio). One may instead choose to compute the mean and the $68\\%$ confidence interval (assuming a gaussian distribution)." + "### What This Step Does:\n", + "\n", + "1. **Splits instances** into train (80%) and test (20%) sets\n", + "2. **Computes aggregate statistics** separately for each set\n", + "3. **Saves results** to checkpoint files for later analysis\n", + "\n", + "### Train vs. Test Sets:\n", + "- **Training set** (80%): Used to learn which parameters work well across instances\n", + "- **Testing set** (20%): Used to evaluate how well recommendations generalize to new instances\n", + "\n", + "### Statistical Measures:\n", + "By default, we compute the **median** across instances, which is robust to outliers. Alternative options include:\n", + "- `stats.Mean()`: Average performance (sensitive to outliers)\n", + "- `stats.Quantile(q)`: Custom quantile (e.g., 25th, 75th percentile)\n", + "- Multiple measures can be combined: `[stats.Mean(), stats.Median()]`\n", + "\n", + "### Output Files:\n", + "- `checkpoints/interpolated_results.pkl`: Updated with `train` column\n", + "- `checkpoints/testing_stats.pkl`: Statistics for test set → `sb.testing_stats`\n", + "- `checkpoints/training_stats.pkl`: Statistics for training set → `sb.training_stats`" ] }, { @@ -171,37 +312,120 @@ "execution_count": 6, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing training/testing statistics...\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 20895/20895 [00:10<00:00, 1981.03it/s]\n", - "100%|██████████| 20895/20895 [00:01<00:00, 10567.55it/s]\n" + "100%|██████████| 20895/20895 [00:11<00:00, 1839.29it/s]\n", + " 0%| | 0/20895 [00:00" ] @@ -274,8 +684,62 @@ } ], "source": [ + "# ============================================================\n", + "# Generate Performance Comparison Plot\n", + "# ============================================================\n", + "# Creates a single plot comparing all experiments' performance vs. resources\n", + "# - Black curve: Virtual Best baseline (oracle upper bound)\n", + "# - Colored curves: Each projection experiment\n", + "# - Shaded regions: Confidence intervals (default 68%)\n", + "# - Log scale x-axis for resource levels\n", "fig, axs = sb.plots.plot_performance()\n", - "fig.savefig(\"performance.png\")" + "\n", + "# Optionally save the figure to a file\n", + "# fig.savefig(\"performance.png\") # Uncomment to save plot as PNG\n", + "# fig.savefig(\"performance.pdf\") # Uncomment to save plot as PDF\n", + "\n", + "# The plot displays in the notebook automatically\n", + "# Data is cached to: checkpoints/performance_plotting/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Individual Parameter Plots (Separate)\n", + "\n", + "These plots show how each **algorithm parameter** evolves with increasing computational resources, displayed on separate subplots for clarity.\n", + "\n", + "### What These Plots Show:\n", + "\n", + "**One plot per parameter**:\n", + "- **iterations**: Number of COBYLA optimizer iterations\n", + "- **shots**: Number of quantum circuit measurements per iteration \n", + "- **rounds**: Number of QAOA layers (p parameter)\n", + "\n", + "**For each parameter plot**:\n", + "- **Y-axis**: Parameter value (recommended or optimal)\n", + "- **X-axis**: Computational resources (log scale) — total quantum circuit evaluations\n", + "\n", + "**Curves displayed**:\n", + "- **Virtual Best (black)**: Optimal parameter values from oracle (per-instance best)\n", + "- **Projection experiments (colored)**: Recommended parameter values from each strategy\n", + "\n", + "### Visual Elements:\n", + "\n", + "- **Lines with color gradients**: Parameter values colored by performance (approximation ratio)\n", + " - **Darker colors**: Better performance at that resource level\n", + " - **Lighter colors**: Worse performance\n", + "- **Separate subplots**: Each parameter gets its own plot for easy comparison\n", + "\n", + "### Interpreting the Results:\n", + "\n", + "**Recommendations close to Virtual Best** → Strategy learned good parameter values \n", + "**Divergence from baseline** → Strategy recommending suboptimal parameters \n", + "**Parameter trends** → How parameters should scale with resources (e.g., more shots at low resources) \n", + "**Color patterns** → Which parameter values lead to better performance\n", + "\n", + "This plot answers: *\"Are we recommending the right parameter values, and how should they change with resources?\"*" ] }, { @@ -287,19 +751,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 2409.18it/s]" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ + "100%|██████████| 100/100 [00:00<00:00, 2565.79it/s]\n", "\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -309,7 +767,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -319,7 +777,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -329,9 +787,71 @@ } ], "source": [ + "# ============================================================\n", + "# Generate Individual Parameter Plots\n", + "# ============================================================\n", + "# Creates separate plots for each parameter (iterations, shots, rounds)\n", + "# showing how recommended values evolve with resources\n", + "# - Black curves: Virtual Best optimal parameter values (per-instance)\n", + "# - Colored curves: Recommended parameter values from each experiment\n", + "# - Color gradient on curves: Represents performance (darker = better)\n", + "# - Returns dictionary: {parameter_name: figure}\n", "figs, axes = sb.plots.plot_parameters_separate()\n", - "for param, fig in figs.items():\n", - " fig.savefig(param + \".png\")" + "\n", + "# Optionally save each parameter plot to individual files\n", + "# for param, fig in figs.items():\n", + "# fig.savefig(param + \".png\") # Uncomment to save as PNG\n", + "# # fig.savefig(param + \".pdf\") # Or save as PDF\n", + "\n", + "# The plots display in the notebook automatically\n", + "# Data is cached to: checkpoints/params_plotting/" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Combined Parameter Plot (Together)\n", + "\n", + "This plot displays **all algorithm parameters together** on a single figure with subplots, making it easy to see how the entire parameter configuration evolves with resources.\n", + "\n", + "### What This Plot Shows:\n", + "\n", + "**Layout**: Multiple subplots on one figure, each showing a different parameter:\n", + "- **iterations**: COBYLA optimizer iterations\n", + "- **shots**: Quantum circuit measurements per iteration\n", + "- **rounds**: QAOA layers (p parameter)\n", + "\n", + "**For each subplot**:\n", + "- **Y-axis**: Parameter value (recommended or optimal)\n", + "- **X-axis**: Computational resources (log scale) — total quantum circuit evaluations\n", + "- **Shared x-axis**: All subplots aligned for easy comparison across parameters\n", + "\n", + "**Curves displayed**:\n", + "- **Virtual Best (black)**: Optimal parameter values from oracle\n", + "- **Projection experiments (colored)**: Recommended parameter values from each strategy\n", + "\n", + "### Visual Elements:\n", + "\n", + "- **Synchronized x-axes**: Same resource levels across all parameter subplots\n", + "- **Consistent color scheme**: Same color represents same experiment across all subplots\n", + "- **Compact layout**: All parameters visible at once for holistic view\n", + "\n", + "### Interpreting the Results:\n", + "\n", + "**Parameter coordination** → See how all parameters change together with resources \n", + "**Resource allocation** → Understand tradeoffs (e.g., more shots vs. more iterations) \n", + "**Strategy comparison** → Quickly compare how different strategies recommend different parameter combinations \n", + "**Scaling patterns** → Identify which parameters scale linearly vs. remain constant\n", + "\n", + "### Use Case:\n", + "\n", + "This plot is ideal for:\n", + "- **Publications and presentations**: Compact visualization of complete parameter recommendations\n", + "- **Strategy comparison**: Quickly assess which strategy makes sensible parameter recommendations\n", + "- **Resource budgeting**: Understand how to allocate computational budget across parameters\n", + "\n", + "This plot answers: *\"How should I configure all parameters together as my computational budget changes?\"*" ] }, { @@ -350,12 +870,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:00<00:00, 2370.73it/s]\n" + "100%|██████████| 100/100 [00:00<00:00, 2423.84it/s]\n", + "\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkcAAAIMCAYAAAD/3AhYAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAA9LxJREFUeJzsvXl8VOX1+P++M5OZZLIvZAWSECAhhIQ1EJaIbAEEWawitQWp1daKVbGL7Uel2lbU9mfRfqh+a3H7VAVBQERFkC0SgmGHEBK2QEL2fZkss93fH5NMMiSQfSPPm9d9MeeeZ7s3M3fOnOc855FkWZYRCAQCgUAgEACg6OkBCAQCgUAgEPQmhHEkEAgEAoFA0AhhHAkEAoFAIBA0QtXTA+hKzGYz2dnZODs7I0lSTw9HIBAIBP0YWZapqKjA398fhaLrfRM1NTXo9fpOaUutVmNvb98pbfUF7mjjKDs7m0GDBvX0MAQCgUAgsJKZmcnAgQO7tI+amhq8vQKo0BV3Snu+vr6kp6f3GwOp1xhHb7/9Nm+//TbXrl0DYOTIkbz44ovMmzcPsPyhn332WTZt2kRtbS1xcXH861//wsfH55ZtOjs7A5Y3oouLS5dfg6B/kZSfzrGCawB4qJ0pqK606jztnSio0lllD40j+brqBr3GkfyqxrKWvMpGsr0juRUNspe9I9nlNVbZx1FLdrlF7+vkQE55Q1lfJ0eyyxrJzlob2cfJgezShrb8XR3ILq2yygGuDuSUVjfS25NdUm1TPreuvL+rAzklDXX93LTkNpZdHcgtbqjr5+5ATuO23O3JuZ3ezYHcYkt7vh43t2VPXqFt3dyiRn17OJDXqPz0cQHMmCB+LAl6jvLycgYNGmT9bupK9Ho9Fbpifv/kf9FotB1qq7a2itf++RP0er0wjrqbgQMH8uqrrzJs2DBkWebDDz9k0aJFnDp1ipEjR/LMM8/w1VdfsWXLFlxdXVm9ejVLly4lISHhlm3WT6W5uLgI40jQ6ThWO2Nf7QiAg9oRe2VDVgwHe0fsG3nNHTRO2EuKW8v2jmjkxrITGnODbG/vhMaobJAdHa2yvaNDE53a0FjW3iQ7oNY3fPTttQ6o9QpbubZRea096hrlTXpFw+uaxnW1N8kOaKpt9Zo26bVoqqVGr2+q63BT2SrpJrlB7+jobPMcSM8qI9DPBYVCTLkLupfuDPNQOzii0Th2qA25H35Geo1xtHDhQhv5r3/9K2+//TZHjx5l4MCBbNy4kU8++YQZM2YA8P777zNixAiOHj3KpEmTemLIgn5Cub4aZzt7mwdaYWEhN9KvUakvA8BYU0qVnQJHd1d0JWWY9CVUqZRW2agvQadU4ejmiq60DHNtCTqlEkc3N3SlpZgNxVShROvmRlVpKQWGYqokFVpXN65cK+VkWQlOWiVBg93xuriXEN15DI4RAAzVJWPURpA/ZA7eV/cwrCoZo8MocoPi8L32LaFV5zDZjyInaC5+13YzouYcsnoUWYPnEZDxDSP0dfKguQRk7ibsyjnM6lHkBMzFL2s3YVfPYVKPIsc/Dr/sbwm7dg6z3SgAhl8/h0kVQa7fHHxz9jA8MxmzKoJc3zn45u5hWGYyJuVI8n3m4J23h6HZ5zE2kkOykzEqI8j3no13/l5CcpqRFSM5phhPckERTgoFQZ7uXCsqIbmgEGcUBHu4k15cwrmiIovs7oZn8T4Ci86jZyTFHjPxKN6HYX8qR/JnEByznG83v4tLYRIXht/N/B8/yt6UPBKvFBET4snscB8bGbilrrPkhMuFRAe6MzPMm32p+fyQXszEYA8A6+ubdV0t95e+W9NX0vUSpgz1Ynb4rWcqeiuyJCF30BjraP2+iNQbk0CaTCa2bNnCypUrOXXqFLm5ucycOZOSkhLc3Nys5QIDA3n66ad55plnmm2nvLwcV1fXJtNqGo0GjUbT1ZchuAMwmc38J/UQaqWSgY4eDHbyxL7azImT5zldWMDlvMsggbOzD7UmHd4BnuRnFaFWOFJr1OEd4EV+ViFqhRPVBh0DAgZQkFWAWulEjaEKLz8vCnMK0Si1VNVW4ek3gKKcAjQqJ3S1VdQ4+HE+VwvIgMRTqs95RvU5sgz1z6v610VmJzwVld0md0ffJllCKcn8XP8s35nHAhIqTBhRWu/JzfJ8xVH+pX7rlm0Xm53wUFRiliUUksyv+R07a0Zb/+ZuDipKq43Nvh9u1nW2rAFqb/FevFnX1XJ/6bstfb27YnyHDKT676SysrIun82o7+v53+/AvoOeo5paHX95bXG3jLu30Gs8RwDnzp0jJiaGmpoanJyc2L59O+Hh4Zw+fRq1Wm1jGAH4+PiQm5vbYrs3B2WvXbuWGTNmMGbMGHbt2mWjmzZtGrm5uYSHh3P48GGKiops2gkLCyMvLw87OztOnDhhU/eBBx4gISGBmJgYtm7daqOLjo6mqqqKgIAAkpOTycrKsuq8vb2Jjo7m0qVLeHl5NZkqXLRoEcePHyc2NpbNmzdjNputusjISOzs7HB2diYjI4OrV69adS4uLsyZM4djx44REhLC/v37bdqNi4sjOTmZ2NhYduzYQXV1Q3xGaGgoXl5emM1mysrKSElJseo0Gg1Lly4lPj6eqKgovv76a5t2p0+fTkZGBlFRURw8eJCSkhKrLjAwkJCQEOu5U6dO2dRdvnw58fHxREdHs337dhtdTEwMZWVlBAUFcfLkSZu/va+vL2PHjuXatWu4urqSmJhoU3fJkiUkJSURGxvLp59+aqMbM2YMAO7u7ly5coXr169bdUpPZ/R+akrKSiitquTwxbMUZ+WSn6HDY+hwSsuqMZllQieM5PiRQ1RVXKTKpMUvaBDlWeVwIwudXo3rkEFknjuFriKNarMDA0OC0edmkZ2ejknpgsrNk6L8QnQVadSY7Rk5bgy5p46TYw1jkrhHcZRfK7dZpEY/5Opfeyoqu1Xujr6UkoxZlpikSOE78ziAOkPIck9ulh2o4Y+qT27btkedrJBkzDKMMZ1hJ6Ot13Qrw6g5XWfLt/rSbk7X1XJ/6bu1ZSUJ9idn4lhq+4xwd3dn+vTpnDlzhsGDB3Pw4EGbNubPn8+ZM2eIjY1l586dt+m9a5AlkDu4ME7uf46j3uU50uv1ZGRkUFZWxtatW/nPf/7DoUOHOH36NKtWraK21vatGx0dzd13381rr73WbHvCcyToKIl5lzlZeM3mXGVJGVeS0ymplaksL0CSFGidvFApDAwe7NepnqPL+sGUVdvxE+UeXlZ9iEKyfFzrPSqNX3/FZO7hSKvlXebJLFDcWv7KPJl7GsumydyjPNJ83zfpOkuuZ78pikcMv0FGibfCQL7ZjnpPkbekJ19W40oF76v/xljFZZux7ayN5l5NklX+xjSFecoEqycpnYHcW/MndJIWswz3Rvqx82wOCgnMdU/H+tc369oqh9kpSTWYkOpGv2i0P1+czrbKQyWJy7JslYFb6rpa7i99t6Wvvug5+sMfv8DevoOeoxod615ZJDxHPYVarWbo0KEAjBs3jmPHjvHmm2+ybNky9Ho9paWlNt6jvLw8fH19W2xXBGQL2ktmZVGTc05uzvzY8TyeValk+AYA4F9+kFzHQKrslXg6nMW/IpNsp8EUOkTipT2LX2UmWU6DKXCIZIDTWTyqiznjM56MwLFoXV1wMJipqIs5mlXzAyPKz3HdJZAd+RUssjvAPOUxABIGLOCwPpShuhTS6mKOhuuSSauLOTp9dQ+hVcmk1sUcnbr2LWFV57hQF3N0si7mKKUu5uhkxjeE65NJUUeQNWguJzN3E6636HMC5nIiq062s8Qcncj+lnD9OS7UxRyNMJwjtS7m6FTOHsKMyaTVxRydzt1DqCGZNOVI8gPmcDpvD6Gm8zZyWL3sP5sz+Xsb9HXyfOPXRJLCDOUZ4pW/5YgihnLXMbiUnWKgOYMsaTDlzqNxrThJnPwdLuiokpzYZJyPvamEc7XDuSxNIVGfQKTmIhnqUZR4zuSCLoExtfuJ4STB0g32av5AhjKIbIIpuz6CGdoL+HGNXHkwAL5kkCcPpuJyGLPsU/GVMsg1D6byciizNGn4KjLINQ1CdzGUWeo0nJQlXDCOpzRNwxyVigIlSDk6BlQbWeJ5kAjHVIoVQQyUp/KL8PNUXT/NjSo/9KoI1MZkfOyyyDNY3lv1r2/WdbXcX/puTV8DtTmYw+8lOvyeLnrSCHobvcpzdDMzZsxg8ODBvPnmmwwYMIBPP/2U++67D4C0tDTCwsJITEy8ZUB2d1rpgjuPaqOe99Lim5yfkfRPRlw/2KG2LT4P2Dz6eS56T8TL3pGciiqWpLzBmLz9t6z33tC1nHefjK+TI1l1y/P9nB1slur7OTtyo/FSfBetjezn7MCNkoal/ANdHbjRaCn/IFcHshotpx/oZs+N4sayA9l1y/UHujmQVdwoDYC7luzGspsDOY2W1/t73KT3cCD7dnp3LePS1zOj6vNb3pOb2a79JbtqZlNTbUBvaJiCdnfR4OHSsAy5pKwG14pUXtT+FSdFVXNNtZv6v+9n8nNcYgK11Xrycir56YAPmOpy6xW2gt5N+T3/D5cJD7a/fg94jp77n52d4jl69a/39qvv0l6zfcgf/vAH4uPjuXbtGufOneMPf/gDBw8e5KGHHsLV1ZVHHnmENWvWcODAAU6cOMGqVauIiYkRK9UEXUZmM8nT7GvLGZZx2CrLNLjmZcCgVNvI+ptlhdr6xQkw8fqOOqXMnMvv2RhGMlAlN9Q3oSCk4lyHr6uvocSMue6OyUAtGtt72kg2o8DTnIuriwalsuXH23VzEMeM46n/iWhpz/ZvZtuXulWy9e+LJcZk4CBX7vfebmMYyTLUmu0a+pah1qyykW+n62q5v/Td2rJmJMxXmv5Y6vUoJOQOHvTDpfy9xjjKz89nxYoVhIaGMnPmTI4dO8a3337L7NmzAfjHP/7BggULuO+++4iNjcXX15dt27b18KgFdzKZlU2No3EXPkclW4JoTSiQsHwR1r8+HrLQRj4x5F4kwCxZ5KTge+viFywPm6CSZO47/SrLDvyMqZkN7+f68huN8yz1UaDEzBXnyK685F7JZXUkCmTMdfc03nGJ9Z5IwCGHBlmBmSt2kSiVCvwG3PrXclVlKWVFWdRWl3FKnoAkNbSXoFps037j10ele2+SF9rIP7DQ5u8bKKWwyPhXFhf9nFnODQsXTLKEJMERwxwkqUGOr5puI99O19Vyf+m7VWVRoEBGERLbBe9wQW+k18Qcbdy48bZ6e3t7NmzYwIYNG7ppRIL+jCzLTeKNXCpzGXV5NwBvGH6Ei6TjqDkcgEmKFI6aw0m5PoVwfZBVXhr1cwxjFiNdT8AUOIUJofMwpC1GunYYqaoIZfIWwvMbvAnGCY8hB8ciXU/g9VRv3skLJXLSDKaoUjEGTuXHw+fVj7BhCUnjtfXdLcuN/SR14+p0eST6i8NRZBzGOHgq04bPQ39xYZ08pU5egCIjAePgKSyvu0cGo5k3Pz5FeaVlb6n6VqsqS8nKuoLOKKEwGLjgEsK60uWMcbzB6fKBXHOYyg/VSkY73+BEoQdICsZ5FJJc5s81uykkGZSMcsniXFkA1+0mk2RQMco1i3Nl/mQqJ/ODSUmkaxb2+gpiXc4SYXfSejUHdVM4lO1FlEcOV/VBFDnHccM8BN/aU5wvG0aJ52zyqsIY5pDGpapQAOvrTPu7bHRdLfeXvlvT13i/6/hPXdChKbWewqywHB1to7/Rq2OOOoqIORK0l+KaSj69ctTm3OyjbzA8M4GjikgerHquxTYkCX42JZgXFoTfutCH90L6oboKCpj4OMx9BYPJzKg/fUuNwcx3a+5iqLdTRy6n33LyQj6ffXvR5lxFaTbOLib8hoxi396DOJoM6JR2hI0cy8WzJ9Ga9VQp1ISOGsPJ+N1IShVjJ83k8tmTaE16qpRqhkWM4dK5kzia9OiUaoaPGsulsydwMuqpVKkJHTWOi2dP8OKADxjpkG7xTMkSe8sm8G7xfDx9QynNT2OgkzueHgGUFVdRVlKDQgG+fi4EDHYjP7cCAG9fZ+vr7pb7S98tlZ16dwjTZobQUXoi5ui3L+1C08GYo9oaHX9bu6BffZf2Q3tQIGiZjJvijQYUX2Z4ZgIyEn+n6a/H+in5OY2W+coyTBriefuOJv7S8r+kBNkMQVMBSMutoMZgxtlexRCvjj3Y+jOjQwfgWze9JkkwKdKX3/5sKtGhnmRfPoed2Yizmzd2ZiO515JRmY24uHmjMhvJTT+Po50dWqWS3GvnsTMZcHEZgJ3JQN6186hNRlxcBqA2WeramS2yndlIzvVk7ExGEg0zrdM0CkkmQ4pEgwknbT6OShl7e1ujV2Nvh8pOPJYFgp6m10yrCQS9CZspNVlmxjHLdG6GRzjHs4MAiBquYIi/Ahe1A6oqLyYNsWwHse7rC/y/+KsEeTm2nBMlbD48+ClcO2wxjMLmA3AqowSA0YPcxN5fHUChkJg/NYgfzuUyd0ogA9wtG3A6adVUVJ2nptoJrZMbDo4uuGpMVGgVaB3dcNC64GpvpNLB21Le3kSVxhtHR1e0WhectCZ09o1kRxNV6sayGZ2dN/na0XxU40CofSppNWHku0wnUFVGxFA3IpfG8s0X1zAYTJY+nNR4ejnazioKBB3ELCkwSx0zuDtavy8ijCOB4CZMZjPZulKrPDZ1G17lGchAYPF5ZilOkOw+njkT7Sx6L39ifIZayz8wYRD/L/4quXXZs5UtGTdh861GUT2nMi39jxns3hmX1K8ZHujO8EDb++jl5UXAwCBSb2QAoHVyY4CHFlO+ziI7ujHAywFzniWbtrenIwWy5bWjoyveAxzJz28keztSYG4sO5FfJ2dqplPrfQ/5eZa2HbWuDAwIIiJyCFqtK5/99xQz5w4ndtZQ6/59zW3RUk93h5T1h75bKtualY+9lvpVBR1to58hjCOB4CZyqksxyiarHHLDEnskYVm1MkmRQqVftFU/yMnDpn6QpyP2dgpqDGauF+kYMqDt8UKnM0oBGDPYrc11BX2HIUM9+fmvJuE5wJHu3KldIBDcnj5sDgsEXcO5okxMjfavs9eXA5Y8J0rMHDWHE+Rv+eioJCV+Dm429ZUKiVAfZwAu5FTQVkp0eq4WWrwMowe63b6woM/j5e0kDCNBl2FWSp1y9DeE50ggaIQsyxTVlCNjQiEpcKopxaWqEDOwxy6arbqpHJLG8qSX5WHh7+iGUtH0N8YIPxfO3CgjNbeceyL92jSG0zdKARji5Yi7o7qjlyS4BdOjBzF1XIDNOanR2t2unOLp09M0gj6FLEnIHTS+O1q/LyKMI4GgEbnVpeiMtdgrLfFEAbmnAci0C+D9gN/zQ2oNAz30KJWWbSgGOTW/Gi3Mt95zVN7mMZyqm1IbPcitzXUFrUelVKASRopAIGgGYRwJBI24WJZrIw/MOwPABXUQF9OLAS3jgp2IcA+g3FDD4FsYRyP8LLlA2jOtVr9STcQbCQSCjmLdAqSDbfQ3xM8mgaAOo9nE1fK8hhOyzMC8swAUD5tCmd4BAJ+BMqmlWSgk8NA0n4MozNdiHGWVVlNWbWj1GMxmmePXLDmW9EZzC6UFAoHg9pgBs9TBo6cvogcQxpFAUEdGZSF6k9Eqe5RdR1tTikFlzzmH0ZhlCRdH8HCx/IrydXC9ZVuuWjsC3CzGVFpu671H/3f0OtV1O8n/+asL7E3Ja6GGQCAQCDobYRwJBHU0mVLLtUypZQ8I50qeEoBgP4V1ZdEwV9/btteeuKPtp7Ksr5WSxNGrRbcpLRAIBLenflqto0d/QxhHAgFQbdSTWVloc64+3uiGTxTp2RZvTnDdEn4frSsuau1t26yPO0rNbZ1xJMsyWaVVgGU7EpMst7z9iEAgENwGs0LqlKO/IQKyBQLganke5kZ7MCuNtfgVpACQ5hpFQalFZ6rLDTncteXl+WF+Fs9RSiuDsk9mlFBQoUetUrB8wiCmDhvQ8vYjAoFAIOh0hHEkENB0Ss23MBWV2UCFvSf/e2SA9fyXCUbs1QoeDm3ZaKn3HF3MrWjVNiLbTlqm1BaM8uOlRRFtvQSBQCBoitg+pF10ybRaeXk5O3bs4MKFC13RvEDQqWTpism4aUptUN5pAA4YIiiuaHgySBKUFKvR1OVBuh3124hUG0xcL9Ldtmyt0cSuszkALB07sI1XIBAIBM0jptXaR6cYRw888AD/+7//C0B1dTXjx4/ngQceIDIyks8//7wzuhAIuoyUkkxk2USloRq92bJazf/KEQByapywr0tSLUmWTMfTh90+ELuextuIpLawYu1AagFl1QZ8XDTEhIg4I4FAIOhJOsU4io+PZ9q0aQBs374dWZYpLS3lrbfe4i9/+UtndCEQdAlFNeVkVhbgorbHTW2PnQSa779mgLEQWYZf2H3F4wN/4Ed3qxgfpuTBmfYsHzus1e3X5ztqacXa9lM3AFg8OqDF6TeBQCBoLfXbh3T06G90inFUVlaGh4dlZ/Ldu3dz3333odVqueeee7h06VJndCEQdDqyLJOU3/D+lCQJtVLF5Jw9dTIYZQWBxRcYNkjJrAkq7okIaHYvtVsxwq/lDWhLq/TsT80HYMnYgFuWEwgEgrYiKzu++aysbLmfDRs2EBQUhL29PRMnTiQpKem25devX09oaCgODg4MGjSIZ555hpqaGqv+T3/6E5Ik2RxhYWEdvR2tplMCsgcNGkRiYiIeHh7s3r2bTZs2AVBSUoK9vX1ndCEQNItZNmOWW5e/VSEpUEgNhk2WroicqhLb9m5kEiLfAAlMsoRKMmMOjGaqXyhXy/NbzG10M2F+LXuOdp3NwWCSGeHnYvU0CQQCQV9h8+bNrFmzhnfeeYeJEyeyfv164uLiSEtLw9vbu0n5Tz75hOeee4733nuPyZMnc/HiRR5++GEkSeKNN96wlhs5ciTfffedVVapum8NWaf09PTTT/PQQw/h5OREYGAg06dPByzTbaNGjeqMLgSCZsmoSOdaRToADkpHygwNgc8OKkdK9Q3ycNdgQt1CADDLMscKLjdpL+zYxyglmWRpCJftQ8j3CUc1ZgxnCtOJ8QnFV+vWpvGNaLSNyG8+O02YnwsX8yq4VlRFkKeW4T7OvHfYMv4If2EYCQSCzkWWLEdH27gdb7zxBo8++iirVq0C4J133uGrr77ivffe47nnnmtS/siRI0yZMoUf//jHAAQFBbF8+XJ++OEHm3IqlQpf37b9IO0sOsU4+tWvfkV0dDSZmZnMnj0bRd20w5AhQ0TMkaBXcqU8h5LaSptzcloKU2uPYZIljk59EsXAwdYPSI1Jj0rRCt/yTSTV7ZMGsPVkFtCQATspvdim7JYTN5gz0lfkNhIIBJ1GezJcmwx6TEa9VdbXVt2yrF6v58SJE/zhD3+wnlMoFMyaNYvExMRm60yePJn//ve/JCUlER0dzdWrV/n666/56U9/alPu0qVL+Pv7Y29vT0xMDOvWrWPw4MFtupb20mk+qvHjxzN+/Hibc/fcc09nNS/o5+gM5agUKjTK22elbi15VWU2smw2E33mIwD2Od2NYqDtB9BP685Ax7avIku8UoRCArNsSRXi4qCivNqITFO5frsQYRwJBIKe5MSuDzj+xX9aVbawsBCTyYSPj+1zy8fHh9TU1Gbr/PjHP6awsJCpU6ciyzJGo5Ff/vKX/PGPf7SWmThxIh988AGhoaHk5OTw0ksvMW3aNJKTk3F2dm7/xbWSTjGOTCYTH3zwAfv27SM/Px+z2TYGZP/+/Z3RjaCfIssy6RXJ1Bh1eDsMwt9xCCqFmvJjm1Be+BIHn2AAPLIvYPAbQdXI6ZQVl1GkK8HsoMDFw5Xy4jKuF13Dc7AregdwtrNjuKsP6RUFGMxm3L/5gFHmS9TKKjKmPNhkpcL4AcOse6q1hZgQT95LSEcpSZhkmZ9MCmLDgcu3lMV2IQKBoDMxSxLmNj67xixcReS8h6yyvlrHf59Z0GljOnjwIK+88gr/+te/mDhxIpcvX+app57iz3/+My+88AIA8+bNs5aPjIxk4sSJBAYG8tlnn/HII4902lhuRacYR0899RQffPAB99xzDxEREe36Elm3bh3btm0jNTUVBwcHJk+ezGuvvUZoaKi1TE1NDc8++yybNm2itraWuLg4/vWvfzWxWAV3FkW1OVQZLau9cquvU1iThe+xffgnbcAZGHTVUk4Ghl3/jr2V1SRX+WE0OwI6Bg32JDOjCGc7HzKuFWMMgFqtpbxWqcb9ZDJLK74CQCMZMaedRxETa+0/2MWHAQ7tiweaHe7DuyvGc/RqEZOGeDI73IfRg9xuKwsEAkGnoZAsRxtQajQoNRrbNm6Bl5cXSqWSvLw8m/N5eXm3jBd64YUX+OlPf8rPf/5zAEaNGoVOp+Oxxx7jf/7nf6yhOY1xc3Nj+PDhXL7cNFa0K+gU42jTpk189tlnzJ8/v91tHDp0iCeeeIIJEyZgNBr54x//yJw5c0hJScHR0RGAZ555hq+++ootW7bg6urK6tWrWbp0KQkJCZ1xGYJeiFk2kVVpmw7CaDbgfub/ANus9hJ1BtKVvez1+hlDI0dy4cwJcrJyKa5VoB3iwem0i7hqVAwYbPnQVpn0jL2ys6FtWYF3XgrFWIwjhaRgvNfQDl3D7HAfG6OnJVkgEAj6Cmq1mnHjxrFv3z4WL14MgNlsZt++faxevbrZOlVVVU0MIKXSEtMpN9rjsjGVlZVcuXKlSVxSV9EpxpFarWbo0I59gezevdtG/uCDD/D29ubEiRPExsZSVlbGxo0b+eSTT5gxYwYA77//PiNGjODo0aNMmjSpQ/0Leid51RnUmmtszrldO45DrWVpvBkJBZYPU30cT1D1deIqvuPLU2aMVKD0dIGqMjIvpGCnNOLg3GhpaXUNw83XQQJz3dL9XJ9Q9IZqNEo7ojyDcVY7dNPVCgQCQedilsDcwYyG5hYcT2vWrGHlypWMHz+e6Oho1q9fj06ns65eW7FiBQEBAaxbtw6AhQsX8sYbbzBmzBjrtNoLL7zAwoULrUbSb37zGxYuXEhgYCDZ2dmsXbsWpVLJ8uXLO3YxraRTjKNnn32WN998k//93/9t15Rac5SVWQJm65NLnjhxAoPBwKxZs6xlwsLCGDx4MImJicI4ugMxmg3k6NJtT5pNDEr8GIDcgeMoVjiQ72vJWO2VfQlnuZbArGPMLP2eCP0ljg6bS17wCJzcnDFXmTDba1C7OlqbCzj6HS5SNXmyGz84jKPQLwLnKbEYzWYq9LWEuw/qtusVCASCTkeSLEdH27gNy5Yto6CggBdffJHc3FxGjx7N7t27rSEvGRkZNp6i559/HkmSeP7558nKymLAgAEsXLiQv/71r9YyN27cYPny5RQVFTFgwACmTp3K0aNHGTBgQJP+u4JOMY4OHz7MgQMH+Oabbxg5ciR2drabcm7btq1N7ZnNZp5++mmmTJlCRIRld/Lc3FzUajVubm42ZX18fMjNzW2mlQbKy20T8Gk0GjSN51MFvZLsqqsYZYPNuQEX9uNQmo3B3pmsuCcpUyioNNQCUBk+DZXCCUXCvxmU9h0+VbksOvMBexztuTZoHHaeGsr0DctTKS1jftE3IMG3oStRRsdS/65QKRREeQXhou6c1XECgUBwJ7N69epbTqMdPHjQRlapVKxdu5a1a9fesr36ZNI9RacYR25ubixZsqQzmgLgiSeeIDk5mcOHD3dKe4MG2f76X7t2LTNmzGDMmDHs2rXLRjdt2jRyc3MJDw/n8OHDFBUV2bQTFhZGXl4ednZ2nDhxwqbuAw88QEJCAjExMWzdutVGFx0dTVVVFQEBASQnJ5OV1ZDvxtvbm+joaC5duoSXl1eTGKpFixZx/PhxYmNj2bx5s81qwMjISOzs7HB2diYjI4OrV69adS4uLsyZM4djx44REhLSZNVgXFwcycnJxMbGsmPHDqqrq6260NBQvLy8MJvNlJWVkZKSYtVpNBqWLl1KfHw8UVFRfP311zbtTp8+nYyMDKKiojh48CAlJQ1ZqAMDAwkJCbGeO3XqlE3d5cuXEx8fz5hxozhzKQmp0TvUTavG/4fNAFweeQ85pZUYlWBSSUiSAkc7R3S6avSSChkJqW66bdKpzWT6jKRCNoFShaHOQApP3IWjVEuyIoTiERG46vVUV9dQW5fCXp+cj84+i+nTp3PmzBkGDx7c5EM+f/58zpw5Q2xsLNu2baO2ttaqCw8Px9XVFYVCQWFhIWlpaVadg4MDixcvJj4+noiICL799lubdmfMmMGVK1eYMGECe/bssTHwhwwZwuDBg6moqMBgMHD27FmrTqFQsGzZMuLj4xk/fjxffPGFTbtTpkyhsLCQYcOGkZSURH5+vlUXEBBAREQEWVlZaLXaJun/f/SjH5GYmMiUKVP47LPPbHTjxo3DYDBYl+9mZmZadZ6enkydOpWUlBR8fX35/vvvbeouWLCAU6dOERsby5YtWzAajVZdREQEWq0WjUZDbm6uzXZETk5OzJ8/n8TERMLCwti7d69Nu7NnzyY1NZWYmBi+/vprKisb8loNGzYMX19famtrqaqqIjk52apTqVTcf//9lveheEb02mdEdHQ027dvt9HFxMRQVlZGUFAQJ0+etPnh7Ovry9ixY7l27Rqurq5NcvAsWbKEpKQkYmNj+fTTT210Y8aMAcDd3Z0rV65w/fp1q87d3b3Vz4idO3fS3SgUMgpF83E8bWmjvyHJt4p+6iFWr17NF198QXx8PMHBwdbz+/fvZ+bMmZSUlNh4jwIDA3n66ad55plnmrRVXl6Oq6srmZmZuLg0rDYSnqPeT2blWUprc1ApnNAZqjFjwmnz3wkvSqJS5cqFR97m2DUFp64bCfLVIyGRmedCsJ+J2YqTjPnuVZt4pAKNNyfsRnLdfxTVoyLxSDzET7L+D4UE/xr1e/TDh+Fp74aizn2sUahZGjzVZrsRgUAg6Aj130llZWU230ld2dcjHxxErXXqUFv6qko2Pjy9W8bdW+jUjUoKCgqsv45DQ0PbNDcoyzJPPvkk27dv5+DBgzaGEVh+mdrZ2bFv3z7uu+8+ANLS0sjIyCAmJua2bbu4uPSbP+idQLWxnFJ9NkhglCuwVym5tms/0UUWT4aTsYz/+3/H2FkzAcveyfX799XCKdjiNJ4o/bNMUqSQJ7vzlN02BtTmE1eTj3TxAHkXXfGhzLrUTVlr+TVca6rFQWVpK9DZRxhGAoFA0E/pFONIp9Px5JNP8tFHH1nduUqlkhUrVvDPf/4TrbbluI0nnniCTz75hC+++AJnZ2erO9TV1RUHBweLBfzII6xZswYPDw9cXFx48skniYmJEcHYdxi5VWk2soyJ0KtfWWWjrCDSlMpOJjRbv6BSz3eM4zvzOABCpUzuU35vjSn0oSE7tkmW8MtN4+qoSGpMeqtxNMS5Z/bzEQgEgs5ETKu1j075abxmzRoOHTrEl19+SWlpKaWlpXzxxRccOnSIZ599tlVtvP3225SVlTF9+nT8/Pysx+bNm61l/vGPf7BgwQLuu+8+YmNj8fX1bXOwt6B3U2EopNJYZHOuJD2LIfINwGLMqCQzRV5hgO0iivo8ZQtG+dnIad7RSJKlLsABdXRdWwqUkkyOryXRqNFswmQ24WynxUMjPI0CgaDvI0lypxz9jU7xHH3++eds3bqV6dOnW8/Nnz8fBwcHHnjgAd5+++0W22hN6JO9vT0bNmxgw4YNHRmuoJciy3ITrxGA5rtPUUoyFxRDyNAOoXbQCObNmoj3FQ1nM2DeiHCkun3J6rNML0rJ4+jVIkID7FC6afjkuITrjfNk+wxHN2oU55PG4F9wiewBwzBHRuGgVGOv1KCUlAQ7+3VaSgqBQCAQ9D06xTiqqqpqdgsPb29vqqpuvZuvQNCYUn02NaYKm3P5Z1OZWX0MkyyRN+9X+Ic0rDwcP1TPfaPH4qK2JHVsLuu0WTbzTWYOjI+hZnwM7rKMubCYcyY3TrlMRms2MVIn4eTZMPUbLKbUBALBHYLUCdNqkphWax8xMTGsXbuWmpqGTMbV1dW89NJLLQZLCwRg8RoV1Vy3PWc243vYkvDxiOt0PENsUzI4qtxxtrt90L9CUjDQ0WI0SYC3gweh6gDGeI3hkbiHGeI8DBeTBkXdR8Hb3g0nO5ERWyAQ3BlIis45+hud4jl68803iYuLY+DAgURFRQFw5swZ7O3tm+RvEQiao9Zcgp82hApDGYU115Axk/PJf4kzXqRWVqGcd3+TOr7a0FZNfwU5B2CvVDPIyQ+typ5Cu0KKs05y8exJAp2diR0+Fmd3VzIq89GqRIoHgUAg6O90inEUERHBpUuX+Pjjj0lNTQUsiboeeughHBzEr3BBy5TVXqTGVIRKcsDXwZ/jX25jbrFlhZpGMlJ49gLOs6day7uqfdGq3FrVtqvaCVd1Q54PLy8vYieOpbS0FDc3N7y8vAAY5hrQeRckEAgEvQCFBIoOBlQr+mEIZqflOdJqtTz66KOd1ZygH2E0V1NjsqxQM8rVGI3X8UlryKhrlBVoMi8AFuNIQsLHYXiH+vTy8rIaRQKBQHCnIinkDscM9ceYo3YbRzt37mTevHnY2dm1mBL93nvvbW83gn6AzphtI1dX1hBivA4SmOuW7tcOGo7JXItCUuNpH4hGKfY8EwgEAkHX0G7jaPHixeTm5uLt7c3ixYtvWU6SJEwmU3u7EdzhyLKMznDD5lzul18RJlVRgCtnnMdhDBpB5JzJ1JoNVBsrGWAffIvWBAKBQNAYkQSyfbTbOGq8sWHj1wJBWzCYyzGYGzYELc8vY0LWLpAgecxKhs1oyH5ur1TjoQ7CTmnfXFMCgUAguAlJ6vhqs/6Y9q1TFuh99NFHNruR16PX6/noo486owvBHUqlIctGLtv1OY5SLanKEIKnT2xS3kk9sLuGJhAIBIJ+SqcYR6tWraKsrKzJ+YqKClatWtUZXQjuQGTZjM6YhVz378rOPUwu/g6Awqk/RrppiYRS0mCvFEHUAoFA0FoUktwpR3+jU1arybLcbL6ZGzdu4Orq2hldCO5AakyFGEylGOVqMuPPM/PSB5ZMjYCpmczqjnYBYlsPgUAgaANitVr76JBxNGbMGCRJQpIkZs6ciUrV0JzJZCI9PZ25c+d2eJCCOxNd3ZSayWgm6PQu63mTLCGlp0DsOJvyjiqRh0ggEAgEXU+HjKP6VWqnT58mLi4OJ6eGRHtqtZqgoCDuu+++Dg1QcGcgy2ZqTelolIORJDvMspEqYx6GWgMVH/wf0WbLijWTLKGUZOTgcJv6dgpn1EqXnhi6QCAQ9FkUCsvR0Tb6Gx0yjtauXQtAUFAQy5Ytw95erCISNI/efIMqUyo1pivYq4ahlgZy+etThF/4N6EUo5dVHPKcAQYjpsARjLjJa+RkJwKxBQKBoK10RsyQiDlqJytXruyMZgR3KLJspNp4EQAzBqqMKRzZ9T4zLrxpLbPXI47rfkOoMmhxRsKnqAwPz4Z4Na3Kv9vHLRAIBIL+Sac4y0wmE3//+9+Jjo7G19cXDw8Pm0PQv6kxpWPGNtWD64X91tcmWUJRVYnB7EbUmJmYZD8qywxWvb3SC5VCeCUFAoGgrdQHZHf06G90inH00ksv8cYbb7Bs2TLKyspYs2YNS5cuRaFQ8Kc//akzuhD0UcxyLTWmqzbn9DUGAo3X6/SWGCP9wCAc7Wq4mnwRX60/Yf7z8XaIxlEVgJPdoJ4YukAgEPR56jNkd/Tob3TKtNrHH3/Mu+++yz333MOf/vQnli9fTkhICJGRkRw9epRf//rXndGNoA9SY7qMjNHm3MUvvyOWcspkLSecJ2AIGsqYuCiKiyrQ62SG+Iy1bgrroBrQE8MWCAQCQT+mU4yj3NxcRo0aBYCTk5M1IeSCBQt44YUXOqMLQR9Eb86nyngOheRIvZOysqyKUZe3A3A2fDkjFsZgMFlyGnl4OqP1HYyXvUj0KBAIBJ2CouPbh3TOHFPfolMueeDAgeTk5AAQEhLCnj17ADh27BgajaYzuhD0MYzmUnSGY8iyEZNcAVjcste378SdSq5L/oTeM/2mWhJ2Cu/uHqpAIBDcsSikzjn6G51iHC1ZsoR9+/YB8OSTT/LCCy8wbNgwVqxYwc9+9rPO6ELQhzCaC6kyHkchqbBTeKDADrNcwYkt3xKTbUn2mD1hGSo7pU09heSAonOcmQKBQCAQtJtO+SZ69dVXra+XLVtGYGAgR44cYdiwYSxcuLAzuhD0EUxyFVXGU8iYAZAkJSrJhRNf7Gf25Q+t24NUV1tWr6kVDqgV9igkB1zspqGQ7Hpq6AKBQHDHIUkyUgfzFHW0fl+kw8aRwWDgF7/4BS+88ALBwcEATJo0iUmTJnV4cIK+hSzLKCUtakUwteYr1vM1VbWEnv/cKptkCa5fBKbW7ZUmoVWFoVSIKViBQCDoTBQKGYWyg0kg++FqtQ5Pq9nZ2fH555+3XFBwRyPLMkZzCkZzJmpFEGqFZfl9RUklRRv+QgAFQMP2IHZDYlFKjgCoJBfUCrFvmkAgEAh6B50yrbZ48WJ27NjBM8880xnNCfogZooxUwpyKSZysZMGkbj1v4xO+5CBUiXlaDnuNx90ZUjBYUxeeC9qRSC15kyUklOdB0kgEAgEnYmYVmsfnWIcDRs2jJdffpmEhATGjRuHo6Ojjb61eY7i4+P529/+xokTJ8jJyWH79u3WzW3B4p1Yu3Yt7777LqWlpUyZMoW3336bYcOGdcZlCNqJLJsxma81OqPnyJf/ZsbFDdYYo2ODFjH+p0usJWpMF5FQY68M7NaxCgQCQX9CbDzbPjrFONq4cSNubm6cOHGCEydO2OgkSWq1caTT6YiKiuJnP/sZS5cubaJ//fXXeeutt/jwww8JDg7mhRdeIC4ujpSUFLHpbQ9ilvOQqbE5Z3/hoPW1SVYglRU0qWeUi7CT/YXXSCAQCAS9ik4xjtLT0zujGebNm8e8efOa1cmyzPr163n++edZtGgRAB999BE+Pj7s2LGDBx98sFPGIGgbsmzEKGfYnDObTATUWs5ZtgcxIwUNRZarkLAHSYFaMRh7ZZgwjAQCgaALEdNq7aNTnWV6vZ60tDSMRmPLhdtIeno6ubm5zJo1y3rO1dWViRMnkpiYeNu65eXlNkdtbe1tywtaj8l8HWSDzbkz3+wjgAKqZDWHnacTP/pZJt07HwkzMpVoFEHCMBIIBIJuQOyt1j46xXNUVVXFk08+yYcffgjAxYsXGTJkCE8++SQBAQE899xzHe4jNzcXAB8fH5vzPj4+Vt2tGDTIduPStWvXMmPGDMaMGcOuXbtsdNOmTSM3N5fw8HAOHz5MUVGRTTthYWHk5eVhZ2fXZArxgQceICEhgZiYGLZu3Wqji46OpqqqioCAAJKTk8nKyrLqvL29iY6O5tKlS3h5eZGQkGBTd9GiRRw/fpzY2Fg2b96M2Wy26iIjI7Gzs8PZ2ZmMjAyuXm3Y5NXFxYU5c+Zw7NgxQkJC2L9/v027cXFxJCcnExsby44dO6iurrbqQkND8fLywmw2U1ZWRkpKilWn0WhYunQpp0/tJyxCT0VlDdXVljHpawwEnvovAKeCfsSwe+ZhMBopyC9CUsiYTQ7UqtwoKUmzlDl1ymZMy5cvJz4+nujoaLZv326ji4mJoaysjKCgIE6ePGnzd/f19WXs2LFcu3YNV1fXJgbzkiVLSEpKIjY2lk8//dRGN2bMGADc3d25cuUK169ft+rc3d2ZPn06Z86cYfDgwRw8eNCm7vz58zlz5gyxsbFs27bNxvAODw/H1dUVhUJBYWEhaWlpVp2DgwOLFy8mPj6eiIgIvv32W5t2Z8yYwZUrV5gwYQJ79uyhvLzcqhsyZAiDBw+moqICg8HA2bNnrTqFQsGyZcuIj49n/PjxfPHFFzbtTpkyhcLCQoYNG0ZSUhL5+flWXUBAABEREWRlZaHVaklKSrKp+6Mf/YjExESmTJnCZ599ZqMbN24cBoMBHx8fUlNTyczMtOo8PT2ZOnUqKSkp+Pr68v3339vUXbBgAadOnSI2NpYtW7bY/LiKiIhAq9Wi0WjIzc3l0qVLVp2TkxPz588nMTGRsLAw9u7da9Pu7NmzSU1NJSYmhq+//prKykqrbtiwYfj6+lJbW0tVVRXJyclWnUql4v777yc+Pl48Izr4jIiPjycqKoqvv/7apt3p06eTkZFBVFQUBw8epKSkxKoLDAwkJCTEeu5Oekbs3LkTQd9AkmW5wybhU089RUJCAuvXr2fu3LmcPXuWIUOG8MUXX/CnP/2pyZu7VQOTJJuA7CNHjjBlyhSys7Px8/OzlnvggQeQJInNmzc3aaO8vBxXV1cyMzNxcXGxntdoNGJbk44ilyKbLmOiEhM1gBokDSc+2czkKx+SjwfqNe/i4OjQqJICtWIskiTuvUAg6H/UfyeVlZXZfCd1ZV9/SdiBvZNjyxVuQ02ljuenLO6WcfcWOsVztGPHDjZv3sykSZNspkpGjhzJlStXblOz9fj6+gKQl5dnYxzl5eUxevTo29Z1cXHpN3/QbkEuBPN1JAlUOKGUHTCio7S4iMjLm0CCNLfxRNsYRqCU/IVhJBAIBN1IZ+yNJvZWaycFBQV4ezfdMFSn03VaXElwcDC+vr7WPdzAYhn/8MMPxMTEdEofgpaR9deQzVnUbyQLli1C9JVKSt9+HiepFlmGaaV7+OHLfY1qqlBKItGjQCAQCHo/nWIcjR8/nq+++soq1xtE//nPf9pkuFRWVnL69GlOnz4NWIKwT58+TUZGBpIk8fTTT/OXv/yFnTt3cu7cOVasWIG/v79NLiRB1yDLMnLtRdBfgupi5EZOx5LCErL+dw3DzNeRZZAkMMoKzOmN4jikQUiS2FRWIBAIuhNFJx39jU75tnrllVeYN28eKSkpGI1G3nzzTVJSUjhy5AiHDh1qdTvHjx/n7rvvtspr1qwBYOXKlXzwwQf87ne/Q6fT8dhjj1FaWsrUqVPZvXu3yHHUxciyGWovgDG77owRasqR7Z35/tNNRF36P4ZLOiple5ykGoyyApVkRjVkChJqQEIh+fbkJQgEAkG/ROqEabX+uLC4UwKyAa5cucKrr77KmTNnqKysZOzYsfz+979n1KhRndF8u+jO4Lc7FVk2Qk0ymJomcfz+sy+JzfjQKscHrULlNgBD+lnsgkczedEaZFTI1KKQtN05bIFAIOh19ERA9muJO3DoYEB2daWO38eIgOx2ERISwrvvvttZzQl6AbJZD6UJoDCBEutWIABpZ9KIvv6J9ZxRViCX5DD5pz8B4uoauIgkjUAShpFAIBD0CCIgu310ylSiUqm0yZdST1FREUqlsjO6EHQjsmxCNlZA8X4w5ENtMZhV1hjsc0dOMXjPy9hLluSP9dNodsGRN7XkhsWqEggEAkFPoJQ65+hvdIrn6FYzc7W1tajV6s7oQtCdlJ2E8mOAySKrnKAGcPDh+/feZkrxbpSSzDn1KMqCp2DKvoIqeAyTF8Y1tCENBIWIMxIIBAJB36NDxtFbb70FWFan/ec//8HJycmqM5lMxMfHExYW1rERCroU2VAB1blILsMaTupzsRpGjUj473vElnxjnUorC4llyj13A3VbupgUyEozkiIIJK+uHrpAIBAIWkDCJiKi3W30NzpkHP3jH/8ALJ6jd955x2YKTa1WExQUxDvvvNOxEQq6DLm2BLJ3g7EaGQWSS4hFoRkENVlAoz3TZJkR+Q1bCxhlBaYbF4GG1YXoS8BhNEie3TF8gUAgELSAiDlqHx0yjtLT0wG4++672b59O25ubp0xJkE3IFfnQfZeMOstJ/LikZVqtp2rISHlBpN97LlvlExhcSmlOh0e5Vl4Ytnfy7pUP3BEoxaV4DAGSene/RcjEAgEAkEn0m7jaM2aNfz5z3/G0dGR0aNH8/LLL9+y7BtvvNHebgRdgKzLhJz9IDeeOpP5fO9efnPUBwnYdnEAFboMXKsLqDQ7cM8Ny+abX5snoXXWYjdwOJPnzgZqQVKD/VgkpXNPXI5AIBAIbkFnBFSLgOw2cOrUKQwGy7RLfUbr5uis7UMEnYNckoacexRJrbjJOIIvrlr2PZORkJA5kqFkirsrd7lk42kqpkB25Xz4w/zm7rrp06oicPQHh1FICrFcXyAQCHobktTxJI798Wu83cbRgQMHmn0t6H3IZhPIJuTCc5CTCJKEjDOSndJqIJllSNc1GDgyEpMHm/Go0uF74UsA1hvv4yejVFjX9CsdwT4SSeFwc5cCgUAgEPRZ+uOWKf0OOfsH5KTX4dJWqMyC2nLQVyCbVBQW67h8PY9N52Ru6NSoFWaUkhkALy935hiO4GDWkWN256x7LGFedYaR3QBwn46kFIaRQCAQ9FbqA7I7erTEhg0bCAoKwt7enokTJ5KUlHTb8uvXryc0NBQHBwcGDRrEM888Q01NTYfa7EyEcXQHIhdcsHiL6tGXgUnXpFxhzg3izxVw6HINb5xyBeCJ0VX8ekwZANmH92CfdQ4AP0UJqwOzAQk0AeA+DUkhclgJBAJBb6Y7kkBu3ryZNWvWsHbtWk6ePElUVBRxcXHNJocG+OSTT3juuedYu3YtFy5cYOPGjWzevJk//vGP7W6zsxHG0R2ELMvIVw8gX9gJaV9Zk3NKGjfLFNhNlFZUU1GtJ1M7miKjAx5qA49EVPFIRDn32f/AI6Zt1rJGWcE0zXVwnw6uMUhSp+08IxAIBII+zBtvvMGjjz7KqlWrCA8P55133kGr1fLee+81W/7IkSNMmTKFH//4xwQFBTFnzhyWL19u4xlqa5udjfiGu0Mwm/RwcTfknwdALkhBsrMn4fx1jBf3oHLxIibSn8RTVzCWnkXlE8ywkEEoKzIJzPuUWYoIJoQPxDEvGdIO8TcuW12p1qX7w6eDekDPXaRAIBAI2kxbA6oNtXoM+oY8d9WVVbcsq9frOXHiBH/4wx+s5xQKBbNmzSIxMbHZOpMnT+a///0vSUlJREdHc/XqVb7++mt++tOftrvNzkYYR3cAstkIiRuQiy5Zz0n2rhzZ8zlT8jdhliUUOpmUnCCmcM0iZx4m9UYwP5XTMSslfqb6ltIbQ5BSr1rqA0nSKP5TO4toRSpHzeEsM49jdg9do0AgEAjajoK2TxF9+f82se2f/9eqsoWFhZhMJnx8fGzO+/j4kJqa2mydH//4xxQWFjJ16lRkWcZoNPLLX/7SOq3WnjY7G2Ec3QlIzb/1lYWpyDIoJMv0WjjXgAY5TE63kd0qr1rrykiUOg9nT/UE9pgnoJQkAq8WMTvc9s0qEAgEgjuLRb94kPmr7rPK1ZVVPBn7405r/+DBg7zyyiv861//YuLEiVy+fJmnnnqKP//5z7zwwgud1k9HEMZRH8Ocmw6ShMInyHpOkhTIPqOhJAPMtQCcyyhmjCkZSQJZtrhVUwgmnHSL50iSuSANYYR81SqXOgbiprsOkgJJNjNg1EzYZ1mpYJJlJg0R24IIBAJBX6I9SSCV9mrs7RsW3NyuvpeXF0qlkry8PJvzeXl5+Po2v/n4Cy+8wE9/+lN+/vOfAzBq1Ch0Oh2PPfYY//M//9OuNjsbYRz1IWSzCWPCduSyfBSBI1GOn4vCdQBHdv4Hw4VvUTq4EROsJeFMGlMMR1FKMpcYRLYqAJWbNzHjR5Jw7jrGsiJUQ2cQE+7KqWPHqM27hsY3mNELnoCcVLh2GIKmMiZsPu8G5HH0ahGThngKr5FAIBD0Mbp6bzW1Ws24cePYt28fixcvBsBsNrNv3z5Wr17dbJ2qqioUCtsZj/q9WWVZblebnY0wjvoQ5ovHkcssyxjN189jzrjAD3mXiK3ZYylQDRRDLFi3Uc7zimFauC+YdaArICYyCGnQCqSAGGRDJVFmAxjDkILnIzkNBNchEDbf2ufscB9hFAkEAoHglqxZs4aVK1cyfvx4oqOjWb9+PTqdjlWrVgGwYsUKAgICWLduHQALFy7kjTfeYMyYMdZptRdeeIGFCxdajaSW2uxqhHHUR5ANtRhP7rU5dyL3GtNq9lgNIWvZumk0o6zAWJYN1LshZdAVIstmJECyc4Ih94JJj6T17o7LEAgEAkE30h3bhyxbtoyCggJefPFFcnNzGT16NLt377YGVGdkZNh4ip5//nkkSeL5558nKyuLAQMGsHDhQv7617+2us2uRpLrk+HcgZSXl+Pq6kpZWRkuLi4dbs9sMGI2GG9bpv5NVG+g2Ooan5BtjZqbysvYysYzBzCfsWzTIptlTuZfYrKxYduW+uX2B6RJ3C0ftcoJ3g8SE+Zt8RxJCtAOQBocixQQ0/oLFwgEAkGH6ezvpNb09fGZHWidm+a5awtVFToeilrcLePuLQjPURu48vF3XP5oj1V2Dw2gOiPXKrsN90d/wyK7DvfHmNOgcwnxRy5oCC5zCPJGLsoB4IL5OgNUF6mQ3TAoPLEzF+GsKKVCdsWo8ERlKsKZYiplF4ySC27yDSYrLSvLEuxmYZIdMRtyUdm7MdXfmcM58zCa9dgNnUaMnwlMRnAYAOH3ITkNAEnZpfdJIBAIBIK+jDCOephUOZXpdvstQr2nqN77KGFxITWzUr/eM6XRuDPKwwtJ4YqksCTqmujnhGLcj1COnItcdAn56gGkiPuRHNy7+GoEAoFA0Jvo6oDsOxVhHPUgF+U8piobpsbMMpTjiAs6FFLLslFWYKjOBbxs2pUcXZHstZbXnsPAfQiSQniLBAKBoL/RHTFHdyJib7VWcmTnf7iW/i7FAQUAFAcUUOp8gHxvy1RZvnce+ep9ZLnlkOWWQ4Z5L1cdLNNmVx1yuFi1hwuKLAAuKLLIKvqYycrPUdYlYDTKChQSnJMnWA0fhQTJ0k2yeZRVVklm7BxuyvmgUIKTm80pYRgJBAKBQNB6+qTnaMOGDfztb38jNzeXqKgo/vnPfxIdHd1l/X2/6Q2mpb5kCZIOgcpgDU6KWsvUViBUDmokB1jqyDJIA6DSrCGiXudikecqaq1tnzCEcq48GE/nSkqqnBihcOIj81w8HCspq3ZihJ0jHxvm4qqtpKxGS4QCPq6NxVVbS7nZnbvcLR4i2axFNjugnDAf5YgYi5EkEAgEgn5Ne5JANtdGf6PPeY42b97MmjVrWLt2LSdPniQqKoq4uDjy8/O7rtMbPwANrkWnOuPmVnJrygKYZYl8gxsV5W7Y+9yLTudCdlkFOp0LWv8F6KpdyCqrRFftgvPgBVTp3ciqgSrzAFxC7qXa7EFZVX17EpKTF8rwaUgqDZKiZ+ze2tpa/vSnP1FbW9ty4X6MuE+tQ9yn1iHuU+voj/dJomF/tfYe/dA26nvG0RtvvMGjjz7KqlWrCA8P55133kGr1fLee+91WZ9SyN0AmGTLW+TbsrE28t7ycTZy49f7qsbbyAeqLbJlmkzGaPLGyVzD5WuXcTLX4O/qXCdfwclcTYCrE07mai6mX8FZriLAzQlnarlUYcA9ehbuI8Za+1ROmIuk7FmPUW1tLS+99FK/evi0B3GfWoe4T61D3KfWIe6ToLX0KeNIr9dz4sQJZs2aZT2nUCiYNWsWiYmJLdbfsGHDbeVblZm65JccHLmO/8sK47+XFmI+M4aPr9zLnuqpbL6+CFXaODZfX8Temqlsy1rEtqxF7NNPY2fBEnwKo9lZsIQDxmnsLl/KkNoYdpcv5ZBpKnurlxCtHcRgUzUTPdVM9nNl2ABPJvu5MtFLzeQAV4Z7ezI5wJWYAWqmDHRluI8nUwa6oshKIfbuu/Bb/AvsFj6BckQMiqBRLV5Pa3StvS+t7aezaE8fra0j7pO4T51ZR9wncZ96C/Wr1Tp69Df6VBLI7OxsAgICOHLkCDExDUkMf/e733Ho0CF++OEHm/L1SbAyMzNxcXFhwoQJHDt2DI1Gg0ajITw8nJSUFJs6N5+rl8vLy5nvGspz0x5AqbJ4Zzorz1FSUhLT7lsIRdlWvcrPF+r0AEo/Pyhp0K/dfpDXvzve4j1r7hpb0rXlvtwsd2WSs9tdS0friPsk7lNn1hH3Sdyn5uiJJJA7Unbg2MEkkLoKHYvDRRLIO4Z6u2/QoEHWc66urjz33HPExsai1+vZuHGjTZ3a2loOHjxIWFgYiYmJlJSUsHHjRmpqajBipqxah0k2IaHgRlo5qpJKa92Qwe4UFuXj6uxCZuoFNBU6q87bVQUlxag1GqoqddTUFKGtsdStqK2luLyCmqIi7OzsKC8rp7akFK2+HABPT09K0q/ho5EpKCwAWaa0ooKNGzcSERGBnZ0dTk5O3Lhxg/T0dGufLi4uGI1G9u7dS3BwMIcOHbK5Vr1ezzfffMOUKVPYtWsX1dXVAJSUlBAfH4+npydms5ny8nLrfQDQaDSYTCa++eYbIiIi2LNnj819Ajh06BATJ07k+++/p7S01Nrn4MGDCQ4Otp47c+aMzZjuv/9+EhISGDduHF9++aWNrqamhoSEBAYPHsyZM2dsdmz28fEhKiqKjIwMXFxcSEpKsl7Lxo0bWbhwISdOnGDKlCls2bLFpt2oqCiqq6u5fPky6enpZGRkWHVubm4YDAb279/PwIED+f777626kpISMjMzSU5OZsqUKezcudPmPoWFhVFTU8P58+cpKiri0qVLVn39e3Pv3r3WDRYbc9ddd5Gens7YsWPZv38/5eXlVl1wcDADBw6ksrISg8FAcnKyVadQKKx/mzFjxvDVV1/ZtDtp0iSKiooICQnhxIkTFBQUWK/lm2++YcSIEeTk5ODg4MCJEyds6i5evJjKykpKSkrYtm2bjW7MmDFUV1eTnp7OxYsXuXHjhlVXXl5Obm4uqamp+Pj4cOTIEZv7NHfuXCorKykvL2f79u0YjUarPjAwEIC0tDR0Oh1Xrlyxtuvk5MScOXNISkpi+PDh7N+/32ZMM2bM4OLFi0RHR7Nnzx4qKxt9VkNCqK2t5fTp01RXV9t8qalUKpYsWUJCQgKRkZHs3r3b5m9+4cIF8vLyrM+I4uJiq37gwIEMHz6c6upqTp48yalTp2zGtHTpUiorKykqKmLHjh02upqaGhITE/Hz8+PChQtkZ2db78OAAQMYN24cOp2O8+fPc/ToUet4Nm7cSGxsrPVef/7555jNZmu7LT0jZsyYwcmTJ5t9RsycOdP6t2n8jAAYNmyYzTMiNTXVqistLaW8vJyEhATrM6Ix06ZN48aNGxgMBj7//PNmnxHV1dUcP368yTOi/v3d+BlRfx+io6MpLy9Hr9eza9cu6zOipKSEXbt2MWTIEADOnz/fxJBp6RkBludBc8+IadOmodPpuHjxos0zAmDOnDnWZ8TmzZuBhu8mQe+lT3mO9Ho9Wq2WrVu3WnfqBVi5ciWlpaV88cUXNuVv3LhhYxgJBAKBQNDTZGZmMnDgwC7to95ztPNC53iO7h0hPEe9FrVabf2VXW8cmc1m9u3bx+rVq5uU9/f3JzMzE2dn55v2NRMIBAKBoHuRZZmKigr8/f27rc/6FWcdbaO/0aeMI4A1a9awcuVKxo8fT3R0NOvXr0en07Fq1aomZRUKRZdb5wKBQCAQtBZXV9eeHoKgFfQ542jZsmUUFBTw4osvkpuby+jRo9m9ezc+Pj49PTSBQCAQCHoVYm+19tGnYo4EAoFAIBC0TH3M0Tdp2zsl5mhe6JJ+FXPUH6cSBQKBQCAQCG5Jn5tWEwgEAoFA0DrEtFr7EJ6jDpKZmcn06dMJDw8nMjKySX4MgYXS0lLGjx/P6NGjiYiI4N133+3pIfVqqqqqCAwM5De/+U1PD6XXEhQURGRkJKNHj+buu+/u6eH0WtLT07n77rsJDw9n1KhR6HS6liv1Q9LS0hg9erT1cHBwaJKLqi+iQO6Uo78hPEcdRKVSsX79ekaPHk1ubi7jxo1j/vz5ODp2bI73TsPZ2Zn4+Hi0Wi06nY6IiAiWLl2Kp6dnTw+tV/LXv/6VSZMm9fQwej1HjhzBycmpp4fRq3n44Yf5y1/+wrRp0yguLkaj0fT0kHoloaGhnD59GoDKykqCgoKYPXt2zw5K0GMIz1EH8fPzY/To0QD4+vri5eVlkzFXYEGpVKLVagFLFnJZlkWW2Ftw6dIlUlNTmTdvXk8PRdDHOX/+PHZ2dkybNg0ADw8PVCrxm7gldu7cycyZM++IH7mS1DlHf6PfG0fx8fEsXLgQf39/JElq1o26YcMGgoKCsLe3Z+LEidatKW7mxIkTmEymOzIrd2fcp9LSUqKiohg4cCC//e1v8fLy6qbRdx+dcZ9+85vfsG7dum4acc/QGfdJkiTuuusuJkyYwMcff9xNI+9eOnqfLl26hJOTEwsXLmTs2LG88sor3Tj67qUzn+WfffYZy5Yt6+IRdw+SJKPo4CFJ/e+HbL83jnQ6HVFRUbfcUXnz5s2sWbOGtWvXcvLkSaKiooiLiyM/P9+mXHFxMStWrODf//53dwy72+mM++Tm5saZM2dIT0/nk08+sdkb7U6ho/fpiy++YPjw4QwfPrw7h93tdMb76fDhw5w4cYKdO3fyyiuvcPbs2e4afrfR0ftkNBr5/vvv+de//kViYiJ79+5l79693XkJ3UZnPcvLy8s5cuQI8+fP745hC3orssAKIG/fvt3mXHR0tPzEE09YZZPJJPv7+8vr1q2znqupqZGnTZsmf/TRR9011B6lvfepMY8//ri8ZcuWrhxmj9Oe+/Tcc8/JAwcOlAMDA2VPT0/ZxcVFfumll7pz2N1OZ7yffvOb38jvv/9+F46y52nPfTpy5Ig8Z84cq/7111+XX3/99W4Zb0/SkffURx99JD/00EPdMcwupaysTAbkA1c+l4/l7+7QceDK5zIgl5WV9fRldRv93nN0O/R6PSdOnGDWrFnWcwqFglmzZpGYmAhY9sp5+OGHmTFjBj/96U97aqg9SmvuU15eHhUVFQCUlZURHx9PaGhoj4y3p2jNfVq3bh2ZmZlcu3aNv//97zz66KO8+OKLPTXkHqE190mn01nfT5WVlezfv5+RI0f2yHh7itbcpwkTJpCfn09JSQlms5n4+HhGjBjRU0PuMVpzr+q5k6bUAKROOvobwji6DYWFhZhMpiZbk/j4+JCbmwtAQkICmzdvZseOHdYloOfOneuJ4fYYrblP169fZ9q0aURFRTFt2jSefPJJRo0a1RPD7TFac58ErbtPeXl5TJ06laioKCZNmsSKFSuYMGFCTwy3x2jNfVKpVLzyyivExsYSGRnJsGHDWLBgQU8Mt0dp7WevrKyMpKQk4uLiunuIgl6GWLbQQaZOnYrZbO7pYfR6oqOjrctkBa3j4Ycf7ukh9FqGDBnCmTNnenoYfYJ58+aJlY+txNXV9Y6LhVRKlqOjbfQ3hHF0G7y8vFAqlU0+LHl5efj6+vbQqHof4j61DnGfWoe4T61D3KfW05/vVWcsxRdL+QU2qNVqxo0bx759+6znzGYz+/btIyYmpgdH1rsQ96l1iPvUOsR9ah3iPrUeca8EbaXfe44qKyu5fPmyVU5PT+f06dN4eHgwePBg1qxZw8qVKxk/fjzR0dGsX78enU7HqlWrenDU3Y+4T61D3KfWIe5T6xD3qfWIe9U8Ciy5ijraRr+jp5fL9TQHDhyQgSbHypUrrWX++c9/yoMHD5bVarUcHR0tHz16tOcG3EOI+9Q6xH1qHeI+tQ5xn1qPuFe21C/lP5q+VU4u+qZDx9H0rf1uKb8ky2IPB4FAIBAI7iTKy8txdXXlaPpWnFw6tg1KZbmOScE/oqysDBcXl04aYe+m30+rCQQCgUBwp2IJyO6YD6Q/BmTf0caR2WwmOzsbZ2dnpP741xUIBAJBr0GWZSoqKvD390eh6J71UArJcnS0jf7GHW0cZWdn35GbwAoEAoGg75KZmcnAgQN7ehiC29BtxtG6devYtm0bqampODg4MHnyZF577TWbLSRqamp49tln2bRpE7W1tcTFxfGvf/3LJqtpRkYGjz/+OAcOHMDJyYmVK1eybt06VKqml+Ls7AxY3oj9ZZ5UIOgvfHf8BgdOZlllP3cHcouqGmQPB/KKq62yr7sDeY30vh43ye4O5Bc0kj3tKcjXAeDtoaWw7jWAt5cjBQWVDfIARwrzGstOFOQ3yAMGOFJQoLMpb6P3cqIwv6JB9namoE5u/Lq75f7Sd0tlY6YFM3n6EDpKeXk5gwYNsn43dQcKqRNWq3Wwfl+k24yjQ4cO8cQTTzBhwgSMRiN//OMfmTNnDikpKTg6WoLFnnnmGb766iu2bNmCq6srq1evZunSpSQkJABgMpm455578PX15ciRI+Tk5LBixQrs7Ox45ZVXmvRZP5Xm4uIijCOB4A7D0ckZjUNDoKm9VoumSrpJVtjKukZ6By0a+wbZoYnsgMa+/rUj9vY00jliby/fXtbcLNOC3tysfDtdV8v9pe+Wyjo6Onfqd0h3hnlIdDyhYT+cVes+42j37t028gcffIC3tzcnTpwgNjaWsrIyNm7cyCeffMKMGTMAeP/99xkxYgRHjx5l0qRJ7Nmzh5SUFL777jt8fHwYPXo0f/7zn/n973/Pn/70J9RqdXddjkAg6EEKCwvJzrxGVWUFWic3qipLKdQXUlWjtMoFhkKqalS2cnUjvbGIqmoFWic3hlTsY6TuPCnGkaQ7ziBYt5+RNee5oLds0jpCn0JabTjXHabjVHUQ36xUqoxhVDrchVP1IXyyLqAzjKDKPhZtTTwDsi9QaRhBlSYWbW08A3JsZa+cC1QawqhSx6LVx+OVl0qlPoxq9TQc9N/jmZdKhT4MwPr6Zl1Xy/2l79b0VZn4Pkd0M5l878974N0u6Al6bCn/5cuXGTZsGOfOnSMiIoL9+/czc+ZMSkpKcHNzs5YLDAzk6aef5plnnuHFF19k586dNnt0paenM2TIEE6ePMmYMWNs+qhfynjztJpGo0Gj0SAQCHo/JpOZyhojapUCO5WCkuIivk86xdGLxVy8WoC7uxclJYU4OmmpqtDh7uZFSWkhjs5aqsqr8HDzori0EK2zluoyXYPsoqWqXMcC98usUv8fsmxZlWOUFagks1UGrK8NsgK7RrqulkXfvauvI2P/vw4ZSPXfSd2xJL6+r1OZW3B20XaorYryKsYMul8s5e9qzGYzTz/9NFOmTCEiIgKA3Nxc1Gq1jWEEtrsm5+bmNrurcr3uVtwclL127VpmzJjBmDFj2LVrl41u2rRp5ObmEh4ezuHDhykqKrJpJywsjLy8POzs7Dhx4oRN3QceeICEhARiYmLYunWrjS46OpqqqioCAgJITk4mK6shVsLb25vo6GguXbqEl5eXdRqxnkWLFnH8+HFiY2PZvHmzzUa3kZGR2NnZ4ezsTEZGBlevXrXqXFxcmDNnDseOHSMkJIT9+/fbtBsXF0dycjKxsbHs2LGD6uqG+IzQ0FC8vLwwm82UlZWRkpJi1Wk0GpYuXUp8fDxRUVF8/fXXNu1Onz6djIwMoqKiOHjwICUlJVZdYGAgISEh1nOnTp2yqbt8+XLi4+OJjo5m+/btNrqYmBjKysoICgri5MmTNn9zX19fxo4dy7Vr13B1dSUxMdGm7pIlS0hKSiI2NpZPP/3URldvVLu7u3PlyhWuX79u1bm7uzN9+nTOnDnD4MGDOXjwoE3d+fPnc+bMGWJjY9m2bRu1tbVWXXh4OK6urigUCgoLC0lLS7PqHBwcWLx4MfHx8URERPDtt9/atDtjxgyuXLnChAkT2LNnD+Xl5VbdkCFDGDx4MBUVFRgMBs6ePWvVKRQKli1bRnx8POPHj+eLL76waXfKlCkUFhYybNgwkpKSyM/Pt+oCAgKIiIggKysLrVZLUlKSTd0f/ehHJCYmMmXKFD777DMb3bhx4zAYDPj4+JCamkpmZqZV5+npydSpU0lJScHX15fvv//epu6CBQs4deoUsbGxbNmyBaPRaNVFRERQVqvk04R8avV6qqurqSjKobSyDEf/cEoqcsgvvIJZo8XFyYuykkIqSy+iV9ozMGwMufk/oCrJp6SqFo3XQAp1BVSWXkTWuuDnN5TC4tOMMh4BdcMXpUqyfL4az3zUv7a7SdfVsui79/RlkiWq0w5y5Eh4u58RO3fupLtR0PFptf64z1iPeI4ef/xxvvnmGw4fPmyN2P/kk09YtWqVzZcLWIyKu+++m9dee43HHnuM69ev23yRVFVV4ejoyNdff91k52nhORII+j5XcsrZ8MV5q1xdWUpW5mXKamRqK6txdPZAV1GMQq1GYTAwPGhgmzxHj3scZJbdAat34IAhlrvt4jHJEsq6QNT619/U3sU8zSGrd2lb7d0s1RzogDydpZqDVnl77XSWNJKBW+q6Wu4vfbelr77oOTrTSZ6jKOE56lpWr17Nrl27iI+Pt1nK6Ovri16vp7S01MZ71HjXZF9f3ya/Zut3Wb7dzsoiIFsg6LvoDWYb2cHJjYBBQ7HLK6JKa4dG64rawQXJWIVa7YinTwAOjq64aoxUOFtijhwcXXHRGKlw8m2Q7U1UOCmosMuDmgMUKXzYIf+YdLcZXNGNY6SqUcyR3QXSakdw3XE6X1WNZbQilSxzKJI2lmvVkQSrUknXh1FlH8u1mkiGqFJJN4RRpYnlHzWRBNs1la8ZQqlSx7K+JpIguzSu1YZSrZ7G+qpIgjQWGbC+vlnX1XJ/6bs1fQ13uYJb5Iw+GXMkVqu1j27zHMmyzJNPPsn27ds5ePAgw4YNs9GXlZUxYMAAPv30U+677z4A0tLSCAsLIzExkUmTJvHNN9+wYMECcnJy8Pb2BuDf//43v/3tb8nPz2/iDepOK10gEHQNZ9OL+eDbtCbnS8pqKClv8DRrVAokGQYNsKxg8/fUklvYaGm/p5bcRsvp/Ty15BbqmFq7nXtqNpLqOIv/4ymr3t/Lgby65fm+no4U1L3eXlVDqVlmnr0dfkolAD7ejhTkNizN9/F2Ir+R7O3jSH5eQ98+Po62em8nCnIblo57+zqTXyc3ft3dcn/pu6WyU+8OYdrMEDpKT3iOkrM+6xTPUUTAA/3qu7TbPEdPPPEEn3zyCV988QXOzs7WeBFXV1ccHBxwdXXlkUceYc2aNXh4eODi4sKTTz5JTEwMkyZNAmDOnDmEh4fz05/+lNdff53c3Fyef/55nnjiCTFNJhDcoRiM5pYL1dGeTL52ssXAMio00IqujHU/J5X9coGzQNA/6Dbj6O233wYswbqNef/993n44YcB+Mc//oFCoeC+++6zSQJZj1KpZNeuXTz++OPExMTg6OjIypUrefnll7vrMgQCQTejN5haXbY9+WPs0ANglFr3A8uExTpSCdtI0AdQIKOgg9NqHazfF+k246g1s3f29vZs2LCBDRs23LJMYGBgk9VRAoHgzsVgat6d4+aiwdW5sUEjMyLQg5WzhzVb/lao9u6CYxAxchAjpk9uaK2Zpd4An73yHdSa+NWj0QR6OjbRd7bclW2LvltXVqnsu+u1xN5q7eOO3ltNIBD0fW41rSZJ0k27hUto7VXYq9v4WDNbptVU9k6oNC3Xra0LEHd10qBpRXmBQND3EJ9sgUDQq9G3IebIrj2/8A11+b1U9rcvh8WLZTRbvOD2KmXb+xIIuhmxWq19CONIIBD0atoSkK1Wtcc4qlvRZufQYtHqRvFP9uq+O9Ui6D9IEjd5WNvXRn9DfLoFAkGvpk2eo/YYR8aausotL3euqTOOFBKo+3AcikAguD3CcyQQCHo1bfEctcs4qp9Ws2t5Wq1GbxmLvZ2yW3dWFwjaS3/ePqS0tJSNGzdy4cIFAEaOHMnPfvYzXF1dW6zbV69ZIBD0E9o2rdaOOCDrtFrLnqP6aTUHOxFvJOgb1K9W6+jR1zh+/DghISH84x//oLi4mOLiYt544w1CQkI4efJki/WFcSQQCHo1BlPr8xyplO14ihvqptVaEZBdP61mL4wjgcCGDRs2EBQUhL29PRMnTmyy1Vdjpk+fXrfa1Pa45557rGUefvjhJvq5c+e2ejzPPPMM9957L9euXWPbtm1s27aN9PR0FixYwNNPP91ifTGtJhAIejVtiTnqLs+RvZ34XSnoK0hIHc7mfvv6mzdvZs2aNbzzzjtMnDiR9evXExcXR1pamnWrr8Zs27YNvV5vlYuKioiKiuL++++3KTd37lzef/99q9yWnTCOHz/Ou+++i0rVYOaoVCp+97vfMX78+Bbri0+4QCDo1bTNOOpIzFHLq9XqPUcOauE5EvQR6perdfS4DW+88QaPPvooq1atIjw8nHfeeQetVst7773XbHkPDw98fX2tx969e9FqtU2MI41GY1PO3d291Zft4uJCRkZGk/OZmZk4Ozu3WF8YRwKBoFfT5QHZxrYbRyLHkeBOprbWQHl5lfWoqKi6ZVm9Xs+JEyeYNWuW9ZxCoWDWrFkkJia2qr+NGzfy4IMP4ujoaHP+4MGDeHt7ExoayuOPP05RUVGrr2HZsmU88sgjbN68mczMTDIzM9m0aRM///nPWb58eYv1xbSaQCDo1XR9nqPWG0fVwnMk6GNI7ZhWW//6Fl7/6yetKltYWIjJZMLHx8fmvI+PD6mpqS3WT0pKIjk5mY0bN9qcnzt3LkuXLiU4OJgrV67wxz/+kXnz5pGYmIhS2fLn7+9//zuSJLFixQqMRiMAdnZ2PP7447z66qst1hfGkUAg6NV0qefIbAJTXexDq/IcNSzlFwj6AvXBzG1hze+X8cTTS61yRUUVEUNWdPbQAIvXaNSoUURHR9ucf/DBB62vR40aRWRkJCEhIRw8eJCZM2e22K5arebNN99k3bp1XLlyBYCQkBC02pY/5yCMI4FA0Mvp0iSQ9V4jaNVqtWq9WK0muPPRaOzQaOxaVdbLywulUkleXp7N+by8PHx9fW9bV6fTsWnTJl5++eUW+xkyZAheXl5cvny5VcZRPVqtllGjRrW6fD3COBIIBL2aLvUctdU4suY5EuGagr6BZVKtY+/X203LqdVqxo0bx759+1i8eDEAZrOZffv2sXr16tu2u2XLFmpra/nJT37S4hhu3LhBUVERfn5+tyyzdOlSPvjgA1xcXFi6dOkty4FlxdztEMaRQCDotciyjMHY+jxHbY45MjbadFbRct1akedIIGjCmjVrWLlyJePHjyc6Opr169ej0+lYtWoVACtWrCAgIIB169bZ1Nu4cSOLFy/G09PT5nxlZSUvvfQS9913H76+vly5coXf/e53DB06lLi4uFuOw9XV1TqF6OLi0qEs9sI4EggEvRajqW27gbc5z1EbgrFBZMgWCJpj2bJlFBQU8OKLL5Kbm8vo0aPZvXu3NUg7IyMDxU0/PtLS0jh8+DB79uxp0p5SqeTs2bN8+OGHlJaW4u/vz5w5c/jzn/9821xHjXMiffDBBx26JmEcCQSCXktbptSgPdNqrU8ACSIgW9D3kFB0wrRay/VXr159y2m0gwcPNjkXGhqKLDf/48fBwYFvv/22TWO8mRkzZrBt2zbc3NxszpeXl7N48WL2799/2/rCOBIIBL0WfRum1ADslG01jlq/dQg0zpAtjCNB36A9S/mba6OvcfDgQZss3PXU1NTw/ffft1hfGEcCgaDX0hbPkVKpQNHWHTLb6DkSAdkCQe/m7Nmz1tcpKSnk5uZaZZPJxO7duwkICGixHWEcCQSCXove1MXZsa0xR63zHImAbEFfoz15jppro68wevRo6zXPmDGjid7BwYF//vOfLbYjjCOBQNBr0Ru6ODu2sW5ara0B2SJDtqDPINHSxrGta6NvkJ6ejizLDBkyhKSkJAYMGGDVqdVqvL29W5VhWxhHAoGg12Jsi+eorfFG0PZpNZEEUiDo1QQGBgKWXEsdQRhHAoGg19Kl2bGhzQHZYrWaoK/RXwOy60lJSSEjI6NJcPa9995723rCOBIIBL2WLs2ODe1Yyi/yHAkEfYGrV6+yZMkSzp07hyRJ1rQB9fFTJtPtV8KKJRcCgaDX0hbjqM0JIKHNSSCFcSToa9QHJ3f06Gs89dRTBAcHk5+fj1ar5fz588THxzN+/Phm8y7djPAcCQSCXktb8hy1y3NkbF+GbHuxlF/QR+iuJJC9jcTERPbv34+XlxcKhQKFQsHUqVNZt24dv/71rzl16tRt6/e9KxYIBP0GQxu2D2nXarV2bh8iYo4Egt6NyWTC2dkZAC8vL7KzswFLwHZaWlqL9YXnSCAQ9Fr0hi7cdBYaYo5aEZAty7IIyBYI+ggRERGcOXOG4OBgJk6cyOuvv45arebf//43Q4YMabF+m42j8vJy9u/fT2hoKCNGjGjXoAUCgaA1tCXmSNWupfz1eY5aDsiubTQWkedI0FeQJAWS1MFptQ7W7wmef/55dDodAC+//DILFixg2rRpeHp6snnz5hbrt2gcPfDAA8TGxrJ69Wqqq6sZP348165dQ5ZlNm3axH333dfxqxAIBIJmMLQhz5G6PXFAbZhWq2nkxbJvj5dKIBB0G3FxcdbXQ4cOJTU1leLiYtzd3VsVYN7iJzw+Pp5p06YBsH37dmRZprS0lLfeeou//OUvHRi6QCAQ3J62ZMhuVxLINgRk18cb2Sml9nmpBIIeQOqkf30Jg8GASqUiOTnZ5ryHh0erV961+AkvKyvDw8MDgN27d3Pfffeh1Wq55557uHTpUjuGLRAIBK2jLZ6jju2t1grjSGTHFvRB+qNxZGdnx+DBg1vMZXQ7WnyaDBo0iMTERHQ6Hbt372bOnDkAlJSUYG/fuqyyAoFA0B7alOeoPUZLG5JA1gdjixxHAkHv53/+53/44x//SHFxcbvqtxhz9PTTT/PQQw/h5OREYGAg06dPByzTbaNGjWpXpwKBQNAa2rR9iLIdv27bsH2IWMYv6Jv0r41n6/nf//1fLl++jL+/P4GBgTg6OtroT548edv6LRpHv/rVr5g4cSIZGRnMnj0bhcLibBoyZAh//etfOzB0gUAguD3dlyG7NZ4jkR1b0Pfor3urLV68uEP1WzSOXn75ZX7zm98wbtw4m/MzZszgb3/7G5MnT+7QAAQCgeBWdHmGbOu0WsueoxqRHVsg6DOsXbu2VeU+/fRT7r333iaepRY/5S+99BKVlZVNzldVVfHSSy+1cpgCgUDQdrp841ljfZ6j1q9WE9Nqgr6EZW80RQePvuc5ai2/+MUvyMvLa3K+Rc+RLMvN3pgzZ85YV7EJBAJBV9C2abU2Gkey3L6AbJEAUtCH6J8RR61HlpvfouiWxlF9oiRJkhg+fLiNgWQymaisrOSXv/xl549UIBAI6ujSpfwmPch17bclILs9sU0CgaBPcUvjaP369ciyzM9+9jNeeuklXF1drTq1Wk1QUBAxMTHdMkiBQNA/aVMSyLYaR/XB2NA6z1FdniPhORL0KSSF5ehoG/2MWxpHK1euBCA4OJjJkydjZ2fXoY7i4+P529/+xokTJ8jJyWH79u020eQPP/wwH374oU2duLg4du/ebZWLi4t58skn+fLLL1EoFNx33328+eabODk5dWhsAoGgd9Km7UPamrW63jiSlKBs+flWI2KOBH2Q/rparaO0GHN01113YTKZ+Pzzz7lw4QIAI0eO5N5770WpbP1DQqfTERUVxc9+9jOWLl3abJm5c+fy/vvvW2WNRmOjf+ihh8jJyWHv3r0YDAZWrVrFY489xieffNLqcQgEgr6B2Sxj6spptcZbh7Qi4LRarFYTCPoNLRpHly9fZv78+WRlZREaGgrAunXrGDRoEF999RUhISGt6mjevHnMmzfvtmU0Gg2+vr7N6i5cuMDu3bs5duwY48ePB+Cf//wn8+fP5+9//zv+/v6tGodAIOgbtMVrBO3Ic9SGrUOgwTgSeY4EfQnhObo9gYGBzc6MtfgT6Ne//jUhISFkZmZy8uRJTp48SUZGBsHBwfz617/u1EEePHgQb29vQkNDefzxxykqKrLqEhMTcXNzsxpGALNmzUKhUPDDDz906jgEAkHP05aVatCBmCNV64yj+tVqYlpN0JeoX1jV0aOvceDAgVvq/t//+3/W18nJyQwaNKhJmRafJocOHeL111+3Wbbv6enJq6++yqFDh9o63lsyd+5cPvroI/bt28drr73GoUOHmDdvnnXjuNzcXLy9vW3qqFQqPDw8yM3NvW3b5eXlNkdtbW2njVsgEHQNbUkAiSShauv2IW30HIkM2QJB32Hu3Ln89re/xWAwWM8VFhaycOFCnnvuuRbrtzitptFoqKioaHK+srIStVrdxuHemgcffND6etSoUURGRhISEsLBgweZOXNmh9q+2Spcu3YtM2bMYMyYMezatctGN23aNHJzcwkPD+fw4cM23qtBgwYRFhZGXl4ednZ2nDhxwqbuAw88QEJCAjExMWzdutVGFx0dTVVVFQEBASQnJ5OVlWXVeXt7Ex0dzaVLl/Dy8iIhIcGm7qJFizh+/DixsbFs3rwZs7nhF3VkZCR2dnY4OzuTkZHB1atXrToXFxfmzJnDsWPHCAkJYf/+/TbtxsXFkZycTGxsLDt27KC6umH1TmhoKF5eXpjNZsrKykhJSbHqNBoNS5cuJT4+nqioKL7++mubdqdPn05GRgZRUVEcPHiQkpISqy4wMJCQkBDruVOnTtnUXb58OfHx8URHR7N9+3YbXUxMDGVlZQQFBXHy5Ekbo9jX15exY8dy7do1XF1dSUxMtKm7ZMkSkpKSiI2N5dNPP7XRjRkzBrCkr7hy5QrXr1+36tzd3Zk+fTpnzpxh8ODBHDx40Kbu/PnzOXPmDLGxsWzbts3G8A4PD8fV1RWFQkFhYSFpaWlWnYODA4sXLyY+Pp6IiAi+/fZbm3ZnzJjBlStXmDBhAnv27KG8vNyqGzJkCIMHD6aiogKDwcDZs2etOoVCwbJly4iPj2f8+PF88cUXNu1OmTKFwsJChg0bRlJSEvn5+VZdQEAAERERZGVlodVqSUpKsqn7ox/9iMTERKZMmcJnn31moxs3bhwGgwEfHx9SU1PJzMy06jw9PZk6dSopKSn4+vry/fff29RdsGABp06dIjY2li1btmA0GgGo0EtU6rxQKpUoJIlavd7mPapUKvH09KSsrAxXFyc2bdpk0+7s2bNJTU0lJiaGr7/+2iaZ7bBhwwgyZOIFVBnhi0bvCZVKxf333098fLzNM+LSNQfAjhpdOcePHxfPCPGMsJ5r7TNi586ddDty3dHRNvoYBw4cYMWKFezdu5dPPvmE9PR0HnnkEUJDQzl9+nSL9SX5VhmQ6lixYgUnT55k48aNREdHA/DDDz/w6KOPMm7cOD744IM2D1qSpCar1ZpjwIAB/OUvf+EXv/gF7733Hs8++6zNh8hoNGJvb8+WLVtYsmRJk/rl5eW4urqSmZmJi4uL9bxGo2kS7C0QCHoXmQWV/OPzc60q6+hgx59Xjm+5YGPO74AtK2FwDPxsd4vFH34/iYNpBfztR5HcP76pG14gaIn676SysjKb76Qu7avkIC4uHVvRXV5eiav79G4Zd2dSn49x69atmM1m/vznP/O73/2uVdOELU6rvfXWW4SEhBATE4O9vT329vZMmTKFoUOH8uabb3bKBTTHjRs3KCoqws/PD7D8IigtLbX5JbZ//37MZjMTJ068bVsuLi42hzCMBILej74tW4e0dRk/tGnrEIBqkedIIOhTXLx4kePHjzNw4EBUKhVpaWlUVVW1qm6LTxQ3Nze++OIL0tLS2Lp1K1u3biUtLY3t27fbJIZsicrKSk6fPm11Z6Wnp3P69GkyMjKorKzkt7/9LUePHuXatWvs27ePRYsWMXToUOLi4gAYMWIEc+fO5dFHHyUpKYmEhARWr17Ngw8+KFaqCQR3IMau3letDVuHANTUjUfEHAn6FLLcOUcf49VXXyUmJobZs2eTnJxMUlISp06dIjIyssmUanO0GHNUz7Bhwxg2bFi7B3r8+HHuvvtuq7xmzRrAkmzy7bff5uzZs3z44YeUlpbi7+/PnDlz+POf/2zj5fn4449ZvXo1M2fOtCaBfOutt9o9JoFA0Htpk+eoXcZR/Wq1lrcOgYYM2WK1mqBvYa47OtpG3+LNN99kx44d1hRCERERJCUl8cc//pHp06e3uDCrRePIZDLxwQcfsG/fPvLz820C/YAmAXy3Yvr06bfc4A1oEpDaHB4eHiLho0DQT2jLUv4OGUdtzHMkjCOBoPdz7tw5vLy8bM7Z2dnxt7/9jQULFrRYv0Xj6KmnnuKDDz7gnnvuISIiok/mOxAIBH2PtniO1N1gHNWIDNmCvohMx6fF+t6sGl5eXphMJnbs2GHd3SM8PJxFixZx1113tVi/ReNo06ZNfPbZZ8yfP7/joxUIBIJW0pY8R+0yjtoakC3yHAn6Imaz5ehoG32Mju7u0eITRa1WM3To0M4ZrUAgELQSo6n1P1ft2rDPo5U2BmTX1mXIFqvVBILeT0d392jROHr22Wd58803bxsvJBAIBJ1NmzxH7ZnqakNAttFkRl+315t9W/dwEwh6FLmTjr5FR3f3aHZabenSpTby/v37+eabbxg5cmSTDdq2bdvWnnELBALBbWlLQLaqPXmOrDFHLXuOahqNRXiOBH2KzliK3wedIx3d3aNZ4+jm/EXNZZ8WCASCrqQtxlFXB2TXB2MDaNrTl0Ag6FYWLFjAY4891mR3j1/+8pfce++9LdZv1jh6//33ra+rq6sxm804OjoCcO3aNXbs2MGIESOsCRoFAoGgs+n6PEf1MUctG0fV+oaVamLFrqBPIZstR0fb6GO89dZbrFy5kpiYGOuMl9Fo5N57723V7h4trlZbtGgRS5cu5Ze//CWlpaVMmjQJOzs7CgsLeeONN3j88cc7fhUCgUBwEwZTF3uO2rBarUasVBP0VfrhtJosy5SXl7Np0yaysrKsS/lHjBjR6gVmLT5RTp48ybRp0wDYunUrPj4+XL9+nY8++khkpxYIBF2G3tB7MmTX1I1FJIAUCHo/siwzdOhQbty4wdChQ1m4cCELFy5s08r7Fp8oVVVVODs7A7Bnzx6WLl2KQqFg0qRJXL9+vf2jFwgEgtvQpgzZXRyQLXIcCfos9dNqHT36EAqFgmHDhlFUVNT+NloqMHToUHbs2EFmZibffvstc+bMASA/Px8XF5d2dywQCAS3o03Tau0xWtoRkC08R4I+Rz/eePa3v/0tycnJ7arfYszRiy++yI9//GOeeeYZZs6cSUxMDGDxIo0ZM6ZdnQoEAkFL6A2tz3PU5QHZYusQgaBPsWLFCqqqqoiKikKtVuPgYPs5Ly4uvm39Fo2jH/3oR0ydOpWcnByioqKs52fOnCmW+AsEgi6jLZ6jdk2rtScgW+Q4EvQ1+ulqtfXr13eofovGEYCvry++vr425+rzBggEAkFX0KY8R2316JjNjYyjViSBFDFHgj6KjBmZjhk3Ha3fE6xcubJD9VtlHAkEAkF306Y8R231HBmrG163YrVafZ4jjTCOBII+g8lkYvv27dal/OHh4SxatAiVqmXTRxhHAoGgV9KlGbINNQ2vWxVzVLfprDCOBH0Ns9lydLSNPsb58+e59957yc3NJTQ0FIDXXnuNAQMG8OWXXxIREXHb+iK6UCAQ9DpkWe7aDNn1wdhKNShaNnhqREC2oK/ST1er/fznP2fkyJHcuHGDkydPcvLkSTIzM4mMjOSxxx5rsb74pAsEgl6Hydy2B3LbjaPWL+MHEXMkELTEhg0bCAoKwt7enokTJ5KUlHTLstOnT0eSpCbHPffcYy0jyzIvvvgifn5+ODg4MGvWLC5dutTq8Zw+fZp169bh7u5uPefu7s5f//pXTp061WJ9YRwJBIJeR1um1ADUqjYaLcbWJ4AEYRwJ+jIyYO7gcfsfKps3b2bNmjWsXbuWkydPEhUVRVxcHPn5+c2W37ZtGzk5OdYjOTkZpVLJ/fffby3z+uuv89Zbb/HOO+/www8/4OjoSFxcHDU1Nc22eTPDhw8nLy+vyfn8/PxWZcoWxpFAIOh1tGVKDcBO2cbNYNuwdQg05DkSAdmCPkc3TKu98cYbPProo6xatYrw8HDeeecdtFot7733XrPlPTw8rKvgfX192bt3L1qt1mocybLM+vXref7551m0aBGRkZF89NFHZGdns2PHjlZd9rp16/j1r3/N1q1buXHjBjdu3GDr1q08/fTTvPbaa5SXl1uP5hAB2QKBoNfRFuNIoZBQtnW1Whu2DgERkC3oX9TWGqitNVjl8oqqW5bV6/WcOHGCP/zhD9ZzCoWCWbNmkZiY2Kr+Nm7cyIMPPoijoyMA6enp5ObmMmvWLGsZV1dXJk6cSGJiIg8++GCLbS5YsACABx54AEmy/HiS64y8hQsXWmVJkjCZmiacFcaRQCDodbRpX7WObDrb1pgjkQRS0NdoRxLIdW9s5uXXN7WqbGFhISaTCR8fH5vzPj4+pKamtlg/KSmJ5ORkNm7caD2Xm5trbePmNut1LXHgwIFWlbsVwjgSCAS9DoOx92wdAmK1mqAP047VZn94+keseXyRVS6vqGJw5COdPTLA4jUaNWpUpyeWvuuuuzpUXxhHAoGg19GmTWfbGowNbdo6BBqSQIppNUF/QKOxQ6Oxa1VZLy8vlEplk+DnvLy8Jjtr3IxOp2PTpk28/PLLNufr6+Xl5eHn52fT5ujRo1s1LoCSkhI2btxokwRy1apVeHh4tFhX/AwSCAS9jm6bVmtlQHaNUQRkC/oq5oaptfYet9k+RK1WM27cOPbt29fQo9nMvn37rBvV34otW7ZQW1vLT37yE5vzwcHB+Pr62rRZXl7ODz/80GKb9cTHxxMUFMRbb71FSUkJJSUlvPXWWwQHBxMfH99ifeE5EggEvQ69oQ2eo/ZsOmudVmtlQLbwHAn6Kp2RxLGF+mvWrGHlypWMHz+e6Oho1q9fj06nY9WqVQCsWLGCgIAA1q1bZ1Nv48aNLF68GE9PT5vzkiTx9NNP85e//IVhw4YRHBzMCy+8gL+/P4sXL27VkJ944gmWLVvG22+/jVJp+dyaTCZ+9atf8cQTT3Du3Lnb1hfGkUAg6HXo2zCt1j7PUdum1WrEajWB4JYsW7aMgoICXnzxRXJzcxk9ejS7d++2BlRnZGSgUNh+TtPS0jh8+DB79uxpts3f/e536HQ6HnvsMUpLS5k6dSq7d+/G3r513t7Lly+zdetWq2EEoFQqWbNmDR999FGL9YVxJBAIeh1t2letPUHS7Q7IFsaRoI/RjtVqzbbRAqtXr2b16tXN6g4ePNjkXGhoqHVpfXNIksTLL7/cJB6ptYwdO5YLFy5Y91Wr58KFC0RFRbVYXxhHAoGg19GmfdXaNa3WtqX81SJDtqCv0g3Tar2RX//61zz11FNcvnyZSZMmAXD06FE2bNjAq6++ytmzZ61lIyMjm9QXxpFAIOh1GLs6INvYeuNIluUGz5FarGERCPoCy5cvByzTc83pJEkSSSAFAkHfQt/leY7qV6u1bBzpTWbMdT+cxbSaoM/RTdNqvY309PQO1RfGkUAg6HX0pgzZNfqGsYhpNUGfo59OqwUGBgKQkpJCRkYGer3eqpMkybqFyK0QxpFAIOh1tCXmqF1JINtiHNV5sZQKqX3xTQKBoNu5evUqS5Ys4dy5c9YpNMC6z1pzU2mNEZ90gUDQ62jTarUu9hyJHEeCPk1HE0B2xrRcD/DUU08RHBxMfn4+Wq2W5ORk4uPjGT9+fLOr525GeI4EAkGvoy3bh7TLm2MNyG45CWS950jEGwn6JLdPcN36NvoYiYmJ7N+/Hy8vLxQKBUqlkqlTp7Ju3Tp+/etfc+rUqdvWF54jgUDQ62jTtFq78hy1fvuQes+R2HRWIOg7mEwmnJ2dAcv+b9nZ2YAlFiktLa3F+sJzJBAIeh1tmVZTdfH2ISLHkaBP009Xq0VERHDmzBmCg4OZOHEir7/+Omq1mn//+98MGTKkxfrCOBIIBL2Oro85qt8+pGXPUW3d1iFiWk3QJzGDNRdFR9roYzz//PPodDoAXn75ZRYsWMC0adPw9PRk8+bNLdYXxpFAIOh1dFueI+E5EgjuSOLi4qyvhw4dSmpqKsXFxbi7u1tXrN0OYRy1AbPBiNlgvG2Z+nsuyw2vG3SNT8hwsyjZiE1lbiNLtu3LyEh1JeSb+m5ubDR5r9yut6aDs22/4dpu7qs5+XZd3ayXm962VnNz2SZdt1jgNrJs+Rvcqmyz96GFpptyUwm5DTe5q+SW/oDtlGv0profuw16SWrmbUo7l/K3IUO2NeZILYwjQR+kn+Y5ag4PD49WlxXGURu48vF3XP6oYQdh99AAqjNyrbLbcH/0Nyyy63B/jDkNOpcQf+SCPKvsEOSNXJRjlTWDfKAo2yqr/HyhkV7p5wclDXqFbwCUNbSnDApEMpVYZcnNB7m6sG5gfsi1xQ0X4uSDrG+QJWdfMJU16B0HgLm8QdZ42soOvqCobZDVA0DZYDSaUGOSKyyvzSoMcmlDX2gxyg1tybIztaYGWYELteYKq2yWXak0VjZcJ842sp3kQpne4jp1UDpSZtA1DFPlSKm+QXZUOVJiIztRVNvQlrPKicKaBtlVbSu7a5woaCS7qZ3Ir5M91c7kVzfovOydyK9q6MtT40SerqpBf7Ns70hORYM8wN6J7JvkrLJqq+zr5GiV/ZwdyG6k83N25EZpg+zvorWR/ZwduFFSY5UHujpwo7Shr0GuDmSVNJQf6GbPjeLGsgPZJVXW11nFDXUD3LVkN5bdHMgpapD9PW7SeziQ3Yz+ek4FRrMZjUqJvs5z4+6swdNZw8202XNkMoC57v3aioBs62q19nioBIKexmy2HB1to5/RbZ/2+Ph4Fi5ciL+/P5IksWPHDhu9LMu8+OKL+Pn54eDgwKxZs7h06ZJNmeLiYh566CFcXFxwc3PjkUceobKyEoFAcGdhbsMv1TYv5Tc0GGOtmlarz3MkPEcCQb+h24wjnU5HVFQUGzZsaFb/+uuv89Zbb/HOO+/www8/4OjoSFxcHDU1Db9wH3roIc6fP8/evXvZtWsX8fHxPPbYY911CQKBoJtoixe/zUv564OxkUDV1BN1M7V1weEi5kjQJ6mfVuvo0c/otmm1efPmMW/evGZ1siyzfv16nn/+eRYtWgTARx99hI+PDzt27ODBBx/kwoUL7N69m2PHjjF+/HgA/vnPfzJ//nz+/ve/4+/v32Vjl81mEr54l+r03RQHOOKWNYDSgAIk51RKvT0ZkO9DgXceenUKlW6eAJSbk6l28CKw2pfrDrk4Vp1FrxjAcLM/FxXZaApPYTJ4EW7nS4ohF9WNs8gmDyK1PpytykNKPw+yB2OcfThVkYdUkQKSO+M8fDhRnAcFF1CoPBnn68uJ3FzkrGQUrr5EDw8i6eI1zJWJKF18ATBVJKD08CM6cjhJZy9iKj6A0iuA6LFhJJ1MxVS0F6XPYCZOGsUPR89hKshE6R/ExKlj+OHwKUw511D6D2Hi9PH8cPC4RR4cxsQ5U/lhz2FMmRdRBo9i0vw5HP16D6ZryUhB4QCY089jDhpG1NwpnNmdgHQtDXPgMEbNncy53UeQrl/CMHgoI+ZM5sKeI6iuX0Y/eBjDZ0/m4t4j2GVcRjdwGIEzpnB9fwIOmZeoCBiO//QpZB9MwCnrIqV+YQC4ZqdS4heG+9SplBw+jFtOKmW+YThPmUpFwmGUualU+oShnTyVqiOHcchLpXZAGHYxUzEkHsYtPxXTgDAU0VMxJx1Gk58KA8KQJ0xFOnYYh4JUFAPCMI2fivL4YZwLUinxsvTtVphGqUcotWOnoTn5PR5FaZR7hFI9JhaHU/F4FadR4T4CXWQsjmfj8Sm5QKXrCCojpuOUfBC/0gvoXEZQHn43LikHGFh2gWrnkZSE3o172gGCylPQO4ZTMHQWAy5/R4guBYPDSACGVZ3HpB1JXvBsfNL3MrzqPCb7CHKC5uB3bQ+hNckWeXAcfhnfEl6TDOoIbgycy8AbuwmvTQZNBDcC4hiY9S0jLicj20WQHRCHf9a3hF1NxqyKINt/Dv7Zewi7loysigAg9FoyZtVIcnxn45e7l9CM85iVI8n1nY1v7l6GZ57HrBhJnvcsfPK/Y1jWeUzKBnlo1nmMynDyB8zCu+A7hmanYFSEc1WewEh9ApGGVM6aLfc4qiyNa9WjKPCaiX/5YYJrz5KuiUQigpO7P0J/JR51SCyRMx/k7L5Nt5bHxqACTCg4vfcTomYu57sLeRy9WsykIR7MGuFjIydnWaac8ysaTSULBH0Fs9wJq9X6n3EkyXL3m4SSJLF9+3YWL14MWPZACQkJ4dSpU4wePdpa7q677mL06NG8+eabvPfeezz77LOUlDTE1RiNRuzt7dmyZQtLlixp0k95eTmurq5kZmbi4uJiPa/RaNBoWv7FWM/3m/4/pqW+3PYLFQgEvZb6uPKf65/lO/O4VtV5d8V4Zof7dPHIBHcq9d9JZWVlNt9JXdlX6ckNuDi3vPDgtm1VVOM29oluGXdvoVcEZOfmWgKXfXxsHzo+Pj5WXW5uLt7e3jZ6lUqFh4eHtcytGDRokI28du1aZsyYwZgxY9i1a5eNbtq0aeTm5hIeHs7hw4cpKirCLW1/u65LIBD0XiQJjLKCSYqUVhlHEjIffJ3ACJfoJs+IegYNGkRYWBh5eXnY2dlx4sQJmzYeeOABEhISiImJYevWrTa66OhoqqqqCAgIIDk5maysLKvO29ub6OhoLl26hJeXFwkJCTZ1586dy5o1a3jnnXfYsWMH5kYBtJGRkdjZ2eHs7ExGRgZXr1616lxcXJgzZw7Hjh0jJCSE/fttn3VxcXEkJycTGxvLjh07qK5uCMwPDQ3Fy8sLs9lMWVkZKSkpVp1Go2Hp0qXEx8cTFRXF119/bdPu9OnTycjIICoqioMHD9r86A0MDCQkJMR67uZtHpYvX058fDzR0dFs377dRhcTE0NZWRlBQUGcPHnS5rvB19eXkSNH8uKLL/LMM89w8uRJm7pLliwhKSmJ2NhYPv30UxvdmDFjAHB3d+fKlStcv37dqnN3d2f69OmcOXOGwYMHN9m3a/78+Zw5c4bY2Fh27txJ99MZ02LCc9Q9nd7kOTpy5AhTpkwhOzsbPz8/a7kHHngASZLYvHkzr7zyCh9++GGTtN/e3t689NJLPP7440366SzPUcKOfzPl9G8xygpUkpmdRZO41/OoVd5VOokFbg0yYH39TUUM85wTrfK3VZOJ0x6xyntrYpht36D/rnYSszQNbe0zTGKmXYO83ziJGapGsimGGcqG+vsVU5hhTmh2LPvV05ih/76RHMsMfXyDbH8XM2oONcjau5lRdaBBdrybGbpGsvMsZlR8Z5UPOM/l7ordzfa9z3kWMxuV3es8k9kV+24pf+s8k7hG8jdOs5hX2VD/K8dZ3KP7rtm+vnSYzcLqvQ1/L4fZ3NtI3uEwm8WN5O0Os1nSSN6mmc3S2lvLn2tmc18juXHfW9SzuV+/95byZ+o5PKDfY5U3q2azzNig36Saw4PGBv0m5RweNDXIn0pzWC7vabbvT6W5LJcb7v8nzOXHNMgfM5eH2iLLc3lIaiSb5/KQovm/7yfmufy4ke4T01x+rGyQPzXFsVz57W3kOSxX7rml3LiveM8fEVu01Sonej9ITP6mdsubh77O75MHopQkTLLMz6cG85/D6VYZsL7urZ6j7vRI9GV6+j71iOfo+D9xceqg56iyGrfxT/ar91ev8Bz5+lpiY/Ly8myMo7y8POs0m6+vL/n5+Tb1jEYjxcXF1vq3wsXFBRcXFzZs2MATTzxhPX+z3Ny5evmgwci1bz9CVT0UzxxvPg7wxsOvhPICD7zzfdjs7YOrdzFVxZY8Ck5eJdSUezKk2o+dNb5o3YowVnsxwhzAbqMvdtpCzAZPItV+7ChwwsWzFsnozngXXw5U+oCqGMnswUQPHw6W+SArilEq3Inx8yG+yJuqmly0Tv5M8fUjPtcHs7kElasPd4UFczg1AGNFPnZuvlRWVKIx67Dz9GP6mFASTg3CUJyL3YAAhvm5kJATiLEoG5XPYO6eHEnCkSHoMi/hGBzG3XeNJeFQCMbsa9S4eTPn3rtJ2D/MInsMZM7980nYHY4x4yI13kOIW34fh3dGUPD/t3ffUVFe6QPHv1MYehHpiGAFUcSKwYINa2KaJq7rRk2M+a1RNybrrjG7qzExmh53Y5q60ZhNNdUk9ootwdiiUVEUu6CIgNSBmff3BzLMAOIA44zK8zlnzuG+9ZnLODze95a92/CNjUelVmNIOwgRrelydy82/dQGJS0FIlrR+e4ebPwpCuXkMYxNW9J2SA/WrYpEfSqVkvBWtBnUg9VrotCcSqWwSWuaDejJp9+G4XflPHmhrWnSvxffbGiD29mj5IRe63N0rqzPUePeCXy2JRrvC0c47RlK6JC7+d/WaHwvHOFSUBQePRP4aFs0jdOPcDEgCuceCfx7TVNa5J/lvH8U2vgEFu6MJvjSEc75R3G+SQsuno0m5OIRzvpHoXRL4N1fovE7u5+M0FgAmmYe4VTjKNKCW3LhQrSpfCKoFefTowm/fISTjaI5FtCK8xfbEp51iKQ8T7z6jebNQ+1oduUwx73akNuuP68fbEvznMMc82xLdpv+nDocQ8vcQxx1a0tm6wGcPNqe1vm/k+Je1u+ndf5BUtzacbH5QE6ciCHiym7SfLqQHjGIEyfbE1VwgMMuMVyIGMyJk+1pU3SAQ7oYzjUdwvHT7YnWHyRZH0FOmxEcP9OeaH3Z/guhgzl+7lrZKYYLIYP4LaU5XZ3TOOwUA0CbkgMc0bYjPXggvx1rRheXk6Ro25EeNJC09BgiSw6yuyicguYPciIjhkjD76Ro2rKXtpzQxhBVXlaiSdO2r9h/rdy69CAbz3sT2iSUWKej+LbtS8K9j7NvXX+KUrfg0rI38QP+yL51vWtdPrPjK8K6j2DkgD/ieyiDn09c5q7mjRkQHUi35o1NZcD089FNXzEg2vI7ozrVfbfcaF9tvo+suY+t1OUe1p7T0OtJ3LpuiZYjRVEICQlh2rRp/PWvfwXKst6AgACWLl1q6pAdHR3Nr7/+SufOZU3ga9euZfDgwZw9e7baDtmVs/To6GiLpt/K5eq2lZdzc3MZ6h3Js70eRnNt0jlbzXOUnJxMr+HDajXP0bfbfmb4gJ4V+6uZ54jCTJKTk4kbeB9UmucIfVbZvri4KvMcfbU6iREPDKg43rkxyT+vJy4u7lrwQSTv2kpct2tlnT/Ju3fQLS6OUkMpi5d+yiNjh6PVam06z1HyL8nEd+tfq3mO1m7bSFxcN6DmeY6Sf0mmf49+1c5zVF5Plec52vDDGnrdXTYLa/k8R+XHls9zVF4un+eovOylduabNWvp1asXWq3WpvMcbV+zirsS7zaVrZnn6Ju1m02/35rmOUpOTubBgb2rnecoOTmZBwb1qTLP0XerNtPt2rXL5zH6JTmZbnFxpnmOyuulfH95OcBDy/IV6+jVqxdDu4UzuIvlI/L6qO7fv63Oqem46+2rzfdR5fLNbJGQerKONe/ZIS1Hu/5tm5ajrk9Jy9HNkJeXR2pqqqmclpbGvn378PX1pWnTpkydOpU5c+bQqlUrmjVrxr/+9S9CQkJMCVSbNm0YPHgwEyZM4P3336ekpITJkyfzhz/84boj1crzvtzcsj++BoPB9HN15ZqOyc3NpRQjBaXFaChLjnT6IgpLKkawaIuLKLlW1hQXUaqv2KcqKkQpriiXFhWZygWlpeQWFkGR2bUqlTUFRVBYUS4oKSXXrKzJL0RlqPiDp9IWQlER+UUl5OYVQnHFPigAfSH5hXpy8wpRUQDGij+GBYV6cs3+MKN3Ib+guGJbST75+UXk5l5LNHSu5OcXkpubR6nBQGGhntzcfLPkqCIhUaFQqphdW1FTbKgoq9FQbKwoGxUt+aVl5xcWFJGXm0+eoeJ6TioN+dcSHqMG8s2SI6MWiguKKLh6bZsWCsySI7QqCorLyuXHFRabXdtJRWFxPvrCIgrz8nHWqyz2lxQVU5R3LTadmqLCfEoKiyjKy6ewVEVRgVm5BIryC01lJ3UppUVFFOfnU6rVUliqUJxf8TsoNGBRLjKUxWgqqxSKC8r2F6kNpp8BDPoi9AUVSVyRxojebH+R2oDe/FpOBgzFhaZzipwM6M36lhTpSk1lg76QooI89IUF1/YZTD9X3le+v1RfSHFhWT0VFRgpLiw0bSsqMFwrF10rGy3Lag2GkiL0hfnk512t8u+1Pqr792+rc2o67nr7avN9VLlcvs2W9XOjeG1xTkOrp/L9dm2TkNFqdWK3lqPNmzfTt2/fKtvHjh3L0qVLURSFWbNmsXDhQrKzs+nZsyfvvvsurVu3Nh2blZXF5MmT+eGHH1Cr1QwfPpz//Oc/eHh4VHvPs2fPVumMLYQQQjjSmTNnaNKkyU29h6nl6Jf5tmk56ja1QbUcOeSxmr0YjUbOnz+Pp6enVQvNCSGEEDeLoihcvXqVkJAQ1OqbOwdzeXJ05Ze3bJIcNer2dINKjm6JDtk3i1qtvunZuRBCCGEtb29v+95QHqvViaykKIQQQghh5o5uORJCCCEaNMVY9qrvNRoYSY6EEEKIO5U8VqsTeawmhBBCCGFGkqN6OnPmDH369CE6Opr27duzfPlyR4d0S8rOzqZLly506NCBdu3asWjRIkeHdEsrKCggPDycadOmOTqUW1ZERATt27enQ4cO1U4TIsqkpaXRt29foqOjiYmJIT8//8YnNUApKSl06NDB9HJ1deW7775zdFj1pyi2eTUw8litnrRaLfPnz6dDhw6kp6fTuXNnhg4diru7u6NDu6V4enqSlJSEm5sb+fn5tGvXjgcffJDGjRs7OrRb0ksvvcRdd93l6DBueTt27LjuPGeizLhx45gzZw69evUiKyurVutKNiSRkZHs27cPKJu0OCIiggEDBtR80u3AqICxnn2G5LGaqK3g4GCL9d/8/PzIysqq+aQGSKPR4ObmBkBxcTGKoth3ltjbyLFjxzhy5AhDhgxxdCjiNvf777/j5OREr169APD19UWrlf8T38iKFSvo37+//Ce3AWvwyVFSUhLDhg0jJCQElUpVbTPqO++8Q0REBC4uLnTr1o3k5ORqr7V7924MBsMdOSu3LeopOzub2NhYmjRpwt/+9jf8/PzsFL392KKepk2bxrx58+wUsWPYop5UKhW9e/ema9eufPLJJ3aK3L7qW0/Hjh3Dw8ODYcOG0alTJ+bOnWvH6O3Llt/lX375JSNHjrzJEduJYqNXA9Pgk6P8/HxiY2N55513qt3/xRdf8MwzzzBr1iz27NlDbGwsgwYN4uLFixbHZWVlMWbMGBYuXGiPsO3OFvXk4+PD/v37SUtL49NPPyUjI6Paa93O6ltP33//Pa1bt7ZYNudOZIvP07Zt29i9ezcrVqxg7ty5/Pbbb/YK327qW0+lpaVs3bqVd999l507d7Ju3TrWrVtnz7dgN7b6Ls/NzWXHjh0MHTrUHmHffEajbV4NjSJMAOXbb7+12BYXF6dMmjTJVDYYDEpISIgyb94807aioiKlV69eyrJly+wVqkPVtZ7MTZw4UVm+fPnNDNPh6lJPzz77rNKkSRMlPDxcady4seLl5aXMnj3bnmHbnS0+T9OmTVOWLFlyE6N0vLrU044dO5SBAwea9r/66qvKq6++apd4Hak+n6lly5Ypo0ePtkeYN1VOTo4CKFc2zlMMyW/V63Vl4zwFUHJychz9tuymwbcc1USv17N7924SExNN29RqNYmJiezcuRMoWytn3Lhx9OvXj0ceecRRoTqUNfWUkZHB1atXAcjJySEpKYnIyEiHxOso1tTTvHnzOHPmDCdPnuT1119nwoQJzJw501EhO4Q19ZSfn2/6POXl5bFx40batm3rkHgdxZp66tq1KxcvXuTKlSsYjUaSkpJo06aNo0J2GGvqqtwd9UgNZLRaHUnPvBpkZmZiMBgIDAy02B4YGMiRI0cA2L59O1988QXt27c3PeP++OOPiYmJsXe4DmNNPZ06dYonnnjC1BF7ypQpDaqOwLp6EtbVU0ZGBg888AAABoOBCRMm0LVrV7vH6kjW1JNWq2Xu3LkkJCSgKAoDBw7knnvucUS4DmXtv72cnBySk5P5+uuv7R3izaPYYBJISY5EbfXs2RNjQ3weW0txcXGmYbLCOuPGjXN0CLes5s2bs3//fkeHcVsYMmSIjHy0kre39x3ZF1LUniRHNfDz80Oj0VT5x5KRkUFQUJCDorr1SD1ZR+rJOlJP1pF6sl6DritZW61OpM9RDXQ6HZ07d2bDhg2mbUajkQ0bNhAfH+/AyG4tUk/WkXqyjtSTdaSerNeg66p8bbX6vhqYBt9ylJeXR2pqqqmclpbGvn378PX1pWnTpjzzzDOMHTuWLl26EBcXx/z588nPz+fRRx91YNT2J/VkHakn60g9WUfqyXpSV8KmHDtYzvE2bdpU7ZRXY8eONR3z9ttvK02bNlV0Op0SFxen/Pzzz44L2EGknqwj9WQdqSfrSD1ZT+rKkmko/+rZimHrK/V6XVk9u8EN5VcpSgPshi6EEELcwXJzc/H29ubKyufxcnep37Xyi2g09HlycnLw8vKyUYS3NulzJIQQQghh5o7uc2Q0Gjl//jyenp6oVCpHhyOEEKIBUxSFq1evEhISglptn7YJxaig1LNDdX3Pvx3d0cnR+fPn78hFYIUQQty+zpw5Q5MmTexzM1vMcN0Ae9/c0cmRp6cnUPZBbCjPSYX9JF9MY9elkwD46jy5VJhn2tfYxYNLBfmmsq+zOxfzCyv2O7tzscC87EZGnlnZxZ30qxVlPxd3zucWmcqB7m6czy3bH+ThyoXcimODPNw5n2NW9nSzKAd6uHI+u+JaId6unM8uMJVDvV25kF1ott+F81cKLY5Pv3Z8iLcrF65UnBvs40a6ednblfSsinODG7lywfxajVy4UNN+H1fSs8quF+Rb+VouZGRanpt+2ezevq5kmB0f1MiVDLP9Qb6Vyo1cuXjJrNzYhUsXy36HAb5uZF6s+H0G+Llz6VLF7zvA353MDPOyB5cuVpT9/d25dCnf4niL/X4eZF68WlEO8OTStbL5z/YuN5R73+jY+F7N6N6nOfWVm5tLWFiY6W+TuHXd0clR+aM0Ly8vSY6EzbkXeuJS6A6Aq84dF03F/65cXdxxMWs1d3X2wEWlvn7ZxR1nxbzsgbOxouzi4oFzqaai7O5uKru4u1bZpysxL7tVKrui01f803dxc0WnV1uWi82Od3NBV6SptF9d8XOR+blulcquOBda7neu1X43nAtVZj9XOte10rEFqkrlSvvzzfa7uuHsUlF2rVJ2xdml/Gd3XMz6tJaVlZrLzpXL3GC/sdpyTftudrmh3PtGx7q7e9r0b4hdu3kYrr3qe40G5o5OjoS4WTIzMzmbdpI8fQ4ApUXZFDipcW/kTeixzURm/sYJ79acb96DkBPbaZ59lGNekZyP6EnIyW20vFY+27QXTU5vpWVOCikekZwOS6DpmSRa5aZwxL0Np0IT8ExJokXeEXCNIiO8N4GnttCyIAWVSxQArYuOoHGJIr1JH4LObi4rO0dzPrQPIec2E1l8CI2uohxVfAidUzRngvsSdmETUSXXykF9CEvfTFTJIZy00ZwL7ENoxmbaHD+E1imac/59CL20mTZph3DSli1eGnXyMFpNFOf9+xByaTORp4+g1URxwa8PwZnXyuoo0v16E5S5hdbnjqCxKB9GrY4io3FvAi9vofX5I9WWAVqlX9vXKIHAK0llZaLI8OlFYPZWWl06AkRx0asnAbnbaHm5rHzJqyf+udtokXUERYkk07Mnfle30fxKCkalNZe9etI4dxsR2UcxGFuT5d4T3/xtNM1LobS0NQBhBUcpLW1Njkt3vIt20OTcUfSlrclxjse7eCeh546iL2lFrnM8XsU7CT5/jOKSVuTq4vHS7yT4wnXKTnfhVfIzwRnHKNa34qpTNzxLfiEo4xhF+lYApp8r77vZ5YZyb2vuVbjjA7bnJtLjgYl2+X6xKXmsVid39FD+8qGMDWn4obC9U1czcVJrrr205F7J5pdf93Mg8zKpF4+DCjw9Ayk25NPH4zzj0hY7OmQhxE2wo9MbdL/38Tqfb8+/SeX3yvr2XzYZyu/7wIsN6m+ptBwJUQOjovDj6X0W2y6dPkfaqSt4tGhJekouKo0Tnm1DuHz4EKH5v6EAMjZSiDuLQVFRcnwbUPfkyCFssfxHAxytJvMcCVGDEmPVh+2unh44a0q5mHIYZzcNOheFC0cOoVIVczawvUVitMF/AACGa1vX+Q20KK/xtSyv8i4vl/3TXKq+G4DSa/2RllUqW+xT3WNRXkrl8rD6lRXL61nsM1a6l8GyvMxwd73KNR5beoNyiWX545KhNZb/V6ls/vMnxUNqLhcNrlX508rlQstyTftudrmh3NvaYzUqBacWPbntGBUw1PNlRXL0zjvvEBERgYuLC926dSM5ObnG47Ozs5k0aRLBwcE4OzvTunVrVq5cadr//PPPo1KpLF5RUVH1rg5ryWM1IWqQV1LER0e3Vd1+JYf0y5kUO5c1vhryilC5udIiJJz/W/kYXvps1oUPZ2/sn2iSupkWWYc56hPNmeZ9CTuxiVZZh0nxjuZ0s340TdtI6+xDHPaM5mR4fyJObSAq5xC/e7RjRUkPAk9up7fuEGe925LZegB+R9fROv93UtzbAdA6/yApbu242HwgASfWEllwkCOuMaRHDCLo5BqiCg5w2CWGCxGDCT65mjZFBziki+Fc0yGEnl5FtP4gh3TtOBc2mNAzq4nWl+2/EDqY4HPXyk4xXAgZRPD5NUTrD3DYKQaANiUHOKJtR3rwQIIurCWq9CAp2nakBw0kKH0tkSUHSdG05WLgQAIy1hJp+N2iHFVeDhhAwMV1FfvNykfV0WXv03iIo+poLvkPwP/SOlobf+eoqi2XGyfS+PJ6Wht/55iqLZd9+9M4awOtlN9JpS1Zvv3xzdpAK37nGNFc8elPo+wNtOIQx5Q2ZPv0xyd7A604zHFjG7K9+uGTu5GW6kMcN5T1rWqhPsyJ0ijy3PrgUbCZ5tojpJVGkefaG4/CLTTTHiGtJIoClwTcipLK9pdEUeCcgFtxEs2cqpZPlkRSoEvATZ9EhFMKJ4sjKdT1wlW/lQjnsjJg+rnyvptdbij3tuZerb2O49O+X70eqYGDHqst/wdebvV8rFZQhO9DL1037i+++IIxY8bw/vvv061bN+bPn8/y5ctJSUkhICCgyvF6vZ4ePXoQEBDAc889R2hoKKdOncLHx4fY2FigLDn66quvWL9+vek8rVaLn59fvd6LtSQ5EqIGWcX5fJa6s9p9V4oLydaXDYnXqjQUG4yEujXi/1Y/jmdRFh8lvE6GTwsAGjt7kJFfMUzcr3LZxZ0LVyvK/i4enL9awN5jhRw5VUzH5h40D60Y7hTk4c65a8Pzgz1dLYbqB3u6c9Z8KL6Xm0U52NOVs1cqhvI38XblrNlQ/jBvV86ZDadv4uPC2Szzsivnrw3Xb+Ljyrkss2kAGrlx3rzs48oFs+HyIb6V9vu6cr6m/Y3cuHC5bAh8cGO3StdyJf2S5bkXMiuGy4c0diM902xof2M30s2G0wc3diPd/HhfN9LNhuuH+LmScW14flBjdy6ZDdUP9HfnotlQ/MAAdy6lm5c9uGhWDgh052JGxbUDA90t9wd4cCm9Yuh4QJAnF6+VzX+2d7mh3PtGx/bs24Je/VtQX45Iji5/+ZxNkqPGD8+9btzdunWja9euLFiwACibgDksLIwpU6bw7LPPVjn+/fff57XXXuPIkSM4OTlVe8/nn3+e7777jn379tUr9rqSx2pC1KDEWGr1seprj8Z0pWWJhF7rWu/7l5aW/d/FSSO9mIQQdVDe56gWr+LiEnLzCs1eRde9vF6vZ/fu3SQmJpq2qdVqEhMT2bmz+v9Yrlixgvj4eCZNmkRgYCDt2rVj7ty5GAyW3RiOHTtGSEgIzZs3Z/To0Zw+fdo2dWIF6ZAtRA1KDNZP8KFSqUBR0JWWfZHYIjkqMZQlRzqt/D9GCGEfryzfyoufb7bq2MzMTAwGA4GBgRbbAwMDOXLkSLXnnDhxgo0bNzJ69GhWrlxJamoqTz75JCUlJcyaNQsoa41aunQpkZGRXLhwgdmzZ9OrVy8OHjxol0k0JTkSogbVdcgu56NzwVt3rblaUfB19mBEWDSq78sSmsc7JoLOvXw35vO+KYrliLbKI9zKn3VPOreXU+kXGdA6lJFdm1oeoajMLlb54nYqK9VFfrPK16sl21GZXbLy23RkFcu9HXsvjeY2/s9JHUarTR/ek6n33mUq5xYU0+zxt2wXktFIQEAACxcuRKPR0LlzZ86dO8drr71mSo6GDBliOr59+/Z069aN8PBwvvzyS8aPH2+zWK5HkiMhaqCv4bGaSqWq+FOtUuGidcK5tLh8A84uXpbfsHVQqC9LznxcdbhoNTc4WgghLCnGsldt6DRadJqK9KCm8/38/NBoNGRkZFhsz8jIICgoqNpzgoODcXJyQqOp+E5r06YN6enp6PV6dDpdlXN8fHxo3bo1qamptXszdXQbp8NC3Hw1tRxVptNoQX+tk63Oo96JEUB+cVly5q6T/8cIIW49Op2Ozp07s2HDBtM2o9HIhg0biI+Pr/acHj16kJqaitFYkXUdPXqU4ODgahMjgLy8PI4fP05wcLBt38B1SHIkRA1q0yHbSa2B4msjXJw9bHL/vPLkyFmSIyFEHRgVMBrr+ar5sdwzzzzDokWL+Oijjzh8+DATJ04kPz+fRx99FIAxY8YwY8YM0/ETJ04kKyuLp556iqNHj/LTTz8xd+5cJk2aZDpm2rRpbNmyhZMnT7Jjxw4eeOABNBoNo0aNujn1VIl84wpRA31tWo7UWtBnXSvYJjnKLy67v4ckR0KIurDDDNkjR47k0qVLzJw5k/T0dDp06MDq1atNnbRPnz6NWl3RFhMWFsaaNWt4+umnad++PaGhoTz11FNMnz7ddMzZs2cZNWoUly9fxt/fn549e/Lzzz/j7+9fv/diJfnGFaIGekNtW46uPVazUcuR6bGas/Q3EkLcuiZPnszkyZOr3bd58+Yq2+Lj4/n555+ve73PP//cVqHViSRHQtSgNn2OnNSV+hzVk6Io5OvLkiNpORJC1IWiXBtUWs9rNDTyjStEDWqXHGkqkiPn+s/DUVRiNLVmS58jIUSdlK+PVt9rNDDSIVuIGtRutJrZY7Vr8xvVR3lnbABXJ3msJoQQ9iL/HRWiBjXNc1SZzsaP1SqG8WtQq2X5ECFEHdihQ/adSJIjIWpQ68dqNhzKL8P4hRD1Z4NORzdhNvpbnTxWE6IGtRutZt5yVP8+R+UtR9IZWwgh7Eu+dYWoQa36HNl4KH/BtaVDpOVICFFn0iG7TuRbV4ga1H60Wn5ZwQZ9jvJkjiMhRD0pioJSz8dq9T3/diSP1YS4DqNipFSpRXJksbZa/UerybpqQgjhGPKtK8R11KbVCCp3yK5/nyPpkC2EqDcZrVYnt3XL0csvv4xKpWLq1KmODkXcgWqzrhpc63Nk06H80udICFFPRhu9GpjbNjnatWsXH3zwAe3bt3d0KOIOVZuWI61KjVqltmmH7IqlQ6TPkRBC2NNtmRzl5eUxevRoFi1aRKNGjRwdjrhDldRiAkgn9bXWnZsxCaS0HAkh6kgxKjZ5NTS3ZXI0adIk7r77bhITE606Pjc31+JVXFx8kyMUd4ISQy1HqhmNNl1bTeY5EkLUW3mfo/q+Gpjb7lv3888/Z8+ePezatcvqc8LCwizKs2bNol+/fnTs2JEff/zRYl+vXr1IT08nOjqabdu2cfnyZYvrREVFkZGRgZOTE7t377Y49+GHH2b79u3Ex8fz1VdfWeyLi4ujoKCA0NBQDh48yLlz50z7AgICiIuL49ixY/j5+bF9+3aLc++77z5+/fVXEhIS+OKLLzAaKx4At2/fHicnJzw9PTl9+jQnTpww7fPy8mLgwIHs2rWLFi1asHHjRovrDho0iIMHD5KQkMB3331HYWGhaV9kZCR+fn4YjUZycnI4dOiQaZ+zszMPPvggSUlJxMbGsnLlSovr9unTh9OnTxMbG8vmzZu5cuWKaV94eDgtWrQwbdu7d6/FuaNGjSIpKYm4uDi+/fZbi33x8fHk5OQQERHBnj17SE9PN+0LCgqiU6dOnDx5Em9vb3bu3Glx7gMPPEBycjIJCQl89tlnFvs6duwIQKNGjTh+/DinTp0C4KqzQpa/Fh8fH/Lz8nB2cSH7SrbFuY0b+5KXl0/jQA++//pz7ru2/cvvVxHZrgPe3t6o1WoyMzNJSUkxnefq6sr9999PUlIS7dq1Y82aNRbX7devH2fSLwFwIuUwn539xbSvefPmNG3alKtXr1JSUsJvv/1m2qdWqxk5ciRJSUl06dKF77//3uK6PXr0IDMzk1atWpGcnMzFixdN+0JDQ2nXrh3nzp3Dzc2N5ORki3NHjBjBzp076dGjB19++aXFvs6dO1NSUkJgYCBHjhzhzJkzZnXUmJ49e3Lo0CGCgoLYunWrxbn33HMPe/fuJSEhgeXLl1NaWtFi165dO9zc3HB2diY9PZ1jx46Z9nl4eDB06FB27txJVFQU69ats7jugAEDOHLkCPHx8axcuZK8vDzTvlatWhEUFERxcTEFBQUcPHjQtE+r1fLQQw+RlJQk3xHyHQFc/zuifFufPn3Yv38/TZs2ZfPmzRbnDh06lP3795OQkMCKFSsQtweVchtNYHDmzBm6dOnCunXrTH2N+vTpQ4cOHZg/f36V43Nzc/H29ubMmTN4eXmZtjs7O+Ps7GyvsMVtKiX7AuvP/W7VscFuPjzo1wTeiASVGmZmgap+66GNWvgzO09c5t9/6MB9HULrdS0hhOOV/03Kycmx+Jt0M++V8foUvFzr9/cut7CYwGlv2yXuW8Vt1XK0e/duLl68SKdOnUzbDAYDSUlJLFiwgOLiYjSaqp1Xvby8GswvVNhO7ddVM+tvVM/ECMw7ZN9W/0yFELcQmQSybm6rb93+/ftz4MABi22PPvooUVFRTJ8+vdrESIi60teiQ7ZOrQX9tTmObNAZG2SeIyGEcJTb6lvX09OTdu3aWWxzd3encePGVbYLUV+1bznKLivYYBg/QMG1eY6k5UgIUWdGG6yt1gA7ZNtttNrq1avZtm2bqfzOO+/QoUMH/vjHP1p0xhPiVqE31GYov20ngAQZyi+EsAHFRq8Gxm7J0d/+9jdyc3MBOHDgAH/9618ZOnQoaWlpPPPMM3W+7ubNm6vtjC1EfdWu5UhbseisDVqOFEUx9TmShWeFEMK+7PZf0rS0NKKjowH4+uuvueeee5g7dy579uxh6NCh9gpDCKvVJjnSaczWVbNBy1FhicHUki0Lzwoh6koxqlCM9RsgUt/zb0d2aznS6XQUFBQAsH79egYOHAiAr6+vqUVJiFtJ7Ttk2+6xWnlnbJUK3HTSciSEqBuZA7Ju7PZf0p49e/LMM8/Qo0cPkpOT+eKLLwA4evQoTZo0sVcYQlitzkP5bbGuWvmiszotKhtMCyCEEMJ6dms5WrBgAVqtlq+++or33nuP0NCySe1WrVrF4MGD7RWGEFardXJ0U9ZVk1YjIUQ9KCrbvBoYu7UcNW3atMo0/ABvvfWWvUIQolZqM1pNp9ZW9Dmy4bpqMlJNCFEfilL2qu81Gpqb+s1bm75EMoO1uNXUquVIY+OWI5kdWwghHOamfvP6+PhY3V/CUIsV0IWwh5JadMi2GMqvc6/3vfOu9TmSzthCiPpQjGWv+l6jobmpydGmTZtMP588eZJnn32WcePGER8fD8DOnTv56KOPmDdv3s0MQ4haMypGSmvxjWD7DtnSciSEqD95rFY3N/Wbt3fv3qafX3jhBd58801GjRpl2nbvvfcSExPDwoULGTt27M0MRYha0dfikRqATq0xW1tN+hwJIcTtzG6j1Xbu3EmXLl2qbO/SpQvJycn2CkMIq9SmvxHcxKH8khwJIeqhfBLI+r4aGrslR2FhYSxatKjK9sWLFxMWFmavMISwSm2SI61Kg1qllg7ZQohbTvljtfq+Ghq7ffO+9dZbDB8+nFWrVtGtWzcAkpOTOXbsGF9//bW9whDCKiW1XXQWbNpyVD5DtiwdIoQQ9me3lqOhQ4dy7Ngxhg0bRlZWFllZWQwbNoyjR4/K2mrillObPkc6jQaMRigpH61myz5HMlpNCFF3iqKyyauhset/S5s0acLcuXPteUsh6qTWw/jLEyOwyVB+6ZAthLAJ5dqrvtdoYOz6zZudnU1ycjIXL17EaLQcJj1mzBh7hiJEjeq8rppKDU6u9b5/niRHQgjhMHb75v3hhx8YPXo0eXl5eHl5WUwOqVKpJDkSt5TaJEc6tdasM7Yn2GCh2AJ92f095LGaEKIeFKMKYz1Hm8lotZvor3/9K4899hh5eXlkZ2dz5coV0ysrK8teYQhhFX2tHqtpzNZVq39nbJAO2UII25DRanVjt+To3Llz/OUvf8HNzc1etxSizvS1WM7GSW3bddVA+hwJIYQj2S05GjRoEL/++qu9bidEvdSmQ7ZOo7XpMH6omARS5jkSQtSLAhjr+WqALUd2++a9++67+dvf/sahQ4eIiYnBycnJYv+9995rr1CEuKFad8i24aKziqKYJoF0kz5HQoh6kLXV6sZuydGECROAsjXWKlOpVBhq8RhDiJutNn2ObL2uWoHeYPoykpYjIYSwP7t981Yeui/Erax2LUe2faxW3mqkVoGrk7QcCSHqzhaTOMokkEIIoC6P1Wy4rlr5orM6rcWUF0IIUVuKsexV32s0NHZLjqp7nGZu5syZdopEiBvT12JtNZ2tW45kpJoQQjiU3b59v/32W4tySUkJaWlpaLVaWrRoIcmRuKXUquVIY9s+R3myrpoQwkakQ3bd2C052rt3b5Vtubm5jBs3jgceeMBeYQhhlTqPVrNhy5F0xhZC1JdiVNV7hmuZIdvOvLy8mD17Nv/6178cGYYQVdRuhmyzx2q2WHT22tIhbjI7thBCOITDv31zcnLIyclxdBhCmBgUI4Za9EDU2bxDtvQ5EkLYhjxWqxu7ffv+5z//sSgrisKFCxf4+OOPGTJkiL3CEOKGavNIDcpbjsrXVqt/n6OKx2rS50gIUT/yWK1u7JYcvfXWWxZltVqNv78/Y8eOZcaMGfYKQ4gbqn1yZNuWozxpORJCCIeyW5+jtLQ0i9fx48f5+eefmTt3Lp6e9f/fthC2UlKLYfxalQa1SnVThvJLh2whRH2VP1ar7+tG3nnnHSIiInBxcaFbt24kJyfXeHx2djaTJk0iODgYZ2dnWrduzcqVK+t1TVtySIfss2fPcvbsWUfcWogb0tei5Uinufboy6YtR9cmgZTkSAhRT/ZIjr744gueeeYZZs2axZ49e4iNjWXQoEFcvHix2uP1ej0DBgzg5MmTfPXVV6SkpLBo0SJCQ0PrfE1bs1tyZDQaeeGFF/D29iY8PJzw8HB8fHx48cUXZWkRcUspqdVINQ0YDVBSULbBBslRQfmiszrpcySEuPW9+eabTJgwgUcffZTo6Gjef/993Nzc+PDDD6s9/sMPPyQrK4vvvvuOHj16EBERQe/evYmNja3zNW3NbsnRP/7xDxYsWMDLL7/M3r172bt3L3PnzuXtt9+WofzillLrddXK5zgCeawmhLi1KLV/FZeUcrWo2PTKKy6+7uX1ej27d+8mMTHRtE2tVpOYmMjOnTurPWfFihXEx8czadIkAgMDadeuHXPnzjUtQF+Xa9qa3b59P/roIxYvXsy9995r2ta+fXtCQ0N58skneemll+wVihA1qk1yZDGMX6UBrUu97y8dsoUQtlKX0WrvJO/k379sterYzMxMDAYDgYGBFtsDAwM5cuRIteecOHGCjRs3Mnr0aFauXElqaipPPvkkJSUlzJo1q07XtDW7fftmZWURFRVVZXtUVBRZWVn2CkOIG6rzBJDOHmCDhWLLF56VliMhhCM82aU7j3fsZirn6YuJ//Btm13faDQSEBDAwoUL0Wg0dO7cmXPnzvHaa68xa9Ysm92nPuz2WC02NpYFCxZU2b5gwQKL54xCOJreUNulQ2y3rhrIJJBCCNsxKrV/OWm0uOucTS83J+frXt/Pzw+NRkNGRobF9oyMDIKCgqo9Jzg4mNatW6PRVPSrbNOmDenp6ej1+jpd09bslhy99tprfPjhh0RHRzN+/HjGjx9PdHQ0S5cu5bXXXrNXGELcUG06ZOs0WpsO4wdZeFYIYTuKUUEx1PNlvP5wNZ1OR+fOndmwYYNpm9FoZMOGDcTHx1d7To8ePUhNTbUYjHX06FGCg4PR6XR1uqat2eW/piUlJcyePZuVK1eydu1aDh8+DMCDDz7Ik08+SUhIiD3CaLAUowGUitYQRan09EelQaV2zB9iRTGiYDZaUQFU5vurls1Dr82s9pWPrXRp03DVwtISlGrGrqpQWZ5AeZ+jax2ybTBSDaBAL4/VhBC3j2eeeYaxY8fSpUsX4uLimD9/Pvn5+Tz66KMAjBkzhtDQUObNmwfAxIkTWbBgAU899RRTpkzh2LFjzJ07l7/85S9WX/Nms8u3r5OTE7/99hvBwcHMmTPHHrcU5i4ko5z/paLsEYiir+jnpQrsCkFxDggM8kpSuVpy1FRW40Wx8aqpbFS8ySvNM5U1eFqUnVRe5FxLTlw17uSUVIwcc9W6k202ksxd684Vi7IHl4srruWp9SCzKI9LRfnklejRqDQWnbM9da54Oll2uLacHbv+i84qikK+aSi/JEdCiPopf1RW32vUZOTIkVy6dImZM2eSnp5Ohw4dWL16talD9enTp1GrKx5UhYWFsWbNGp5++mnTwKynnnqK6dOnW33Nm81u375/+tOf+O9//8vLL79c52vMmzePb775hiNHjuDq6kr37t155ZVXiIyMtGGkoqEz1mKVRSe1xqbrqhXoDaYWLGk5EkLUl2KE+k4laM063JMnT2by5MnV7tu8eXOVbfHx8fz88891vubNZrdv39LSUj788EPWr19P586dcXe3/F/2m2++ecNrbNmyhUmTJtG1a1dKS0t57rnnGDhwIIcOHapyPSHqqjYrUJfNc2S72bHLO2OrVeDi5JAJ7IUQosGzW3J08OBBOnXqBJR1vDKnsnL48+rVqy3KS5cuJSAggN27d5OQkGCbQO8wO1YspiRlDVpvP+I7RrJzbwqlWZvR+jchvksbdv56mNKsLThFDqT7vY/DkZVwcitE9IKooexb9ylFxzbj0qoPHQb80eaxFaeup7RpM9oO6cHvq7ajPpVKSXgr2gzqweE129GeOkZBk0iaDehJ2rptuJxJIS80kib9e3F2w1bcz6aQHdoGAO9zh7kS3IbGvRO4vCUJnwuHyQlug3evBHK2JqG5cJi8oDZ49Ewgb1sSLumHKQ5og3OPBIq3J+GdcZhS/zYYYzvivXcXEZePkebbiuyOXfHZu4vmWalkBLZD6ZaA8/5fCEw/yMXWfUnP+Jkg4NLF8/gD6w5lsPP4ZeJbNGZAdGCtyi38y5J8jVrF+sMXGRBtnyZkIcSdSTFa1/Jzo2s0NCqlup6nt4nU1FRatWrFgQMHaNeuXZX9ubm5eHt7c+bMGby8vEzbnZ2dcXa+/tDE25Wiz4czO8HVF1x92bFpJT1+m2HqgJ2juOKtKrxuuVjjjrMh39RRuUTriVPpVYyKCrVKYV+P9+qcIJUYL1FivIxG5Y5G5cEvP3xJj71/tzq2G5UBm12rLvcuN4W/80NRB1PZ00XL1aJSq8vuOg35+op+TovGdJEESYg7RPnfpJycHIu/STfzXsljn8FDV7+/d3n6YuI+etMucd8qbttODUajkalTp9KjR49qEyNzYWFhFuVZs2bRr18/OnbsyI8//mixr1evXqSnpxMdHc22bdu4fPmyxXWioqLIyMjAycmJ3bt3W5z78MMPs337duLj4/nqq68s9sXFxVFQUEBoaCgHDx7k3Llzpn0BAQHExcVx7Ngx/Pz82L59u8W59913H7/++isJCQl88cUXFsMf27dvj5OTE56enmSm7sYvY6NpX9GhQxiVskc0AN6qQqDiD3rlsrOhrLNy+d97p9KyvjRqlUKpouZ88rcczlTh7OzMgw8+SFJSErGxsVVWUu7Tpw+nT58mNjaWzZs3c+XKFUKblRAQUoqLiwuurq4UHl1lkVzcKLYbletzri3uDWBQVMQaDvADHUzbzBMfa8rmiZFaBTtSL6FP+5Xc3FzT9ubNm9O0aVOuXr1KSUkJv/32W8U5ajUjR44kKSmJLl268P3331tcv0ePHmRmZtKqVSuSk5MtFnEMDQ2lXbt2nDt3Djc3tyorYI8YMYKdO3fSo0cPvvzyS4t9nTt3pqSkxDSD7ZkzZ0z7GjduTM+ePTl06BBBQUFs3Wo58+4999zD3r17SUhIYPny5ZSWVtRJu3btcHNzw9nZmfT0dI4dO2ba5+HhwdChQ9m5cydRUVGsW7fO4roDBgzgyJEjxMfHs3LlSvLyKjrft2rViqCgIIqLiykoKODgwYOmfVqtloceeoikpKQ77jvi9OnTnDhxwrTPy8uLgQMHsmvXLlq0aMHGjRstrjto0CAOHjxIQkIC3333HYWFhaZ9kZGR+Pn5YTQaycnJ4dChQ6Z9dfmOKBceHk6LFi1M2/bu3Wtx7qhRo0hKSiIuLo5vv/3WYl98fDw5OTlERESwZ88e0tPTTfuCgoLo1KkTJ0+exNvbu8oyFA888ADJyckkJCTw2WefWezr2LEjAI0aNeL48eOcOnXKtK9Ro0b06dOH/fv307Rp0yr9a4YOHcr+/ftJSEhgxYoViNvDbdtyNHHiRFatWsW2bdto0qRJtcc0uJaj83tQUiv+QOw8eIIeFz83lbepO9HTuAeDokKjUtim7ULP0l9N5ZONuhBx5VcUlQqVorDXdwgds1aZzq9Py9HVkl2UGCv+EO/+YhUDTnxsSpA2u8TRpyjZFMtml3j6FO00lTc6d6df8Y7rlgHTz+t13UnUV+xbp+vOALPyWl13BpqV1zh1Z1BJRXm1tjuDS69f3ukxgPi8dZXurUajMvJh2FxeOBaBWlU2wmNEp1C+2nOu1mWNSoVBUaTlSIg7iCNajn75k21ajrr9T1qObnmTJ0/mxx9/JCkp6bqJkTkvL6+G8QsttFyGpUtUOKUZarQqI0meg+nZsQnbj4VTcjkDJ/9gundpxhtrOuGdd4Z8n2b8ZWgrlLOxkJGKEtiStYWP4v/zLpqoM9nZZDzx9ehzZFTyLcpewcFwArLxILndSNoMimXNmhg0p05Q0jSS6MEJrF7TCc2pVAqbtKbZgJ6sWNcZlzNHyQttTZP+vfhmQ2fczh4lJ7RsWRrvc0e4EhxF494JfLalK94XjpAVHIV3rwT+t7UrvheOcCkoCo+eCXy0rSuN049wMSAK5x4JfLi9KwEZRzjvH4U2PoGFO7sSfOkI5/yjUHVL4P1fuhKRmYpXZD+63/t4WV+s1C24tOwNYPr5sQF/JOxQBj+fuMxdzcv6FA1qF1yvshBC1JVRUWo1Avd612hobquWI0VRmDJlCt9++y2bN2+mVatWNR5vzyz9VmA8uByyKprMz16+StP9b1Oo6HDq8SfUahV4upQ11Wi0oNay9Kg/L+wNY1B4Ee8n5lhcb+L2SO47Poshml383Hoad/3xX3WKS1GMZOtXo5hNw3hw+SoSUj9ml1tXAic+UvEe0ILijkrlVFZ2wDxH5bx1luXO/s3p4t+8TnUghBCOaDnaOfppm7QcxX/yVoP5Wwq3WcvRpEmT+PTTT/n+++/x9PQ0PU/29vbG1dXVwdHdAgouWxQvX8mhKXBeFUCz8o5HirFs9fhrPYuaexYBkJZT9aNwIrOAE0owAKrLqXUOy6gUWCRGANqsCwAUelWzTo5Kls0QQghbkNFqdXNbJUfvvfceUNaZz9ySJUsYN26c/QO6hSjGUii2bPkpupoNQLaTf8VGg1K2ot613sTNPIsBOHlVg8EImmtT6xiMcPKKnhNK2dIu7nkn6xybodIjNQCPvLLkSPELsNiuQoUdl/wTQog7mtGoYKznFNn1Pf92dFslR7fRE0D7K8qusniYurCsJUnv4gflCZKqBFQGcA9GpVIT6go6jYLeoOJ8vpowz7L/IpzPV6M3QJqqrGUnoPh0nUMzKnlVtgXqy5Ijj5Aw3J18Tds1eOPl3N1UdsTaatc7QKOSpE0IIRqC2yo5EjUoyKqyyUN/CQCtuy+U/2FXNKAClbrsV6/RQDOvUlKuOHEiR0uYpx6AE9ces131iIASCCCL/KvZuHv61Dq0yi1HRflFhFAWr1+zEFRmSYeT2gu1yuxjWXl+UOvmCxVCCIF91la7E8l/he8UhVeqbAowlA2d9/T2rtioXOuMbaaZd9ncOidyKvr6lP/cvGkYVyjrgHfhxO91Cq3ySLVLaWV9xa7ggaev5ZIbapUsAyOEELZiNILRUM9XA+xzJMnRnaLQsjN2XlEJ/qpsAIIamS2IalSjUjtZHNvclBxVJE3lPzf3dSLDqWy6hOyzh6iLyi1HeefLkqN0bUiVYzWSHAkhhHAwSY7uEEqllqP0rLLZrbMUT7zcKg3j1FiWm3mVzUicZtZyVP5zM2+FXPcIAEoyjlFbilKKkWKLbcaL5wHIca86Uk1ajoQQwnYUxTavhkaSoztFpT5HObllI9cyNJUnEVSBzsdiS3nLkflw/vKfm3uXYvBtCYBT9vFah2WopjO2Lrus5ajER1qOhBBC3HqkQ/YdQCkphJICi22leWXJ0lXzYfzlXBpDcYap2My7rOXofL6GghJMPwM09yzkVFBrOAHeBaeqXOpGqhvG71NYNlJNE2DZcqRWuaBSyUdSCCFsRYby1438JboTVNMZ2+laHySDq6/lDhXgFmiRHDVyUWjkbORKsZqTuRUfCR9nI420V7kaFg1AcMlZFKMRldr6BsfKnbEVo0JwaVly5Nkk2GKftBoJIYSN2WASSKRDtrgtFVYdxu9dWjaM39mjkeUOZy9wblzl+PLWoxM5moqRat6loM8hqFkbDIoKD1Uhl9PPVDm3JpVbjnIzc/GiAKOiwi/c8pGfWmU5ck0IIYRwBEmO7gSVkiPFqBBiLGsZauTjbXmsqy/oqq6NY97vqHykWjNvAxgK0em0pKvLZrLOOFm74fyVJ4C8fKqs1Shd7Yezq85in7QcCSGEbZUvPFvfV0MjydGdoFJydDmvCHdVEQZFRVAjy9YYlasvOFWXHFW0HKWZtxwB6HPIdG4KQN65w1aHpShKlZajwvNlydElXXCV4yU5EkII2zIabfNqaCQ5ugMolUaqXbySC0C6yg9np0qLuLo2KpvnSOtmsbl8Isi03IqWo/LWJPS5FHo1K7tXpvXD+RWKUTBYbFNdLkuO8jyrJkcyjF8IIcStQDpk3+YURanSITs/NxuATE0gVVIQt2v9jZy8obRihJt5y1G58vmPKMlB5dcKLoJLbprVsVU3jN8ttyw5MvhaRqZChRq3KscLIYSoO8WooNRztFl9z78dScvR7a74KhhLLTYZC8qSpcJqOl5TPnpNZ9kXKdzTgAqFq3o1V/VqVChEeJW3HOXgHhIFQOMi6xegrTxSDcC3uGyOI5cgy+RIrXJHpZKF04QQwpbK11ar76uhkZajWjCWlGIsKa3xmPK/74pS8XPFvkrryVcuqiyKVctULSu5F6qM03QtKhuphlulYfxqTdloNaiSHDlroYmngTNXyz4SoR4GnLXX/kXos/Frem04vzEdfVEeTs4ulWKviE5Ryt5bqfHqtYoo215aYiDEkA4q8G5qOceR9DcSQghxq5DkqBaOf7Ke1GVrTeVGkaEUnk43lX1ah6A/W1b2bh1C6YWKfV4tQlAuVcwt5BoRgHKt/w2Ac1ggXD5vKmuDg8BsvyY4GK5U7FcHhUJOBiptEWrnAlSuLqCUJW6+1xacdfesNIzftVFFElNNp+xmXhXJUXPvIuDa47rSAgLc9BQozripijl15DuatjQbhq/zB01F0mhAh0G5SonxIkaKUK61bF06c5kAlYEixYnGIZatWtLfSAghbE8xgFLPZ0SK4cbH3GnksdptTqW2bDUqMSgEK5kA+DWqlACZTwhZaQkRMOuADTT31pvtUVCpFM5rylp7ss6dsyo2IyUW5dwzZS1a5zVBqDWWHz2NzHEkhBA2J4/V6kaSo9ud2jKlz8grxUlloEDR4e/larFPZZ4cad1BZfnrL58IsuxnvcU+lFJyXMqSo6KLZ28YlqIoKIrlI0h9RllylOUqI9WEEELcuuSxmhUMpaVs//wVjGnbyW3uiVOmHyV+mei8D3CliS8uVwIpapQBLvvIDihLQAqNe8j1bEzjoiAuu6TjXfArBVp/Ao3BZKgv4J75C0WljQnRBnG+NB3Xs79SbPAlzDWIM4XpOKftpcToS1P3QE7nZ6C7uo8SfInwCuBk7kWcLu2nVONL82AvTly8jLbkCqUuvrg6OxEOFKFj76E04ts1r3gjZsmRSqVGcfICfbZpm3nL0bkrZYlNZlY+2Xk5+ASo0HsGQQGEnFpH0nIVLeO6kpq8C+2lNAzBUbSI787xnTtQXzhCSXALSo2FOGecojggnJC7oml0al9ZfVYzaYb0ORJCCNtTFBuMVmuAk0BKcmSFHV/9m4TUV8s6Fje59ioXfO1VznydV+dKF3KqVL5W++3KfwtqoBQiy4/TAEXQ0nyqolxoVv6zATgLTcvLhddegA959Lj4OdsP/qEiQarcQVvnbZEcpWRUtBYtPNKEYOdjeBflk6vyxSs9k0Z5ZfMnhXOB8FMfwamPCC0/4XgSHF9oWS53ciecrCh2K/yVjT9tp8PdPQBQoUWF5WzZQggh6s8WkzjKJJCiemd3UZ44KwoYFFWN5doce7PKahWUKmpK83NQNe2Oyr+NZZ8jALcw8I4C/24QMoDfiypamVQo7DjnRq7iQWT7WHJLdSjFRTaph1JFjfrUady1MbhomuGsCWtww/iLi4t5/vnnKS4udnQotzSpJ+tIPVlH6klYS5IjK2haJ6K6lmyoVLDicneL8o9ZlmXzn1df7WlRXltgWV5fbFneoO9hUd5YanntjQbL8mbF8vzNTgmmslZlxCkyEVVEL1Rt7kXlVKkPkndrVAHdUfm0ReUeRs/IsnYfFQoKKro3NeKl1ZPy+2G8tCUYQyMt7rXFZ7Bl2fee69bDxkaDLeLSteiDs6Ypbtpo3LTRjvi1OlRxcTGzZ8+WL+kbkHqyjtSTdRpiPcnaanXToJKjd955p8by9Y7pfu/jbG47j/+di+R/x4bhciiKT47fy7rCHnxx6j68TrTli1P3sb6oB9+cu49vzt3HRn1PVlx6gPDsGFZceoDNpT1Znfsg0SUdWJ37IFsMPVlX+AAdnGL47tIAkpSebCq5jzivtmwquY+t9GCz8T7ifduy2XgfW1U9SFLfS8/gaJLU97K+pAtJuvvpGdGOJN39bHPqxbbGD9On211sa/ww29wS2dHpDfaeuf6XQOX3OvyuVrxxf2vu8jzP6wmXGNfdk14dmtCjtQ8tgzT0H9qD7ZFPsN0rkTXhj9F3wni2t/sL270Hsqblk/SbPJVtsdP4QYljS/unSerwV7b6DGBT7BTinnyUTbFT2OYzhB2d3qD7vY/X+/dny3NqOu56+6z9/NQlnvqQerKO1JN1pJ6sY4971IVisM2roVEpd3BPq9zcXLy9vcnJycHLy4vo6GgOHTpk2l+5XN228nJubi5DvSN5ttfDaLRlnYBsNc9RcnIyvYYPq9U8R99u+5nhA3pW7I8IR2WoWEZE1bwn6hYJ1b7Hmt4/wHOT7+GlZ0dVbHBuTPLP64mLi7sWfBDJu7YS1+1aWedP8u4ddIuLo9RQyuKln/LI2OFotVoMRi0lSnbFpdQtcNG2rDaeG6npvdT3nLrUU20+P5XLlT+btiT1ZB2pJ+tIPVnHmvd8M+9/vXt9nTAJd23lDrC1k19azPCkd+wS963iju6QXZ735eaWdSQ2GAymn6sr13RMbm4upRgpKC1GQ1lypNMXUVhS0TKjLS6i5FpZU1xEqb5in6qoEMWsKbe0qMhULigtJbewCIrMrlWprCkogsKKckFJKblmZU1+ISpDUcX9ruajzs2t9j3W9P4BivUl5F6tWHcNvQv5BcUV20ryyc8vIjf32vIgOlfy8wvJzc2j1GCgsFBPbm6+WXJUsYyIs/oqem318dxITe+lvufUpZ5q8/mpXC7fVtv3Yw2pJ+tIPVlH6sk61rzn8v32bJPILymu9/0KSvU3PugOc0e3HJ09e5awsDBHhyGEEEKYnDlzhiZNmtz4wHooKiqiWbNmpKen3/hgKwQFBZGWloaLi8uND74D3NHJkdFo5Pz583h6eja40VBCCCFuLYqicPXqVUJCQlCrb36X36KiIvR627T66HS6BpMYwR2eHAkhhBBC1FaDGq0mhBBCCHEjkhwJIYQQQpiR5EgIIYQQwowkR0IIIYQQZiQ5qqczZ87Qp08foqOjad++PcuXL3d0SLek7OxsunTpQocOHWjXrh2LFi1ydEi3tIKCAsLDw5k2bZqjQ7llRURE0L59ezp06EDfvn0dHc4tKy0tjb59+xIdHU1MTAz5+fk3PqkBSklJoUOHDqaXq6sr3333naPDEg4io9Xq6cKFC2RkZNChQwfS09Pp3LkzR48exd3d3dGh3VIMBgPFxcW4ubmRn59Pu3bt+PXXX2ncuLGjQ7sl/eMf/yA1NZWwsDBef/11R4dzS4qIiODgwYN4eHg4OpRbWu/evZkzZw69evUiKysLLy8vtNo7ev7fesvLyyMiIoJTp07Jd3kDJS1H9RQcHEyHDh2Askmy/Pz8yMrKcmxQtyCNRoObmxtQtvijoih2nSX2dnLs2DGOHDnCkCFDHB2KuM39/vvvODk50atXLwB8fX0lMbLCihUr6N+/vyRGDViDT46SkpIYNmwYISEhqFSqaptR33nnHSIiInBxcaFbt24kJydXe63du3djMBjuyFm5bVFP2dnZxMbG0qRJE/72t7/h5+dnp+jtxxb1NG3aNObNm2eniB3DFvWkUqno3bs3Xbt25ZNPPrFT5PZV33o6duwYHh4eDBs2jE6dOjF37lw7Rm9ftvwu//LLLxk5cuRNjljcyhp8cpSfn09sbOx1V1T+4osveOaZZ5g1axZ79uwhNjaWQYMGcfHiRYvjsrKyGDNmDAsXLrRH2HZni3ry8fFh//79pKWl8emnn5KRkVHttW5n9a2n77//ntatW9O6dWt7hm13tvg8bdu2jd27d7NixQrmzp3Lb7/9Zq/w7aa+9VRaWsrWrVt599132blzJ+vWrWPdunX2fAt2Y6vv8tzcXHbs2MHQoUPtEba4VSnCBFC+/fZbi21xcXHKpEmTTGWDwaCEhIQo8+bNM20rKipSevXqpSxbtsxeoTpUXevJ3MSJE5Xly5ffzDAdri719OyzzypNmjRRwsPDlcaNGyteXl7K7Nmz7Rm23dni8zRt2jRlyZIlNzFKx6tLPe3YsUMZOHCgaf+rr76qvPrqq3aJ15Hq85latmyZMnr0aHuEKW5hDb7lqCZ6vZ7du3eTmJho2qZWq0lMTGTnzp1A2Vo548aNo1+/fjzyyCOOCtWhrKmnjIwMrl69CkBOTg5JSUlERkY6JF5Hsaae5s2bx5kzZzh58iSvv/46EyZMYObMmY4K2SGsqaf8/HzT5ykvL4+NGzfStm1bh8TrKNbUU9euXbl48SJXrlzBaDSSlJREmzZtHBWyw1hTV+XkkZoAeaxWo8zMTAwGA4GBgRbbAwMDTSsdb9++nS+++ILvvvvONAT0wIEDjgjXYaypp1OnTtGrVy9iY2Pp1asXU6ZMISYmxhHhOow19SSsq6eMjAx69uxJbGwsd911F2PGjKFr166OCNdhrKknrVbL3LlzSUhIoH379rRq1Yp77rnHEeE6lLX/9nJyckhOTmbQoEH2DlHcYmTYQj317NkTo9Ho6DBueXFxcezbt8/RYdxWxo0b5+gQblnNmzdn//79jg7jtjBkyBAZ+Wglb2/vO7IvpKg9aTmqgZ+fHxqNpso/loyMDIKCghwU1a1H6sk6Uk/WkXqyjtST9aSuRG1JclQDnU5H586d2bBhg2mb0Whkw4YNxMfHOzCyW4vUk3Wknqwj9WQdqSfrSV2J2mrwj9Xy8vJITU01ldPS0ti3bx++vr40bdqUZ555hrFjx9KlSxfi4uKYP38++fn5PProow6M2v6knqwj9WQdqSfrSD1ZT+pK2JSjh8s52qZNmxSgymvs2LGmY95++22ladOmik6nU+Li4pSff/7ZcQE7iNSTdaSerCP1ZB2pJ+tJXQlbkrXVhBBCCCHMSJ8jIYQQQggzkhwJIYQQQpiR5EgIIYQQwowkR0IIIYQQZiQ5EkIIIYQwI8mREEIIIYQZSY6EEEIIIcxIciSEEEIIYUaSIyGEEEIIM5IcCXEbGTduHCqVCpVKhZOTE82aNePvf/87RUVFjg5NCCHuGA1+4VkhbjeDBw9myZIllJSUsHv3bsaOHYtKpeKVV15xdGjV0uv16HQ6R4chhBBWk5YjIW4zzs7OBAUFERYWxv33309iYiLr1q0DwGg0Mm/ePJo1a4arqyuxsbF89dVXpnOvXLnC6NGj8ff3x9XVlVatWrFkyRLT/gMHDtCvXz9cXV1p3LgxTzzxBHl5eab9ffr0YerUqRbx3H///YwbN85UjoiI4MUXX2TMmDF4eXnxxBNPALB9+3b69OmDm5sbjRo1YtCgQVy5csWquIUQwp4kORLiNnbw4EF27NhhapmZN28ey5Yt4/333+f333/n6aef5k9/+hNbtmwB4F//+heHDh1i1apVHD58mPfeew8/Pz8A8vPzGTRoEI0aNWLXrl0sX76c9evXM3ny5FrH9frrrxMbG8vevXv517/+xb59++jfvz/R0dHs3LmTbdu2MWzYMAwGg1VxCyGEPcljNSFuMz/++CMeHh6UlpZSXFyMWq1mwYIFFBcXM3fuXNavX098fDwAzZs3Z9u2bXzwwQf07t2b06dP07FjR7p06QKUtfKU+/TTTykqKmLZsmW4u7sDsGDBAoYNG8Yrr7xCYGCg1TH269ePv/71r6byH//4R7p06cK7775r2ta2bVsAq+IWQgh7kuRIiNtM3759ee+998jPz+ett95Cq9UyfPhwfv/9dwoKChgwYIDF8Xq9no4dOwIwceJEhg8fzp49exg4cCD3338/3bt3B+Dw4cPExsaaEiOAHj16YDQaSUlJqVVyVJ58ldu3bx8PPfRQtcempqbeMG4hhLAnSY6EuM24u7vTsmVLAD788ENiY2P573//S7t27QD46aefCA0NtTjH2dkZgCFDhnDq1ClWrlzJunXr6N+/P5MmTeL111+36t5qtRpFUSy2lZSUVBujOVdX1+tes7xPU01xCyGEPUmfIyFuY2q1mueee45//vOfREdH4+zszOnTp2nZsqXFKywszHSOv78/Y8eO5X//+x/z589n4cKFALRp04b9+/eTn59vOnb79u2o1WoiIyNN5164cMG032AwcPDgwRvG2b59ezZs2FDtPmvjFkIIe5HkSIjb3EMPPYRGo+GDDz5g2rRpPP3003z00UccP36cPXv28Pbbb/PRRx8BMHPmTL7//ntSU1P5/fff+fHHH2nTpg0Ao0ePxsXFhbFjx3Lw4EE2bdrElClTeOSRR0yP1Pr168dPP/3ETz/9xJEjR5g4cSLZ2dk3jHHGjBns2rWLJ598kt9++40jR47w3nvvkZmZiaen5w3jFkIIe5LHakLc5rRaLZMnT+bVV18lLS0Nf39/5s2bx4kTJ/Dx8aFTp04899xzAOh0OmbMmMHJkydxdXWlV69efP755wC4ubmxZs0annrqKbp27YqbmxvDhw/nzTffNN3rscceY//+/YwZMwatVsvTTz9N3759bxhj69atWbt2Lc899xxxcXG4urrSrVs3Ro0aBcCLL75YY9xCCGFPKqVyBwIhhBBCiAZMHqsJIYQQQpiR5EgIIYQQwowkR0IIIYQQZiQ5EkIIIYQwI8mREEIIIYQZSY6EEEIIIcxIciSEEEIIYUaSIyGEEEIIM5IcCSGEEEKYkeRICCGEEMKMJEdCCCGEEGYkORJCCCGEMCPJkRBCCCGEGUmOhBBCCCHMSHIkhBBCCGFGkiMhhBBCCDOSHAkhhBBCmJHkSAghhBDCjCRHQgghhBBmJDkSQgghhDCjdXQAQtiSwWCgpKTE0WEIIW4hOp0OtVraAoT1JDkSdwRFUUhPTyc7O9vRoQghbjFqtZpmzZqh0+kcHYq4TagURVEcHYQQ9XXhwgWys7MJCAjAzc0NlUrl6JCEELcAo9HI+fPncXJyomnTpvLdIKwiLUfitmcwGEyJUePGjR0djhDiFuPv78/58+cpLS3FycnJ0eGI24A8hBW3vfI+Rm5ubg6ORAhxKyp/nGYwGBwcibhdSHIk7hjSXC6EqI58N4jakuRICCGEEMKMJEfijlZiMFKoN9jtVWIw2jT+559/ng4dOtj0mrWlUqn47rvvHBqDEELYk3TIFne07/ae4+s9Z+12v+GdmvBQlzCrjh02bBglJSWsXr26yr6tW7eSkJDA/v37mTJlyg2vFRERwdSpU5k6dWptQ64180cUGo2GkJAQRowYwbx583B2drbJPez5foQQojJpORLCQcaPH8+6des4e7Zq8rZkyRK6dOlC+/btaxyBp9frb2aI17VkyRIuXLhAWloa7777Lh9//DFz5sxxSCxCCGFrkhwJ4SD33HMP/v7+LF261GJ7Xl4ey5cvZ/z48VUeq40bN47777+fl156iZCQECIjI+nTpw+nTp3i6aefRqVSmVp2qnskN3/+fCIiIkzlXbt2MWDAAPz8/PD29qZ3797s2bPnhrH7+PgQFBREWFgY99xzD/fdd1+V877//ns6deqEi4sLzZs3Z/bs2ZSWlgJlk3Y+//zzNG3aFGdnZ0JCQvjLX/4CcN33I4QQ9iLJkRAOotVqGTNmDEuXLsV8Ltbly5djMBgYNWpUtedt2LCBlJQU1q1bx48//sg333xDkyZNeOGFF7hw4QIXLlywOoarV68yduxYtm3bxs8//0yrVq0YOnQoV69etfoaR48eZePGjXTr1s20bevWrYwZM4annnqKQ4cO8cEHH7B06VJeeuklAL7++mveeustPvjgA44dO8Z3331HTEwMQL3ejxBC2IL0ORLCgR577DFee+01tmzZQp8+fYCyR1bDhw/H29u72nPc3d1ZvHixxVIIGo0GT09PgoKCanX/fv36WZQXLlyIj48PW7Zs4Z577rnueaNGjUKj0VBaWkpxcTH33HMPM2bMMO2fPXs2zz77LGPHjgWgefPmvPjii/z9739n1qxZnD59mqCgIBITE00zF8fFxQHg6+tb5/cjhBC2IC1HQjhQVFQU3bt358MPPwQgNTWVrVu3Mn78+OueExMTY7M1ojIyMpgwYQKtWrXC29sbLy8v8vLyOH36dI3nvfXWW+zbt4/9+/fz448/cvToUR555BHT/v379/PCCy/g4eFhek2YMIELFy5QUFDAQw89RGFhIc2bN2fChAl8++23pkduQgjhaNJyJISDjR8/nilTpvDOO++wZMkSWrRoQe/eva97vLu7u1XXVavVVF46sXw28XJjx47l8uXL/Pvf/yY8PBxnZ2fi4+Nv2NE7KCiIli1bAhAZGcnVq1cZNWoUc+bMoWXLluTl5TF79mwefPDBKue6uLgQFhZGSkoK69evZ926dTz55JOmFjRZ3kEI4WiSHAnhYA8//DBPPfUUn376KcuWLWPixIm17oSs0+mqLI3g7+9Peno6iqKYrrdv3z6LY7Zv3867777L0KFDAThz5gyZmZm1fg8ajQaAwsJCADp16kRKSoopgaqOq6srw4YNY9iwYUyaNImoqCgOHDhAp06dqn0/QghhL5IcCeFgHh4ejBw5khkzZpCbm8u4ceNqfY2IiAiSkpL4wx/+gLOzM35+fvTp04dLly7x6quvMmLECFavXs2qVavw8vIyndeqVSs+/vhjunTpQm5uLn/7299wdXW94f2ys7NJT0/HaDRy7NgxXnjhBVq3bk2bNm0AmDlzJvfccw9NmzZlxIgRqNVq9u/fz8GDB5kzZw5Lly7FYDDQrVs33Nzc+N///oerqyvh4eHXfT9CCGEv0udIiFvA+PHjuXLlCoMGDSIkJKTW57/wwgucPHmSFi1a4O/vD0CbNm149913eeedd4iNjSU5OZlp06ZZnPff//6XK1eu0KlTJx555BH+8pe/EBAQcMP7PfroowQHB9OkSRNGjRpF27ZtWbVqFVpt2f+3Bg0axI8//sjatWvp2rUrd911F2+99ZYp+fHx8WHRokX06NGD9u3bs379en744QfTnE7VvR8hhLAXlVK5U4IQt5mioiLS0tJo1qwZLi4uFvuW/3rmlp0hWwhhHzV9RwhRHXmsJu5o93cM5Z72tW+JqSutRiYsFEKI250kR+KO5qRR46RxdBRCCCFuJ9LnSAghhBDCjCRHQgghhBBmJDkSQgghhDAjyZEQQgghhBlJjoQQQgghzEhyJIQQQghhRpIjIYQQQggzkhwJcQd6/vnn6dChw02/j0ql4rvvvrvp91m4cCFhYWGo1Wrmz59/0+/nCH369GHq1KlWH3/y5ElUKlWVxYSFEPUnyZEQDjRu3DhUKhUqlQqdTkfLli154YUXKC0trdd1p02bxoYNG2wU5fWTrQsXLjBkyBCb3ac6ubm5TJ48menTp3Pu3DmeeOKJm3q/G4mIiDD9zqp71WXhYIBvvvmGF1980erjw8LCuHDhAu3atavT/a6noKCAGTNm0KJFC1xcXPD396d37958//33pmMiIiLqlKTWNgEUwlFkhmwhHGzw4MEsWbKE4uJiVq5cyaRJk3BycmLGjBlVjtXr9eh0uhte08PDAw8Pj5sRroWgoKCbfo/Tp09TUlLC3XffTXBwcLXHWFsvtrBr1y4MBgMAO3bsYPjw4aSkpODl5QWAq6urxfElJSU4OTnd8Lq+vr61ikOj0dyU+v/zn//ML7/8wttvv010dDSXL19mx44dXL582eb3EuKWpQhxmyssLFQOHTqkFBYWOjqUWhs7dqxy3333WWwbMGCActddd1nsnzNnjhIcHKxEREQoiqIov/32m9K3b1/FxcVF8fX1VSZMmKBcvXrVdI1Zs2YpsbGxFtddtGiREhUVpTg7OyuRkZHKO++8Y7H/zJkzyh/+8AelUaNGipubm9K5c2fl559/VpYsWaIAFq8lS5YoiqIogPLtt9+arnGjuMrfz2uvvaYEBQUpvr6+ypNPPqno9fpq66e6e6elpZne36JFi5SIiAhFpVIpiqIop06dUu69917F3d1d8fT0VB566CElPT29Sr3897//VcLCwhR3d3dl4sSJSmlpqfLKK68ogYGBir+/vzJnzpwb//IURdm0aZMCKFeuXFEURVHS0tIUQPn888+VhIQExdnZWVmyZImSmZmp/OEPf1BCQkIUV1dXpV27dsqnn35qca3evXsrTz31lKkcHh6uvPTSS8qjjz6qeHh4KGFhYcoHH3xg2l9+r71791rEsn79eqVz586Kq6urEh8frxw5csTiPi+++KLi7++veHh4KOPHj1emT59u8Vnx9vZWli5det333Lt37yq/E0VRbvgex44dW+3vMisrS/njH/+o+Pn5KS4uLkrLli2VDz/80Kr6t9bt/B0hHENajsQdSVEUCksMdTp345GLJKdlEdfMl35RAbU+39VJg0pV9wVoXV1dLf6XvmHDBry8vFi3bh0A+fn5DBo0iPj4eHbt2sXFixd5/PHHmTx5MkuXLq32mp988gkzZ85kwYIFdOzYkb179zJhwgTc3d0ZO3YseXl59O7dm9DQUFasWEFQUBB79uzBaDQycuRIDh48yOrVq1m/fj0A3t7eVe5hbVybNm0iODiYTZs2kZqaysiRI+nQoQMTJkyocs2RI0cSFhZGYmIiycnJhIWF4e/vD0Bqaipff/0133zzDRqNBqPRyH333YeHhwdbtmyhtLSUSZMmMXLkSDZv3my65vHjx1m1ahWrV6/m+PHjjBgxghMnTtC6dWu2bNnCjh07eOyxx0hMTKRbt261/fUB8Oyzz/LGG2/QsWNHXFxcKCoqonPnzkyfPh0vLy9++uknHnnkEVq0aEFcXNx1r/PGG2/w4osv8txzz/HVV18xceJEevfuTWRk5HXP+cc//sEbb7yBv78/f/7zn3nsscfYvn07UPY5eOmll3j33Xfp0aMHn3/+OW+88QbNmjUznR8UFMTKlSt58MEH8fT0rHL9b775htjYWJ544gmL39mN3uO///1vjh49Srt27XjhhRcA8Pf356mnnuLQoUOsWrUKPz8/UlNTKSwsrHWdC2FLkhyJO1JhiYHomWvqdY1lO0/V6bxDLwzCTVf7f1qKorBhwwbWrFnDlClTTNvd3d1ZvHix6bHRokWLKCoqYtmyZbi7uwOwYMEChg0bxiuvvEJgYGCVa8+aNYs33niDBx98EIBmzZpx6NAhPvjgA8aOHcunn37KpUuX2LVrl+nxTsuWLU3ne3h4oNVqa3yM8+mnn1oVV6NGjViwYAEajYaoqCjuvvtuNmzYUG1y5OrqSuPGjYGyP6Tm99fr9SxbtsyULK1bt44DBw6QlpZGWFgYAMuWLaNt27bs2rWLrl27AmA0Gvnwww/x9PQkOjqavn37kpKSwsqVK1Gr1URGRvLKK6+wadOmOidHU6dONdV1uWnTppl+njJlCmvWrOHLL7+sMTkaOnQoTz75JADTp0/nrbfeYtOmTTUmRy+99BK9e/cGypK0u+++m6KiIlxcXHj77bcZP348jz76KAAzZ85k7dq15OXlmc5fuHAho0ePpnHjxsTGxtKzZ09GjBhBjx49gLLHfxqNBk9PT4vfR2hoaI3v0dvbG51Oh5ubm8V5p0+fpmPHjnTp0gUo688khKNJh2whHOzHH3/Ew8MDFxcXhgwZwsiRI3n++edN+2NiYiz60xw+fJjY2FhTAgLQo0cPjEYjKSkpVa6fn5/P8ePHGT9+vKkvkoeHB3PmzOH48eMA7Nu3j44dO9a634s5a+Nq27YtGo3GVA4ODubixYu1vl94eLgpMSq/f1hYmCkxAoiOjsbHx4fDhw+btkVERFi0iAQGBhIdHY1arbbYVpeYypX/oS9nMBh48cUXiYmJwdfXFw8PD9asWcPp06drvE779u1NP6tUKoKCgm4Yl/k55X20ys9JSUmpkoxVLickJHDixAk2bNjAiBEj+P333+nVq9cNO4vX9T1OnDiRzz//nA4dOvD3v/+dHTt21Hi8EPYgLUfijuTqpOHQC4Nqfd7GIxeZ/OleNCoVBkVhwR871vrRmquT5sYHmenbty/vvfceOp2OkJAQtFrLf5bmyUZdlLcKLFq0qEpLSHmSUrkT8c1UuXOySqXCaDTW+jp1rZfq7m+rmK4X22uvvca///1v5s+fT0xMDO7u7kydOhW9Xl/rWG8Ul/k55Y93a/tenJyc6NWrF7169WL69OnMmTOHF154genTp1+343td3+OQIUM4deoUK1euZN26dfTv359Jkybx+uuv1ypmIWxJkiNxR1KpVHV6tHVP+xCctRp+PnGZu5o3ZkB01UdUtubu7m7xCOtG2rRpw9KlS8nPzzf9Ed6+fbvpkVBlgYGBhISEcOLECUaPHl3tNdu3b8/ixYvJysqqtvVIp9OZRmjZKi5ba9OmDWfOnOHMmTOm1qNDhw6RnZ1NdHT0Tb9/TbZv3859993Hn/70J6AsWTl69Kjd44qMjGTXrl2MGTPGtG3Xrl03PC86OprS0lKKiorQ6XTVfh6seY/X+xz5+/szduxYxo4dS69evfjb3/4myZFwKHmsJkQlA6ID+dc90XZJjOpi9OjRuLi4MHbsWA4ePMimTZuYMmUKjzzySLX9jQBmz57NvHnz+M9//sPRo0c5cOAAS5Ys4c033wRg1KhRBAUFcf/997N9+3ZOnDjB119/zc6dO4GyR1FpaWns27ePzMxMiouLbRKXLSUmJhITE8Po0aPZs2cPycnJjBkzht69e1d5zGVvrVq1Yt26dezYsYPDhw/zf//3f2RkZNg9jilTpvDf//6Xjz76iGPHjjFnzhx+++03iwEEffr04YMPPmD37t2cPHmSlStX8txzz9G3b1/TdAUREREkJSVx7tw5MjMzrX6PERER/PLLL5w8eZLMzEyMRiMzZ87k+++/JzU1ld9//50ff/yRNm3a2K9ShKiGJEdC3Gbc3NxYs2YNWVlZdO3alREjRtC/f38WLFhw3XMef/xxFi9ezJIlS4iJiaF3794sXbrUNEpJp9Oxdu1aAgICGDp0KDExMbz88sumx27Dhw9n8ODB9O3bF39/fz777DObxGVLKpWK77//nkaNGpGQkEBiYiLNmzfniy++sMv9a/LPf/6TTp06MWjQIPr06WNKRO1t9OjRzJgxg2nTptGpUyfS0tIYN24cLi4upmMGDRrERx99xMCBA2nTpg1Tpkxh0KBBfPnll6ZjXnjhBU6ePEmLFi1M/b6seY/Tpk1Do9EQHR2Nv78/p0+fRqfTMWPGDNq3b09CQgIajYbPP//cLvUhxPWoFEVRHB2EEPVRVFREWloazZo1s/iSb8hmzJjB1q1b2bZtm6NDEbe4AQMGEBQUxMcff+zoUG4a+Y4QtSV9joS4gyiKYhpp1LFjR0eHI24xBQUFvP/++wwaNAiNRsNnn33G+vXrTXNoCSHKyGM1Ie4gOTk5REdHo9PpeO655xwdjrjFqFQqVq5cSUJCAp07d+aHH37g66+/JjEx0dGhCXFLkZYjIe4gPj4+1XaWFgLKpmwon+VcCHF90nIkhBBCCGFGkiMhhBBCCDOSHAkhhBBCmJHkSAghhBDCjCRHQgghhBBmJDkSQgghhDAjyZEQd6Dnn3+eDh063PT7qFQqvvvuu5t+n4ULFxIWFoZarWb+/Pk3/X6O0KdPH6ZOnWr18SdPnkSlUrFv376bFpOjbN68GZVKRXZ2tqNDEQ2UJEdCONC4ceNQqVSoVCp0Oh0tW7bkhRdeoLS0tF7XnTZtGhs2bLBRlNdPti5cuMCQIUNsdp/q5ObmMnnyZKZPn865c+d44oknbur9biQiIsL0O6vuNW7cuDpd95tvvuHFF1+0+viwsDAuXLhAu3bt6nS/63n++edN70Wj0RAWFsYTTzxBVlaWTe9TG0uXLsXHx8dh9xcNj0wCKYSDDR48mCVLllBcXMzKlSuZNGkSTk5OzJgxo8qxer0enU53w2t6eHjg4eFxM8K1EBQUdNPvcfr0aUpKSrj77rsJDg6u9hhr68UWdu3ahcFgAGDHjh0MHz6clJQU04r1rq6uFseXlJTg5OR0w+v6+vrWKg6NRnPT6r9t27asX78eg8HA4cOHeeyxx8jJybklFvEVwh6k5UgIB3N2diYoKIjw8HAmTpxIYmIiK1asAMpalu6//35eeuklQkJCiIyMBODAgQP069cPV1dXGjduzBNPPEFeXp7pmtW19CxevJg2bdrg4uJCVFQU7777rsX+s2fPMmrUKHx9fXF3d6dLly788ssvLF26lNmzZ7N//35Ti8LSpUuBqo/VbhRX+ft5/fXXCQ4OpnHjxkyaNImSkpJq62bp0qXExMQA0Lx5c1QqFSdPnjS9v8WLF1ssJnr69Gnuu+8+PDw88PLy4uGHHyYjI6NKvXz44Yc0bdoUDw8PnnzySQwGA6+++ipBQUEEBATw0ksvXff35e/vT1BQEEFBQaaEJiAggKCgIIqKivDx8eGLL76gd+/euLi48Mknn3D58mVGjRpFaGgobm5uxMTE8Nlnn1lct/JjtYiICObOnctjjz2Gp6cnTZs2ZeHChab9lR+rlT+K2rBhA126dMHNzY3u3buTkpJicZ85c+YQEBCAp6cnjz/+OM8++2yVz4pWqyUoKIjQ0FASExN56KGHqqy/VtPnSa/XM3nyZIKDg3FxcSE8PJx58+ZVGzdAdnY2KpWKzZs3V6nvzZs38+ijj5KTk2P6/D3//PMAvPvuu7Rq1QoXFxcCAwMZMWLEdX9vQtSGtByJO5OiQElB3c49ugZO7YDw7tB6UO3Pd3IDlapu96as5eHy5cum8oYNG/Dy8jL9ccrPz2fQoEHEx8eza9cuLl68yOOPP87kyZNNSUtln3zyCTNnzmTBggV07NiRvXv3MmHCBNzd3Rk7dix5eXn07t2b0NBQVqxYQVBQEHv27MFoNDJy5EgOHjzI6tWrTUtPeHt7V7mHtXFt2rSJ4OBgNm3aRGpqKiNHjqRDhw5MmDChyjVHjhxJWFgYiYmJJCcnExYWhr+/PwCpqal8/fXXfPPNN2g0GoxGoykx2rJlC6WlpUyaNImRI0da/NE9fvw4q1atYvXq1Rw/fpwRI0Zw4sQJWrduzZYtW9ixYwePPfYYiYmJdOvWrba/PgCeffZZ3njjDTp27IiLiwtFRUV07tyZ6dOn4+XlxU8//cQjjzxCixYtiIuLu+513njjDV588UWee+45vvrqKyZOnEjv3r1NSXJ1/vGPf/DGG2/g7+/Pn//8Zx577DG2b98OlH0OXnrpJd5991169OjB559/zhtvvEGzZs2ue72TJ0+yZs0ai5a5G32e/vOf/7BixQq+/PJLmjZtypkzZzhz5kwdahK6d+/O/PnzmTlzpinR8/Dw4Ndff+Uvf/kLH3/8Md27dycrK4utW7fW6R5CVCbJkbgzlRTA3JD6XWPXorqd99x50LnX+jRFUdiwYQNr1qxhypQppu3u7u4sXrzY9Mdp0aJFFBUVsWzZMtzdy+6zYMEChg0bxiuvvEJgYGCVa8+aNYs33niDBx98EIBmzZpx6NAhPvjgA8aOHcunn37KpUuX2LVrl6k1pGXLlqbzPTw8TK0J1/Ppp59aFVejRo1YsGABGo2GqKgo7r77bjZs2FBtclTeAgUVLTbl9Ho9y5YtMyVL69at48CBA6SlpREWFgbAsmXLaNu2Lbt27aJr164AGI1GPvzwQzw9PYmOjqZv376kpKSwcuVK1Go1kZGRvPLKK2zatKnOydHUqVNNdV1u2rRppp+nTJnCmjVr+PLLL2tMjoYOHcqTTz4JwPTp03nrrbfYtGlTjcnRSy+9RO/evYGyJO3uu++mqKgIFxcX3n77bcaPH8+jjz4KwMyZM1m7dq1F6x6UtQB6eHhgMBgoKioC4M033zTtv9Hn6fTp07Rq1YqePXuiUqkIDw+/YZ1dj06nw9vbG5VKZfH7P336NO7u7txzzz14enoSHh5Ox44d63wfIczJYzUhHOzHH3/Ew8MDFxcXhgwZwsiRI02PDQBiYmIs/td++PBhYmNjTQkIQI8ePTAajVUeoUBZi87x48cZP368qS+Sh4cHc+bM4fjx4wDs27ePjh071rrfizlr42rbti0ajcZUDg4O5uLFi7W+X3h4uCkxKr9/WFiYKTECiI6OxsfHh8OHD5u2RURE4OnpaSoHBgYSHR2NWq222FaXmMp16dLFomwwGHjxxReJiYnB19cXDw8P1qxZw+nTp2u8Tvv27U0/lycHN4rL/JzyPlrl56SkpFRJxqpLziIjI9m3bx+7du1i+vTpDBo0yJSwW/N5GjduHPv27SMyMpK//OUvrF27tsaY62LAgAGEh4fTvHlzHnnkET755BMKCurYWixEJdJyJO5MTm5lLTi1dXQNfPUoqDSgGGDEkto/WnNyq9Xhffv25b333kOn0xESEoJWa/nP0jzZqIvyVoFFixZVaQkpT1IqdyK+mSp3TlapVBiNxlpfp671Ut39bRXT9WJ77bXX+Pe//838+fOJiYnB3d2dqVOnotfrax3rjeIyP0d17fFubd9L+chJgJdffpm7776b2bNn8+KLL1r1eerUqRNpaWmsWrWK9evX8/DDD5OYmMhXX31lSkIVRTGdd70+ZzXx9PRkz549bN68mbVr1zJz5kyef/55du3aJSPbRL1JciTuTCpVnR5t0e5B0LrAyW0Q0ROihto+tkrc3d0tHmHdSJs2bVi6dCn5+fmmP8Lbt283PRKqLDAwkJCQEE6cOMHo0aOrvWb79u1ZvHgxWVlZ1bYe6XQ60wgtW8Vla23atDH1bSlvPTp06BDZ2dlER0ff9PvXZPv27dx333386U9/AsqSlaNHj9o9rsjISHbt2sWYMWNM23bt2nXD8/75z3/Sr18/Jk6cSEhIyA0/TwBeXl6MHDmSkSNHMmLECAYPHkxWVpapte/ChQumx2A3mqvpep8/rVZLYmIiiYmJzJo1Cx8fHzZu3FjlkaYQtSWP1YSoLGooDJ5rl8SoLkaPHo2Liwtjx47l4MGDbNq0iSlTpvDII49U298IYPbs2cybN4///Oc/HD16lAMHDrBkyRJTP5JRo0YRFBTE/fffz/bt2zlx4gRff/01O3fuBMoeRaWlpbFv3z4yMzMpLi62SVy2lJiYSExMDKNHj2bPnj0kJyczZswYevfuXeUxl721atWKdevWsWPHDg4fPsz//d//WYyis5cpU6bw3//+l48++ohjx44xZ84cfvvtN1ML0/XEx8fTvn175s6dC9z48/Tmm2/y2WefceTIEY4ePcry5csJCgrCx8cHV1dX7rrrLl5++WUOHz7Mli1b+Oc//1nj/SMiIsjLy2PDhg1kZmZSUFDAjz/+yH/+8x/27dvHqVOnWLZsGUaj0S6JuLjzSXIkxG3Gzc2NNWvWkJWVRdeuXRkxYgT9+/dnwYIF1z3n8ccfZ/HixSxZsoSYmBh69+7N0qVLTaOUdDoda9euJSAggKFDhxITE8PLL79sekwyfPhwBg8eTN++ffH3968yDL2ucdmSSqXi+++/p1GjRiQkJJCYmEjz5s1vibl5/vnPf9KpUycGDRpEnz59TImovY0ePZoZM2Ywbdo006OvcePGmaZCqMnTTz/N4sWLOXPmzA0/T56enrz66qt06dKFrl27cvLkSVOHd4APP/yQ0tJSOnfuzNSpU5kzZ06N9+7evTt//vOfGTlyJP7+/rz66qv4+PjwzTff0K9fP9q0acP777/PZ599Rtu2betfUaLBUynmD36FuA0VFRWRlpZmMd9NQzdjxgy2bt3Ktm3bHB2KuMUNGDCAoKAgPv74Y0eHctPId4SoLelzJMQdRFEUTpw4wYYNG2RYs6iioKCA999/n0GDBqHRaPjss89Yv359lQkehWjo5LGaEHeQnJwcoqOj0el0PPfcc44OR9xiVCoVK1euJCEhgc6dO/PDDz/w9ddfk5iY6OjQhLilSMuREHcQHx+fajtLCwFlUzaUz3IuhLg+aTkSQgghhDAjyZG4Y8jYAiFEdeS7QdSWJEfitlc+I7AsHSCEqE75TOTmy9YIURPpcyRuexqNBh8fH9P6UW5ubjec1E4I0TAYjUYuXbqEm5tblaV5hLge+aSIO0L5at31WSxUCHFnUqvVNG3aVP7TJKwmk0CKO4rBYKjTIpZCiDuXTqczzc4thDUkORJCCCGEMCOptBBCCCGEGUmOhBBCCCHM/D/BpmoSYg+nQwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -365,14 +886,607 @@ } ], "source": [ + "# ============================================================\n", + "# Generate Combined Parameter Plot\n", + "# ============================================================\n", + "# Creates a single figure with subplots for all parameters\n", + "# showing how the complete parameter configuration evolves with resources\n", + "# - Black curves: Virtual Best optimal parameter values\n", + "# - Colored curves: Recommended parameter values from each experiment\n", + "# - Shared x-axis: All subplots aligned at same resource levels\n", + "# - Compact layout: All parameters visible at once\n", "fig, axes = sb.plots.plot_parameters_together()\n", - "fig.savefig(\"all_params.png\")" + "\n", + "# Optionally save the combined figure to a file\n", + "# fig.savefig(\"all_params.png\") # Uncomment to save plot as PNG\n", + "# fig.savefig(\"all_params.pdf\") # Uncomment to save plot as PDF\n", + "\n", + "# The plot displays in the notebook automatically\n", + "# Data is cached to: checkpoints/params_plotting/" ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "QAOA PERFORMANCE METRICS\n", + "============================================================\n", + "\n", + "Virtual Best (Oracle Upper Bound):\n", + "------------------------------------------------------------\n", + "At 1e+02 evaluations: 0.5660 ± 0.0563\n", + " Optimal params: shots≈100, iterations≈1, rounds≈1.0\n", + "At 1e+03 evaluations: 0.7340 ± 0.0285\n", + " Optimal params: shots≈100, iterations≈9, rounds≈1.0\n", + "At 1e+04 evaluations: 0.8243 ± 0.0196\n", + " Optimal params: shots≈100, iterations≈26, rounds≈3.5\n", + "At 1e+05 evaluations: 0.8668 ± 0.0084\n", + " Optimal params: shots≈150, iterations≈30, rounds≈5.0\n", + "At 1e+06 evaluations: 0.8813 ± 0.0067\n", + " Optimal params: shots≈300, iterations≈28, rounds≈5.0\n", + "\n", + "============================================================\n", + "RECOMMENDATION STRATEGY PERFORMANCE\n", + "============================================================\n", + "\n", + "Projection from TrainingStats:\n", + "------------------------------------------------------------\n", + "At 1e+02: 0.5660 (100.0% of VB, gap: 0.0000)\n", + "At 1e+03: 0.7340 (100.0% of VB, gap: 0.0000)\n", + "At 1e+04: 0.8197 (99.4% of VB, gap: 0.0046)\n", + "At 1e+05: 0.8657 (99.9% of VB, gap: 0.0010)\n", + "At 1e+06: 0.8808 (99.9% of VB, gap: 0.0005)\n", + "\n", + "Projection from TrainingResults:\n", + "------------------------------------------------------------\n", + "At 1e+02: 0.5660 (100.0% of VB, gap: 0.0000)\n", + "At 1e+03: 0.7340 (100.0% of VB, gap: 0.0000)\n", + "At 1e+04: 0.8204 (99.5% of VB, gap: 0.0039)\n", + "At 1e+05: 0.8657 (99.9% of VB, gap: 0.0010)\n", + "At 1e+06: 0.8778 (99.6% of VB, gap: 0.0035)\n", + "\n", + "============================================================\n", + "PERFORMANCE IMPROVEMENTS\n", + "============================================================\n", + "1e+02 → 1e+03: +29.70% improvement\n", + "1e+03 → 1e+04: +12.30% improvement\n", + "1e+04 → 1e+05: +5.15% improvement\n", + "1e+05 → 1e+06: +1.68% improvement\n", + "\n", + "============================================================\n", + "STRATEGY COMPARISON\n", + "============================================================\n", + "At 1e+03: |TrainingStats - TrainingResults| = 0.0000\n", + " → Small difference: Universal parameters work well\n", + "At 1e+04: |TrainingStats - TrainingResults| = 0.0006\n", + " → Small difference: Universal parameters work well\n", + "At 1e+05: |TrainingStats - TrainingResults| = 0.0000\n", + " → Small difference: Universal parameters work well\n", + "\n", + "============================================================\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# Extract Performance Metrics from Results\n", + "# ============================================================\n", + "# Read the saved CSV files to extract actual performance values\n", + "# for the conclusions section below\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "# Load performance data from checkpoints\n", + "perf_dir = os.path.join(here, \"checkpoints\", \"performance_plotting\")\n", + "params_dir = os.path.join(here, \"checkpoints\", \"params_plotting\")\n", + "\n", + "# Read Virtual Best baseline performance\n", + "vb_perf = pd.read_csv(os.path.join(perf_dir, \"baseline.csv\"))\n", + "\n", + "# Read projection experiment performances\n", + "try:\n", + " proj_stats_perf = pd.read_csv(os.path.join(perf_dir, \"Projection from TrainingStats.csv\"))\n", + "except:\n", + " proj_stats_perf = None\n", + "\n", + "try:\n", + " proj_results_perf = pd.read_csv(os.path.join(perf_dir, \"Projection from TrainingResults.csv\"))\n", + "except:\n", + " proj_results_perf = None\n", + "\n", + "# Read parameter recommendations\n", + "vb_params = pd.read_csv(os.path.join(params_dir, \"baseline.csv\"))\n", + "\n", + "# Define resource levels of interest\n", + "resource_levels = [1e2, 1e3, 1e4, 1e5, 1e6]\n", + "\n", + "# Helper function to get value at closest resource level\n", + "def get_value_at_resource(df, resource, column='response'):\n", + " \"\"\"Get value from dataframe at closest resource level.\"\"\"\n", + " if df is None or len(df) == 0:\n", + " return None\n", + " idx = (df['resource'] - resource).abs().idxmin()\n", + " return df.loc[idx, column]\n", + "\n", + "# Extract performance metrics at each resource level\n", + "print(\"=\" * 60)\n", + "print(\"QAOA PERFORMANCE METRICS\")\n", + "print(\"=\" * 60)\n", + "print(\"\\nVirtual Best (Oracle Upper Bound):\")\n", + "print(\"-\" * 60)\n", + "\n", + "for resource in resource_levels:\n", + " approx_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " ci_lower = get_value_at_resource(vb_perf, resource, 'response_lower')\n", + " ci_upper = get_value_at_resource(vb_perf, resource, 'response_upper')\n", + " \n", + " if approx_ratio is not None:\n", + " ci_range = ci_upper - ci_lower if ci_upper and ci_lower else 0\n", + " print(f\"At {resource:.0e} evaluations: {approx_ratio:.4f} ± {ci_range/2:.4f}\")\n", + " \n", + " # Get optimal parameters at this resource level\n", + " shots = get_value_at_resource(vb_params, resource, 'shots')\n", + " iterations = get_value_at_resource(vb_params, resource, 'iterations')\n", + " rounds_val = get_value_at_resource(vb_params, resource, 'rounds')\n", + " \n", + " if all(v is not None for v in [shots, iterations, rounds_val]):\n", + " print(f\" Optimal params: shots≈{shots:.0f}, iterations≈{iterations:.0f}, rounds≈{rounds_val:.1f}\")\n", + "\n", + "# Compare projection strategies\n", + "if proj_stats_perf is not None or proj_results_perf is not None:\n", + " print(\"\\n\" + \"=\" * 60)\n", + " print(\"RECOMMENDATION STRATEGY PERFORMANCE\")\n", + " print(\"=\" * 60)\n", + " \n", + " if proj_stats_perf is not None:\n", + " print(\"\\nProjection from TrainingStats:\")\n", + " print(\"-\" * 60)\n", + " for resource in resource_levels:\n", + " approx_ratio = get_value_at_resource(proj_stats_perf, resource, 'response')\n", + " vb_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " \n", + " if approx_ratio is not None and vb_ratio is not None:\n", + " gap = vb_ratio - approx_ratio\n", + " pct_of_vb = (approx_ratio / vb_ratio * 100) if vb_ratio > 0 else 0\n", + " print(f\"At {resource:.0e}: {approx_ratio:.4f} ({pct_of_vb:.1f}% of VB, gap: {gap:.4f})\")\n", + " \n", + " if proj_results_perf is not None:\n", + " print(\"\\nProjection from TrainingResults:\")\n", + " print(\"-\" * 60)\n", + " for resource in resource_levels:\n", + " approx_ratio = get_value_at_resource(proj_results_perf, resource, 'response')\n", + " vb_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " \n", + " if approx_ratio is not None and vb_ratio is not None:\n", + " gap = vb_ratio - approx_ratio\n", + " pct_of_vb = (approx_ratio / vb_ratio * 100) if vb_ratio > 0 else 0\n", + " print(f\"At {resource:.0e}: {approx_ratio:.4f} ({pct_of_vb:.1f}% of VB, gap: {gap:.4f})\")\n", + "\n", + "# Calculate performance improvements\n", + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"PERFORMANCE IMPROVEMENTS\")\n", + "print(\"=\" * 60)\n", + "\n", + "prev_approx = None\n", + "for i, resource in enumerate(resource_levels):\n", + " approx_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " if approx_ratio is not None:\n", + " if prev_approx is not None:\n", + " improvement = ((approx_ratio - prev_approx) / prev_approx * 100)\n", + " print(f\"{resource_levels[i-1]:.0e} → {resource:.0e}: +{improvement:.2f}% improvement\")\n", + " prev_approx = approx_ratio\n", + "\n", + "# Strategy comparison\n", + "if proj_stats_perf is not None and proj_results_perf is not None:\n", + " print(\"\\n\" + \"=\" * 60)\n", + " print(\"STRATEGY COMPARISON\")\n", + " print(\"=\" * 60)\n", + " \n", + " for resource in [1e3, 1e4, 1e5]:\n", + " stats_ratio = get_value_at_resource(proj_stats_perf, resource, 'response')\n", + " results_ratio = get_value_at_resource(proj_results_perf, resource, 'response')\n", + " \n", + " if stats_ratio is not None and results_ratio is not None:\n", + " diff = abs(stats_ratio - results_ratio)\n", + " print(f\"At {resource:.0e}: |TrainingStats - TrainingResults| = {diff:.4f}\")\n", + " \n", + " if diff < 0.02:\n", + " print(f\" → Small difference: Universal parameters work well\")\n", + " elif diff > 0.05:\n", + " print(f\" → Large difference: Instance-specific tuning beneficial\")\n", + " else:\n", + " print(f\" → Moderate difference: Consider problem characteristics\")\n", + "\n", + "print(\"\\n\" + \"=\" * 60)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/markdown": [ + "\n", + "## Summary of Results with Actual Performance Data\n", + "\n", + "### Virtual Best Performance (Oracle Upper Bound)\n", + "\n", + "The table below shows the **best achievable approximation ratio** at each resource level:\n", + "\n", + "| Resource Level | Approximation Ratio | Confidence Interval | Optimal Parameters |\n", + "|----------------|--------------------:|--------------------:|:-------------------|\n", + "| 1e+02 | 0.5660 | ±0.0563 | s≈100, i≈1, r≈1.0 |\n", + "| 1e+03 | 0.7340 | ±0.0285 | s≈100, i≈9, r≈1.0 |\n", + "| 1e+04 | 0.8243 | ±0.0196 | s≈100, i≈26, r≈3.5 |\n", + "| 1e+05 | 0.8668 | ±0.0084 | s≈150, i≈30, r≈5.0 |\n", + "| 1e+06 | 0.8813 | ±0.0067 | s≈300, i≈28, r≈5.0 |\n", + "\n", + "\n", + "### Performance Improvements Between Resource Levels\n", + "\n", + "- **1e+02 → 1e+03**: +29.70% improvement\n", + "- **1e+03 → 1e+04**: +12.30% improvement\n", + "- **1e+04 → 1e+05**: +5.15% improvement\n", + "- **1e+05 → 1e+06**: +1.68% improvement\n", + "\n", + "\n", + "### Recommendation Strategy Performance\n", + "\n", + "**How close do recommendations get to optimal (Virtual Best)?**\n", + "\n", + "| Resource | TrainingStats | % of VB | TrainingResults | % of VB | Difference |\n", + "|----------|-------------:|--------:|----------------:|--------:|-----------:|\n", + "| 1e+03 | 0.7340 | 100.0% | 0.7340 | 100.0% | 0.0000 |\n", + "| 1e+04 | 0.8197 | 99.4% | 0.8204 | 99.5% | 0.0006 |\n", + "| 1e+05 | 0.8657 | 99.9% | 0.8657 | 99.9% | 0.0000 |\n", + "\n", + "\n", + "### Key Insights\n", + "\n", + "\n", + "**Recommended Resource Budget**: ~1e+06 circuit evaluations\n", + "- At this level, you get substantial performance while avoiding diminishing returns\n", + "- Performance: ~0.8813 approximation ratio\n", + "\n", + "\n", + "**Recommended Strategy**: **TrainingStats** (universal parameters work well - difference < 0.02)\n", + "- Average difference between strategies: 0.0002\n", + "\n", + "\n", + "**vs. Classical Algorithms**: At 10⁵ evaluations, QAOA achieves 0.8668, which is **Competitive** with classical methods (GW: 0.878)\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "✅ Results summary saved to: results_summary.md\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# Generate Filled Conclusions with Actual Data\n", + "# ============================================================\n", + "# This cell creates a markdown summary with actual performance values\n", + "# extracted from the analysis above\n", + "\n", + "from IPython.display import Markdown\n", + "\n", + "# Build the conclusions with actual data\n", + "conclusions_md = f\"\"\"\n", + "## Summary of Results with Actual Performance Data\n", + "\n", + "### Virtual Best Performance (Oracle Upper Bound)\n", + "\n", + "The table below shows the **best achievable approximation ratio** at each resource level:\n", + "\n", + "| Resource Level | Approximation Ratio | Confidence Interval | Optimal Parameters |\n", + "|----------------|--------------------:|--------------------:|:-------------------|\n", + "\"\"\"\n", + "\n", + "# Add rows for each resource level\n", + "for resource in resource_levels:\n", + " approx_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " ci_lower = get_value_at_resource(vb_perf, resource, 'response_lower')\n", + " ci_upper = get_value_at_resource(vb_perf, resource, 'response_upper')\n", + " \n", + " if approx_ratio is not None:\n", + " ci_range = (ci_upper - ci_lower) / 2 if (ci_upper and ci_lower) else 0\n", + " \n", + " # Get parameters\n", + " shots = get_value_at_resource(vb_params, resource, 'shots')\n", + " iterations = get_value_at_resource(vb_params, resource, 'iterations')\n", + " rounds_val = get_value_at_resource(vb_params, resource, 'rounds')\n", + " \n", + " param_str = f\"s≈{shots:.0f}, i≈{iterations:.0f}, r≈{rounds_val:.1f}\" if all(v is not None for v in [shots, iterations, rounds_val]) else \"N/A\"\n", + " \n", + " conclusions_md += f\"| {resource:.0e} | {approx_ratio:.4f} | ±{ci_range:.4f} | {param_str} |\\n\"\n", + "\n", + "# Add performance improvements\n", + "conclusions_md += f\"\"\"\n", + "\n", + "### Performance Improvements Between Resource Levels\n", + "\n", + "\"\"\"\n", + "\n", + "prev_approx = None\n", + "for i, resource in enumerate(resource_levels):\n", + " approx_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " if approx_ratio is not None:\n", + " if prev_approx is not None:\n", + " improvement = ((approx_ratio - prev_approx) / prev_approx * 100)\n", + " conclusions_md += f\"- **{resource_levels[i-1]:.0e} → {resource:.0e}**: +{improvement:.2f}% improvement\\n\"\n", + " prev_approx = approx_ratio\n", + "\n", + "# Add recommendation strategy performance\n", + "if proj_stats_perf is not None or proj_results_perf is not None:\n", + " conclusions_md += f\"\"\"\n", + "\n", + "### Recommendation Strategy Performance\n", + "\n", + "**How close do recommendations get to optimal (Virtual Best)?**\n", + "\n", + "\"\"\"\n", + " \n", + " if proj_stats_perf is not None and proj_results_perf is not None:\n", + " conclusions_md += \"| Resource | TrainingStats | % of VB | TrainingResults | % of VB | Difference |\\n\"\n", + " conclusions_md += \"|----------|-------------:|--------:|----------------:|--------:|-----------:|\\n\"\n", + " \n", + " for resource in [1e3, 1e4, 1e5]:\n", + " vb_ratio = get_value_at_resource(vb_perf, resource, 'response')\n", + " stats_ratio = get_value_at_resource(proj_stats_perf, resource, 'response')\n", + " results_ratio = get_value_at_resource(proj_results_perf, resource, 'response')\n", + " \n", + " if all(v is not None for v in [vb_ratio, stats_ratio, results_ratio]):\n", + " stats_pct = (stats_ratio / vb_ratio * 100) if vb_ratio > 0 else 0\n", + " results_pct = (results_ratio / vb_ratio * 100) if vb_ratio > 0 else 0\n", + " diff = abs(stats_ratio - results_ratio)\n", + " \n", + " conclusions_md += f\"| {resource:.0e} | {stats_ratio:.4f} | {stats_pct:.1f}% | {results_ratio:.4f} | {results_pct:.1f}% | {diff:.4f} |\\n\"\n", + "\n", + "# Add interpretation\n", + "conclusions_md += f\"\"\"\n", + "\n", + "### Key Insights\n", + "\n", + "\"\"\"\n", + "\n", + "# Determine sweet spot (where improvement rate drops)\n", + "improvements = []\n", + "for i in range(1, len(resource_levels)):\n", + " prev_approx = get_value_at_resource(vb_perf, resource_levels[i-1], 'response')\n", + " curr_approx = get_value_at_resource(vb_perf, resource_levels[i], 'response')\n", + " if prev_approx is not None and curr_approx is not None:\n", + " improvements.append((resource_levels[i], (curr_approx - prev_approx) / prev_approx * 100))\n", + "\n", + "if len(improvements) > 0:\n", + " # Find where improvement drops below threshold\n", + " sweet_spot_idx = next((i for i, (r, imp) in enumerate(improvements) if imp < 5.0), len(improvements)-1)\n", + " sweet_spot = improvements[sweet_spot_idx][0]\n", + " \n", + " conclusions_md += f\"\"\"\n", + "**Recommended Resource Budget**: ~{sweet_spot:.0e} circuit evaluations\n", + "- At this level, you get substantial performance while avoiding diminishing returns\n", + "- Performance: ~{get_value_at_resource(vb_perf, sweet_spot, 'response'):.4f} approximation ratio\n", + "\"\"\"\n", + "\n", + "# Strategy recommendation\n", + "if proj_stats_perf is not None and proj_results_perf is not None:\n", + " avg_diff = np.mean([\n", + " abs(get_value_at_resource(proj_stats_perf, r, 'response') - \n", + " get_value_at_resource(proj_results_perf, r, 'response'))\n", + " for r in [1e3, 1e4, 1e5]\n", + " if get_value_at_resource(proj_stats_perf, r, 'response') is not None\n", + " and get_value_at_resource(proj_results_perf, r, 'response') is not None\n", + " ])\n", + " \n", + " if avg_diff < 0.02:\n", + " strategy_rec = \"**TrainingStats** (universal parameters work well - difference < 0.02)\"\n", + " elif avg_diff > 0.05:\n", + " strategy_rec = \"**TrainingResults** (instance-specific tuning beneficial - difference > 0.05)\"\n", + " else:\n", + " strategy_rec = \"**Either strategy** (moderate difference suggests both are viable)\"\n", + " \n", + " conclusions_md += f\"\"\"\n", + "\n", + "**Recommended Strategy**: {strategy_rec}\n", + "- Average difference between strategies: {avg_diff:.4f}\n", + "\"\"\"\n", + "\n", + "# Comparison to classical\n", + "vb_at_1e5 = get_value_at_resource(vb_perf, 1e5, 'response')\n", + "if vb_at_1e5 is not None:\n", + " gw_ratio = 0.878 # Goemans-Williamson for Max-Cut\n", + " \n", + " if vb_at_1e5 >= gw_ratio:\n", + " classical_comp = f\"**Exceeds** classical Goemans-Williamson ({gw_ratio:.3f})\"\n", + " elif vb_at_1e5 >= 0.85:\n", + " classical_comp = f\"**Competitive** with classical methods (GW: {gw_ratio:.3f})\"\n", + " else:\n", + " classical_comp = f\"**Below** classical Goemans-Williamson ({gw_ratio:.3f})\"\n", + " \n", + " conclusions_md += f\"\"\"\n", + "\n", + "**vs. Classical Algorithms**: At 10⁵ evaluations, QAOA achieves {vb_at_1e5:.4f}, which is {classical_comp}\n", + "\"\"\"\n", + "\n", + "# Display the generated markdown\n", + "display(Markdown(conclusions_md))\n", + "\n", + "# Optionally save to file\n", + "with open(os.path.join(here, \"results_summary.md\"), \"w\") as f:\n", + " f.write(conclusions_md)\n", + " \n", + "print(\"\\n✅ Results summary saved to: results_summary.md\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusions: QAOA Performance and Parameter Recommendations\n", + "\n", + "This notebook demonstrated the stochastic benchmarking workflow for analyzing QAOA performance on 10 Max-Cut problem instances. The analysis quantifies what approximation ratios can be achieved with different resource budgets and parameter configurations.\n", + "\n", + "---\n", + "\n", + "### Summary\n", + "\n", + "**See the automated results summary above** for detailed performance metrics, including:\n", + "\n", + "1. **Virtual Best Performance**: Best achievable approximation ratios at each resource level (10² to 10⁶ circuit evaluations) with optimal parameter configurations\n", + "2. **Performance Improvements**: Quantified gains between resource levels to identify diminishing returns\n", + "3. **Recommendation Strategy Performance**: Comparison of TrainingStats vs. TrainingResults approaches\n", + "4. **Key Insights**: Recommended resource budget, recommended strategy, and comparison to classical algorithms\n", + "\n", + "The summary table shows actual values extracted from the analysis and provides actionable recommendations for:\n", + "- Which resource budget to use (sweet spot balancing performance vs. cost)\n", + "- Which parameter recommendation strategy to employ (universal vs. instance-specific)\n", + "- Expected performance relative to classical approximation algorithms\n", + "\n", + "---\n", + "\n", + "### Interpreting the Results\n", + "\n", + "#### Virtual Best as an Upper Bound\n", + "\n", + "The **Virtual Best baseline** represents perfect hindsight—the best performance achievable if you knew the optimal parameters for each instance in advance. This is an **oracle** that cannot be achieved in practice but serves as a useful benchmark.\n", + "\n", + "**Key insight**: The closer a recommendation strategy gets to Virtual Best, the better it performs. Gaps between recommendation strategies and Virtual Best indicate room for improvement.\n", + "\n", + "#### Recommendation Strategies\n", + "\n", + "Two strategies were evaluated:\n", + "\n", + "1. **TrainingStats** (aggregate-then-recommend):\n", + " - Finds parameters that work best for the **average** instance\n", + " - Good when instances share similar characteristics\n", + " - Simpler, more robust to outliers\n", + "\n", + "2. **TrainingResults** (instance-specific-then-average):\n", + " - Averages the best parameters found for **individual** instances\n", + " - Captures instance-specific preferences\n", + " - Better when instances have diverse optimal parameters\n", + "\n", + "**Which to use?** Check the strategy comparison in the summary above. If the difference is small (< 0.02), either works well. If large (> 0.05), instance-specific tuning (TrainingResults) may be beneficial.\n", + "\n", + "#### Resource Budget Planning\n", + "\n", + "The performance improvements table in the summary shows how much you gain by increasing your computational budget:\n", + "\n", + "- **High % improvement** (> 10%): Significant gains, budget increase is worthwhile\n", + "- **Moderate % improvement** (5-10%): Meaningful gains, evaluate cost-benefit\n", + "- **Low % improvement** (< 5%): Diminishing returns, may not justify additional cost\n", + "\n", + "The \"sweet spot\" recommendation identifies where you get substantial performance while avoiding diminishing returns.\n", + "\n", + "#### Parameter Scaling Insights\n", + "\n", + "Examine the **parameter plots** above to understand:\n", + "\n", + "- **How parameters change with resources**: Do they increase linearly, logarithmically, or plateau?\n", + "- **Resource allocation**: At your budget level, how should you split resources between shots, iterations, and rounds?\n", + "- **Sensitivity**: Which parameters have the biggest impact on performance?\n", + "\n", + "These insights help you configure QAOA effectively when working with new problem instances.\n", + "\n", + "---\n", + "\n", + "### Practical Guidelines for QAOA Users\n", + "\n", + "#### 1. Choose Your Resource Budget\n", + "\n", + "Based on your computational constraints and performance requirements:\n", + "- **Limited budget** (< 10⁴ evaluations): Expect moderate performance; focus on high shots for noise reduction\n", + "- **Standard budget** (10⁴-10⁵ evaluations): Good performance-cost balance; see summary for expected approximation ratio\n", + "- **High budget** (> 10⁵ evaluations): Near-optimal performance; check if gains justify additional cost\n", + "\n", + "#### 2. Configure Parameters\n", + "\n", + "Use the Virtual Best optimal parameters from the summary table at your chosen resource level as starting values:\n", + "- **shots**: Number of measurements per circuit evaluation\n", + "- **iterations**: Number of classical optimizer steps\n", + "- **rounds**: QAOA depth (p parameter)\n", + "\n", + "These represent the best configurations found across the test instances.\n", + "\n", + "#### 3. Select Recommendation Strategy\n", + "\n", + "- If your problem instances are **similar**: Use TrainingStats (universal parameters)\n", + "- If your problem instances are **diverse**: Use TrainingResults (instance-adapted parameters)\n", + "- If **uncertain**: Check strategy comparison in summary; small difference means either works\n", + "\n", + "#### 4. Set Performance Expectations\n", + "\n", + "The summary provides expected approximation ratios at each resource level. Use these to:\n", + "- **Validate** your results are in the expected range\n", + "- **Debug** if performance is significantly below expectations\n", + "- **Decide** if additional resources would meaningfully improve results\n", + "\n", + "---\n", + "\n", + "### Comparison to Classical Methods\n", + "\n", + "The summary compares QAOA performance to the Goemans-Williamson algorithm for Max-Cut (~0.878 approximation ratio):\n", + "\n", + "- **Below classical**: QAOA may need more resources or better parameter tuning\n", + "- **Competitive**: QAOA achieves similar performance, demonstrating quantum viability \n", + "- **Exceeds classical**: QAOA shows potential advantage for this problem instance set\n", + "\n", + "**Note**: Comparisons depend on problem size, structure, and instance characteristics. These results are specific to the 10 Max-Cut instances analyzed.\n", + "\n", + "---\n", + "\n", + "### Next Steps\n", + "\n", + "1. **Run the cells above** to generate the performance and parameter plots with your data\n", + "2. **Execute the data extraction cell** to compute metrics from the CSV checkpoints\n", + "3. **Review the automated summary** for filled-in performance values and recommendations\n", + "4. **Examine the plots** to visually verify the trends and identify scaling patterns\n", + "5. **Apply the insights** to configure QAOA for your specific use case\n", + "\n", + "The automated summary (`results_summary.md`) can be included in reports, presentations, or shared with collaborators to communicate the benchmarking results.\n", + "\n", + "---\n", + "\n", + "### Key Takeaway\n", + "\n", + "This benchmarking framework provides a **systematic, data-driven approach** to understanding QAOA performance:\n", + "\n", + "- **Quantifies** expected approximation ratios at different resource levels\n", + "- **Identifies** optimal parameter configurations through Virtual Best analysis \n", + "- **Compares** parameter recommendation strategies objectively\n", + "- **Recommends** resource budgets that balance performance and computational cost\n", + "\n", + "By running this analysis on your own problem instances, you can make informed decisions about QAOA configuration rather than relying on trial-and-error or heuristics." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] } ], "metadata": { "kernelspec": { - "display_name": "stochastic-benchmark", + "display_name": "stochastic-benchmark-ci-py310", "language": "python", "name": "python3" }, @@ -386,7 +1500,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.11" + "version": "3.10.19" } }, "nbformat": 4, diff --git a/examples/QAOA_multipleSplits/qaoa_multiple_splits.ipynb b/examples/QAOA_multipleSplits/qaoa_multiple_splits.ipynb index 93f66101..23bd9be1 100644 --- a/examples/QAOA_multipleSplits/qaoa_multiple_splits.ipynb +++ b/examples/QAOA_multipleSplits/qaoa_multiple_splits.ipynb @@ -1,8 +1,36 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# QAOA Cross-Validation Analysis: Multiple Train/Test Splits\n", + "\n", + "This notebook demonstrates **cross-validation** analysis for QAOA parameter tuning across **10 different train/test splits**. Unlike the single-split analysis in `qaoa_demo.ipynb`, this notebook:\n", + "\n", + "1. **Runs 10 independent train/test splits** (numbered run1 through run10)\n", + "2. **Aggregates results across all splits** to assess robustness and variability\n", + "3. **Visualizes performance and parameters** both aggregated and per-split\n", + "4. **Uses the cross_validation module** to handle multi-split data processing\n", + "\n", + "## Purpose\n", + "\n", + "Cross-validation helps answer:\n", + "- **How robust are parameter recommendations?** Do they work well across different train/test splits?\n", + "- **How variable is performance?** What's the spread in approximation ratios across splits?\n", + "- **Which strategy is most reliable?** TrainingStats vs TrainingResults across multiple splits\n", + "\n", + "## Workflow Overview\n", + "\n", + "1. Load data from 10 independent runs (each with its own train/test split)\n", + "2. Process and aggregate results across splits\n", + "3. Plot aggregated performance with confidence intervals\n", + "4. Examine individual split results for detailed analysis" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -10,84 +38,555 @@ "%autoreload 2" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Modules and Packages\n", + "\n", + "This notebook uses the **cross_validation module** (`cross_validation.py`) which provides specialized tools for aggregating results across multiple train/test splits.\n", + "\n", + "### Key Imports:\n", + "- **cross_validation (cv)**: Handles loading and processing data from multiple split directories\n", + "- **plotting.ws_style**: Consistent matplotlib styling for publication-quality figures\n", + "- **pandas, numpy**: Data manipulation and numerical operations\n", + "- **matplotlib**: Visualization" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "import pandas as pd\n", - "import matplotlib.pyplot as plt\n", - "import os\n", - "import numpy as np\n", + "# ============================================================\n", + "# Import Required Libraries\n", + "# ============================================================\n", + "import pandas as pd # DataFrame operations\n", + "import matplotlib.pyplot as plt # Plotting\n", + "import os # File path operations\n", + "import numpy as np # Numerical operations\n", "import sys\n", - "import matplotlib.pyplot as plt\n", "\n", + "# Add src directory to Python path for importing stochastic_benchmark modules\n", "sys.path.append('../../src/')\n", + "\n", + "# Cross-validation module for handling multiple train/test splits\n", "import cross_validation as cv\n", + "\n", + "# Consistent plotting style for publication-quality figures\n", "from plotting import ws_style\n", "plt.style.use(ws_style)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "parameter_names = ['iterations'\t,'shots', 'rounds']\n", - "# split indices go from 1 to 10\n", + "# ============================================================\n", + "# Algorithm Parameters to Track\n", + "# ============================================================\n", + "# These are the QAOA parameters that were tuned in each run\n", + "parameter_names = ['iterations', 'shots', 'rounds']\n", + "\n", + "# ============================================================\n", + "# Cross-Validation Setup: 10 Independent Train/Test Splits\n", + "# ============================================================\n", + "# Each \"run\" represents an independent train/test split of the problem instances\n", + "# Split indices go from 1 to 10 (run1, run2, ..., run10)\n", "curpath = os.path.abspath('.')\n", - "folders = [os.path.join(curpath, 'runs', 'run{}'.format(split),'checkpoints') for split in range(1,11)]\n", - "list_of_expts = ['Projection from TrainingStats', 'Projection from TrainingResults']\n", - "colors_dict = {'baseline' : 'k',\n", - " 'Projection from TrainingStats' : 'tab:blue',\n", - " 'Projection from TrainingResults' : 'tab:orange',\n", - " 'Random Exploration' : 'green',\n", - " 'SequentialSearch: Id=cold' : 'red',\n", - " 'SequentialSearch: Id=warm' : 'purple'\n", - " }\n", - "response_string = 'Approximation Ratio\\n' + r\"r=$\\frac{\\langle \\vec{\\beta}, \\vec{\\gamma} | H | \\vec{\\beta}, \\vec{\\gamma} \\rangle}{E_{max}}$\" # Used for y-label on plots \n", - "resource_string = r'Resource = Restarts $\\times$ shots $\\times$ COBLYA Iterations' # Used for x-label on plots " + "folders = [\n", + " os.path.join(curpath, 'runs', f'run{split}', 'checkpoints') \n", + " for split in range(1, 11) # 10 splits total\n", + "]\n", + "\n", + "# ============================================================\n", + "# Experiments to Analyze\n", + "# ============================================================\n", + "# Which parameter recommendation strategies to compare across splits\n", + "list_of_expts = [\n", + " 'Projection from TrainingStats', # Aggregate-then-recommend strategy\n", + " 'Projection from TrainingResults' # Instance-specific-then-average strategy\n", + "]\n", + "\n", + "# ============================================================\n", + "# Visualization Configuration\n", + "# ============================================================\n", + "# Color mapping for consistent plotting across all figures\n", + "colors_dict = {\n", + " 'baseline': 'k', # Virtual Best (black)\n", + " 'Projection from TrainingStats': 'tab:blue', # TrainingStats (blue)\n", + " 'Projection from TrainingResults': 'tab:orange', # TrainingResults (orange)\n", + " 'Random Exploration': 'green', # (if present)\n", + " 'SequentialSearch: Id=cold': 'red', # (if present)\n", + " 'SequentialSearch: Id=warm': 'purple' # (if present)\n", + "}\n", + "\n", + "# Axis labels with mathematical notation\n", + "response_string = (\n", + " 'Approximation Ratio\\n' + \n", + " r\"r=$\\frac{\\langle \\vec{\\beta}, \\vec{\\gamma} | H | \\vec{\\beta}, \\vec{\\gamma} \\rangle}{E_{max}}$\"\n", + ")\n", + "resource_string = r'Resource = Restarts $\\times$ shots $\\times$ COBYLA Iterations'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configuration: Cross-Validation Setup\n", + "\n", + "This cell configures the cross-validation analysis by specifying:\n", + "\n", + "1. **Parameter names** to track across splits (iterations, shots, rounds)\n", + "2. **Data directories** for the 10 independent runs (run1 through run10)\n", + "3. **Experiments to analyze** (projection strategies)\n", + "4. **Visualization settings** (colors, axis labels)\n", + "\n", + "### Directory Structure\n", + "\n", + "Each run directory (`runs/run1/`, `runs/run2/`, ..., `runs/run10/`) contains:\n", + "- `checkpoints/performance_plotting/`: Performance CSVs for each experiment\n", + "- `checkpoints/params_plotting/`: Parameter recommendation CSVs\n", + "\n", + "The cross_validation module will load data from all these directories and aggregate results." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading parameter data from all splits...\n", + "Loaded parameter data for 3 experiments\n", + "Aggregating parameter data across splits...\n", + "Aggregated parameters across splits\n", + "\n", + "Loading performance data from all splits...\n", + "Loaded performance data for 3 experiments\n", + "Aggregating performance data across splits...\n", + "Warning: Error aggregating performance: The value of stats_measure can only be mean or median\n", + "\n", + "============================================================\n", + "DATA LOADING SUMMARY\n", + "============================================================\n", + "Experiments with parameter data: ['baseline', 'Projection from TrainingStats', 'Projection from TrainingResults']\n", + "Experiments with performance data: ['baseline', 'Projection from TrainingStats', 'Projection from TrainingResults']\n", + "Number of splits configured: 10\n", + "============================================================\n", + "Loaded performance data for 3 experiments\n", + "Aggregating performance data across splits...\n", + "Warning: Error aggregating performance: The value of stats_measure can only be mean or median\n", + "\n", + "============================================================\n", + "DATA LOADING SUMMARY\n", + "============================================================\n", + "Experiments with parameter data: ['baseline', 'Projection from TrainingStats', 'Projection from TrainingResults']\n", + "Experiments with performance data: ['baseline', 'Projection from TrainingStats', 'Projection from TrainingResults']\n", + "Number of splits configured: 10\n", + "============================================================\n" + ] + } + ], "source": [ - "# Load data for parameter plotting\n", - "cv.load_parameters(folders, list_of_expts)\n", - "cv.process_params_across_splits(parameter_names)\n", - "\n", - "# Load data for performance plotting\n", - "cv.load_performance(folders, list_of_expts)\n", - "cv.process_performance_across_splits(parameter_names)\n", - "# pd.read_csv(os.path.join(folders[0], 'params_plotting', 'baseline.csv'))" + "# ============================================================\n", + "# Load Parameter Data from All Splits\n", + "# ============================================================\n", + "# Reads CSV files from checkpoints/params_plotting/ for each split\n", + "# - Loads baseline (Virtual Best) and projection experiments\n", + "# - Concatenates data across all 10 splits\n", + "# - Stores in cv.parameters_dict[experiment_name]\n", + "print(\"Loading parameter data from all splits...\")\n", + "try:\n", + " cv.load_parameters(folders, list_of_expts)\n", + " print(f\"Loaded parameter data for {len(cv.parameters_dict)} experiments\")\n", + "except Exception as e:\n", + " print(f\"Warning: Error loading parameter data: {e}\")\n", + " print(\"Continuing with available data...\")\n", + "\n", + "# Aggregate parameter data across splits\n", + "# - Computes mean parameter values across splits\n", + "# - Calculates confidence intervals\n", + "# - Stores in cv.parameters_summarized_dict[experiment][parameter]\n", + "if len(cv.parameters_dict) > 0:\n", + " print(\"Aggregating parameter data across splits...\")\n", + " try:\n", + " cv.process_params_across_splits(parameter_names)\n", + " print(\"Aggregated parameters across splits\")\n", + " except Exception as e:\n", + " print(f\"Warning: Error aggregating parameters: {e}\")\n", + "else:\n", + " print(\"Warning: No parameter data loaded - skipping aggregation\")\n", + "\n", + "# ============================================================\n", + "# Load Performance Data from All Splits \n", + "# ============================================================\n", + "# Reads CSV files from checkpoints/performance_plotting/ for each split\n", + "# - Loads baseline and projection experiments\n", + "# - Option to interpolate to common resource grid (disabled if causing issues)\n", + "# - Stores in cv.performance_dict[experiment_name]\n", + "print(\"\\nLoading performance data from all splits...\")\n", + "try:\n", + " # Try with interpolation disabled first (more robust)\n", + " cv.load_performance(\n", + " folders, \n", + " list_of_expts,\n", + " interpolate_flag=False # Disable interpolation to avoid errors with missing data\n", + " )\n", + " print(f\"Loaded performance data for {len(cv.performance_dict)} experiments\")\n", + "except Exception as e:\n", + " print(f\"Warning: Error loading performance data: {e}\")\n", + " print(\"Continuing with available data...\")\n", + "\n", + "# Aggregate performance data across splits\n", + "# - Computes mean approximation ratio across splits\n", + "# - Calculates confidence intervals \n", + "# - Stores in cv.performance_summarized_dict[experiment]\n", + "if len(cv.performance_dict) > 0:\n", + " print(\"Aggregating performance data across splits...\")\n", + " try:\n", + " cv.process_performance_across_splits(parameter_names)\n", + " print(\"Aggregated performance across splits\")\n", + " except Exception as e:\n", + " print(f\"Warning: Error aggregating performance: {e}\")\n", + "else:\n", + " print(\"Warning: No performance data loaded - skipping aggregation\")\n", + "\n", + "print(\"\\n\" + \"=\" * 60)\n", + "print(\"DATA LOADING SUMMARY\")\n", + "print(\"=\" * 60)\n", + "print(f\"Experiments with parameter data: {list(cv.parameters_dict.keys())}\")\n", + "print(f\"Experiments with performance data: {list(cv.performance_dict.keys())}\")\n", + "print(f\"Number of splits configured: {len(folders)}\")\n", + "print(\"=\" * 60)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Plot Parameters" + "## Load and Process Cross-Validation Data\n", + "\n", + "This section loads results from all 10 train/test splits and aggregates them for analysis.\n", + "\n", + "### Optional: Check Data Availability First\n", + "\n", + "The cell below can be run to verify which data files exist before attempting to load them. This is useful for:\n", + "- **Debugging**: Understanding why loading might fail\n", + "- **Validation**: Ensuring all expected experiments have been completed\n", + "- **Planning**: Identifying which splits or experiments need to be re-run\n", + "\n", + "**You can skip this cell if you're confident all data files exist.**\n", + "\n", + "### Data Loading Process\n", + "\n", + "**For Parameters:**\n", + "1. `cv.load_parameters()` - Loads parameter CSV files from each split's `checkpoints/params_plotting/` directory\n", + "2. `cv.process_params_across_splits()` - Aggregates across splits, computing mean and confidence intervals\n", + "\n", + "**For Performance:**\n", + "1. `cv.load_performance()` - Loads performance CSV files from each split's `checkpoints/performance_plotting/` directory\n", + "2. `cv.process_performance_across_splits()` - Aggregates across splits, computing mean and confidence intervals\n", + "\n", + "### Output Data Structures\n", + "\n", + "After processing, the following dictionaries are populated:\n", + "- `cv.parameters_dict[expt]` - Raw parameter data for each experiment across all splits\n", + "- `cv.parameters_summarized_dict[expt][param]` - Aggregated statistics (mean, CI_lower, CI_upper) for each parameter\n", + "- `cv.performance_dict[expt]` - Raw performance data for each experiment across all splits \n", + "- `cv.performance_summarized_dict[expt]` - Aggregated performance statistics (mean, CI_lower, CI_upper)\n", + "\n", + "**Note:** If any CSV files are missing, warnings will be displayed but processing will continue with available data." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Checking data availability across splits...\n", + "\n", + "Split 1 (run1):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 2 (run2):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 3 (run3):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 4 (run4):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 5 (run5):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 6 (run6):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 7 (run7):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 8 (run8):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 9 (run9):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "Split 10 (run10):\n", + " params_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + " performance_plotting: 3 files\n", + " [OK] baseline.csv\n", + " [OK] Projection from TrainingStats.csv\n", + " [OK] Projection from TrainingResults.csv\n", + "\n", + "============================================================\n", + "DATA AVAILABILITY SUMMARY\n", + "============================================================\n", + "Checkpoint folders found: 10/10\n", + "\n", + "Parameter data availability:\n", + " [COMPLETE] baseline: 10/10 splits\n", + " [COMPLETE] Projection from TrainingStats: 10/10 splits\n", + " [COMPLETE] Projection from TrainingResults: 10/10 splits\n", + "\n", + "Performance data availability:\n", + " [COMPLETE] baseline: 10/10 splits\n", + " [COMPLETE] Projection from TrainingStats: 10/10 splits\n", + " [COMPLETE] Projection from TrainingResults: 10/10 splits\n", + "============================================================\n" + ] + } + ], + "source": [ + "# ============================================================\n", + "# Check Data Availability (Optional - for debugging)\n", + "# ============================================================\n", + "# Verify which data files actually exist before attempting to load\n", + "print(\"Checking data availability across splits...\\n\")\n", + "\n", + "experiments_to_check = ['baseline'] + list_of_expts\n", + "data_types = ['params_plotting', 'performance_plotting']\n", + "\n", + "# Track availability statistics\n", + "availability_stats = {\n", + " 'total_splits': len(folders),\n", + " 'existing_folders': 0,\n", + " 'params_available': {expt: 0 for expt in experiments_to_check},\n", + " 'performance_available': {expt: 0 for expt in experiments_to_check}\n", + "}\n", + "\n", + "for split_idx, folder in enumerate(folders):\n", + " print(f\"Split {split_idx + 1} ({os.path.basename(os.path.dirname(folder))}):\")\n", + " \n", + " # Check if checkpoints folder exists\n", + " if not os.path.exists(folder):\n", + " print(f\" [MISSING] Checkpoints folder: {folder}\")\n", + " continue\n", + " \n", + " availability_stats['existing_folders'] += 1\n", + " \n", + " # Check each data type\n", + " for data_type in data_types:\n", + " data_dir = os.path.join(folder, data_type)\n", + " if os.path.exists(data_dir):\n", + " # List available CSV files\n", + " csv_files = [f for f in os.listdir(data_dir) if f.endswith('.csv')]\n", + " print(f\" {data_type}: {len(csv_files)} files\")\n", + " \n", + " # Check which experiments have files\n", + " for expt in experiments_to_check:\n", + " expected_file = os.path.join(data_dir, f\"{expt}.csv\")\n", + " if os.path.exists(expected_file):\n", + " print(f\" [OK] {expt}.csv\")\n", + " # Track availability\n", + " if data_type == 'params_plotting':\n", + " availability_stats['params_available'][expt] += 1\n", + " else:\n", + " availability_stats['performance_available'][expt] += 1\n", + " else:\n", + " print(f\" [MISSING] {expt}.csv\")\n", + " else:\n", + " print(f\" [MISSING] {data_type} directory\")\n", + " print()\n", + "\n", + "# Print summary statistics\n", + "print(\"=\" * 60)\n", + "print(\"DATA AVAILABILITY SUMMARY\")\n", + "print(\"=\" * 60)\n", + "print(f\"Checkpoint folders found: {availability_stats['existing_folders']}/{availability_stats['total_splits']}\")\n", + "print()\n", + "\n", + "print(\"Parameter data availability:\")\n", + "for expt, count in availability_stats['params_available'].items():\n", + " status = \"[COMPLETE]\" if count == availability_stats['total_splits'] else \"[INCOMPLETE]\"\n", + " print(f\" {status} {expt}: {count}/{availability_stats['total_splits']} splits\")\n", + "\n", + "print()\n", + "print(\"Performance data availability:\")\n", + "for expt, count in availability_stats['performance_available'].items():\n", + " status = \"[COMPLETE]\" if count == availability_stats['total_splits'] else \"[INCOMPLETE]\"\n", + " print(f\" {status} {expt}: {count}/{availability_stats['total_splits']} splits\")\n", + "\n", + "print(\"=\" * 60)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Aggregated Parameter Plots Across All Splits\n", + "\n", + "These plots show how **parameter recommendations** evolve with resources, **aggregated across all 10 train/test splits**.\n", + "\n", + "### What This Shows:\n", + "\n", + "For each algorithm parameter (iterations, shots, rounds):\n", + "- **Mean parameter values** across all splits at each resource level\n", + "- **Confidence intervals** (shaded regions) showing variability across splits\n", + "- **Virtual Best** (black) vs **Projection strategies** (colored)\n", + "\n", + "### Interpreting Confidence Intervals:\n", + "\n", + "- **Narrow intervals**: Parameter recommendations are consistent across different train/test splits (robust)\n", + "- **Wide intervals**: Recommendations vary significantly depending on which instances are in train vs test sets (less robust)\n", + "\n", + "The plots help assess whether parameter recommendations are stable or sensitive to the particular train/test split." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "# ============================================================\n", + "# Plot Aggregated Parameters Across All Splits\n", + "# ============================================================\n", + "# Creates one plot per parameter showing mean and confidence intervals\n", + "# aggregated across all 10 train/test splits\n", + "\n", "for param in parameter_names:\n", " fig, axs = plt.subplots()\n", + " \n", + " # Plot each experiment's aggregated parameter values\n", " for expt in cv.parameters_summarized_dict.keys():\n", " expt_param_df = cv.parameters_summarized_dict[expt][param]\n", + " \n", + " # Extract mean and confidence interval bounds\n", " y = expt_param_df['mean']\n", " x = expt_param_df['resource']\n", " y_u = expt_param_df['CI_u']\n", " y_l = expt_param_df['CI_l']\n", + " \n", + " # Style configuration\n", " if expt == 'baseline':\n", " lw = 1\n", " alpha = 0.1\n", @@ -97,8 +596,11 @@ " alpha = 0.25\n", " label = expt\n", " \n", - " axs.fill_between(x, y_l, y_u ,alpha=alpha, lw=0, color=colors_dict[expt])\n", - " axs.plot(x, y , '-o', lw=lw, color=colors_dict[expt], label=label)\n", + " # Plot confidence interval and mean line\n", + " axs.fill_between(x, y_l, y_u, alpha=alpha, lw=0, color=colors_dict[expt])\n", + " axs.plot(x, y, '-o', lw=lw, color=colors_dict[expt], label=label)\n", + " \n", + " # Configure axes and styling\n", " axs.set_xscale('log')\n", " axs.set_xlabel(resource_string)\n", " axs.set_ylabel(param)\n", @@ -107,33 +609,73 @@ " axs.legend(loc='best')\n", " fig.tight_layout()\n", " \n", - " figsaveloc = os.path.join('figures','all_splits')\n", - " if not os.path.exists(figsaveloc): os.makedirs(figsaveloc)\n", - " figname = os.path.join(figsaveloc, param)\n", - " fig.savefig(figname+'.png', dpi=300)\n", - " fig.savefig(figname+'.pdf')\n" + " # Optionally save figures (commented out by default)\n", + " # figsaveloc = os.path.join('figures', 'all_splits')\n", + " # if not os.path.exists(figsaveloc): \n", + " # os.makedirs(figsaveloc)\n", + " # figname = os.path.join(figsaveloc, param)\n", + " # fig.savefig(figname + '.png', dpi=300)\n", + " # fig.savefig(figname + '.pdf')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Plot Performance" + "## Aggregated Performance Plot Across All Splits\n", + "\n", + "This plot shows the **approximation ratio** (performance metric) aggregated across all 10 train/test splits.\n", + "\n", + "### What This Shows:\n", + "\n", + "- **Mean approximation ratio** at each resource level, averaged across all splits\n", + "- **Confidence intervals** (shaded regions) showing performance variability across splits\n", + "- **Virtual Best** (black): Oracle baseline using perfect hindsight\n", + "- **Projection strategies** (colored): Different parameter recommendation approaches\n", + "\n", + "### Key Insights:\n", + "\n", + "- **Convergence to Virtual Best**: How close do the strategies get to optimal performance?\n", + "- **Consistency across splits**: Narrow confidence intervals indicate reliable performance regardless of train/test split\n", + "- **Resource efficiency**: Which strategy achieves good performance with fewer resources?\n", + "\n", + "This is the primary plot for comparing the effectiveness of different parameter recommendation strategies in a cross-validation setting." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ + "# ============================================================\n", + "# Plot Aggregated Performance Across All Splits\n", + "# ============================================================\n", + "# Shows mean approximation ratio and confidence intervals\n", + "# aggregated across all 10 train/test splits\n", + "\n", "fig, axs = plt.subplots()\n", "\n", + "# Plot each experiment's aggregated performance\n", "for expt, expt_df in cv.performance_summarized_dict.items():\n", + " # Extract mean and confidence interval bounds\n", " x = expt_df['resource']\n", " y = expt_df['mean']\n", " y_u = expt_df['CI_u']\n", " y_l = expt_df['CI_l']\n", + " \n", + " # Style configuration based on experiment type\n", " if expt == 'baseline':\n", " lw = 1\n", " alpha = 0.1\n", @@ -142,8 +684,12 @@ " lw = 1.5\n", " alpha = 0.25\n", " label = expt\n", + " \n", + " # Plot confidence interval and mean line\n", " axs.fill_between(x, y_l, y_u, alpha=alpha, lw=0, color=colors_dict[expt])\n", " axs.plot(x, y, '-o', lw=lw, color=colors_dict[expt], label=label)\n", + "\n", + "# Configure axes and styling\n", "axs.set_xscale('log')\n", "axs.set_xlabel(resource_string)\n", "axs.set_ylabel(response_string)\n", @@ -152,50 +698,114 @@ "axs.legend(loc='best')\n", "fig.tight_layout()\n", "\n", - "figsaveloc = os.path.join('figures','all_splits')\n", - "if not os.path.exists(figsaveloc): os.makedirs(figsaveloc)\n", - "figname = os.path.join(figsaveloc, 'performance')\n", - "fig.savefig(figname+'.png', dpi=300)\n", - "fig.savefig(figname+'.pdf')" + "# Optionally save figure (commented out by default)\n", + "# figsaveloc = os.path.join('figures', 'all_splits')\n", + "# if not os.path.exists(figsaveloc): \n", + "# os.makedirs(figsaveloc)\n", + "# figname = os.path.join(figsaveloc, 'performance')\n", + "# fig.savefig(figname + '.png', dpi=300)\n", + "# fig.savefig(figname + '.pdf')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Individual splits" + "## Individual Split Analysis\n", + "\n", + "While aggregated plots show overall trends, examining **individual splits** can reveal:\n", + "- **Outlier splits**: Which train/test splits behave differently?\n", + "- **Split-specific patterns**: Are some splits easier/harder than others?\n", + "- **Recommendation stability**: Do parameter recommendations vary wildly between splits?\n", + "\n", + "### How to Use This Section:\n", + "\n", + "1. **Select a split**: Change `split_ind` to examine different splits (0-9 for run1-run10)\n", + "2. **Compare to aggregated plots**: How does this split compare to the mean behavior?\n", + "3. **Look for anomalies**: Unusually wide gaps or different convergence patterns\n", + "\n", + "This detailed view helps understand what contributes to the confidence intervals in the aggregated plots." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "split_ind=0" + "# ============================================================\n", + "# Select Split to Examine\n", + "# ============================================================\n", + "# split_ind ranges from 0 to 9, corresponding to run1 through run10\n", + "# Change this value to examine different train/test splits\n", + "split_ind = 0 # Examine run1 (first split)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Plot parameters\n", + "# ============================================================\n", + "# Plot Parameters for Selected Split\n", + "# ============================================================\n", + "# Shows parameter recommendations for a single train/test split\n", + "# Compare to aggregated plots to see split-specific variations\n", + "\n", "for param in parameter_names:\n", " fig, axs = plt.subplots()\n", + " \n", + " # Plot each experiment's parameter values for this split\n", " for expt, expt_df in cv.parameters_dict.items():\n", + " # Filter data for selected split\n", " expt_split_df = expt_df[expt_df['split_ind'] == split_ind]\n", " x = expt_split_df['resource']\n", " y = expt_split_df[param]\n", - " label = expt\n", + " \n", + " # Style configuration\n", " if expt == 'baseline':\n", " lw = 1\n", " label = 'VirtualBest'\n", " else:\n", " lw = 1.5\n", - " axs.plot(x, y , '-o', lw=lw, color=colors_dict[expt], label=label)\n", + " label = expt\n", + " \n", + " # Plot parameter trajectory\n", + " axs.plot(x, y, '-o', lw=lw, color=colors_dict[expt], label=label)\n", " \n", + " # Configure axes and styling\n", " axs.set_xscale('log')\n", " axs.set_xlabel(resource_string)\n", " axs.set_ylabel(param)\n", @@ -204,27 +814,48 @@ " axs.legend(loc='best')\n", " fig.tight_layout()\n", " \n", - " figsaveloc = os.path.join('figures','split_ind={}'.format(split_ind))\n", - " if not os.path.exists(figsaveloc): os.makedirs(figsaveloc)\n", - " figname = os.path.join(figsaveloc, param)\n", - " fig.savefig(figname+'.png', dpi=300)\n", - " fig.savefig(figname+'.pdf')" + " # Optionally save figures (commented out by default)\n", + " # figsaveloc = os.path.join('figures', f'split_ind={split_ind}')\n", + " # if not os.path.exists(figsaveloc): \n", + " # os.makedirs(figsaveloc)\n", + " # figname = os.path.join(figsaveloc, param)\n", + " # fig.savefig(figname + '.png', dpi=300)\n", + " # fig.savefig(figname + '.pdf')" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "# Plot performance\n", + "# ============================================================\n", + "# Plot Performance for Selected Split\n", + "# ============================================================\n", + "# Shows approximation ratio for a single train/test split\n", + "# Individual split CIs (if present) show bootstrap uncertainty within that split\n", + "\n", "fig, axs = plt.subplots()\n", "\n", + "# Plot each experiment's performance for this split\n", "for expt, expt_df in cv.performance_dict.items():\n", + " # Filter data for selected split\n", " expt_split_df = expt_df[expt_df['split_ind'] == split_ind]\n", " y = expt_split_df['response']\n", " x = expt_split_df['resource']\n", - " label = expt\n", + " \n", + " # Style configuration\n", " if expt == 'baseline':\n", " lw = 1\n", " alpha = 0.1\n", @@ -232,15 +863,18 @@ " else:\n", " lw = 1.5\n", " alpha = 0.25\n", + " label = expt\n", " \n", - " axs.plot(x, y , '-o', lw=lw, color=colors_dict[expt], label=label)\n", + " # Plot performance trajectory\n", + " axs.plot(x, y, '-o', lw=lw, color=colors_dict[expt], label=label)\n", + " \n", + " # Add confidence intervals if available (bootstrap CIs within this split)\n", " if 'response_lower' in expt_split_df.columns:\n", - " # Add CI, if they exist in the data\n", " y_u = expt_split_df['response_upper']\n", " y_l = expt_split_df['response_lower']\n", - " axs.fill_between(x, y_l, y_u ,alpha=alpha, lw=0, color=colors_dict[expt])\n", - " \n", - " \n", + " axs.fill_between(x, y_l, y_u, alpha=alpha, lw=0, color=colors_dict[expt])\n", + "\n", + "# Configure axes and styling\n", "axs.set_xscale('log')\n", "axs.set_xlabel(resource_string)\n", "axs.set_ylabel(response_string)\n", @@ -249,17 +883,74 @@ "axs.legend(loc='best')\n", "fig.tight_layout()\n", "\n", - "figsaveloc = os.path.join('figures','split_ind={}'.format(split_ind))\n", - "if not os.path.exists(figsaveloc): os.makedirs(figsaveloc)\n", - "figname = os.path.join(figsaveloc, 'performance')\n", - "fig.savefig(figname+'.png', dpi=300)\n", - "fig.savefig(figname+'.pdf')" + "# Optionally save figure (commented out by default)\n", + "# figsaveloc = os.path.join('figures', f'split_ind={split_ind}')\n", + "# if not os.path.exists(figsaveloc): \n", + "# os.makedirs(figsaveloc)\n", + "# figname = os.path.join(figsaveloc, 'performance')\n", + "# fig.savefig(figname + '.png', dpi=300)\n", + "# fig.savefig(figname + '.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Conclusions and Next Steps\n", + "\n", + "This notebook demonstrated a comprehensive **cross-validation analysis** of QAOA parameter tuning strategies across 10 independent train/test splits.\n", + "\n", + "### Key Takeaways:\n", + "\n", + "1. **Robustness Assessment**: The confidence intervals in aggregated plots reveal how sensitive each strategy is to the particular train/test split\n", + " - **Narrow confidence intervals** → Strategy produces consistent recommendations regardless of which instances are in train vs test\n", + " - **Wide confidence intervals** → Recommendations vary significantly with different splits (potential overfitting to training data)\n", + "\n", + "2. **Performance Comparison**: The aggregated performance plot shows:\n", + " - How close each strategy gets to the Virtual Best (oracle) performance\n", + " - Resource efficiency: Which strategy achieves good performance with fewer function evaluations\n", + " - Reliability: Whether performance is consistent across all splits\n", + "\n", + "3. **Individual Split Insights**: Examining individual splits helps:\n", + " - Identify outlier splits that may have unusual characteristics\n", + " - Understand the sources of variability in the aggregated results\n", + " - Debug unexpected behavior in the overall analysis\n", + "\n", + "### Interpreting Your Results:\n", + "\n", + "- **Best strategy**: Look for approaches that combine:\n", + " - High mean approximation ratio (close to Virtual Best)\n", + " - Narrow confidence intervals (robust across splits)\n", + " - Good resource efficiency (high performance with fewer resources)\n", + "\n", + "- **Trade-offs**: Consider the balance between:\n", + " - **TrainingStats** (aggregate-then-recommend): May have lower variance but potentially lower peak performance\n", + " - **TrainingResults** (instance-specific-then-average): May achieve higher peak performance but with more variability\n", + "\n", + "### Recommendations:\n", + "\n", + "- If confidence intervals are wide, consider:\n", + " - Using more training instances to reduce variance\n", + " - Adjusting the parameter search space\n", + " - Testing alternative recommendation strategies\n", + "\n", + "- If performance doesn't converge to Virtual Best:\n", + " - Check if resource budgets are sufficient\n", + " - Verify that the parameter space includes optimal values\n", + " - Consider whether the problem instances are too diverse for a single recommendation\n", + "\n", + "### Next Steps:\n", + "\n", + "1. **Compare to single-split results** in `qaoa_demo.ipynb` to see if cross-validation reveals different insights\n", + "2. **Adjust strategies** based on the robustness/performance trade-offs observed\n", + "3. **Re-run experiments** for splits with incomplete data (check data availability cell)\n", + "4. **Test on new problem instances** using the recommended parameters from the most robust strategy" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "stochastic-benchmark-ci-py310", "language": "python", "name": "python3" }, @@ -273,14 +964,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.10.19" }, - "orig_nbformat": 4, - "vscode": { - "interpreter": { - "hash": "d651d14a5496386137173db75c785255facb03a606f46254da78831c40677b0f" - } - } + "orig_nbformat": 4 }, "nbformat": 4, "nbformat_minor": 2 diff --git a/examples/general_workflow.md b/examples/general_workflow.md new file mode 100644 index 00000000..0f7a5ca6 --- /dev/null +++ b/examples/general_workflow.md @@ -0,0 +1,49 @@ +# General Benchmark Workflow + +Given a benchmark task, the workflow generally follows these steps: + +1. Define the metrics +2. Perform bootstrapping +3. Perform interpolation +4. Train/Test split and Statistical Aggregation +5. Virtual Best Baseline +6. Evaluating Parameter Recommendation Strategies +7. Visualization + +Each step is explored in greater detail along with code implementation at `examples/QAOA_iterative/qaoa_demo.ipynb`. +## Define the Metrics +In this first step, we configure the central object for the benchmark task. We define: + +- The algorithm parameters being tuned +- Columns used to group problem instances +- The column containing the optimization objective +- Optimization direction (Minimization / Maximization) +## Bootstrapping +Suppose we have a distribution of data based on a numerical parameter. In the case of an optimization task, a more concrete example would be to have the execution performance of an algorithm based on input values. It is often useful to understand how this distribution would look if the numerical parameters were different. + +Bootstrapping is a statistical process that allows us to build distributions of the **expected values** of the results we are interested in for different input values. + +Example: For algorithm `A` with an input parameter `i`, we have a distribution of `n` performances `p`. +$$ +P=[p1​,...,pn​] +$$ +The goal of `A` is to minimize `p`. We are interested in knowing what this performance would look like, had the algorithm been run with input `j > i`. Although we are not able to know in a concrete way what the minimum performance would be in that case, bootstrapping allows us to infer a **distribution for the minimum performance**. From that, we get the expected value and confidence interval for the minimum performance given different inputs. +## Interpolation +When comparing different experimental runs, they often have data at different resource levels. This makes comparison difficult. Interpolation allows us to compute, for each run/method, a common comparison metric. + +Example: Algorithm `A` and `B` might solve the same problem with different sets of parameters, which is a problem at first. But, the **total energy** spent by `A` could be determined by some combination of its input parameters, while the same is true for `B`. Interpolation allows us to compare them through the lens of this common metric. +## Train/Test split and Statistical Aggregation +One of the goals of the framework is to provide recommendations for the input parameters. For that, different data splits serve different purposes. The train set is used to learn the best parameter strategies, while the test set is used to verify them against unseen data. +## Virtual Best Baseline +When dealing with different problem instances, it is likely that the input parameters that work well for one instance are not optimal for another. Even if that's the case, it is useful to study how good of a performance we would get if it were possible to select the best input parameters for every unknown instance. This is what we are calling Virtual Best Baseline. It gives us an upper bound that generates insights into how good the current performance is, even though the Virtual Best Baseline itself is unachievable. +## Evaluating Parameter Recommendation Strategies +After having devised parameter recommendations from the training set, we need a way to evaluate how well these recommended strategies perform on new instances (test set). For this, the framework applies two different strategies: + +1. We can aggregate statistics across all training instances to learn a parameter recipe. We refer to this as the Aggregate-then-Recommend projection strategy. +2. It is also possible to look at what parameters work best for each instance individually. After this, we can average those recommendations. +## Visualization + +The framework's results can be visualized, mainly, through two lenses: + +1. We can look at how our defined metric of interest compares against the defined resource. Here we can compare the Virtual Best, the Projection from the Training Set, and the Performance from the Training Set. Essentially, this tells us how close we can expect to be from the Virtual Best when new problem instances come in. +2. We can look at how we should distribute our input parameters for different resource amounts. Getting back to the previous **energy** example, if we have a given amount we are willing to spend, this can be achieved via different combinations of inputs. This analysis tells us what inputs to pick in order to achieve the performance metrics computed by the framework. \ No newline at end of file diff --git a/examples/wishart_n_50_alpha_0.5/README.md b/examples/wishart_n_50_alpha_0.5/README.md new file mode 100644 index 00000000..4cdf2c18 --- /dev/null +++ b/examples/wishart_n_50_alpha_0.5/README.md @@ -0,0 +1,76 @@ +# Wishart n=50 α=0.50 Example + +This example demonstrates the stochastic benchmarking framework applied to Wishart problem instances. + +## Prerequisites + +### Additional Dependencies + +This example has different dependencies depending on what you want to do: + +#### For Running Analysis Only (using pre-generated data): +```bash +pip install -r ../../requirements-examples.txt +``` + +This installs: +- **scikit-learn** - Required for polynomial regression models in parameter recommendation + +#### For Generating New Experimental Data: +If you want to generate new data (not just analyze existing results), you also need: +- **pysa** - For running simulated annealing experiments +- Note: `wishart_runs.py` handles missing pysa gracefully with a try/except + +The analysis notebook (`wishart_n_50_alpha_0.50.ipynb`) only requires scikit-learn and works with pre-generated data files. + +### Data Files + +The example expects the following directory structure relative to this folder: + +``` +wishart_n_50_alpha_0.5/ +├── wishart_ws.py # Main analysis functions +├── wishart_runs.py # Experimental run functions +├── wishart_n_50_alpha_0.50.ipynb # Main analysis notebook +├── rerun_data/ # Experimental results (pickled data) +│ ├── hpoTrials_warmstart=*_trial=*_inst=*.pkl +│ └── ... +└── wishart_planting_N_50_alpha_0.50/ # Problem instances + ├── wishart_planting_N_50_alpha_0.50_inst_*.txt + └── gs_energies.txt # Ground state energies +``` + +## Running the Example + +1. **Ensure you have the data files** in the appropriate directories (see structure above) + +2. **Install dependencies**: + ```bash + pip install -r ../../requirements-examples.txt + ``` + +3. **Open and run the Jupyter notebook**: + ```bash + jupyter notebook wishart_n_50_alpha_0.50.ipynb + ``` + +## What This Example Demonstrates + +- Loading experimental data from multiple parameter configurations +- Bootstrap resampling for statistical analysis +- Interpolation across resource levels +- Computing virtual best (oracle) performance +- Comparing different parameter recommendation strategies +- Generating performance plots (Window Stickers) + +## Key Files + +- **wishart_ws.py**: Contains `stoch_bench_setup()` which initializes the benchmarking framework with Wishart-specific configuration +- **wishart_runs.py**: Functions for running QAOA/simulated annealing experiments on Wishart instances +- **wishart_n_50_alpha_0.50.ipynb**: Main analysis notebook with visualization + +## Notes + +- The paths in `wishart_ws.py` and `wishart_runs.py` have been configured to use relative paths for portability +- If you encounter permission errors, ensure you're running the notebook from the correct directory +- The example uses polynomial regression models (via scikit-learn) for parameter recommendation strategies diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=cold_postprocess=custom.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=cold_postprocess=custom.pkl new file mode 100644 index 00000000..2432efab Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=cold_postprocess=custom.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=warm_postprocess=custom.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=warm_postprocess=custom.pkl new file mode 100644 index 00000000..f60f3da9 Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTest_id=warm_postprocess=custom.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=cold.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=cold.pkl new file mode 100644 index 00000000..7bbc2419 Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=cold.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=warm.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=warm.pkl new file mode 100644 index 00000000..db58f681 Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_evalTrain_id=warm.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=cold.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=cold.pkl new file mode 100644 index 00000000..b2ac6b6d Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=cold.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=warm.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=warm.pkl new file mode 100644 index 00000000..ce07e5de Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/SequentialSearch_meta_params_id=warm.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/testing_stats.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/testing_stats.pkl new file mode 100644 index 00000000..ed349e92 Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/testing_stats.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/checkpoints/training_stats.pkl b/examples/wishart_n_50_alpha_0.5/checkpoints/training_stats.pkl new file mode 100644 index 00000000..cfd72137 Binary files /dev/null and b/examples/wishart_n_50_alpha_0.5/checkpoints/training_stats.pkl differ diff --git a/examples/wishart_n_50_alpha_0.5/wishart_n_50_alpha_0.50.ipynb b/examples/wishart_n_50_alpha_0.5/wishart_n_50_alpha_0.50.ipynb index 578b420f..1b65d9bc 100644 --- a/examples/wishart_n_50_alpha_0.5/wishart_n_50_alpha_0.50.ipynb +++ b/examples/wishart_n_50_alpha_0.5/wishart_n_50_alpha_0.50.ipynb @@ -1,5 +1,67 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Wishart n=50 α=0.50 Example\n", + "\n", + "This notebook demonstrates comprehensive stochastic benchmarking analysis on Wishart problem instances. The Wishart problem is a challenging optimization problem commonly used to benchmark quantum and classical optimization algorithms.\n", + "\n", + "## Problem Overview\n", + "\n", + "The Wishart planted ensemble is a benchmark problem where:\n", + "- **n = 50**: Problem dimension (matrix size)\n", + "- **α = 0.50**: Planting parameter controlling problem difficulty\n", + "- Ground state solutions are known (planted), enabling performance verification\n", + "\n", + "## Prerequisites\n", + "\n", + "### Required Dependencies for Analysis\n", + "\n", + "This example requires **scikit-learn** (not part of the core stochastic-benchmark package). Install it with:\n", + "\n", + "```bash\n", + "pip install -r ../../requirements-examples.txt\n", + "```\n", + "\n", + "Or directly:\n", + "```bash\n", + "pip install scikit-learn>=1.3.0\n", + "```\n", + "\n", + "### Notes on Other Dependencies\n", + "\n", + "- **pysa**: Only needed if you want to *generate* new experimental data. The notebook works with pre-existing data files and will show a harmless \"no pysa found\" message if it's not installed.\n", + "- **hyperopt**: Already included in core requirements. You may see a deprecation warning about `pkg_resources` - this is harmless and can be ignored.\n", + "\n", + "### Data Files\n", + "\n", + "This notebook analyzes pre-generated experimental data. You'll need the data files in:\n", + "- `rerun_data/` directory (pickled experimental results)\n", + "- `wishart_planting_N_50_alpha_0.50/` directory (problem instances)\n", + "\n", + "See `README.md` in this directory for complete data structure requirements." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Notebook Setup\n", + "\n", + "Configure autoreload for interactive development and manage warning display.\n", + "\n", + "### Note on Sequential Search Warning\n", + "\n", + "During initialization, you may see:\n", + "```\n", + "Sequential search experiment terminated due to insufficient data\n", + "```\n", + "\n", + "This warning is **expected** - it occurs when sequential search experiments encounter sparse data regions during Bayesian optimization. Without filtering, this warning would appear **468 times** during bootstrapping, cluttering the output. The filter shows it once so you're aware of the condition without overwhelming the display." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -7,7 +69,26 @@ "outputs": [], "source": [ "%load_ext autoreload\n", - "%autoreload 2" + "%autoreload 2\n", + "\n", + "# Configure warning filters\n", + "import warnings\n", + "\n", + "# Suppress known harmless warnings\n", + "warnings.filterwarnings('ignore', message='pkg_resources is deprecated')\n", + "\n", + "# Show sequential search data warning only once\n", + "# This is expected when sequential search encounters sparse data regions\n", + "warnings.filterwarnings('once', message='Sequential search experiment terminated due to insufficient data')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Import Libraries\n", + "\n", + "Import the stochastic-benchmark framework and supporting libraries for data analysis and visualization." ] }, { @@ -16,31 +97,20 @@ "metadata": {}, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/robin/anaconda3/envs/stoch_bench/lib/python3.9/site-packages/tqdm/auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" + "no pysa found\n" ] } ], "source": [ + "# Add source directory to path for development\n", "import sys\n", "sys.path.append('../../src/')\n", - "import stochastic_benchmark\n", - "\n", - "from collections import defaultdict\n", - "import dill\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "import matplotlib.patches as mpatches\n", - "import numpy as np\n", - "import os\n", - "import pandas as pd\n", - "import glob\n", - "import seaborn as sns\n", - "import seaborn.objects as so\n", "\n", + "# Core stochastic-benchmark imports\n", + "import stochastic_benchmark\n", "import bootstrap\n", "import df_utils\n", "import interpolate\n", @@ -51,276 +121,762 @@ "import success_metrics\n", "import training\n", "\n", + "# Standard scientific computing libraries\n", + "from collections import defaultdict\n", + "import numpy as np\n", + "import pandas as pd\n", + "import os\n", + "import glob\n", + "\n", + "# Visualization libraries\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.patches as mpatches\n", + "import seaborn as sns\n", + "import seaborn.objects as so\n", + "\n", + "# Serialization\n", + "import dill\n", + "\n", + "# Problem-specific modules\n", "from wishart_ws import *\n", "from wishart_runs import *" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Initialize Stochastic Benchmark\n", + "\n", + "Set up the benchmarking framework with multiple experiment types to compare different optimization strategies.\n", + "\n", + "### Experiments Analyzed\n", + "\n", + "This analysis includes five different experimental approaches:\n", + "\n", + "1. **Experiment 0**: ProjectionExperiment from TrainingStats - Projects parameter recommendations from training statistics\n", + " \n", + "2. **Experiment 1**: ProjectionExperiment from TrainingResults - Projects parameters from actual training run results\n", + " \n", + "3. **Experiment 2**: RandomSearchExperiment - Explores parameter space using random search\n", + " \n", + "4. **Experiment 3**: SequentialSearchExperiment (cold start) - Bayesian optimization starting from scratch\n", + " \n", + "5. **Experiment 4**: SequentialSearchExperiment (warm start) - Bayesian optimization initialized with prior knowledge\n", + "\n", + "**Note**: The full setup includes experiments 5-6 (StaticRecommendationExperiment), but these require external re-runs and are excluded from this analysis." + ] + }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 3, "metadata": {}, "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading and bootstrapping experimental data...\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Computing training/testing statistics...\n", + "Computing virtual best baseline...\n", + " ├─ Running ProjectionExperiment from TrainingStats...\n", + " ├─ Running ProjectionExperiment from TrainingStats...\n", + " ├─ Running ProjectionExperiment from TrainingResults...\n", + " ├─ Running ProjectionExperiment from TrainingResults...\n" + ] + }, { "name": "stderr", "output_type": "stream", "text": [ - "/home/robin/stochastic-benchmark/examples/wishart_N=50_alpha=0.50/../../src/interpolate.py:43: UserWarning: Resource value type log does not support passing in values. Removing.\n", - " warnings.warn(warn_str)\n" + "100%|██████████| 100/100 [00:00<00:00, 2471.24it/s]\n", + "100%|██████████| 100/100 [00:00<00:00, 2471.24it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Runnng baseline\n", - "Running projection experiment\n", - "Running projection experiment\n", - "Running random search experiment\n", - "Running sequential search experiment\n", - "Running sequential search experiment\n", - "Running static recommendation experiment\n", - "Running static recommendation experiment\n" + " ├─ Running RandomSearchExperiment...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 5700/5700 [00:42<00:00, 135.62it/s]\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + " ├─ Running SequentialSearchExperiment (cold)...\n", + " ├─ Running SequentialSearchExperiment (warm)...\n", + "\n", + "✓ Setup complete! Analyzing 5 experiments:\n", + " 0: Projection from TrainingStats (ProjectionExperiment)\n", + " 1: Projection from TrainingResults (ProjectionExperiment)\n", + " 2: RandomSearch (RandomSearchExperiment)\n", + " 3: SequentialSearch_cold (SequentialSearchExperiment)\n", + " 4: SequentialSearch_warm (SequentialSearchExperiment)\n" ] } ], "source": [ + "# Initialize stochastic benchmark with all experiment configurations\n", "sb = stoch_bench_setup()\n", - "keep_experiments = [2, 3, 6]\n", - "sb.experiments = [sb.experiments[ex] for ex in keep_experiments]" + "\n", + "# Filter to experiments with complete results (0-4)\n", + "# Experiments 5-6 are StaticRecommendationExperiment objects that lack\n", + "# attached results and will be excluded from the analysis\n", + "keep_experiments = [0, 1, 2, 3, 4]\n", + "sb.experiments = [sb.experiments[ex] for ex in keep_experiments]\n", + "\n", + "# Display experiment summary\n", + "print(f\"\\n✓ Setup complete! Analyzing {len(sb.experiments)} experiments:\")\n", + "for idx, exp in enumerate(sb.experiments):\n", + " print(f\" {idx}: {exp.name} ({type(exp).__name__})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Configure Plotting\n", + "\n", + "Initialize the plotting system and set resource budget limits for visualization." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ + "# Initialize plotting system\n", "sb.initPlotting()\n", - "sb.plots.set_xlims((10**3, 10**6))" + "\n", + "# Set x-axis limits for resource budget (total function evaluations)\n", + "# Range: 10^3 to 10^6 function evaluations\n", + "sb.plots.set_xlims((10**3, 10**6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Performance Comparison\n", + "\n", + "Compare the performance of different parameter recommendation strategies across resource budgets.\n", + "\n", + "### Interpretation\n", + "\n", + "- **X-axis**: Total computational budget (function evaluations)\n", + "- **Y-axis**: Success probability or performance metric\n", + "- **Curves**: Each experiment's performance trajectory with confidence intervals\n", + "- **Higher values**: Better performance (closer to optimal solution)" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 5, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/100 [00:00" + "(0.93, 1.001)" ] }, - "metadata": { - "needs_background": "light" + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "p = sb.plots.plot_performance()\n", - "ax = p.axes[0]\n", + "# Plot performance comparison across all experiments\n", + "fig, ax = sb.plots.plot_performance()\n", + "\n", + "# Focus on high-performance region (93% to 100% success)\n", "ax.set_ylim(0.93, 1.001)\n", - "p.show()\n", - "# keep pink static, cold start\n", - "# p.savefig('Performance.pdf')" + "\n", + "# Optionally save the figure\n", + "# fig.savefig('wishart_performance_comparison.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gap to Optimality (Log Scale)\n", + "\n", + "Visualize the convergence toward optimal performance by plotting the gap to optimality (1 - performance) on a logarithmic scale. This view emphasizes how quickly different strategies approach perfect performance.\n", + "\n", + "### Interpretation\n", + "\n", + "- **Y-axis**: Gap to optimality (1 - performance) on log scale\n", + "- **Lower values**: Closer to optimal performance\n", + "- **Log scale**: Makes small improvements near optimality more visible" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" ] }, - "metadata": { - "needs_background": "light" + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "p = sb.plots.plot_parameters_distance()\n", - "ax = p.axes[0]\n", + "# Plot gap to optimality (1 - performance) on logarithmic scale\n", + "fig, ax = sb.plots.plot_performance()\n", + "\n", + "# Transform all plot elements to show gap to optimality\n", + "# Handle line plots (mean trajectories)\n", + "for line in ax.get_lines():\n", + " ydata = line.get_ydata()\n", + " gap = 1.0 - ydata\n", + " line.set_ydata(gap)\n", + "\n", + "# Handle filled areas (confidence intervals)\n", + "for collection in ax.collections:\n", + " # Get the paths from PolyCollection (filled areas)\n", + " paths = collection.get_paths()\n", + " for path in paths:\n", + " vertices = path.vertices\n", + " # Transform y-coordinates: gap = 1 - performance\n", + " vertices[:, 1] = 1.0 - vertices[:, 1]\n", + "\n", + "# Set logarithmic scale and update labels\n", "ax.set_yscale('log')\n", - "p.show()\n", - "# p.savefig('Parameters_distance.pdf')" + "ax.set_ylabel('Gap to Optimality (1 - Performance)')\n", + "ax.set_ylim(1e-3, 1e-1)\n", + "\n", + "ax.legend(loc='lower left')\n", + "\n", + "# Optionally save the figure\n", + "# fig.savefig('wishart_gap_to_optimality.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Meta-Parameter Evolution\n", + "\n", + "Visualize how meta-parameters (hyperparameters controlling the search strategy) evolve as the resource budget increases.\n", + "\n", + "### Meta-Parameters\n", + "\n", + "Meta-parameters control the behavior of adaptive search algorithms:\n", + "\n", + "- **tau**: Temperature or exploration parameter\n", + "- **frac**: Fraction or allocation parameter\n", + "\n", + "Only experiments with adaptive search strategies (Random Search and Sequential Search) have meta-parameters." ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAEQCAYAAAD/FwBWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA8QUlEQVR4nO3dd3xb1dnA8Z8k7+3Y8owdZ/kkTkKWs1gBCuUFwuiiTWkDBdpSNt28BUqhLdCXQqHQMtpCEkYppKwUCgWasALZIfNkecSJHW/H8tB+/5Bs7NhJbFn2lezn+/nwsX3P1dUjXaJHZ5u8Xi9CCCGE0cxGByCEEEKAJCQhhBAhQhKSEEKIkCAJSQghREiQhCSEECIkRBgdQAiKBuYAlYDb4FiEECJcWPw/ywBXIBeQhNTTHOADo4MQQogwNRYoDeSBkpB6qgRoaGjB45E5WuEmLS2Bujqb0WGIAMn9C19paQkDvoYkpJ7cAB6PVxJSmJL7Ft7k/o1cMqhBCCFESJCEJIQQIiRIk10fud0umppqcTodRocijqO21ozb7en8OzIyiuTkdCwW+V9diFA3JP9KlVL3A18BCoBpWutt/uOFwFIgDagDlmit9wxW2UA0NdWSkpJMauooTCbTQC8nBklkpAWn0zda3+v10tBQT2NjLaNGZRkcmRDiRIaqye4V4HR849O7egx4VGtdCDwKPD7IZQFzOh2SjMKMyWQiNXWU1GqFOIFlaw+wvryx27H15Y0sW3ugz+dvKKsfcBxDkpC01h9qrbu9MqVUBjALeN5/6HlgllLKOhhlwXgdkozCj9wzIU6sKCuRW1fu7Ewy68sbuXXlToqyEvt8/h2vbh9wHEY2rOcBB7XWbgCttVspdch/3DQIZTVD+/KCLyYmiqlTp+FyuSgoKODpp5eSkpIy4OsuW7aUDRs28NBDDw/4Wk8//RQPPfQQJpMJj8fDXXfdzUUXXTTg6/amtLSUSy65mM2btwzK9YUYKYrzU7hn0WRufnkbCVEWGtuc5CTH8IfV+4/5mMRoC9e/9BmjU2Jpanfx1yuKBxyH9PQew9GTvGprzURGWjr/Lv71f6i1Ba8pKD0hivW3nXPcc2JjY9myZTMAl19+OU888Ri/+MUvBvzcFosZs9nU7fUFoqKignvvvYeNGzeSnJyMzWajpqZmwNd1uVxERPT8XzUy0oLJRI/rH/23xWLGau39m54IPXKvjFHg8mJ3ebC7PIxNj2O89cQTXSMizJTUtnLjWROYPWbUgGMwMiEdAHKVUhZ/TcYC5PiPmwahrF/q6mzdJui53Z7OznIgqMmo43pdr38sHefMnTuPrVu34nS6WbduLT/60Q9pa2snNjaGJ5/8K0opli1byuuvv05bWyv79+/noosu5t577wNg6dKnue+++8jOzmLixEKio6NxOt2UlZXxve9dTU1NLVZrOk8++Vfy8/O56qoriY2NRetdlJeX8+STf2H58uV88sknzJ07l7/+9W8cOlRJQkIi0dGxOJ1uoqNjGT06H6fTzb59+7jpphuoqaklLi6WP//5cSZNmsTKla9zzz2/xeFwkpY2iqVLl5OZmcldd/2KyspKyspKSUtL5/77f891111LSUkJAI888gjZ2Tm4XG6uuupq1qxZQ25uDq+99hoREVHd3jO320NNTXNQ75cYHFZrotwrg/xiha+l4VvFuazcXs1XzsyiOD/lmOd3NOtdNT+fZWvKWKisA05Khs1D0lpXA5uBxf5Di4FNWuuawSgb3FcztNxuN++99x6LFi0CQKlJvPfeKtatW88vf3knt99+W+e5n322hWeffZ6NGzfz0ksvcuDAASorK7nrrl+xevX7vPnmW+zcuaPz/JtuupHLLvs2GzduYvHib3LLLTd3ljU0NPD22+/wf//3e770pUu48cab2LLlM7Zt28bmzZs56aTpZGZmUFg4gauvvoqVK1/vfOy1117Dgw8+xKefruW++37HjTdeD8App5zKhx9+zLp167n00q/z+9//X+djNm7cyIoVL7N8+TPccsvNnH766WzYsJG1a9dRVDQFgL1793DNNT9gy5bPSE5OYcWKFYPyngsxnL22tYqNFUc4b5KVmxaO555Fk7v1ER2tIxnds2gy15xSwD2LJodPH5JS6mHgy0AW8I5Sqk5rPQW4BliqlLoDaACWdHnYYJSFtba2NoqLZ1NWVsqsWbM4+2xfE19TUxNXXvkd9u7di8lkwul0dj7mzDPPIjk5GYDJkydTXl5GbW0dp5++EKvVN9bja1+7lD17fCPjP/30E1588SUALrvsW9x66887r3XBBYswmUxMnTqVzMxMpk2bBkBRURFlZWXMmDGDlSvfYP36dbz33nv85Cc/ZuPGjfzwhz9izZo1LF78jc5r2e12wNfMd9lli6msrMLhcDB2bEHnOYsWLSI2NhaAVav+y1NPPQ2AxWIhOTmZhoYGxo4dy4wZMwCYNWsWpaWlwXirhRhRXth0kCiLiR+eNQH4vE9pR1Vzr7WkHVXN3LNocmdZcX4Kd6VPGXAcQ5KQtNY3Ajf2cnwXMO8Yjwl6WbiLjY1l/foNNDU1ccklF/HnP/+J66+/gTvv/CVnnHEGL720gtLSUs455wudj4mOju783WKx4HL5VoXv6+izrud1XMtsNhMV9fl1zWZzt+vOmTOXOXPmcvbZZ3P11Vdz8823kJKSwvr1G3pc/5ZbbuKmm27hwgsvZPXqVdx9912dZfHx8SeMr2scFosFh8Pep9clhPAprWtlT00L354zmpTYyM7jxfkpx2yyWzI3r8exYPQhydJBYSg5OZkHHvgDDz74AE6nk6amJnJycgHfiLkTmTt3Lu+/v5q6ujqcTicrVrzUWTZ//gJeeOEFAJ5//jlOPvmUPsd16NAhNm3a2Pn3li1bGDMmn6SkJAoKCnjpJd/zeL1etmzxtVc3NR0hNzcHgOXLlx/z2meeeRaPP/4Y4GuyPHLkSJ/jEkIc21Nry4mKMHNZ8WijQ5GEFK5mzpzJtGkn8cILL/DjH/+Y2277BQsXnobbfeKBEdnZ2dx++x2cdtqp/M//fJGZM2d1lj344B9YtuxpZs2aybPPPsMDDzzY55icTic/+9lPmTp1CsXFs3nxxX/w+9/7Hr906XKefvpvzJ49i+nTT+L1118D4Pbb72Dx4m9w5pkLSU9PO+a1H3jgQVatWsXMmTOYN28uO3YMvL1aiJHuQEMbb+2s5ivTsxkVF3XiBwwyk9crS70fpQAoOXqU3eHD5Sg1qfPvBfe9F/Rh32t+dlbQrjdSdV06qIPWu8jMzDcoItEfMspuaN39luatXTW8ctUc0hOiT/yA4+gyXF826BtqkjyE6Mnp9qCrbXR8l8tOisaaEE27083umpYe5+cmx5AWH0Wrw83e2hZSWl00NrZ2luenxJISF4nN7mJ/XWuPxxeMiiUpJpKmNidlDW09yselxZEQHUFDq4MDje09yiekxxMXZaGuxcHBpp7lhdZ4YiIt1NjsVB7p2T85OTOBSIuZqiPtVPfyBXVKViIWs4lDTe3UtvQsPyknCYCKxjbqW53dyswmmJrtKy+rb6Wpvfuu4BFmU+dKCiV1rTTbu5dHW8yoTN9con21LbQ4un9Ra2538q8d1Xx1ejYNbU4OHfX64qMsjE/39ePqwzbsXRYtBkiKjqAgLa7HaxoISUhCiKB5Zn0Ff/qwtPPvmxaO41vFo6lqtnPV85t7nH/rORP58knZlNa39lr+6/Mnce7kDHS1jWv+8VmP8gcumcJp49PYcugIP3qlZzPuY5eexOy8FD4ta+T2N3b1KF/2rZlMzkxk9d5a7nlnb4/yl75TzJhRcfx7ZzUPv1/So/zN788jPSGa17ZV8eSa8h7lq284hbgoCy9sOshzGw72KF/3o9MBWLr2AK9srepWFhdpYfWNvj7cJz4u4+2jZq+kx0fx5jXzAXj4/f18uL/7WnL5qbGsuHIOAL97dy8bK5q6lafERmA2wZI5efzole3squ6+U++s0ck8/vXpAPzvv3ZSflTCP3XcKB780tQer2kgpMmupwL60GQnQpM02Rnrzn9r1pTUc+d5CoAxqXHkJMfQ5nSz+WBTj/PHjoojKykGm93F1sojJCfH0dT0eU1oYno86QnRNLU52XG4Z1OeykhgVFwU9a0OdHXPrc+LMhNJjo2k1mZnT23PGtq07CQSoiOoOtJOSX3PGtiM3GRiIy0cbGrr8YEMMHt0ClERZg40tFHR1LN8Tn4qEWYTpXWtVDb3rIEtKPCNTNtX20K1rXsNxWwyMW9MKgC7q23UtXavYUVZzMzOSwFg1+FmGtq617BiIizMHO2b8rG98ghHutSgGloc3PXWbr50UjY/O3sinx06Qoujew0rKTqCKf4a2qaKJtpd3f9dpcZGMinz81U1gtFkJwmppwKOkZAKC5Us1hnijk5IXq+X3bu1JKQhcu87ezjcbA/4m7P0IQ2N+97Zwytbq3j5qjlkJcUE5ZrShzSEIiOjaGioly0owkjHfkiRkcaPHhopfn72RKNDECdQ3Wzn1W1VXDg1M2jJKFgkIfVRcnI6jY211NQMq1WIhh2LpfcdY4UQPsvWHcDj8XJ5L5NbjSYJqY8slgjZdTQMSJOPcWx2F9e9tJXvzM3jjInyJSAU1bY4eGVrFecXZZKbHGt0OD3IxFghRFBU2+zsqGrG7vKc+GRhiGfWVeB0e/jOvNDsU5WEJIQIippm3ygwa6L02YWi+lYHK7Yc4n8mZ5CXGnq1I5CEJIQIksP+YcsZA5zxLwbHs+sPYneFbu0IJCEJIYKkxp+QrJKQQk5jq5MXNx/ki5OsFIwK7uoKwSQJSQgRFMkxkczJTyE6Qj5WQs3zGytod4Z27QhklJ0QIki+OiOHr87IMToMcZQj7U5e2HSILxSmd65NF6rkq4wQQgxjf994kBaHmyvnh3btCCQhCSGC5BtL1/PUpz0XGBXGsdld/H3jIc6YkMZEa4LR4ZyQJCQhxIDZXR721bbi9sjamKHkH5sO0Wx3cVUY1I5AEpIQIgg6RthlJMoIu1DR4nDx3IYKTh03qtuq3KFMEpIQYsBq/JvTZcqQ75Dx0uZKmtpdXB0mtSOQhCSECILqZv8cJFmlISS0Od08s76CBQWpnXsahQNJSEKIAUuNi+SMCWmySkOIWLGlksY2J1cvGGN0KP0i85CEEAM2d0wqc/27mwpjtTvdLF93gLn5KZyUEz61I5AakhAiCDyy83TIeGVrFfWt4Vc7AklIQogg+O7ft/Dz13cYHcaIZ3d5WLbuALPzkpk5OtnocPpNEpIQYsCqjrQTE2kxOowR77VtVdTYHGEz7+hokpCEEAPi9nipa3GQmSAj7IzkcHl4+tNypuckUZyXYnQ4AZGEJIQYkPpWB26vbDthtJU7DlNtc3D1gnxMJpPR4QREEpIQYkA65iDJKg3Gcbl9taOp2YnMC+PRjpKQhBADkhgTyddn5jAuLXQ3fhuOlq09wPryRgDe2FFN5RE7C8ensXxdhbGBDUBIzENSSi0C7gZM+JLknVrrfyqlCoGlQBpQByzRWu/xPyagMiFEcOWnxvLjsyYYHcaIU5SVyK0rd/LrCybxt0/LyU+N4dkNFdyzqMjo0AJmeA1JKWUClgPf1lrPAL4FLFVKmYHHgEe11oXAo8DjXR4aaJkQIohsdhdOt8foMEac4vwU7lk0mZ++uoODTe3UtTi5Z1ERxfkpRocWMMMTkp8H6Bg0nwJUAunALOB5//HngVlKKatSKiOQskF/FUKMQL97dy9ffWq90WGMSFOzEwHfpORvzMwJ62QEIZCQtNZe4FLgVaVUGfAKcDmQBxzUWrv957mBQ/7jgZYJIYKs2mYnQ4Z8G+J37+6l1enhgqJMVnxW1dmnFK4M70NSSkUAtwIXa60/UkqdArwAfNvIuNLSQn93RdE7qzU89n4ZLurbXEzJSQra+y73r2/e2HqI17cfprgglUeXFPPxvlquf24Tj3xzJiePTzc6vIAYnpCAGUCO1vojAH9SagHagVyllEVr7VZKWYAc4AC+wQ+BlPVZXZ0Nj+x+GXas1kRqapqNDmPE8Hq9HGps4+QxqUF53+X+9d2j7+7BbIJbz5pATU0zE5Oi+c35k1izq5qJSUM/BD8YXyQMb7IDKoDRSikFoJSaDGQBe4DNwGL/eYuBTVrrGq11dSBlg/9ShBhZmu0u7C4PGbIP0pDaV9vCzsM2Lp2ZS35qbOfx4vwUlswN394JwxOS1roK+AHwklJqC/B34Dta63rgGuAGpdRu4Ab/3x0CLRNCBInZZOKG08Yye3SK0aGMKA+/v5/4qIiwXbPuWExeWTb+aAVAiTTZhSdp8glvcv9O7NPSBq5fsZWbFo7jW8WjjQ6nU5cmu7FAaSDXMLyGJIQIX3UtDg42tcl+SEPE7fHy0Pv7yUmO4dIZOUaHE3SSkIQQAVux5RBf+ss63NKaMCT+tf0we2pauP60sURFDL+P7+H3ioQQQ6ba5iA1LpJIi3yUDLY2p5s/f1TKtOxEzi4Mz2HdJyL/FwkhAlbdbCdTVvkeEs+sq6C2xcFNC8eF7fYSJyIJSQgRsBqbQ/ZBGgK1NjvL1h3gC4XpTM8Nv63J+0oSkhAiYLJs0NB47KMyXB4v15821uhQBlUorNQghAhDXq+Xn541gZzkGKNDGdb21Nh4bVsVi2fnMjol9sQPCGOSkIQQATGZTJw7OcPoMIa9h1eXkBgTwZXzhtck2N5Ik50QIiB1LQ42VjTS7nQbHcqwtaa0nk/KGrhqfj7JsZFGhzPoJCEJIQLyaVkD33/hM6qa7UaHMiy5PV4eWr2f0SkxfG0YToLtjSQkIURAqv2JKENG2Q2K17ZVsa+2lRtOGzti5nmNjFcphAi6GpuDxOgI4qIsRocy7LQ63Dz2USnTc5I4c+LwnATbG0lIQoiAVNvsWGXI96BYtu4A9a1Obj5j+E6C7Y0kJCFEQKptDjJklYagq26288z6Cs5RVqZmJxkdzpCSYd9CiID89KzxRocwLP35o1I8Xi/XnVZgdChDThKSECIgU0bYt/ehoKtt/Gv7YS4rHk1u8vCeBNsbabITQvRbc7uLf++spsYmQ76Dxev1DfNOGiGTYHsjCUkI0W8l9a3c/sYudle3GB3KsPFRST3ryhu5esEYEmNGZuOVJCQhRL911IwyEmWUXTC4PF4eXl1CfmosX5mebXQ4hpGEJITot8P+SbGy9URwvLq1kpL6Vq4fQZNgezNyX7kQImDVzQ6iI8wkj9CmpWCy2V088XEZM3OTOGNCmtHhGEoSkhCi32r8k2JH0qTNwdIxCfamM8aP+PdTvt4IIfrt5jPG0djmNDqMsFd1pJ3nNhzk3ElWpmQlGh2O4SQhCSH6zZoQLf1HQfDnj0rxer1cN8x3gu0rabITQvSL1+tl2doD7DrcbHQoYW3n4Wbe2FHNN2aNJjtJdt0FSUhCiH5qbHPyxw9K2HzwiNGhhK2OSbApsZF8Z16e0eGEDElIQoh+qbY5AMiQlb4D9v6+ejYcaOK7C8aQEC09Jx0kIQkh+qVzYz5Z6TsgLreHP76/nzGpsXz5pCyjwwkpkpCEEP3SsUqDDGoIzD8/q6KsoY0bTh9HxAieBNsbeTeEEP1y2ObAbIK0eGmy6y+b3cWTa8qYnZfM6eNHGR1OyJHGSyFEv1w9P58vTcsiwjyyJ3EG4qlPD9DY5uSmhSNrJ9i+khqSEKJfIi1msmSYcr9VHmnn7xsrOL8og8mZMgm2NyFRQ1JKxQAPAmcD7cAarfX3lFKFwFIgDagDlmit9/gfE1CZEGJg/vpJGePS4jlzYrrRoYSVRz8owWQy8YNTCowOJWSFSg3pd/gSUaHWehpwu//4Y8CjWutC4FHg8S6PCbRMCDEAy9dVsOFAo9FhhJXtlUd4a1cN35ydK7XL4zC8hqSUSgCWAKO11l4ArfVhpVQGMAs4x3/q88AjSikrYAqkTGtdMxSvSYjhqsXhosXhJkNG2B3XsrUHKMpKpDg/pXMSbGK0hSgZVXdcofDujMfXrPZLpdR6pdQqpdSpQB5wUGvtBvD/POQ/HmiZEGIAapp9k2KtsjHfcRVlJXLryp2sL29k1d46Nh08gsvjZUZustGhhTTDa0j4YhgHbNJa/0QpNQ94HfiakUGlpSUY+fRiAKxW6TAeLLrRNwepcHTqoL3Pw+H+nWdNJDklluue3YjH68VsgieWFHPaRKvRoYW0UEhIZYALX9MaWutPlVK1QBuQq5SyaK3dSikLkAMcwNcsF0hZn9XV2fB4vMF6jWKIWK2J1NTIop+DpayqCRMQ5XIPyvs8nO7fhMQorAlR7K5u4YvKyqSUmGHz2noTjC8ShjfZaa1rgf/i7/Pxj5DLAHYDm4HF/lMX46tF1WitqwMpG/QXI8Qw98VJGXx886nkpkjH/In8+q3d7K5uYUZuEmvLG1lf3mh0SCHP8ITkdw3wv0qprcDfgW9rrRv9x29QSu0GbvD/3fUxgZQJIQYgwmLGLJM6j+vRD0p4bfth5o1J4YmvT+eeRZM7+5TEsZm8XmmWOkoBUCJNduFpODX5hKKnPi3HBFwxL39Qrj8c7t+68gauf2krE9LjefqymUT6R9atL29kR1UzS+YOz/FVXZrsxgKlgVwjFPqQhBBh4t3dtaTLGnbHtLe2hZ+8uoOCUXE8dun0zmQEUJyfQnF+inHBhYFQabITQoSBGpudDBny3avqZjs3rdhKXJSFh748lcQY+b7fX/KOCSH6xOHyUN/qlG0netHicHHzy9uw2d088Y3pshpDgKSGJITok9oW36TYTElI3bjcHn7++k7217Zw70WTURkyhzFQkpCEEH3SbHeRHh9FpuwU28nr9XLvO3v5pLSBW8+ZyIIC2eNoIKTJTgjRJyojgTevmW90GCHlr5+U8+q2Kq6an8/F07KNDifs9TkhKaU+AHodB621Pj1oEQkhRBhYub2Kxz8u44KiDL5/8hijwxkW+lND+stRf2cBVwHPBC8cIUSoem5DBTuqmvn1BZONDsVwa8sa+PXbe5iTn8Ivvlgou78GSZ8TktZ66dHHlFIrgKeAu4IZlBAi9Gw91MyeGpvRYRhub00LP31tBwWjYvndRUXd5hqJgRnoO3kQOCkYgQghQlu1zY51hA9oqG62c9M/txIfZeEPX5pKQrR0wwdTf/qQrjzqUBzwZeCToEYkhAhJ1c12ZueN3P18bHbfXKMWh5snvi5zjQZDf9L7t4/6uwX4GHgweOEIIUKRx+ulpsUxYifF+uYa7WB/XSt/+NIUCmWu0aDoTx/SmYMZiBAidLU63KiMBApGxRkdypDzer389j97+LSskdvPLWS+zDUaNP1uAFVKJQLp+DbCA0BrvT+YQQkhQktCdARLL5tpdBiG+Msn5by+/TDfXZDPRVOzjA5nWOtPH1IR8CwwHd98JBOfz0uyBD80IYQw1srtVTzxcRmLpmTy3QUy12iw9WeU3Z/w7ew6CjgCpAKPA5cPQlxCiBCycnsV316+keZ2l9GhDKplaw90bqL3qX+u0aTMeMakxspcoyHQn4Q0HfiZfydXk9a6CfgJcPdgBCaECB1l9W3sqW0hPnp4N4YUZSVy68qdvLK1kp+9toOsxGgqm+xMzU4yOrQRoT8JqR2I9P9eq5TK9z8+LehRCSFCSrXNjjU+athvXV6cn8LV8/P57dt78Hq9NNtd3HthkWysN0T6k5A+AC71//4S8CawGng32EEJIUJLtW1kDPleub2Kh97fT2K0hVanh6/NyJFkNIT6M8purdb6af/v/wtsAxLx9SUJIYax6mY7hdZ4o8MYNG6Plz++X8KzGypQGfFUHbFz1fx8VmyppDhPth4fKv1JSHcA9wNorT34F1VVStUDvw1+aEKIUDE1O5FJmYlGhzEobHYXt/1rFx+V1HPG+DQ2H2rqbKYrzkvh1pU7uWfRZElKQ+CECUkpdVbHuUqpM+ky/wgYBzQPRmBCiNDxq/MmGR3CoDjQ0MaPXtlOeWMbt549AZvdzddn5XYmn+L8FO5ZNJkdVc2SkIZAX2pIf/X/jAb+1uW4FzgM3BDsoIQQYrCtK2/g56/vxAQ8+tVpzM5L6fW84nxpshsqJ0xIWuuxAEqpZVrrJYMfkhAilHxSWs8db2j++JVpqMzhsYbbi5sP8fv39jJmVBy/v2QKo1NijQ5J0L+17CQZCTECHW6209DmJDEm/LdacLk93P/ffazYUsmp40Zx9/mTZAuJECJ3QghxXNU2BwDWhCiDI+mfZWsPUJSV2Nnc1tjm5LoXP2N3TQtL5uRx7akFWMzDe15VuJGtDoUQx1XdbGdUXGTY7YzaserC+vJG9tW2sHjpenbXtHDF3DxuOH2sJKMQJDUkIcRx1YTppNji/BR+fb7ih69sw+X24vJ4+clZ47l0Zq7RoYljkIQkhDiu2XnJuD3eE58YQrxeLx+V1PPQ6v20OT0AfH1mjiSjECcJSQhxXN+ek2d0CP2yt7aFh1bt55OyBjISooiPsvCNmTms+KyKMyakyxDuECYJSQhxTB6vF6fbS3RE6PcfNbQ6ePzjMl7+rJL4qAi+Oj2bd3bXcP/FU/xziVJl1YUQF1IJSSn1S+BOYJrWeptSqhBYim9F8TpgidZ6j//cgMqEEH13sLGdL/9tHXefP4n/mZxhdDi9crg8vLDpIH/9pJx2p5uvzcjh6gVjeG1rFfcsKpJVF8JIyHztUUrNAuYD5V0OPwY8qrUuBB7FtyHgQMuEEH1UbbMDkBoXeYIzh57X6+W9PbVc+vR6Hn6/hBm5yTx/eTE/PmsCKbGRLJmb1yPxFOensGRueDVBjiQhUUNSSkXjSxzfxLcrLUqpDGAWcI7/tOeBR5RSVnzr6fW7TGtdMwQvR4hhoyMhZYbYKLtdh5t5cNV+NlY0MS4tjj9+ZSrzC0YZHZYYoFCpId0FPKO1LulyLA84qLV2A/h/HvIfD7RMCNEPNc3+SbGJoTEpttZm565/a5Y8s4n9da38/OwJPLtktiSjYcLwGpJSagEwB/i50bF0lZY2PNbsGoms1uG5TYIRmt1eEqMjKMgdum3Pert/7U43f/lgP39atQ+n28N3Tx/HdWdOIDk29JoSReAMT0jAQmASUKKUAhgNvAXcAuQqpSxaa7dSygLkAAfwNcsFUtZndXU2PGE290L4PsxqamRHlGCZao0nbs7oIXtPj75/Xq+Xt3fV8MgHJVQ12zljQho3nj6OvNRYHLZ2amztQxKXOLFgfBE0PCFpre8F7u34WylVCizyj7K7FliMbzPAxcCmjn4gpdTmQMqEEH23cEIaCyekGfLcWw8d4cFV+9ha2YzKSODO89Qxt4gQw4PhCekErgGWKqXuABqAJUEoE0L00aGmdtLio4Z0HlLVkXYe+aCEt3bVkBYfxe3nFnJBUaasPTcCmLxeaZY6SgFQIk124Uma7ILH5fFy6h8+4Ip5+VxzSkHQr3/0atytDjd/+LCE17ZUEmE2cdnsXC6fm09clCXozy2Cr0uT3VigNJBrhHoNSQhhkPoWB24vZAzSthMdq3H/5oJJHG6284fV+znS7qI4L5lf/o8iKylmUJ5XhC5JSEKIXnXMQcpIHJw5SJMyE7igKIMbV2zF7QWL2cSdF03hgonG9FkJ40lCEkL06vON+YKXkLxeL5sONvHatsO8q2tod3lIiY2gsc3F5XNGc8XJBdLkOoJJQhJC9Kq6OXirNBxutvPGjsO8vq2KA43txEdZOL8ok4nWOB7/uIyr5uezYkslZ5+Uw8Sk0FoVQgwdSUhCiF7NGp3MzQvHkRx74o+JowcoAKwpqefNndU0tTv5pLQBj9e3t9LVC8Zw1sR0tlU2+1ff9i2AWpyXwvXPbeI350+SxU9HKBll11MBMsoubMkoO2OsL2/s3NohOTaCJ9eUs2pPLV58gyIWTc3iwimZjE6J7XxMb0lszxE7a3ZVywKoYUhG2QkhBo2utpESG0nmCQY1tDnd2F0eZuQmcd1Ln9HxPW7W6GSumJfH3PzUXucQ9ZZ0Th6fLk12I5gkJCFEr37++g6KMhP5zaLJ3Y57vV721bWypqSeT0ob2HSwqXMTv5zkGCoa27msOJebF443KHIRriQhCSF68Hq9VDfbOWNCOgBNbU7WljfySakvCXWMwBuXFselM3JZUJCKx+vljjd15wCFU8emSV+Q6BdJSEKMYL3146wvb2R9eQMOt5e9tTaufG4T26ua8XghMTqCeWNSmF+QyvyCUZ3NeevLG7lt5a7O7cGL81Jku3DRb5KQhBjBOlZLuGfRZMaMiuX5DQf5+6aDWPxdPp+UNjI1O5Er5+WzYOwoirISieilP2hHVXO35CPbhYtAyCi7ngqQUXZhS0bZnZjX66WuxcGe2hb21rTwSWkD6w80dg5GSIqJQGUksK68kYe+PJWTxw7d5ndy/8KXjLITQhxXu9PN/rpW9ta0+BOQjT01LTS1uzrPyUiI6hyM8KWTsrj17InUtTrZVNHESTlJBkYvRhpJSEKEqGP17+yoau4xZNrj9VJ5pN2XeGpa2Ouv/RxobOus+cREmJlgjefMielMtMYzPj2eCenx7Klp4daVOzsHI3xRZVCcn8I5yjqEr1YISUhChKyu/TvF+Smdk0/vOLeQzRVNvqRT60tA+2pbaHG4Ox87OiWGCenxfHGSlQnWBCamx5ObEoPZ1L3/p+uE1q6DEb67IJ9JmYlSQxJDSvqQeipA+pDCltF9EP2p1RyPy+2hpsXB6j11/PnjUgqt8WyrbCYpJoL6VmfneYnREUywxjMxPd730xrPuLT4Pu8hdKx47/nPHhJiIlh62cw+xxwMRt8/ETjpQxIixByrVnNPl8mlHq+X+hYHh5vtHG62U+X/2fW/WpuDrl+HNh88QkpsBHPyU5iQHs9EawLj0+PITIzGZAp8J9XekmRxfgoRFtOg7YMkxLFIQhLiOPpb45manciPzxrPT1/bwfyCVD7cX8dp49N4dVsVT6wp43CznepmO66jat/REWYyE6PJSoxm/phUMhOjyUyMpqndydK1FXxlejavbK3ikmnZQzKMutpmpzhv8J9HiK4kIYmQ0d8P/97O/3hfbVAW5/R4vbQ53WQnR/PT13ZwzSljyEqKYXNFEy9uPsQp40Zx55u7aGhz0tDqpNH/s93l6bzGf3QNAO/uriUzIYrMxGimZSeSWWglKym6M+lkJkaTHBPRo6azvryRR1eW8ruLfKthzxuTOiSTTVsdbmx2N1apIYkhJglpGAtWf8ZQPUdfmrtOdP4v3tjFnecWUt/qwGZ30+JwYbO7aLG7sTlcXY4d/2eL3d2tyez/3tvX7bk/3F9PamwkqXGRpMRGMjYtjpTYSFJjI2lqd/LyZ1V8oTCdVXvruGfRZOaOSe3XewHGTTYd7J1ihTgWGdTQUwFBHNQQjG/9gX7AHz2C6ui/g+FEz+H1enF7vDjcXhxuDw6XB4fbg9P/t9Pt/9vlxe72sOtwM89uOMis3GQ2VDTyRWUlPSEau8tDu9NNu8tDu9OD3eX7vdbmoLyhlbgoCza7G4vZ1KM5rDfREWbioywkREf06efqfXW8vauGS2fmcP1pY4mN7H3QwFC854Ot3elGV9vIS41lVNzQ1pJkUEP4CsagBklIPRUQxITU8YH02wsmMdGawMaKRn7znz38/OwJTMtOwouvecjrBY8XPjvUxAP/3c9NC8dRlJXAtkPN/PGDEn5w6hgKrQl4vL7z3R6v76cXPF1+93aW+c7bW9PCii2VzBydxMaKJi4oyiQnOQaXx3eey/+fu9tPz1F/e3G5vbi9vp8urxe324PLAy6Ph+Z2F4eOtJMQHUGz3UVClAUv+JKOy0Mw/g+LiTATE2khJsJMdJffYyLNVB6xU97QxqTMBM6cnInJ5T5hgom0mPt9D78yPZsVWyqPm1yGolY6nElCCl+SkAZHAUEe9r2+vJGbX96GvUv/QiiJMJuwmE1E+P/r+nuExYzFZCLCYurx8/NzzZQ1tFJW38YEazzTshOJspiJspiJjDATZTH5frf4f48wd/nbTGRHeYSZvTUtPLx6P+dPyeTNHYe56zzFgrGjjjmS7Ohk8advzQrqfjrDocbTX58dOkJFYxvnTc4Y0Ai+QEhCCl8y7DtMFOencNHULF7cfIgFBamcMSENk8mE2UTnT7PJhMkEZnw/391dy3t7ajm7MJ3zijKxmEyYzb7zOn63mEyYTSbMZhMW/zXMR523veoI//fePi4oyuSNHYe5/dxC5vg3TIswfx7DQHR8SB890z+Q6zzyQQn3+TvxF45PO+6Hf2+TOoO9BfZIXDT0zR2HeVvXcH5RptGhiBFGEtIQWF/eyH90TecH9pI5ecf9MFtf3sjGiqbO878yPSfgD/jf/3c/913o+4A//QQf8IE41kz/QJ6jvx/+vZ3/yDdnsmZXddBe37Hm6QzXZARQbXOQkSADGsTQkya7ngoYhD6kvjb5BLOJKNxG2QWDNPkM3JJnNpIaF8lDX5425M8t9y98SR/S4ChgmIyyG4nkA23gzv3zGk4bn8ZtXywc8ueW+xe+pA8pDPS3yWckNhGJ0OF0e6hvdZIpTXbCAJKQhBCdIswmVn5vHlGWoR1dJwRIQhJCdGEymciUFRqEQfo+O1AIMeztOtzMU5+W09xlR1khhookJCFEp40VTfzpw1I8MthJGMDwJjulVBqwHBgP2IG9wPe11jVKqUJgKZAG1AFLtNZ7/I8LqEwIcWyHm+1ER5hJijH8o0GMQKFQQ/ICv9NaK631ScA+4F5/2WPAo1rrQuBR4PEujwu0TAhxDDU2BxkJUUO+ZJAQEAI1JK11PbCqy6FPgB8opTKAWcA5/uPPA48opayAKZAyrf0b1AghelXdbJdtJ4RhDE9IXSmlzMAPgNeAPOCg1toNoLV2K6UO+Y+bAizrc0JKS0sI3gsTQ6rLBD3RTw3tLmblpxj6Hsr9G7lCKiEBfwRswCPATCMDCeZq32LoyEz/gXnh8tnYXW7D3kO5f+ErGF8kQqEPCQCl1P3ARODrWmsPcADIVUpZ/OUWIMd/PNAyIcRxRJhNxEeF2vdUMVKEREJSSv0GmA1corW2A2itq4HNwGL/aYuBTVrrmkDLhuClCBG2DjS0ce87eyitbzU6FDFCGZ6QlFJTgP/FV4v5WCm1WSn1sr/4GuAGpdRu4Ab/3wywTAjRi/11razYUkmLw210KGKEMrxurrXejm8gQm9lu4B5wSwTQvSuxmYHICMhyuBIxEhleA1JCBEaqm12LCYYFScJSRhDEpIQAvDtFJsWH4XFLJNihTEkIQkhAHC4POQkxxgdhhjBDO9DEkKEht8umozsIC2MJDUkIUQnWcNOGEkSkhACm93FLS9v49PSBqNDESOYJCQhBNU2Ox/ur6exzWl0KGIEk4QkhKC62T8HSVb6FgaShCSEoNrmAMAqk2KFgSQhCSE6a0jWBKkhCeNIQhJCEGkxM9EaT3SEfCQI48g8JCEEl8/N4/K5eUaHIUY4+TokhBAiJEhCEkLwg39s4R+bDhkdhhjhJCEJMcLZXR7WH2ii2S5zkISxJCGJAXG5PTS2+j7Iamx2nvi4lCaZXBkWqpvtLF17gCXPbAQgO0kWVhXGkoQkArbhQCPfXL6RO97chdfrZU1JA0+uKefiv6zlkQ9KqG91GB2iOEqrw43d5QHgrV3VPPJBCYnREdx6zkTOUVaDoxMjnYyyE/1W2+Lg4dX7eXNnNTlJ0Xx1Rg4mk4mLpmVRlJXI3z4tZ9naA/x940G+NiOHG08fK4t2Gsjt8bKuvIF/7ahm1Z5abj1nIucXZXLh1CzOmJBOXmqs0SEKAUhCEv20saKRH768HYfbw5Xz8/nO3DxiIi2d5ROs8fx20WS+d/IYnv60nIZWR2cyamx1khIXaVToI47T7eFPH5by753V1LY4SIyO4PyiTAqtCQCkxEaSEiv3Q4QOSUiiT9qdbmIiLRRaEzh13Ci+d3IB+cf5Zl0wKo47z5vUub/Onhoblz+7ifMnZ3LFvDxGp8i38sFQa7Oja1o4ZewoIswm1pc3MiUrkfOLMjh1XBpRMvFVhDCTbMjVQwFQUldnw+OR96ax1ckjH5SwvaqZ5d+aSYQlsA+0Gpudpz89wCtbK3F7vJw7OYMr5uYzNi0uqPFarYnU1DQH9Zqhrs3pZtXeWt7YUc3asgZiIiy8fe0CoiPMuDxeIsJoS/KReP+GC6s1sePXsUBpINeQGpLolcfr5dWtVTz6QQk2u4tvzBrt+3CznPixvbEmRPOTL0zgO/PyWL6+gn9uqWT13jrevGY+sZEBXlTw1s5qfvufPbQ63eQkRXPFvHzOn5zRuQRQOCUjISQhiR5qWxz85NXtbKtsZuboZH76hQlMSI8PyrXTE6K55YzxXDE3jx2HbcRGWvB6vTz8fgnnKCtFWYknvsgItq+2hTd2VHP6+FFMz01mXHoc50yycn5RBjNykzHL4BERxiQhDZF2p5v61s/n55hNkOWf91HX4ugcitvBYjaROcR703i9XkwmEymxkSRERfCr8xTnTc4YlBFyqXFRnDJ2FACHjrTz6tYqnllfwYKCVC6fm0d2UgzWhCgiLWZsdhdH2l09rpGRGE2E2URzu4tmu6+83WKhvqkdgMzEaCxmE01tTloc7h6Pz06KxmQy0djmpPWocpPp83k5Da0O2pzd70/X+1ff6qDdeez7V9viwHHU/Y0wmzr3Hqqx2XG6uzcPR1lMpPtX3q5obOP9fXW8uaOaXdU2LCZIi49kem4yE60J3PbFwl7fYyHCjfQh9VRAEPqQWh1u4qJ8TVH3v7eXl7b4+k46pMVH8e9r5gNwy8vb+HB/fbfH56fGsuLKOQC8t6eW3KQYCjPiByU5eL1e3thRzbMbKnj80ukkxgz99xSb3cVLmw/x7IaDnbuWvnDFbMalxfP8xoM88N99PR7z+nfnkpUUw18/KeOxj8p6lL973QKSYiL54/v7Wbauokf5mltOI8Js4t539rBiS2W3sugIMx/edCoAd7yxizd3VncrT42N5O1rFwDwk1e3s2pvXbfy3OQYXrl6LgDXvvgZ68obu5VPtMbz3JLZAFzx7Ca2V3XvN5mek8RfFs8A4NKn1lNS38rkzATOK8rk3ElWRsUNz32LpA8pfEkfUgipbXGwuaKJzQeb2FjRxP66Vt65dgEJ0RFMzkzkW8UW8lNj6UgnXZf5/8asXM6amN7tevHRvlvj8Xq59z97aGhzkpMcw5kT0jlzYhrTcpKC0jyzt7aF3727l00VTUzNTqSp3WlIQkqIjuCKefl8fVYuH+yrw+7yYI331RDmjUnhjnN71gKS/UOWTxuXRoa/NpGYGENzs6+GFOPv8PpCoZWCUT0HT3R0r5xflMmUo5oKLV36Xi45KYs5+Sndyrvev0tn5nD6+LRu5fFRn/eLfXvOaM6bnNGtPKnLe3zV/PweW4d3TTjXnlpAXmos44PUbCpEqJIaUk8F9KGGVHmkncToCBKiI3h9WxV3vbUb8H1QnZSTxMzRyXxtRk5Q5nk0tjpZva+W/+6p49OyBlweL5fPzeP608bi8XrxePvfee3yeHnk/RL+vrGChOgIrjttLBdPywr7Pgj5hh3e5P6FL6khDRGv10tZfRsbDzaxqaKJzRVNVDXb+fX5kzh3sq8z+cbTxzIjN5lJmQlEBjg0+lhS4iK5eFo2F0/LxmZ38eH++s5BBp8dPMKPX93O6ePTOHNiOvPGpPZpronFBGUNrSyamsX1p46VCatCCMNJDamnAqBkna7G6XYz0ZpA5ZF2LnpyLQCj4iKZNTqZmaOTOW18muELUu6utrF8fQUf7KujxeEmPsrCKWNH8aOzxvfoZyirb+Wh1fv54ZnjGZ0SG3ZzVPpCvmGHN7l/4UtqSIPolle2UZSRwG8WTSY7KYZfnaeYmp1EXkpMSK3LVpiRwN3nT8Lp9rC2vJH/7qllU0UTif4+qDd2HMbrhfLGNpavO0CUxUxJXSujU2KHXTISQoQ3SUjH8MMzxlNo/bwT+fyiTAOjObFIi5lTxo7ilLGjOodvA7y2rYoNB5oAOG9yBjcuHEd6/PAcoSWECG/DNiEppQqBpUAaUAcs0Vrv6evjF05IC9ulg7rW4P70tZPYWdVMhNmMykwwMCohhDi+4bzS4mPAo1rrQuBR4HGD4zGE2WRiSnaSJCMhRMgblglJKZUBzAKe9x96HpillOxAJoQQoWpYJiQgDziotXYD+H8e8h8XQggRgoZtH9JApaVJE1e46jL8VIQhuX8j13BNSAeAXKWURWvtVkpZgBz/8T6R/ZDCk8xjCW9y/8JXML5IDMsmO611NbAZWOw/tBjYpLWuMSwoIYQQxzVca0gA1wBLlVJ3AA3AEoPjEUIIcRzDNiFprXcB84yOQwghRN8M24Q0ABYAsyyrE7bk3oU3uX8jlySknrIBUlNl75lwJSMkw5vcv5FLVvvuKRqYA1QCPfe9FkII0ZuOXSnLAFcgF5CEJIQQIiQMy2HfQgghwo8kJCGEECFBEpIQQoiQIAlJCCFESJCEJIQQIiRIQhJCCBESJCEJIYQICZKQhBBChARZOqiPlFJFwE34ZiNHAN/RWsus4jCilFoKOLXWVxsdi+g7pVQB8CawGqjWWt9hbESiP5RStwNWwK21vuV4547IhKSUuh/4ClAATNNab/MfLwSWAmlAHbBEa70HQGu9A/i+/7wXgXjANuTBj3CB3Dt/+fXAW8BZQx2z+Fyg9w9oxres1/4hDVh0CuTeKaUWAVOBg0D1iZ5jpDbZvQKcjm/Npa4eAx7VWhcCjwKPdy1USp2plHoWqAVahyBO0dMr9PPeKaVmA3HAx0MUozi2V+j/v70yrfVc4Epgkb/GJIbeK/T/3k0BtmutfwikKKVOPd4TjMiEpLX+UGvdbTtzpVQGMAt43n/oeWCWUsra5XH/1Vpfhm/hwBlDFK7oIsB7dwEwEfgNcIpS6rShild0F8j962ga9/+sBga+V7botwD/7ZXhqzWB74t80vGeY0Q22R1DHnBQa+0G0Fq7lVKH/MdrlFJnAF8FTEAksM2oQEUPx713Wuu7oLMv4jat9QeGRSp605d/e0vwrb7frLXealik4mjHvXfAP4E/KaV+D4wCHjrexSQh9ZHWehWwyuAwxABorUsBGdAQZuTfXvjSWjvox7+5EdlkdwwHgFyllAXA/zPHf1yENrl34U3uX/gK6r2ThOSnta4GNgOL/YcWA5u01jWGBSX6RO5deJP7F76Cfe9G5AZ9SqmHgS8DWfg62uq01lOUUpPwDV9MBRrwDV/UxkUqjib3LrzJ/QtfQ3HvRmRCEkIIEXqkyU4IIURIkIQkhBAiJEhCEkIIERIkIQkhhAgJkpCEEEKEBElIQgghQoIkJCFCgFLKq5SaMEjXvlMp9cxgXFuIYJK17IQ4DqVU1z2v4gA7vkU+Ab6vtX62l8ecATyjtR4d4HM+DXwTcABeYDfwQ6316kCuFyz+xWlLgEittcvIWMTwJAlJiOPQWid0/K6UKgWu1lq/MwRP/Tut9W1KKTO+fYD+qZTK6FhVWYjhSBKSEAFQSkUD9wGX+g/9A/gZvn9TbwLRXWpXhcBofEvvTwbagBX4aj2O4z2P1tqjlHoOeBLIBA4ppe4EJmitv+WPpYAuNRel1FjgaXz71HwCdFvGRSm1BLgbSAD+AFyFP9H6E+BPge8CKcC7wDVa63rgff8lGpVSAOdordf06Q0Tog+kD0mIwPwCmI9vo8bpwFx8ey21AOcBh7TWCf7/DuFr5rsFSAcWAF8Arj3Rk/hXT16CL+Ec7mNszwEb/M91N3B5l+sVAX8CLgOygWQgt8tjbwQuARbiW7W5Ad8uoODbLRQgxf+6JBmJoJIakhCBuQy4wb/aMUqpX+Hbuvn23k7WWm/o8mepUupxfB/6fzjG9X+slLoeiPH/fVVfmuuUUvnAHOBsrbUdeF8p9XqXU74KvK61/tB//h34klCH7wPXa60r/OV3AuVKqW+f6LmFGChJSEIEJgff9swdyvzHeqWUKgQeAIrxDY6IwFeLOZb7/X1IJmAK8LZSql5r/WYf4mrw19S6xpbXpbxzrxqtdatSqq7LuWOAl5VSni7H3PiaC4UYVNJkJ0RgDuH78O6Q7z8GvpFxR/szsAuYqLVOAv4XMJ3oSbTWXq31NuAj4AL/4RZ8Sa1DVpffK4FUpVT8UbF1Le8c/aeUigXSupQfAM7TWqd0+S9Ga33wGK9LiKCRhCREYJ4HblNKWZVS6cAdQMdcn8NAmlIqucv5icARwObfP+YHfX0i//mnAtv9hzYDpyul8v3PcWvHuVrrMmA98CulVJRS6lTgwi6Xewm4UCl1slIqCvgV3RPjY8BvlFJj/M9tVUpd7C+rATzAuL7GLkR/SEISIjC/xvfB/xmwFdjoP4bWehe+hLVfKdWolMoBfoxvblEzvhFzL5zg+j9VStmUUi3A28BT+Pqo0Fr/x//4z/A1+6086rHfBOYB9cAvgWUdBVrr7cANwN/x1ZaagWp886vANxLwNXxNhM34RunN8z+2FfgN8JH/dc3vyxslRF/JBn1CjGBKqQSgEV9TYonB4YgRTgY1CDHCKKUuxDe/yATcj6+GV2pkTEKANNkJMRJdjG8AxiFgIvANrbU0lQjDSZOdEEKIkCA1JCGEECFBEpIQQoiQIAlJCCFESJCEJIQQIiRIQhJCCBESJCEJIYQICf8PxiUMqAgwhI0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "p_dict = sb.plots.plot_meta_parameters()\n", - "for experiment,v in p_dict.items():\n", - " for param, p in v.items():\n", - " # ax = p.axes[0]\n", - " # ax.set_xscale('linear')\n", - " if param == 'tau':\n", - " ax = p.axes[0]\n", - " # ax.set_yscale('log')\n", - " p.show()\n", - " #Tau on log scale, frac on linear, definitions for axis\n", - " # p.savefig('{}_metaparameters={}.pdf'.format(experiment, param))\n", - " " + "# Plot meta-parameters for experiments that have them\n", + "# Returns nested dictionaries: {experiment_name: {param_name: fig}}\n", + "figs_dict, axes_dict = sb.plots.plot_meta_parameters()\n", + "\n", + "# Iterate through each experiment's meta-parameter plots\n", + "for experiment_name, exp_figs in figs_dict.items():\n", + " exp_axes = axes_dict[experiment_name]\n", + " \n", + " for param, fig in exp_figs.items():\n", + " ax = exp_axes[param]\n", + " \n", + " # Optional: customize axes for specific parameters\n", + " # if param == 'tau':\n", + " # ax.set_yscale('log') # Logarithmic scale for temperature\n", + " # if param == 'frac':\n", + " # ax.set_xscale('linear') # Linear scale for fraction\n", + " \n", + " # Display the figure (last expression in loop)\n", + " display(fig)\n", + " \n", + " # Optionally save individual figures\n", + " # fig.savefig(f'{experiment_name}_metaparam_{param}.pdf')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Recommended Parameters\n", + "\n", + "Visualize how algorithm parameters are recommended to change as resource budgets increase.\n", + "\n", + "### Algorithm Parameters\n", + "\n", + "These are the actual parameters passed to the optimization algorithm:\n", + "\n", + "- **sweeps**: Number of optimization sweeps/iterations\n", + "- **replicas**: Number of parallel replicas\n", + "- **pcold**: Cold state probability\n", + "- **phot**: Hot state probability\n", + "\n", + "Each parameter gets a separate plot showing recommendations from different experiments with confidence intervals." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:00<00:00, 606.75it/s]\n", + "\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], "source": [ - "p_dict = sb.plots.plot_parameters()\n", - "for k, p in p_dict.items():\n", - " ax = p.axes[0]\n", - " if k == 'sweeps':\n", - " # ax.plot(x, sweeps, '--')\n", - " ax.set_ylim(1, 50)\n", - " # ax.set_xscale('linear')\n", - " # if k == 'replicas':\n", - " # ax.plot(x, replicas, '--')\n", - " # ax.set_ylim(0, 22)\n", - " # if k == 'pcold':\n", - " # ax.plot(x, pcold, '--')\n", - " # if k == 'phot':\n", - " # ax.plot(x, phot, '--')\n", - " # ax = p.axes[0]\n", - " # \n", + "# Plot recommended parameters with separate figures for each parameter\n", + "# Returns dictionaries: {param_name: fig} and {param_name: ax}\n", + "figs_dict, axes_dict = sb.plots.plot_parameters_separate()\n", + "\n", + "# Iterate through each parameter's plot\n", + "for param_name in figs_dict.keys():\n", + " fig = figs_dict[param_name]\n", + " ax = axes_dict[param_name]\n", + " \n", + " # Customize y-axis limits for specific parameters\n", + " if param_name == 'sweeps':\n", + " ax.set_ylim(1, 50) # Sweeps typically range from 1 to 50\n", + " \n", + " # Additional customization options (commented out by default)\n", + " # if param_name == 'replicas':\n", + " # ax.set_ylim(0, 22) # Replicas up to ~20\n", + " # if param_name == 'pcold':\n", + " # ax.set_ylim(0, 1) # Probability between 0 and 1\n", + " # if param_name == 'phot':\n", + " # ax.set_ylim(0, 1) # Probability between 0 and 1\n", " \n", - " p.show()\n", - " # p.savefig('Recommended_parameter={}_scale={}.pdf'.format(k, sb.plots.xscale))" + " # Optionally save individual parameter plots\n", + " # fig.savefig(f'wishart_parameter_{param_name}_scale_{sb.plots.xscale}.pdf')" ] }, { - "cell_type": "code", - "execution_count": 33, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Parameter Scaling Insights\n", + "\n", + "Examine the **parameter plots** above to understand how algorithm configuration should change with available resources:\n", + "\n", + "#### Key Observations:\n", + "\n", + "- **Sweeps scaling**: Number of optimization sweeps typically increases with budget - more resources allow more thorough optimization\n", + "- **Replicas strategy**: Different experiments recommend different numbers of parallel replicas, revealing trade-offs between exploration and exploitation\n", + "- **Temperature parameters (pcold, phot)**: These control the annealing schedule and may show distinct patterns:\n", + " - Stable values suggest robust settings\n", + " - Varying values indicate adaptive strategies\n", + " \n", + "#### Practical Applications:\n", + "\n", + "1. **Resource allocation**: At your target budget level, use the recommended parameter values to configure the optimization algorithm\n", + "2. **Scaling predictions**: Extrapolate trends to estimate optimal configurations for budgets beyond the tested range \n", + "3. **Sensitivity analysis**: Parameters with wide confidence intervals may require problem-specific tuning\n", + "4. **Strategy selection**: Compare which experiments provide the most reliable recommendations (narrowest confidence intervals) for your use case\n", + "\n", + "These insights help configure optimization algorithms effectively when solving new Wishart instances or similar problems." + ] + }, + { + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "for idx in [5, 6]:\n", - " parameters_list = sb.experiments[idx].list_runs()\n", - " params_array = np.array([[p[0], int(p[1]), int(p[2]), np.round(p[3], decimals=2),\n", - " np.maximum(0.1, np.round(p[4], decimals=1))] for p in parameters_list])\n", - " np.savetxt('rerun_params_{}.txt'.format(idx - 5), params_array)" + "## Appendix: Exporting Parameters for External Runs\n", + "\n", + "This optional section demonstrates how to export recommended parameters from StaticRecommendationExperiment objects (experiments 5-6) for external re-running.\n", + "\n", + "### When to Use This\n", + "\n", + "StaticRecommendationExperiment objects generate parameter recommendations that need to be:\n", + "1. Exported to a file\n", + "2. Run externally on actual hardware/solvers\n", + "3. Results imported back and attached using `attach_runs()`\n", + "4. Then the experiments can be included in the analysis\n", + "\n", + "### Requirements\n", + "\n", + "To export parameters for experiments 5-6:\n", + "- Re-initialize the full experiment set (without filtering)\n", + "- Ensure experiments 5-6 are properly configured in `stoch_bench_setup()`\n", + "\n", + "**Note**: This section is kept for reference but is not required for the main analysis above." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "# Uncomment the following code if you want to export parameters for experiments 5-6:\n", + "\n", + "# # Re-initialize with all experiments (don't overwrite the filtered 'sb' object)\n", + "# sb_full = stoch_bench_setup()\n", + "# \n", + "# # Export parameters for StaticRecommendationExperiment objects\n", + "# for idx in [5, 6]:\n", + "# # Get list of parameter combinations to run\n", + "# parameters_list = sb_full.experiments[idx].list_runs()\n", + "# \n", + "# # Convert to numpy array with appropriate formatting\n", + "# params_array = np.array([\n", + "# [p[0], int(p[1]), int(p[2]), \n", + "# np.round(p[3], decimals=2),\n", + "# np.maximum(0.1, np.round(p[4], decimals=1))] \n", + "# for p in parameters_list\n", + "# ])\n", + "# \n", + "# # Save to text file for external runs\n", + "# output_file = f'rerun_params_{idx - 5}.txt'\n", + "# np.savetxt(output_file, params_array)\n", + "# print(f\"Exported {len(params_array)} parameter sets to {output_file}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary and Conclusions\n", + "\n", + "This notebook demonstrated comprehensive benchmarking analysis on Wishart optimization problems (n=50, α=0.50), comparing five different parameter recommendation strategies.\n", + "\n", + "### Key Insights from Performance Plots\n", + "\n", + "**Performance Trajectories (\"Windows Stickers\")**:\n", + "\n", + "Based on the actual results from this run:\n", + "\n", + "1. **Best performing strategies**:\n", + " - **At 10⁴ resources**: Projection methods lead with ~95.5% performance\n", + " - Projection from TrainingResults: 0.9545 [0.9501, 0.9589]\n", + " - Projection from TrainingStats: 0.9532 [0.9474, 0.9590]\n", + " - **At 10⁵ resources**: Projection methods maintain lead with ~96.5% performance\n", + " - Projection from TrainingStats: 0.9636 [0.9600, 0.9670]\n", + " - Projection from TrainingResults: 0.9644 [0.9594, 0.9687]\n", + " - **At 10⁶ resources**: All strategies converge to 97-98% performance\n", + " - Projection from TrainingStats: 0.9836 [0.9726, 0.9913]\n", + " - Projection from TrainingResults: 0.9815 [0.9721, 0.9886]\n", + " - SequentialSearch_cold: 0.9775 [0.9619, 0.9899]\n", + " - SequentialSearch_warm: 0.9740 [0.9597, 0.9856]\n", + " - RandomSearch: 0.9672 [0.9556, 0.9789]\n", + "\n", + "2. **Convergence patterns**:\n", + " - **Projection methods** (from Stats/Results) converge fastest - reach 95%+ by 10⁴ evaluations\n", + " - **Sequential Search** methods converge more slowly but catch up at higher budgets\n", + " - **Random Search** lags throughout, suggesting less efficient parameter recommendations\n", + "\n", + "3. **Practical recommendations**:\n", + " - **Low budget (<10⁵)**: Use **Projection from TrainingStats** or **TrainingResults** \n", + " - These leverage pre-trained knowledge effectively\n", + " - Achieve 95-96% performance with minimal resources\n", + " - **Medium budget (10⁵-10⁶)**: Either projection method works well\n", + " - Performance plateau around 96-98%\n", + " - Diminishing returns beyond this point\n", + " - **High budget (>10⁶)**: All methods converge, choice matters less\n", + " - Final performance ~97-98% across all strategies\n", + "\n", + "4. **Confidence intervals**: \n", + " - Projection methods show **narrow confidence bands** (~1-2% width) → consistent, reliable\n", + " - Sequential methods show **wider bands** (~3-4% width) → more variability\n", + " - This indicates projection approaches are more robust across problem instances\n", + "\n", + "### Parameter Recommendation Insights\n", + "\n", + "From the parameter plots, here's what the data shows:\n", + "\n", + "**Parameter scaling with budget** (Projection from TrainingStats example):\n", + "\n", + "- **sweeps**: Scales up with budget\n", + " - At 1,080 resources: ~2 sweeps\n", + " - At 95,459 resources: ~9 sweeps \n", + " - At 956,648 resources: ~30 sweeps\n", + " - **Insight**: More resources → more optimization sweeps for better convergence\n", + "\n", + "- **replicas**: Also increases with budget\n", + " - At 1,080 resources: ~6 replicas\n", + " - At 95,459 resources: ~12 replicas\n", + " - At 956,648 resources: ~32 replicas\n", + " - **Insight**: Parallel exploration becomes more valuable at higher budgets\n", + "\n", + "- **pcold** (cold probability): Remains relatively stable ~1.0\n", + " - Small variations around 0.99-1.05\n", + " - **Insight**: Temperature schedule is fairly robust across budgets\n", + "\n", + "- **phot** (hot probability): Decreases slightly with budget\n", + " - At 1,080 resources: ~43\n", + " - At 95,459 resources: ~38\n", + " - At 956,648 resources: Not shown in excerpt, likely stabilizes\n", + " - **Insight**: Annealing schedule adapts mildly to resource availability\n", + "\n", + "**Key takeaway**: The dominant scaling is in **sweeps** and **replicas** - allocate additional resources primarily to more thorough optimization (sweeps) and broader exploration (replicas), rather than changing temperature parameters significantly.\n", + "\n", + "### Meta-Parameter Adaptation\n", + "\n", + "For adaptive strategies (Random Search and Sequential Search):\n", + "\n", + "- Meta-parameters (tau, frac) automatically tune themselves during optimization\n", + "- Evolution shows how exploration vs. exploitation balance changes with budget\n", + "- Useful for understanding algorithm behavior and debugging\n", + "\n", + "### Workflow Summary\n", + "\n", + "The complete benchmarking workflow includes:\n", + "\n", + "1. **Load experimental data**: Pre-generated results from multiple recommendation strategies\n", + "2. **Filter experiments**: Select experiments with complete results for fair comparison\n", + "3. **Visualize performance**: Plot trajectories to identify best-performing strategies\n", + "4. **Analyze parameters**: Understand how algorithm configuration should scale with resources\n", + "5. **Extract insights**: Determine optimal strategy and configuration for your use case\n", + "\n", + "### Next Steps\n", + "\n", + "To apply these insights:\n", + "\n", + "1. **Select your target budget**: Based on available computational resources\n", + "2. **Choose recommendation strategy**: Pick the experiment with best performance at your budget\n", + "3. **Read parameter values**: From the plots at your budget level\n", + "4. **Configure your optimizer**: Use the recommended parameter settings\n", + "5. **Test on new instances**: Apply the learned configuration to solve new Wishart problems\n", + "\n", + "For further analysis:\n", + "\n", + "- Run experiments 5-6 (StaticRecommendationExperiment) with recommended parameters\n", + "- Test on different problem sizes (vary n) or difficulty levels (vary α)\n", + "- Compare to other optimization methods (quantum annealers, classical solvers)\n", + "- Extend the benchmarking framework to other combinatorial optimization problems" + ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3.9.12 ('stoch_bench': conda)", + "display_name": "stochastic-benchmark-ci-py310", "language": "python", "name": "python3" }, @@ -334,12 +890,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" - }, - "vscode": { - "interpreter": { - "hash": "d142a842be6207d35f7e25a8386fd96606ed78a30f2363613ba223f43dc5fd10" - } + "version": "3.10.19" } }, "nbformat": 4, diff --git a/examples/wishart_n_50_alpha_0.5/wishart_runs.py b/examples/wishart_n_50_alpha_0.5/wishart_runs.py index 97919501..ea17a066 100644 --- a/examples/wishart_n_50_alpha_0.5/wishart_runs.py +++ b/examples/wishart_n_50_alpha_0.5/wishart_runs.py @@ -19,8 +19,11 @@ n_reads = 1001 #TODO change this if you want float_type = 'float32' penalty = 1e6 -datapath = '/home/bernalde/repos/stochastic-benchmark/examples/wishart_N=50_alpha={}/data'.format(alpha) #TODO change the directory where you want this -rerun_datapath = '/home/bernalde/repos/stochastic-benchmark/examples/wishart_N=50_alpha={}/rerun_data'.format(alpha) #TODO change the directory where you want this + +# Use relative paths based on this script's location +script_dir = os.path.dirname(os.path.abspath(__file__)) +datapath = os.path.join(script_dir, 'data') # Relative path for portability +rerun_datapath = os.path.join(script_dir, 'rerun_data') # Relative path for portability class seen_result: def __init__(self): @@ -60,10 +63,12 @@ def obj_fcn(norm_score, mean_time, replicas, s): return replicas * 1e-6 * mean_time * np.log(1 - s) / np.log(1 - norm_score) def load_instance(instance_num): - #TODO fill in your correct path here - base_dir = '/home/bernalde/repos/stochastic-benchmark-backup/data/wishart/instance_generation/wishart_planting_N_50_alpha_{}'.format(alpha) + # Load instance data - assumes instance files are in wishart_planting_N_50_alpha_0.50/ subdirectory + # relative to this script + script_dir = os.path.dirname(os.path.abspath(__file__)) + instance_dir = os.path.join(script_dir, 'wishart_planting_N_50_alpha_{}'.format(alpha)) inst_name = 'wishart_planting_N_50_alpha_{}_inst_{}.txt'.format(alpha, instance_num) - filename = os.path.join(base_dir, inst_name) + filename = os.path.join(instance_dir, inst_name) rows = [] cols = [] @@ -80,7 +85,7 @@ def load_instance(instance_num): qubo = csr_matrix((vals, (rows, cols)), shape = (N, N)) - gs_filename = os.path.join(base_dir, 'gs_energies.txt') + gs_filename = os.path.join(instance_dir, 'gs_energies.txt') gs_dict = {} with open(gs_filename) as f: line = f.readline() @@ -114,7 +119,7 @@ def run_pysa(args, instance_num, pbar=None): #TODO double check these!!! min_temp = 2 * np.min(np.abs(qubo[np.nonzero(qubo)])) / np.log(100/pcold) # min_temp_cal = 2*min(sum(abs(i) for i in qubo)) / np.log(100/p_cold) - max_temp = 2*max(sum(abs(i) for i in qubo.A)) / np.log(100/phot) + max_temp = 2 * np.max(np.abs(qubo.A).sum(axis=0)) / np.log(100/phot) solver = Solver(problem=qubo.A, problem_type='ising', float_type=float_type) res = solver.metropolis_update( num_sweeps = sweeps, @@ -135,7 +140,7 @@ def run_pysa(args, instance_num, pbar=None): else: min_temp = 2 * np.min(np.abs(qubo[np.nonzero(qubo)])) / np.log(100/pcold) # min_temp_cal = 2*min(sum(abs(i) for i in qubo)) / np.log(100/p_cold) - max_temp = 2*max(sum(abs(i) for i in qubo.A)) / np.log(100/phot) + max_temp = 2 * np.max(np.abs(qubo.A).sum(axis=0)) / np.log(100/phot) solver = Solver(problem=qubo.A, problem_type='ising', float_type=float_type) res = solver.metropolis_update( num_sweeps = sweeps, @@ -186,7 +191,7 @@ def rerun_pysa(params, instance_num): print('Trying to run pysa for parameters ', params) min_temp = 2 * np.min(np.abs(qubo[np.nonzero(qubo)])) / np.log(100/pcold) # min_temp_cal = 2*min(sum(abs(i) for i in qubo)) / np.log(100/p_cold) - max_temp = 2*max(sum(abs(i) for i in qubo.A)) / np.log(100/phot) + max_temp = 2 * np.max(np.abs(qubo.A).sum(axis=0)) / np.log(100/phot) solver = Solver(problem=qubo.A, problem_type='ising', float_type=float_type) res = solver.metropolis_update( num_sweeps = sweeps, @@ -292,7 +297,7 @@ def rerun_outer(instance_num): rerun_pysa(params, instance_num) if __name__ == '__main__': - instance_num = int(os.getenv('PBS_ARRAY_INDEX')) + instance_num = int(os.getenv('PBS_ARRAY_INDEX', '0')) # Default to '0' if not set rerun_outer(instance_num) # #base_num = 500 diff --git a/examples/wishart_n_50_alpha_0.5/wishart_ws.py b/examples/wishart_n_50_alpha_0.5/wishart_ws.py index e48235b2..a6079357 100644 --- a/examples/wishart_n_50_alpha_0.5/wishart_ws.py +++ b/examples/wishart_n_50_alpha_0.5/wishart_ws.py @@ -12,6 +12,10 @@ from sklearn.pipeline import make_pipeline import sys from tqdm import tqdm +import warnings + +# Filter known third-party warnings +warnings.filterwarnings('ignore', message='pkg_resources is deprecated') sys.path.append('../../src') #TODO set path to point to src of stochastic-benchmark import bootstrap @@ -27,8 +31,10 @@ import wishart_runs #TODO I need to find the file I sent previous -> add to path if necessary alpha = '0.50' -# datadir = '/home/bernalde/repos/stochastic-benchmark/examples/wishart_n_50_alpha_{}/data'.format(alpha) #TODO set this to where the pickled datafiles are stored -datadir = '/home/bernalde/repos/stochastic-benchmark/examples/wishart_n_50_alpha_{}/rerun_data'.format(alpha) #TODO set this to where the pickled datafiles are stored +# Set datadir relative to the current file location +# This assumes the data is in rerun_data/ subdirectory of the example folder +script_dir = os.path.dirname(os.path.abspath(__file__)) +datadir = os.path.join(script_dir, 'rerun_data') # Use relative path for portability def compress_order(df_single): @@ -185,8 +191,8 @@ def postprocess_random(meta_params): def stoch_bench_setup(): # Set up basic information alpha = '0.5' - # path to working directory - here = os.path.join('/home/robin/stochastic-benchmark/examples', 'wishart_n_50_alpha_{}/'.format(alpha)) + # path to working directory - use current directory (where notebook is located) + here = os.path.abspath(os.getcwd()) parameter_names = ['sweeps', 'replicas', 'pcold', 'phot'] instance_cols = ['instance'] #indicates how instances should be grouped, default is ['instance'] @@ -207,15 +213,15 @@ def stoch_bench_setup(): 'response_dir':-1,\ 'confidence_level':68,\ 'random_value':0.} - metric_args = {} + metric_args = defaultdict(dict) metric_args['Response'] = {'opt_sense':-1} metric_args['SuccessProb'] = {'gap':1.0, 'response_dir':-1} metric_args['RTT'] = {'fail_value': np.nan, 'RTT_factor':1.,\ 'gap':1.0, 's':0.99} - def update_rules(self, df): #These update the bootstrap parameters for each group + def update_rules(self, df): # Update the bootstrap parameters for each group GTMinEnergy = df['GTMinEnergy'].iloc[0] - self.shared_args['best_value'] = GTMinEnergy #update best value for each instance + self.shared_args['best_value'] = GTMinEnergy # Update best value for each instance self.metric_args['RTT']['RTT_factor'] = df['MeanTime'].iloc[0] agg = 'count' #aggregated column @@ -274,7 +280,8 @@ def resource_fcn(df): resource_values = list(recipes['resource']) budgets = [i*10**j for i in [1, 1.5, 2, 3, 5, 7] for j in [3, 4, 5]] + [1e6] - budgets = np.unique([take_closest(resource_values, b) for b in budgets]) + # Convert to list for type safety with RandomSearchParameters.budgets: list + budgets = list(np.unique([take_closest(resource_values, b) for b in budgets])) # which columns determin the order in sequential search experiments ssOrderCols0 = ['warmstart=0_hpo_order={}'.format(hpo_trial) for hpo_trial in range(10)] @@ -308,8 +315,11 @@ def resource_fcn(df): sb.run_StaticRecommendationExperiment(sb.experiments[0]) sb.run_StaticRecommendationExperiment(sb.experiments[1]) - testing_results = sb.interp_results[sb.interp_results['train'] == 0].copy() - testing_instances = list(np.unique(testing_results['instance'])) + if sb.interp_results is not None: + testing_results = sb.interp_results[sb.interp_results['train'] == 0].copy() + # np.unique returns ndarray which works fine for iteration, but explicit list + # conversion improves clarity and ensures compatibility with functions expecting lists + testing_instances = list(np.unique(testing_results['instance'])) # for idx in [5, 6]: # parameters_list = sb.experiments[idx].list_runs() # if idx == 5: @@ -418,10 +428,26 @@ def prepare_param(k): for k in tqdm(results_dict.keys()): ret = prepare_param(k) ret_list.append(ret) + + # Filter out None values that may be returned when res_list is empty + ret_list = [r for r in ret_list if r is not None] + + if len(ret_list) == 0: + print('Warning: No valid results to concatenate. Returning empty DataFrame.') + return pd.DataFrame() + try: ret = pd.concat(ret_list, ignore_index=True) - except: - print('failing external loop') + except ValueError as e: + # Raised when DataFrames have incompatible columns or no objects to concatenate + print(f'Error concatenating results: {e}') + print(f'Number of DataFrames: {len(ret_list)}') + raise + except TypeError as e: + # Raised when ret_list contains non-DataFrame objects + print(f'Error: ret_list contains invalid objects: {e}') + print(f'Types in ret_list: {[type(r) for r in ret_list]}') + raise return ret def main(): diff --git a/quick-reference.sh b/quick-reference.sh new file mode 100755 index 00000000..b0baba7d --- /dev/null +++ b/quick-reference.sh @@ -0,0 +1,88 @@ +#!/bin/bash +# Quick Reference Card for CI Testing +# Print this for easy reference + +cat << 'EOF' +╔═══════════════════════════════════════════════════════════════════════════╗ +║ STOCHASTIC-BENCHMARK CI TESTING ║ +║ Quick Reference Card ║ +╚═══════════════════════════════════════════════════════════════════════════╝ + +📋 INITIAL SETUP +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # Create CI environment (Python 3.10 default) + ./setup-ci-env.sh + + # Or specify Python version + ./setup-ci-env.sh 3.11 # Python 3.11 + ./setup-ci-env.sh 3.12 # Python 3.12 + +🧪 RUNNING TESTS +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # Activate environment + conda activate stochastic-benchmark-ci-py310 + + # Run full CI test suite + ./run-ci-tests.sh + + # Run specific tests + export PYTHONPATH="${PYTHONPATH}:${PWD}/src" + pytest tests/test_bootstrap.py -v + + # Run with parallel execution + pytest tests/ -n auto + +🔄 TEST ALL PYTHON VERSIONS (3.10, 3.11, 3.12) +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # Test all versions automatically + ./test-all-python-versions.sh + +📊 VIEW COVERAGE +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # HTML report (open in browser) + firefox htmlcov/index.html + + # Terminal report + coverage report + +🔍 LINTING +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # Check for critical errors + flake8 src --count --select=E9,F63,F7,F82 --show-source --statistics + + # Full style check + flake8 src --max-line-length=120 --statistics + +🧹 CLEANUP +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + # Remove environment + conda deactivate + conda env remove -n stochastic-benchmark-ci-py310 + + # Remove coverage reports + rm -rf htmlcov/ .coverage coverage.xml .pytest_cache/ + +📚 ENVIRONMENT NAMES +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + Python 3.10 → stochastic-benchmark-ci-py310 + Python 3.11 → stochastic-benchmark-ci-py311 + Python 3.12 → stochastic-benchmark-ci-py312 + +💡 TIPS +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + • Always set PYTHONPATH before running manual pytest commands + • Use run-ci-tests.sh to replicate CI exactly + • Create all Python version environments to match CI matrix + • Check CI-TESTING.md for detailed documentation + +📄 FILES CREATED +━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ + • environment-ci.yml → Conda environment specification + • setup-ci-env.sh → Environment setup script + • run-ci-tests.sh → Run full CI test suite + • test-all-python-versions.sh → Test all Python versions + • CI-TESTING.md → Complete documentation + • quick-reference.sh → This reference card + +═══════════════════════════════════════════════════════════════════════════ +EOF diff --git a/requirements-examples.txt b/requirements-examples.txt new file mode 100644 index 00000000..f91aa5c1 --- /dev/null +++ b/requirements-examples.txt @@ -0,0 +1,3 @@ +# Optional dependencies for running example notebooks and scripts +# These are NOT required for core stochastic-benchmark functionality +scikit-learn>=1.3.0 diff --git a/run-ci-tests.sh b/run-ci-tests.sh new file mode 100755 index 00000000..d2f7327b --- /dev/null +++ b/run-ci-tests.sh @@ -0,0 +1,106 @@ +#!/bin/bash +# Script to run tests exactly as the CI does +# This replicates the test steps from .github/workflows/ci.yml + +set -e # Exit on error + +# Colors for output +GREEN='\033[0;32m' +BLUE='\033[0;34m' +YELLOW='\033[1;33m' +RED='\033[0;31m' +NC='\033[0m' # No Color + +print_step() { + echo -e "${GREEN}==>${NC} $1" +} + +print_error() { + echo -e "${RED}ERROR:${NC} $1" +} + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}Running CI Tests Locally${NC}" +echo -e "${BLUE}========================================${NC}" +echo "" + +# Set PYTHONPATH to include src directory (matches CI) +export PYTHONPATH="${PYTHONPATH}:${PWD}/src" +print_step "PYTHONPATH set: ${PYTHONPATH}" + +# Check if we're in the right directory +if [ ! -f "pyproject.toml" ] || [ ! -d "src" ] || [ ! -d "tests" ]; then + print_error "Please run this script from the repository root directory" + exit 1 +fi + +# Step 1: Lint with flake8 (optional, matches CI) +print_step "Step 1: Linting with flake8" +echo "" +echo "Checking for syntax errors and undefined names..." +flake8 src --count --select=E9,F63,F7,F82 --show-source --statistics || { + print_error "Critical flake8 errors found!" +} + +echo "" +echo "Checking code style (warnings only)..." +flake8 src --count --exit-zero --max-complexity=10 --max-line-length=120 --statistics + +echo "" + +# Step 2: Run tests with pytest and coverage (matches CI) +print_step "Step 2: Running tests with pytest and coverage" +echo "" +pytest tests/ -v --cov=src --cov-report=xml --cov-report=html --cov-report=term + +echo "" + +# Step 3: Generate coverage report (matches CI) +print_step "Step 3: Coverage Summary" +echo "" +coverage report + +echo "" + +# Step 4: Run integration tests if they exist (matches CI) +print_step "Step 4: Running integration tests" +echo "" +if [ -d "tests/integration" ]; then + pytest tests/integration/ -v +else + echo "No integration tests found (this is OK)" +fi + +echo "" + +# Step 5: Smoke tests - ensure main modules import (matches CI) +print_step "Step 5: Running smoke tests" +echo "" +python -c " +import sys +sys.path.insert(0, 'src') +try: + import stochastic_benchmark + import bootstrap + import plotting + import stats + import names + print('✓ All main modules import successfully') +except ImportError as e: + print(f'✗ Import error: {e}') + sys.exit(1) +" + +echo "" +echo -e "${GREEN}========================================${NC}" +echo -e "${GREEN}All CI Tests Passed! ✓${NC}" +echo -e "${GREEN}========================================${NC}" +echo "" +echo -e "Coverage reports generated:" +echo -e " - Terminal output (above)" +echo -e " - XML: ${BLUE}coverage.xml${NC}" +echo -e " - HTML: ${BLUE}htmlcov/index.html${NC}" +echo "" +echo -e "To view the HTML coverage report:" +echo -e " ${BLUE}firefox htmlcov/index.html${NC} # or your preferred browser" +echo "" diff --git a/setup-ci-env.sh b/setup-ci-env.sh new file mode 100755 index 00000000..0c2a1cd1 --- /dev/null +++ b/setup-ci-env.sh @@ -0,0 +1,84 @@ +#!/bin/bash +# Script to set up and test the stochastic-benchmark package locally +# This replicates the CI environment for local testing + +set -e # Exit on error + +# Colors for output +GREEN='\033[0;32m' +BLUE='\033[0;34m' +YELLOW='\033[1;33m' +RED='\033[0;31m' +NC='\033[0m' # No Color + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}Stochastic Benchmark CI Environment Setup${NC}" +echo -e "${BLUE}========================================${NC}" +echo "" + +# Function to print colored messages +print_step() { + echo -e "${GREEN}==>${NC} $1" +} + +print_warning() { + echo -e "${YELLOW}WARNING:${NC} $1" +} + +print_error() { + echo -e "${RED}ERROR:${NC} $1" +} + +# Check if conda is installed +if ! command -v conda &> /dev/null; then + print_error "conda is not installed. Please install Miniconda or Anaconda first." + exit 1 +fi + +# Get Python version from argument or use default +PYTHON_VERSION="${1:-3.10}" +ENV_NAME="stochastic-benchmark-ci-py${PYTHON_VERSION//./}" + +echo -e "Python version: ${BLUE}${PYTHON_VERSION}${NC}" +echo -e "Environment name: ${BLUE}${ENV_NAME}${NC}" +echo "" + +# Create conda environment +print_step "Creating conda environment: ${ENV_NAME}" +conda env create -f environment-ci.yml -n "${ENV_NAME}" python="${PYTHON_VERSION}" || { + print_warning "Environment already exists. Updating instead..." + conda env update -f environment-ci.yml -n "${ENV_NAME}" +} + +# Activate environment (note: this won't persist outside the script) +print_step "Activating environment" +eval "$(conda shell.bash hook)" +conda activate "${ENV_NAME}" + +# Verify Python version +ACTUAL_PYTHON=$(python --version) +print_step "Python version: ${ACTUAL_PYTHON}" + +# Install package in development mode +print_step "Installing package in development mode" +pip install -e . + +# Set PYTHONPATH (matches CI setup) +export PYTHONPATH="${PYTHONPATH}:${PWD}/src" +print_step "PYTHONPATH set to include src directory" + +echo "" +echo -e "${GREEN}========================================${NC}" +echo -e "${GREEN}Environment Setup Complete!${NC}" +echo -e "${GREEN}========================================${NC}" +echo "" +echo -e "To activate the environment, run:" +echo -e " ${BLUE}conda activate ${ENV_NAME}${NC}" +echo "" +echo -e "To run tests (like CI does), use:" +echo -e " ${BLUE}./run-ci-tests.sh${NC}" +echo "" +echo -e "Or run tests manually:" +echo -e " ${BLUE}export PYTHONPATH=\"\${PYTHONPATH}:\${PWD}/src\"${NC}" +echo -e " ${BLUE}pytest tests/ -v --cov=src --cov-report=xml --cov-report=html --cov-report=term${NC}" +echo "" diff --git a/src/bootstrap.py b/src/bootstrap.py index 86c1ed19..f3f889c4 100644 --- a/src/bootstrap.py +++ b/src/bootstrap.py @@ -9,7 +9,7 @@ import os import pandas as pd from tqdm import tqdm -from typing import Callable, List, DefaultDict +from typing import Callable, List, DefaultDict, Optional import names import success_metrics @@ -33,14 +33,30 @@ class BootstrapParameters: shared_args : dict Shared arguments for the bootstrap method. We usually have 'resource_col, response_col, response_dir, best_value, random_value, confidence_level' - update_rule : Callable[[pd.DataFrame], None] - Function to update the dataframe with the bootstrap results. - agg : str - Aggregation function to use for the bootstrap. + update_rule : Callable[[BootstrapParameters, pd.DataFrame], None], optional + Update rule function to modify shared_args and metric_args for each bootstrap group. + + This is an UNBOUND function pattern where you define a function with signature: + def update_rule(bs_params, df) + + When called, the first parameter receives the BootstrapParameters instance, + and the second receives the DataFrame. Inside the function, access attributes via + the first parameter (e.g., bs_params.shared_args, bs_params.metric_args). + + The function is stored and called as: bs_params.update_rule(bs_params, df) + + If None, uses default_update which sets best_value and RTT_factor. + + Example: + def custom_update(bs_params, df): + bs_params.shared_args['best_value'] = df['ground_truth'].iloc[0] + bs_params.metric_args['RTT']['RTT_factor'] = df['time'].iloc[0] + agg : Optional[str] + Aggregation column name to use for weighted sampling, or None for uniform sampling. metric_args : DefaultDict[str, dict] Dictionary of metric arguments to pass to the success_metrics functions. - success_metrics : dict - Dictionary of success_metrics functions to use. + success_metrics : List + List of success_metrics classes to use. bootstrap_iterations : int Number of bootstrap iterations to perform. downsample : int @@ -52,28 +68,31 @@ class BootstrapParameters: ------- __post_init__() Post-initialization function. - default_update(df) - Default update rule for the bootstrap method. + default_update(self, df) + Default update rule for the bootstrap method (bound method). + Sets best_value based on response direction and RTT_factor based on resource sum. + Note: This is a bound method, but when assigned to update_rule, it becomes + unbound and must be called as update_rule(bs_params, df). """ shared_args: dict #'resource_col, response_col, response_dir, best_value, random_value, confidence_level' - update_rule: Callable[[pd.DataFrame], None] = field() - agg: str = field(default_factory=lambda: None) + update_rule: Optional[Callable[['BootstrapParameters', pd.DataFrame], None]] = None + agg: Optional[str] = None metric_args: DefaultDict[str, dict] = field( - default_factory=lambda: defaultdict(lambda: None) + default_factory=lambda: defaultdict(dict) ) - success_metrics: dict = field(default_factory=lambda: [success_metrics.PerfRatio]) + success_metrics: List = field(default_factory=lambda: [success_metrics.PerfRatio]) bootstrap_iterations: int = 1000 downsample: int = 10 keep_cols: List = field(default_factory=lambda: []) def __post_init__(self): - temp_metric_args = defaultdict(lambda: None) + temp_metric_args = defaultdict(dict) temp_metric_args.update(self.metric_args) self.metric_args = temp_metric_args - if not hasattr(self, "update_rule"): - self.update_rule = self.default_update + if self.update_rule is None: + self.update_rule = BootstrapParameters.default_update def default_update(self, df): if self.shared_args["response_dir"] == -1: # Minimization @@ -266,16 +285,17 @@ def Bootstrap(df, group_on, bs_params_list, progress_dir=None): df_list : List[str] List of strings pointing to files with portions of bootstrapped_results """ - if type(df) == list: - if type(df)[0] == pd.DataFrame: + if isinstance(df, list): + if isinstance(df[0], pd.DataFrame): df = pd.concat(df, ignore_index=True) - elif type(df)[0] == str: + elif isinstance(df[0], str): df = pd.concat([pd.read_pickle(df_str) for df_str in df], ignore_index=True) - elif type(df) == str: + elif isinstance(df, str): df = pd.read_pickle(df) - if type(df) != pd.DataFrame: + if not isinstance(df, pd.DataFrame): logger.error("Unsupported type as bootstrap input") + raise TypeError(f"Expected DataFrame but got {type(df)}") def f(bs_params): if progress_dir is not None: @@ -324,14 +344,19 @@ def Bootstrap_reduce_mem(df, group_on, bs_params_list, bootstrap_dir, name_fcn=N DataFrame containing the bootstrap results. """ bs_params_list = list(bs_params_list) - - if (type(df) == pd.DataFrame) or (type(df) == str): - if type(df) == str: + + # Validate name_fcn early for all code paths that require it + # (All paths in Bootstrap_reduce_mem require name_fcn to generate group names) + if name_fcn is None: + raise ValueError("name_fcn is required for Bootstrap_reduce_mem operation") + + if isinstance(df, pd.DataFrame) or isinstance(df, str): + if isinstance(df, str): df = pd.read_pickle(df) lower_group_on = group_on[1] group_on = group_on[0] - def upper_f(df_upper_group, bs_params_list): + def upper_f_dataframe(df_upper_group, bs_params_list): group_name = name_fcn(df_upper_group[0]) df_group = df_upper_group[1] filename = os.path.join( @@ -365,12 +390,14 @@ def bs_params_eval(bs_params): res = pd.concat(df_list, ignore_index=True) res.to_pickle(filename) return filename + + upper_f = upper_f_dataframe - elif type(df) == list: - if type(df[0]) == str: + elif isinstance(df, list): + if isinstance(df[0], str): logger.debug("calling list of names method") - def upper_f(upper_group_filename, bs_params_list): + def upper_f_str_list(upper_group_filename, bs_params_list): df_group = pd.read_pickle(upper_group_filename) group_name = name_fcn(upper_group_filename) logger.info("evaluation bs for %s", group_name) @@ -406,10 +433,12 @@ def bs_params_eval(bs_params): res = pd.concat(df_list, ignore_index=True) res.to_pickle(filename) return filename + + upper_f = upper_f_str_list - elif type(df[0]) == pd.DataFrame: + elif isinstance(df[0], pd.DataFrame): - def upper_f(df_group, bs_params_list): + def upper_f_df_list(df_group, bs_params_list): group_name = name_fcn(df_group) filename = os.path.join( bootstrap_dir, "bootstrapped_results_{}.pkl".format(group_name) @@ -443,6 +472,12 @@ def bs_params_eval(bs_params): res = pd.concat(df_list, ignore_index=True) res.to_pickle(filename) return filename + + upper_f = upper_f_df_list + else: + raise TypeError(f"Unsupported type for df[0]: {type(df[0])}") + else: + raise TypeError(f"Unsupported type for df: {type(df)}") bs_filenames = [upper_f(df_group, bs_params_list) for df_group in df] return bs_filenames diff --git a/src/cross_validation.py b/src/cross_validation.py index f02f42f8..52e44909 100644 --- a/src/cross_validation.py +++ b/src/cross_validation.py @@ -169,7 +169,7 @@ def process_params_across_splits(parameter_names, confidence_level=68): expt_param_df = ( curr_param_df[["resource", param]] .groupby("resource") - .apply(lambda col: all_ci(col, param, confidence_level)) + .apply(lambda col: all_ci(col, param, confidence_level), include_groups=False) .reset_index() ) expt_param_df.drop("level_1", axis=1, inplace=True) @@ -204,7 +204,7 @@ def process_performance_across_splits( perf_df = ( curr_perf_df[["resource", "response"]] .groupby("resource") - .apply(lambda col: all_ci(col, "response")) + .apply(lambda col: all_ci(col, "response"), include_groups=False) .reset_index() ) perf_df.drop("level_1", axis=1, inplace=True) @@ -214,7 +214,7 @@ def process_performance_across_splits( perf_df = ( curr_perf_df.groupby("resource") - .apply(lambda df: propagate_ci(df, stats_measure)) + .apply(lambda df: propagate_ci(df, stats_measure), include_groups=False) .reset_index() ) perf_df.drop("level_1", axis=1, inplace=True) diff --git a/src/experiments.py b/src/experiments.py new file mode 100644 index 00000000..65f34b8d --- /dev/null +++ b/src/experiments.py @@ -0,0 +1,1138 @@ +from collections import namedtuple +import os +import pandas as pd +from typing import List, Callable +import warnings +import logging +from dataclasses import dataclass + +import df_utils +from plotting import * +import random_exploration +import sequential_exploration +import training +import stats + +logger = logging.getLogger(__name__) +import names + +median = False + +@dataclass(frozen=True) +class ExperimentParameters: + parameter_names: List[str] + instance_cols: List[str] + interp_results: pd.DataFrame + checkpoint_path: str + response_key: str + response_dir: int + smooth: bool + stat_params: stats.StatsParameters + training_stats: pd.DataFrame + testing_stats: pd.DataFrame + evaluate_without_bootstrap: Callable[[pd.DataFrame, List[str]], pd.DataFrame] + baseline_recalibrate: Callable[[pd.DataFrame], None] + + +class Experiment: + """ + Base class for experiments + + Attributes + ---------- + parent_params: ExperimentParameters + Parent stochastic_benchmark instance. This is a forward reference to the + stochastic_benchmark class defined later in this module. + name : str + Name of experiment + + Methods + ------- + __init__(parent_params, name) + Initializes experiment + evaluate() + Evaluates experiment + evaluate_monotone() + Monotonizes the response and parameters from evaluate + """ + + parent_params: ExperimentParameters + + def evaluate(self): + raise NotImplementedError( + "Evaluate should be overriden by a subclass of Experiment" + ) + + def evaluate_monotone(self): + """ + Monotonizes the response and parameters from evaluate + + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + res = self.evaluate() + params_df = None + eval_df = None + preproc_params = None + + if len(res) == 2: + params_df, eval_df = res + elif len(res) == 3: + params_df, eval_df, preproc_params = res + + if params_df is None or eval_df is None: + raise ValueError("evaluate() returned invalid result") + + joint = params_df.merge(eval_df, on="resource") + joint = df_utils.monotone_df(joint, "resource", "response", 1) + + params_df = joint.loc[:, ["resource"] + self.parent_params.parameter_names] + eval_df = joint.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + + if len(res) == 3 and preproc_params is not None: + return params_df, eval_df, preproc_params + else: + return params_df, eval_df + + +class ProjectionExperiment(Experiment): + """ + Holds information needed for projection experiments. + Used for evaluating performance of a recipe on the test set if the user cannot re-run experiments. + Recipes can be post-processed by a user-defined function (e.g., smoothed fit) and queried for running + evaluatation experiments. + + Attributes + ---------- + parent_params: ExperimentParameters + Parent experiment parameters + name : str + name for pretty printing + project_from : str + 'TrainingStats' or 'TrainingResults' + recipe : pd.DataFrame + Recommended parameters for each resource (can be postprocessed). This is not projected + rec_params : pd.DataFrame + Projected recommended parameters for each resource + rec_path : str + Path to recipe + postprocess : function + Function to postprocess recipe + postprocess_name : str + Name of postprocessing function + + Methods + ------- + __init__(parent_params, project_from, postprocess=None, postprocess_name=None) + Initializes projection experiment + set_rec_path() + Sets rec_path + get_TrainingStats_recipe() + Gets recipe from TrainingStats + get_TrainingResults_recipe() + Gets recipe from TrainingResults + evaluate() + Evaluates experiment + """ + + def __init__(self, parent_params, project_from, postprocess=None, postprocess_name=None): + self.parent_params = parent_params + self.name = "Projection from {}".format(project_from) + self.project_from = project_from + self.postprocess = postprocess + self.postprocess_name = postprocess_name + self.populate() + + def populate(self): + """ + Adds recipe depending on source. Currently only projection from the best recommended from the training stats or results are available. + Any addition recipe specifications should be implemented here + """ + # Set rec_path, i.e. the path where the recipe is/will be stored + self.set_rec_path() + + # Prepare the recipes + if self.project_from == "TrainingStats": + self.get_TrainingStats_recipe() + elif self.project_from == "TrainingResults": + self.get_TrainingResults_recipe() + else: + raise NotImplementedError( + "Projection from {} has not been implemented".format(self.project_from) + ) + + # Run the projections + if os.path.exists(self.rec_path): + self.rec_params = pd.read_pickle(self.rec_path) + else: + logger.info("Evaluating recommended parameters on testing results") + testing_results = self.parent_params.interp_results[ + self.parent_params.interp_results["train"] == 0 + ].copy() + self.rec_params = training.evaluate( + testing_results, + self.recipe, + training.scaled_distance, + parameter_names=self.parent_params.parameter_names, + group_on=self.parent_params.instance_cols, + ) + self.rec_params.to_pickle(self.rec_path) + + def get_TrainingResults_recipe(self): + """ + If TrainingResults recipe is already stored in a pkl file, load it. Otherwise, create and store it by obtaining the best parameters from training_stats (and post_processing, if requested) + """ + vb_train_path = os.path.join( + self.parent_params.checkpoint_path, "VirtualBest_train.pkl" + ) + + if os.path.exists(vb_train_path): + self.vb_train = pd.read_pickle(vb_train_path) + else: + response_col = names.param2filename({"Key": self.parent_params.response_key}, "") + training_results = self.parent_params.interp_results[ + self.parent_params.interp_results["train"] == 1 + ].copy() + self.vb_train = training.virtual_best( + training_results, + parameter_names=self.parent_params.parameter_names, + response_col=response_col, + response_dir=1, + groupby=self.parent_params.instance_cols, + resource_col="resource", + smooth=self.parent_params.smooth, + ) + self.vb_train.to_pickle(vb_train_path) + + self.recipe = training.best_recommended( + self.vb_train.copy(), + parameter_names=self.parent_params.parameter_names, + resource_col="resource", + additional_cols=["boots"], + ).reset_index() + + if self.postprocess is not None: + self.preproc_recipe = self.recipe.copy() + self.recipe = self.postprocess(self.recipe) + + def get_TrainingStats_recipe(self): + """ + If TrainingStats recipe is already stored in a pkl file, load it. Otherwise, create and store it by obtaining the best parameters from training_stats (and post_processing, if requested) + """ + + best_rec_train_path = os.path.join( + self.parent_params.checkpoint_path, "BestRecommended_train.pkl" + ) + if os.path.exists(best_rec_train_path): + # If the recipe was already stored in a pkl file, simply load it + self.recipe = pd.read_pickle(best_rec_train_path) + else: + # If not, create the recipe dataframe, and store it in a pkl file + # Get the name of the response column + response_col = names.param2filename( + { + "Key": self.parent_params.response_key, + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + + # Obtain the recipe, before the postprocessing step + self.recipe = training.best_parameters( + self.parent_params.training_stats.copy(), + parameter_names=self.parent_params.parameter_names, + response_col=response_col, + response_dir=1, + resource_col="resource", + additional_cols=["boots"], + smooth=self.parent_params.smooth, + ) + + self.recipe.to_pickle(best_rec_train_path) + + if self.postprocess is not None: + best_rec_train_path_post = os.path.join( + self.parent_params.checkpoint_path, + "BestRecommended_train_postprocess={}.pkl".format( + self.postprocess_name + ), + ) + # Copy the recipe to preproc_recipe before postprocessing + self.preproc_recipe = self.recipe.copy() + # Implement post-processing + self.recipe = self.postprocess(self.recipe) + self.recipe.to_pickle(best_rec_train_path_post) + + def evaluate(self, monotone=False): + """ + Evaluates the recommended parameters on the testing results, and returns the recommended parameters and the responses + + Parameters + ---------- + monotone : bool, optional + If True, the recommended parameters are evaluated on the monotone testing results, by default False + + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + # params_df = self.rec_params.loc[:, ['resource'] + self.parent.parameter_names].copy() + + # base = names.param2filename({'Key': self.parent_params.response_key}, '') + # CIlower = names.param2filename({'Key': self.parent_params.response_key, + # 'ConfInt':'lower'}, '') + # CIupper = names.param2filename({'Key': self.parent_params.response_key, + # 'ConfInt':'upper'}, '') + # eval_df = self.rec_params.copy() + # eval_df.rename(columns = { + # base :'response', + # CIlower :'response_lower', + # CIupper :'response_upper', + # }, inplace=True + # ) + + # joint = self.rec_params.copy() + # base = names.param2filename({'Key': self.parent_params.response_key}, '') + # CIlower = names.param2filename({'Key': self.parent_params.response_key, + # 'ConfInt':'lower'}, '') + # CIupper = names.param2filename({'Key': self.parent_params.response_key, + # 'ConfInt':'upper'}, '') + # joint.rename(columns = { + # base :'response', + # CIlower :'response_lower', + # CIupper :'response_upper', + # }, inplace=True + # ) + # joint = joint.loc[:, ['resource'] + self.parent.parameter_names + + # ['response', 'response_lower', 'response_upper'] + self.parent.instance_cols] + + # extrapolate_from = self.parent.interp_results.loc[self.parent.interp_results['train'] == 0].copy() + # extrapolate_from.rename(columns = { + # base :'response', + # CIlower :'response_lower', + # CIupper :'response_upper', + # }, inplace=True + # ) + + # def mono(df): + # # res = df_utils.monotone_df(joint, 'resource', 'response', 1, + # # extrapolate_from=extrapolate_from, match_on = self.parent.parameter_names + self.parent.instance_cols) + # res = df_utils.monotone_df(joint, 'resource', 'response', 1) + # return res + + # joint = joint.groupby(self.parent.instance_cols, include_groups=False).apply(mono) + + # params_df = joint.loc[:, ['resource'] + self.parent.parameter_names] + # eval_df = joint.loc[:, ['resource','response', 'response_lower', 'response_upper']] + # params_df = params_df.groupby('resource').mean() + # params_df.reset_index(inplace=True) + + # eval_df = eval_df.groupby('resource').median() + # eval_df = eval_df.groupby('resource').median() + # eval_df.reset_index(inplace=True) + + params_df = self.rec_params.loc[ + :, ["resource"] + self.parent_params.parameter_names + ].copy() + params_df = params_df.groupby("resource").mean() + params_df.reset_index(inplace=True) + + base = names.param2filename({"Key": self.parent_params.response_key}, "") + CIlower = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "lower"}, "" + ) + CIupper = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "upper"}, "" + ) + eval_df = self.rec_params.copy() + eval_df.rename( + columns={ + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + eval_df = eval_df.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + if median: + eval_df = eval_df.groupby("resource").median() + else: + eval_df = eval_df.groupby("resource").mean() + eval_df.reset_index(inplace=True) + return params_df, eval_df + + def evaluate_monotone(self): + """ + Monotonizes the response and parameters from evaluate + + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + params_df, eval_df = self.evaluate() + + joint = params_df.merge(eval_df, on="resource") + extrapolate_from = self.parent_params.testing_stats.copy() + base = names.param2filename( + { + "Key": self.parent_params.response_key, + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + CIlower = names.param2filename( + { + "Key": self.parent_params.response_key, + "ConfInt": "lower", + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + CIupper = names.param2filename( + { + "Key": self.parent_params.response_key, + "ConfInt": "upper", + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + extrapolate_from.rename( + columns={ + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + + # joint = df_utils.monotone_df(joint, 'resource', 'response', 1, + # extrapolate_from=extrapolate_from, match_on = self.parent.parameter_names) + joint = df_utils.monotone_df(joint, "resource", "response", 1) + params_df = joint.loc[:, ["resource"] + self.parent_params.parameter_names] + eval_df = joint.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + return params_df, eval_df + + def set_rec_path(self): + """ + Define the path where the recipe is to be stored + """ + if self.postprocess is not None: + self.rec_path = os.path.join( + self.parent_params.checkpoint_path, + "Projection_from={}_postprocess={}.pkl".format( + self.project_from, self.postprocess_name + ), + ) + else: + self.rec_path = os.path.join( + self.parent_params.checkpoint_path, + "Projection_from={}.pkl".format(self.project_from), + ) + + +class StaticRecommendationExperiment(Experiment): + """ + Holds parameters for fixed recommendation experiments + + Attributes + ---------- + parent_params: ExperimentParameters + Parent experiment parameters + name : str + name for pretty printing + rec_params : pd.DataFrame + Recommended parameters for evaluation + preproc_rec_params : pd.DataFrame + Recommended parameters before processing + + Methods + ------- + __init__(parent_params, init_from) + Initialize the class + list_runs() + Returns a list of experiments evaluate + evaluate() + Returns the recommended parameters and responses + evaluate_monotone() + Monotonizes the response and parameters from evaluate + set_rec_path() + Define the path where the recipe is to be stored + """ + + def __init__(self, parent_params, init_from): + self.parent_params = parent_params + self.name = "FixedRecommendation" + + if type(init_from) == ProjectionExperiment: + self.rec_params = init_from.recipe + if init_from.postprocess is not None: + self.preproc_rec_params = init_from.preproc_recipe.copy() + + elif type(init_from) == pd.DataFrame: + self.rec_params = init_from + else: + warn_str = ( + "init_from type is not supported. No recommended parameters are set." + ) + warnings.warn(warn_str) + + def list_runs(self): + """ + Returns a list of experiments evaluate. + + Returns + ------- + runs : list + List of named tuples of parameters + """ + parameter_names = "resource " + " ".join(self.parent_params.parameter_names) + Parameter = namedtuple("Parameter", parameter_names) + runs = [] + for _, row in self.rec_params.iterrows(): + runs.append( + Parameter( + row["resource"], *[row[k] for k in self.parent_params.parameter_names] + ) + ) + return runs + + def attach_runs(self, df, process=True): + """ + Attaches reruns of experiment to the experiment object + + Parameters + ---------- + df : pd.DataFrame or str + Dataframe of responses + process : bool + Whether to process the dataframe + + Returns + ------- + None + """ + if type(df) == str: + df = pd.read_pickle(df) + if process: + group_on = self.parent_params.instance_cols + ["resource"] + self.eval_df = self.parent_params.evaluate_without_bootstrap(df, group_on) + else: + self.eval_df = df + self.parent_params.baseline_recalibrate(self.eval_df) + + def evaluate(self): + """ + Evaluates the recommended parameters + + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + params_df = self.rec_params.loc[ + :, ["resource"] + self.parent_params.parameter_names + ].copy() + preproc_params = self.preproc_rec_params.loc[ + :, ["resource"] + self.parent_params.parameter_names + ].copy() + # params_df = params_df.groupby('resource').mean() + # params_df.reset_index(inplace=True) + + base = names.param2filename({"Key": self.parent_params.response_key}, "") + CIlower = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "lower"}, "" + ) + CIupper = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "upper"}, "" + ) + eval_df = self.eval_df.copy() + eval_df.rename( + columns={ + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + eval_df = eval_df.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + eval_df = eval_df.groupby("resource").mean() + eval_df.reset_index(inplace=True) + return params_df, eval_df, preproc_params + + +class RandomSearchExperiment(Experiment): + """ + Holds parameters needed for random search experiment + + Attributes + ---------- + parent_params: ExperimentParameters + Parent experiment parameters + name : str + name for pretty printing + meta_params : pd.DataFrame + Best metaparameters (Exploration budget and Tau) + eval_train : pd.DataFrame + Resulting parameters of meta_params on training set + eval_test : pd.DataFrame + Resulting parameters of meta_params on testing set + rsParams : dict + Dictionary of parameters for random search + postprocess : function + Function to postprocess the results + postprocess_name : str + Name of the postprocessing function + + Methods + ------- + __init__(parent, rsParams, postprocess=None, postprocess_name=None) + Initialize the class + populate() + Populates meta_params, eval_train, eval_test + """ + + def __init__(self, parent_params, rsParams, postprocess=None, postprocess_name=None): + self.parent_params = parent_params + self.name = "RandomSearch" + self.rsParams = rsParams + self.meta_parameter_names = ["ExploreFrac", "tau"] + self.resource = "TotalBudget" + self.postprocess = postprocess + self.postprocess_name = postprocess_name + self.populate() + + def populate(self): + """ + Populates meta_params, eval_train, eval_test + """ + meta_params_path = os.path.join( + self.parent_params.checkpoint_path, "RandomSearch_meta_params.pkl" + ) + eval_train_path = os.path.join( + self.parent_params.checkpoint_path, "RandomSearch_evalTrain.pkl" + ) + + if self.postprocess is None: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, "RandomSearch_evalTest.pkl" + ) + else: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, + "RandomSearch_evalTest_postprocess={}.pkl".format( + self.postprocess_name + ), + ) + + if os.path.exists(meta_params_path): + self.meta_params = pd.read_pickle(meta_params_path) + else: + self.meta_params, self.eval_train, _ = random_exploration.RandomExploration( + self.parent_params.training_stats, self.rsParams + ) + self.meta_params.to_pickle(meta_params_path) + self.eval_train.to_pickle(eval_train_path) + self.meta_params["ExploreFrac"] = ( + self.meta_params["ExplorationBudget"] / self.meta_params["TotalBudget"] + ) + + if self.postprocess is not None: + self.preproc_meta_params = self.meta_params.copy() + self.meta_params = self.postprocess(self.meta_params) + + if os.path.exists(eval_test_path): + self.eval_test = pd.read_pickle(eval_test_path) + else: + logger.info("\t Evaluating random search on test") + self.eval_test = random_exploration.apply_allocations( + self.parent_params.testing_stats.copy(), self.rsParams, self.meta_params + ) + self.eval_test.to_pickle(eval_test_path) + + def evaluate(self): + """ + Evaluates the random search + + Returns + ------- + params_df : pd.DataFrame + Dataframe of parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + params_df = self.eval_test.loc[:, ["TotalBudget"] + self.parent_params.parameter_names] + params_df = params_df.groupby("TotalBudget").mean() + params_df.reset_index(inplace=True) + params_df.rename(columns={"TotalBudget": "resource"}, inplace=True) + + base = names.param2filename( + { + "Key": self.parent_params.response_key, + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + CIlower = names.param2filename( + { + "Key": self.parent_params.response_key, + "ConfInt": "lower", + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + CIupper = names.param2filename( + { + "Key": self.parent_params.response_key, + "ConfInt": "upper", + "Metric": self.parent_params.stat_params.stats_measures[0].name, + }, + "", + ) + eval_df = self.eval_test.copy() + eval_df.drop("resource", axis=1, inplace=True) + eval_df.rename( + columns={ + "TotalBudget": "resource", + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + + eval_df = eval_df.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + if median: + eval_df = eval_df.groupby("resource").median() + else: + eval_df = eval_df.groupby("resource").mean() + eval_df.reset_index(inplace=True) + return params_df, eval_df + + +class SequentialSearchExperiment(Experiment): + """ + Holds parameters needed for sequential search experiment + + Attributes + ---------- + parent_params: ExperimentParameters + Parent experiment parameters + name : str + name for pretty printing + meta_params : pd.DataFrame + Best metaparameters (Exploration budget and Tau) + eval_train : pd.DataFrame4 + Resulting parameters of meta_params on training set + eval_test : pd.DataFrame + Resulting parameters of meta_params on testing set + ssParams : SequentialSearchParameters + Parameters for sequential search + id_name : str + Name of experiment + postprocess : function + Function to postprocess meta_params + postprocess_name : str + Name of postprocess function + + Methods + ------- + __init__(parent_params, ssParams, id_name=None, postprocess=None, postprocess_name=None) + Initialize the class + populate() + Populates meta_params, eval_train, eval_test + evaluate() + Evaluates the sequential search + """ + + def __init__( + self, parent_params, ssParams, id_name=None, postprocess=None, postprocess_name=None + ): + self.parent_params = parent_params + if id_name is None: + self.name = "SequentialSearch" + else: + self.name = "SequentialSearch_{}".format(id_name) + self.ssParams = ssParams + self.id_name = id_name + self.meta_parameter_names = ["ExploreFrac", "tau"] + self.resource = "TotalBudget" + self.postprocess = postprocess + self.postprocess_name = postprocess_name + self.populate() + + def populate(self): + if self.id_name is None: + meta_params_path = os.path.join( + self.parent_params.checkpoint_path, "SequentialSearch_meta_params.pkl" + ) + eval_train_path = os.path.join( + self.parent_params.checkpoint_path, "SequentialSearch_evalTrain.pkl" + ) + if self.postprocess is None: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, "SequentialSearch_evalTest.pkl" + ) + else: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, + "SequentialSearch_evalTest_postprocess={}.pkl".format( + self.postprocess_name + ), + ) + else: + meta_params_path = os.path.join( + self.parent_params.checkpoint_path, + "SequentialSearch_meta_params_id={}.pkl".format(self.id_name), + ) + eval_train_path = os.path.join( + self.parent_params.checkpoint_path, + "SequentialSearch_evalTrain_id={}.pkl".format(self.id_name), + ) + if self.postprocess is None: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, + "SequentialSearch_evalTest_id={}.pkl".format(self.id_name), + ) + else: + eval_test_path = os.path.join( + self.parent_params.checkpoint_path, + "SequentialSearch_evalTest_id={}_postprocess={}.pkl".format( + self.id_name, self.postprocess_name + ), + ) + + if os.path.exists(meta_params_path): + self.meta_params = pd.read_pickle(meta_params_path) + self.eval_train = pd.read_pickle(eval_train_path) + else: + training_results = self.parent_params.interp_results[ + self.parent_params.interp_results["train"] == 1 + ].copy() + ( + self.meta_params, + self.eval_train, + _, + ) = sequential_exploration.SequentialExploration( + training_results, self.ssParams, group_on=self.parent_params.instance_cols + ) + self.meta_params.to_pickle(meta_params_path) + self.eval_train.to_pickle(eval_train_path) + self.meta_params["ExploreFrac"] = ( + self.meta_params["ExplorationBudget"] / self.meta_params["TotalBudget"] + ) + if self.postprocess is not None: + self.preproc_meta_params = self.meta_params.copy() + self.meta_params = self.postprocess(self.meta_params) + if os.path.exists(eval_test_path): + self.eval_test = pd.read_pickle(eval_test_path) + else: + # try: + logger.info("\t Evaluating sequential search on test") + testing_results = self.parent_params.interp_results[ + self.parent_params.interp_results["train"] == 0 + ].copy() + self.eval_test = sequential_exploration.apply_allocations( + testing_results, + self.ssParams, + self.meta_params, + self.parent_params.instance_cols, + ) + self.eval_test.to_pickle(eval_test_path) + # except: + # print('Not enough test data for sequential search. Evaluating on train.') + + def evaluate(self): + """ + Evaluates the sequential search + + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + if hasattr(self, "eval_test"): + params_df = self.eval_test.loc[ + :, ["TotalBudget"] + self.parent_params.parameter_names + ] + eval_df = self.eval_test.copy() + else: + params_df = self.eval_train.loc[ + :, ["TotalBudget"] + self.parent_params.parameter_names + ] + eval_df = self.eval_train.copy() + + for col in params_df.columns: + if params_df[col].dtype == "object": + params_df.loc[:, col] = params_df.loc[:, col].astype(float) + + temp = params_df.groupby("TotalBudget").mean() + params_df.reset_index(inplace=True) + params_df.rename(columns={"TotalBudget": "resource"}, inplace=True) + base = names.param2filename({"Key": self.parent_params.response_key}, "") + CIlower = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "lower"}, "" + ) + CIupper = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "upper"}, "" + ) + + eval_df.drop("resource", axis=1, inplace=True) + eval_df.rename( + columns={ + "TotalBudget": "resource", + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + + eval_df = eval_df.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + if median: + eval_df = eval_df.groupby("resource").median() + else: + eval_df = eval_df.groupby("resource").mean() + eval_df.reset_index(inplace=True) + return params_df, eval_df + + +class VirtualBestBaseline: + """ + Calculates virtual best on an instance by instance basis + + Attributes + ---------- + parent_params: ExperimentParameters + Parent experiment parameters + name : str + name for pretty printing + rec_params : pd.DataFrame + Dataframe of best paremeters per instance and resource level + + Methods + ------- + savename() + Returns the path to save the results + populate() + Calculates the virtual best + evaluate() + Evaluates the virtual best + recalibrate() + Recalibrates the response of virtual best based on best found value + """ + + parent_params: ExperimentParameters + + def __init__(self, parent_params): + self.parent_params = parent_params + self.name = "VirtualBest" + self.populate() + + def savename(self): + return os.path.join(self.parent_params.checkpoint_path, "VirtualBest_test.pkl") + + def populate(self): + if os.path.exists(self.savename()): + self.rec_params = pd.read_pickle(self.savename()) + else: + response_col = names.param2filename({"Key": self.parent_params.response_key}, "") + testing_results = self.parent_params.interp_results[ + self.parent_params.interp_results["train"] == 0 + ].copy() + self.rec_params = training.virtual_best( + testing_results, + parameter_names=self.parent_params.parameter_names, + response_col=response_col, + response_dir=self.parent_params.response_dir, + groupby=self.parent_params.instance_cols, + resource_col="resource", + smooth=self.parent_params.smooth, + additional_cols=[ + "ConfInt=lower_" + response_col, + "ConfInt=upper_" + response_col, + ], + ) + self.rec_params.to_pickle(self.savename()) + + def recalibrate(self, new_df): + """ + Parameters + ---------- + new_df : pd.DataFrame + pandas dataframe with the new data. Should only have columns + ['resource'. *(parameters_names), response, response_lower, response_upper] + response cols should match name of results columns + Updates params and evaluation to take in new data + """ + base = names.param2filename({"Key": self.parent_params.response_key}, "") + joint_cols = ( + ["resource", base] + self.parent_params.parameter_names + self.parent_params.instance_cols + ) + new_df = new_df.loc[:, joint_cols] + joint = pd.concat( + [self.rec_params.loc[:, joint_cols], new_df], ignore_index=True + ) + + self.rec_params = training.virtual_best( + joint, + parameter_names=self.parent_params.parameter_names, + response_col=base, + response_dir=self.parent_params.response_dir, + groupby=self.parent_params.instance_cols, + resource_col="resource", + additional_cols=[], + smooth=self.parent_params.smooth, + ) + + def evaluate(self): + """ + Returns + ------- + params_df : pd.DataFrame + Dataframe of recommended parameters + eval_df : pd.DataFrame + Dataframe of responses, renamed to generic columns for compatibility + """ + params_df = self.rec_params.loc[:, ["resource"] + self.parent_params.parameter_names] + params_df = params_df.groupby("resource").mean() + + base = names.param2filename({"Key": self.parent_params.response_key}, "") + CIlower = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "lower"}, "" + ) + CIupper = names.param2filename( + {"Key": self.parent_params.response_key, "ConfInt": "upper"}, "" + ) + eval_df = self.rec_params.copy() + eval_df.rename( + columns={ + base: "response", + CIlower: "response_lower", + CIupper: "response_upper", + }, + inplace=True, + ) + + eval_df = eval_df.loc[ + :, ["resource", "response", "response_lower", "response_upper"] + ] + + def StatsSingle(df_single: pd.DataFrame, stat_params: stats.StatsParameters): + """ + Function for computing the stat (such as mean) and confidence intervals of the response + + Parameters + ---------- + df_single : pd.DataFrame + Dataframe of a single resource level + stat_params : stats.StatsParameters + Only one stats_measure will be used. + + Returns + ------- + pd.Dataframe + """ + df_dict = {} + sm = stat_params.stats_measures[0] # Ignore the rest if they exist + base, CIlower, CIupper = sm.ConfInts( + df_single["response"], + df_single["response_lower"], + df_single["response_upper"], + ) + + df_dict["response"] = [base] + df_dict["response_lower"] = [CIlower] + df_dict["response_upper"] = [CIupper] + df_dict["count"] = len(df_single["response"]) + + df_stats_single = pd.DataFrame.from_dict(df_dict) + return df_stats_single + + def applyBounds(df: pd.DataFrame, stat_params: stats.StatsParameters): + """ + Trim the response values obtained from statsSingle to be between 0 and 1 + + Parameters + ---------- + df : pd.DataFrame + Dataframe of a single resource level + stat_params : stats.StatsParameters + Only one stats_measure will be used. + """ + df_copy = df.loc[:, ("response_lower")].copy() + df_copy.clip(lower=0.0, inplace=True) + df.loc[:, ("response_lower")] = df_copy + + df_copy = df.loc[:, ("response_upper")].copy() + df_copy.clip(upper=1.0, inplace=True) + df.loc[:, ("response_upper")] = df_copy + return + + def Stats( + df: pd.DataFrame, stats_params: stats.StatsParameters, group_on=["resource"] + ): + """ + Compute a stat(eg. mean) of the response along with CIs for it, for each value of resource for the virtual best + + Parameters + ---------- + df : pd.DataFrame + Dataframe of a single resource level with columns 'resource', 'response', 'response_lower' and 'response_upper' + stats_params : stats.StatsParameters + Only one statsMeasure will be used. + group_on : list[str] + Confidence interval propagation will be done for all rows of dataframe having the same values for groupon + + Returns + ------- + pd.DataFrame + Dataframe with columns 'resource', 'response', 'response_lower' and 'response_upper' + """ + + def dfSS(df): + return StatsSingle(df, stats_params) + + df_stats = df.groupby(group_on).progress_apply(dfSS, include_groups=False).reset_index() + df_stats.drop("level_{}".format(len(group_on)), axis=1, inplace=True) + applyBounds(df_stats, stats_params) + + return df_stats + + if median: + stParams = stats.StatsParameters( + metrics=["response"], stats_measures=[stats.Median()] + ) + eval_df = Stats(eval_df, stParams, ["resource"]) + else: + stParams = stats.StatsParameters( + metrics=["response"], stats_measures=[stats.Mean()] + ) + eval_df = Stats(eval_df, stParams, ["resource"]) + eval_df.reset_index(inplace=True) + return params_df, eval_df diff --git a/src/sequential_exploration.py b/src/sequential_exploration.py index 535e3f2a..d8d266ec 100644 --- a/src/sequential_exploration.py +++ b/src/sequential_exploration.py @@ -345,25 +345,9 @@ def fcn(df): if len(df_experiment) >= 1: final_values.append(df_experiment) - # res_list = [] - # for name, group in df_stats.groupby(group_on): - # # print(name) - # res = fcn(group) - # if res is not None: - # res_list.append(res.iloc[[-1]]) - # # try: - # # res_list.append(res.iloc[-1]) - # # except: - # # print(name) - # # print(res) - # # print(len(res_list)) - # if len(res_list) >= 1: - # df_experiment = pd.concat(res_list, ignore_index=True) - # final_values.append(df_experiment) - # else: - # print('no res list') - - # df_experiment = df_stats.groupby(group_on, include_groups=False).apply(lambda df: SequentialExplorationSingle(df, ssParams, 0, budget, explore_frac, tau).iloc[[-1]]) + # Note: Previous sequential implementation (manual iteration with res_list) + # was replaced with applyParallel for better performance and cleaner error handling. + # See git history for the sequential loop pattern if needed for debugging. return pd.concat(final_values, ignore_index=True) diff --git a/src/stochastic_benchmark.py b/src/stochastic_benchmark.py index e175fa51..78dbc7dc 100644 --- a/src/stochastic_benchmark.py +++ b/src/stochastic_benchmark.py @@ -1,36 +1,34 @@ -from collections import namedtuple -import copy +from collections import defaultdict import glob -from math import floor -import matplotlib as mpl -import matplotlib.pyplot as plt -import matplotlib.patches as mpatches import numpy as np import os import pandas as pd -from random import choice -import seaborn.objects as so -import seaborn as sns +from typing import Optional, Union, List import warnings import logging - import bootstrap import df_utils import interpolate from plotting import * -import random_exploration -import sequential_exploration import stats import success_metrics import training logger = logging.getLogger(__name__) import names -import utils_ws median = False +from experiments import ( + RandomSearchExperiment, + ProjectionExperiment, + StaticRecommendationExperiment, + SequentialSearchExperiment, + VirtualBestBaseline, + ExperimentParameters +) + def default_bootstrap( nboots=1000, @@ -62,7 +60,7 @@ def default_bootstrap( "random_value": 0.0, } - metric_args = {} + metric_args = defaultdict(dict) metric_args["Response"] = {"opt_sense": -1} metric_args["SuccessProb"] = {"gap": 1.0, "response_dir": -1} metric_args["RTT"] = { @@ -79,7 +77,11 @@ def default_bootstrap( success_metrics.Resource, success_metrics.RTT, ] - bsParams = bootstrap.BootstrapParameters(shared_args, metric_args, sms) + bsParams = bootstrap.BootstrapParameters( + shared_args=shared_args, + metric_args=metric_args, + success_metrics=sms + ) bs_iter_class = bootstrap.BSParams_iter() bsparams_iter = bs_iter_class(bsParams, nboots) @@ -103,1092 +105,6 @@ def sweep_boots_resource(df): return df["sweep"] * df["boots"] -class Experiment: - """ - Base class for experiments - - Attributes - ---------- - parent : Experiment - Parent experiment - name : str - Name of experiment - - Methods - ------- - __init__(parent, name) - Initializes experiment - evaluate() - Evaluates experiment - evaluate_monotone() - Monotonizes the response and parameters from evaluate - """ - - def __init__(self): - return - - def evaluate(self): - raise NotImplementedError( - "Evaluate should be overriden by a subclass of Experiment" - ) - - def evaluate_monotone(self): - """ - Monotonizes the response and parameters from evaluate - - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - res = self.evaluate() - if len(res) == 2: - params_df, eval_df = res - elif len(res) == 3: - params_df, eval_df, preproc_params = res - joint = params_df.merge(eval_df, on="resource") - joint = df_utils.monotone_df(joint, "resource", "response", 1) - params_df = joint.loc[:, ["resource"] + self.parent.parameter_names] - eval_df = joint.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - - if len(res) == 2: - return params_df, eval_df - elif len(res) == 3: - return params_df, eval_df, preproc_params - - -class ProjectionExperiment(Experiment): - """ - Holds information needed for projection experiments. - Used for evaluating performance of a recipe on the test set if the user cannot re-run experiments. - Recipes can be post-processed by a user-defined function (e.g., smoothed fit) and queried for running - evaluatation experiments. - - Attributes - ---------- - parent : stochatic_benchmark - name : str - name for pretty printing - project_from : str - 'TrainingStats' or 'TrainingResults' - recipe : pd.DataFrame - Recommended parameters for each resource (can be postprocessed). This is not projected - rec_params : pd.DataFrame - Projected recommended parameters for each resource - rec_path : str - Path to recipe - postprocess : function - Function to postprocess recipe - postprocess_name : str - Name of postprocessing function - - Methods - ------- - __init__(parent, project_from, postprocess=None, postprocess_name=None) - Initializes projection experiment - set_rec_path() - Sets rec_path - get_TrainingStats_recipe() - Gets recipe from TrainingStats - get_TrainingResults_recipe() - Gets recipe from TrainingResults - evaluate() - Evaluates experiment - """ - - def __init__(self, parent, project_from, postprocess=None, postprocess_name=None): - self.parent = parent - self.name = "Projection from {}".format(project_from) - self.project_from = project_from - self.postprocess = postprocess - self.postprocess_name = postprocess_name - self.populate() - - def populate(self): - """ - Adds recipe depending on source. Currently only projection from the best recommended from the training stats or results are available. - Any addition recipe specifications should be implemented here - """ - # Set rec_path, i.e. the path where the recipe is/will be stored - self.set_rec_path() - - # Prepare the recipes - if self.project_from == "TrainingStats": - self.get_TrainingStats_recipe() - elif self.project_from == "TrainingResults": - self.get_TrainingResults_recipe() - else: - raise NotImplementedError( - "Projection from {} has not been implemented".format(self.project_from) - ) - - # Run the projections - if os.path.exists(self.rec_path): - self.rec_params = pd.read_pickle(self.rec_path) - else: - logger.info("Evaluating recommended parameters on testing results") - testing_results = self.parent.interp_results[ - self.parent.interp_results["train"] == 0 - ].copy() - self.rec_params = training.evaluate( - testing_results, - self.recipe, - training.scaled_distance, - parameter_names=self.parent.parameter_names, - group_on=self.parent.instance_cols, - ) - self.rec_params.to_pickle(self.rec_path) - - def get_TrainingResults_recipe(self): - """ - If TrainingResults recipe is already stored in a pkl file, load it. Otherwise, create and store it by obtaining the best parameters from training_stats (and post_processing, if requested) - """ - vb_train_path = os.path.join( - self.parent.here.checkpoints, "VirtualBest_train.pkl" - ) - - if os.path.exists(vb_train_path): - self.vb_train = pd.read_pickle(vb_train_path) - else: - response_col = names.param2filename({"Key": self.parent.response_key}, "") - training_results = self.parent.interp_results[ - self.parent.interp_results["train"] == 1 - ].copy() - self.vb_train = training.virtual_best( - training_results, - parameter_names=self.parent.parameter_names, - response_col=response_col, - response_dir=1, - groupby=self.parent.instance_cols, - resource_col="resource", - smooth=self.parent.smooth, - ) - self.vb_train.to_pickle(vb_train_path) - - self.recipe = training.best_recommended( - self.vb_train.copy(), - parameter_names=self.parent.parameter_names, - resource_col="resource", - additional_cols=["boots"], - ).reset_index() - - if self.postprocess is not None: - self.preproc_recipe = self.recipe.copy() - self.recipe = self.postprocess(self.recipe) - - def get_TrainingStats_recipe(self): - """ - If TrainingStats recipe is already stored in a pkl file, load it. Otherwise, create and store it by obtaining the best parameters from training_stats (and post_processing, if requested) - """ - - best_rec_train_path = os.path.join( - self.parent.here.checkpoints, "BestRecommended_train.pkl" - ) - if os.path.exists(best_rec_train_path): - # If the recipe was already stored in a pkl file, simply load it - self.recipe = pd.read_pickle(best_rec_train_path) - else: - # If not, create the recipe dataframe, and store it in a pkl file - # Get the name of the response column - response_col = names.param2filename( - { - "Key": self.parent.response_key, - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - - # Obtain the recipe, before the postprocessing step - self.recipe = training.best_parameters( - self.parent.training_stats.copy(), - parameter_names=self.parent.parameter_names, - response_col=response_col, - response_dir=1, - resource_col="resource", - additional_cols=["boots"], - smooth=self.parent.smooth, - ) - - self.recipe.to_pickle(best_rec_train_path) - - if self.postprocess is not None: - best_rec_train_path_post = os.path.join( - self.parent.here.checkpoints, - "BestRecommended_train_postprocess={}.pkl".format( - self.postprocess_name - ), - ) - # Copy the recipe to preproc_recipe before postprocessing - self.preproc_recipe = self.recipe.copy() - # Implement post-processing - self.recipe = self.postprocess(self.recipe) - self.recipe.to_pickle(best_rec_train_path_post) - - def evaluate(self, monotone=False): - """ - Evaluates the recommended parameters on the testing results, and returns the recommended parameters and the responses - - Parameters - ---------- - monotone : bool, optional - If True, the recommended parameters are evaluated on the monotone testing results, by default False - - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - # params_df = self.rec_params.loc[:, ['resource'] + self.parent.parameter_names].copy() - - # base = names.param2filename({'Key': self.parent.response_key}, '') - # CIlower = names.param2filename({'Key': self.parent.response_key, - # 'ConfInt':'lower'}, '') - # CIupper = names.param2filename({'Key': self.parent.response_key, - # 'ConfInt':'upper'}, '') - # eval_df = self.rec_params.copy() - # eval_df.rename(columns = { - # base :'response', - # CIlower :'response_lower', - # CIupper :'response_upper', - # }, inplace=True - # ) - - # joint = self.rec_params.copy() - # base = names.param2filename({'Key': self.parent.response_key}, '') - # CIlower = names.param2filename({'Key': self.parent.response_key, - # 'ConfInt':'lower'}, '') - # CIupper = names.param2filename({'Key': self.parent.response_key, - # 'ConfInt':'upper'}, '') - # joint.rename(columns = { - # base :'response', - # CIlower :'response_lower', - # CIupper :'response_upper', - # }, inplace=True - # ) - # joint = joint.loc[:, ['resource'] + self.parent.parameter_names + - # ['response', 'response_lower', 'response_upper'] + self.parent.instance_cols] - - # extrapolate_from = self.parent.interp_results.loc[self.parent.interp_results['train'] == 0].copy() - # extrapolate_from.rename(columns = { - # base :'response', - # CIlower :'response_lower', - # CIupper :'response_upper', - # }, inplace=True - # ) - - # def mono(df): - # # res = df_utils.monotone_df(joint, 'resource', 'response', 1, - # # extrapolate_from=extrapolate_from, match_on = self.parent.parameter_names + self.parent.instance_cols) - # res = df_utils.monotone_df(joint, 'resource', 'response', 1) - # return res - - # joint = joint.groupby(self.parent.instance_cols, include_groups=False).apply(mono) - - # params_df = joint.loc[:, ['resource'] + self.parent.parameter_names] - # eval_df = joint.loc[:, ['resource','response', 'response_lower', 'response_upper']] - # params_df = params_df.groupby('resource').mean() - # params_df.reset_index(inplace=True) - - # eval_df = eval_df.groupby('resource').median() - # eval_df = eval_df.groupby('resource').median() - # eval_df.reset_index(inplace=True) - - params_df = self.rec_params.loc[ - :, ["resource"] + self.parent.parameter_names - ].copy() - params_df = params_df.groupby("resource").mean() - params_df.reset_index(inplace=True) - - base = names.param2filename({"Key": self.parent.response_key}, "") - CIlower = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "lower"}, "" - ) - CIupper = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "upper"}, "" - ) - eval_df = self.rec_params.copy() - eval_df.rename( - columns={ - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - eval_df = eval_df.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - if median: - eval_df = eval_df.groupby("resource").median() - else: - eval_df = eval_df.groupby("resource").mean() - eval_df.reset_index(inplace=True) - return params_df, eval_df - - def evaluate_monotone(self): - """ - Monotonizes the response and parameters from evaluate - - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - params_df, eval_df = self.evaluate() - - joint = params_df.merge(eval_df, on="resource") - extrapolate_from = self.parent.testing_stats.copy() - base = names.param2filename( - { - "Key": self.parent.response_key, - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - CIlower = names.param2filename( - { - "Key": self.parent.response_key, - "ConfInt": "lower", - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - CIupper = names.param2filename( - { - "Key": self.parent.response_key, - "ConfInt": "upper", - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - extrapolate_from.rename( - columns={ - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - - # joint = df_utils.monotone_df(joint, 'resource', 'response', 1, - # extrapolate_from=extrapolate_from, match_on = self.parent.parameter_names) - joint = df_utils.monotone_df(joint, "resource", "response", 1) - params_df = joint.loc[:, ["resource"] + self.parent.parameter_names] - eval_df = joint.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - return params_df, eval_df - - def set_rec_path(self): - """ - Define the path where the recipe is to be stored - """ - if self.postprocess is not None: - self.rec_path = os.path.join( - self.parent.here.checkpoints, - "Projection_from={}_postprocess={}.pkl".format( - self.project_from, self.postprocess_name - ), - ) - else: - self.rec_path = os.path.join( - self.parent.here.checkpoints, - "Projection_from={}.pkl".format(self.project_from), - ) - - -class StaticRecommendationExperiment(Experiment): - """ - Holds parameters for fixed recommendation experiments - - Attributes - ---------- - parent : stochastic_benchmark - name : str - name for pretty printing - rec_params : pd.DataFrame - Recommended parameters for evaluation - preproc_rec_params : pd.DataFrame - Recommended parameters before processing - - Methods - ------- - __init__(parent, init_from) - Initialize the class - list_runs() - Returns a list of experiments evaluate - evaluate() - Returns the recommended parameters and responses - evaluate_monotone() - Monotonizes the response and parameters from evaluate - set_rec_path() - Define the path where the recipe is to be stored - """ - - def __init__(self, parent, init_from): - self.parent = parent - self.name = "FixedRecommendation" - - if type(init_from) == ProjectionExperiment: - self.rec_params = init_from.recipe - if init_from.postprocess is not None: - self.preproc_rec_params = init_from.preproc_recipe.copy() - - elif type(init_from) == pd.DataFrame: - self.rec_params = init_from - else: - warn_str = ( - "init_from type is not supported. No recommended parameters are set." - ) - warnings.warn(warn_str) - - def list_runs(self): - """ - Returns a list of experiments evaluate. - - Returns - ------- - runs : list - List of named tuples of parameters - """ - parameter_names = "resource " + " ".join(self.parent.parameter_names) - Parameter = namedtuple("Parameter", parameter_names) - runs = [] - for _, row in self.rec_params.iterrows(): - runs.append( - Parameter( - row["resource"], *[row[k] for k in self.parent.parameter_names] - ) - ) - return runs - - def attach_runs(self, df, process=True): - """ - Attaches reruns of experiment to the experiment object - - Parameters - ---------- - df : pd.DataFrame or str - Dataframe of responses - process : bool - Whether to process the dataframe - - Returns - ------- - None - """ - if type(df) == str: - df = pd.read_pickle(df) - if process: - group_on = self.parent.instance_cols + ["resource"] - self.eval_df = self.parent.evaluate_without_bootstrap(df, group_on) - else: - self.eval_df = df - self.parent.baseline.recalibrate(self.eval_df) - - def evaluate(self): - """ - Evaluates the recommended parameters - - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - params_df = self.rec_params.loc[ - :, ["resource"] + self.parent.parameter_names - ].copy() - preproc_params = self.preproc_rec_params.loc[ - :, ["resource"] + self.parent.parameter_names - ].copy() - # params_df = params_df.groupby('resource').mean() - # params_df.reset_index(inplace=True) - - base = names.param2filename({"Key": self.parent.response_key}, "") - CIlower = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "lower"}, "" - ) - CIupper = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "upper"}, "" - ) - eval_df = self.eval_df.copy() - eval_df.rename( - columns={ - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - eval_df = eval_df.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - eval_df = eval_df.groupby("resource").mean() - eval_df.reset_index(inplace=True) - return params_df, eval_df, preproc_params - - -class RandomSearchExperiment(Experiment): - """ - Holds parameters needed for random search experiment - - Attributes - ---------- - parent : stochatic_benchmark - name : str - name for pretty printing - meta_params : pd.DataFrame - Best metaparameters (Exploration budget and Tau) - eval_train : pd.DataFrame - Resulting parameters of meta_params on training set - eval_test : pd.DataFrame - Resulting parameters of meta_params on testing set - rsParams : dict - Dictionary of parameters for random search - postprocess : function - Function to postprocess the results - postprocess_name : str - Name of the postprocessing function - - Methods - ------- - __init__(parent, rsParams, postprocess=None, postprocess_name=None) - Initialize the class - populate() - Populates meta_params, eval_train, eval_test - """ - - def __init__(self, parent, rsParams, postprocess=None, postprocess_name=None): - self.parent = parent - self.name = "RandomSearch" - self.rsParams = rsParams - self.meta_parameter_names = ["ExploreFrac", "tau"] - self.resource = "TotalBudget" - self.postprocess = postprocess - self.postprocess_name = postprocess_name - self.populate() - - def populate(self): - """ - Populates meta_params, eval_train, eval_test - """ - meta_params_path = os.path.join( - self.parent.here.checkpoints, "RandomSearch_meta_params.pkl" - ) - eval_train_path = os.path.join( - self.parent.here.checkpoints, "RandomSearch_evalTrain.pkl" - ) - - if self.postprocess is None: - eval_test_path = os.path.join( - self.parent.here.checkpoints, "RandomSearch_evalTest.pkl" - ) - else: - eval_test_path = os.path.join( - self.parent.here.checkpoints, - "RandomSearch_evalTest_postprocess={}.pkl".format( - self.postprocess_name - ), - ) - - if os.path.exists(meta_params_path): - self.meta_params = pd.read_pickle(meta_params_path) - else: - self.meta_params, self.eval_train, _ = random_exploration.RandomExploration( - self.parent.training_stats, self.rsParams - ) - self.meta_params.to_pickle(meta_params_path) - self.eval_train.to_pickle(eval_train_path) - self.meta_params["ExploreFrac"] = ( - self.meta_params["ExplorationBudget"] / self.meta_params["TotalBudget"] - ) - - if self.postprocess is not None: - self.preproc_meta_params = self.meta_params.copy() - self.meta_params = self.postprocess(self.meta_params) - - if os.path.exists(eval_test_path): - self.eval_test = pd.read_pickle(eval_test_path) - else: - logger.info("\t Evaluating random search on test") - self.eval_test = random_exploration.apply_allocations( - self.parent.testing_stats.copy(), self.rsParams, self.meta_params - ) - self.eval_test.to_pickle(eval_test_path) - - def evaluate(self): - """ - Evaluates the random search - - Returns - ------- - params_df : pd.DataFrame - Dataframe of parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - params_df = self.eval_test.loc[:, ["TotalBudget"] + self.parent.parameter_names] - params_df = params_df.groupby("TotalBudget").mean() - params_df.reset_index(inplace=True) - params_df.rename(columns={"TotalBudget": "resource"}, inplace=True) - - base = names.param2filename( - { - "Key": self.parent.response_key, - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - CIlower = names.param2filename( - { - "Key": self.parent.response_key, - "ConfInt": "lower", - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - CIupper = names.param2filename( - { - "Key": self.parent.response_key, - "ConfInt": "upper", - "Metric": self.parent.stat_params.stats_measures[0].name, - }, - "", - ) - eval_df = self.eval_test.copy() - eval_df.drop("resource", axis=1, inplace=True) - eval_df.rename( - columns={ - "TotalBudget": "resource", - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - - eval_df = eval_df.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - if median: - eval_df = eval_df.groupby("resource").median() - else: - eval_df = eval_df.groupby("resource").mean() - eval_df.reset_index(inplace=True) - return params_df, eval_df - - -class SequentialSearchExperiment(Experiment): - """ - Holds parameters needed for sequential search experiment - - Attributes - ---------- - parent : stochatic_benchmark - name : str - name for pretty printing - meta_params : pd.DataFrame - Best metaparameters (Exploration budget and Tau) - eval_train : pd.DataFrame4 - Resulting parameters of meta_params on training set - eval_test : pd.DataFrame - Resulting parameters of meta_params on testing set - ssParams : SequentialSearchParameters - Parameters for sequential search - id_name : str - Name of experiment - postprocess : function - Function to postprocess meta_params - postprocess_name : str - Name of postprocess function - - Methods - ------- - populate() - Populates meta_params, eval_train, eval_test - evaluate() - Evaluates the sequential search - """ - - def __init__( - self, parent, ssParams, id_name=None, postprocess=None, postprocess_name=None - ): - self.parent = parent - if id_name is None: - self.name = "SequentialSearch" - else: - self.name = "SequentialSearch_{}".format(id_name) - self.ssParams = ssParams - self.id_name = id_name - self.meta_parameter_names = ["ExploreFrac", "tau"] - self.resource = "TotalBudget" - self.postprocess = postprocess - self.postprocess_name = postprocess_name - self.populate() - - def populate(self): - if self.id_name is None: - meta_params_path = os.path.join( - self.parent.here.checkpoints, "SequentialSearch_meta_params.pkl" - ) - eval_train_path = os.path.join( - self.parent.here.checkpoints, "SequentialSearch_evalTrain.pkl" - ) - if self.postprocess is None: - eval_test_path = os.path.join( - self.parent.here.checkpoints, "SequentialSearch_evalTest.pkl" - ) - else: - eval_test_path = os.path.join( - self.parent.here.checkpoints, - "SequentialSearch_evalTest_postprocess={}.pkl".format( - self.postprocess_name - ), - ) - else: - meta_params_path = os.path.join( - self.parent.here.checkpoints, - "SequentialSearch_meta_params_id={}.pkl".format(self.id_name), - ) - eval_train_path = os.path.join( - self.parent.here.checkpoints, - "SequentialSearch_evalTrain_id={}.pkl".format(self.id_name), - ) - if self.postprocess is None: - eval_test_path = os.path.join( - self.parent.here.checkpoints, - "SequentialSearch_evalTest_id={}.pkl".format(self.id_name), - ) - else: - eval_test_path = os.path.join( - self.parent.here.checkpoints, - "SequentialSearch_evalTest_id={}_postprocess={}.pkl".format( - self.id_name, self.postprocess_name - ), - ) - - if os.path.exists(meta_params_path): - self.meta_params = pd.read_pickle(meta_params_path) - self.eval_train = pd.read_pickle(eval_train_path) - else: - training_results = self.parent.interp_results[ - self.parent.interp_results["train"] == 1 - ].copy() - ( - self.meta_params, - self.eval_train, - _, - ) = sequential_exploration.SequentialExploration( - training_results, self.ssParams, group_on=self.parent.instance_cols - ) - self.meta_params.to_pickle(meta_params_path) - self.eval_train.to_pickle(eval_train_path) - self.meta_params["ExploreFrac"] = ( - self.meta_params["ExplorationBudget"] / self.meta_params["TotalBudget"] - ) - if self.postprocess is not None: - self.preproc_meta_params = self.meta_params.copy() - self.meta_params = self.postprocess(self.meta_params) - if os.path.exists(eval_test_path): - self.eval_test = pd.read_pickle(eval_test_path) - else: - # try: - logger.info("\t Evaluating sequential search on test") - testing_results = self.parent.interp_results[ - self.parent.interp_results["train"] == 0 - ].copy() - self.eval_test = sequential_exploration.apply_allocations( - testing_results, - self.ssParams, - self.meta_params, - self.parent.instance_cols, - ) - self.eval_test.to_pickle(eval_test_path) - # except: - # print('Not enough test data for sequential search. Evaluating on train.') - - def evaluate(self): - """ - Evaluates the sequential search - - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - if hasattr(self, "eval_test"): - params_df = self.eval_test.loc[ - :, ["TotalBudget"] + self.parent.parameter_names - ] - eval_df = self.eval_test.copy() - else: - params_df = self.eval_train.loc[ - :, ["TotalBudget"] + self.parent.parameter_names - ] - eval_df = self.eval_train.copy() - - for col in params_df.columns: - if params_df[col].dtype == "object": - params_df.loc[:, col] = params_df.loc[:, col].astype(float) - - temp = params_df.groupby("TotalBudget").mean() - params_df.reset_index(inplace=True) - params_df.rename(columns={"TotalBudget": "resource"}, inplace=True) - base = names.param2filename({"Key": self.parent.response_key}, "") - CIlower = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "lower"}, "" - ) - CIupper = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "upper"}, "" - ) - - eval_df.drop("resource", axis=1, inplace=True) - eval_df.rename( - columns={ - "TotalBudget": "resource", - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - - eval_df = eval_df.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - if median: - eval_df = eval_df.groupby("resource").median() - else: - eval_df = eval_df.groupby("resource").mean() - eval_df.reset_index(inplace=True) - return params_df, eval_df - - -class VirtualBestBaseline: - """ - Calculates virtual best on an instance by instance basis - - Attributes - ---------- - parent : stochatic_benchmark - name : str - name for pretty printing - rec_params : pd.DataFrame - Dataframe of best paremeters per instance and resource level - - Methods - ------- - savename() - Returns the path to save the results - populate() - Calculates the virtual best - evaluate() - Evaluates the virtual best - recalibrate() - Recalibrates the response of virtual best based on best found value - """ - - def __init__(self, parent): - self.parent = parent - self.name = "VirtualBest" - self.populate() - - def savename(self): - return os.path.join(self.parent.here.checkpoints, "VirtualBest_test.pkl") - - def populate(self): - if os.path.exists(self.savename()): - self.rec_params = pd.read_pickle(self.savename()) - else: - response_col = names.param2filename({"Key": self.parent.response_key}, "") - testing_results = self.parent.interp_results[ - self.parent.interp_results["train"] == 0 - ].copy() - self.rec_params = training.virtual_best( - testing_results, - parameter_names=self.parent.parameter_names, - response_col=response_col, - response_dir=self.parent.response_dir, - groupby=self.parent.instance_cols, - resource_col="resource", - smooth=self.parent.smooth, - additional_cols=[ - "ConfInt=lower_" + response_col, - "ConfInt=upper_" + response_col, - ], - ) - self.rec_params.to_pickle(self.savename()) - - def recalibrate(self, new_df): - """ - Parameters - ---------- - new_df : pd.DataFrame - pandas dataframe with the new data. Should only have columns - ['resource'. *(parameters_names), response, response_lower, response_upper] - response cols should match name of results columns - Updates params and evaluation to take in new data - """ - base = names.param2filename({"Key": self.parent.response_key}, "") - joint_cols = ( - ["resource", base] + self.parent.parameter_names + self.parent.instance_cols - ) - new_df = new_df.loc[:, joint_cols] - joint = pd.concat( - [self.rec_params.loc[:, joint_cols], new_df], ignore_index=True - ) - - self.rec_params = training.virtual_best( - joint, - parameter_names=self.parent.parameter_names, - response_col=base, - response_dir=self.parent.response_dir, - groupby=self.parent.instance_cols, - resource_col="resource", - additional_cols=[], - smooth=self.parent.smooth, - ) - - def evaluate(self): - """ - Returns - ------- - params_df : pd.DataFrame - Dataframe of recommended parameters - eval_df : pd.DataFrame - Dataframe of responses, renamed to generic columns for compatibility - """ - params_df = self.rec_params.loc[:, ["resource"] + self.parent.parameter_names] - params_df = params_df.groupby("resource").mean() - - base = names.param2filename({"Key": self.parent.response_key}, "") - CIlower = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "lower"}, "" - ) - CIupper = names.param2filename( - {"Key": self.parent.response_key, "ConfInt": "upper"}, "" - ) - eval_df = self.rec_params.copy() - eval_df.rename( - columns={ - base: "response", - CIlower: "response_lower", - CIupper: "response_upper", - }, - inplace=True, - ) - - eval_df = eval_df.loc[ - :, ["resource", "response", "response_lower", "response_upper"] - ] - - def StatsSingle(df_single: pd.DataFrame, stat_params: stats.StatsParameters): - """ - Function for computing the stat (such as mean) and confidence intervals of the response - - Parameters - ---------- - df_single : pd.DataFrame - Dataframe of a single resource level - stat_params : stats.StatsParameters - Only one stats_measure will be used. - - Returns - ------- - pd.Dataframe - """ - df_dict = {} - sm = stat_params.stats_measures[0] # Ignore the rest if they exist - base, CIlower, CIupper = sm.ConfInts( - df_single["response"], - df_single["response_lower"], - df_single["response_upper"], - ) - - df_dict["response"] = [base] - df_dict["response_lower"] = [CIlower] - df_dict["response_upper"] = [CIupper] - df_dict["count"] = len(df_single["response"]) - - df_stats_single = pd.DataFrame.from_dict(df_dict) - return df_stats_single - - def applyBounds(df: pd.DataFrame, stat_params: stats.StatsParameters): - """ - Trim the response values obtained from statsSingle to be between 0 and 1 - - Parameters - ---------- - df : pd.DataFrame - Dataframe of a single resource level - stat_params : stats.StatsParameters - Only one stats_measure will be used. - """ - df_copy = df.loc[:, ("response_lower")].copy() - df_copy.clip(lower=0.0, inplace=True) - df.loc[:, ("response_lower")] = df_copy - - df_copy = df.loc[:, ("response_upper")].copy() - df_copy.clip(upper=1.0, inplace=True) - df.loc[:, ("response_upper")] = df_copy - return - - def Stats( - df: pd.DataFrame, stats_params: stats.StatsParameters, group_on=["resource"] - ): - """ - Compute a stat(eg. mean) of the response along with CIs for it, for each value of resource for the virtual best - - Parameters - ---------- - df : pd.DataFrame - Dataframe of a single resource level with columns 'resource', 'response', 'response_lower' and 'response_upper' - stats_params : stats.StatsParameters - Only one statsMeasure will be used. - group_on : list[str] - Confidence interval propagation will be done for all rows of dataframe having the same values for groupon - - Returns - ------- - pd.DataFrame - Dataframe with columns 'resource', 'response', 'response_lower' and 'response_upper' - """ - - def dfSS(df): - return StatsSingle(df, stats_params) - - df_stats = df.groupby(group_on).progress_apply(dfSS, include_groups=False).reset_index() - df_stats.drop("level_{}".format(len(group_on)), axis=1, inplace=True) - applyBounds(df_stats, stats_params) - - return df_stats - - if median: - stParams = stats.StatsParameters( - metrics=["response"], stats_measures=[stats.Median()] - ) - eval_df = Stats(eval_df, stParams, ["resource"]) - else: - stParams = stats.StatsParameters( - metrics=["response"], stats_measures=[stats.Mean()] - ) - eval_df = Stats(eval_df, stParams, ["resource"]) - eval_df.reset_index(inplace=True) - return params_df, eval_df - - class stochastic_benchmark: """ Attributes @@ -1286,10 +202,10 @@ def __init__( self.response_dir = response_dir ## Dataframes needed for experiments and baselines - self.bs_results = None - self.interp_results = None - self.training_stats = None - self.testing_stats = None + self.bs_results: Optional[Union[pd.DataFrame, List[str]]] = None + self.interp_results: Optional[pd.DataFrame] = None + self.training_stats: Optional[pd.DataFrame] = None + self.testing_stats: Optional[pd.DataFrame] = None self.experiments = [] @@ -1321,6 +237,9 @@ def initAll( self.train_test_split = train_test_split # Recursive file recovery + # Note: Bootstrap results are NOT auto-populated here. They must be explicitly + # created via run_Bootstrap() method to give users control over when bootstrapping + # occurs. This design was established in November 2022. while any( [ v is None @@ -1330,13 +249,29 @@ def initAll( self.populate_training_stats() self.populate_testing_stats() self.populate_interp_results() - # self.populate_bs_results() + + def get_experiment_parameters(self) -> ExperimentParameters: + return ExperimentParameters( + parameter_names=self.parameter_names, + instance_cols=self.instance_cols, + interp_results=self.interp_results, + checkpoint_path=self.here.checkpoints, + response_key=self.response_key, + response_dir=self.response_dir, + smooth=self.smooth, + stat_params=self.stat_params, + training_stats=self.training_stats, + testing_stats=self.testing_stats, + evaluate_without_bootstrap=self.evaluate_without_bootstrap, + baseline_recalibrate=self.baseline.recalibrate, + ) def run_Bootstrap(self, bsParams_iter, group_name_fcn=None): if self.bs_results is not None: logger.info("Bootstrapped results is already populated: doing nothing.") return + print("Loading and bootstrapping experimental data...") if self.reduce_mem: self.raw_data = glob.glob(os.path.join(self.here.raw_data, "*.pkl")) @@ -1426,20 +361,21 @@ def raw2bs_names(raw_filename): self.bs_results = bootstrap.Bootstrap( self.raw_data, group_on, bsParams_iter, progress_dir ) - self.bs_results.to_pickle(self.here.bootstrap) + if isinstance(self.bs_results, pd.DataFrame): + self.bs_results.to_pickle(self.here.bootstrap) def set_Bootstrap(self, bs_results): """ Sets bootstrap results without doing anything """ - if type(bs_results) == str: + if isinstance(bs_results, str): self.bs_results = pd.read_pickle(bs_results) - elif type(bs_results) == pd.DataFrame: + elif isinstance(bs_results, pd.DataFrame): self.bs_results = bs_results - elif type(bs_results) == list: - if type(bs_results[0]) == pd.DataFrame: + elif isinstance(bs_results, list): + if isinstance(bs_results[0], pd.DataFrame): self.bs_results = pd.concat(bs_results, ignore_index=True) - elif type(bs_results[0]) == str: + elif isinstance(bs_results[0], str): self.bs_results = bs_results def run_Interpolate(self, iParams): @@ -1453,20 +389,32 @@ def run_Interpolate(self, iParams): return if self.bs_results is None: - raise Exception( - "Bootstrapped results needs to be populated before interpolation." + raise ValueError( + "bs_results is None - bootstrapped results must be populated before interpolation. " + "Ensure Bootstrap() or initBootstrap() has been called successfully." ) + print("Interpolating results across resource budgets...") if self.reduce_mem: logger.info("Interpolating results with parameters: %s", iParams) + if not isinstance(self.bs_results, list): + raise TypeError( + f"Expected list for reduce_mem mode but got {type(self.bs_results).__name__}" + ) self.interp_results = interpolate.Interpolate_reduce_mem( self.bs_results, iParams, self.parameter_names + self.instance_cols ) else: logger.info("Interpolating results with parameters: %s", iParams) + if not isinstance(self.bs_results, pd.DataFrame): + raise TypeError( + f"Expected DataFrame for non-reduce_mem mode but got {type(self.bs_results).__name__}" + ) self.interp_results = interpolate.Interpolate( self.bs_results, iParams, self.parameter_names + self.instance_cols ) + + assert self.interp_results is not None, "Interpolation failed to produce results" base = names.param2filename({"Key": self.response_key}, "") CIlower = names.param2filename( @@ -1488,11 +436,14 @@ def run_Stats(self, stat_params, train_test_split=0.5): "Interpolated results needs to be populated before computing stats." ) + print("Computing training/testing statistics...") if "train" not in self.interp_results.columns: self.interp_results = training.split_train_test( self.interp_results, self.instance_cols, train_test_split ) self.interp_results.to_pickle(self.here.interpolate) + + assert self.interp_results is not None, "interp_results was unexpectedly None" if self.training_stats is None: if os.path.exists(self.here.training_stats) and self.recover: @@ -1509,7 +460,9 @@ def run_Stats(self, stat_params, train_test_split=0.5): stat_params, self.parameter_names + ["boots", "resource"], ) - self.training_stats.to_pickle(self.here.training_stats) + + if self.training_stats is not None: + self.training_stats.to_pickle(self.here.training_stats) if self.testing_stats is None: if os.path.exists(self.here.testing_stats) and self.recover: @@ -1528,7 +481,9 @@ def run_Stats(self, stat_params, train_test_split=0.5): stat_params, self.parameter_names + ["boots", "resource"], ) - self.testing_stats.to_pickle(self.here.testing_stats) + + if self.testing_stats is not None: + self.testing_stats.to_pickle(self.here.testing_stats) def populate_training_stats(self): """ @@ -1547,7 +502,8 @@ def populate_training_stats(self): self.stat_params, self.parameter_names + ["boots", "resource"], ) - self.training_stats.to_pickle(self.here.training_stats) + if self.training_stats is not None: + self.training_stats.to_pickle(self.here.training_stats) def populate_testing_stats(self): """ @@ -1569,7 +525,8 @@ def populate_testing_stats(self): self.stat_params, self.parameter_names + ["boots", "resource"], ) - self.testing_stats.to_pickle(self.here.testing_stats) + if self.testing_stats is not None: + self.testing_stats.to_pickle(self.here.testing_stats) def populate_interp_results(self): """ @@ -1578,7 +535,7 @@ def populate_interp_results(self): if self.interp_results is None: if os.path.exists(self.here.interpolate) and self.recover: self.interp_results = pd.read_pickle(self.here.interpolate) - if "train" not in self.interp_results.columns: + if self.interp_results is not None and "train" not in self.interp_results.columns: self.interp_results = training.split_train_test( self.interp_results, self.instance_cols, self.train_test_split ) @@ -1588,6 +545,10 @@ def populate_interp_results(self): # print(self.bs_results) if self.reduce_mem: logger.info("Interpolating results with parameters: %s", self.iParams) + if not isinstance(self.bs_results, list): + raise TypeError( + f"Expected list for reduce_mem mode but got {type(self.bs_results).__name__}" + ) self.interp_results = interpolate.Interpolate_reduce_mem( self.bs_results, self.iParams, @@ -1595,11 +556,17 @@ def populate_interp_results(self): ) else: logger.info("Interpolating results with parameters: %s", self.iParams) + if not isinstance(self.bs_results, pd.DataFrame): + raise TypeError( + f"Expected DataFrame for non-reduce_mem mode but got {type(self.bs_results).__name__}" + ) self.interp_results = interpolate.Interpolate( self.bs_results, self.iParams, self.parameter_names + self.instance_cols, ) + + assert self.interp_results is not None, "Interpolation failed to produce results" base = names.param2filename({"Key": self.response_key}, "") CIlower = names.param2filename( @@ -1617,50 +584,10 @@ def populate_interp_results(self): ) self.interp_results.to_pickle(self.here.interpolate) self.bs_results = None - else: - self.populate_bs_results(self.bsParams_iter, self.group_name_fcn) - - # def populate_bs_results(self, group_name_fcn=None): - # """ - # Tries to recover or computes bootstrapped results - # """ - - # if self.bs_results is None: - # if self.reduce_mem: - # def raw2bs_names(raw_filename): - # group_name = group_name_fcn(raw_filename) - # bs_filename = os.path.join(self.here.checkpoints, 'bootstrapped_results_{}.pkl'.format(group_name)) - # return bs_filename - - # self.raw_data = glob.glob(os.path.join(self.here.raw_data, '*.pkl')) - # bs_names = [raw2bs_names(raw_file) for raw_file in self.raw_data] - - # if all([os.path.exists(bs_name) for bs_name in bs_names]) and len(bs_names) > 1 and self.recover: - # print('Reading bootstrapped results') - # self.bs_results = bs_names - # else: - # group_on = self.parameter_names + self.instance_cols - # if not hasattr(self, 'raw_data'): - # print('Running bootstrapped results') - # self.raw_data = glob.glob(os.path.join(self.here.raw_data, '*.pkl')) - # self.bs_results = bootstrap.Bootstrap_reduce_mem(self.raw_data, group_on, self.bsParams_iter, self.here.checkpoints, group_name_fcn) - - # else: - # if os.path.exists(self.here.bootstrap) and self.recover: - # print('Reading bootstrapped results') - # self.bs_results = pd.read_pickle(self.here.bootstrap) - # else: - # print('Running bootstrapped results') - # group_on = self.parameter_names + self.instance_cols - # if not hasattr(self, 'raw_data'): - # self.raw_data = df_utils.read_exp_raw(self.here.raw_data) - - # progress_dir = os.path.join(self.here.progress, 'bootstrap/') - # if not os.path.exists(progress_dir): - # os.makedirs(progress_dir) - - # self.bs_results = bootstrap.Bootstrap(self.raw_data, group_on, self.bsParams_iter, progress_dir) - # self.bs_results.to_pickle(self.here.bootstrap) + # Note: If neither interp_results nor bs_results exist, they must be explicitly + # created via run_Bootstrap(). Auto-population was removed in commit 857574f (Nov 2022) + # to give users explicit control. For reference implementation of auto-population + # with reduce_mem support, see git history. def evaluate_without_bootstrap(self, df, group_on): """ " @@ -1713,8 +640,9 @@ def run_baseline(self): """ Adds virtual best baseline """ + print("Computing virtual best baseline...") logger.info("Runnng baseline") - self.baseline = VirtualBestBaseline(self) + self.baseline = VirtualBestBaseline(self.get_experiment_parameters()) def run_ProjectionExperiment( self, project_from, postprocess=None, postprocess_name=None @@ -1736,9 +664,10 @@ def run_ProjectionExperiment( ProjectionExperiment Experiment object """ + print(f" ├─ Running ProjectionExperiment from {project_from}...") logger.info("Running projection experiment") self.experiments.append( - ProjectionExperiment(self, project_from, postprocess, postprocess_name) + ProjectionExperiment(self.get_experiment_parameters(), project_from, postprocess, postprocess_name) ) def run_RandomSearchExperiment( @@ -1747,10 +676,11 @@ def run_RandomSearchExperiment( """ Runs random search experiments """ + print(" ├─ Running RandomSearchExperiment...") logger.info("Running random search experiment") self.experiments.append( RandomSearchExperiment( - self, + self.get_experiment_parameters(), rsParams, postprocess=postprocess, postprocess_name=postprocess_name, @@ -1779,10 +709,12 @@ def run_SequentialSearchExperiment( SequentialSearchExperiment Experiment object """ + id_label = f" ({id_name})" if id_name else "" + print(f" ├─ Running SequentialSearchExperiment{id_label}...") logger.info("Running sequential search experiment") self.experiments.append( SequentialSearchExperiment( - self, + self.get_experiment_parameters(), ssParams, id_name, postprocess=postprocess, @@ -1805,7 +737,7 @@ def run_StaticRecommendationExperiment(self, init_from): Experiment object """ logger.info("Running static recommendation experiment") - self.experiments.append(StaticRecommendationExperiment(self, init_from)) + self.experiments.append(StaticRecommendationExperiment(self.get_experiment_parameters(), init_from)) def initPlotting(self): """ diff --git a/test-all-python-versions.sh b/test-all-python-versions.sh new file mode 100755 index 00000000..21b6a052 --- /dev/null +++ b/test-all-python-versions.sh @@ -0,0 +1,79 @@ +#!/bin/bash +# Script to test all Python versions that CI uses +# This helps verify compatibility across Python 3.10, 3.11, and 3.12 + +set -e + +# Colors +GREEN='\033[0;32m' +BLUE='\033[0;34m' +YELLOW='\033[1;33m' +RED='\033[0;31m' +NC='\033[0m' + +PYTHON_VERSIONS=("3.10" "3.11" "3.12") +FAILED_VERSIONS=() +PASSED_VERSIONS=() + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}Testing All Python Versions (Like CI)${NC}" +echo -e "${BLUE}========================================${NC}" +echo "" + +for PY_VERSION in "${PYTHON_VERSIONS[@]}"; do + ENV_NAME="stochastic-benchmark-ci-py${PY_VERSION//./}" + + echo -e "${YELLOW}========================================${NC}" + echo -e "${YELLOW}Testing Python ${PY_VERSION}${NC}" + echo -e "${YELLOW}========================================${NC}" + echo "" + + # Check if environment exists + if ! conda env list | grep -q "^${ENV_NAME} "; then + echo -e "${YELLOW}Environment ${ENV_NAME} not found. Creating it...${NC}" + ./setup-ci-env.sh "${PY_VERSION}" + fi + + # Activate and test + eval "$(conda shell.bash hook)" + conda activate "${ENV_NAME}" + + echo -e "Testing with environment: ${BLUE}${ENV_NAME}${NC}" + echo "" + + if ./run-ci-tests.sh; then + echo -e "${GREEN}✓ Python ${PY_VERSION} tests PASSED${NC}" + PASSED_VERSIONS+=("${PY_VERSION}") + else + echo -e "${RED}✗ Python ${PY_VERSION} tests FAILED${NC}" + FAILED_VERSIONS+=("${PY_VERSION}") + fi + + conda deactivate + echo "" + echo "" +done + +echo -e "${BLUE}========================================${NC}" +echo -e "${BLUE}Test Summary${NC}" +echo -e "${BLUE}========================================${NC}" +echo "" + +echo -e "${GREEN}Passed (${#PASSED_VERSIONS[@]}/${#PYTHON_VERSIONS[@]}):${NC}" +for version in "${PASSED_VERSIONS[@]}"; do + echo -e " ✓ Python ${version}" +done + +if [ ${#FAILED_VERSIONS[@]} -gt 0 ]; then + echo "" + echo -e "${RED}Failed (${#FAILED_VERSIONS[@]}/${#PYTHON_VERSIONS[@]}):${NC}" + for version in "${FAILED_VERSIONS[@]}"; do + echo -e " ✗ Python ${version}" + done + echo "" + exit 1 +else + echo "" + echo -e "${GREEN}All Python versions passed! 🎉${NC}" + echo "" +fi diff --git a/tests/test_bootstrap.py b/tests/test_bootstrap.py index 1618822e..28acd4e7 100644 --- a/tests/test_bootstrap.py +++ b/tests/test_bootstrap.py @@ -28,8 +28,12 @@ import success_metrics -def dummy_update_rule(bs_params, df): - """Default dummy update rule for testing.""" +def dummy_update_rule(self, df): + """Default dummy update rule for testing. + + Note: update_rule functions should use signature (self, df) where + self is the BootstrapParameters instance. The function will be called as bs_params.update_rule(bs_params, df). + """ pass @@ -48,7 +52,7 @@ def test_bootstrap_parameters_initialization(self): } # Create a simple update rule function - def dummy_update_rule(bs_params, df): + def dummy_update_rule(self, df): pass params = BootstrapParameters(shared_args=shared_args, update_rule=dummy_update_rule) @@ -95,7 +99,7 @@ def test_bootstrap_parameters_post_init(self): """Test BootstrapParameters post-initialization behavior.""" shared_args = {'response_col': 'energy'} - def dummy_update_rule(bs_params, df): + def dummy_update_rule(self, df): pass params = BootstrapParameters(shared_args=shared_args, update_rule=dummy_update_rule) @@ -103,8 +107,9 @@ def dummy_update_rule(bs_params, df): # Check that metric_args is a defaultdict assert isinstance(params.metric_args, defaultdict) - # Check that accessing non-existent key returns None - assert params.metric_args['NonExistent'] is None + # Check that accessing non-existent key returns empty dict + assert params.metric_args['NonExistent'] == {} + assert isinstance(params.metric_args['NonExistent'], dict) # Check that update_rule is set to default if not provided assert hasattr(params, 'update_rule') @@ -118,11 +123,11 @@ def test_default_update_minimization(self): 'response_dir': -1 } - def dummy_update_rule(bs_params, df): + def dummy_update_rule(self, df): pass # Provide metric_args with RTT structure - metric_args = defaultdict(lambda: None) + metric_args = defaultdict(dict) metric_args['RTT'] = {} params = BootstrapParameters( @@ -154,11 +159,11 @@ def test_default_update_maximization(self): 'response_dir': 1 } - def dummy_update_rule(bs_params, df): + def dummy_update_rule(self, df): pass # Provide metric_args with RTT structure - metric_args = defaultdict(lambda: None) + metric_args = defaultdict(dict) metric_args['RTT'] = {} params = BootstrapParameters( @@ -178,6 +183,238 @@ def dummy_update_rule(bs_params, df): # Should set best_value to maximum energy assert params.shared_args['best_value'] == 120 + def test_update_rule_called_via_initBootstrap(self): + """Test that update_rule is called correctly through initBootstrap. + + This test verifies the actual code path where update_rule is called + as bs_params.update_rule(bs_params, df) from initBootstrap(). + """ + shared_args = { + 'response_col': 'energy', + 'resource_col': 'time', + 'response_dir': -1, + 'confidence_level': 68 + } + + # Track whether update_rule was called correctly + call_tracker = {'called': False, 'self_param': None, 'df_param': None} + + def custom_update(bs_params, df): + call_tracker['called'] = True + call_tracker['self_param'] = bs_params + call_tracker['df_param'] = df + bs_params.shared_args['best_value'] = df['energy'].min() + + metric_args = defaultdict(dict) + metric_args['RTT'] = {} + + params = BootstrapParameters( + shared_args=shared_args, + update_rule=custom_update, + metric_args=metric_args, + bootstrap_iterations=10, + downsample=2 + ) + + df = pd.DataFrame({ + 'energy': [100, 80, 120, 90], + 'time': [10, 15, 8, 12] + }) + + # Call initBootstrap which internally calls update_rule(bs_params, df) + responses, resources = initBootstrap(df, params) + + # Verify update_rule was called + assert call_tracker['called'], "update_rule should have been called" + assert call_tracker['self_param'] is params, "First parameter should be bs_params" + assert isinstance(call_tracker['df_param'], pd.DataFrame), "Second parameter should be DataFrame" + assert params.shared_args['best_value'] == 80, "best_value should be updated" + + def test_default_update_called_via_initBootstrap(self): + """Test that default_update works when called through update_rule. + + This test verifies that when no custom update_rule is provided, + the default_update method is correctly assigned and called as an + unbound method through the update_rule attribute. + """ + shared_args = { + 'response_col': 'energy', + 'resource_col': 'time', + 'response_dir': -1, + 'confidence_level': 68 + } + + metric_args = defaultdict(dict) + metric_args['RTT'] = {} + + # Don't provide update_rule, should use default + params = BootstrapParameters( + shared_args=shared_args, + metric_args=metric_args, + bootstrap_iterations=10, + downsample=2 + ) + + df = pd.DataFrame({ + 'energy': [100, 80, 120, 90], + 'time': [10, 15, 8, 12] + }) + + # Verify default_update was assigned + assert params.update_rule is not None + assert params.update_rule == BootstrapParameters.default_update + + # Call initBootstrap which internally calls update_rule(bs_params, df) + responses, resources = initBootstrap(df, params) + + # Verify default_update was executed correctly + assert 'best_value' in params.shared_args + assert params.shared_args['best_value'] == 80 # min energy + assert params.metric_args['RTT']['RTT_factor'] == 1e-6 * df['time'].sum() + + def test_update_rule_signature_with_self_and_df(self): + """Test that update_rule functions must accept (self, df) parameters. + + This verifies the correct signature pattern where update_rule is an + unbound function taking (BootstrapParameters instance, DataFrame). + """ + shared_args = { + 'response_col': 'energy', + 'resource_col': 'time', + 'response_dir': -1, + 'confidence_level': 68 + } + + metric_args = defaultdict(dict) + metric_args['Response'] = {'opt_sense': -1} + metric_args['RTT'] = {'fail_value': np.nan, 'RTT_factor': 1.0} + + # Define update_rule like in wishart_ws.py example + def update_rules(self, df): + """Custom update rule that modifies shared_args and metric_args.""" + # Simulate getting ground truth from dataframe + if 'ground_truth' in df.columns: + self.shared_args['best_value'] = df['ground_truth'].iloc[0] + self.metric_args['RTT']['RTT_factor'] = df['time'].iloc[0] + + params = BootstrapParameters( + shared_args=shared_args, + update_rule=update_rules, + metric_args=metric_args, + bootstrap_iterations=10, + downsample=2 + ) + + df = pd.DataFrame({ + 'energy': [100, 80, 120], + 'time': [10, 15, 8], + 'ground_truth': [75, 75, 75] + }) + + # Call update_rule the way bootstrap.py does + if params.update_rule is not None: + params.update_rule(params, df) + + # Verify the updates were applied + assert params.shared_args['best_value'] == 75 + assert params.metric_args['RTT']['RTT_factor'] == 10 + + def test_update_rule_wrong_signature_fails(self): + """Test that update_rule with wrong signature fails at runtime. + + This test validates that providing an update_rule with incorrect signature + (missing self parameter) will fail when called, helping catch common mistakes. + """ + import inspect + + shared_args = { + 'response_col': 'energy', + 'resource_col': 'time', + 'response_dir': -1, + 'confidence_level': 68 + } + + # Define update_rule with WRONG signature (only takes df) + def wrong_update(df): + """This has wrong signature - missing self parameter.""" + pass + + # Create params with wrong signature function + params = BootstrapParameters( + shared_args=shared_args, + update_rule=wrong_update, # type: ignore # Intentionally wrong for testing + metric_args=defaultdict(dict), + bootstrap_iterations=10, + downsample=2 + ) + + df = pd.DataFrame({ + 'energy': [100, 80, 120], + 'time': [10, 15, 8] + }) + + # Verify the signature is actually wrong (only 1 parameter) + sig = inspect.signature(wrong_update) + assert len(sig.parameters) == 1, "Test setup: function should have 1 parameter" + + # Calling it should fail with TypeError + with pytest.raises(TypeError) as exc_info: + params.update_rule(params, df) # type: ignore # Will fail at runtime + + assert "takes 1 positional argument but 2 were given" in str(exc_info.value) + + def test_update_rule_signature_validation(self): + """Test helper to validate update_rule has correct signature. + + This demonstrates how to check update_rule signature before using it, + which could be useful for providing better error messages to users. + """ + import inspect + + def correct_signature(self, df): + """Correct: takes self and df.""" + pass + + def wrong_signature_1(df): + """Wrong: only takes df.""" + pass + + def wrong_signature_2(self, df, extra): + """Wrong: takes too many parameters.""" + pass + + def wrong_signature_3(): + """Wrong: takes no parameters.""" + pass + + # Helper function to validate signature + def validate_update_rule_signature(func): + """Check if function has correct signature (2 parameters).""" + sig = inspect.signature(func) + param_count = len(sig.parameters) + return param_count == 2 + + # Test validation + assert validate_update_rule_signature(correct_signature) is True + assert validate_update_rule_signature(wrong_signature_1) is False + assert validate_update_rule_signature(wrong_signature_2) is False + assert validate_update_rule_signature(wrong_signature_3) is False + + # Show that correct signature works + params = BootstrapParameters( + shared_args={'response_col': 'energy'}, + update_rule=correct_signature, + metric_args=defaultdict(dict) + ) + + df = pd.DataFrame({'energy': [100, 80, 120]}) + + # Validate before using + assert validate_update_rule_signature(params.update_rule) is True + + # Should work fine + params.update_rule(params, df) # type: ignore # Already validated above + class TestBSParamsIter: """Test class for BSParams_iter iterator.""" @@ -646,6 +883,28 @@ def name_function(group_data): # Clean up os.unlink(tmp_file.name) + + def test_bootstrap_reduce_mem_requires_name_fcn(self): + """Test that Bootstrap_reduce_mem fails fast when name_fcn is None.""" + df = pd.DataFrame({ + 'energy': [100, 80], + 'time': [10, 15], + 'group': ['A', 'B'] + }) + + shared_args = {'response_col': 'energy', 'resource_col': 'time'} + params = BootstrapParameters(shared_args=shared_args, update_rule=dummy_update_rule) + + with tempfile.TemporaryDirectory() as bootstrap_dir: + # Test with None name_fcn - should fail fast at function start + with pytest.raises(ValueError, match="name_fcn is required for Bootstrap_reduce_mem"): + Bootstrap_reduce_mem( + df, + [['group']], + [params], + bootstrap_dir, + name_fcn=None # This should cause immediate failure + ) class TestConstants: diff --git a/tests/test_smoke.py b/tests/test_smoke.py index 0bd9fa80..f29cac89 100644 --- a/tests/test_smoke.py +++ b/tests/test_smoke.py @@ -327,5 +327,116 @@ def test_invalid_parameters_handling(self): pass + + +class TestStochasticBenchmarkErrorHandling: + """Test error handling in stochastic_benchmark module.""" + + def test_interpolate_with_none_bs_results_clear_error(self): + """Test that interpolation with None bs_results gives clear ValueError, not confusing TypeError.""" + import stochastic_benchmark + import interpolate + import tempfile + import pandas as pd + + def dummy_resource_fcn(df): + return pd.Series([1]*len(df)) + + with tempfile.TemporaryDirectory() as temp_dir: + # Create a minimal stochastic_benchmark instance + sb = stochastic_benchmark.stochastic_benchmark( + here=temp_dir, + response_key="test_response", + response_dir="max", + parameter_names=["param1"], + instance_cols=["instance"], + ) + + # Set up interpolation parameters + iParams = interpolate.InterpolationParameters( + resource_fcn=dummy_resource_fcn, + resource_value_type="manual", + resource_values=[1, 2, 3] + ) + + # Ensure bs_results is None + sb.bs_results = None + sb.reduce_mem = False + + # Test that we get a clear ValueError about None, not a TypeError + with pytest.raises(ValueError, match="bs_results is None"): # Now expects clearer ValueError + sb.run_Interpolate(iParams) + + def test_interpolate_reduce_mem_with_none_bs_results_clear_error(self): + """Test that reduce_mem interpolation with None bs_results gives clear ValueError.""" + import stochastic_benchmark + import interpolate + import tempfile + import pandas as pd + + def dummy_resource_fcn(df): + return pd.Series([1]*len(df)) + + with tempfile.TemporaryDirectory() as temp_dir: + # Create a minimal stochastic_benchmark instance + sb = stochastic_benchmark.stochastic_benchmark( + here=temp_dir, + response_key="test_response", + response_dir="max", + parameter_names=["param1"], + instance_cols=["instance"], + ) + + # Set up interpolation parameters + iParams = interpolate.InterpolationParameters( + resource_fcn=dummy_resource_fcn, + resource_value_type="manual", + resource_values=[1, 2, 3] + ) + + # Ensure bs_results is None + sb.bs_results = None + sb.reduce_mem = True + + # Test that we get a clear ValueError about None, not a TypeError + with pytest.raises(ValueError, match="bs_results is None"): # Now expects clearer ValueError + sb.run_Interpolate(iParams) + + def test_interpolate_with_wrong_type_gives_type_error(self): + """Test that interpolation with wrong type gives TypeError (after None check).""" + import stochastic_benchmark + import interpolate + import tempfile + import pandas as pd + + def dummy_resource_fcn(df): + return pd.Series([1]*len(df)) + + with tempfile.TemporaryDirectory() as temp_dir: + # Create a minimal stochastic_benchmark instance + sb = stochastic_benchmark.stochastic_benchmark( + here=temp_dir, + response_key="test_response", + response_dir="max", + parameter_names=["param1"], + instance_cols=["instance"], + ) + + # Set up interpolation parameters + iParams = interpolate.InterpolationParameters( + resource_fcn=dummy_resource_fcn, + resource_value_type="manual", + resource_values=[1, 2, 3] + ) + + # Set bs_results to wrong type (not None, but not the expected type) + sb.bs_results = "wrong_type" # String instead of DataFrame + sb.reduce_mem = False + + # Test that we get a TypeError about wrong type + with pytest.raises(TypeError, match="Expected DataFrame.*but got"): + sb.run_Interpolate(iParams) + + if __name__ == "__main__": - pytest.main([__file__]) \ No newline at end of file + pytest.main([__file__])