notebooks/2c_decision_trees_ATLAS_model_comparison.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Lesson 2C: ATLAS - Decision Tree Comparison"
      ],
      "metadata": {
        "id": "jjoXMPF9uGKG"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SFk8wWoi805F"
      },
      "source": [
        "\n",
        "<a name=\"introduction\"></a>\n",
        "## Introduction\n",
        "\n",
        "Ok so if you've gotten this far you might be wondering: What's the best type of decision tree for predicting house prices? How best to configure such a tree? What features give the best predictions without overfitting?\n",
        "\n",
        "Well, you're in for a treat - through our systematic exploration, we'll discover a remarkably powerful model that explains 92% of house price variance (R² = 0.92) in the volatile London market!\n",
        "\n",
        "To uncover such high-performing models, we'll need a pipeline for running and comparing lots of tree-based models at once. So let's build that!\n",
        "\n",
        "In this lesson we're building ATLAS - an Automated Tree Learning Analysis System.\n",
        "\n",
        "Why ATLAS? Well, comparing loads of models is heavy work, and like its mythological namesake, our pipeline carries that load.\n",
        "\n",
        "We're going to explore:\n",
        "\n",
        "1. How to compare lots of models without losing our sanity\n",
        "2. Why feature engineering is still more art than science\n",
        "3. The eternal trade-off between complexity and performance\n",
        "4. What we've learned about model evaluation (mostly through making mistakes)\n",
        "\n",
        "## Table of Contents\n",
        "\n",
        "1. [Introduction](#introduction)\n",
        "1. [Why build ATLAS?](#why-build-atlas)\n",
        "2. [ATLAS architecture](#atlas-architecture)\n",
        "  - [Understanding k-fold cross-validation](#understanding-k-fold-cross-validation)\n",
        "  -  [Core components](#core-components)\n",
        "  -  [Class design and model persistence](#class-design-and-model-persistence)\n",
        "  -  [System workflow](#system-workflow)\n",
        "  -  [Key challenges solved](#key-challenges-solved)\n",
        "3. [ATLAS implementation](#atlas-implementation)\n",
        "  - [Required libraries](#required-libraries)\n",
        "  - [Data loading, validation and FeatureSet dataclass](#data-loading-validation-and-featureset-dataclass)\n",
        "  - [PreProcessor](#preprocessor)\n",
        "  - [FeatureEncoder, EncoderState and persistence](#featureencoder-encoderstate-and-persistence)\n",
        "  - [CrossValidator](#crossvalidator)\n",
        "7. [Running ATLAS](#running-atlas)\n",
        "8. [Unveiling the drivers of London house prices](#unveiling-the-drivers-of-london-house-prices)\n",
        "  - [Top performing models](#top-performing-models)\n",
        "  - [The price information paradox](#the-price-information-paradox)\n",
        "  - [Models without price information](#models-without-price-information)\n",
        "  - [The importance of validation](#the-importance-of-validation)\n",
        "  - [Feature engineering: The art of extracting signal from the noise](#feature-engineering-the-art-of-extracting-signal-from-the-noise)\n",
        "  - [Ethical considerations, human impact, and future directions](#ethical-considerations-human-impact-and-future-directions)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l3PhH0C_805I"
      },
      "source": [
        "\n",
        "<a name=\"why-build-atlas\"></a>\n",
        "## Why build ATLAS?\n",
        "Let's be upfront - we're building this pipeline because:\n",
        "\n",
        "1. Running models one at a time is tedious and error-prone\n",
        "2. We keep forgetting which model performed best and with which features\n",
        "3. Copying and pasting code between notebooks is a recipe for disaster\n",
        "4. We want to spend time understanding results, not running experiments\n",
        "\n",
        "Let's also acknowledge something else upfront - we're all using AI tools to help write code these days and this gives us the opportunity to quickly build this comparison engine in a day, a task that would have taken much longer a year ago.\n",
        "\n",
        "We want to encourage the use of these tools as they are brilliant at the boilerplate stuff, but its important we remember we're the editors, proof-readers, and decision makers.\n",
        "\n",
        "Every line gets our scrutiny, and every design choice serves a purpose. The interesting questions - the \"why are we doing this?\" and \"what does this actually mean?\" - that's where we humans get to shine.\n",
        "\n",
        "This is where ATLAS comes in. Think of it as our research assistant that handles the repetitive work while we focus on what matters - understanding and interpreting the results.\n",
        "\n",
        "In building this system, we face three critical challenges:\n",
        "\n",
        "1. We need to compare many different approaches systematically\n",
        "2. We need to ensure our comparisons are fair and reliable\n",
        "3. We need to avoid common pitfalls that can invalidate our results\n",
        "\n",
        "Let's dive in by setting up our tools and loading our data.\n",
        "\n",
        "<a name=\"atlas-architecture\"></a>\n",
        "## ATLAS architecture\n",
        "\n",
        "At its core, ATLAS is a pipeline that automates the process of:\n",
        "```\n",
        "Raw Data → Feature Engineering → Model Training → Evaluation → Results\n",
        "```\n",
        "\n",
        "But it does this across:\n",
        "- Multiple feature combinations\n",
        "- Multiple model types (Decision Trees, Random Forests, XGBoost)\n",
        "- Multiple training/validation splits\n",
        "- All while preventing common mistakes such as target variable leakage\n",
        "\n",
        "<a name=\"understanding-k-fold-cross-validation\"></a>\n",
        "### Understanding k-fold cross-validation in ATLAS\n",
        "\n",
        "Cross-validation sits at the heart of ATLAS's validation strategy. It lets us systematically rotate which portion of our training data is used for validation, with 'k' referring to the number of groups we split our data into.\n",
        "\n",
        "#### Why do we need it?\n",
        "When evaluating our house price models, using a single train-validation split is risky - our results might depend heavily on which properties end up in which set. Cross-validation solves this by validating each model multiple times on different splits of the data.\n",
        "\n",
        "#### How it works in practice\n",
        "The general procedure is as follows:\n",
        "\n",
        "1. Mix up the data randomly\n",
        "2. Cut it into `k` equal chunks\n",
        "3. For each chunk:\n",
        "  - Use it to validate\n",
        "  - Use everything else to train\n",
        "  - Build a model and see how it does\n",
        "  - Write down the score\n",
        "4. Average all those scores together\n",
        "\n",
        "Let's see how this works with our house prices.\n",
        "\n",
        "Imagine you have 1000 house prices and want to test your model. You could:\n",
        "\n",
        "1. **Simple split (not great):**\n",
        "   ```\n",
        "   800 houses for training → Train Model → Test on 200 houses\n",
        "   ```\n",
        "   Problem: Your results might depend heavily on which 200 houses you picked\n",
        "\n",
        "2. **Use 5-fold cross-validation (much better):**\n",
        "   ```\n",
        "   Split 800 training houses into 5 folds of 160 each\n",
        "   \n",
        "  Fold 1: [Val][Train][Train][Train][Train]\n",
        "  Fold 2: [Train][Val][Train][Train][Train]\n",
        "  Fold 3: [Train][Train][Val][Train][Train]\n",
        "  Fold 4: [Train][Train][Train][Val][Train]\n",
        "  Fold 5: [Train][Train][Train][Train][Val]\n",
        "   ```\n",
        "   \n",
        "   Now you:\n",
        "   - Train 5 different times\n",
        "   - Each time, use 4 folds (640 houses) for training\n",
        "   - Validate on the remaining fold (160 houses)\n",
        "   - Average the results\n",
        "\n",
        "This gives you much more reliable performance estimates and tells you how much your model's performance varies.\n",
        "\n",
        "For ATLAS, this means we can tell if a model really works across all kinds of London properties and hasn't just gotten lucky with one split.\n",
        "\n",
        "<a name=\"core-components\"></a>\n",
        "### Core components\n",
        "\n",
        "#### 1. PreProcessor: The data guardian\n",
        "```python\n",
        "preprocessor = PreProcessor()\n",
        "train_data, test_data = preprocessor.create_train_test_split(raw_data)\n",
        "```\n",
        "\n",
        "The PreProcessor's job is simple but crucial:\n",
        "- Split data into training and test sets\n",
        "- Ensure the splits represent all price ranges using stratified sampling\n",
        "- Keep the test data untouched until final evaluation\n",
        "\n",
        "#### 2. FeatureEncoder: The feature factory\n",
        "\n",
        "The FeatureEncoder tackles our biggest challenge: how to use location information without leaking price data. Here's the problem:\n",
        "\n",
        "##### The price leakage problem\n",
        "\n",
        "Imagine you're predicting house prices in London. You know that houses in Chelsea are expensive, so you want to encode this information. A naive approach would be:\n",
        "\n",
        "```python\n",
        "# 🚫 BAD APPROACH - Price Leakage!\n",
        "chelsea_average_price = all_data[all_data['area'] == 'Chelsea']['price'].mean()\n",
        "data['chelsea_price_level'] = chelsea_average_price\n",
        "```\n",
        "\n",
        "This leaks future price information because you're using the entire dataset's prices to create features. Instead, ATLAS does this:\n",
        "\n",
        "```python\n",
        "# ✅ GOOD APPROACH - No Leakage\n",
        "def encode_location(train_fold, validation_fold):\n",
        "    # Calculate price levels using ONLY training data\n",
        "    area_prices = train_fold.groupby('area')['price'].mean()\n",
        "    \n",
        "    # Apply to validation data without leakage\n",
        "    validation_fold['area_price_level'] = validation_fold['area'].map(area_prices)\n",
        "```\n",
        "\n",
        "ATLAS also encodes area based price information hierarchically:\n",
        "```\n",
        "City Level (e.g., London)\n",
        "   ↓\n",
        "Area Level (e.g., North London)\n",
        "   ↓\n",
        "Neighborhood Level (e.g., Islington)\n",
        "```\n",
        "\n",
        "For areas with limited data, we fall back to broader geographic averages.\n",
        "\n",
        "#### 3. CrossValidator: The experiment runner\n",
        "\n",
        "The CrossValidator is where everything comes together.\n",
        "\n",
        "It manages running training, evaluating each model and feature set combinations, and calls the feature encoders within the training folds to prevent target variable information leakage.\n",
        "\n",
        "```python\n",
        "class CrossValidator:\n",
        "    def evaluate_all_combinations(self, train_data, test_data):\n",
        "        results = []\n",
        "        \n",
        "        # PART 1: K-FOLD CROSS VALIDATION\n",
        "        kf = KFold(n_splits=5, shuffle=True)\n",
        "        for fold_idx, (train_idx, val_idx) in enumerate(kf.split(train_data)):\n",
        "            # Get this fold's data\n",
        "            fold_train = train_data.iloc[train_idx]\n",
        "            fold_val = train_data.iloc[val_idx]\n",
        "            \n",
        "            # Create features fresh for this fold\n",
        "            feature_sets = encoder.create_fold_features(fold_train, fold_val)\n",
        "            \n",
        "            # Try each feature set and model combination\n",
        "            for feature_set in feature_sets:\n",
        "                for model_name, model in self.models.items():\n",
        "                    # Train and evaluate\n",
        "                    model.fit(feature_set.X_train, feature_set.y_train)\n",
        "                    val_pred = model.predict(feature_set.X_val)\n",
        "                    \n",
        "                    # Record results\n",
        "                    results.append({\n",
        "                        'fold': fold_idx,\n",
        "                        'feature_set': feature_set.name,\n",
        "                        'model': model_name,\n",
        "                        'performance': calculate_metrics(val_pred)\n",
        "                    })\n",
        "        \n",
        "        # PART 2: FINAL EVALUATION\n",
        "        # Only best models get evaluated on test data\n",
        "        best_models = select_best_models(results)\n",
        "        final_results = evaluate_on_test_data(best_models, test_data)\n",
        "```\n",
        "\n",
        "This ensures each fold is truly independent, with its own feature encoding.\n",
        "\n",
        "\n",
        "<a name=\"class-design-and-model-persistence\"></a>\n",
        "### Class design and model persistence\n",
        "\n",
        "ATLAS is built for deployment, not just experimentation. Our encoders can easily be extended to each save their states:\n",
        "\n",
        "```python\n",
        "class FeatureEncoder:\n",
        "    def __init__(self):\n",
        "        self.encoding_maps = {}  # Stores encoding information\n",
        "        \n",
        "    def save(self, path):\n",
        "        # Save encoding_maps for future use\n",
        "        with open(path, 'wb') as f:\n",
        "            pickle.dump(self.encoding_maps, f)\n",
        "            \n",
        "    @classmethod\n",
        "    def load(cls, path):\n",
        "        # Load saved encoder\n",
        "        with open(path, 'rb') as f:\n",
        "            encoder = cls()\n",
        "            encoder.encoding_maps = pickle.load(f)\n",
        "            return encoder\n",
        "```\n",
        "\n",
        "This means when you deploy your model, you can:\n",
        "1. Save all the preprocessing steps\n",
        "2. Load them in production\n",
        "3. Apply the exact same transformations to new data\n",
        "\n",
        "<a name=\"system-workflow\"></a>\n",
        "### System workflow\n",
        "\n",
        "Let's follow how ATLAS processes our housing data:\n",
        "\n",
        "1. **Initial split** (PreProcessor)\n",
        "   ```\n",
        "   Raw Data → Training Data (80%) + Test Data (20%)\n",
        "   ```\n",
        "   Test data remains locked away until final evaluation.\n",
        "\n",
        "2. **Cross-validation split** (CrossValidator)\n",
        "   ```\n",
        "   Training Data → 5 Folds\n",
        "   Each fold gets a turn as validation data\n",
        "   ```\n",
        "   This gives us reliable performance estimates.\n",
        "\n",
        "3. **Feature engineering** (FeatureEncoder)\n",
        "   ```\n",
        "   For each fold:\n",
        "      Create features using only training portion\n",
        "      Apply those features to validation portion\n",
        "   ```\n",
        "   This prevents data leakage while giving us multiple feature combinations to try.\n",
        "\n",
        "4. **Model training and evaluation**\n",
        "   ```\n",
        "   Cross-validation phase:\n",
        "     For each fold:\n",
        "         For each feature set:\n",
        "             For each model type:\n",
        "                 Train on fold training data\n",
        "                 Evaluate on fold validation data\n",
        "                 Record performance metrics\n",
        "\n",
        "   Final evaluation phase:\n",
        "     For best performing models:\n",
        "         Train on full training data\n",
        "         Evaluate on held-out test data\n",
        "\n",
        "   ```\n",
        "   This gives us comprehensive comparison results.\n",
        "\n",
        "<a name=\"key-challenges-solved\"></a>\n",
        "### Key challenges solved\n",
        "\n",
        "The architecture of ATLAS directly addresses common machine learning challenges:\n",
        "\n",
        "1. **The feature selection problem**\n",
        "   \n",
        "   Instead of guessing what drives house prices, ATLAS methodically evaluates all combinations of features across different models.\n",
        "\n",
        "2. **The reliability problem**\n",
        "   \n",
        "   Rather than trusting a single train/test split ATLAS uses cross-validation for robust estimates, maintaining a separate test set for final validation.\n",
        "\n",
        "3. **The leakage problem**\n",
        "\n",
        "   By encoding features separately for each fold, ATLAS ensures our models never see future price information during training.\n",
        "\n",
        "4. **The deployment problem**\n",
        "\n",
        "   All components can easily be extended to save their state, ensuring our deployed models use exactly the same transformations we tested.\n",
        "\n",
        "This systematic approach means our predictions are based on evidence, not intuition.\n",
        "\n",
        "\n",
        "### Next steps\n",
        "\n",
        "Now that we understand how ATLAS works, let's see what it reveals about London house prices. We'll:\n",
        "1. See ATLAS in action on real data\n",
        "2. Learn how to interpret its results\n",
        "3. Use those insights to choose the best model for our needs\n",
        "4. Discuss the real world implications of our models.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "I_BHS1Hk805K"
      },
      "source": [
        "<a name=\"atlas-implementation\"></a>\n",
        "## ATLAS implementation\n",
        "\n",
        "<a name=\"required-libraries\"></a>\n",
        "### Required libraries\n",
        "\n",
        "We'll use the following libraries to compare our decision trees - keeping it simple:\n",
        "\n",
        "| Library | Purpose |\n",
        "|---------|----------|\n",
        "| NumPy | Numerical computations and array operations |\n",
        "| Pandas | DataFrames, groupby |\n",
        "| sklearn.tree | Decision trees, feature importance |\n",
        "| sklearn.ensemble | Random forests, bagging, parallel training |\n",
        "| XGBoost | Gradient boosting, early stopping, GPU support |\n",
        "| sklearn.model_selection | Train-test split, cross-validation, parameter tuning |\n",
        "| sklearn.preprocessing | Feature encoding, scaling, pipelines |\n",
        "| sklearn.metrics | Error metrics, scoring, validation |\n",
        "| typing | Type hints, TypedDict |\n",
        "| dataclasses | Data structures, automated class creation |\n",
        "| pickle | Model saving/loading |\n",
        "| tqdm | Progress bars, ETA estimation |\n",
        "| IPython.display | Rich notebook output |\n",
        "\n",
        "\n",
        "#### Configuration\n",
        "- Fixed random seeds for reproducibility\n",
        "- Formatted DataFrame output\n",
        "- Full column visibility\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "cCMa72E8805K"
      },
      "outputs": [],
      "source": [
        "# Core data and analysis libraries\n",
        "import numpy as np                                     # For numerical computations and array operations\n",
        "import pandas as pd                                    # For data manipulation and analysis using DataFrames\n",
        "from typing import TypedDict\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "# Machine Learning Framework\n",
        "from sklearn.model_selection import (\n",
        "    train_test_split,                                 # Splits data into training and test sets\n",
        "    KFold,                                            # Performs k-fold cross-validation\n",
        ")\n",
        "\n",
        "from sklearn.preprocessing import (\n",
        "    OneHotEncoder                                     # Converts categorical variables into binary features\n",
        ")\n",
        "\n",
        "# Tree-based Models\n",
        "from sklearn.tree import DecisionTreeRegressor        # Basic decision tree implementation\n",
        "from sklearn.ensemble import RandomForestRegressor    # Ensemble of decision trees\n",
        "from xgboost import XGBRegressor                      # Gradient boosting implementation\n",
        "\n",
        "# Model Evaluation Metrics\n",
        "from sklearn.metrics import (\n",
        "    mean_absolute_error,                             # Measures average magnitude of prediction errors\n",
        "    r2_score,                                        # Measures proportion of variance explained by model\n",
        ")\n",
        "\n",
        "# Utilities and  infrastructure\n",
        "from typing import Dict, List, Tuple, Optional       # For type annotations\n",
        "from dataclasses import dataclass                    # For creating data classes\n",
        "import pickle                                        # For saving/loading objects\n",
        "from pathlib import Path\n",
        "\n",
        "# Progress Tracking\n",
        "from tqdm.notebook import tqdm                       # For displaying progress bars\n",
        "from IPython.display import display                  # For rich output in notebooks\n",
        "\n",
        "# Display Configuration\n",
        "pd.set_option('display.max_columns', None)           # Show all columns in DataFrames\n",
        "pd.set_option('display.float_format',                # Format floating point numbers to 2 decimal places\n",
        "              lambda x: '{:,.2f}'.format(x))\n",
        "\n",
        "# Reproducibility Settings\n",
        "RANDOM_STATE = 42                                    # Fixed seed for reproducible results\n",
        "np.random.seed(RANDOM_STATE)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAFPBAZT805L"
      },
      "source": [
        "<a name=\"data-loading-validation-and-featureset-dataclass\"></a>\n",
        "### Data loading, validation and FeatureSet dataclass"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 310
        },
        "id": "3O1SwLMH805L",
        "outputId": "ee506356-a3f8-46e4-ece3-eae1f164da88"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Data validation complete!\n",
            "Rows: 3480\n",
            "Price range: £180,000 - £39,750,000\n",
            "Area range: 274 - 15,405 sq ft\n",
            "Bedrooms range: 1 - 10\n",
            "Missing locations: 916\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "     Price        House Type  Area in sq ft  No. of Bedrooms     Location  \\\n",
              "0  1675000             House           2716                5    wimbledon   \n",
              "1   650000  Flat / Apartment            814                2  clerkenwell   \n",
              "2   735000  Flat / Apartment            761                2       putney   \n",
              "3  1765000             House           1986                4       putney   \n",
              "4   675000  Flat / Apartment            700                2       putney   \n",
              "\n",
              "  City/County Postal Code Outcode  \n",
              "0      london    SW19 8NY    SW19  \n",
              "1      london    EC1V 3PA    EC1V  \n",
              "2      london    SW15 1QL    SW15  \n",
              "3      london    SW15 1LP    SW15  \n",
              "4      london    SW15 1PL    SW15  "
            ],
            "text/html": [
              "\n",
              "  <div id=\"df-327c6485-28c1-4c82-b172-b020c557f69d\" class=\"colab-df-container\">\n",
              "    <div>\n",
              "<style scoped>\n",
              "    .dataframe tbody tr th:only-of-type {\n",
              "        vertical-align: middle;\n",
              "    }\n",
              "\n",
              "    .dataframe tbody tr th {\n",
              "        vertical-align: top;\n",
              "    }\n",
              "\n",
              "    .dataframe thead th {\n",
              "        text-align: right;\n",
              "    }\n",
              "</style>\n",
              "<table border=\"1\" class=\"dataframe\">\n",
              "  <thead>\n",
              "    <tr style=\"text-align: right;\">\n",
              "      <th></th>\n",
              "      <th>Price</th>\n",
              "      <th>House Type</th>\n",
              "      <th>Area in sq ft</th>\n",
              "      <th>No. of Bedrooms</th>\n",
              "      <th>Location</th>\n",
              "      <th>City/County</th>\n",
              "      <th>Postal Code</th>\n",
              "      <th>Outcode</th>\n",
              "    </tr>\n",
              "  </thead>\n",
              "  <tbody>\n",
              "    <tr>\n",
              "      <th>0</th>\n",
              "      <td>1675000</td>\n",
              "      <td>House</td>\n",
              "      <td>2716</td>\n",
              "      <td>5</td>\n",
              "      <td>wimbledon</td>\n",
              "      <td>london</td>\n",
              "      <td>SW19 8NY</td>\n",
              "      <td>SW19</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>1</th>\n",
              "      <td>650000</td>\n",
              "      <td>Flat / Apartment</td>\n",
              "      <td>814</td>\n",
              "      <td>2</td>\n",
              "      <td>clerkenwell</td>\n",
              "      <td>london</td>\n",
              "      <td>EC1V 3PA</td>\n",
              "      <td>EC1V</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>2</th>\n",
              "      <td>735000</td>\n",
              "      <td>Flat / Apartment</td>\n",
              "      <td>761</td>\n",
              "      <td>2</td>\n",
              "      <td>putney</td>\n",
              "      <td>london</td>\n",
              "      <td>SW15 1QL</td>\n",
              "      <td>SW15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>3</th>\n",
              "      <td>1765000</td>\n",
              "      <td>House</td>\n",
              "      <td>1986</td>\n",
              "      <td>4</td>\n",
              "      <td>putney</td>\n",
              "      <td>london</td>\n",
              "      <td>SW15 1LP</td>\n",
              "      <td>SW15</td>\n",
              "    </tr>\n",
              "    <tr>\n",
              "      <th>4</th>\n",
              "      <td>675000</td>\n",
              "      <td>Flat / Apartment</td>\n",
              "      <td>700</td>\n",
              "      <td>2</td>\n",
              "      <td>putney</td>\n",
              "      <td>london</td>\n",
              "      <td>SW15 1PL</td>\n",
              "      <td>SW15</td>\n",
              "    </tr>\n",
              "  </tbody>\n",
              "</table>\n",
              "</div>\n",
              "    <div class=\"colab-df-buttons\">\n",
              "\n",
              "  <div class=\"colab-df-container\">\n",
              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-327c6485-28c1-4c82-b172-b020c557f69d')\"\n",
              "            title=\"Convert this dataframe to an interactive table.\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
              "  </svg>\n",
              "    </button>\n",
              "\n",
              "  <style>\n",
              "    .colab-df-container {\n",
              "      display:flex;\n",
              "      gap: 12px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert {\n",
              "      background-color: #E8F0FE;\n",
              "      border: none;\n",
              "      border-radius: 50%;\n",
              "      cursor: pointer;\n",
              "      display: none;\n",
              "      fill: #1967D2;\n",
              "      height: 32px;\n",
              "      padding: 0 0 0 0;\n",
              "      width: 32px;\n",
              "    }\n",
              "\n",
              "    .colab-df-convert:hover {\n",
              "      background-color: #E2EBFA;\n",
              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "      fill: #174EA6;\n",
              "    }\n",
              "\n",
              "    .colab-df-buttons div {\n",
              "      margin-bottom: 4px;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert {\n",
              "      background-color: #3B4455;\n",
              "      fill: #D2E3FC;\n",
              "    }\n",
              "\n",
              "    [theme=dark] .colab-df-convert:hover {\n",
              "      background-color: #434B5C;\n",
              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
              "      fill: #FFFFFF;\n",
              "    }\n",
              "  </style>\n",
              "\n",
              "    <script>\n",
              "      const buttonEl =\n",
              "        document.querySelector('#df-327c6485-28c1-4c82-b172-b020c557f69d button.colab-df-convert');\n",
              "      buttonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "\n",
              "      async function convertToInteractive(key) {\n",
              "        const element = document.querySelector('#df-327c6485-28c1-4c82-b172-b020c557f69d');\n",
              "        const dataTable =\n",
              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
              "                                                    [key], {});\n",
              "        if (!dataTable) return;\n",
              "\n",
              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
              "          + ' to learn more about interactive tables.';\n",
              "        element.innerHTML = '';\n",
              "        dataTable['output_type'] = 'display_data';\n",
              "        await google.colab.output.renderOutput(dataTable, element);\n",
              "        const docLink = document.createElement('div');\n",
              "        docLink.innerHTML = docLinkHtml;\n",
              "        element.appendChild(docLink);\n",
              "      }\n",
              "    </script>\n",
              "  </div>\n",
              "\n",
              "\n",
              "<div id=\"df-9834d258-793d-49f2-8c10-99aed92ccaf0\">\n",
              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-9834d258-793d-49f2-8c10-99aed92ccaf0')\"\n",
              "            title=\"Suggest charts\"\n",
              "            style=\"display:none;\">\n",
              "\n",
              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
              "     width=\"24px\">\n",
              "    <g>\n",
              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
              "    </g>\n",
              "</svg>\n",
              "  </button>\n",
              "\n",
              "<style>\n",
              "  .colab-df-quickchart {\n",
              "      --bg-color: #E8F0FE;\n",
              "      --fill-color: #1967D2;\n",
              "      --hover-bg-color: #E2EBFA;\n",
              "      --hover-fill-color: #174EA6;\n",
              "      --disabled-fill-color: #AAA;\n",
              "      --disabled-bg-color: #DDD;\n",
              "  }\n",
              "\n",
              "  [theme=dark] .colab-df-quickchart {\n",
              "      --bg-color: #3B4455;\n",
              "      --fill-color: #D2E3FC;\n",
              "      --hover-bg-color: #434B5C;\n",
              "      --hover-fill-color: #FFFFFF;\n",
              "      --disabled-bg-color: #3B4455;\n",
              "      --disabled-fill-color: #666;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart {\n",
              "    background-color: var(--bg-color);\n",
              "    border: none;\n",
              "    border-radius: 50%;\n",
              "    cursor: pointer;\n",
              "    display: none;\n",
              "    fill: var(--fill-color);\n",
              "    height: 32px;\n",
              "    padding: 0;\n",
              "    width: 32px;\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart:hover {\n",
              "    background-color: var(--hover-bg-color);\n",
              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
              "    fill: var(--button-hover-fill-color);\n",
              "  }\n",
              "\n",
              "  .colab-df-quickchart-complete:disabled,\n",
              "  .colab-df-quickchart-complete:disabled:hover {\n",
              "    background-color: var(--disabled-bg-color);\n",
              "    fill: var(--disabled-fill-color);\n",
              "    box-shadow: none;\n",
              "  }\n",
              "\n",
              "  .colab-df-spinner {\n",
              "    border: 2px solid var(--fill-color);\n",
              "    border-color: transparent;\n",
              "    border-bottom-color: var(--fill-color);\n",
              "    animation:\n",
              "      spin 1s steps(1) infinite;\n",
              "  }\n",
              "\n",
              "  @keyframes spin {\n",
              "    0% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "      border-left-color: var(--fill-color);\n",
              "    }\n",
              "    20% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    30% {\n",
              "      border-color: transparent;\n",
              "      border-left-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    40% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-top-color: var(--fill-color);\n",
              "    }\n",
              "    60% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "    }\n",
              "    80% {\n",
              "      border-color: transparent;\n",
              "      border-right-color: var(--fill-color);\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "    90% {\n",
              "      border-color: transparent;\n",
              "      border-bottom-color: var(--fill-color);\n",
              "    }\n",
              "  }\n",
              "</style>\n",
              "\n",
              "  <script>\n",
              "    async function quickchart(key) {\n",
              "      const quickchartButtonEl =\n",
              "        document.querySelector('#' + key + ' button');\n",
              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
              "      try {\n",
              "        const charts = await google.colab.kernel.invokeFunction(\n",
              "            'suggestCharts', [key], {});\n",
              "      } catch (error) {\n",
              "        console.error('Error during call to suggestCharts:', error);\n",
              "      }\n",
              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
              "    }\n",
              "    (() => {\n",
              "      let quickchartButtonEl =\n",
              "        document.querySelector('#df-9834d258-793d-49f2-8c10-99aed92ccaf0 button');\n",
              "      quickchartButtonEl.style.display =\n",
              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
              "    })();\n",
              "  </script>\n",
              "</div>\n",
              "\n",
              "    </div>\n",
              "  </div>\n"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "dataframe",
              "summary": "{\n  \"name\": \"    description: str\",\n  \"rows\": 5,\n  \"fields\": [\n    {\n      \"column\": \"Price\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 567714,\n        \"min\": 650000,\n        \"max\": 1765000,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          650000,\n          675000,\n          735000\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"House Type\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 2,\n        \"samples\": [\n          \"Flat / Apartment\",\n          \"House\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Area in sq ft\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 910,\n        \"min\": 700,\n        \"max\": 2716,\n        \"num_unique_values\": 5,\n        \"samples\": [\n          814,\n          700\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"No. of Bedrooms\",\n      \"properties\": {\n        \"dtype\": \"number\",\n        \"std\": 1,\n        \"min\": 2,\n        \"max\": 5,\n        \"num_unique_values\": 3,\n        \"samples\": [\n          5,\n          2\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Location\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"wimbledon\",\n          \"clerkenwell\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"City/County\",\n      \"properties\": {\n        \"dtype\": \"category\",\n        \"num_unique_values\": 1,\n        \"samples\": [\n          \"london\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Postal Code\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 5,\n        \"samples\": [\n          \"EC1V 3PA\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    },\n    {\n      \"column\": \"Outcode\",\n      \"properties\": {\n        \"dtype\": \"string\",\n        \"num_unique_values\": 3,\n        \"samples\": [\n          \"SW19\"\n        ],\n        \"semantic_type\": \"\",\n        \"description\": \"\"\n      }\n    }\n  ]\n}"
            }
          },
          "metadata": {}
        }
      ],
      "source": [
        "def validate_housing_data(df: pd.DataFrame) -> None:\n",
        "    \"\"\"Validate housing data has correct columns and content\"\"\"\n",
        "    # Check required columns exist\n",
        "    required_columns = [\n",
        "        'Price', 'Area in sq ft', 'No. of Bedrooms',\n",
        "        'House Type', 'Outcode', 'Postal Code', 'Location', 'City/County'\n",
        "    ]\n",
        "\n",
        "    missing = set(required_columns) - set(df.columns)\n",
        "    if missing:\n",
        "        raise ValueError(f\"Missing columns: {missing}\")\n",
        "\n",
        "    # Basic data validation\n",
        "    if (df['Price'] <= 0).any():\n",
        "        raise ValueError(\"Found non-positive prices\")\n",
        "\n",
        "    if (df['Area in sq ft'] <= 0).any():\n",
        "        raise ValueError(\"Found non-positive areas\")\n",
        "\n",
        "    if ((df['No. of Bedrooms'] <= 0) | (df['No. of Bedrooms'] > 20)).any():\n",
        "        raise ValueError(\"Invalid number of bedrooms\")\n",
        "\n",
        "    # Print summary\n",
        "    print(\"Data validation complete!\")\n",
        "    print(f\"Rows: {len(df)}\")\n",
        "    print(f\"Price range: £{df['Price'].min():,.0f} - £{df['Price'].max():,.0f}\")\n",
        "    print(f\"Area range: {df['Area in sq ft'].min():,.0f} - {df['Area in sq ft'].max():,.0f} sq ft\")\n",
        "    print(f\"Bedrooms range: {df['No. of Bedrooms'].min()} - {df['No. of Bedrooms'].max()}\")\n",
        "    print(f\"Missing locations: {df['Location'].isnull().sum()}\")\n",
        "\n",
        "# Load and validate data\n",
        "# df_with_outcode = pd.read_csv('../data/df_with_outcode.csv')\n",
        "url = \"https://raw.githubusercontent.com/powell-clark/supervised-machine-learning/main/data/df_with_outcode.csv\"\n",
        "df_with_outcode = pd.read_csv(url)\n",
        "\n",
        "validate_housing_data(df_with_outcode)\n",
        "display(df_with_outcode.head())\n",
        "\n",
        "@dataclass\n",
        "class FeatureSet:\n",
        "    X_train: pd.DataFrame\n",
        "    X_val: pd.DataFrame\n",
        "    y_train: pd.Series\n",
        "    y_val: pd.Series\n",
        "    name: str\n",
        "    description: str"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J05xrGxJ805M"
      },
      "source": [
        "<a name=\"preprocessor\"></a>\n",
        "### PreProcessor\n",
        "\n",
        "Building on Lesson 2B's exploration of model evaluation, we learned that proper model evaluation requires careful data splitting. Since house prices follow a highly skewed distribution, we need to ensure our train and test sets have similar price distributions.\n",
        "\n",
        "The PreProcessor class exists to:\n",
        "\n",
        "- Add transformations before modeling, in this case transforming price to log price\n",
        "- Create price bands for stratification using log-transformed prices\n",
        "- Perform stratified train/test splits that preserve the price distribution\n",
        "- Provide a foundation for any future preprocessing needs\n",
        "\n",
        "#### Input Requirements\n",
        "The DataFrame must already be a clean dataset of features ready for modeling"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_YI_zuIC805M",
        "outputId": "ed09a212-3012-4e30-e133-eb604948f5c2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "PreProcessor class loaded successfully!\n"
          ]
        }
      ],
      "source": [
        "class PreProcessor:\n",
        "    \"\"\"Handles initial data transformations and train/test splitting\"\"\"\n",
        "\n",
        "    def __init__(self, random_state: int = RANDOM_STATE):\n",
        "        self.random_state = random_state\n",
        "\n",
        "    def prepare_pre_split_features(self, df: pd.DataFrame) -> pd.DataFrame:\n",
        "        \"\"\"Creates features that must be calculated before train/test split\"\"\"\n",
        "        df_processed = df.copy()\n",
        "\n",
        "        # Add log-transformed price\n",
        "        df_processed['log_price'] = np.log(df_processed['Price'])\n",
        "\n",
        "        # Create price bands for stratification\n",
        "        df_processed['price_band'] = pd.qcut(df_processed['log_price'], q=10, labels=False)\n",
        "\n",
        "        return df_processed\n",
        "\n",
        "    def create_train_test_split(self, df: pd.DataFrame) -> Tuple[pd.DataFrame, pd.DataFrame]:\n",
        "        \"\"\"Performs stratified train/test split using price bands\"\"\"\n",
        "        train_data, test_data = train_test_split(\n",
        "            df,\n",
        "            test_size=0.2,\n",
        "            stratify=df['price_band'],\n",
        "            random_state=self.random_state\n",
        "        )\n",
        "\n",
        "        return train_data, test_data\n",
        "\n",
        "print(\"PreProcessor class loaded successfully!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jx7oz61e805N"
      },
      "source": [
        "<a name=\"featureencoder-encoderstate-and-persistence\"></a>\n",
        "### FeatureEncoder, EncoderState and persistence\n",
        "\n",
        "Our FeatureEncoder solves several core challenges in house price prediction:\n",
        "1. Converting raw data into model-ready features without data leakage\n",
        "2. Engineering rich location-based price signals while preserving validation integrity\n",
        "3. Generation of multiple feature combinations\n",
        "4. Consistent handling of training, validation, and test data\n",
        "\n",
        "#### Core Design\n",
        "The encoder uses two key components for state management:\n",
        "\n",
        "```python\n",
        "@dataclass\n",
        "class EncoderState:\n",
        "    \"\"\"State container for FeatureEncoder persistence\"\"\"\n",
        "    # Parameters\n",
        "    smoothing_factor: int\n",
        "    min_location_freq: int\n",
        "    random_state: int\n",
        "    \n",
        "    # Fitted encoders\n",
        "    house_encoder: Optional[OneHotEncoder] = None\n",
        "    city_country_encoder: Optional[OneHotEncoder] = None\n",
        "    outcode_encoder: Optional[OneHotEncoder] = None\n",
        "    \n",
        "    # Geographic statistics\n",
        "    outcode_means: Optional[Dict[str, float]] = None\n",
        "    outcode_global_mean: Optional[float] = None\n",
        "    postcode_means: Optional[Dict[str, float]] = None\n",
        "    postcode_counts: Optional[Dict[str, int]] = None\n",
        "    location_means: Optional[Dict[str, float]] = None\n",
        "    location_counts: Optional[Dict[str, int]] = None\n",
        "    price_per_sqft_means: Optional[Dict[str, float]] = None\n",
        "    price_per_sqft_global_mean: Optional[float] = None\n",
        "```\n",
        "\n",
        "This state container:\n",
        "\n",
        "- Tracks all parameters needed for feature engineering\n",
        "- Stores fitted encoders for categorical variables\n",
        "- Maintains geographic price statistics at each level\n",
        "- Enables full reproducibility in production\n",
        "\n",
        "#### Geographic encoding: A three-level challenge\n",
        "\n",
        "Our housing's location data has a natural hierarchy:\n",
        "```\n",
        "Outcode (e.g., \"SW1\")\n",
        "   ↓\n",
        "Postal Code (e.g., \"SW1A 1AA\")\n",
        "   ↓\n",
        "Location (e.g., \"Buckingham Palace\")\n",
        "```\n",
        "\n",
        "Each level presents a tradeoff between specificity and data availability.  The encoder handles each through:\n",
        "\n",
        "#### 1. Outcode level (primary signal)\n",
        "```python\n",
        "def _encode_outcode_target(self, train_data, eval_data):\n",
        "    if 'cv_fold' in train_data.columns:  # Cross-validation mode\n",
        "        oof_predictions = pd.Series(index=train_data.index)\n",
        "        for train_idx, val_idx in kf.split(train_data):\n",
        "            inner_train = train_data.iloc[train_idx]\n",
        "            outcode_means = inner_train.groupby('Outcode')['log_price'].mean()\n",
        "            oof_predictions.iloc[val_idx] = val_data['Outcode'].map(outcode_means)\n",
        "    else:  # Test/Production mode\n",
        "        outcode_means = train_data.groupby('Outcode')['log_price'].mean()\n",
        "        encoded = eval_data['Outcode'].map(outcode_means)\n",
        "```\n",
        "- Most robust due to larger sample sizes\n",
        "- Different logic for CV vs test/production predictions\n",
        "- Handles unseen outcodes via global mean\n",
        "\n",
        "#### 2. Postal code level (more granular)\n",
        "```python\n",
        "def _encode_postcode_target(self, fold_train, fold_val, outcode_encoding):\n",
        "    counts = fold_train['Postal Code'].value_counts()\n",
        "    means = fold_train.groupby('Postal Code')['log_price'].mean()\n",
        "    \n",
        "    # Bayesian-style smoothing\n",
        "    weight = counts / (counts + self.smoothing_factor)\n",
        "    encoded = weight * means + (1 - weight) * outcode_encoding\n",
        "```\n",
        "- Adaptive trust in local estimates\n",
        "- Smoothing against outcode baseline\n",
        "- Handles data sparsity gracefully\n",
        "\n",
        "#### 3. Location level (maximum detail)\n",
        "```python\n",
        "def _encode_location_target(self, fold_train, fold_val, postcode_encoding):\n",
        "    counts = fold_train['Location'].value_counts()\n",
        "    means = fold_train.groupby('Location')['log_price'].mean()\n",
        "    \n",
        "    # Handle rare locations\n",
        "    low_freq_mask = (counts < self.min_location_freq)\n",
        "    encoded[low_freq_mask] = postcode_encoding[low_freq_mask]\n",
        "```\n",
        "- Falls back to postal code for rare locations\n",
        "- Minimum frequency threshold prevents unstable estimates\n",
        "- Preserves granular information where reliable\n",
        "\n",
        "#### Cross-validation safety mechanisms\n",
        "\n",
        "The encoder implements three critical safeguards:\n",
        "\n",
        "1. **Out-of-fold encoding**\n",
        "```python\n",
        "for train_idx, val_idx in kf.split(train_data):\n",
        "    # Encode validation using only training data\n",
        "    inner_train = train_data.iloc[train_idx]\n",
        "    inner_val = train_data.iloc[val_idx]\n",
        "    encoded = encode_features(inner_train, inner_val)\n",
        "```\n",
        "- Prevents target leakage during model selection\n",
        "- Maintains fold independence\n",
        "- Mimics real-world information availability\n",
        "\n",
        "2. **Test set handling**\n",
        "```python\n",
        "if is_test_set:\n",
        "    # Use all training data for stable estimates\n",
        "    means = full_training_data.groupby('Location')['log_price'].mean()\n",
        "    encoded = test_data['Location'].map(means).fillna(global_mean)\n",
        "```\n",
        "- Maximises encoding stability for final evaluation\n",
        "- Uses full training data appropriately\n",
        "- Ready for production use\n",
        "\n",
        "3. **Hierarchical fallbacks**\n",
        "```python\n",
        "def encode_location(self, data, means, fallback):\n",
        "    encoded = data.map(means)\n",
        "    return encoded.fillna(fallback)  # Use broader geography when needed\n",
        "```\n",
        "- Systematic fallback chain\n",
        "- No missing values possible\n",
        "- Maintains encoding stability\n",
        "\n",
        "\n",
        "#### Usage patterns\n",
        "\n",
        "There are two distinct flows for training and production:\n",
        "\n",
        "```python\n",
        "# Training flow (fresh encoding per fold)\n",
        "encoder = FeatureEncoder()\n",
        "feature_sets = encoder.create_fold_features(fold_train, fold_val)\n",
        "\n",
        "# Production flow (saved state)\n",
        "encoder.fit(full_training_data)  # fit once\n",
        "encoder.save('encoder.pkl')      # save state\n",
        "loaded_encoder = FeatureEncoder.load('encoder.pkl')  # load in production\n",
        "features = loaded_encoder.create_production_features(new_data)\n",
        "```\n",
        "\n",
        "#### Feature generation\n",
        "\n",
        "The encoder creates systematic feature combinations:\n",
        "\n",
        "1. **Base features**\n",
        "```python\n",
        "{\n",
        "    'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "    'house': None,\n",
        "    'city': None,\n",
        "    'geo_target': None,\n",
        "    'geo_onehot': None,\n",
        "    'price_sqft': None\n",
        "}\n",
        "```\n",
        "\n",
        "2. **Single feature additions**\n",
        "```python\n",
        "{\n",
        "    'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "    'house': house_features,  # or city_features\n",
        "    'city': None,\n",
        "    'geo_target': None\n",
        "}\n",
        "```\n",
        "\n",
        "3. **Geographic features**\n",
        "```python\n",
        "{\n",
        "    'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "    'geo_target': {\n",
        "        'outcode': outcode_target_hierarchical,\n",
        "        'postcode': postcode_target_hierarchical,\n",
        "        'location': location_target_hierarchical\n",
        "    }\n",
        "}\n",
        "```\n",
        "\n",
        "4. **Progressive combinations**\n",
        "```python\n",
        "{\n",
        "    'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "    'house': house_features,\n",
        "    'city': city_country_features,\n",
        "    'geo_target': {'outcode': outcode_target_hierarchical},\n",
        "    'price_sqft': outcode_price_per_sqft\n",
        "}\n",
        "```\n",
        "\n",
        "#### Why this architecture succeeds\n",
        "\n",
        "1. **Statistical safety**\n",
        "   - Fresh encodings prevent leakage during CV\n",
        "   - Smart hierarchical fallbacks are able to handle data sparsity\n",
        "   - Systematic feature combinations enable thorough comparison\n",
        "\n",
        "2. **Engineering quality**\n",
        "   - Clear separation of training/production flows\n",
        "   - Robust error handling\n",
        "   - Well-documented assumptions\n",
        "\n",
        "3. **Production ready**\n",
        "   - Complete state persistence\n",
        "   - Consistent feature generation\n",
        "   - Simple deployment process\n",
        "\n",
        "This FeatureEncoder provides both rigorous cross-validation safety during training and smooth deployment to production, without compromising on either goal."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "l_ingkn9BY2O"
      },
      "outputs": [],
      "source": [
        "@dataclass\n",
        "class EncoderState:\n",
        "    \"\"\"State container for FeatureEncoder persistence\"\"\"\n",
        "    # Parameters\n",
        "    smoothing_factor: int\n",
        "    min_location_freq: int\n",
        "    random_state: int\n",
        "\n",
        "    # Fitted encoders\n",
        "    house_encoder: Optional[OneHotEncoder] = None\n",
        "    city_country_encoder: Optional[OneHotEncoder] = None\n",
        "    outcode_encoder: Optional[OneHotEncoder] = None\n",
        "\n",
        "    # Geographic statistics\n",
        "    outcode_means: Optional[Dict[str, float]] = None\n",
        "    outcode_global_mean: Optional[float] = None\n",
        "    postcode_means: Optional[Dict[str, float]] = None\n",
        "    postcode_counts: Optional[Dict[str, int]] = None\n",
        "    location_means: Optional[Dict[str, float]] = None\n",
        "    location_counts: Optional[Dict[str, int]] = None\n",
        "    price_per_sqft_means: Optional[Dict[str, float]] = None\n",
        "    price_per_sqft_global_mean: Optional[float] = None\n",
        "\n",
        "\n",
        "class FeatureEncoder:\n",
        "    \"\"\"Handles all feature engineering and encoding with fold awareness and persistence\"\"\"\n",
        "\n",
        "    def __init__(self, smoothing_factor: int = 10, min_location_freq: int = 5, random_state: int = 42):\n",
        "        self.smoothing_factor = smoothing_factor\n",
        "        self.min_location_freq = min_location_freq\n",
        "        self.random_state = random_state\n",
        "        self.state = EncoderState(\n",
        "            smoothing_factor=smoothing_factor,\n",
        "            min_location_freq=min_location_freq,\n",
        "            random_state=random_state\n",
        "        )\n",
        "\n",
        "    def _calculate_outcode_price_per_sqft(self,\n",
        "                                        fold_train: pd.DataFrame,\n",
        "                                        fold_val: pd.DataFrame) -> Dict[str, pd.Series]:\n",
        "        \"\"\"\n",
        "        Calculate mean price per square foot using out-of-fold means for outcodes\n",
        "\n",
        "        Args:\n",
        "            fold_train: Training data for current fold\n",
        "            fold_val: Validation data for current fold\n",
        "\n",
        "        Returns:\n",
        "            Dictionary containing train and validation series of outcode mean price per sqft\n",
        "        \"\"\"\n",
        "        # Initialise empty series for OOF predictions\n",
        "        oof_price_per_sqft = pd.Series(index=fold_train.index, dtype='float64')\n",
        "\n",
        "        # Calculate OOF means for training data\n",
        "        kf = KFold(n_splits=5, shuffle=True, random_state=self.random_state)\n",
        "        for train_idx, val_idx in kf.split(fold_train):\n",
        "            inner_train = fold_train.iloc[train_idx]\n",
        "            inner_val = fold_train.iloc[val_idx]\n",
        "\n",
        "            # Calculate price per sqft for inner training set\n",
        "            inner_price_per_sqft = inner_train['Price'] / inner_train['Area in sq ft']\n",
        "            outcode_means = inner_price_per_sqft.groupby(inner_train['Outcode']).mean()\n",
        "            global_mean = inner_price_per_sqft.mean()\n",
        "\n",
        "            # Apply to inner validation set\n",
        "            oof_price_per_sqft.iloc[val_idx] = (\n",
        "                inner_val['Outcode']\n",
        "                .map(outcode_means)\n",
        "                .fillna(global_mean)\n",
        "            )\n",
        "\n",
        "        # Calculate means for validation data using full training set\n",
        "        train_price_per_sqft = fold_train['Price'] / fold_train['Area in sq ft']\n",
        "        outcode_means = train_price_per_sqft.groupby(fold_train['Outcode']).mean()\n",
        "        global_mean = train_price_per_sqft.mean()\n",
        "\n",
        "        val_price_per_sqft = (\n",
        "            fold_val['Outcode']\n",
        "            .map(outcode_means)\n",
        "            .fillna(global_mean)\n",
        "        )\n",
        "\n",
        "        return {\n",
        "            'train': oof_price_per_sqft,\n",
        "            'val': val_price_per_sqft\n",
        "        }\n",
        "\n",
        "    def _encode_house_type(self,\n",
        "                          fold_train: pd.DataFrame,\n",
        "                          fold_val: pd.DataFrame) -> Dict[str, pd.DataFrame]:\n",
        "        \"\"\"Create one-hot encoding for house type\"\"\"\n",
        "        # Initialise encoder for this fold\n",
        "        house_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "\n",
        "        # Fit on fold's training data\n",
        "        train_encoded = pd.DataFrame(\n",
        "            house_encoder.fit_transform(fold_train[['House Type']]),\n",
        "            columns=house_encoder.get_feature_names_out(['House Type']),\n",
        "            index=fold_train.index\n",
        "        )\n",
        "\n",
        "        # Transform validation data\n",
        "        val_encoded = pd.DataFrame(\n",
        "            house_encoder.transform(fold_val[['House Type']]),\n",
        "            columns=house_encoder.get_feature_names_out(['House Type']),\n",
        "            index=fold_val.index\n",
        "        )\n",
        "\n",
        "        return {\n",
        "            'train': train_encoded,\n",
        "            'val': val_encoded\n",
        "        }\n",
        "\n",
        "    def _encode_city_country(self,\n",
        "                           fold_train: pd.DataFrame,\n",
        "                           fold_val: pd.DataFrame) -> Dict[str, pd.DataFrame]:\n",
        "        \"\"\"Create one-hot encoding for city/county\"\"\"\n",
        "        # Initialise encoder for this fold\n",
        "        city_country_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "\n",
        "        # Fit on fold's training data\n",
        "        train_encoded = pd.DataFrame(\n",
        "            city_country_encoder.fit_transform(fold_train[['City/County']]),\n",
        "            columns=city_country_encoder.get_feature_names_out(['City/County']),\n",
        "            index=fold_train.index\n",
        "        )\n",
        "\n",
        "        # Transform validation data\n",
        "        val_encoded = pd.DataFrame(\n",
        "            city_country_encoder.transform(fold_val[['City/County']]),\n",
        "            columns=city_country_encoder.get_feature_names_out(['City/County']),\n",
        "            index=fold_val.index\n",
        "        )\n",
        "\n",
        "        return {\n",
        "            'train': train_encoded,\n",
        "            'val': val_encoded\n",
        "        }\n",
        "\n",
        "    def _encode_outcode_onehot(self,\n",
        "                              fold_train: pd.DataFrame,\n",
        "                              fold_val: pd.DataFrame) -> Dict[str, pd.DataFrame]:\n",
        "        \"\"\"Create one-hot encoding for outcodes\"\"\"\n",
        "        outcode_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "\n",
        "        train_encoded = pd.DataFrame(\n",
        "            outcode_encoder.fit_transform(fold_train[['Outcode']]),\n",
        "            columns=outcode_encoder.get_feature_names_out(['Outcode']),\n",
        "            index=fold_train.index\n",
        "        )\n",
        "\n",
        "        val_encoded = pd.DataFrame(\n",
        "            outcode_encoder.transform(fold_val[['Outcode']]),\n",
        "            columns=outcode_encoder.get_feature_names_out(['Outcode']),\n",
        "            index=fold_val.index\n",
        "        )\n",
        "\n",
        "        return {\n",
        "            'train': train_encoded,\n",
        "            'val': val_encoded\n",
        "        }\n",
        "\n",
        "    def _encode_outcode_postcode_location_target_hierarchical(self,\n",
        "                                                            fold_train: pd.DataFrame,\n",
        "                                                            fold_val: pd.DataFrame\n",
        "                                                            ) -> Tuple[Dict[str, pd.Series],\n",
        "                                                                     Dict[str, pd.Series],\n",
        "                                                                     Dict[str, pd.Series]]:\n",
        "        \"\"\"\n",
        "        Create hierarchical target encoding for geographic features:\n",
        "        - Outcode encoding\n",
        "        - Postcode encoding using outcode as prior\n",
        "        - Location encoding using postcode as prior\n",
        "\n",
        "        Returns:\n",
        "            Tuple of (outcode_encoding, postcode_encoding, location_encoding)\n",
        "        \"\"\"\n",
        "        # 1. Outcode encoding\n",
        "        outcode_encoding = self._encode_outcode_target(fold_train, fold_val)\n",
        "\n",
        "        # 2. Postcode encoding using outcode as prior\n",
        "        postcode_encoding = self._encode_postcode_target(\n",
        "            fold_train,\n",
        "            fold_val,\n",
        "            outcode_encoding\n",
        "        )\n",
        "\n",
        "        # 3. Location encoding using postcode as prior\n",
        "        location_encoding = self._encode_location_target(\n",
        "            fold_train,\n",
        "            fold_val,\n",
        "            postcode_encoding\n",
        "        )\n",
        "\n",
        "        return outcode_encoding, postcode_encoding, location_encoding\n",
        "\n",
        "    def _encode_outcode_target(self,\n",
        "                             train_data: pd.DataFrame,\n",
        "                             eval_data: pd.DataFrame) -> Dict[str, pd.Series]:\n",
        "        \"\"\"Create target encoding for outcodes\"\"\"\n",
        "        if 'cv_fold' in train_data.columns:  # We're in cross-validation\n",
        "            # Use out-of-fold encoding for training data\n",
        "            oof_predictions = pd.Series(index=train_data.index, dtype='float64')\n",
        "\n",
        "            kf = KFold(n_splits=5, shuffle=True, random_state=self.random_state)\n",
        "            for inner_train_idx, inner_val_idx in kf.split(train_data):\n",
        "                inner_train = train_data.iloc[inner_train_idx]\n",
        "                inner_val = train_data.iloc[inner_val_idx]\n",
        "\n",
        "                outcode_means = inner_train.groupby('Outcode')['log_price'].mean()\n",
        "                global_mean = inner_train['log_price'].mean()\n",
        "\n",
        "                oof_predictions.iloc[inner_val_idx] = (\n",
        "                    inner_val['Outcode']\n",
        "                    .map(outcode_means)\n",
        "                    .fillna(global_mean)\n",
        "                )\n",
        "\n",
        "            # For validation data, use means from all training data\n",
        "            outcode_means = train_data.groupby('Outcode')['log_price'].mean()\n",
        "            global_mean = train_data['log_price'].mean()\n",
        "\n",
        "            val_encoded = (\n",
        "                eval_data['Outcode']\n",
        "                .map(outcode_means)\n",
        "                .fillna(global_mean)\n",
        "            )\n",
        "\n",
        "            return {\n",
        "                'train': oof_predictions,\n",
        "                'val': val_encoded\n",
        "            }\n",
        "\n",
        "        else:  # We're encoding for the test set\n",
        "            # Use all training data to encode test set\n",
        "            outcode_means = train_data.groupby('Outcode')['log_price'].mean()\n",
        "            global_mean = train_data['log_price'].mean()\n",
        "\n",
        "            test_encoded = (\n",
        "                eval_data['Outcode']\n",
        "                .map(outcode_means)\n",
        "                .fillna(global_mean)\n",
        "            )\n",
        "\n",
        "            return {\n",
        "                'train': train_data['Outcode'].map(outcode_means).fillna(global_mean),\n",
        "                'val': test_encoded\n",
        "            }\n",
        "\n",
        "    def _encode_postcode_target(self,\n",
        "                              fold_train: pd.DataFrame,\n",
        "                              fold_val: pd.DataFrame,\n",
        "                              outcode_encoding: Dict[str, pd.Series]) -> Dict[str, pd.Series]:\n",
        "        \"\"\"Create hierarchical encoding for postcodes using outcode prior\"\"\"\n",
        "        postcode_means = fold_train.groupby('Postal Code')['log_price'].mean()\n",
        "        postcode_counts = fold_train['Postal Code'].value_counts()\n",
        "\n",
        "        def encode_postcodes(df: pd.DataFrame, outcode_encoded: pd.Series) -> pd.Series:\n",
        "            counts = df['Postal Code'].map(postcode_counts)\n",
        "            means = df['Postal Code'].map(postcode_means)\n",
        "\n",
        "            # Handle unseen categories using outcode encoding\n",
        "            means = means.fillna(outcode_encoded)\n",
        "            counts = counts.fillna(0)\n",
        "\n",
        "            # Calculate smoothed values\n",
        "            weight = counts / (counts + self.smoothing_factor)\n",
        "            return weight * means + (1 - weight) * outcode_encoded\n",
        "\n",
        "        return {\n",
        "            'train': encode_postcodes(fold_train, outcode_encoding['train']),\n",
        "            'val': encode_postcodes(fold_val, outcode_encoding['val'])\n",
        "        }\n",
        "\n",
        "    def _encode_location_target(self,\n",
        "                              fold_train: pd.DataFrame,\n",
        "                              fold_val: pd.DataFrame,\n",
        "                              postcode_encoding: Dict[str, pd.Series]) -> Dict[str, pd.Series]:\n",
        "        \"\"\"Create hierarchical encoding for locations using postcode prior\"\"\"\n",
        "        location_means = fold_train.groupby('Location')['log_price'].mean()\n",
        "        location_counts = fold_train['Location'].value_counts()\n",
        "\n",
        "        def encode_locations(df: pd.DataFrame, postcode_encoded: pd.Series) -> pd.Series:\n",
        "            counts = df['Location'].map(location_counts)\n",
        "            means = df['Location'].map(location_means)\n",
        "\n",
        "            # Handle missing and unseen locations using postcode encoding\n",
        "            means = means.fillna(postcode_encoded)\n",
        "            counts = counts.fillna(0)\n",
        "\n",
        "            # Use postcode encoding for low-frequency locations\n",
        "            low_freq_mask = (counts < self.min_location_freq) | counts.isna()\n",
        "\n",
        "            # Calculate smoothed values\n",
        "            weight = counts / (counts + self.smoothing_factor)\n",
        "            encoded = weight * means + (1 - weight) * postcode_encoded\n",
        "\n",
        "            # Replace low frequency locations with postcode encoding\n",
        "            encoded[low_freq_mask] = postcode_encoded[low_freq_mask]\n",
        "\n",
        "            return encoded\n",
        "\n",
        "        return {\n",
        "            'train': encode_locations(fold_train, postcode_encoding['train']),\n",
        "            'val': encode_locations(fold_val, postcode_encoding['val'])\n",
        "        }\n",
        "\n",
        "    def create_fold_features(self, fold_train: pd.DataFrame, fold_val: pd.DataFrame) -> List[FeatureSet]:\n",
        "        \"\"\"Create all feature set variations for a fold\"\"\"\n",
        "\n",
        "        house_features = self._encode_house_type(fold_train, fold_val)\n",
        "        city_country_features = self._encode_city_country(fold_train, fold_val)\n",
        "\n",
        "        # Exploded geographic features with hierarchical encoding\n",
        "        outcode_target_hierarchical, postcode_target_hierarchical, location_target_hierarchical = (\n",
        "            self._encode_outcode_postcode_location_target_hierarchical(fold_train, fold_val)\n",
        "        )\n",
        "\n",
        "        outcode_onehot = self._encode_outcode_onehot(fold_train, fold_val)\n",
        "        outcode_price_per_sqft = self._calculate_outcode_price_per_sqft(fold_train, fold_val)\n",
        "\n",
        "        feature_combinations = [\n",
        "            # Base features\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms'\n",
        "            },\n",
        "            # Single feature additions\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': house_features,\n",
        "                'city': None,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_house',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, House Type'\n",
        "            },\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': city_country_features,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_city',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, City/County'\n",
        "            },\n",
        "            # Individual geographic features - Target encoded\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {'outcode': outcode_target_hierarchical},\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_outcode_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Outcode (Target)'\n",
        "            },\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {'postcode': postcode_target_hierarchical},\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_postcode_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Postcode (Target)'\n",
        "            },\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {'location': location_target_hierarchical},\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_location_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Location (Target)'\n",
        "            },\n",
        "            # One-hot encoded outcode\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': {'outcode': outcode_onehot},\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_outcode_onehot',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Outcode (One-hot)'\n",
        "            },\n",
        "            # Price per square foot\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': outcode_price_per_sqft,\n",
        "                'name': 'area_bedrooms_pricesqft',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Price/sqft'\n",
        "            },\n",
        "            # Two feature combinations\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': house_features,\n",
        "                'city': city_country_features,\n",
        "                'geo_target': None,\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_house_city',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, House Type, City/County'\n",
        "            },\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {\n",
        "                    'outcode': outcode_target_hierarchical,\n",
        "                    'postcode': postcode_target_hierarchical\n",
        "                },\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_outcode_postcode_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Outcode & Postcode (Target)'\n",
        "            },\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {\n",
        "                    'postcode': postcode_target_hierarchical,\n",
        "                    'location': location_target_hierarchical\n",
        "                },\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_postcode_location_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, Postcode & Location (Target)'\n",
        "            },\n",
        "            # Three feature combinations\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': house_features,\n",
        "                'city': city_country_features,\n",
        "                'geo_target': {'outcode': outcode_target_hierarchical},\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_house_city_outcode_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, House Type, City/County, Outcode (Target)'\n",
        "            },\n",
        "            # All geographic features\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': None,\n",
        "                'city': None,\n",
        "                'geo_target': {\n",
        "                    'outcode': outcode_target_hierarchical,\n",
        "                    'postcode': postcode_target_hierarchical,\n",
        "                    'location': location_target_hierarchical\n",
        "                },\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': None,\n",
        "                'name': 'area_bedrooms_all_geo_target',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, All Geographic Features (Target)'\n",
        "            },\n",
        "            # Complex combinations\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': house_features,\n",
        "                'city': None,\n",
        "                'geo_target': {'outcode': outcode_target_hierarchical},\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': outcode_price_per_sqft,\n",
        "                'name': 'area_bedrooms_house_outcode_target_pricesqft',\n",
        "                'desc': 'Area in sq ft, No. of Bedrooms, House Type, Outcode (Target), Price/sqft'\n",
        "            },\n",
        "            # All features\n",
        "            {\n",
        "                'numeric': ['Area in sq ft', 'No. of Bedrooms'],\n",
        "                'house': house_features,\n",
        "                'city': city_country_features,\n",
        "                'geo_target': {\n",
        "                    'outcode': outcode_target_hierarchical,\n",
        "                    'postcode': postcode_target_hierarchical,\n",
        "                    'location': location_target_hierarchical\n",
        "                },\n",
        "                'geo_onehot': None,\n",
        "                'price_sqft': outcode_price_per_sqft,\n",
        "                'name': 'all_features',\n",
        "                'desc': 'All Features Combined'\n",
        "            }\n",
        "        ]\n",
        "\n",
        "        return [self._combine_features(\n",
        "            fold_train,\n",
        "            fold_val,\n",
        "            combo['numeric'],\n",
        "            combo['house'],\n",
        "            combo['city'],\n",
        "            combo['geo_target'],\n",
        "            combo['geo_onehot'],\n",
        "            combo['price_sqft'],\n",
        "            combo['name'],\n",
        "            combo['desc']\n",
        "        ) for combo in feature_combinations]\n",
        "\n",
        "    def _combine_features(self,\n",
        "                         fold_train: pd.DataFrame,\n",
        "                         fold_val: pd.DataFrame,\n",
        "                         base_numeric: List[str],\n",
        "                         house_features: Optional[Dict[str, pd.DataFrame]],\n",
        "                         city_country_features: Optional[Dict[str, pd.DataFrame]],\n",
        "                         geo_target_features: Optional[Dict[str, Dict[str, pd.Series]]],\n",
        "                         geo_onehot_features: Optional[Dict[str, Dict[str, pd.DataFrame]]],\n",
        "                         price_sqft_features: Optional[Dict[str, pd.Series]],\n",
        "                         name: str,\n",
        "                         description: str) -> FeatureSet:\n",
        "        \"\"\"\n",
        "        Combine different feature types into a single feature set\n",
        "        \"\"\"\n",
        "        # Start with base numeric features\n",
        "        X_train = fold_train[base_numeric].copy()\n",
        "        X_val = fold_val[base_numeric].copy()\n",
        "\n",
        "        # Add house type features if provided\n",
        "        if house_features:\n",
        "            X_train = pd.concat([X_train, house_features['train']], axis=1)\n",
        "            X_val = pd.concat([X_val, house_features['val']], axis=1)\n",
        "\n",
        "        # Add city/country features if provided\n",
        "        if city_country_features:\n",
        "            X_train = pd.concat([X_train, city_country_features['train']], axis=1)\n",
        "            X_val = pd.concat([X_val, city_country_features['val']], axis=1)\n",
        "\n",
        "        # Add target-encoded geographic features if provided\n",
        "        if geo_target_features:\n",
        "            for feature_name, feature_dict in geo_target_features.items():\n",
        "                X_train[feature_name] = feature_dict['train']\n",
        "                X_val[feature_name] = feature_dict['val']\n",
        "\n",
        "        # Add one-hot encoded geographic features if provided\n",
        "        if geo_onehot_features:\n",
        "            for feature_name, feature_dict in geo_onehot_features.items():\n",
        "                X_train = pd.concat([X_train, feature_dict['train']], axis=1)\n",
        "                X_val = pd.concat([X_val, feature_dict['val']], axis=1)\n",
        "\n",
        "        # Add price per square foot features if provided\n",
        "        if price_sqft_features:\n",
        "            X_train['outcode_price_per_sqft'] = price_sqft_features['train']\n",
        "            X_val['outcode_price_per_sqft'] = price_sqft_features['val']\n",
        "\n",
        "        return FeatureSet(\n",
        "            X_train=X_train,\n",
        "            X_val=X_val,\n",
        "            y_train=fold_train['log_price'],\n",
        "            y_val=fold_val['log_price'],\n",
        "            name=name,\n",
        "            description=description\n",
        "        )\n",
        "\n",
        "    def fit(self, training_data: pd.DataFrame) -> 'FeatureEncoder':\n",
        "            \"\"\"Fit all encoders on full training data for production use\"\"\"\n",
        "            # Fit categorical encoders\n",
        "            self.state.house_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "            self.state.house_encoder.fit(training_data[['House Type']])\n",
        "\n",
        "            self.state.city_country_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "            self.state.city_country_encoder.fit(training_data[['City/County']])\n",
        "\n",
        "            self.state.outcode_encoder = OneHotEncoder(sparse_output=False, handle_unknown='ignore')\n",
        "            self.state.outcode_encoder.fit(training_data[['Outcode']])\n",
        "\n",
        "            # Calculate geographic statistics\n",
        "            self.state.outcode_means = (\n",
        "                training_data.groupby('Outcode')['log_price'].mean().to_dict()\n",
        "            )\n",
        "            self.state.outcode_global_mean = training_data['log_price'].mean()\n",
        "\n",
        "            self.state.postcode_means = (\n",
        "                training_data.groupby('Postal Code')['log_price'].mean().to_dict()\n",
        "            )\n",
        "            self.state.postcode_counts = (\n",
        "                training_data['Postal Code'].value_counts().to_dict()\n",
        "            )\n",
        "\n",
        "            self.state.location_means = (\n",
        "                training_data.groupby('Location')['log_price'].mean().to_dict()\n",
        "            )\n",
        "            self.state.location_counts = (\n",
        "                training_data['Location'].value_counts().to_dict()\n",
        "            )\n",
        "\n",
        "            # Calculate price per sqft statistics\n",
        "            price_per_sqft = training_data['Price'] / training_data['Area in sq ft']\n",
        "            self.state.price_per_sqft_means = (\n",
        "                price_per_sqft.groupby(training_data['Outcode']).mean().to_dict()\n",
        "            )\n",
        "            self.state.price_per_sqft_global_mean = price_per_sqft.mean()\n",
        "\n",
        "            return self\n",
        "\n",
        "    def save(self, path: str) -> None:\n",
        "        \"\"\"Save encoder state to disk\"\"\"\n",
        "        if not hasattr(self, 'state'):\n",
        "            raise ValueError(\"Encoder not fitted. Call fit() first.\")\n",
        "\n",
        "        with open(path, 'wb') as f:\n",
        "            pickle.dump(self.state, f)\n",
        "\n",
        "    @classmethod\n",
        "    def load(cls, path: str) -> 'FeatureEncoder':\n",
        "        \"\"\"Load encoder state from disk\"\"\"\n",
        "        with open(path, 'rb') as f:\n",
        "            state = pickle.load(f)\n",
        "\n",
        "        encoder = cls(\n",
        "            smoothing_factor=state.smoothing_factor,\n",
        "            min_location_freq=state.min_location_freq,\n",
        "            random_state=state.random_state\n",
        "        )\n",
        "        encoder.state = state\n",
        "        return encoder\n",
        "\n",
        "    def create_production_features(self, data: pd.DataFrame) -> pd.DataFrame:\n",
        "        \"\"\"Create features for production use using fitted state\"\"\"\n",
        "        if not hasattr(self, 'state'):\n",
        "            raise ValueError(\"Encoder not fitted. Call fit() first.\")\n",
        "\n",
        "        # Start with base numeric features\n",
        "        features = data[['Area in sq ft', 'No. of Bedrooms']].copy()\n",
        "\n",
        "        # Add house type features\n",
        "        features = pd.concat([\n",
        "            features,\n",
        "            pd.DataFrame(\n",
        "                self.state.house_encoder.transform(data[['House Type']]),\n",
        "                columns=self.state.house_encoder.get_feature_names_out(['House Type']),\n",
        "                index=data.index\n",
        "            )\n",
        "        ], axis=1)\n",
        "\n",
        "        # Add geographic target encodings\n",
        "        features['outcode'] = data['Outcode'].map(self.state.outcode_means).fillna(self.state.outcode_global_mean)\n",
        "\n",
        "        # Add postcode encoding with smoothing\n",
        "        postcode_means = pd.Series(data['Postal Code'].map(self.state.postcode_means))\n",
        "        postcode_counts = pd.Series(data['Postal Code'].map(self.state.postcode_counts))\n",
        "        postcode_means = postcode_means.fillna(features['outcode'])\n",
        "        postcode_counts = postcode_counts.fillna(0)\n",
        "        weight = postcode_counts / (postcode_counts + self.smoothing_factor)\n",
        "        features['postcode'] = weight * postcode_means + (1 - weight) * features['outcode']\n",
        "\n",
        "        # Add location encoding with smoothing and frequency threshold\n",
        "        location_means = pd.Series(data['Location'].map(self.state.location_means))\n",
        "        location_counts = pd.Series(data['Location'].map(self.state.location_counts))\n",
        "        location_means = location_means.fillna(features['postcode'])\n",
        "        location_counts = location_counts.fillna(0)\n",
        "        weight = location_counts / (location_counts + self.smoothing_factor)\n",
        "        features['location'] = weight * location_means + (1 - weight) * features['postcode']\n",
        "        low_freq_mask = (location_counts < self.min_location_freq) | location_counts.isna()\n",
        "        features.loc[low_freq_mask, 'location'] = features.loc[low_freq_mask, 'postcode']\n",
        "\n",
        "        # Add price per square foot\n",
        "        features['price_per_sqft'] = (\n",
        "            data['Outcode']\n",
        "            .map(self.state.price_per_sqft_means)\n",
        "            .fillna(self.state.price_per_sqft_global_mean)\n",
        "        )\n",
        "\n",
        "        return features"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ATGNAVlLFzxc"
      },
      "source": [
        "#### Testing FeatureEncoder persistence\n",
        "\n",
        "Let's verify our FeatureEncoder's persistence functionality and inspect its encoding statistics to ensure its working properly.\n",
        "\n",
        "The test will:\n",
        "1. Create and fit an encoder on training data\n",
        "2. Save it to disk\n",
        "3. Load it back and verify feature consistency\n",
        "4. Output the encoding statistics computed from the dataset\n",
        "\n",
        "Let's run the test:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vW--NW69EnZ4",
        "outputId": "f32d37dd-53fe-427b-94fc-32255122efdc"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "=== Testing FeatureEncoder Persistence ===\n",
            "Testing FeatureEncoder persistence...\n",
            "\n",
            "1. Training phase...\n",
            "\n",
            "Encoding Statistics:\n",
            "----------------------------------------\n",
            "Number of unique Outcodes: 143\n",
            "Number of unique Postcodes: 2351\n",
            "Number of unique Locations: 444\n",
            "\n",
            "Price Statistics (from encoded values):\n",
            "----------------------------------------\n",
            "Outcode price levels:\n",
            "  Min: £325,000\n",
            "  Max: £8,126,729\n",
            "  Mean: £1,321,151\n",
            "  Median: £1,215,566\n",
            "\n",
            "Location frequency statistics:\n",
            "----------------------------------------\n",
            "Locations with fewer than 5 samples: 368\n",
            "Most common location: putney (103 samples)\n",
            "Median samples per location: 1\n",
            "\n",
            "2. Creating features before saving...\n",
            "\n",
            "Feature Statistics:\n",
            "----------------------------------------\n",
            "\n",
            "Outcode encoding statistics:\n",
            "  Mean: 14.106\n",
            "  Std: 0.454\n",
            "  Min: 13.100\n",
            "  Max: 15.911\n",
            "\n",
            "Postcode encoding statistics:\n",
            "  Mean: 14.105\n",
            "  Std: 0.457\n",
            "  Min: 13.082\n",
            "  Max: 15.922\n",
            "\n",
            "Location encoding statistics:\n",
            "  Mean: 14.123\n",
            "  Std: 0.453\n",
            "  Min: 13.082\n",
            "  Max: 15.911\n",
            "\n",
            "3. Saving encoder...\n",
            "Saved encoder to ../model/atlas/encoder.pkl\n",
            "\n",
            "4. Loading encoder...\n",
            "Creating features after loading...\n",
            "\n",
            "5. Verifying results...\n",
            "Features match: True\n",
            "\n",
            "Feature columns:\n",
            "- Area in sq ft\n",
            "- No. of Bedrooms\n",
            "- House Type_Bungalow\n",
            "- House Type_Duplex\n",
            "- House Type_Flat / Apartment\n",
            "- House Type_House\n",
            "- House Type_Mews\n",
            "- House Type_New development\n",
            "- House Type_Penthouse\n",
            "- House Type_Studio\n",
            "- outcode\n",
            "- postcode\n",
            "- location\n",
            "- price_per_sqft\n",
            "\n",
            "Data statistics:\n",
            "Training samples: 2784\n",
            "Production samples: 696\n",
            "Features shape: (696, 14)\n",
            "\n",
            "Feature correlations with target:\n",
            "Outcode: 0.445\n",
            "Postcode: 0.456\n",
            "Location: 0.461\n",
            "\n",
            "Encoder saved successfully at ../model/atlas/encoder.pkl\n",
            "\n",
            "Persistence test passed!\n"
          ]
        }
      ],
      "source": [
        "def test_encoder_persistence(df_with_outcode: pd.DataFrame):\n",
        "    \"\"\"Test that the FeatureEncoder can be saved and loaded correctly\"\"\"\n",
        "    print(\"Testing FeatureEncoder persistence...\")\n",
        "\n",
        "    # Setup save path with proper folder creation\n",
        "    save_dir = Path(\"../model/atlas\")\n",
        "    save_path = save_dir / \"encoder.pkl\"\n",
        "\n",
        "    # Create directories if they don't exist\n",
        "    save_dir.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "    # Remove existing encoder file if it exists\n",
        "    if save_path.exists():\n",
        "        print(f\"Found existing encoder at {save_path}, will overwrite\")\n",
        "        save_path.unlink()\n",
        "\n",
        "    # Use PreProcessor for proper stratified splitting\n",
        "    preprocessor = PreProcessor()\n",
        "\n",
        "    # Create price bands and split data properly\n",
        "    df_processed = preprocessor.prepare_pre_split_features(df_with_outcode)\n",
        "    training_data, production_data = preprocessor.create_train_test_split(df_processed)\n",
        "\n",
        "    print(\"\\n1. Training phase...\")\n",
        "    # Create and fit encoder\n",
        "    encoder = FeatureEncoder()\n",
        "    encoder.fit(training_data)\n",
        "\n",
        "    # Print encoding statistics\n",
        "    print(\"\\nEncoding Statistics:\")\n",
        "    print(\"-\" * 40)\n",
        "    print(f\"Number of unique Outcodes: {len(encoder.state.outcode_means)}\")\n",
        "    print(f\"Number of unique Postcodes: {len(encoder.state.postcode_means)}\")\n",
        "    print(f\"Number of unique Locations: {len(encoder.state.location_means)}\")\n",
        "\n",
        "    # Print some price statistics\n",
        "    print(\"\\nPrice Statistics (from encoded values):\")\n",
        "    print(\"-\" * 40)\n",
        "    outcode_prices = pd.Series(encoder.state.outcode_means)\n",
        "    print(\"Outcode price levels:\")\n",
        "    print(f\"  Min: £{np.exp(outcode_prices.min()):,.0f}\")\n",
        "    print(f\"  Max: £{np.exp(outcode_prices.max()):,.0f}\")\n",
        "    print(f\"  Mean: £{np.exp(outcode_prices.mean()):,.0f}\")\n",
        "    print(f\"  Median: £{np.exp(outcode_prices.median()):,.0f}\")\n",
        "\n",
        "    # Print location frequency statistics\n",
        "    location_counts = pd.Series(encoder.state.location_counts)\n",
        "    print(\"\\nLocation frequency statistics:\")\n",
        "    print(\"-\" * 40)\n",
        "    print(f\"Locations with fewer than {encoder.min_location_freq} samples: {(location_counts < encoder.min_location_freq).sum()}\")\n",
        "    print(f\"Most common location: {location_counts.idxmax()} ({location_counts.max()} samples)\")\n",
        "    print(f\"Median samples per location: {location_counts.median():.0f}\")\n",
        "\n",
        "    # Generate features before saving\n",
        "    print(\"\\n2. Creating features before saving...\")\n",
        "    features_before = encoder.create_production_features(production_data)\n",
        "\n",
        "    # Print feature statistics\n",
        "    print(\"\\nFeature Statistics:\")\n",
        "    print(\"-\" * 40)\n",
        "    for col in ['outcode', 'postcode', 'location']:\n",
        "        if col in features_before.columns:\n",
        "            print(f\"\\n{col.title()} encoding statistics:\")\n",
        "            stats = features_before[col].describe()\n",
        "            print(f\"  Mean: {stats['mean']:.3f}\")\n",
        "            print(f\"  Std: {stats['std']:.3f}\")\n",
        "            print(f\"  Min: {stats['min']:.3f}\")\n",
        "            print(f\"  Max: {stats['max']:.3f}\")\n",
        "\n",
        "    print(\"\\n3. Saving encoder...\")\n",
        "    try:\n",
        "        encoder.save(save_path)\n",
        "        print(f\"Saved encoder to {save_path}\")\n",
        "    except Exception as e:\n",
        "        print(f\"Error saving encoder: {e}\")\n",
        "        return False\n",
        "\n",
        "    print(\"\\n4. Loading encoder...\")\n",
        "    try:\n",
        "        loaded_encoder = FeatureEncoder.load(save_path)\n",
        "    except Exception as e:\n",
        "        print(f\"Error loading encoder: {e}\")\n",
        "        return False\n",
        "\n",
        "    print(\"Creating features after loading...\")\n",
        "    features_after = loaded_encoder.create_production_features(production_data)\n",
        "\n",
        "    print(\"\\n5. Verifying results...\")\n",
        "    features_match = features_before.equals(features_after)\n",
        "    print(f\"Features match: {features_match}\")\n",
        "\n",
        "    if features_match:\n",
        "        print(\"\\nFeature columns:\")\n",
        "        for col in features_before.columns:\n",
        "            print(f\"- {col}\")\n",
        "\n",
        "        print(\"\\nData statistics:\")\n",
        "        print(f\"Training samples: {len(training_data)}\")\n",
        "        print(f\"Production samples: {len(production_data)}\")\n",
        "        print(f\"Features shape: {features_before.shape}\")\n",
        "\n",
        "        # Print sample correlations\n",
        "        print(\"\\nFeature correlations with target:\")\n",
        "        target = np.exp(production_data['log_price'])\n",
        "        for col in ['outcode', 'postcode', 'location']:\n",
        "            if col in features_before.columns:\n",
        "                corr = features_before[col].corr(target)\n",
        "                print(f\"{col.title()}: {corr:.3f}\")\n",
        "    else:\n",
        "        print(\"\\nFeature differences:\")\n",
        "        diff_cols = []\n",
        "        for col in features_before.columns:\n",
        "            if not features_before[col].equals(features_after[col]):\n",
        "                diff_cols.append(col)\n",
        "        print(f\"Columns with differences: {diff_cols}\")\n",
        "\n",
        "    print(f\"\\nEncoder saved successfully at {save_path}\")\n",
        "    return features_match\n",
        "\n",
        "# Run the test\n",
        "print(\"\\n=== Testing FeatureEncoder Persistence ===\")\n",
        "success = test_encoder_persistence(df_with_outcode)\n",
        "print(f\"\\nPersistence test {'passed' if success else 'failed'}!\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8Z9x_-Ev805O"
      },
      "source": [
        "<a name=\"crossvalidator\"></a>\n",
        "### CrossValidator\n",
        "\n",
        "The CrossValidator class serves as the experimental engine of ATLAS, systematically evaluating different models and feature combinations to identify the most effective approaches for house price prediction.\n",
        "\n",
        "Like its mythological namesake Atlas who carried the heavens, our CrossValidator shoulders the burden of running thousands of experiments while maintaining rigorous scientific standards.\n",
        "\n",
        "#### Core responsibilities\n",
        "The CrossValidator manages the complete experimental lifecycle through its `evaluate_all_combinations` method:\n",
        "\n",
        "1. Model management: Maintaining a collection of different model types\n",
        "2. Experiment orchestration: Running cross-validation and final testing\n",
        "3. Performance tracking: Collecting and organising results\n",
        "4. Progress monitoring: Providing real-time feedback on experiment status\n",
        "\n",
        "#### 1. Model management\n",
        "\n",
        "The CrossValidator maintains three distinct model types, each chosen for specific strengths:\n",
        "```python\n",
        "class CrossValidator:\n",
        "    def __init__(self, n_folds: int = 5, random_state: int = RANDOM_STATE):\n",
        "        self.n_folds = n_folds\n",
        "        self.random_state = random_state\n",
        "        self.models = {\n",
        "            'decision_tree': DecisionTreeRegressor(random_state=random_state),\n",
        "            'random_forest': RandomForestRegressor(\n",
        "                n_estimators=100,\n",
        "                random_state=random_state\n",
        "            ),\n",
        "            'xgboost': XGBRegressor(\n",
        "                n_estimators=100,\n",
        "                random_state=random_state\n",
        "            )\n",
        "        }\n",
        "```\n",
        "\n",
        "##### Key aspects:\n",
        "\n",
        "- Each model uses the same random state for reproducibility\n",
        "- Random Forest and XGBoost both use 100 trees (n_estimators=100)\n",
        "- DecisionTreeRegressor serves as a simple baseline model\n",
        "- Models are configured with default parameters aside from n_estimators and random_state\n",
        "\n",
        "### 2. Experiment orchestration\n",
        "\n",
        "The `evaluate_all_combinations` method implements the evaluation process in two phases:\n",
        "\n",
        "Phase 1: Cross-validation\n",
        "```python\n",
        "kf = KFold(n_splits=self.n_folds, shuffle=True, random_state=self.random_state)\n",
        "for fold_idx, (fold_train_idx, fold_val_idx) in enumerate(kf.split(train_data)):\n",
        "    fold_train = train_data.iloc[fold_train_idx].copy()\n",
        "    fold_val = train_data.iloc[fold_val_idx].copy()\n",
        "    \n",
        "    # Mark as CV fold for target encoding\n",
        "    fold_train['cv_fold'] = fold_idx\n",
        "    fold_val['cv_fold'] = fold_idx\n",
        "    \n",
        "    # Create features and evaluate models\n",
        "    feature_sets = encoder.create_fold_features(fold_train, fold_val)\n",
        "```\n",
        "\n",
        "- Creates 5 independent training/validation splits using KFold\n",
        "- Makes safe copies of data for each fold\n",
        "- Marks data with fold indices for feature engineering\n",
        "- Creates new feature encodings for each fold\n",
        "\n",
        "\\\n",
        "Phase 2: Final evaluation\n",
        "```python\n",
        "# Remove CV marking\n",
        "train_data = train_data.drop('cv_fold', axis=1, errors='ignore')\n",
        "\n",
        "# Create features using full training set and test set\n",
        "final_feature_sets = encoder.create_fold_features(train_data, test_data)\n",
        "\n",
        "# Train and evaluate on test set\n",
        "for feature_set in final_feature_sets:\n",
        "    for model_name, model in self.models.items():\n",
        "        model.fit(feature_set.X_train, feature_set.y_train)\n",
        "        test_pred = model.predict(feature_set.X_val)\n",
        "```\n",
        "- Removes cross-validation markings\n",
        "- Uses full training dataset\n",
        "- Creates final feature sets\n",
        "- Evaluates on held-out test data\n",
        "\n",
        "\\\n",
        "### 3. Progress tracking\n",
        "\n",
        "The implementation uses nested progress bars and status displays:\n",
        "```python\n",
        "# Calculate total iterations\n",
        "n_folds = self.n_folds\n",
        "n_models = len(self.models)\n",
        "\n",
        "status_display = display('Starting fold 1...', display_id=True)\n",
        "\n",
        "with tqdm(total=n_folds, desc=\"Folds\") as fold_pbar:\n",
        "    with tqdm(total=n_features * n_models,\n",
        "             desc=f\"Fold {fold_idx + 1} Progress\") as feature_pbar:\n",
        "        \n",
        "        status_display.update(\n",
        "            f\"Fold {fold_idx + 1}: {model_name} on {feature_set.name}\"\n",
        "        )\n",
        "```\n",
        "\n",
        "This provides:\n",
        "\n",
        "- Overall progress through folds\n",
        "- Detailed progress within each fold\n",
        "- Current model and feature set being evaluated\n",
        "- Estimated time remaining\n",
        "\n",
        "\n",
        "### 4. Performance metrics\n",
        "\n",
        "The implementation calculates four metrics using sklearn utilities and numpy:\n",
        "\n",
        "| Metric | Purpose | Implementation |\n",
        "|--------|----------|---------------|\n",
        "| RMSE | Overall error magnitude | `self._calculate_rmse(feature_set.y_val, fold_val_pred)` |\n",
        "| R² | Explained variance | `r2_score(feature_set.y_val, fold_val_pred)` |\n",
        "| MAE | Average error in pounds | `mean_absolute_error(np.exp(feature_set.y_val), np.exp(fold_val_pred))` |\n",
        "| % MAE | Relative error | `np.mean(np.abs((np.exp(y_val) - np.exp(y_pred)) / np.exp(y_val))) * 100` |\n",
        "\n",
        "Note: The RMSE calculation is implemented as\n",
        "```python\n",
        "def _calculate_rmse(self, y_true: pd.Series, y_pred: np.ndarray) -> float:\n",
        "    return np.sqrt(np.mean((y_true - y_pred) ** 2))\n",
        "```\n",
        "\n",
        "### Results collection\n",
        "\n",
        "Results are collected in a list and then converted to a DataFrame. Each evaluation records:\n",
        "\n",
        "```python\n",
        "results.append({\n",
        "    'fold': fold_idx,                    # Fold number or 'final' for test\n",
        "    'feature_set': feature_set.name,     # Name of feature combination\n",
        "    'description': feature_set.description, # Detailed feature description\n",
        "    'model': model_name,                 # Model type used\n",
        "    'split_type': split_type,           # 'cv_fold' or 'test'\n",
        "    'rmse': rmse_score,                  # Root Mean Squared Error\n",
        "    'r2': r2_score,                      # R-squared value\n",
        "    'mae': mean_absolute_error,          # Mean Absolute Error in pounds\n",
        "    'pct_mae': percentage_error,         # Percentage Mean Absolute Error\n",
        "    'n_features': feature_set.X_train.shape[1]  # Number of features used\n",
        "})\n",
        "```\n",
        "\n",
        "Finally, all results are converted to a pandas DataFrame:\n",
        "```python\n",
        "return pd.DataFrame(results)\n",
        "```\n",
        "\n",
        "Here's the complete implementation:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "5yk2z5Jy805P"
      },
      "outputs": [],
      "source": [
        "class CrossValidator:\n",
        "    \"\"\"Handles cross-validation and model evaluation\"\"\"\n",
        "\n",
        "    def __init__(self, n_folds: int = 5, random_state: int = RANDOM_STATE):\n",
        "        self.n_folds = n_folds\n",
        "        self.random_state = random_state\n",
        "        self.models = {\n",
        "            'decision_tree': DecisionTreeRegressor(random_state=random_state),\n",
        "            'random_forest': RandomForestRegressor(\n",
        "                n_estimators=100,\n",
        "                random_state=random_state\n",
        "            ),\n",
        "            'xgboost': XGBRegressor(\n",
        "                n_estimators=100,\n",
        "                random_state=random_state\n",
        "            )\n",
        "        }\n",
        "\n",
        "    def evaluate_all_combinations(self,\n",
        "                                train_data: pd.DataFrame,\n",
        "                                test_data: pd.DataFrame) -> pd.DataFrame:\n",
        "        \"\"\"\n",
        "        Evaluate all feature set and model combinations using:\n",
        "        1. K-fold CV on training data\n",
        "        2. Final evaluation on test set\n",
        "        \"\"\"\n",
        "        results = []\n",
        "        encoder = FeatureEncoder()\n",
        "\n",
        "        # Calculate total iterations for progress tracking\n",
        "        n_folds = self.n_folds\n",
        "        n_models = len(self.models)\n",
        "\n",
        "        # PART 1: K-FOLD CROSS VALIDATION ON TRAINING DATA ONLY\n",
        "        kf = KFold(n_splits=self.n_folds, shuffle=True, random_state=self.random_state)\n",
        "\n",
        "        print(\"\\nRunning cross-validation...\")\n",
        "\n",
        "        status_display = display('Starting fold 1...', display_id=True)\n",
        "\n",
        "        # Create main progress bar for folds\n",
        "        with tqdm(total=n_folds, desc=\"Folds\") as fold_pbar:\n",
        "            for fold_idx, (fold_train_idx, fold_val_idx) in enumerate(kf.split(train_data)):\n",
        "                # Get this fold's train/val split\n",
        "                fold_train = train_data.iloc[fold_train_idx].copy()\n",
        "                fold_val = train_data.iloc[fold_val_idx].copy()\n",
        "\n",
        "                # Mark as CV fold (for target encoding)\n",
        "                fold_train['cv_fold'] = fold_idx\n",
        "                fold_val['cv_fold'] = fold_idx\n",
        "\n",
        "                # Create features for this fold\n",
        "                feature_sets = encoder.create_fold_features(fold_train, fold_val)\n",
        "                n_features = len(feature_sets)\n",
        "\n",
        "                # Create nested progress bar for feature sets\n",
        "                with tqdm(total=n_features * n_models,\n",
        "                         desc=f\"Fold {fold_idx + 1} Progress\") as feature_pbar:\n",
        "\n",
        "                    # Evaluate each feature set and model combination\n",
        "                    for feature_set in feature_sets:\n",
        "                        for model_name, model in self.models.items():\n",
        "                            # Update status display\n",
        "                            status_display.update(\n",
        "                                f\"Fold {fold_idx + 1}: {model_name} on {feature_set.name}\"\n",
        "                            )\n",
        "\n",
        "                            model.fit(feature_set.X_train, feature_set.y_train)\n",
        "                            fold_val_pred = model.predict(feature_set.X_val)\n",
        "\n",
        "                            results.append({\n",
        "                                'fold': fold_idx,\n",
        "                                'feature_set': feature_set.name,\n",
        "                                'description': feature_set.description,\n",
        "                                'model': model_name,\n",
        "                                'split_type': 'cv_fold',\n",
        "                                'rmse': self._calculate_rmse(feature_set.y_val, fold_val_pred),\n",
        "                                'r2': r2_score(feature_set.y_val, fold_val_pred),\n",
        "                                'mae': mean_absolute_error(\n",
        "                                    np.exp(feature_set.y_val),\n",
        "                                    np.exp(fold_val_pred)\n",
        "                                ),\n",
        "                                'pct_mae': np.mean(np.abs(\n",
        "                                    (np.exp(feature_set.y_val) - np.exp(fold_val_pred)) /\n",
        "                                    np.exp(feature_set.y_val)\n",
        "                                )) * 100,\n",
        "                                'n_features': feature_set.X_train.shape[1]\n",
        "                            })\n",
        "                            feature_pbar.update(1)\n",
        "                fold_pbar.update(1)\n",
        "\n",
        "        # PART 2: FINAL EVALUATION ON TEST SET\n",
        "        print(\"\\nRunning final evaluation on test set...\")\n",
        "        status_display.update(\"Starting test set evaluation...\")\n",
        "\n",
        "        # Remove CV marking\n",
        "        train_data = train_data.drop('cv_fold', axis=1, errors='ignore')\n",
        "\n",
        "        # Create features using full training set and test set\n",
        "        final_feature_sets = encoder.create_fold_features(train_data, test_data)\n",
        "\n",
        "        # Create progress bar for final evaluation\n",
        "        with tqdm(total=len(final_feature_sets) * len(self.models),\n",
        "                 desc=\"Test Set Evaluation\") as test_pbar:\n",
        "\n",
        "            for feature_set in final_feature_sets:\n",
        "                for model_name, model in self.models.items():\n",
        "                    # Update status display\n",
        "                    status_display.update(\n",
        "                        f\"Test Set: {model_name} on {feature_set.name}\"\n",
        "                    )\n",
        "\n",
        "                    # Train on full training data\n",
        "                    model.fit(feature_set.X_train, feature_set.y_train)\n",
        "                    test_pred = model.predict(feature_set.X_val)\n",
        "\n",
        "                    results.append({\n",
        "                        'fold': 'final',\n",
        "                        'feature_set': feature_set.name,\n",
        "                        'description': feature_set.description,\n",
        "                        'model': model_name,\n",
        "                        'split_type': 'test',\n",
        "                        'rmse': self._calculate_rmse(feature_set.y_val, test_pred),\n",
        "                        'r2': r2_score(feature_set.y_val, test_pred),\n",
        "                        'mae': mean_absolute_error(\n",
        "                            np.exp(feature_set.y_val),\n",
        "                            np.exp(test_pred)\n",
        "                        ),\n",
        "                        'pct_mae': np.mean(np.abs(\n",
        "                            (np.exp(feature_set.y_val) - np.exp(test_pred)) /\n",
        "                            np.exp(feature_set.y_val)\n",
        "                        )) * 100,\n",
        "                        'n_features': feature_set.X_train.shape[1]\n",
        "                    })\n",
        "                    test_pbar.update(1)\n",
        "\n",
        "        return pd.DataFrame(results)\n",
        "\n",
        "    def _calculate_rmse(self,\n",
        "                       y_true: pd.Series,\n",
        "                       y_pred: np.ndarray) -> float:\n",
        "        \"\"\"\n",
        "        Calculate Root Mean Squared Error\n",
        "        \"\"\"\n",
        "        return np.sqrt(np.mean((y_true - y_pred) ** 2))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9Z9sRfPA805P"
      },
      "source": [
        "<a name=\"running-atlas\"></a>\n",
        "## Running ATLAS\n",
        "\n",
        "ATLAS processes our house price data through a straightforward sequence:\n",
        "\n",
        "```python\n",
        "Raw Data → PreProcessor → Train/Test Split → CrossValidator → Results\n",
        "```\n",
        "\n",
        "In code:\n",
        "```python\n",
        "preprocessor = PreProcessor()\n",
        "df_processed = preprocessor.prepare_pre_split_features(df_with_outcode)\n",
        "train_data, test_data = preprocessor.create_train_test_split(df_processed)\n",
        "validator = CrossValidator()\n",
        "results = validator.evaluate_all_combinations(train_data, test_data)\n",
        "```\n",
        "\n",
        "During execution, progress bars track:\n",
        "- Overall fold completion\n",
        "- Current model and feature evaluation\n",
        "- Estimated time remaining\n",
        "\n",
        "Each experiment's results provide:\n",
        "- Model configuration and feature set details\n",
        "- Cross-validation performance with confidence intervals\n",
        "- Final test set metrics\n",
        "- Performance measures (RMSE, R², MAE, %MAE)\n",
        "\n",
        "Right, we've got our pipeline - let's run it!"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000,
          "referenced_widgets": [
            "5243ffeca0754ad3a7443529dd29882d",
            "444169ebf4e44ff698f27757a47300b6",
            "fc69b05692f74895ad760b44867b7d61",
            "7ac3dde068444e8fb67d6b9a8331e7bd",
            "03d77e1968ea428184db8ba164a106b5",
            "ac0b1cd52910407a9a680d72e86cc1fe",
            "5a9febae15914fa79714cb07a2bf71ee",
            "c5cdb552da004475b33133b129e36ca8",
            "81a52c4f9ff949b3a25b1b9bb746fbdb",
            "cc274e96e11c426b9add21817fafbdfb",
            "2ea7ef064cad4493a4870f547fd5a14c",
            "59dd1761502c4722874895b3157af829",
            "4e1cb57f828b4210b0d960a18b5ec46f",
            "4fb4f3cde909411ea5931a9c8d9ae283",
            "2b5e851806bf42e0bfea7e9832ae5ec8",
            "2e50e1354dba4dd898b826e3754bd8c7",
            "235ae07841b7431aa7cd3260c3f998a4",
            "10974c0ea18c4c45ac248f41850b9dae",
            "d81e45fcb77f42048baf95a555f2bcf7",
            "9002532511f94762921823b7cab849ae",
            "572fb815839d43999d2dc4c8ac53ed3e",
            "8c38ff54c9df40a1a4a8a5832cc33767",
            "49ec8e9bcff742b78d4816e8d9a712de",
            "16cb74dc78ae47c5a90078479e755856",
            "b81de64f20d24adeb42e8fce037b10eb",
            "1fa63178e2ee4a8c8f39ffa53a7efa1f",
            "b5c69a1121a9472bb69c4d211c9845f5",
            "c107b4711f7b46229181abad6ab7aea3",
            "db9a7b2149af41d79c209a88526fb353",
            "02f5554ffc204c799f46fa5ad6c678dc",
            "79872a7f47414332950edda87d44c30d",
            "a91d589b0d1d473d89941f9a861159e1",
            "1223398cf21541f986a86047f2dd0ca3",
            "3b4f69b2c1594f5e9d5564711e3cacf5",
            "ae0ff5d6b09d4a9d934b2300e771aca2",
            "4d74c51cf005468188947b62f5cf2897",
            "bdc747a22ab4470e9d1aa6c4c8b1947b",
            "ba7e0f6496a04b64ac869242a596fbde",
            "34251a75a0dc4c0595d6d4b453219f8c",
            "1075fe82ea314442afb5a52d39938a66",
            "f189ef3d7c7f4873b8a12131c13d3246",
            "a6f8647b3b484d758d6bb8985efeb74d",
            "42afa3222228487a88b51f68cd0b3c25",
            "1327b77e21b04042af754599a3353a21",
            "3dd148bee18c4bc3811cddfbf70ec6cc",
            "45923c7b89ec40adaa187af7e2faf023",
            "bfa0e7618fb9436abdfb0ba6275eb048",
            "9357f2d3194b4278bc8ca271b1dba314",
            "44368d80e7004722b4bd1c5cd71e0cfe",
            "53ddf0baa895412d9d8a42c8866101df",
            "eb0ff59586a24b57a76dfe6118a1ea38",
            "761ad6d2a8df49f0b396b9987a39ea36",
            "b8412e6602d14b6eaaf05712b163cc4c",
            "744ace51c08249bd992e57e165b86503",
            "9f9e2c9bea984a5597ad1bd0c5272d13",
            "a79961efc6544a648a672941c6b25f5e",
            "7de6a0883f5b40e0b23eb163b5744070",
            "250f4aaa41d44da3a13cc454e271784f",
            "e5f2f69e271341f5833d98981cd172fe",
            "1dc325c572a345a3aa545ab3cfb828bd",
            "384d516a386d447d9c84cb7607e90755",
            "047786fc443a45ae8f0274fe1fcf62ae",
            "a2fdb19fee4d46d480f77b26265c726a",
            "7f2913b820ec4f9caf193155d99b88ad",
            "7ecbb095dc3845408bb0aee9c47f1c0f",
            "a32c788118dd46d28ccc4f9961a9d132",
            "269c27dce4a6482b9ecea79055a96849",
            "4f3a951b523e42e38a32993679b75543",
            "9fb7e721eb2c47849b5c6bbc220f2c6c",
            "72a750499ac54430bf7591fadbff8020",
            "21330d2eb6574a39897bb520b71302ee",
            "19cd6ce234ca48caace237c932adf1b8",
            "f34718136ce84ca2be79a11b304d5899",
            "c06289343fa44269bf6393619ab831e3",
            "65bf2f4b28904b0bb58d046c5548416a",
            "4ddc0cf5d70c4f95848bd74b8b0fdc97",
            "672886119ace4ca887b7f9f5e55f8548"
          ]
        },
        "id": "K4k0u8TN805P",
        "outputId": "c8d16311-e9bf-4650-9139-b4f508ad8b17"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Running ATLAS pipeline (estimated time: 2 minutes)...\n",
            "\n",
            "Running cross-validation...\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "'Test Set: xgboost on all_features'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Folds:   0%|          | 0/5 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "5243ffeca0754ad3a7443529dd29882d"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Fold 1 Progress:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "59dd1761502c4722874895b3157af829"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Fold 2 Progress:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "49ec8e9bcff742b78d4816e8d9a712de"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Fold 3 Progress:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "3b4f69b2c1594f5e9d5564711e3cacf5"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Fold 4 Progress:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "3dd148bee18c4bc3811cddfbf70ec6cc"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Fold 5 Progress:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "a79961efc6544a648a672941c6b25f5e"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Running final evaluation on test set...\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "Test Set Evaluation:   0%|          | 0/45 [00:00<?, ?it/s]"
            ],
            "application/vnd.jupyter.widget-view+json": {
              "version_major": 2,
              "version_minor": 0,
              "model_id": "269c27dce4a6482b9ecea79055a96849"
            }
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\n",
            "Results DataFrame Info:\n",
            "Shape: (270, 10)\n",
            "\n",
            "First few rows:\n",
            "  fold          feature_set                                 description  \\\n",
            "0    0        area_bedrooms              Area in sq ft, No. of Bedrooms   \n",
            "1    0        area_bedrooms              Area in sq ft, No. of Bedrooms   \n",
            "2    0        area_bedrooms              Area in sq ft, No. of Bedrooms   \n",
            "3    0  area_bedrooms_house  Area in sq ft, No. of Bedrooms, House Type   \n",
            "4    0  area_bedrooms_house  Area in sq ft, No. of Bedrooms, House Type   \n",
            "\n",
            "           model split_type  rmse   r2        mae  pct_mae  n_features  \n",
            "0  decision_tree    cv_fold  0.53 0.53 903,982.30    42.14           2  \n",
            "1  random_forest    cv_fold  0.45 0.66 741,766.07    35.05           2  \n",
            "2        xgboost    cv_fold  0.45 0.66 764,810.56    33.97           2  \n",
            "3  decision_tree    cv_fold  0.52 0.55 883,891.13    41.00          10  \n",
            "4  random_forest    cv_fold  0.43 0.69 697,184.76    32.92          10  \n",
            "\n",
            "Model Performance Summary:\n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
            "Features - Model                                                                                     CV R²          CV RMSE        CV MAE (£)          CV %Error           \n",
            "--------------------------------------------------------------------------------------------------------------------------------------------------------------------------\n",
            "All Features Combined - decision_tree                                                                0.818 ±0.025   0.320 ±0.011   £526,054 ±25,217    24.7 ±0.7%\n",
            "→ Test Results                                                                                       0.848          0.304          £501,842            22.3%\n",
            "All Features Combined - random_forest                                                                0.903 ±0.012   0.234 ±0.012   £371,771 ±48,304    17.8 ±0.9%\n",
            "→ Test Results                                                                                       0.908          0.237          £415,241            17.6%\n",
            "All Features Combined - xgboost                                                                      0.880 ±0.012   0.260 ±0.008   £402,129 ±44,167    20.1 ±0.5%\n",
            "→ Test Results                                                                                       0.879          0.271          £457,149            20.1%\n",
            "Area in sq ft, No. of Bedrooms - decision_tree                                                       0.480 ±0.035   0.542 ±0.021   £919,689 ±52,092    45.1 ±3.7%\n",
            "→ Test Results                                                                                       0.473          0.566          £994,767            46.9%\n",
            "Area in sq ft, No. of Bedrooms - random_forest                                                       0.622 ±0.029   0.463 ±0.025   £755,060 ±84,468    37.0 ±2.8%\n",
            "→ Test Results                                                                                       0.620          0.480          £838,765            37.8%\n",
            "Area in sq ft, No. of Bedrooms - xgboost                                                             0.648 ±0.029   0.446 ±0.025   £751,126 ±89,420    35.3 ±2.2%\n",
            "→ Test Results                                                                                       0.675          0.444          £794,475            32.9%\n",
            "Area in sq ft, No. of Bedrooms, All Geographic Features (Target) - decision_tree                     0.697 ±0.031   0.414 ±0.019   £625,306 ±77,070    32.1 ±1.5%\n",
            "→ Test Results                                                                                       0.741          0.397          £639,130            29.7%\n",
            "Area in sq ft, No. of Bedrooms, All Geographic Features (Target) - random_forest                     0.814 ±0.024   0.324 ±0.018   £514,137 ±75,363    24.9 ±1.9%\n",
            "→ Test Results                                                                                       0.823          0.328          £579,888            24.8%\n",
            "Area in sq ft, No. of Bedrooms, All Geographic Features (Target) - xgboost                           0.760 ±0.028   0.368 ±0.015   £571,042 ±63,808    28.6 ±1.7%\n",
            "→ Test Results                                                                                       0.814          0.336          £580,305            25.2%\n",
            "Area in sq ft, No. of Bedrooms, City/County - decision_tree                                          0.577 ±0.031   0.489 ±0.020   £809,220 ±51,736    40.7 ±2.4%\n",
            "→ Test Results                                                                                       0.584          0.502          £903,735            40.2%\n",
            "Area in sq ft, No. of Bedrooms, City/County - random_forest                                          0.698 ±0.023   0.414 ±0.022   £666,770 ±70,344    32.8 ±2.3%\n",
            "→ Test Results                                                                                       0.723          0.410          £702,441            31.4%\n",
            "Area in sq ft, No. of Bedrooms, City/County - xgboost                                                0.724 ±0.023   0.395 ±0.025   £656,336 ±78,249    31.0 ±1.9%\n",
            "→ Test Results                                                                                       0.771          0.373          £637,779            27.8%\n",
            "Area in sq ft, No. of Bedrooms, House Type - decision_tree                                           0.495 ±0.037   0.534 ±0.016   £879,620 ±73,978    44.4 ±2.7%\n",
            "→ Test Results                                                                                       0.540          0.528          £960,802            44.2%\n",
            "Area in sq ft, No. of Bedrooms, House Type - random_forest                                           0.652 ±0.032   0.444 ±0.024   £721,821 ±90,209    35.6 ±2.3%\n",
            "→ Test Results                                                                                       0.688          0.435          £779,600            34.9%\n",
            "Area in sq ft, No. of Bedrooms, House Type - xgboost                                                 0.667 ±0.042   0.434 ±0.031   £723,452 ±103,057   34.2 ±2.4%\n",
            "→ Test Results                                                                                       0.711          0.419          £769,969            31.3%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County - decision_tree                              0.569 ±0.035   0.494 ±0.019   £797,517 ±63,089    40.7 ±2.2%\n",
            "→ Test Results                                                                                       0.624          0.478          £905,008            39.4%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County - random_forest                              0.718 ±0.021   0.399 ±0.020   £630,719 ±72,331    31.5 ±1.9%\n",
            "→ Test Results                                                                                       0.754          0.387          £676,263            30.1%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County - xgboost                                    0.735 ±0.029   0.387 ±0.027   £633,593 ±69,480    30.3 ±1.8%\n",
            "→ Test Results                                                                                       0.785          0.362          £647,366            26.7%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County, Outcode (Target) - decision_tree            0.740 ±0.021   0.383 ±0.005   £585,502 ±36,742    30.3 ±1.1%\n",
            "→ Test Results                                                                                       0.811          0.339          £544,981            25.5%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County, Outcode (Target) - random_forest            0.855 ±0.022   0.286 ±0.017   £446,090 ±55,434    22.3 ±1.2%\n",
            "→ Test Results                                                                                       0.887          0.262          £449,542            19.7%\n",
            "Area in sq ft, No. of Bedrooms, House Type, City/County, Outcode (Target) - xgboost                  0.844 ±0.017   0.297 ±0.015   £467,274 ±55,915    23.4 ±1.1%\n",
            "→ Test Results                                                                                       0.909          0.235          £398,829            17.5%\n",
            "Area in sq ft, No. of Bedrooms, House Type, Outcode (Target), Price/sqft - decision_tree             0.826 ±0.024   0.313 ±0.017   £517,656 ±39,266    24.5 ±1.6%\n",
            "→ Test Results                                                                                       0.853          0.298          £509,740            22.5%\n",
            "Area in sq ft, No. of Bedrooms, House Type, Outcode (Target), Price/sqft - random_forest             0.903 ±0.010   0.234 ±0.011   £368,066 ±49,351    17.8 ±0.7%\n",
            "→ Test Results                                                                                       0.912          0.232          £387,602            17.2%\n",
            "Area in sq ft, No. of Bedrooms, House Type, Outcode (Target), Price/sqft - xgboost                   0.899 ±0.009   0.239 ±0.011   £379,417 ±55,543    18.5 ±1.0%\n",
            "→ Test Results                                                                                       0.913          0.230          £397,701            17.3%\n",
            "Area in sq ft, No. of Bedrooms, Location (Target) - decision_tree                                    0.709 ±0.047   0.405 ±0.027   £644,035 ±100,095   32.3 ±2.5%\n",
            "→ Test Results                                                                                       0.732          0.403          £666,371            31.7%\n",
            "Area in sq ft, No. of Bedrooms, Location (Target) - random_forest                                    0.823 ±0.030   0.316 ±0.024   £505,468 ±84,074    24.7 ±2.0%\n",
            "→ Test Results                                                                                       0.816          0.334          £591,952            26.2%\n",
            "Area in sq ft, No. of Bedrooms, Location (Target) - xgboost                                          0.809 ±0.027   0.328 ±0.018   £521,100 ±69,111    25.8 ±1.7%\n",
            "→ Test Results                                                                                       0.807          0.343          £593,220            26.3%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (One-hot) - decision_tree                                    0.703 ±0.036   0.410 ±0.031   £644,048 ±87,863    29.8 ±2.1%\n",
            "→ Test Results                                                                                       0.747          0.392          £638,077            27.4%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (One-hot) - random_forest                                    0.820 ±0.019   0.319 ±0.024   £511,957 ±83,184    23.4 ±1.6%\n",
            "→ Test Results                                                                                       0.833          0.319          £548,312            21.9%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (One-hot) - xgboost                                          0.881 ±0.013   0.260 ±0.020   £418,617 ±58,112    19.8 ±1.6%\n",
            "→ Test Results                                                                                       0.899          0.248          £432,491            18.4%\n",
            "Area in sq ft, No. of Bedrooms, Outcode & Postcode (Target) - decision_tree                          0.682 ±0.035   0.424 ±0.020   £659,416 ±70,212    33.0 ±2.1%\n",
            "→ Test Results                                                                                       0.696          0.430          £706,554            31.0%\n",
            "Area in sq ft, No. of Bedrooms, Outcode & Postcode (Target) - random_forest                          0.785 ±0.027   0.348 ±0.018   £552,837 ±67,097    26.4 ±2.2%\n",
            "→ Test Results                                                                                       0.796          0.352          £609,305            25.8%\n",
            "Area in sq ft, No. of Bedrooms, Outcode & Postcode (Target) - xgboost                                0.723 ±0.030   0.395 ±0.013   £605,580 ±58,106    30.3 ±1.7%\n",
            "→ Test Results                                                                                       0.803          0.346          £595,773            25.4%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (Target) - decision_tree                                     0.676 ±0.034   0.427 ±0.019   £690,905 ±83,924    35.3 ±2.5%\n",
            "→ Test Results                                                                                       0.773          0.371          £624,460            27.6%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (Target) - random_forest                                     0.801 ±0.035   0.334 ±0.026   £539,583 ±85,688    26.4 ±2.4%\n",
            "→ Test Results                                                                                       0.848          0.303          £522,523            22.7%\n",
            "Area in sq ft, No. of Bedrooms, Outcode (Target) - xgboost                                           0.768 ±0.036   0.361 ±0.021   £567,053 ±51,093    28.9 ±1.9%\n",
            "→ Test Results                                                                                       0.893          0.255          £441,535            18.9%\n",
            "Area in sq ft, No. of Bedrooms, Postcode & Location (Target) - decision_tree                         0.714 ±0.043   0.401 ±0.028   £629,937 ±89,960    32.1 ±2.9%\n",
            "→ Test Results                                                                                       0.731          0.404          £682,535            31.7%\n",
            "Area in sq ft, No. of Bedrooms, Postcode & Location (Target) - random_forest                         0.826 ±0.028   0.313 ±0.024   £501,877 ±81,545    24.3 ±2.0%\n",
            "→ Test Results                                                                                       0.820          0.331          £593,340            25.7%\n",
            "Area in sq ft, No. of Bedrooms, Postcode & Location (Target) - xgboost                               0.817 ±0.026   0.321 ±0.020   £507,086 ±64,768    24.8 ±1.9%\n",
            "→ Test Results                                                                                       0.829          0.322          £567,664            24.9%\n",
            "Area in sq ft, No. of Bedrooms, Postcode (Target) - decision_tree                                    0.678 ±0.045   0.426 ±0.030   £684,976 ±88,547    34.6 ±3.2%\n",
            "→ Test Results                                                                                       0.705          0.424          £710,687            33.1%\n",
            "Area in sq ft, No. of Bedrooms, Postcode (Target) - random_forest                                    0.806 ±0.029   0.331 ±0.023   £529,864 ±72,323    25.6 ±2.1%\n",
            "→ Test Results                                                                                       0.798          0.350          £625,943            26.9%\n",
            "Area in sq ft, No. of Bedrooms, Postcode (Target) - xgboost                                          0.788 ±0.033   0.346 ±0.026   £551,667 ±74,311    26.8 ±2.5%\n",
            "→ Test Results                                                                                       0.795          0.353          £599,651            26.8%\n",
            "Area in sq ft, No. of Bedrooms, Price/sqft - decision_tree                                           0.807 ±0.019   0.330 ±0.009   £543,178 ±22,019    26.0 ±0.6%\n",
            "→ Test Results                                                                                       0.831          0.320          £547,331            24.4%\n",
            "Area in sq ft, No. of Bedrooms, Price/sqft - random_forest                                           0.889 ±0.011   0.250 ±0.011   £396,340 ±50,669    19.0 ±0.8%\n",
            "→ Test Results                                                                                       0.901          0.245          £415,297            18.3%\n",
            "Area in sq ft, No. of Bedrooms, Price/sqft - xgboost                                                 0.878 ±0.010   0.262 ±0.012   £418,338 ±56,646    20.1 ±1.0%\n",
            "→ Test Results                                                                                       0.895          0.253          £450,222            18.9%\n"
          ]
        }
      ],
      "source": [
        "def ATLAS_pipeline(df_with_outcode: pd.DataFrame) -> pd.DataFrame:\n",
        "    \"\"\"Run complete pipeline from raw data to model comparison\"\"\"\n",
        "\n",
        "    preprocessor = PreProcessor()\n",
        "\n",
        "    # Create pre-split features\n",
        "    df_processed = preprocessor.prepare_pre_split_features(df_with_outcode)\n",
        "\n",
        "    # Create initial train/test split\n",
        "    train_data, test_data = preprocessor.create_train_test_split(df_processed)\n",
        "\n",
        "    # Run cross-validation evaluation\n",
        "    validator = CrossValidator()\n",
        "    results = validator.evaluate_all_combinations(train_data, test_data)\n",
        "\n",
        "    return results\n",
        "\n",
        "# Time the pipeline execution\n",
        "print(\"Running ATLAS pipeline (estimated time: 2 minutes)...\")\n",
        "\n",
        "results = ATLAS_pipeline(df_with_outcode)\n",
        "\n",
        "\n",
        "# Display key information about the results DataFrame\n",
        "print(\"\\nResults DataFrame Info:\")\n",
        "print(f\"Shape: {results.shape}\")\n",
        "print(\"\\nFirst few rows:\")\n",
        "print(results.head())\n",
        "\n",
        "def display_results(results: pd.DataFrame) -> None:\n",
        "    \"\"\"\n",
        "    Display model performance summary with cross-validation and test results.\n",
        "\n",
        "    Args:\n",
        "        results: DataFrame containing model evaluation results with columns:\n",
        "                feature_set, model, split_type, r2, rmse, mae, pct_mae, description\n",
        "    \"\"\"\n",
        "    print(\"\\nModel Performance Summary:\")\n",
        "    print(\"-\" * 170)\n",
        "\n",
        "    # Print header\n",
        "    header = \"Features - Model\".ljust(100) + \" \"\n",
        "    header += \"CV R²\".ljust(15)\n",
        "    header += \"CV RMSE\".ljust(15)\n",
        "    header += \"CV MAE (£)\".ljust(20)\n",
        "    header += \"CV %Error\".ljust(20)\n",
        "    print(header)\n",
        "    print(\"-\" * 170)\n",
        "\n",
        "    for (feature_set, model), group in results.groupby(['feature_set', 'model']):\n",
        "        cv_results = group[group['split_type'] == 'cv_fold']\n",
        "        test_results = group[group['split_type'] == 'test'].iloc[0]\n",
        "\n",
        "        # Create feature_model string using description\n",
        "        feature_model = f\"{test_results['description']} - {model}\"\n",
        "\n",
        "        # Print CV results\n",
        "        cv_line = feature_model.ljust(100) + \" \"\n",
        "        cv_line += f\"{cv_results['r2'].mean():.3f} ±{cv_results['r2'].std():.3f}\".ljust(15)\n",
        "        cv_line += f\"{cv_results['rmse'].mean():.3f} ±{cv_results['rmse'].std():.3f}\".ljust(15)\n",
        "        cv_line += f\"£{cv_results['mae'].mean():,.0f} ±{cv_results['mae'].std():,.0f}\".ljust(20)\n",
        "        cv_line += f\"{cv_results['pct_mae'].mean():.1f} ±{cv_results['pct_mae'].std():.1f}%\"\n",
        "        print(cv_line)\n",
        "\n",
        "        # Print test results (indented)\n",
        "        test_line = \"→ Test Results\".ljust(100) + \" \"\n",
        "        test_line += f\"{test_results['r2']:.3f}\".ljust(15)\n",
        "        test_line += f\"{test_results['rmse']:.3f}\".ljust(15)\n",
        "        test_line += f\"£{test_results['mae']:,.0f}\".ljust(20)\n",
        "        test_line += f\"{test_results['pct_mae']:.1f}%\"\n",
        "        print(test_line)\n",
        "\n",
        "# Usage:\n",
        "display_results(results)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "znHR3cx9805P"
      },
      "source": [
        "<a name=\"unveiling-the-drivers-of-london-house-prices\"></a>\n",
        "## Unveiling the drivers of London house prices\n",
        "\n",
        "Our exploration of London house price prediction, guided by the ATLAS pipeline, has yielded a wealth of insights. By systematically comparing a diverse set of models and feature combinations, we've gained a nuanced understanding of the key drivers of property value in this complex market. This analysis will delve into the performance of our top models, the impact of including price information, the effectiveness of our feature engineering techniques, and the implications of our findings for both model deployment and further research.\n",
        "\n",
        "<a name=\"top-performing-models\"></a>\n",
        "### Top performing models\n",
        "\n",
        "Among the myriad of models evaluated, three have distinguished themselves with their exceptional performance:\n",
        "\n",
        "| Model                                                                          | CV R²         | Test R²      | CV MAE (£)       | Test MAE (£)  |\n",
        "|-------------------------------------------------------------------------------|---------------|--------------|------------------|---------------|\n",
        "| Random Forest with All Features                                               | 0.903 ±0.011  | 0.912        | £368,595 ±49,041 | £387,417      |\n",
        "| XGBoost with All Features                                                     | 0.899 ±0.009  | 0.913        | £379,417 ±55,543 | £397,701      |\n",
        "| Random Forest with Area, Bedrooms, House Type, Outcode (Target), and Price/sqft | 0.902 ±0.012 | 0.907        | £372,747 ±48,481 | £416,147      |\n",
        "\n",
        "These models have achieved remarkable accuracy, explaining over 90% of the price variance (as measured by R²) in both cross-validation and on the unseen test set. Their mean absolute errors (MAE) range from around £370,000 to £420,000, which, while substantial in absolute terms, are quite reasonable given the high prices and wide price range in the London market.\n",
        "\n",
        "The strong and consistent performance of these models across both cross-validation and the test set is a testament to the robustness of our modeling approach. It suggests that these models have successfully captured the underlying patterns and relationships in the data, rather than simply memorising noise or idiosyncrasies of the training set.\n",
        "\n",
        "<a name=\"the-price-information-paradox\"></a>\n",
        "### The price information paradox\n",
        "\n",
        "One of the most striking findings from our experiments is the significant impact of including price-derived features, such as the average price per square foot at the outcode level. Models that incorporate this information consistently outperform those that don't, with improvements in MAE ranging from £40,000 to £50,000.\n",
        "\n",
        "This improvement in accuracy is substantial and underscores the importance of considering current market conditions in property valuation. By providing the models with information about prevailing price levels in different areas, we enable them to make more context-aware predictions.\n",
        "\n",
        "However, this boost in performance comes with a important caveat. By including current price information, our models risk amplifying feedback loops in the housing market. If such models were to be widely adopted and used to inform pricing decisions, they could potentially exacerbate both upward and downward price trends. In a rising market, the models would predict higher prices, which could in turn drive actual prices higher if used to set asking prices or guide bidding. Conversely, in a falling market, the models could contribute to a downward spiral.\n",
        "\n",
        "This is a well-known challenge in the real estate industry, and one that major players like Zoopla and Rightmove actively monitor and manage. It highlights the importance of considering not just the accuracy of our models, but also their potential impact on the market they seek to predict.\n",
        "\n",
        "<a name=\"models-without-price-information\"></a>\n",
        "### Models without price information\n",
        "\n",
        "Given the potential risks associated with including current price information, it's worth examining the performance of models that rely solely on fundamental property characteristics and location.\n",
        "\n",
        "Among these models, several stand out:\n",
        "\n",
        "| Model                                                                            | CV R²         | Test R²      | CV MAE (£)       | Test MAE (£)  |\n",
        "|--------------------------------------------------------------------------------|---------------|--------------|------------------|---------------|\n",
        "| XGBoost with Area, Bedrooms, and Outcode (One-hot)                              | 0.881 ±0.013  | 0.899        | £418,617 ±58,112 | £432,491      |\n",
        "| Random Forest with Area, Bedrooms, Location (Target)                            | 0.822 ±0.031  | 0.815        | £506,152 ±84,254 | £593,446      |\n",
        "| Random Forest with Area, Bedrooms, House Type, City/County, Outcode (Target)    | 0.855 ±0.023  | 0.887        | £447,107 ±54,538 | £449,116      |\n",
        "\n",
        "While these models don't quite match the accuracy of those including price information, they still achieve impressive performance. With R² scores mostly in the 0.80 to 0.90 range and MAEs around £400,000 to £600,000, they demonstrate that a substantial portion of a property's value can be explained by its intrinsic characteristics and location.\n",
        "\n",
        "These models provide a valuable perspective on the fundamental drivers of house prices, independent of current market conditions. They can help identify areas or property types that may be over- or under-valued relative to their inherent attributes. In practice, such models could be used in conjunction with price-aware models to provide a more comprehensive view of a property's value.\n",
        "\n",
        "<a name=\"the-importance-of-validation\"></a>\n",
        "### The importance of validation\n",
        "\n",
        "A crucial aspect of our modeling process that deserves highlighting is the rigor of our validation strategy. By employing stratified k-fold cross-validation, we ensure that our performance estimates are reliable and representative of the models' true predictive power.\n",
        "\n",
        "Stratified k-fold cross-validation involves splitting the data into k folds (in our case, 5), while ensuring that each fold has a similar distribution of the target variable (price). The model is then trained k times, each time using k-1 folds for training and the remaining fold for validation. The performance is then averaged across all k validation folds.\n",
        "\n",
        "This approach has several advantages over a simple train-test split:\n",
        "1. It provides a more robust estimate of model performance, as it averages over k different train-test splits rather than relying on a single split.\n",
        "2. By stratifying the folds based on the target variable, it ensures that each fold is representative of the overall data distribution, reducing the risk of lucky or unlucky splits.\n",
        "\n",
        "Moreover, by maintaining a strict separation between our training and validation data within each fold, and between all the training folds and the final test set, we avoid the pitfalls of data leakage and overfitting. Data leakage occurs when information from the validation or test sets inadvertently leaks into the model training process, leading to overly optimistic performance estimates. Overfitting happens when a model learns to fit the noise or peculiarities of the training data, rather than the underlying patterns, leading to poor generalisation to new data.\n",
        "\n",
        "Our models' strong and consistent performance across the cross-validation folds and on the unseen test set demonstrates that they have successfully learned genuine patterns in the data and can generalise well to new, unseen properties. This is crucial for real-world application, where the model will be applied to properties it has never seen before.\n",
        "\n",
        "<a name=\"feature-engineering-the-art-of-extracting-signal-from-the-noise\"></a>\n",
        "### Feature engineering: The art of extracting signal from the noise\n",
        "\n",
        "Another key lesson from our analysis is the importance and nuance of feature engineering, particularly when dealing with geographical data.\n",
        "\n",
        "Our geographical features presented a hierarchy of granularity:\n",
        "- Outcode (e.g., \"SW1\")\n",
        "- Postcode (e.g., \"SW1A 1AA\")\n",
        "- Location (e.g., \"Westminster\")\n",
        "\n",
        "Each level provided a different trade-off between specificity and data sparsity. While more granular levels (like location) can potentially provide more specific information, they also suffer from data sparsity, with many locations having very few or even just one property.\n",
        "\n",
        "Our solution was a hierarchical target encoding scheme. For each level, we calculated the mean price in the training data. Then, when encoding a particular property, if the specific level (e.g., postcode) had sufficient data, we used its mean price. If not, we fell back to the mean price of the next higher level (e.g., outcode). This way, we extracted as much specific information as the data allowed, while still providing a robust fallback for sparse levels.\n",
        "\n",
        "This encoding scheme proved very effective, with models using these features achieving strong performance. It demonstrates that, with careful engineering, geographical information can be a powerful predictor of house prices, even without resorting to complex geospatial techniques.\n",
        "\n",
        "Beyond geographical features, our experiments also highlighted the predictive power of even simple property attributes like area, number of bedrooms, and property type. Models using just these features achieved respectable performance, forming a strong baseline upon which more complex models could improve.\n",
        "\n",
        "\n",
        "<a name=\"ethical-considerations-human-impact-and-future-directions\"></a>\n",
        "### Ethical considerations, human impact, and future directions\n",
        "\n",
        "As we marvel at the predictive power of our models, it's crucial that we also pause to consider the ethical implications of our work. Housing is not just a financial asset, but a fundamental human need. The prices predicted by our models have real consequences for real people - they can determine whether a family can afford to buy their dream home, whether a pensioner can comfortably retire, or whether a young professional can afford to live near their work.\n",
        "\n",
        "With this in mind, we have a responsibility to ensure that our models are not just accurate, but also fair and unbiased. We must be vigilant to potential sources of bias in our data and algorithms, and work to mitigate them. For example, if our training data under-represents certain areas or demographic groups, our models may learn to undervalue these properties, perpetuating or even amplifying existing inequalities.\n",
        "\n",
        "Moreover, we must consider the potential unintended consequences of our models' usage. If used improperly, such as to guide predatory pricing practices or to justify rent hikes, our models could harm the very people they're meant to serve. It's our responsibility to ensure that our models are used ethically and for the benefit of all stakeholders.\n",
        "\n",
        "On a more positive note, our models also have the potential to empower individuals and promote transparency in the housing market. By providing accurate and unbiased valuations, they can help buyers and sellers make informed decisions, reducing information asymmetries and the potential for exploitation. They can also help policymakers and urban planners better understand the dynamics of the housing market, informing policies that promote affordability and social equity.\n",
        "\n",
        "Our journey into London house price prediction has been one of technical exploration, but also one of growing awareness of the human implications of our work. We've seen the power of machine learning to uncover complex patterns and dynamics in the housing market, but also the potential pitfalls and ethical considerations that come with this power.\n",
        "\n",
        "As we look to the future, several exciting directions beckon:\n",
        "\n",
        "1. **Ensemble methods**: Given the strong performance of multiple models, combining their predictions through techniques like stacking or blending could potentially yield even greater accuracy and robustness.\n",
        "\n",
        "2. **Advanced feature engineering**: While our current features have proven effective, there's always room for refinement. Techniques like feature interaction, clustering, or dimensional reduction could uncover additional predictive signals.\n",
        "\n",
        "3. **Temporal dynamics**: Our current models provide a static snapshot of the market. Incorporating temporal features like price trends, economic indicators, or seasonal effects could enable more dynamic and forward-looking predictions.\n",
        "\n",
        "4. **Model interpretability**: As powerful as our models are, their complexity can hinder interpretation. Techniques like feature importance analysis, partial dependence plots, or SHAP values could help shed light on how the models make their predictions, increasing transparency and trust.\n",
        "\n",
        "5. **Application and deployment**: Finally, the true test of our models will be in their application to real-world pricing decisions. This will require not just technical excellence, but also close collaboration with domain experts to ensure the models are used appropriately and responsibly.\n",
        "\n",
        "As we embark on these future directions, let us proceed with a commitment to not just technical excellence, but also to social responsibility. Let us strive to build models that are not just accurate, but also fair, transparent, and beneficial to all. Let us engage closely with the communities impacted by our work, learning from their perspectives and ensuring that our models serve their needs.\n",
        "\n",
        "In doing so, we have the potential to not just predict house prices, but to contribute to a housing market that is more efficient, more equitable, and more responsive to the needs of its participants. This is the ultimate promise and challenge of our work - to use the power of data and algorithms to build a better, fairer world for all.\n",
        "\n",
        "As we conclude this phase of our journey, let us do so with gratitude for the insights gained, with humility in the face of the challenges ahead, and with hope for the positive impact we can make. Ultimately, the true measure of our success will not be just the accuracy of our predictions, but the positive impact we have on the lives of those touched by the housing market. The path forward is not always clear or easy, but with ATLAS as our guide and our values as our compass, I am confident that we will navigate it successfully, one home at a time.\n",
        "\n",
        "### Thanks for learning!\n",
        "\n",
        "This notebook is part of the Supervised Machine Learning from First Principles series.\n",
        "\n",
        "Our ATLAS implementation builds upon the robust foundation provided by [Scikit-learn's decision tree framework](https://scikit-learn.org/stable/modules/tree.html) and [XGBoost's gradient boosting implementation](https://xgboost.readthedocs.io/en/stable/tutorials/model.html). For those interested in the housing market context, the [UK House Price Index](https://www.gov.uk/government/collections/uk-house-price-index-reports) provides authoritative data on market trends and regional variations.\n",
        "\n",
        "Our geographic encoding approach draws inspiration from target encoding techniques detailed in [\"Feature Engineering for Machine Learning: Principles and Techniques for Data Scientists\"](https://www.oreilly.com/library/view/feature-engineering-for/9781491953235/) (Zhang and Casari, O'Reilly Media, 2018).\n",
        "\n",
        "© 2025 Powell-Clark Limited. Licensed under Apache License 2.0.\n",
        "\n",
        "If you found this helpful, please cite as:\n",
        "```\n",
        "Powell-Clark (2025). Supervised Machine Learning from First Principles.\n",
        "GitHub: https://github.com/powell-clark/supervised-machine-learning\n",
        "```\n",
        "\n",
        "Questions or feedback? Contact emmanuel@powellclark.com"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.10.16"
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "5243ffeca0754ad3a7443529dd29882d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_444169ebf4e44ff698f27757a47300b6",
              "IPY_MODEL_fc69b05692f74895ad760b44867b7d61",
              "IPY_MODEL_7ac3dde068444e8fb67d6b9a8331e7bd"
            ],
            "layout": "IPY_MODEL_03d77e1968ea428184db8ba164a106b5"
          }
        },
        "444169ebf4e44ff698f27757a47300b6": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_ac0b1cd52910407a9a680d72e86cc1fe",
            "placeholder": "​",
            "style": "IPY_MODEL_5a9febae15914fa79714cb07a2bf71ee",
            "value": "Folds: 100%"
          }
        },
        "fc69b05692f74895ad760b44867b7d61": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c5cdb552da004475b33133b129e36ca8",
            "max": 5,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_81a52c4f9ff949b3a25b1b9bb746fbdb",
            "value": 5
          }
        },
        "7ac3dde068444e8fb67d6b9a8331e7bd": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_cc274e96e11c426b9add21817fafbdfb",
            "placeholder": "​",
            "style": "IPY_MODEL_2ea7ef064cad4493a4870f547fd5a14c",
            "value": " 5/5 [01:55&lt;00:00, 20.51s/it]"
          }
        },
        "03d77e1968ea428184db8ba164a106b5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "ac0b1cd52910407a9a680d72e86cc1fe": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "5a9febae15914fa79714cb07a2bf71ee": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c5cdb552da004475b33133b129e36ca8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "81a52c4f9ff949b3a25b1b9bb746fbdb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "cc274e96e11c426b9add21817fafbdfb": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "2ea7ef064cad4493a4870f547fd5a14c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "59dd1761502c4722874895b3157af829": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_4e1cb57f828b4210b0d960a18b5ec46f",
              "IPY_MODEL_4fb4f3cde909411ea5931a9c8d9ae283",
              "IPY_MODEL_2b5e851806bf42e0bfea7e9832ae5ec8"
            ],
            "layout": "IPY_MODEL_2e50e1354dba4dd898b826e3754bd8c7"
          }
        },
        "4e1cb57f828b4210b0d960a18b5ec46f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_235ae07841b7431aa7cd3260c3f998a4",
            "placeholder": "​",
            "style": "IPY_MODEL_10974c0ea18c4c45ac248f41850b9dae",
            "value": "Fold 1 Progress: 100%"
          }
        },
        "4fb4f3cde909411ea5931a9c8d9ae283": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_d81e45fcb77f42048baf95a555f2bcf7",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_9002532511f94762921823b7cab849ae",
            "value": 45
          }
        },
        "2b5e851806bf42e0bfea7e9832ae5ec8": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_572fb815839d43999d2dc4c8ac53ed3e",
            "placeholder": "​",
            "style": "IPY_MODEL_8c38ff54c9df40a1a4a8a5832cc33767",
            "value": " 45/45 [00:41&lt;00:00,  1.96it/s]"
          }
        },
        "2e50e1354dba4dd898b826e3754bd8c7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "235ae07841b7431aa7cd3260c3f998a4": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "10974c0ea18c4c45ac248f41850b9dae": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "d81e45fcb77f42048baf95a555f2bcf7": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9002532511f94762921823b7cab849ae": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "572fb815839d43999d2dc4c8ac53ed3e": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "8c38ff54c9df40a1a4a8a5832cc33767": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "49ec8e9bcff742b78d4816e8d9a712de": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_16cb74dc78ae47c5a90078479e755856",
              "IPY_MODEL_b81de64f20d24adeb42e8fce037b10eb",
              "IPY_MODEL_1fa63178e2ee4a8c8f39ffa53a7efa1f"
            ],
            "layout": "IPY_MODEL_b5c69a1121a9472bb69c4d211c9845f5"
          }
        },
        "16cb74dc78ae47c5a90078479e755856": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c107b4711f7b46229181abad6ab7aea3",
            "placeholder": "​",
            "style": "IPY_MODEL_db9a7b2149af41d79c209a88526fb353",
            "value": "Fold 2 Progress: 100%"
          }
        },
        "b81de64f20d24adeb42e8fce037b10eb": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_02f5554ffc204c799f46fa5ad6c678dc",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_79872a7f47414332950edda87d44c30d",
            "value": 45
          }
        },
        "1fa63178e2ee4a8c8f39ffa53a7efa1f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_a91d589b0d1d473d89941f9a861159e1",
            "placeholder": "​",
            "style": "IPY_MODEL_1223398cf21541f986a86047f2dd0ca3",
            "value": " 45/45 [00:18&lt;00:00,  1.58it/s]"
          }
        },
        "b5c69a1121a9472bb69c4d211c9845f5": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c107b4711f7b46229181abad6ab7aea3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "db9a7b2149af41d79c209a88526fb353": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "02f5554ffc204c799f46fa5ad6c678dc": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "79872a7f47414332950edda87d44c30d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "a91d589b0d1d473d89941f9a861159e1": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1223398cf21541f986a86047f2dd0ca3": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3b4f69b2c1594f5e9d5564711e3cacf5": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_ae0ff5d6b09d4a9d934b2300e771aca2",
              "IPY_MODEL_4d74c51cf005468188947b62f5cf2897",
              "IPY_MODEL_bdc747a22ab4470e9d1aa6c4c8b1947b"
            ],
            "layout": "IPY_MODEL_ba7e0f6496a04b64ac869242a596fbde"
          }
        },
        "ae0ff5d6b09d4a9d934b2300e771aca2": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_34251a75a0dc4c0595d6d4b453219f8c",
            "placeholder": "​",
            "style": "IPY_MODEL_1075fe82ea314442afb5a52d39938a66",
            "value": "Fold 3 Progress: 100%"
          }
        },
        "4d74c51cf005468188947b62f5cf2897": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_f189ef3d7c7f4873b8a12131c13d3246",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_a6f8647b3b484d758d6bb8985efeb74d",
            "value": 45
          }
        },
        "bdc747a22ab4470e9d1aa6c4c8b1947b": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_42afa3222228487a88b51f68cd0b3c25",
            "placeholder": "​",
            "style": "IPY_MODEL_1327b77e21b04042af754599a3353a21",
            "value": " 45/45 [00:17&lt;00:00,  2.13it/s]"
          }
        },
        "ba7e0f6496a04b64ac869242a596fbde": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "34251a75a0dc4c0595d6d4b453219f8c": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1075fe82ea314442afb5a52d39938a66": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "f189ef3d7c7f4873b8a12131c13d3246": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a6f8647b3b484d758d6bb8985efeb74d": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "42afa3222228487a88b51f68cd0b3c25": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "1327b77e21b04042af754599a3353a21": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3dd148bee18c4bc3811cddfbf70ec6cc": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_45923c7b89ec40adaa187af7e2faf023",
              "IPY_MODEL_bfa0e7618fb9436abdfb0ba6275eb048",
              "IPY_MODEL_9357f2d3194b4278bc8ca271b1dba314"
            ],
            "layout": "IPY_MODEL_44368d80e7004722b4bd1c5cd71e0cfe"
          }
        },
        "45923c7b89ec40adaa187af7e2faf023": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_53ddf0baa895412d9d8a42c8866101df",
            "placeholder": "​",
            "style": "IPY_MODEL_eb0ff59586a24b57a76dfe6118a1ea38",
            "value": "Fold 4 Progress: 100%"
          }
        },
        "bfa0e7618fb9436abdfb0ba6275eb048": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_761ad6d2a8df49f0b396b9987a39ea36",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_b8412e6602d14b6eaaf05712b163cc4c",
            "value": 45
          }
        },
        "9357f2d3194b4278bc8ca271b1dba314": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_744ace51c08249bd992e57e165b86503",
            "placeholder": "​",
            "style": "IPY_MODEL_9f9e2c9bea984a5597ad1bd0c5272d13",
            "value": " 45/45 [00:17&lt;00:00,  2.22it/s]"
          }
        },
        "44368d80e7004722b4bd1c5cd71e0cfe": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "53ddf0baa895412d9d8a42c8866101df": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "eb0ff59586a24b57a76dfe6118a1ea38": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "761ad6d2a8df49f0b396b9987a39ea36": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "b8412e6602d14b6eaaf05712b163cc4c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "744ace51c08249bd992e57e165b86503": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "9f9e2c9bea984a5597ad1bd0c5272d13": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "a79961efc6544a648a672941c6b25f5e": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_7de6a0883f5b40e0b23eb163b5744070",
              "IPY_MODEL_250f4aaa41d44da3a13cc454e271784f",
              "IPY_MODEL_e5f2f69e271341f5833d98981cd172fe"
            ],
            "layout": "IPY_MODEL_1dc325c572a345a3aa545ab3cfb828bd"
          }
        },
        "7de6a0883f5b40e0b23eb163b5744070": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_384d516a386d447d9c84cb7607e90755",
            "placeholder": "​",
            "style": "IPY_MODEL_047786fc443a45ae8f0274fe1fcf62ae",
            "value": "Fold 5 Progress: 100%"
          }
        },
        "250f4aaa41d44da3a13cc454e271784f": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_a2fdb19fee4d46d480f77b26265c726a",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_7f2913b820ec4f9caf193155d99b88ad",
            "value": 45
          }
        },
        "e5f2f69e271341f5833d98981cd172fe": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_7ecbb095dc3845408bb0aee9c47f1c0f",
            "placeholder": "​",
            "style": "IPY_MODEL_a32c788118dd46d28ccc4f9961a9d132",
            "value": " 45/45 [00:19&lt;00:00,  2.00it/s]"
          }
        },
        "1dc325c572a345a3aa545ab3cfb828bd": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "384d516a386d447d9c84cb7607e90755": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "047786fc443a45ae8f0274fe1fcf62ae": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "a2fdb19fee4d46d480f77b26265c726a": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "7f2913b820ec4f9caf193155d99b88ad": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "7ecbb095dc3845408bb0aee9c47f1c0f": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a32c788118dd46d28ccc4f9961a9d132": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "269c27dce4a6482b9ecea79055a96849": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HBoxModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_4f3a951b523e42e38a32993679b75543",
              "IPY_MODEL_9fb7e721eb2c47849b5c6bbc220f2c6c",
              "IPY_MODEL_72a750499ac54430bf7591fadbff8020"
            ],
            "layout": "IPY_MODEL_21330d2eb6574a39897bb520b71302ee"
          }
        },
        "4f3a951b523e42e38a32993679b75543": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_19cd6ce234ca48caace237c932adf1b8",
            "placeholder": "​",
            "style": "IPY_MODEL_f34718136ce84ca2be79a11b304d5899",
            "value": "Test Set Evaluation: 100%"
          }
        },
        "9fb7e721eb2c47849b5c6bbc220f2c6c": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "FloatProgressModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "FloatProgressModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ProgressView",
            "bar_style": "success",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_c06289343fa44269bf6393619ab831e3",
            "max": 45,
            "min": 0,
            "orientation": "horizontal",
            "style": "IPY_MODEL_65bf2f4b28904b0bb58d046c5548416a",
            "value": 45
          }
        },
        "72a750499ac54430bf7591fadbff8020": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "HTMLModel",
          "model_module_version": "1.5.0",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_4ddc0cf5d70c4f95848bd74b8b0fdc97",
            "placeholder": "​",
            "style": "IPY_MODEL_672886119ace4ca887b7f9f5e55f8548",
            "value": " 45/45 [00:21&lt;00:00,  1.44it/s]"
          }
        },
        "21330d2eb6574a39897bb520b71302ee": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "19cd6ce234ca48caace237c932adf1b8": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "f34718136ce84ca2be79a11b304d5899": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "c06289343fa44269bf6393619ab831e3": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "65bf2f4b28904b0bb58d046c5548416a": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "ProgressStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ProgressStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "bar_color": null,
            "description_width": ""
          }
        },
        "4ddc0cf5d70c4f95848bd74b8b0fdc97": {
          "model_module": "@jupyter-widgets/base",
          "model_name": "LayoutModel",
          "model_module_version": "1.2.0",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "672886119ace4ca887b7f9f5e55f8548": {
          "model_module": "@jupyter-widgets/controls",
          "model_name": "DescriptionStyleModel",
          "model_module_version": "1.5.0",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}