From 23c6b3ef96e48585b4c6862927e2aef6453ad29e Mon Sep 17 00:00:00 2001 From: Ulrich <ulrich.kerzel@rwth-aachen.de> Date: Wed, 12 Mar 2025 09:15:20 +0100 Subject: [PATCH] add solution to new exercises --- .../solutions/AutoGrad_Solution.ipynb | 461 +++ .../PhysicsInformedNN_Solution.ipynb | 880 +++++ ...n_ContinuousCasting_ConicSteelVessel.ipynb | 927 ++++++ .../solutions/Solution_CyclicBoosting.ipynb | 2872 +++++++++++++++++ .../Solution_RootFinding_Newton.ipynb | 386 +++ 5 files changed, 5526 insertions(+) create mode 100644 datascienceintro/solutions/AutoGrad_Solution.ipynb create mode 100644 datascienceintro/solutions/PhysicsInformedNN_Solution.ipynb create mode 100644 datascienceintro/solutions/Solution_ContinuousCasting_ConicSteelVessel.ipynb create mode 100644 datascienceintro/solutions/Solution_CyclicBoosting.ipynb create mode 100644 datascienceintro/solutions/Solution_RootFinding_Newton.ipynb diff --git a/datascienceintro/solutions/AutoGrad_Solution.ipynb b/datascienceintro/solutions/AutoGrad_Solution.ipynb new file mode 100644 index 0000000..5e2c4ab --- /dev/null +++ b/datascienceintro/solutions/AutoGrad_Solution.ipynb @@ -0,0 +1,461 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Computing Gradients in PyTorch\n", + "\n", + "[PyTorch](https://pytorch.org/) is a comprehensive library that is primarily used for machine learning. However, it can also be used as an effective way to handle matrix operations or gradients.\n", + "In particular for the latter, we can exploit the fact that training neural networks requires calculating gradients efficiently as this is the backbone of the algorithms for training the networks.\n", + "\n", + "Therefore, if we can formute our problem at hand in such a way that we can use PyTorch, we can use the inbuilt methods to compute and obtain the gradients.\n", + "In PyTorch, this is done via [AutoGrad](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html).\n", + "\n", + "In this example, we use a simple sine-function: Using such a simple function makes it easy for any neural network to learn the functional dependency. Moreover, we can compare this to the well known derivative: $\\frac{d \\sin(x)}{d x} = \\cos(x)$, which makes it immediately obvious if we have learned the correct gradient." + ], + "metadata": { + "id": "xyl4csp7yEbk" + } + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "from torch import nn\n", + "import torch.optim as optim\n", + "import torch.nn.functional as F\n", + "\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import numpy as np\n", + "\n", + "# Get cpu or gpu device for training.\n", + "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", + "print(f\"Using {device} device\")\n", + "\n", + "seed = 42\n", + "np.random.seed(seed)\n", + "torch.manual_seed(seed)\n", + "torch.cuda.manual_seed(seed)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rxyiP-tSyIPg", + "outputId": "05dd72f4-c7d5-4af9-ba67-2a55c08bf1b5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Using cpu device\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Training Data\n", + "\n", + "In this simple example, we will use $f(x) = \\sin(x)$ to generate training data.\n", + "First of all, the releationship is very simple, i.e. even small networks will be able to learn this quickly. Additionally, we know what the gradient will look like: $\\frac{dy}{dx} = \\cos(x)$, i.e. we know immediately if the network has learned the correct gradient.\n", + "\n", + "The function [torch.linspace](https://pytorch.org/docs/stable/generated/torch.linspace.html) is the equivalent to numpy version but produces a tensor directly.\n", + "The part ```.view(-1,1)``` re-shapes the resulting array such that we have one feature: torch.linspace creates a tensor with shape (100), i.e. a 1D tensor with 100 elements. The ```-1``` is a placeholder to tell PyTorch to infer the length automatically from the number of elements in the original tensor. The ```1``` tells PyTorch to reformat the data such that we have one feature. The resulting tensor has a shape of (100,1), i.e. 100 rows of 1 feature each." + ], + "metadata": { + "id": "KX6GlXtUysE9" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "\n", + "Create training data ```x_train``` and ```y_train``` for a $sin(x)$ function in the interval $x_{train} \\in (0, 2\\pi)$.\n", + "\n", + "Plot the resulting training data." + ], + "metadata": { + "id": "aeKM4U2ellXN" + } + }, + { + "cell_type": "code", + "source": [ + "##\n", + "## Your code here\n", + "##" + ], + "metadata": { + "id": "Ta5rGSisl58h" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "JoWaGzuPl7tm" + } + }, + { + "cell_type": "code", + "source": [ + "# Generate training data based using sin(x)\n", + "x_train = torch.linspace(0, 2 * torch.pi, steps=100, device=device).view(-1, 1)\n", + "y_train = torch.sin(x_train)\n", + "\n", + "sns.lineplot(x=x_train.numpy().flatten(),\n", + " y=y_train.numpy().flatten(), label='sin(x)')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "8NCpW8Z4yuLT", + "outputId": "035546af-9a0b-4c08-cdcb-47183c5dc9df" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Network Definition and Training\n", + "\n", + "We now define a very small neural network, for example a \"shallow\" network with just three fully connected layers.\n", + "\n", + "- How many input nodes do we need?\n", + "- How many output nodes do we need?\n", + "\n", + "Here, we need one input node, since we pass one value at the time to the network: $y = \\sin(x)$.\n", + "\n", + "Similarly, we only need one output node as we want the network to learn a single number." + ], + "metadata": { + "id": "mu-cy0lXyu7z" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "\n", + "Write a class for a small neural network with three fully-connected (linear) layers and $\\tanh(x)$ as activatin function.\n", + "\n", + "Discuss how many input and output nodes the network needs." + ], + "metadata": { + "id": "LKl2PBVxl_H3" + } + }, + { + "cell_type": "code", + "source": [ + "class NeuralNetwork(nn.Module):\n", + " def __init__(self):\n", + " super(NeuralNetwork, self).__init__()\n", + " ##\n", + " ## your code here\n", + " ##\n", + "\n", + " def forward(self, x):\n", + " ##\n", + " ## your code here\n", + " ##\n", + " return x\n", + "\n", + "model = NeuralNetwork().to(device)\n", + "print(model)" + ], + "metadata": { + "id": "yyY9odYjmQMm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "VbMn4wAvma26" + } + }, + { + "cell_type": "code", + "source": [ + "# A simple Neural Network\n", + "\n", + "class NeuralNetwork(nn.Module):\n", + " def __init__(self):\n", + " super(NeuralNetwork, self).__init__()\n", + " self.flatten = nn.Flatten()\n", + " self.fc1 = nn.Linear(1, 50)\n", + " self.fc2 = nn.Linear(50, 50)\n", + " self.fc3 = nn.Linear(50, 1)\n", + "\n", + " def forward(self, x):\n", + " x = self.fc1(x)\n", + " x = F.tanh(x)\n", + " x = self.fc2(x)\n", + " x = F.tanh(x)\n", + " x = self.fc3(x)\n", + " return x\n", + "\n", + "model = NeuralNetwork().to(device)\n", + "print(model)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3I8E4V-OyWOt", + "outputId": "8b855e66-6660-4794-ec47-362f6513742d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "NeuralNetwork(\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (fc1): Linear(in_features=1, out_features=50, bias=True)\n", + " (fc2): Linear(in_features=50, out_features=50, bias=True)\n", + " (fc3): Linear(in_features=50, out_features=1, bias=True)\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Train model\n", + "\n", + "\n", + "# Define the optimizer and loss function\n", + "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", + "\n", + "# Training loop\n", + "num_epochs = 1000\n", + "loss_history = []\n", + "\n", + "for epoch in range(num_epochs):\n", + " # Enable gradient tracking for time steps\n", + " x_train.requires_grad = True\n", + "\n", + " # Forward pass: Predict\n", + " predictions = model(x_train)\n", + "\n", + " # Compute the data loss (difference from sin(x))\n", + " # using the mean squared error as a loss-function for regression\n", + " data_loss = torch.mean((predictions - y_train) ** 2)\n", + "\n", + " # Compute the gradient dt/dx using torch.autograd.grad\n", + " dy_train = torch.autograd.grad(\n", + " outputs=predictions,\n", + " inputs=x_train,\n", + " grad_outputs=torch.ones_like(predictions),\n", + " create_graph=True\n", + " )[0]\n", + "\n", + " # Physics loss: Enforce the relationship dy/dx = cos(x)\n", + " physics_loss = torch.mean((dy_train- torch.cos(x_train)) ** 2)\n", + "\n", + " # Total loss: Combine data and physics losses\n", + " total_loss = data_loss + physics_loss\n", + "\n", + " # Backward pass and optimization step\n", + " optimizer.zero_grad()\n", + " total_loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Record the loss\n", + " loss_history.append(total_loss.item())\n", + "\n", + " # Print progress every 100 epochs\n", + " if epoch % 100 == 0:\n", + " print(f\"Epoch {epoch}/{num_epochs}, Total Loss: {total_loss.item():.6f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AxNeglAYzqzf", + "outputId": "3ac54803-87d8-4b10-cf43-3900fc8987e7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 0/1000, Total Loss: 1.043527\n", + "Epoch 100/1000, Total Loss: 0.000421\n", + "Epoch 200/1000, Total Loss: 0.000122\n", + "Epoch 300/1000, Total Loss: 0.001010\n", + "Epoch 400/1000, Total Loss: 0.000005\n", + "Epoch 500/1000, Total Loss: 0.000433\n", + "Epoch 600/1000, Total Loss: 0.000004\n", + "Epoch 700/1000, Total Loss: 0.000003\n", + "Epoch 800/1000, Total Loss: 0.001428\n", + "Epoch 900/1000, Total Loss: 0.000008\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.lineplot(loss_history, label='Training loss')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 455 + }, + "id": "wpmM_03k0gZh", + "outputId": "98b8277d-e929-4c50-bb25-204b83fb47cd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Plot the Gradient\n", + "\n", + "We now check if the network has learned the correct gradient, i.e. $\\frac{dy}{dx} = \\cos(x)$\n", + "\n", + "We generate some independent numbers on the same domain, obtain the predictions $\\hat{y}$ and plot:\n", + "- the ground truth: $y = \\sin(x)$,\n", + "- the predictions $\\hat{y}$\n", + "- the gradient" + ], + "metadata": { + "id": "xnVeLeA211hL" + } + }, + { + "cell_type": "code", + "source": [ + "# Prepare test data with requires_grad=True\n", + "x_test = torch.linspace(0, 2 * torch.pi, steps=200, device=device, requires_grad=True).view(-1, 1)\n", + "y_test = torch.sin(torch.tensor(x_test))\n", + "\n", + "# predictions from the trained model\n", + "y_hat = model(x_test)\n", + "\n", + "#gradient\n", + "dy_dx = torch.autograd.grad(\n", + " outputs=y_hat,\n", + " inputs=x_test,\n", + " grad_outputs=torch.ones_like(y_hat),\n", + " create_graph=True\n", + ")[0]\n", + "\n", + "# detach from GPU and graph\n", + "x_test = x_test.detach().cpu().numpy().flatten()\n", + "y_test = y_test.detach().cpu().numpy().flatten()\n", + "y_hat = y_hat.detach().cpu().numpy().flatten()\n", + "dy_dx = dy_dx.detach().cpu().numpy().flatten()\n", + "\n", + "\n", + "\n", + "# Plot predictions and gradients\n", + "sns.lineplot(x=x_test, y=y_test, label='sin(x) (Ground Truth)')\n", + "sns.lineplot(x=x_test, y=y_hat, label='Prediction')\n", + "sns.lineplot(x=x_test, y=dy_dx, label='Predicted Gradient')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 506 + }, + "id": "jKniVE8M10qA", + "outputId": "f6e1fe97-f0e0-431d-8103-4c223020c24d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "<ipython-input-6-1f4b339fb796>:3: UserWarning: To copy construct from a tensor, it is recommended to use sourceTensor.clone().detach() or sourceTensor.clone().detach().requires_grad_(True), rather than torch.tensor(sourceTensor).\n", + " y_test = torch.sin(torch.tensor(x_test))\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/datascienceintro/solutions/PhysicsInformedNN_Solution.ipynb b/datascienceintro/solutions/PhysicsInformedNN_Solution.ipynb new file mode 100644 index 0000000..eee08f0 --- /dev/null +++ b/datascienceintro/solutions/PhysicsInformedNN_Solution.ipynb @@ -0,0 +1,880 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Physics Informed Neural Networks\n", + "\n", + "In \"standard\" machine learning, we assume that we only know the data-points, i.e. our training data where a set of features $\\vec{X}$ are mapped to the corresponding labels $\\vec{y}$.\n", + "\n", + "However, in many cases, we know more about the system we want to study. For example, we may have a physical model in the form of differential equations. Describing the system then amounts to solving these differential equations given some boundary constraints (for example, some measurements).\n", + "However, in many cases, while we know the differential equations, we do not know an analytical solution and need to find the solution numerically. This is computationally very expensive.\n", + "\n", + "Physics-informed neural networks are based on the idea that we can use our additional knowledge to \"guide\" the network to the appropriate solution.\n", + "This approach was proposed in:\n", + "\n", + "\n", + "> Raissi, M., Perdikaris, P., & Karniadakis, G. E. (2019). Physics-informed neural networks: A deep learning framework for solving forward and inverse problems involving nonlinear partial differential equations. Journal of Computational physics, 378, 686-707. [ScienceDirect](https://www.sciencedirect.com/science/article/abs/pii/S0021999118307125)\n", + "\n", + "In this example, we model a simple system where an object cools in a reservoir.\n", + "The reservoir is at ambient temperature, i.e. $T_{reservoir} = 298 K$ and the object is initially $250 K$ warmer.\n", + "\n", + "The differential equation describing the physcis of the system is given by\n", + "$\\frac{dT}{dt} = - \\frac{T(t) - T_{reservoir}}{\\tau}$, where $\\tau$ is some characteristic time constant describing our system (i.e. $\\frac {1}{\\tau}$ is the cooling rate).\n", + "This is a very common type of differential equation of the form $\\frac{dX}{dt} = -kt$ and it is easy to show that this can be solved by the exponential equation.\n", + "Here, the analytical solution is easily obtained as\n", + "$T(t) = T_{reservoir} + (T(t=0) - T_{reservoir}) \\cdot e^{-t/\\tau}$.\n", + "\n", + "However, we want to use the physics-informed neural network to learn from the data and the known differential equation.\n" + ], + "metadata": { + "id": "2MGjQVkBPYg0" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qdyrl-ecPVIB", + "outputId": "25bc162b-a76b-4abd-9406-a0fca0d7957a" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "run on: cuda\n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import torch\n", + "from torch import nn\n", + "\n", + "# small package that prints a concise summary of the\n", + "# network architecture and number of paramters in each layer\n", + "from torchsummary import summary\n", + "\n", + "seed = 10\n", + "np.random.seed(seed)\n", + "torch.manual_seed(seed)\n", + "\n", + "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n", + "print('run on: {}'.format(device))" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# General Setups" + ], + "metadata": { + "id": "CmrXfbx2ugFA" + } + }, + { + "cell_type": "code", + "source": [ + "T_reservoir = 298\n", + "T_start = T_reservoir + 250\n", + "tau = 200\n", + "\n", + "# plot theory curve as \"n_theory\" data points so we get a smooth curve\n", + "n_theory = 1000\n", + "\n", + "# generate a few \"data\" points with the same equation\n", + "n_data = 10\n", + "n_data_max = 300" + ], + "metadata": { + "id": "sFnyv6_Rujx1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def get_temperature(t:float, T_reservoir :float , T_start : float , tau : float) -> float :\n", + " return T_reservoir + (T_start - T_reservoir) * np.exp(-t/tau)" + ], + "metadata": { + "id": "9w0gIwxyPttk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Network\n", + "\n", + "Here, we implement a small neural network.\n", + "Because we later want to be able to compare the effect of using a physics based\n", + "loss function, we encapsulate everything from setup of the network to the training loop as a class.\n", + "By default, we use the mean squared error as the \"data loss\", i.e. the function we typically use for regression tasks, and pass an optional argument for the\n", + "physics loss function. If this argument is not none, we assume that we pass a function that evaluates the physics-based loss that can then be added to the data loss for the total loss function to be opitmised.\n", + "\n", + "We also stick to the [scikit-learn](https://scikit-learn.org/stable/) convention of using ```fit``` and ```predict``` methods.\n", + "\n", + "In order to be flexible regarding the network setup, we pass a python\n", + "list that details the number of hidden nodes. We can then iterate over that\n", + "list and add layers accordingly, each time adding [ReLU](https://pytorch.org/docs/stable/generated/torch.nn.ReLU.html) as a non-linear activation function.\n", + "\n", + "For simplicity, we hard-code a number of other aspects, such as using the [Adam](https://pytorch.org/docs/stable/generated/torch.optim.Adam.html) optimiser, etc." + ], + "metadata": { + "id": "4QDT457Ust1Y" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "Complete the following class definition\n" + ], + "metadata": { + "id": "cuXeO8Mrhd4G" + } + }, + { + "cell_type": "code", + "source": [ + "class Network(nn.Module):\n", + " def __init__(self, input_size : int, output_size : int, hidden_units : list[int],\n", + " loss_fn = nn.MSELoss(), physics_loss_fn = None,\n", + " n_epochs = 30000, learn_rate = 1e-5,\n", + " physics_loss_weight = 1.0,\n", + " device='cpu') -> None:\n", + " super(Network, self).__init__()\n", + " self.input_size = input_size\n", + " self.output_size = output_size\n", + " self.hidden_units = hidden_units\n", + " self.loss_fn = loss_fn\n", + " self.physics_loss_fn = physics_loss_fn\n", + " self.n_epochs = n_epochs\n", + " self.learn_rate = learn_rate\n", + " self.physics_loss_weight = physics_loss_weight\n", + " self.device = device\n", + "\n", + " # here, we define the network architecture.\n", + " # we are goint to use fully connected networks and each layer\n", + " # is followed by a RELU activation function.\n", + " # we specify the list of layers as an array, so we do not need\n", + " # to hard-code the network architecture.\n", + " modules = []\n", + " modules.append(nn.Linear(input_size, hidden_units[0]))\n", + " modules.append(nn.ReLU())\n", + " for i in range(len(hidden_units)-1):\n", + " modules.append(nn.Linear(hidden_units[i], hidden_units[i+1]))\n", + " modules.append(nn.ReLU())\n", + "\n", + " # now build a network from the list of layers\n", + " self.layers = nn.Sequential(*modules)\n", + "\n", + " # the output layer has one node in our case:\n", + " # we have one number as input and predict one number as output\n", + " self.output_layer = nn.Linear(hidden_units[-1], output_size)\n", + "\n", + " # move to GPU if we have one\n", + " self.to(device)\n", + "\n", + " # Forward pass of the network - we need to implement this\n", + " def forward(self, x):\n", + " ##\n", + " ## your code here\n", + " ##\n", + " return x\n", + "\n", + " # a litte \"magic\" to convert an array of plain numbers\n", + " # (how we have generated the training data) to PyTorch tensors that\n", + " # we then move to the device we work on (e.g. GPU)\n", + " def to_tensor(self, x):\n", + " return torch.from_numpy(x).to(torch.float).to(self.device).reshape(len(x), -1)\n", + "\n", + " # keep consistent with the scikit-learn interface\n", + " def fit(self, X, y) -> list:\n", + " X_tensor = self.to_tensor(X)\n", + " y_tensor = self.to_tensor(y)\n", + "\n", + " optimizer = ## your code here\n", + "\n", + " # put model into train mode\n", + " self.train()\n", + " loss_values = []\n", + " for i in range(self.n_epochs):\n", + " ##\n", + " ## your code here\n", + " ##\n", + "\n", + " if self.physics_loss_fn:\n", + " loss += self.physics_loss_weight * self.physics_loss_fn(self)\n", + "\n", + " ##\n", + " ## your code here\n", + " ##\n", + " loss_values.append(loss.item())\n", + "\n", + " if i % int(self.n_epochs/10) == 0:\n", + " print(f\"Epoch {i}/{self.n_epochs}, loss: {loss_values[-1]:.2f}\")\n", + "\n", + "\n", + " return loss_values\n", + "\n", + " def predict(self, X):\n", + " self.eval()\n", + " X_tensor = self.to_tensor(X)\n", + " predictions = # your code here\n", + " return predictions.detach().cpu().numpy()" + ], + "metadata": { + "id": "JtVq9FC_hhjT" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "QJXIMVkVhZou" + } + }, + { + "cell_type": "code", + "source": [ + "class Network(nn.Module):\n", + " def __init__(self, input_size : int, output_size : int, hidden_units : list[int],\n", + " loss_fn = nn.MSELoss(), physics_loss_fn = None,\n", + " n_epochs = 30000, learn_rate = 1e-5,\n", + " physics_loss_weight = 1.0,\n", + " device='cpu') -> None:\n", + " super(Network, self).__init__()\n", + " self.input_size = input_size\n", + " self.output_size = output_size\n", + " self.hidden_units = hidden_units\n", + " self.loss_fn = loss_fn\n", + " self.physics_loss_fn = physics_loss_fn\n", + " self.n_epochs = n_epochs\n", + " self.learn_rate = learn_rate\n", + " self.physics_loss_weight = physics_loss_weight\n", + " self.device = device\n", + "\n", + " # here, we define the network architecture.\n", + " # we are goint to use fully connected networks and each layer\n", + " # is followed by a RELU activation function.\n", + " # we specify the list of layers as an array, so we do not need\n", + " # to hard-code the network architecture.\n", + " modules = []\n", + " modules.append(nn.Linear(input_size, hidden_units[0]))\n", + " modules.append(nn.ReLU())\n", + " for i in range(len(hidden_units)-1):\n", + " modules.append(nn.Linear(hidden_units[i], hidden_units[i+1]))\n", + " modules.append(nn.ReLU())\n", + "\n", + " # now build a network from the list of layers\n", + " self.layers = nn.Sequential(*modules)\n", + "\n", + " # the output layer has one node in our case:\n", + " # we have one number as input and predict one number as output\n", + " self.output_layer = nn.Linear(hidden_units[-1], output_size)\n", + "\n", + " # move to GPU if we have one\n", + " self.to(device)\n", + "\n", + " # Forward pass of the network - we need to implement this\n", + " def forward(self, x):\n", + " x = self.layers(x)\n", + " x = self.output_layer(x)\n", + " return x\n", + "\n", + " # a litte \"magic\" to convert an array of plain numbers\n", + " # (how we have generated the training data) to PyTorch tensors that\n", + " # we then move to the device we work on (e.g. GPU)\n", + " def to_tensor(self, x):\n", + " return torch.from_numpy(x).to(torch.float).to(self.device).reshape(len(x), -1)\n", + "\n", + " # keep consistent with the scikit-learn interface\n", + " def fit(self, X, y) -> list:\n", + " X_tensor = self.to_tensor(X)\n", + " y_tensor = self.to_tensor(y)\n", + "\n", + " optimizer = torch.optim.Adam(self.parameters(), lr=self.learn_rate)\n", + "\n", + " # put model into train mode\n", + " self.train()\n", + " loss_values = []\n", + " for i in range(self.n_epochs):\n", + " optimizer.zero_grad()\n", + " pred = self.forward(X_tensor)\n", + " loss = self.loss_fn(pred, y_tensor)\n", + "\n", + " if self.physics_loss_fn:\n", + " loss += self.physics_loss_weight * self.physics_loss_fn(self)\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + " loss_values.append(loss.item())\n", + "\n", + " if i % int(self.n_epochs/10) == 0:\n", + " print(f\"Epoch {i}/{self.n_epochs}, loss: {loss_values[-1]:.2f}\")\n", + "\n", + "\n", + " return loss_values\n", + "\n", + " def predict(self, X):\n", + " self.eval()\n", + " X_tensor = self.to_tensor(X)\n", + " predictions = self.forward(X_tensor)\n", + " return predictions.detach().cpu().numpy()\n", + "\n" + ], + "metadata": { + "id": "Qyw7O_TPstBY" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Physics-Informed Loss Function\n", + "\n", + "The PINN use two loss functions, the \"normal\" machine-learning loss function, as well as the physics-based loss function.\n", + "The \"normal\" loss function is the same we use for standard machine learning applications, such as the MSE for regression problems.\n", + "\n", + "The physics-based loss function is used to make our knowledge of the physical system available to the neural network during training. Essentially, this is where we encode the known partial differential equations (and their parameters) into what the neural network uses during trainig.\n", + "\n", + "Instead of solving the differential equations ourselves or numerically otherwise, we can use of the functionality of the machine learning framework to compute gradients. In Pytorch, this is done via [autograd.grad](https://pytorch.org/docs/stable/generated/torch.autograd.grad.html), also see the [Introduction to autograd](https://pytorch.org/tutorials/beginner/blitz/autograd_tutorial.html).\n", + "\n", + "In this example, we effectively give the solution to the neural network and, because this is a simeple example, we not only know that the analytical solution exists but can also derive it easily.\n", + "However, in other scenarios we may know the differential equations and some boundary conditions (like our measurements), but computing a numerical solution to these equations is computationally costly." + ], + "metadata": { + "id": "a5UJIStNzDu_" + } + }, + { + "cell_type": "code", + "source": [ + "# physics informed loss function\n", + "def physics_loss(model: nn.Module) -> torch.float:\n", + "\n", + " # create a number of steps that are used to evaluate the physics model\n", + " # here, we use n_theory steps to evaluate the current model between\n", + " # 0 and n_theory\n", + " # requires_grad = True: we need to track the gradients in our later\n", + " # evaluation of the PDE\n", + " # view(-1,1) : reshape the output to the format (n_theory,1) since the\n", + " # algorithms typically require the data to be in the format\n", + " # (batch_size, features)\n", + " # The -1 indicates that PyTorch should infer the appropriate\n", + " # size automatically.\n", + " steps = torch.linspace(0, end = n_theory, steps = n_theory,\n", + " requires_grad=True,\n", + " device=device).view(-1,1)\n", + "\n", + "\n", + " # use the current state of the model to predict the full temperature curve\n", + " current_predictions = model(steps)\n", + "\n", + "\n", + " # calculate gradients to evaluate physics PDE effectively\n", + " # computes the gradient of the temperature\n", + " # output=current_predictions: The predictions of the model (current state)\n", + " # input=steps: The tensor with respect to which we want the gradient\n", + " # Here, these are the time-steps that we want to predict the\n", + " # cooling of the system\n", + " # grad_outputs=torch.ones_like(current_predictions):\n", + " # Specifies the gradient of the output with respect to itself.\n", + " # This is set to 1 for all outputs because we compute\n", + " # derivatives of the temperature T at time t without scaling\n", + " # The output is a tensor dT of the same shape as current_predictions\n", + " dT = torch.autograd.grad(outputs=current_predictions,\n", + " inputs=steps,\n", + " grad_outputs=torch.ones_like(current_predictions),\n", + " create_graph=True)[0]\n", + "\n", + " # use the (known) differential equation (PDE) to calculate the contribution\n", + " # to the loss function\n", + " # -> this is where we put our exisiting knowledge in.\n", + " pde = 1.0/tau * (T_reservoir - current_predictions) - dT\n", + " return torch.mean(pde**2)" + ], + "metadata": { + "id": "r_ZaBppluaN5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Generate data\n", + "\n", + "Use the differntial equation (or rather, the known analytical function here) to generate some (simulated) data.\n", + "\n", + "We generate two sets of arrays:\n", + "```x_space``` contains the steps we want to evaluate the \"theory-curve\". Since we need to plot the curve later, we need to evaluate this at a number of points. ```y_space``` holds the correspoinding temperature values.\n", + "\n", + "The second set of arrays are then used to contain the \"training data\", i.e. our observed \"measurements\". Essentially, this is what we want to constrain the network to, given the partial differential equation that we know describes the behaviour of our system.\n", + "Here, we only use few data points in the array ```x_train``` and we also add some noise to the \"measurements\" ```y_train```." + ], + "metadata": { + "id": "OphtJnU0QltZ" + } + }, + { + "cell_type": "code", + "source": [ + "x_space = np.linspace(0, n_theory, n_theory)\n", + "y_space = get_temperature(x_space, T_reservoir, T_start, tau)\n", + "\n", + "\n", + "# now generate some training \"data\" from the known model.\n", + "# we add a little bit of noise to simulate that the data are not perfect\n", + "# Note that the training data do not cover the whole range of where we would\n", + "# like to apply the network. Instead, we aim that the network learns the\n", + "# underlying physical model and can extrapolate to the region outside the\n", + "# training data.\n", + "x_train = np.linspace(0, n_data_max, n_data)\n", + "y_train = get_temperature(x_train, T_reservoir, T_start, tau) + 2.5 * np.random.randn(10)\n", + "\n", + "# plot \"data\" and curve from theory\n", + "sns.lineplot(x=x_space, y=y_space, color = 'k', label='Theory')\n", + "sns.scatterplot(x=x_train, y=y_train, color = 'r', markers='o', label='Training data')\n", + "\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Temperature (K)')\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "nlUHDWRaQpWw", + "outputId": "94c27a50-0d6b-4953-b8d2-b498cc6bd3c5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAYHJJREFUeJzt3XlcVPXixvHPsAoiiwvggluauOBuinXV0kDFUrNSM5fSupmZaZp581bqTcvbvllpV7MszFJLc8HMJfcVVyR3TAVcEFSU9fz+IObn5MYocGB43q/XecGc75mZ53AoHs82FsMwDERERESk2HMyO4CIiIiI5A8VOxEREREHoWInIiIi4iBU7EREREQchIqdiIiIiINQsRMRERFxECp2IiIiIg5CxU5ERETEQbiYHaAoyM7O5sSJE5QpUwaLxWJ2HBERERErwzA4f/48lSpVwsnpxvvkVOyAEydOEBQUZHYMERERkes6duwYVapUueEyKnZAmTJlgJwfmLe3t8lpRERERP5fSkoKQUFB1r5yIyp2YD386u3trWInIiIiRVJeThfTxRMiIiIiDkLFTkRERMRBqNiJiIiIOAidYyciIlKAsrKyyMjIMDuGFGGurq44Ozvny2up2ImIiBQAwzCIj4/n3LlzZkeRYsDX15fAwMDbvp+uip2IiEgByC11/v7+eHp66gb4ck2GYZCamkpiYiIAFStWvK3XU7ETERHJZ1lZWdZSV65cObPjSBHn4eEBQGJiIv7+/rd1WFYXT4iIiOSz3HPqPD09TU4ixUXu78rtno+pYiciIlJAdPhV8iq/fldU7ERERCRPVq5cicVi0QUhRZiKnYiIiGCxWG44vf7662ZHlDzQxROFISkJEhIgORl8fcHfH/z8zE4lIiJidfLkSev3s2fP5tVXXyU2NtY6z8vLiy1btpgRjfT0dNzc3Ex57+JGe+wK2rFj0KsX1K0LrVpBcHDO42PHzE4mIiJiFRgYaJ18fHywWCw287y8vKzLbt26lebNm+Pp6Unr1q1tCiDATz/9RNOmTSlVqhQ1a9Zk3LhxZGZmWsfj4uLo2rUrXl5eeHt78+ijj5KQkGAdf/3112ncuDHTpk2jRo0alCpVipkzZ1KuXDnS0tJs3qtbt2707du3gH4qxY+pxe7111+/aldvcHCwdbxdu3ZXjT/zzDM2rxEXF0dERASenp74+/szatQom18eUyUlwaBBEBVlOz8qKmd+UpI5uURERG7DK6+8wjvvvMOWLVtwcXHhySeftI79/vvv9OvXj2HDhrF3714+//xzZsyYwRtvvAFAdnY2Xbt25ezZs6xatYply5Zx6NAhevbsafMeBw4c4Mcff2Tu3LlER0fzyCOPkJWVxc8//2xdJjExkV9++cXm/Us60w/F1q9fn19//dX62MXFNtJTTz3F+PHjrY+vvHQ8KyuLiIgIAgMDWbduHSdPnqRfv364uroyceLEgg9/MwkJV5e6XFFROeM6JCsiUiLk3oi2sBXEzZHfeOMN2rZtC8DLL79MREQEly9fplSpUowbN46XX36Z/v37A1CzZk0mTJjASy+9xGuvvcby5cvZtWsXhw8fJigoCICZM2dSv359Nm/eTIsWLYCcw68zZ86kQoUK1vd97LHHmD59Oo888ggA33zzDVWrVqVdu3b5un7FmenFzsXFhcDAwOuOe3p6Xnc8KiqKvXv38uuvvxIQEEDjxo2ZMGECo0eP5vXXXzf/eHxy8u2Ni4iIw0hNTbU5nFlYLly4QOnSpfP1NRs2bGj9PveTEhITE6latSo7duxg7dq11j10kLMj5vLly6SmphITE0NQUJC11AHUq1cPX19fYmJirMWuWrVqNqUOcnb2tGjRguPHj1O5cmVmzJjBgAEDdFuZK5h+jt3+/fupVKkSNWvWpE+fPsTFxdmMz5o1i/Lly9OgQQPGjBlj86+d9evXExISQkBAgHVeeHg4KSkp7Nmz57rvmZaWRkpKis1UIHx8bm9cRESkCHJ1dbV+n1uqsrOzgZwiOW7cOKKjo63Trl272L9/P6VKlcrze1yrjDZp0oRGjRoxc+ZMtm7dyp49exgwYMDtrYyDMXWPXcuWLZkxYwZ16tTh5MmTjBs3jn/84x/s3r2bMmXK8Nhjj1GtWjUqVarEzp07GT16NLGxscydOxfI+Ry+K0sdYH0cHx9/3fedNGkS48aNK7gV+/8wEBZ27cOxYWE54yIiUiJ4enpy4cIFU963MDVt2pTY2Fhq1ap1zfG6dety7Ngxjh07Zt1rt3fvXs6dO0e9evVu+vqDBg3i/fff5/jx43To0MFmz5+YXOw6depk/b5hw4a0bNmSatWq8f333zNw4ECefvpp63hISAgVK1akffv2HDx4kDvuuOOW33fMmDGMGDHC+jglJaVgfjH8/GDatKsvoAgLy5mv8+tEREoMi8WS74dEi6JXX32VLl26ULVqVR5++GGcnJzYsWMHu3fv5j//+Q8dOnQgJCSEPn368P7775OZmcmzzz5L27Ztad68+U1f/7HHHmPkyJFMnTqVmTNnFsIaFS+mH4q9kq+vL3feeScHDhy45njLli0BrOOBgYE2l0cD1sc3Om/P3d0db29vm6nABAWx4cUXefyBB3h94ECIiYHISNC/MERExAGFh4ezcOFCoqKiaNGiBa1ateK9996jWrVqQE7B/emnn/Dz86NNmzZ06NCBmjVrMnv27Dy9vo+PDz169MDLy4tu3boV4JoUTxbDMAyzQ+S6cOECVatW5fXXX+f555+/anzt2rXcc8897Nixg4YNG7J48WK6dOnCyZMn8ff3B+CLL75g1KhRJCYm4u7unqf3TUlJwcfHh+Tk5AIpeXPnzqVHjx7ceeedV93rR0REHM/ly5c5fPiw9R5skr/at29P/fr1+fDDD82Okm9u9DtjT08xdY/dyJEjWbVqFUeOHGHdunV0794dZ2dnevfuzcGDB5kwYQJbt27lyJEj/Pzzz/Tr1482bdpYr8YJCwujXr169O3blx07drB06VLGjh3LkCFD8lzqCkP79u1xdnbmjz/+4NChQ2bHERERKZaSkpKYN28eK1euZMiQIWbHKZJMLXZ//vknvXv3pk6dOjz66KOUK1eODRs2UKFCBdzc3Pj1118JCwsjODiYF198kR49erBgwQLr852dnVm4cCHOzs6Ehoby+OOP069fP5v73hUFPj4+tG7dGoClS5eanEZERKR4atKkCQMGDOCtt96iTp06Zscpkky9eCIyMvK6Y0FBQaxateqmr1GtWjUWLVqUn7EKRMeOHfn9999ZsmQJgwcPNjuOiIhIsXPkyBGzIxR5ReriCUfWsWNHAJYvX056errJaURERMQRqdgVksaNGxMQEMDFixdZu3at2XFERETEAanYFRInJyfCw8MBWLJkiclpRERExBGp2BWi3MOxKnYiIiJSEFTsCtH999+PxWJh586dnDhxwuw4IiIi4mBU7ApR+fLladGiBaDbnoiIiEj+U7ErZDocKyIiJUn16tV5//3387z8ypUrsVgsnDt3rsAyXc+MGTPw9fUt9PfNTyp2hSy32C1btozMzEyT04iIiOSwWCw3nF5//fVbet3Nmzfz9NNP53n51q1bc/LkSXx8fG7p/QqbvcW1oJl6g+KSqEWLFvj5+ZGUlMTmzZsJDQ01O5KIiAgnT560fj979mxeffVVm8839/Lysn5vGAZZWVm4uNy8RlSoUMGuHG5ubgQGBtr1HPl/2mNXyFxcXLj//vsBHY4VEZGiIzAw0Dr5+PhgsVisj/ft20eZMmVYvHgxzZo1w93dnTVr1nDw4EG6du1KQEAAXl5etGjRgl9//dXmdf++R8tisTBt2jS6d++Op6cntWvX5ueff7aO//1QbO7h0aVLl1K3bl28vLzo2LGjTRHNzMzk+eefx9fXl3LlyjF69Gj69+9Pt27dbrjOM2bMoGrVqnh6etK9e3fOnDljM36z9WvXrh1Hjx5l+PDh1j2bAGfOnKF3795UrlwZT09PQkJC+O677+zZHLdMxc4EOs9ORETyJCkJ9u2DjRshNjbnsYlefvll3nzzTWJiYmjYsCEXLlygc+fOLF++nO3bt9OxY0ceeOAB4uLibvg648aN49FHH2Xnzp107tyZPn36cPbs2esun5qayttvv83XX3/N6tWriYuLY+TIkdbxt956i1mzZjF9+nTWrl1LSkoK8+fPv2GGjRs3MnDgQJ577jmio6O59957+c9//mOzzM3Wb+7cuVSpUoXx48dz8uRJa9m8fPkyzZo145dffmH37t08/fTT9O3bl02bNt0wU74wxEhOTjYAIzk5uVDe7/jx4wZgWCwW49SpU4XyniIiUnguXbpk7N2717h06dKtv0hcnGGEhRkG/P8UFpYzv4BNnz7d8PHxsT5esWKFARjz58+/6XPr169vfPTRR9bH1apVM9577z3rY8AYO3as9fGFCxcMwFi8eLHNeyUlJVmzAMaBAwesz/nkk0+MgIAA6+OAgADjv//9r/VxZmamUbVqVaNr167Xzdm7d2+jc+fONvN69uxps963sn7XExERYbz44ovXHb/R74w9PUV77ExQqVIlGjZsiGEYLFu2zOw4IiJS1CQlwaBBEBVlOz8qKme+SXvumjdvbvP4woULjBw5krp16+Lr64uXlxcxMTE33WPXsGFD6/elS5fG29ubxMTE6y7v6enJHXfcYX1csWJF6/LJyckkJCRw1113WcednZ1p1qzZDTPExMTQsmVLm3l/P+/9VtcvKyuLCRMmEBISQtmyZfHy8mLp0qU3fV5+ULEziQ7HiojIdSUkXF3qckVF5YyboHTp0jaPR44cybx585g4cSK///470dHRhISEkJ6efsPXcXV1tXlssVjIzs62a3nDMOxMb79bXb///ve/fPDBB4wePZoVK1YQHR1NeHj4TZ+XH1TsTHJlsbvRL7OIiJRAycm3N15I1q5dy4ABA+jevTshISEEBgZy5MiRQs3g4+NDQEAAmzdvts7Lyspi27ZtN3xe3bp12bhxo828DRs22DzOy/q5ubmRlZV11fO6du3K448/TqNGjahZsyZ//PHHLayd/VTsTHLPPfdYdz1v2bLF7DgiIlKU3OwebkXkHm+1a9dm7ty5REdHs2PHDh577DFTdlYMHTqUSZMm8dNPPxEbG8uwYcNISkqyXqV6Lc8//zxLlizh7bffZv/+/Xz88cdXHUXLy/pVr16d1atXc/z4cU6fPm193rJly1i3bh0xMTH885//JKGQ9rKq2JnE1dWV8PBwABYuXGhyGhERKVICAiAs7NpjYWE540XAu+++i5+fH61bt+aBBx4gPDycpk2bFnqO0aNH07t3b/r160doaCheXl6Eh4dTqlSp6z6nVatWTJ06lQ8++IBGjRoRFRXF2LFjbZbJy/qNHz+eI0eOcMcdd1jv2Td27FiaNm1KeHg47dq1IzAw8Ka3XskvFqMwDlIXcSkpKfj4+JCcnIy3t3ehve/MmTPp378/TZo0uekuYxERKT4uX77M4cOHqVGjxg3LxQ0dO3b1BRRhYTBtGgQF5U9QB5WdnU3dunV59NFHmTBhgtlx8uRGvzP29BR98oSJOnXqhMViYfv27Rw/fpzKlSubHUlERIqKoCCIjMy5UCI5Oefwa0AA+PmZnazIOXr0KFFRUbRt25a0tDQ+/vhjDh8+zGOPPWZ2tEKnQ7EmqlChgvVS60WLFpmcRkREihw/PwgOhpYtc76q1F2Tk5MTM2bMoEWLFtx9993s2rWLX3/9lbp165odrdCp2JmsS5cugM6zExERuVVBQUGsXbuW5ORkUlJSWLduHW3atDE7lilU7EwWEREBwK+//sqlS5dMTiMiIiLFmYqdyRo1akTlypVJTU1l5cqVZscRERGRYkzFzmQWi8V6OPaXX34xOY2IiOQn3XhC8iq/fldU7IqAK8+z0/8ERESKv9yPwEpNTTU5iRQXub8rf//4NHvpdidFwH333UepUqU4evQoe/bsoUGDBmZHEhGR2+Ds7Iyvr6/1g+o9PT1v+CkIUnIZhkFqaiqJiYn4+vri7Ox8W6+nYlcEeHp6ct9997Fo0SIWLlyoYici4gACAwMBrOVO5EZ8fX2tvzO3Q8WuiOjSpQuLFi3il19+4eWXXzY7joiI3CaLxULFihXx9/cnIyPD7DhShLm6ut72nrpcKnZFRO5tT9atW8eZM2coV66cyYlERCQ/ODs759sfbZGb0cUTRUTVqlUJCQkhOzubJUuWmB1HREREiiEVuyJEn0IhIiIit0PFrgjJLXaLFy/W+RgiIiJiNxW7IqRly5ZUqFCB5ORkVq1aZXYcERERKWZU7IoQZ2dnHnzwQQB++uknk9OIiIhIcaNiV8R069YNgPnz5+tTKERERMQuKnZFTPv27fH09OTPP/9k27ZtZscRERGRYkTFrojx8PCgY8eOgA7HioiIiH1U7Iqgrl27AjmHY0VERETySsWuCIqIiMDZ2Zldu3Zx6NAhs+OIiIhIMaFiVwSVK1eONm3aADocKyIiInmnYldE5R6OVbETERGRvFKxK6Jyi93vv//O6dOnTU4jIiIixYGKXRFVvXp1GjduTHZ2tj47VkRERPJExa4I0+FYERERsYeKXRGW+ykUS5cuJTU11dwwIiIiUuSp2BVhjRo1olq1aly6dIlff/3V7DgiIiJSxKnYFWEWi+X/b1Y8ezbs2wcbN0JsLCQlmZxOREREihoVuyIu93Dsz3PmkFm3LrRqBcHB0KsXHDtmbjgREREpUlTsirh/NGhAOVdXzmRksPrKgagoGDRIe+5ERETESsWuiHM5c4ZuGRkA/PD3wagoSEgo9EwiIiJSNKnYFXXJyTz817fzgKxrjIuIiIiAil3R5+PDfYAvEA+su8a4iIiICKjYFX0BAbiFhdH1r4c2h2PDwiAgwIRQIiIiUhSp2BV1fn4wbRo9GjcG4EcgG3JK3bRpOeMiIiIiqNgVD0FB3L9oEWVKl+Y4sOm77yAyEoKCzE4mIiIiRYiKXTFRqmJFHvjrZsU/bNmiPXUiIiJyFRW7YqRHjx4A/PDDDxiGYXIaERERKWpU7IqRjh074unpydGjR9m6davZcURERKSIUbErRjw9PYmIiADgxx9/NDmNiIiIFDUqdsXMww/n3K5Yh2NFRETk71TsipnOnTtTqlQpDhw4wM6dO82OIyIiIkWIil0x4+XlRceOHYGcvXYiIiIiuUwtdq+//joWi8VmCg4Oto5fvnyZIUOGUK5cOby8vOjRowcJf/vQ+7i4OCIiIvD09MTf359Ro0aRmZlZ2KtSqHQ4VkRERK7F9D129evX5+TJk9ZpzZo11rHhw4ezYMEC5syZw6pVqzhx4gQPPfSQdTwrK4uIiAjS09NZt24dX331FTNmzODVV181Y1UKTZcuXXBzc2Pfvn3s3r3b7DgiIiJSRJhe7FxcXAgMDLRO5cuXByA5OZkvv/ySd999l/vuu49mzZoxffp01q1bx4YNGwCIiopi7969fPPNNzRu3JhOnToxYcIEPvnkE9LT081crQLl4+ND586dAYiMjDQ5jYiIiBQVphe7/fv3U6lSJWrWrEmfPn2Ii4sDYOvWrWRkZNChQwfrssHBwVStWpX169cDsH79ekJCQggICLAuEx4eTkpKCnv27CncFSlkvXr1AnKKnQ7HioiICJhc7Fq2bMmMGTNYsmQJU6ZM4fDhw/zjH//g/PnzxMfH4+bmhq+vr81zAgICiI+PByA+Pt6m1OWO545dT1paGikpKTZTcdOlSxc8PT05dOgQW7ZsMTuOiIiIFAGmFrtOnTrxyCOP0LBhQ8LDw1m0aBHnzp3j+++/L9D3nTRpEj4+PtYpKCioQN+vIJQuXZoHH3wQ0OFYERERyWH6odgr+fr6cuedd3LgwAECAwNJT0/n3LlzNsskJCQQGBgIQGBg4FVXyeY+zl3mWsaMGUNycrJ1OnbsWP6uSCHJPRw7e/ZssrOzTU4jIiIiZitSxe7ChQscPHiQihUr0qxZM1xdXVm+fLl1PDY2lri4OEJDQwEIDQ1l165dJCYmWpdZtmwZ3t7e1KtX77rv4+7ujre3t81UHHXs2BEfHx+OHz/O2rVrzY4jIiIiJjO12I0cOZJVq1Zx5MgR1q1bR/fu3XF2dqZ37974+PgwcOBARowYwYoVK9i6dStPPPEEoaGhtGrVCoCwsDDq1atH37592bFjB0uXLmXs2LEMGTIEd3d3M1etULi7u9O9e3dAh2NFRETE5GL3559/0rt3b+rUqcOjjz5KuXLl2LBhAxUqVADgvffeo0uXLvTo0YM2bdoQGBjI3Llzrc93dnZm4cKFODs7ExoayuOPP06/fv0YP368WatU6HIPx86ZM8fhb8wsIiIiN2YxdK8MUlJS8PHxITk5udgdls3IyKBSpUqcPn2aqKgo7r//frMjiYiISD6yp6cUqXPsxH6urq7WjxjT4VgREZGSTcXOAeQejp07dy5paWkmpxERERGzqNg5gHvuuYdKlSpx7tw5oqKizI4jIiIiJlGxcwDOzs48+uijgA7HioiIlGQqdg4i93DsTz/9xMWLF01OIyIiImZQsXMQd911FzVr1uTixYvMnz/f7DgiIiJiAhU7B2GxWHj88ccB+Oabb0xOIyIiImZQsXMgucUuKiqK+Ph4k9OIiIhIYVOxcyC1a9emZcuWZGdn6yIKERGREkjFzsH07dsX0OFYERGRkkjFzsH07NkTFxcXtm7dSkxMjNlxREREpBCp2DmY8uXL06lTJ0B77UREREoaFTsHdOXVsdnZ2SanERERkcKiYueAHnjgAby9vYmLi2PNmjVmxxEREZFComLngDw8PHj44YcB+Prrr01OIyIiIoVFxc5B5V4dO2fOHC5fvmxyGhERESkMKnYOqk2bNgQFBZGcnMzChQvNjiMiIiKFQMXOQTk5OdGnTx9AV8eKiIiUFCp2Diz36thFixZx+vRpk9OIiIhIQVOxc2D169enWbNmZGRkMGvWLLPjiIiISAFTsXNwTzzxBAD/+9//MAzD5DQiIiJSkFTsHFzv3r1xd3dn586dbN++3ew4IiIiUoBU7Bxc2bJl6datGwDTp083N4yIiIgUKBW7EiD3cOysWbN0TzsREREHpmJXAnTo0IEqVaqQlJTEzz//bHYcERERKSAqdiWAs7Mz/fv3B3Q4VkRExJGp2JUQAwYMACAqKoo///zT3DAiIiJSIFTsSohatWrRpk0bsrOzmTlzptlxREREpACo2JUguRdRTJ8+Xfe0ExERcUAqdiVFUhIPh4RQ2sODAwcOsHbJErMTiYiISD5TsSsJjh2DXr3wat6cnpcuAfC/QYNy5ouIiIjDULFzdElJMGgQREUB8MRfs78/cYLzAwbkjIuIiIhDULFzdAkJ1lIHcDdwJ3ARiPztt5xxERERcQgqdo4uOdnmoQV4+q/vv7jGuIiIiBRfKnaOzsfnqln9ATdgC7BN97QTERFxGCp2ji4gAMLCbGaVBx766/svFi4s9EgiIiJSMFTsHJ2fH0ybdlW5e7p5cwBm/fADFy5cMCOZiIiI5DMVu5IgKAgiIyEmBjZsgJgY2i1dSu3atblw4QKRkZFmJxQREZF8oGJXUvj5QXAwtGwJwcFYypbl6adzLqP44osvTA4nIiIi+UHFrgTr378/rq6ubN68me3bt5sdR0RERG6Til0JVqFCBR56KOcyCu21ExERKf5U7Eq43MOxs2bN0kUUIiIixZyKXQl37733UqtWLc6fP8/s2bPNjiMiIiK3QcWuhLNYLNa9dp9//rnJaUREROR2qNiJzUUU27ZtMzuOiIiI3CIVO8Hf35+HH34YgE8++cTkNCIiInKrVOwEgCFDhgDw7bffcubMGZPTiIiIyK1QsRMAWrduTePGjbl8+TLTp083O46IiIjcAhU7AXIuonjuuecAmDJlCllZWSYnEhEREXvdUrHLyMjg2LFjxMbGcvbs2fzOJCbp3bs3fn5+HDp0iCVLlpgdR0REROyU52J3/vx5pkyZQtu2bfH29qZ69erUrVuXChUqUK1aNZ566ik2b95ckFmlgHl6evLkk08CuohCRESkOMpTsXv33XepXr0606dPp0OHDsyfP5/o6Gj++OMP1q9fz2uvvUZmZiZhYWF07NiR/fv3F3RuKSCDBw/GYrGwePFiDhw4YHYcERERsYPFMAzjZgv17t2bsWPHUr9+/Rsud/nyZWbMmIGbm5t1z09xkJKSgo+PD8nJyXh7e5sdx3QREREsWrSIESNG8M4775gdR0REpESzp6fkqdjl1YULF/Dy8sqvlys0Kna2Fi1aREREBL6+vhw/fhxPT0+zI4mIiJRY9vSUPJ9j9957791w/Pz584SHh+f15aQI69ixIzVr1uTcuXN8++23ZscRERGRPMpzsfvXv/7FzJkzrzl28eJFOnbsqBvbOggnJyeeffZZIOciinzcqSsiIiIFKM/F7uuvv+af//wnP//8s838ixcvEh4ezqlTp1ixYkW+BxRzPPHEE3h4eBAdHc2aNWvMjiMiIiJ5kOdi9/DDD/PRRx/Ru3dvVq5cCfz/nrqEhARWrlxJxYoVCyqnFLKyZcvSt29f4OaH4UVERKRosOsGxYMGDeK1116ja9eurFy5kk6dOnHixAlWrFhBpUqVCiqjmOSFF14AYP78+Rw6dMjcMCIiInJTdn/yxEsvvcTgwYNp3749x48fZ+XKlVSpUqUgsonJ6tatS8eOHTEMgw8//NDsOCIiInITeb7dyUMPPWTzeNGiRTRq1IjKlSvbzJ87d27+pSskut3J9UVFRREeHo6Xlxd//vknPj4+ZkcSEREpUezpKS55fdG//0Hv3bv3raWTYuX++++nXr167N27ly+//JIRI0aYHUlERESuI19vUFxcaY/djU2dOpWnn36aatWqceDAAVxc8vzvAREREblNBXKD4oL25ptvYrFYrCfsA7Rr1w6LxWIzPfPMMzbPi4uLIyIiAk9PT/z9/Rk1ahSZmZmFnN6xPf7445QvX56jR48yf/58s+OIiIjIdeSp2D3zzDP8+eefeXrB2bNnM2vWLLtCbN68mc8//5yGDRteNfbUU09x8uRJ6zR58mTrWFZWFhEREaSnp7Nu3Tq++uorZsyYwauvvmrX+8uNeXh4WAv1exMnwsaNEBsLSUkmJxMREZEr5anYVahQgfr169O5c2emTJnC5s2bOX78OGfOnOHAgQP8/PPPvPTSS1StWpX33nuPkJCQPAe4cOECffr0YerUqfj5+V017unpSWBgoHW6chdkVFQUe/fu5ZtvvqFx48Z06tSJCRMm8Mknn5Cenp7nDHJzz3btiqvFwrrt29nUqhUEB0OvXnDsmNnRRERE5C95KnYTJkzgjz/+4O677+bTTz+lVatWVK1aFX9/f+rUqUO/fv04dOgQX3zxBRs2bLjmnrfrGTJkCBEREXTo0OGa47NmzaJ8+fI0aNCAMWPGkJqaah1bv349ISEhBAQEWOeFh4eTkpLCnj17rvueaWlppKSk2ExyA0lJVHzlFXr/dTqm9XbFUVEwaJD23ImIiBQReT4LPiAggFdeeYVXXnmFpKQk4uLiuHTpEuXLl+eOO+7AYrHY/eaRkZFs27aNzZs3X3P8scceo1q1alSqVImdO3cyevRoYmNjrbdUiY+Ptyl1uTlzx65n0qRJjBs3zu68JVZCAkRFMRyYCcwB3gKqQk65S0iAa+xtFRERkcJ1S5c3+vn5XfOwqT2OHTvGsGHDWLZsGaVKlbrmMk8//bT1+5CQECpWrEj79u05ePAgd9xxxy2/95gxY2xu25GSkkJQUNAtv57DS04GoDFwL7CCnL127/1tXERERMxl2lWxW7duJTExkaZNm+Li4oKLiwurVq3iww8/xMXFhaysrKue07JlSwAOHDgAQGBgIAkJCTbL5D4ODAy87nu7u7vj7e1tM8kNXHEPw5f++joVOHuNcRERETGPacWuffv27Nq1i+joaOvUvHlz+vTpQ3R0NM7Ozlc9Jzo6GoCKFSsCEBoayq5du0hMTLQus2zZMry9valXr16hrEeJEBAAYWEAhAONgIvAp5Az/2+Hw0VERMQcReoGxe3ataNx48a8//77HDx4kG+//ZbOnTtTrlw5du7cyfDhw6lSpQqrVq0Ccm530rhxYypVqsTkyZOJj4+nb9++DBo0iIkTJ+b5fXWD4jw4diznQomoKL4F+gAVXF05umcPHrVrm51ORETEYRXLGxT/nZubG7/++ithYWEEBwfz4osv0qNHDxYsWGBdxtnZmYULF+Ls7ExoaCiPP/44/fr1Y/z48SYmd1BBQRAZCTExPLpmDdUrV+ZURgbTly0zO5mIiIj85Zb22GVmZrJy5UoOHjzIY489RpkyZThx4gTe3t54eXkVRM4CpT129vv4448ZOnQoNWrU4I8//tDHjImIiBSQAt1jd/ToUUJCQujatStDhgzh1KlTALz11luMHDny1hJLsfPkk09Srlw5Dh8+zA8//GB2HBEREeEWit2wYcNo3rw5SUlJeHh4WOd3796d5cuX52s4Kbo8PT0ZOnQokFPqi9CpmiIiIiWW3cXu999/Z+zYsbi5udnMr169OsePH8+3YFL0Pffcc3h6ehIdHc0ynWsnIiJiOruLXXZ29jXvMffnn39SpkyZfAklxUO5cuUYNGgQkLPXTkRERMxld7ELCwvj/ffftz62WCxcuHCB1157jc6dO+dnNikGRowYgbOzM7/99tt1PxpORERECofdxe7tt99m7dq11KtXj8uXL/PYY49ZD8Nqr03JU61aNR577DEA/vOf/5icRkREpGS75dudzJ49mx07dnDhwgWaNm1Knz59bC6mKE50u5Pbs2/fPurVq4dhGERHR9OoUSOzI4mIiDgMe3qKXcUuIyOD4OBgFi5cSN26dW87aFGhYnf7evbsyffff88jjzzC999/b3YcERERh1Fg97FzdXXl8uXLtxVOHNPYsWMB+OGHH4iJiTE5jYiISMlk9zl2Q4YM4a233iIzM7Mg8kgxFRISQrdu3TAMgzfeeMPsOCIiIiWS3efY5d6I2MvLi5CQEEqXLm0zPnfu3HwNWBh0KDZ/bN26lebNm+Pk5MS+ffuoXbu22ZFERESKvQL9SDFfX1969OhBeHg4lSpVwsfHx2aSkqtZs2Z07tyZ7OxsJk2aZHYcERGREueWrop1NNpjl382bNhAaGgoLi4u7N+/n+rVq5sdSUREpFgr0D12IjfSqlUrOnToQGZmpu5rKCIiUsjs3mNXo0YNLBbLdccPHTp026EKm/bY5a/Vq1fTtm1b3NzcOHjwIFWqVDE7koiISLFlT09xsffFX3jhBZvHGRkZbN++nSVLljBq1Ch7X04cUJs2bWjTpg2rV69m4sSJfPrpp2ZHEhERKRHy7Ry7Tz75hC1btjB9+vT8eLlCpT12+W/VqlW0a9cOV1dX9u/fT7Vq1cyOJCIiUiyZco5dp06d+PHHH/Pr5aSYa9u2Le3btycjI4MJEyaYHUdERKREyLdi98MPP1C2bNn8ejlxALmFbsaMGRw4cMDkNCIiIo7P7nPsmjRpYnPxhGEYxMfHc+rUKZ1LJTZCQ0Pp3LkzixYtYty4cXz99ddmRxIREXFodp9j9/rrr9sUOycnJypUqEC7du0IDg7O94CFQefYFZzcT6OwWCzs3r2bevXqmR1JRESkWLGnp+gGxajYFbSHHnqIefPm8cgjj/D999+bHUdERKRYKdCLJ5ydnUlMTLxq/pkzZ3B2drb35aQEGDduHBaLhTlz5rDj999h3z7YuBFiYyEpyex4IiIiDsPuYne9HXxpaWm4ubnddiBxPCEhITz66KMAvNajB9StC61aQXAw9OoFx46ZnFBERMQx5PniiQ8//BAAi8XCtGnT8PLyso5lZWWxevXqYnuOnRS814cPZ87s2fx06hSbgLtyB6KiYNAgiIwEPz8TE4qIiBR/eS527733HpCzx+6zzz6zOezq5uZG9erV+eyzz/I/oTiEYB8f+gJfAS8DywHrJThRUZCQoGInIiJym/Jc7A4fPgzAvffey9y5c/HTH2GxR3Iy44DvgBVAFBD+t3ERERG5PXafY7dixQqVOrGfjw/VgOf+ejgayP7buIiIiNweu29QDPDnn3/y888/ExcXR3p6us3Yu+++my/BxMEEBEBYGP+KimIasIOcvXd9AMLCcsZFRETktthd7JYvX86DDz5IzZo12bdvHw0aNODIkSMYhkHTpk0LIqM4Aj8/mDaNcoMG8XJUFP8CxgIPd+iA+7RpOr9OREQkH9h9KHbMmDGMHDmSXbt2UapUKX788UeOHTtG27ZteeSRRwoioziKoCCIjGTYtm1UqlCBI8Bn992XM19ERERum93FLiYmhn79+gHg4uLCpUuX8PLyYvz48bz11lv5HlAcjJ8fnk2aMG7iRAAmvPMOybpwQkREJF/YXexKly5tPa+uYsWKHDx40Dp2+vTp/EsmDm3AgAEEBwdz5swZ3n77bbPjiIiIOAS7i12rVq1Ys2YNAJ07d+bFF1/kjTfe4Mknn6RVq1b5HlAck4uLC5MmTQJyLrg5efKkyYlERESKP7uL3bvvvkvLli2BnM8Abd++PbNnz6Z69ep8+eWX+R5QHFfXrl0JDQ0lNTWVf//732bHERERKfYsxvU+/PUasrKyWLt2LQ0bNsTX17cAYxWulJQUfHx8SE5Oxtvb2+w4Jcr69etp3bo1FouFbdu20bhxY7MjiYiIFCn29BS79tg5OzsTFhZGUlLSbQUUyRUaGkqvXr0wDIMRI0Zgx78zRERE5G/sPhTboEEDDh06VBBZpIR68803KVWqFCtWrODnn382O46IiEixZXex+89//sPIkSNZuHAhJ0+eJCUlxWYSsVe1atUYMWIEACNHjrzq00xEREQkb+w6xw7Ayen/u6DFYrF+bxgGFouFrKys/EtXSHSOnfnOnz/PnXfeSXx8PO+884616ImIiJR09vQUu4vdqlWrbjjetm1be16uSFCxKxq+/PJLBg0ahI+PDwcOHKB8+fJmRxIRETFdgRY7R6RiVzRkZWXRvHlzoqOjGTJkCB9//LHZkURERExXYFfF5vr99995/PHHad26NcePHwfg66+/tt64WORWODs78+677wLw2WefsXfvXpMTiYiIFC92F7sff/yR8PBwPDw82LZtG2lpaQAkJycz8a/P/xS5Vffeey/dunUjKyuL559/Xrc/ERERscMtXRX72WefMXXqVFxdXa3z7777brZt25av4aRkeuedd3B3d2f58uX8+OOPZscREREpNuwudrGxsbRp0+aq+T4+Ppw7dy4/MkkJV7NmTUaPHg3AiBEjuHjxosmJREREige7i11gYCAHDhy4av6aNWuoWbNmvoQSefnll6levTrHjh3TIX4REZE8srvYPfXUUwwbNoyNGzdisVg4ceIEs2bNYuTIkQwePLggMkoJ5OHhwfvvvw/A22+/zf79+80NJCIiUgy42PuEl19+mezsbNq3b09qaipt2rTB3d2dkSNHMnTo0ILIKCXUgw8+SMeOHVmyZAnPP/88ixYtsrkptoiIiNi65fvYpaenc+DAAS5cuEC9evXw8vLK72yFRvexK7r2799PgwYNSE9PZ/78+XTt2tXsSCIiIoWqwO9jB+Dm5kaZMmWoWLFisS51UrTVrl2bkSNHAvDCCy9w6dIlkxOJiIgUXXYXu8zMTP7973/j4+ND9erVqV69Oj4+PowdO5aMjIyCyCgl3L/+9S+CgoI4cuSILqQQERG5AbuL3dChQ/niiy+YPHky27dvZ/v27UyePJkvv/yS559/viAySglXunRp64UUb731lj6RQkRE5DrsPsfOx8eHyMhIOnXqZDN/0aJF9O7dm+Tk5HwNWBh0jl3RZxgGXbt2ZcGCBdxzzz2sWrUKJ6dbPpNARESk2CjQc+zc3d2pXr36VfNr1KiBm5ubvS8nkicWi4WPP/6Y0qVLs2bNGv73v/+ZHUlERKTIsbvYPffcc0yYMMH6GbEAaWlpvPHGGzz33HP5Gk7kSlWrVmXChAkAjBo1ioSEBJMTiYiIFC12H4rt3r07y5cvx93dnUaNGgGwY8cO0tPTad++vc2yc+fOzb+kBUiHYouPzMxMWjZvzrYdO+gTHs43H3wA/v7g52d2NBERkQJhT0+x+wbFvr6+9OjRw2ZeUFCQvS8jcktcTp7kCw8P7gJmLV1K/+Bg7g8Lg2nTQL+HIiJSwt3yDYodifbYFRNJSdCrF0RF8QLwAVAT2A14hIVBZKT23ImIiMMplBsUixS6hASIigJgAlAFOASMg5z5OudORERKOLuL3ZkzZxgyZAj16tWjfPnylC1b1mYSKTBX3EqnDPDJX9+/DWz527iIiEhJZPc5dn379uXAgQMMHDiQgIAAfSi7FB4fH5uHDwK9ge+AJ4AtHh64mxBLRESkqLB7j93vv//OnDlzGD16NAMGDKB///4206168803sVgsvPDCC9Z5ly9fZsiQIZQrVw4vLy969Ohx1S0u4uLiiIiIwNPTE39/f0aNGkVmZuYt55AiLCAAwsJsZn0I+JNznt0bX39tRioREZEiw+5iFxwcnO8fxL5582Y+//xzGjZsaDN/+PDhLFiwgDlz5rBq1SpOnDjBQw89ZB3PysoiIiKC9PR01q1bx1dffcWMGTN49dVX8zWfFBF+fjlXv15R7soDn/z1ezPp/feJjo42J5uIiEhRYNhp06ZNxn333WesXLnSOH36tJGcnGwz2ev8+fNG7dq1jWXLlhlt27Y1hg0bZhiGYZw7d85wdXU15syZY102JibGAIz169cbhmEYixYtMpycnIz4+HjrMlOmTDG8vb2NtLS0PGdITk42gFvKLyY4e9YwYmIMY8OGnK9nzxo9evQwAKNx48ZGenq62QlFRETyjT09xe49dr6+vqSkpHDffffh7++Pn58ffn5++Pr64ncLt5oYMmQIERERdOjQwWb+1q1bycjIsJkfHBxM1apVWb9+PQDr168nJCSEgIAA6zLh4eGkpKSwZ88eu7NIMeHnB8HB0LJlzlc/Pz755BPKli1LdHQ0b731ltkJRURETGH3xRN9+vTB1dWVb7/99rYvnoiMjGTbtm1s3rz5qrH4+Hjc3Nzw9fW1mR8QEEB8fLx1mStLXe547tj1pKWl2XwkWkpKyq2ughQRAQEBfPjhhzz++OOMHz+ebt260aBBA7NjiYiIFCq7i93u3bvZvn07derUua03PnbsGMOGDWPZsmWUKlXqtl7LXpMmTWLcuHGF+p5S8B577DFmz57NggUL6NevHxs2bMDNzc3sWCIiIoXG7kOxzZs359ixY7f9xlu3biUxMZGmTZvi4uKCi4sLq1at4sMPP8TFxYWAgADS09M5d+6czfMSEhIIDAwEIDAw8KqrZHMf5y5zLWPGjCE5Odk65cf6iPksFguff/45ZcuWZfv27YwfP97sSCIiIoXK7mI3dOhQhg0bxowZM9i6dSs7d+60mfKqffv27Nq1i+joaOvUvHlz+vTpY/3e1dWV5cuXW58TGxtLXFwcoaGhAISGhrJr1y4SExOtyyxbtgxvb2/q1at33fd2d3fH29vbZhLHULFiRT7//HMgZ89s7vmYIiIiJYHdnxXr5HR1F7RYLBiGgcViISsr65bDtGvXjsaNG/P+++8DMHjwYBYtWsSMGTPw9vZm6NChAKxbtw7Iud1J48aNqVSpEpMnTyY+Pp6+ffsyaNAgJk6cmOf31WfFOp6+ffvyzTffcMcddxAdHY2Xl5fZkURERG6JPT3F7nPsDh8+fMvB7PXee+/h5OREjx49SEtLIzw8nE8//dQ67uzszMKFCxk8eDChoaGULl2a/v376xCc8NFHH7Fy5UoOHjzIyJEj+eyzz8yOJCIiUuDs3mPniLTHzjEtX77cerucX375hc6dO5ucSERExH729BS7z7ED+Prrr7n77rupVKkSR48eBeD999/np59+upWXEykQ7du3t35E3cCBAzl9+rS5gURERAqY3cVuypQpjBgxgs6dO3Pu3DnrOXW+vr7Wc+NEioqJEydSt25d4uPjeeqpp9AOahERcWR2F7uPPvqIqVOn8sorr+Ds7Gyd37x5c3bt2pWv4URul4eHB9988w2urq7Mnz9f59qJiIhDs7vYHT58mCZNmlw1393dnYsXL+ZLKJH81LRpU+vHjA0fPlz/ABEREYdld7GrUaMG0dHRV81fsmQJdevWzY9MIvlu2LBhdOrUibS0NHr16kXq8eOwbx9s3AixsZCUZHZEERGR25bnYjd+/HhSU1MZMWIEQ4YMYfbs2RiGwaZNm3jjjTcYM2YML730UkFmFbllTk5OzJgxg8DAQPbu3cuIVq2gbl1o1QqCg6FXL9AnkIiISDGX59udODs7c/LkSfz9/Zk1axavv/46Bw8eBKBSpUqMGzeOgQMHFmjYgqLbnZQcv86bR9hDD2EAPwA9rhwMC4PISPDzMyeciIjINdjTU/Jc7JycnIiPj8ff3986LzU1lQsXLtjMK45U7EqQffsYU7cubwK+QDRQ7crxmJicPXgiIiJFRIHdx85isdg89vT0LPalTkqY5GTGAy2Bc0AvIP1v4yIiIsWVXR8pduedd15V7v7u7NmztxVIpED5+OAKfAc0BTYALwHvXzEuIiJSXNlV7MaNG4eP/vBJcRYQAGFh1IiK4iugK/AB0Bp4NCwsZ1xERKSYuq1z7ByFzrErYY4dg0GDICqKl4G3AC9nZ7b8+it12rUzOZyIiIitAjnH7maHYEWKjaCgnKtfY2L4z5o1tG3RggtZWfR47jndZFtERIq1PBc7fcamOBQ/PwgOxuXuu4n8+WcCAwPZs2cPgwcP1u+6iIgUW3kudtnZ2Q55GFYkMDCQ2bNn4+zszNdff83UqVPNjiQiInJL7P5IMRFH1KZNGyZOnAjA0KFD2bRpk8mJRERE7KdiJ/KXUaNG0a1bN9LT0+nevTsnT540O5KIiIhdVOxE/mKxWPjqq6+oW7cuJ06coEePHqSlpZkdS0REJM9U7ESu4O3tzU8//YSvry/r169nyJAhuphCRESKDRU7kb+pXbs2kZGRODk58eWXX/Lpp5+aHUlERCRPVOxEriE8PJy33noLgGHDhrFy5UpzA4mIiOSBip3Idbz44ov06dOHrKwsHn74YY4cOWJ2JBERkRtSsRO5DovFwtSpU2nWrBlnzpzhwQcfJCUlxexYIiIi16ViJ3IDHh4ezJs3j8DAQHbt2kXPnj3JzMw0O5aIiMg1qdiJ3ERQUBALFizAw8ODJUuW8Pzzz+tKWRERKZJU7ETyoHnz5nz77bdYLBamTJnC+xMnwr59sHEjxMZCUpLZEUVERFTsRPKqW7duvP322wC8OHYs8+vWhVatIDgYevWCY8dMTigiIiWdip2IHYYPGMAzVapgAH2ALbkDUVEwaJD23ImIiKlU7ETsYElM5KM//yQcSAUeAI7mDkZFQUKCadlERERU7ETskZyMC/A9EALEA+HA6SvGRUREzKJiJ2IPHx8AvIFFQBAQC3QBLl4xLiIiYgYVOxF7BARAWBgAVYClQFlgI/BI+fJklC1rYjgRESnpVOxE7OHnB9OmWctdXWAh4OHkxOLTpxk0apTucSciIqZRsROxV1AQREZCTAxs2EBoTAzfz5qFs7MzM2fO5OWXXzY7oYiIlFAuZgcQKZb8/HKmv3QJDmbqpUs8+eSTTJ48mYCAAEaMGGFiQBERKYm0x04knzzxxBNMmjQJgBdffJGpU6eanEhEREoaFTuRfDR69GhGjhwJwD//+U+++eYbkxOJiEhJomInko8sFguTJ0/m2WefxTAMBgwYwNy5c82OJSIiJYSKnUg+s1gsfPTRRwwYMICsrCx69erFokWLzI4lIiIlgIqdSAFwcnJi2rRpPProo2RkZNCjRw9WrFhhdiwREXFwKnYiBcTZ2ZlvvvmGBx54gMuXL/PAAw+wdu1as2OJiIgDU7ETKUCurq58//333H///Vy8eJHw8HB+//13s2OJiIiDUrETKWClSpVi/vz5tG/fnosXL9KpUydWr15tdiwREXFAKnYihcDT05MFCxZY99x16tSJlQsWwL59sHEjxMZCUpLZMUVEpJhTsRMpJB4eHvz000+Eh4eTmppK527d+K1uXWjVCoKDoVcvOHbM7JgiIlKMqdiJFCIPDw/mT59O5/LluZSdTQTwa+5gVBQMGqQ9dyIicstU7EQKWankZOaePk0EcBnoAvycOxgVBQkJpmUTEZHiTcVOpLAlJ+MO/Ah0A9KAh4BvrhgXERG5FSp2IoXNxwcAd2AO0A/IAvoCn14xLiIiYi8VO5HCFhAAYWEAuADTgaF/DQ0BJs6ahWEYJoUTEZHiTMVOpLD5+cG0adZy5wR8APy7Zk0AXvnPf3jppZdU7kRExG4qdiJmCAqCyEiIiYENG7DExDB+yxbeeecdAN5++22efPJJMjIyTA4qIiLFiYvZAURKLD+/nOkKI0aMwNfXl6eeeooZM2Zw8uRJ5syZQ5kyZUwKKSIixYn22IkUMU8++SQ//fQTnp6eLF26lLZt23Ly5EmzY4mISDGgYidSBHXp0oWVK1dSoUIFtm/fTmhoKPv27TM7loiIFHEqdiJFVIsWLVi/fj21atXi6NGjtG7dmjVr1pgdS0REijAVO5Ei7I477mDdunW0atWKpKQkOnTowPfff292LBERKaJU7ESKuAoVKrB8+XK6du1KWloaPXv2ZNy4cbodioiIXEXFTqQY8PT05Mcff+TFF18E4PXXX6dXr16kHj8O+/bBxo0QGwtJSSYnFRERM1kM/bOflJQUfHx8SE5Oxtvb2+w4Ijf05ZdfMnjwYDIyMmju7c38lBQq5w6GheXc/DgoyMyIIiKSj+zpKdpjJ1LMDBw4kF/nzaOcqytbUlJoAWzJHYyKgkGDtOdORKSEUrETKYba3HEHmzMyqA+cBP4BfJc7GBUFCQmmZRMREfOo2IkUR8nJ1ADWARHAZeAx4AUg469xEREpeUwtdlOmTKFhw4Z4e3vj7e1NaGgoixcvto63a9cOi8ViMz3zzDM2rxEXF0dERASenp74+/szatQoMjMzC3tVRAqXjw8A3sBPwL/+mv0BcB9wMi3NnFwiImIqU4tdlSpVePPNN9m6dStbtmzhvvvuo2vXruzZs8e6zFNPPcXJkyet0+TJk61jWVlZREREkJ6ezrp16/jqq6+YMWMGr776qhmrI1J4AgJyLpQAnIE3gPnkFL01QLOePVm7dq1p8URExBxF7qrYsmXL8t///peBAwfSrl07GjduzPvvv3/NZRcvXkyXLl04ceIEAQEBAHz22WeMHj2aU6dO4ebmlqf31FWxUiwdO5ZzoURUlHXWH3ffzUOnTrHnjz9wcXHhnXfeYejQoVgsFhODiojI7SiWV8VmZWURGRnJxYsXCQ0Ntc6fNWsW5cuXp0GDBowZM4bU1FTr2Pr16wkJCbGWOoDw8HBSUlJs9vr9XVpaGikpKTaTSLETFASRkRATAxs2QEwMdy5YwIatW+nZsyeZmZkMGzaM3r1763dcRKSEcDE7wK5duwgNDeXy5ct4eXkxb9486tWrB8Bjjz1GtWrVqFSpEjt37mT06NHExsYyd+5cAOLj421KHWB9HB8ff933nDRpEuPGjSugNRIpRH5+OdMVvIDvvvuOVq1aMXLkSGbPns3mzZuZPXs2zZs3NyeniIgUCtMPxaanpxMXF0dycjI//PAD06ZNY9WqVdZyd6XffvuN9u3bc+DAAe644w6efvppjh49ytKlS63LpKamUrp0aRYtWkSnTp2u+Z5paWmkXXFyeUpKCkFBQToUKw5n/fr19OrVi7i4OFxdXZk8eTLDhg3ToVkRkWKkWB2KdXNzo1atWjRr1oxJkybRqFEjPvjgg2su27JlSwAOHDgAQGBgIAl/u19X7uPAwMDrvqe7u7v1StzcScQRhYaGEh0dTffu3cnIyGD48OE8+OCDnDlzxuxoIiJSAEwvdn+XnZ1tszftStHR0QBUrFgRyPmjtWvXLhITE63LLFu2DG9v72vu8RMpifz8/Pjxxx/5+OOPcXNzY+HChTRq1IjVq1ebHU1ERPKZqcVuzJgxrF69miNHjrBr1y7GjBnDypUr6dOnDwcPHmTChAls3bqVI0eO8PPPP9OvXz/atGlDw4YNAQgLC6NevXr07duXHTt2sHTpUsaOHcuQIUNwd3c3c9VEihSLxcKQIUPYuHEjd955J8ePH6ddu3aMHj36uv+QEhGR4sfUYpeYmEi/fv2oU6cO7du3Z/PmzSxdupT7778fNzc3fv31V8LCwggODubFF1+kR48eLFiwwPp8Z2dnFi5ciLOzM6GhoTz++OP069eP8ePHm7hWIkVX48aN2bJlC0888QSGYTB58mTuuusudu3aZXY0ERHJB6ZfPFEU6D52UhLNmzePp59+mtOnT+Pm5sbEiRMZPnw4Tk5F7gwNEZESrVhdPCEi5ujevTu7du2yfnrLyJEjad++PUePHjU7moiI3CIVO5ESLDAwkAULFvD5559TunRpVq5cSYMGDZgyZQrZ2dlmxxMRETup2ImUcBaLhaeffpro6Ghat27NhQsXePbZZ7n33nvZv3+/2fFERMQOKnYiAkCtWrVYvXo1H3zwAZ6enqxevZqGDRvy9ttvk5WVZXY8ERHJAxU7EbFydnbm+eefZ/fu3bRv357Lly8zatQoQkND2b17t9nxRETkJlTsROQqNWrUYNmyZUybNg0fHx82b95M06ZNeeWVV0hNTTU7noiIXIeKnYhck8ViYeDAgezZs4cHH3yQjIwMJk6cSP369fnll1/MjiciItegYiciN1S5cmXmz5/P3LlzqVKlCkeOHKFLly50796duLg4s+OJiMgVVOxE5KYsFgvdu3cnJiaGUaNG4eLiwvz586lbty6TJ08mIyPD7IgiIoKKnYjYwcvLi8mTJ7N9+3b+8Y9/kJqayujRo2nUqBFLliwxO56ISImnYicidmvQoAGrVq1ixowZlC9fnpiYGDp16kRERASxsbFmxxMRKbFU7ETkllgsFvr378/+/fsZPnw4Li4uLFq0iAYNGjB8+HCSkpLMjigiUuKo2InIbfH19eXdd99lz549dOnShczMTN5//31q167NlClTyMzMNDuiiEiJoWInIvnizjvvZMGCBSxdupR69epx5swZnn32WRo0aMDcuXMxDMPsiCIiDk/FTkTyVVhYGDt27OCjjz6iXLlyxMbG0qNHD0JDQ1m5cqXZ8UREHJqKnYjkOxcXF5577jkOHjzI2LFj8fT0ZOPGjdx777106tSJHTt2mB1RRMQhqdiJSIHx8fFhwoQJHDx4kGeffRYXFxeWLFlCkyZNePzxxzlw4IDZEUVEHIqKnYgUuMDAQD755BNiYmLo2bMnhmEwa9YsgoODeeKJJ1TwRETyiYqdiBSaWrVqERkZyZYtW+jUqRNZWVnMmDGD4OBgBgwYoIInInKbVOxEpNA1a9aMRYsWsXHjRjp37kxWVhZfffWVCp6IyG1SsRMR09x111388ssv1yx4ffr0YefOnWZHFBEpVlTsRMR01yp43377LY0aNaJz586sWrVK98ETEckDFTsRKTJyC97WrVt59NFHcXJyYvHixbRr147WrVszf/58srOzzY4pIlJkqdiJSJHTtGlTZs+eTWxsLM888wzu7u5s2LCB7t27U79+faZOnUpqaqrZMUVEihyLoeMbpKSk4OPjQ3JyMt7e3mbHEZG/SUhI4IMPPuDTTz8lOTkZgLJly/L000/z7LPPEhQUZHJCEZGCY09PUbFDxU6kuEhJSWHatGl89NFHHDlyBABnZ2ceeughhg0bRuvWrbFYLOaGFBHJZ/b0FB2KFZFiw9vbmxEjRnDgwAHmzZtHu3btyMrKYs6cOdxzzz20aNGCmTNncunSJbOjioiYQsVORIodZ2dnunXrxooVK9ixYwcDBw7E3d2drVu30r9/fypXrszw4cPZt2+f2VFFRAqVDsWiQ7EijuD06dN88cUXfP7558TFxVnnt2nThn/+85/06NEDd3d3ExOKiNwanWNnJxU7EceRlZXF0qVL+fzzz1m4cKH19ijlypVjwIABDBo0iODgYJNTiojknYqdnVTsRBzTn3/+yZdffsm0adP4888/rfPvuusuBgwYQK9evfDz8zMxoYjIzanY2UnFTsSxZWZmsnjxYr744gsWL15MVlYWAG5ubjz44IMMGDCA8PBwXFxcTE4qInI1FTs7qdiJlBwJCQnMmjWLr776yuazaAMCAujTpw99+/alUaNGum2KiBQZKnZ2UrETKZmio6OZMWMG3377LadOnbLODw4OpmfPnvTq1Uvn44mI6VTs7KRiJ1KyZWRksHjxYmbOnMnChQtJS0uzjjVq1IhevXrRs2dPatSoYWJKESmpVOzspGInIrlSUlL46aefmD17NkuXLiUzM9M61rJlSx555BG6d+9OzZo1TUwpIiWJip2dVOxE5FrOnDnDvHnziIyMZMWKFdZbpwA0bNiQ7t270717dxo2bKhz8kSkwKjY2UnFTkRuJj4+nh9++IG5c+eyevVq65W1ADVq1LCWvNDQUJydnU1MKiKORsXOTip2ImKPM2fOsGDBAubNm0dUVBSXL1+2jvn7+9O5c2c6d+5MWFgYPj4+JiYVEUegYmcnFTsRuVUXL15kyZIlzJs3j4ULF5KcnGwdc3Z25p577rEWvfr16+uQrYjYTcXOTip2IpIf0tPT+f3331m0aBGLFi1i3759NuNBQUHWknfvvfdSpkwZk5KKSHGiYmcnFTsRKQiHDh2ylrwVK1bYHLJ1cXGhVatWtG/fng4dOtCyZUtcXV1NTCsiRZWKnZ1U7ESkoKWmprJy5UoWLVrE4sWLOXTokM24l5cXbdu2tRa9Bg0a6LCtiAAqdnZTsRORwnb48GGWL1/Or7/+yvLlyzl9+rTNeEBAAG3btqVNmza0adOG+vXr4+TkZFJaETGTip2dVOxExEzZ2dns3LnTWvJWr15NamqqzTJ+fn7cc8891qLXpEkTHboVKSFU7OykYiciRUlaWhobN25k9erVrF69mnXr1nHx4kWbZUqXLk1oaCj/+Mc/CA0N5a677tKtVUQclIqdnVTsRKQoy8jIIDo62lr01qxZw9mzZ22WsVgs1K1bl1atWlmnevXq6WbJIg5Axc5OKnYiUpxkZ2ezd+9eVq9ezdq1a9mwYcNVF2NAzgUZd911F61ataJly5Y0b96cihUr6qIMkWJGxc5OKnYiUtwlJiayceNGNmzYwIYNG9i0aRMXLly4armAgACaNWtG06ZNrV+DgoJU9kSKMBU7O6nYiYijycrKYu/evdait3HjRmJiYsjOzr5q2fLly9sUvSZNmlCjRg1dhStSRKjY2UnFTkRKgtTUVHbs2MG2bdvYunUr27ZtY8+ePWRmZl61bOnSpWnQoAEhISE0bNiQkJAQQkJCKFeunAnJRUo2FTs7qdiJSEl1+fJldu3axdatW63Tnj17SE9Pv+bylSpVsha9hg0b0qBBA+688048PT0LOblIyaFiZycVOxGR/5eZmcn+/fvZuXMnu3btsn49cuTINZe3WCxUq1aN4OBg6tata/O1QoUKhRtexAGp2NlJxU5E5OZSUlLYvXu3Tdnbs2fPVbdeuVK5cuUIDg62lr06depQq1YtatSogbu7eyGmFym+VOzspGInInLrTp06xb59+9i3bx8xMTHWr0ePHuV6f2IsFgtVq1alVq1a3HHHHdSqVcs61axZk9KlSxfyWogUXSp2dlKxExHJf6mpqezfv9+m7P3xxx8cOHDgmrdiuVLFihWtRa9GjRpUr16datWqUa1aNSpXroyLi0shrYWI+VTs7KRiJyJSeAzD4NSpUxw4cOCaU1JS0g2f7+zsTJUqVaxl7+9fg4KCcHNzK6S1ESl4KnZ2UrETESk6zp49y8GDB61F78iRIxw5coSjR48SFxdHRkbGDZ9vsVioVKkSlStXpkqVKlSuXPmq7ytXrqwreaXYULGzk4qdiEjxkJWVRXx8PEePHrWWvb9/vXz5cp5ey8/P75rFLzAw0Dr5+/vrIg8xnYqdnVTsREQcg2EYJCYmEhcXx/Hjx/nzzz9tvuZ+n5qamufX9PPzIzAwkICAAGvhu9b3FSpU0Ll/UiBU7OykYiciUnIYhkFycvI1C9/x48dJSEggPj6ehISEmx72vZLFYqFcuXJUqFCB8uXLX3P6+5iXl5c+p1duyp6eon9aiIhIiWKxWPD19cXX15f69etfdznDMEhKSiI+Pt5a9K78euX3iYmJZGdnc/r0aU6fPp3nLG5ubleVPj8/v5tO3t7eKoRyTabusZsyZQpTpkyx3s28fv36vPrqq3Tq1AnI+aibF198kcjISNLS0ggPD+fTTz8lICDA+hpxcXEMHjyYFStW4OXlRf/+/Zk0aZJdu8O1x05ERG5HVlYWZ86cISEhgTNnznDq1Clrybtyyp1/6tSpPJ8LeC1OTk74+vresPz5+vri7e19zalMmTK4urrm409AClKx2WNXpUoV3nzzTWrXro1hGHz11Vd07dqV7du3U79+fYYPH84vv/zCnDlz8PHx4bnnnuOhhx5i7dq1QM5/SBEREQQGBrJu3TpOnjxJv379cHV1ZeLEiWaumoiIlCDOzs74+/vj7++f5+ekpqZes/AlJSXdcEpLSyM7O5uzZ8/e8FM/bsbDw+O6xS938vHxsSmDpUuXpnTp0nh5edl87+HhoT2IRUSRO8eubNmy/Pe//+Xhhx+mQoUKfPvttzz88MMA7Nu3j7p167J+/XpatWrF4sWL6dKlCydOnLDuxfvss88YPXo0p06dyvN9jLTHTkREiotLly5x7ty5mxbA5ORkUlJSrpouXbqU75ksFguenp5XFb6/f3+9cQ8Pj5tOJfnClGKzx+5KWVlZzJkzh4sXLxIaGsrWrVvJyMigQ4cO1mWCg4OpWrWqtditX7+ekJAQm0Oz4eHhDB48mD179tCkSRMzVkVERKTA5BadihUr3tLzMzIyOH/+/DVL382mixcvWqcLFy5Yry42DMM6v6C4uLjkqQBeb3J3d8/TVKpUqWvOd3Z2LrB1y0+mF7tdu3YRGhrK5cuX8fLyYt68edSrV4/o6Gjc3Nzw9fW1WT4gIID4+HgA4uPjbUpd7nju2PWkpaWRlpZmfZySkpJPayMiIlK0ubq6UrZsWcqWLXvbr5WdnU1qaqpN2bvya17nXbp06ZrTlX+rMzMzOX/+POfPn7/t3LfC2dn5umWwVq1azJ0715Rcf2d6satTpw7R0dEkJyfzww8/0L9/f1atWlWg7zlp0iTGjRtXoO8hIiLi6JycnPDy8sLLy6tAXj87O5vLly9ft/jldbp8+bJ1p86V0/Xm505Xnq2WlZVFamrqNe+BmJWVVSDrfytML3Zubm7UqlULgGbNmrF582Y++OADevbsSXp6OufOnbPZa5eQkEBgYCAAgYGBbNq0yeb1EhISrGPXM2bMGEaMGGF9nJKSQlBQUH6tkoiIiOQDJycnPD09Tfn4N8MwyMzMzFMhLFWqVKHnux7Ti93fZWdnk5aWRrNmzXB1dWX58uX06NEDgNjYWOLi4ggNDQUgNDSUN954g8TEROuVSMuWLcPb25t69epd9z1yd52KiIiIXIvFYsHV1RVXV9cC2yNZEEwtdmPGjKFTp05UrVqV8+fP8+2337Jy5UqWLl2Kj48PAwcOZMSIEZQtWxZvb2+GDh1KaGgorVq1AiAsLIx69erRt29fJk+eTHx8PGPHjmXIkCEqbiIiIlLimFrsEhMT6devHydPnsTHx4eGDRuydOlS7r//fgDee+89nJyc6NGjh80NinM5OzuzcOFCBg8eTGhoKKVLl6Z///6MHz/erFUSERERMU2Ru4+dGXQfOxERESmq7OkpToWUSUREREQKmIqdiIiIiINQsRMRERFxECp2IiIiIg5CxU5ERETEQajYiYiIiDgIFTsRERERB6FiJyIiIuIgVOxEREREHISKnYiIiIiDULETERERcRAqdiIiIiIOwsXsAEWBYRhAzofsioiIiBQluf0kt6/ciIodcP78eQCCgoJMTiIiIiJybefPn8fHx+eGy1iMvNQ/B5ednc2JEycoU6YMFoulQN4jJSWFoKAgjh07hre3d4G8h9hH26Ro0fYoerRNih5tk6KnMLaJYRicP3+eSpUq4eR047PotMcOcHJyokqVKoXyXt7e3vqPsYjRNilatD2KHm2TokfbpOgp6G1ysz11uXTxhIiIiIiDULETERERcRAqdoXE3d2d1157DXd3d7OjyF+0TYoWbY+iR9uk6NE2KXqK2jbRxRMiIiIiDkJ77EREREQchIqdiIiIiINQsRMRERFxECp2heCTTz6hevXqlCpVipYtW7Jp0yazIzmkSZMm0aJFC8qUKYO/vz/dunUjNjbWZpnLly8zZMgQypUrh5eXFz169CAhIcFmmbi4OCIiIvD09MTf359Ro0aRmZlZmKvisN58800sFgsvvPCCdZ62SeE7fvw4jz/+OOXKlcPDw4OQkBC2bNliHTcMg1dffZWKFSvi4eFBhw4d2L9/v81rnD17lj59+uDt7Y2vry8DBw7kwoULhb0qDiErK4t///vf1KhRAw8PD+644w4mTJhg8/FR2iYFa/Xq1TzwwANUqlQJi8XC/Pnzbcbz6+e/c+dO/vGPf1CqVCmCgoKYPHly/q+MIQUqMjLScHNzM/73v/8Ze/bsMZ566inD19fXSEhIMDuawwkPDzemT59u7N6924iOjjY6d+5sVK1a1bhw4YJ1mWeeecYICgoyli9fbmzZssVo1aqV0bp1a+t4Zmam0aBBA6NDhw7G9u3bjUWLFhnly5c3xowZY8YqOZRNmzYZ1atXNxo2bGgMGzbMOl/bpHCdPXvWqFatmjFgwABj48aNxqFDh4ylS5caBw4csC7z5ptvGj4+Psb8+fONHTt2GA8++KBRo0YN49KlS9ZlOnbsaDRq1MjYsGGD8fvvvxu1atUyevfubcYqFXtvvPGGUa5cOWPhwoXG4cOHjTlz5hheXl7GBx98YF1G26RgLVq0yHjllVeMuXPnGoAxb948m/H8+PknJycbAQEBRp8+fYzdu3cb3333neHh4WF8/vnn+bouKnYF7K677jKGDBlifZyVlWVUqlTJmDRpkompSobExEQDMFatWmUYhmGcO3fOcHV1NebMmWNdJiYmxgCM9evXG4aR8x+3k5OTER8fb11mypQphre3t5GWlla4K+BAzp8/b9SuXdtYtmyZ0bZtW2ux0zYpfKNHjzbuueee645nZ2cbgYGBxn//+1/rvHPnzhnu7u7Gd999ZxiGYezdu9cAjM2bN1uXWbx4sWGxWIzjx48XXHgHFRERYTz55JM28x566CGjT58+hmFomxS2vxe7/Pr5f/rpp4afn5/N/7dGjx5t1KlTJ1/z61BsAUpPT2fr1q106NDBOs/JyYkOHTqwfv16E5OVDMnJyQCULVsWgK1bt5KRkWGzPYKDg6latap1e6xfv56QkBACAgKsy4SHh5OSksKePXsKMb1jGTJkCBERETY/e9A2McPPP/9M8+bNeeSRR/D396dJkyZMnTrVOn748GHi4+NttomPjw8tW7a02Sa+vr40b97cukyHDh1wcnJi48aNhbcyDqJ169YsX76cP/74A4AdO3awZs0aOnXqBGibmC2/fv7r16+nTZs2uLm5WZcJDw8nNjaWpKSkfMurz4otQKdPnyYrK8vmDxJAQEAA+/btMylVyZCdnc0LL7zA3XffTYMGDQCIj4/Hzc0NX19fm2UDAgKIj4+3LnOt7ZU7JvaLjIxk27ZtbN68+aoxbZPCd+jQIaZMmcKIESP417/+xebNm3n++edxc3Ojf//+1p/ptX7mV24Tf39/m3EXFxfKli2rbXILXn75ZVJSUggODsbZ2ZmsrCzeeOMN+vTpA6BtYrL8+vnHx8dTo0aNq14jd8zPzy9f8qrYiUMaMmQIu3fvZs2aNWZHKdGOHTvGsGHDWLZsGaVKlTI7jpDzj57mzZszceJEAJo0acLu3bv57LPP6N+/v8npSqbvv/+eWbNm8e2331K/fn2io6N54YUXqFSpkraJ2E2HYgtQ+fLlcXZ2vuoKv4SEBAIDA01K5fiee+45Fi5cyIoVK6hSpYp1fmBgIOnp6Zw7d85m+Su3R2Bg4DW3V+6Y2Gfr1q0kJibStGlTXFxccHFxYdWqVXz44Ye4uLgQEBCgbVLIKlasSL169Wzm1a1bl7i4OOD/f6Y3+v9WYGAgiYmJNuOZmZmcPXtW2+QWjBo1ipdffplevXoREhJC3759GT58OJMmTQK0TcyWXz//wvp/mYpdAXJzc6NZs2YsX77cOi87O5vly5cTGhpqYjLHZBgGzz33HPPmzeO33367apd3s2bNcHV1tdkesbGxxMXFWbdHaGgou3btsvkPdNmyZXh7e1/1x1Burn379uzatYvo6Gjr1Lx5c/r06WP9XtukcN19991X3Qbojz/+oFq1agDUqFGDwMBAm22SkpLCxo0bbbbJuXPn2Lp1q3WZ3377jezsbFq2bFkIa+FYUlNTcXKy/XPs7OxMdnY2oG1itvz6+YeGhrJ69WoyMjKsyyxbtow6derk22FYQLc7KWiRkZGGu7u7MWPGDGPv3r3G008/bfj6+tpc4Sf5Y/DgwYaPj4+xcuVK4+TJk9YpNTXVuswzzzxjVK1a1fjtt9+MLVu2GKGhoUZoaKh1PPfWGmFhYUZ0dLSxZMkSo0KFCrq1Rj668qpYw9A2KWybNm0yXFxcjDfeeMPYv3+/MWvWLMPT09P45ptvrMu8+eabhq+vr/HTTz8ZO3fuNLp27XrNWzs0adLE2Lhxo7FmzRqjdu3aurXGLerfv79RuXJl6+1O5s6da5QvX9546aWXrMtomxSs8+fPG9u3bze2b99uAMa7775rbN++3Th69KhhGPnz8z937pwREBBg9O3b19i9e7cRGRlpeHp66nYnxdFHH31kVK1a1XBzczPuuusuY8OGDWZHckjANafp06dbl7l06ZLx7LPPGn5+foanp6fRvXt34+TJkzavc+TIEaNTp06Gh4eHUb58eePFF180MjIyCnltHNffi522SeFbsGCB0aBBA8Pd3d0IDg42vvjiC5vx7Oxs49///rcREBBguLu7G+3btzdiY2Ntljlz5ozRu3dvw8vLy/D29jaeeOIJ4/z584W5Gg4jJSXFGDZsmFG1alWjVKlSRs2aNY1XXnnF5rYY2iYFa8WKFdf8+9G/f3/DMPLv579jxw7jnnvuMdzd3Y3KlSsbb775Zr6vi8Uwrri1tYiIiIgUWzrHTkRERMRBqNiJiIiIOAgVOxEREREHoWInIiIi4iBU7EREREQchIqdiIiIiINQsRMRERFxECp2IiIiIg5CxU5E5C8DBgygW7dupr1/3759mThxYp6W7dWrF++8804BJxKR4kafPCEiJYLFYrnh+Guvvcbw4cMxDANfX9/CCXWFHTt2cN9993H06FG8vLxuuvzu3btp06YNhw8fxsfHpxASikhxoGInIiVCfHy89fvZs2fz6quvEhsba53n5eWVp0JVUAYNGoSLiwufffZZnp/TokULBgwYwJAhQwowmYgUJzoUKyIlQmBgoHXy8fHBYrHYzPPy8rrqUGy7du0YOnQoL7zwAn5+fgQEBDB16lQuXrzIE088QZkyZahVqxaLFy+2ea/du3fTqVMnvLy8CAgIoG/fvpw+ffq62bKysvjhhx944IEHbOZ/+umn1K5dm1KlShEQEMDDDz9sM/7AAw8QGRl5+z8cEXEYKnYiIjfw1VdfUb58eTZt2sTQoUMZPHgwjzzyCK1bt2bbtm2EhYXRt29fUlNTATh37hz33XcfTZo0YcuWLSxZsoSEhAQeffTR677Hzp07SU5Opnnz5tZ5W7Zs4fnnn2f8+PHExsayZMkS2rRpY/O8u+66i02bNpGWllYwKy8ixY6KnYjIDTRq1IixY8dSu3ZtxowZQ6lSpShfvjxPPfUUtWvX5tVXX+XMmTPs3LkTgI8//pgmTZowceJEgoODadKkCf/73/9YsWIFf/zxxzXf4+jRozg7O+Pv72+dFxcXR+nSpenSpQvVqlWjSZMmPP/88zbPq1SpEunp6TaHmUWkZFOxExG5gYYNG1q/d3Z2ply5coSEhFjnBQQEAJCYmAjkXASxYsUK6zl7Xl5eBAcHA3Dw4MFrvselS5dwd3e3ucDj/vvvp1q1atSsWZO+ffsya9Ys617BXB4eHgBXzReRkkvFTkTkBlxdXW0eWywWm3m5ZSw7OxuACxcu8MADDxAdHW0z7d+//6pDqbnKly9Pamoq6enp1nllypRh27ZtfPfdd1SsWJFXX32VRo0ace7cOesyZ8+eBaBChQr5sq4iUvyp2ImI5KOmTZuyZ88eqlevTq1atWym0qVLX/M5jRs3BmDv3r02811cXOjQoQOTJ09m586dHDlyhN9++806vnv3bqpUqUL58uULbH1EpHhRsRMRyUdDhgzh7Nmz9O7dm82bN3Pw4EGWLl3KE088QVZW1jWfU6FCBZo2bcqaNWus8xYuXMiHH35IdHQ0R48eZebMmWRnZ1OnTh3rMr///jthYWEFvk4iUnyo2ImI5KNKlSqxdu1asrKyCAsLIyQkhBdeeAFfX1+cnK7/v9xBgwYxa9Ys62NfX1/mzp3LfffdR926dfnss8/47rvvqF+/PgCXL19m/vz5PPXUUwW+TiJSfOgGxSIiRcClS5eoU6cOs2fPJjQ09KbLT5kyhXnz5hEVFVUI6USkuNAeOxGRIsDDw4OZM2fe8EbGV3J1deWjjz4q4FQiUtxoj52IiIiIg9AeOxEREREHoWInIiIi4iBU7EREREQchIqdiIiIiINQsRMRERFxECp2IiIiIg5CxU5ERETEQajYiYiIiDgIFTsRERERB6FiJyIiIuIg/g8DeMgydKhAGwAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Network Training\n", + "\n", + "We will train two networks, a \"plain\" one that uses only the MSE as loss function, and a physics-informed network where the loss-function consists of the MSE, as well as the contribution from our known physical model of the system." + ], + "metadata": { + "id": "qAVxY9vy9FPy" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Plain Model\n", + "\n", + "This is the model without the physics loss" + ], + "metadata": { + "id": "-xaB7p6h9XjD" + } + }, + { + "cell_type": "code", + "source": [ + "# plain network without physics-informed loss\n", + "model_plain = Network(input_size=1, output_size=1, hidden_units=[100,100,100,100],\n", + " loss_fn=nn.MSELoss(), physics_loss_fn=None,\n", + " n_epochs=30000, learn_rate=1e-5,\n", + " physics_loss_weight=1.0, device=device)\n", + "summary(model_plain, input_size=(1,))\n", + "\n", + "loss_values_plain = model_plain.fit(X=x_train,y=y_train)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3z1EvzrbaGwP", + "outputId": "ec04be7b-bd66-44b9-82ec-0942da4c2be1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "----------------------------------------------------------------\n", + " Layer (type) Output Shape Param #\n", + "================================================================\n", + " Linear-1 [-1, 100] 200\n", + " ReLU-2 [-1, 100] 0\n", + " Linear-3 [-1, 100] 10,100\n", + " ReLU-4 [-1, 100] 0\n", + " Linear-5 [-1, 100] 10,100\n", + " ReLU-6 [-1, 100] 0\n", + " Linear-7 [-1, 100] 10,100\n", + " ReLU-8 [-1, 100] 0\n", + " Linear-9 [-1, 1] 101\n", + "================================================================\n", + "Total params: 30,601\n", + "Trainable params: 30,601\n", + "Non-trainable params: 0\n", + "----------------------------------------------------------------\n", + "Input size (MB): 0.00\n", + "Forward/backward pass size (MB): 0.01\n", + "Params size (MB): 0.12\n", + "Estimated Total Size (MB): 0.12\n", + "----------------------------------------------------------------\n", + "Epoch 0/30000, loss: 188764.47\n", + "Epoch 3000/30000, loss: 79368.84\n", + "Epoch 6000/30000, loss: 76979.43\n", + "Epoch 9000/30000, loss: 50262.94\n", + "Epoch 12000/30000, loss: 5106.35\n", + "Epoch 15000/30000, loss: 231.91\n", + "Epoch 18000/30000, loss: 7.69\n", + "Epoch 21000/30000, loss: 5.46\n", + "Epoch 24000/30000, loss: 4.62\n", + "Epoch 27000/30000, loss: 3.38\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.lineplot(loss_values_plain)\n", + "plt.yscale('log')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "EJ92dAoHcNHh", + "outputId": "638b2e95-b495-4804-9630-9b6e39f575d0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Physics-Informed Network\n", + "\n", + "This is the network where the loss function consists of the MSE and the information from the physical system." + ], + "metadata": { + "id": "c7gm55_49eFe" + } + }, + { + "cell_type": "code", + "source": [ + "# setup netowrk\n", + "model_phys_loss = Network(input_size=1, output_size=1, hidden_units=[100,100,100,100],\n", + " loss_fn=nn.MSELoss(), physics_loss_fn=physics_loss,\n", + " n_epochs=30000, learn_rate=1e-5,\n", + " physics_loss_weight=1.0, device=device)\n", + "summary(model_phys_loss, input_size=(1,))\n", + "\n", + "loss_values_phys_loss = model_phys_loss.fit(X=x_train,y=y_train)\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dBuGOKqReJTM", + "outputId": "7ed0b188-877e-43f6-eba5-4aefe1a776af" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "----------------------------------------------------------------\n", + " Layer (type) Output Shape Param #\n", + "================================================================\n", + " Linear-1 [-1, 100] 200\n", + " ReLU-2 [-1, 100] 0\n", + " Linear-3 [-1, 100] 10,100\n", + " ReLU-4 [-1, 100] 0\n", + " Linear-5 [-1, 100] 10,100\n", + " ReLU-6 [-1, 100] 0\n", + " Linear-7 [-1, 100] 10,100\n", + " ReLU-8 [-1, 100] 0\n", + " Linear-9 [-1, 1] 101\n", + "================================================================\n", + "Total params: 30,601\n", + "Trainable params: 30,601\n", + "Non-trainable params: 0\n", + "----------------------------------------------------------------\n", + "Input size (MB): 0.00\n", + "Forward/backward pass size (MB): 0.01\n", + "Params size (MB): 0.12\n", + "Estimated Total Size (MB): 0.12\n", + "----------------------------------------------------------------\n", + "Epoch 0/30000, loss: 190072.83\n", + "Epoch 3000/30000, loss: 79430.46\n", + "Epoch 6000/30000, loss: 77262.30\n", + "Epoch 9000/30000, loss: 43750.92\n", + "Epoch 12000/30000, loss: 860.27\n", + "Epoch 15000/30000, loss: 20.81\n", + "Epoch 18000/30000, loss: 12.43\n", + "Epoch 21000/30000, loss: 10.50\n", + "Epoch 24000/30000, loss: 6.42\n", + "Epoch 27000/30000, loss: 2.70\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.lineplot(loss_values_phys_loss)\n", + "plt.yscale('log')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "bSRLHYfa0lno", + "outputId": "6be5e181-26b3-4168-9fd5-e0166dbf04be" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "# overlay both curves\n", + "\n", + "sns.lineplot(loss_values_plain, color='b', label='Network w/o Physics Loss')\n", + "sns.lineplot(loss_values_phys_loss, color='r', label='Network w/ Physics Loss')\n", + "\n", + "plt.yscale('log')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "ZtTpDRZqgEFl", + "outputId": "4b107536-5e89-4a14-9cde-83bd2c1f7558" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Evaluation\n", + "\n", + "Here, we overlay the results from both networks.\n", + "We can see that the \"plain\" network does not reproduce the physical systems as well as the network with the physics-based contribution to the loss function." + ], + "metadata": { + "id": "9sEVBQ6n9nrR" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exsercise**\n", + "\n", + "Create predictions for both the neutwork with the \"plain\" loss and the physics-informed network.\n", + "Overlay the predictions for the whole region.\n", + "\n", + "Add the training data and the theory curve to the plot as well.\n", + "\n", + "What do you observe?\n", + "\n" + ], + "metadata": { + "id": "991GTqytlDY6" + } + }, + { + "cell_type": "code", + "source": [ + "##\n", + "## Your code here\n", + "##\n", + "\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Temperature (K)')\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "id": "Dgetptw7lSyD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "uVFDRIxxlQlf" + } + }, + { + "cell_type": "code", + "source": [ + "y_pred_plain=model_plain.predict(x_space).flatten()\n", + "\n", + "y_pred_phys_loss=model_phys_loss.predict(x_space).flatten()\n", + "\n", + "\n", + "sns.lineplot(x=x_space, y=y_space, color = 'k', label='Theory')\n", + "sns.scatterplot(x=x_train, y=y_train, color = 'r', markers='o', label='Training data')\n", + "\n", + "sns.lineplot(x=x_space, y=y_pred_phys_loss, color = 'b', label='Network with Physics Loss')\n", + "sns.lineplot(x=x_space, y=y_pred_plain, color = 'g', label='Network w/o Physics Loss')\n", + "\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Temperature (K)')\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "ldVj6bdK1B0J", + "outputId": "111fd5f9-581e-4d16-cd28-d06852e229c1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "torch.save(model_plain.state_dict(), 'model_plain.pth')\n", + "torch.save(model_phys_loss.state_dict(), 'model_phys_loss.pth')" + ], + "metadata": { + "id": "4KMlNnTggmw5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Next steps\n", + "\n", + "You can now evaluate how the system behaves:\n", + "\n", + "* Change the values of the temperature from 298 K to 25 $^\\circ$C. This does not chang the physcics but does it change how the network behaves?\n", + "* Change the random seed - again, this does not change the physics but does it change how the network behaves?\n", + "* Choose different temperature regimes.\n", + "* Use more or less training data.\n", + "\n" + ], + "metadata": { + "id": "l8e0dFsLgf-X" + } + } + ] +} \ No newline at end of file diff --git a/datascienceintro/solutions/Solution_ContinuousCasting_ConicSteelVessel.ipynb b/datascienceintro/solutions/Solution_ContinuousCasting_ConicSteelVessel.ipynb new file mode 100644 index 0000000..0861149 --- /dev/null +++ b/datascienceintro/solutions/Solution_ContinuousCasting_ConicSteelVessel.ipynb @@ -0,0 +1,927 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Continuous Casting with Conic Supply Vessel\n", + "\n", + "In the following example, we consider a continuous steel casting production plant that is supplied with a conic vessel holding molten steel.\n", + "To ensure operations of the production plant, we require a througput of 6000 kg/min of molten steel and changing the vessels takes 60 seconds.\n", + "The height of the liquid steel inside the vessel is 2 metres initially and the radius at the bottom is $R_1 = 0.9$, the radius at the top is $R_2 = 1.2$ m.\n", + "The vessel has an outlet of radius $r$ and we need to optimise the radius such that we can maintain the required throughput and include the 60 second change-over time as well.\n", + "\n", + "The geometry of the vessel looks like this:\n", + "\n", + "\n", + "\n", + "N.B. This is the same example as discussed in the lecture \"Numerische Modellierung in der Prozesstechnik\" and we discuss this example here to apply the methods of this course to the same example.\n", + "\n" + ], + "metadata": { + "id": "ROkOel9qfsfr" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Torrielli's Law\n", + "\n", + "We model this using Torricelli's law, assuming\n", + "\n", + "- laminar and continuous flow\n", + "- ignorign the effects of viscosity\n", + "- incompressible liqued with uniform density\n", + "- $r << R_1, R_2$\n", + "- no effects from the geometry of the outlet orifice, etc.\n", + "\n", + "Then, Torricelli's law gives the velocity of the liquid as:\n", + "$$ v = \\sqrt{2gh}$$\n", + "where $g$ is the constant of gravity, and $h$ is the height of the liquid.\n", + "\n", + "The volumetric flow rate trough the hole at the bottom is given by\n", + "$$Q = av$$\n", + "with $a = \\pi r^2$.\n", + "Due to the conic shape of the vessel, the volume of a slice through the cone depends on the height, leading to:\n", + "$$ \\frac{dV}{dt} = - Q = - a \\sqrt{2 g h} = A(h) \\frac{dh}{dt}$$\n", + "\n", + "\n", + "\n", + "Hence, the differential equation we have to solve (for each $r$) is given by:\n", + "$$\n", + "\\frac{dh}{dt} = -\\frac{a}{\\pi \\left[ R_1 + s h \\right]^2} \\sqrt{2 g h}\n", + "$$\n", + "\n", + "where:\n", + "\n", + "$$\n", + "s = \\frac{R_2 - R_1}{H}\n", + "$$\n", + "\n", + "Substituting $ s $ into the equation:\n", + "\n", + "$$\n", + "\\frac{dh}{dt} = -\\frac{a}{\\pi \\left[ R_1 + \\left( \\dfrac{R_2 - R_1}{H} \\right) h \\right]^2} \\sqrt{2 g h}\n", + "$$\n" + ], + "metadata": { + "id": "JvESDWsUhe94" + } + }, + { + "cell_type": "code", + "source": [ + "# make sure we have the required libraries\n", + "! pip install torchdiffeq" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fDiLVN2ZjOiZ", + "outputId": "84cbf733-5539-4c18-ef5e-c47391669906" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting torchdiffeq\n", + " Downloading torchdiffeq-0.2.5-py3-none-any.whl.metadata (440 bytes)\n", + "Requirement already satisfied: torch>=1.5.0 in /usr/local/lib/python3.11/dist-packages (from torchdiffeq) (2.5.1+cu124)\n", + "Requirement already satisfied: scipy>=1.4.0 in /usr/local/lib/python3.11/dist-packages (from torchdiffeq) (1.13.1)\n", + "Requirement already satisfied: numpy<2.3,>=1.22.4 in /usr/local/lib/python3.11/dist-packages (from scipy>=1.4.0->torchdiffeq) (1.26.4)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (3.17.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (4.12.2)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (3.4.2)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (3.1.6)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (2024.10.0)\n", + "Collecting nvidia-cuda-nvrtc-cu12==12.4.127 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-runtime-cu12==12.4.127 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cuda-cupti-cu12==12.4.127 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cudnn-cu12==9.1.0.70 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cublas-cu12==12.4.5.8 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cufft-cu12==11.2.1.3 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-curand-cu12==10.3.5.147 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Collecting nvidia-cusolver-cu12==11.6.1.9 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Collecting nvidia-cusparse-cu12==12.3.1.170 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl.metadata (1.6 kB)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.21.5 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (2.21.5)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.4.127 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (12.4.127)\n", + "Collecting nvidia-nvjitlink-cu12==12.4.127 (from torch>=1.5.0->torchdiffeq)\n", + " Downloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl.metadata (1.5 kB)\n", + "Requirement already satisfied: triton==3.1.0 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (3.1.0)\n", + "Requirement already satisfied: sympy==1.13.1 in /usr/local/lib/python3.11/dist-packages (from torch>=1.5.0->torchdiffeq) (1.13.1)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.11/dist-packages (from sympy==1.13.1->torch>=1.5.0->torchdiffeq) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.11/dist-packages (from jinja2->torch>=1.5.0->torchdiffeq) (3.0.2)\n", + "Downloading torchdiffeq-0.2.5-py3-none-any.whl (32 kB)\n", + "Downloading nvidia_cublas_cu12-12.4.5.8-py3-none-manylinux2014_x86_64.whl (363.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m363.4/363.4 MB\u001b[0m \u001b[31m4.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_cupti_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (13.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m13.8/13.8 MB\u001b[0m \u001b[31m62.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_nvrtc_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (24.6 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m24.6/24.6 MB\u001b[0m \u001b[31m34.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cuda_runtime_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (883 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m883.7/883.7 kB\u001b[0m \u001b[31m42.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cudnn_cu12-9.1.0.70-py3-none-manylinux2014_x86_64.whl (664.8 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m664.8/664.8 MB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cufft_cu12-11.2.1.3-py3-none-manylinux2014_x86_64.whl (211.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m211.5/211.5 MB\u001b[0m \u001b[31m5.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_curand_cu12-10.3.5.147-py3-none-manylinux2014_x86_64.whl (56.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m56.3/56.3 MB\u001b[0m \u001b[31m12.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusolver_cu12-11.6.1.9-py3-none-manylinux2014_x86_64.whl (127.9 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m127.9/127.9 MB\u001b[0m \u001b[31m7.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_cusparse_cu12-12.3.1.170-py3-none-manylinux2014_x86_64.whl (207.5 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m207.5/207.5 MB\u001b[0m \u001b[31m5.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading nvidia_nvjitlink_cu12-12.4.127-py3-none-manylinux2014_x86_64.whl (21.1 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m21.1/21.1 MB\u001b[0m \u001b[31m56.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: nvidia-nvjitlink-cu12, nvidia-curand-cu12, nvidia-cufft-cu12, nvidia-cuda-runtime-cu12, nvidia-cuda-nvrtc-cu12, nvidia-cuda-cupti-cu12, nvidia-cublas-cu12, nvidia-cusparse-cu12, nvidia-cudnn-cu12, nvidia-cusolver-cu12, torchdiffeq\n", + " Attempting uninstall: nvidia-nvjitlink-cu12\n", + " Found existing installation: nvidia-nvjitlink-cu12 12.5.82\n", + " Uninstalling nvidia-nvjitlink-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-nvjitlink-cu12-12.5.82\n", + " Attempting uninstall: nvidia-curand-cu12\n", + " Found existing installation: nvidia-curand-cu12 10.3.6.82\n", + " Uninstalling nvidia-curand-cu12-10.3.6.82:\n", + " Successfully uninstalled nvidia-curand-cu12-10.3.6.82\n", + " Attempting uninstall: nvidia-cufft-cu12\n", + " Found existing installation: nvidia-cufft-cu12 11.2.3.61\n", + " Uninstalling nvidia-cufft-cu12-11.2.3.61:\n", + " Successfully uninstalled nvidia-cufft-cu12-11.2.3.61\n", + " Attempting uninstall: nvidia-cuda-runtime-cu12\n", + " Found existing installation: nvidia-cuda-runtime-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-runtime-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-runtime-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-nvrtc-cu12\n", + " Found existing installation: nvidia-cuda-nvrtc-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-nvrtc-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-nvrtc-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cuda-cupti-cu12\n", + " Found existing installation: nvidia-cuda-cupti-cu12 12.5.82\n", + " Uninstalling nvidia-cuda-cupti-cu12-12.5.82:\n", + " Successfully uninstalled nvidia-cuda-cupti-cu12-12.5.82\n", + " Attempting uninstall: nvidia-cublas-cu12\n", + " Found existing installation: nvidia-cublas-cu12 12.5.3.2\n", + " Uninstalling nvidia-cublas-cu12-12.5.3.2:\n", + " Successfully uninstalled nvidia-cublas-cu12-12.5.3.2\n", + " Attempting uninstall: nvidia-cusparse-cu12\n", + " Found existing installation: nvidia-cusparse-cu12 12.5.1.3\n", + " Uninstalling nvidia-cusparse-cu12-12.5.1.3:\n", + " Successfully uninstalled nvidia-cusparse-cu12-12.5.1.3\n", + " Attempting uninstall: nvidia-cudnn-cu12\n", + " Found existing installation: nvidia-cudnn-cu12 9.3.0.75\n", + " Uninstalling nvidia-cudnn-cu12-9.3.0.75:\n", + " Successfully uninstalled nvidia-cudnn-cu12-9.3.0.75\n", + " Attempting uninstall: nvidia-cusolver-cu12\n", + " Found existing installation: nvidia-cusolver-cu12 11.6.3.83\n", + " Uninstalling nvidia-cusolver-cu12-11.6.3.83:\n", + " Successfully uninstalled nvidia-cusolver-cu12-11.6.3.83\n", + "Successfully installed nvidia-cublas-cu12-12.4.5.8 nvidia-cuda-cupti-cu12-12.4.127 nvidia-cuda-nvrtc-cu12-12.4.127 nvidia-cuda-runtime-cu12-12.4.127 nvidia-cudnn-cu12-9.1.0.70 nvidia-cufft-cu12-11.2.1.3 nvidia-curand-cu12-10.3.5.147 nvidia-cusolver-cu12-11.6.1.9 nvidia-cusparse-cu12-12.3.1.170 nvidia-nvjitlink-cu12-12.4.127 torchdiffeq-0.2.5\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "# constant of gravity, take the pre-defined one instead of defining our own\n", + "import scipy\n", + "\n", + "\n", + "import torch\n", + "from torchdiffeq import odeint\n", + "\n", + "\n", + "from datetime import datetime" + ], + "metadata": { + "id": "pAfdaw0afrWZ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Plot Height vs Time\n", + "\n", + "As a first step, we visualise how the height of the molten steel in the conic vessel changes with time.\n", + "\n", + "We will use $r=2$ cm for this example, though the radius $r$ is the quantity we want to optimise later to make sure we can maintain the required throughput, including the change-over time.\n" + ], + "metadata": { + "id": "EiNuMdQfkauk" + } + }, + { + "cell_type": "code", + "source": [ + "# Geometry of the truncated cone\n", + "H = 2.0 # Total height of the vessel (m)\n", + "R1 = 0.9 # Radius at the bottom (m)\n", + "R2 = 1.2 # Radius at the top (m)\n", + "s = (R2 - R1) / H # Slope of the radius as a function of height\n" + ], + "metadata": { + "id": "AcIz5EjClHSh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# assume a fixed radius of the orifice\n", + "a = np.pi * (0.02)**2 # Area of the hole at the bottom (m^2)\n", + " # assuming r=2cm" + ], + "metadata": { + "id": "ccZ5IeSUwf4j" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Time parameters\n", + "t0 = 0.0 # Initial time (s)\n", + "t_end = 3000.0 # End time (s)\n", + "dt = 0.1 # Time step (s)\n", + "t_values = torch.arange(t0, t_end + dt, dt)\n", + "\n", + "# Initial condition\n", + "h0 = torch.tensor([H], dtype=torch.float32) # Initial height of the liquid (full vessel)\n", + "\n", + "# Physical Constants\n", + "g = torch.tensor(scipy.constants.g, dtype=torch.float32)" + ], + "metadata": { + "id": "OP5j1PjUlMN8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "This is the differential equation from above, assuming Torricelli's law.\n", + "\n", + "We need to encode this as ```torch``` tensors, so that we can make use of the advanced compute capabilities of PyTorch.\n", + "\n", + "We use [torch.clamp](https://pytorch.org/docs/stable/generated/torch.clamp.html) to make sure that the height of the steel in the vessel does not become negative.\n", + "\n", + "**N.B.** The function ```def dhdt(t,h)``` also depends on the parameter ```a``` (the area of the outlet orifice) and ```g```. Here, we have specified these as a global variables above.\n", + "\n", + "Since the function ```odeint``` does not take additional arguments, we have to specify these outside the scope of the function.\n", + "This is not an issue at this stage, but we will see later that this requires us to write the code in a specific way when we want to optimise the radius of the orifice and, hence, the area ```a```." + ], + "metadata": { + "id": "ATNqzi02nMgB" + } + }, + { + "cell_type": "code", + "source": [ + "# Function defining the differential equation dh/dt\n", + "def dhdt(t, h):\n", + " # Ensure h is non-negative\n", + " h = torch.clamp(h, min=0.0)\n", + " # Compute r(h)\n", + " r = R1 + s * h\n", + " # Compute A(h)\n", + " A = torch.pi * r ** 2\n", + " # Compute dh/dt\n", + " sqrt_term = torch.sqrt(2 * g * h)\n", + " dh = - (a / A) * sqrt_term\n", + " # Handle h = 0 to prevent division by zero\n", + " dh = torch.where(h > 0.0, dh, torch.tensor(0.0))\n", + " return dh" + ], + "metadata": { + "id": "RRO687otlxU5" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Solve the ODE using torchdiffeq's odeint function\n", + "h_values = odeint(dhdt, h0, t_values, method='dopri5')\n", + "\n", + "# Flatten the result to 1D tensor for easy handling\n", + "h_values = h_values.view(-1)\n", + "\n", + "# Ensure non-negative heights\n", + "h_values = torch.clamp(h_values, min=0.0)\n" + ], + "metadata": { + "id": "NJ5soVYNly9b" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Plot the results\n", + "t_np = t_values.numpy()\n", + "h_np = h_values.detach().numpy()\n", + "\n", + "plt.figure(figsize=(8, 5))\n", + "sns.lineplot(x=t_np, y=h_np)\n", + "plt.title('Height of Liquid in Truncated Cone Over Time')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Height (m)')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + }, + "id": "dSd1kx4ql4vC", + "outputId": "6de2a73a-cdd2-465b-ddda-a2614079eb91" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 800x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Optimising Outlet Radius - Differential Equation\n", + "\n", + "We will now find the optimal radius of the output orifice $r$.\n", + "As discussed above, we need to maintain a specific throughput, as well as consider the time it takes to change vessels for continuous operations.\n", + "\n", + "This means that we need to find a radius of the output orifice such that the vessel is empty at the target time ```t_target = 428.32``` s.\n", + "\n", + "N.B. in the following, we will denote the radius of the output orifice for each step of the optimisation as $r_0$ to avoid confusion with values inside each optimisation step.\n", + "\n" + ], + "metadata": { + "id": "G6dj0FhwosoG" + } + }, + { + "cell_type": "code", + "source": [ + "# Target emptying time\n", + "t_target = torch.tensor(428.32, dtype=torch.float32) # seconds" + ], + "metadata": { + "id": "ti5Iu5x6qAhH" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We now define the function that computes the height of the remaining molten steel inside the vessel at the target time ```t_target``` for a given radius $r_0$ of the output orifice.\n", + "\n", + "We then want to find the value $r_0$ where the height is zero at the end, i.e. when the vessel is empty.\n", + "\n", + "\n", + "This is implemented in the following way: For each radius, we solve the differential equation, calculate the height at various times $t$, and, in particular the time at ```t_target```.\n", + "\n", + "Since we want to find the value of $r_0$ for which the function is zero, we want to find the *root* of the function of the heights as we change $r_0$.\n", + "\n", + "Note:\n", + "Unlike earlier, the area of the orifice now depends on the radius $r_0$ that we are changing. Ideally, we would add another argument to the function with the differential equation.\n", + "However, the function ```odeint``` of [torchdiffeq](https://github.com/rtqichen/torchdiffeq) does not support this. Therefore, we define the function for the differential equation within the function computing the height at time ```t_target```. Then, for each round, the value of the area $a$ is defined and we, kind-off, side-step the problem." + ], + "metadata": { + "id": "PTwdltLgqDMS" + } + }, + { + "cell_type": "code", + "source": [ + "# Compute the height of the molten steel for a given\n", + "# radius of the outlet orifice r_0 after t_target has elapsed\n", + "\n", + "def compute_h_at_tend(r_o):\n", + " # Ensure r_o is a tensor with requires_grad=True\n", + " if not isinstance(r_o, torch.Tensor):\n", + " r_o = torch.tensor(r_o, dtype=torch.float32, requires_grad=True)\n", + " else:\n", + " r_o = r_o.clone().detach().requires_grad_(True)\n", + "\n", + "\n", + " # a is used inside dhdt, but we cannot pass it as an argument\n", + " # hence, we define a here, making it a \"global\" variable as\n", + " # far as dhdt is concerned.\n", + " # (same for g, but that truly is a constant, at least for our purposes here.)\n", + " a = torch.pi * r_o ** 2\n", + "\n", + " # Define the differential equation dh/dt\n", + " def dhdt(t, h):\n", + " h = h.clamp(min=0.0)\n", + " r = R1 + s * h\n", + " A = torch.pi * r ** 2\n", + " sqrt_term = torch.sqrt(2 * g * h)\n", + " dh = - (a / A) * sqrt_term\n", + " return dh\n", + "\n", + " # Time points for solving the ODE (start and end)\n", + " t_span = torch.tensor([0.0, t_target], dtype=torch.float32)\n", + "\n", + " # Solve the ODE\n", + " h_values = odeint(dhdt, h0, t_span, method='dopri5')\n", + " h_tend = h_values[-1, 0] # Height at t_target\n", + "\n", + " return h_tend, r_o" + ], + "metadata": { + "id": "GJG0nbEtsSof" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Before we find the optimal value, we can plot the result to get a feeling for our expectation.\n", + "\n", + "N.B. due to the line ```h = h.clamp(min=0.0)``` we cannot have negative heights in the vessel." + ], + "metadata": { + "id": "bj2N5KIL0CB9" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "\n", + "Plot the function of the height of the remaining steel in the vessel after the target time ```t_target``` has elapsed for the radius in the interval $(0.02, 0.05)$ for 100 steps.\n", + "Note that we need PyTorch tensors." + ], + "metadata": { + "id": "1dEYfP_s0jWq" + } + }, + { + "cell_type": "code", + "source": [ + "# Generate x_space and compute y_space\n", + "x_space = torch.linspace(0.02, 0.05, steps=50) # Orifice radii from 0.02 m to 0.05 m\n", + "y_space = []\n", + "\n", + "##\n", + "## your code here\n", + "##\n", + "\n", + "# Convert to NumPy arrays for plotting\n", + "x_space_np = x_space.numpy()\n", + "y_space_np = np.array(y_space)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_space_np, y_space_np, label='h(t_target)')\n", + "plt.axhline(y=0, color='black', linestyle='--', label='h=0')\n", + "\n", + "# Include known solution\n", + "plt.axvline(x=0.038, color='red', linestyle='--', label='r=0.038 m')\n", + "\n", + "plt.title('Height at $t_{target}$ vs Orifice Radius (Conic Vessel)')\n", + "plt.xlabel('Orifice Radius $r$ (m)')\n", + "plt.ylabel('Height $h(t_{target})$ (m)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()" + ], + "metadata": { + "id": "V7OcDeyg0umW" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "dELBNAZG1DDu" + } + }, + { + "cell_type": "code", + "source": [ + "# Generate x_space and compute y_space\n", + "x_space = torch.linspace(0.02, 0.05, steps=50) # Orifice radii from 0.02 m to 0.05 m\n", + "y_space = []\n", + "\n", + "for r in x_space:\n", + " h_tend, _ = compute_h_at_tend(r.item())\n", + " y_space.append(h_tend.item())\n", + "\n", + "# Convert to NumPy arrays for plotting\n", + "x_space_np = x_space.numpy()\n", + "y_space_np = np.array(y_space)\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(x_space_np, y_space_np, label='h(t_target)')\n", + "plt.axhline(y=0, color='black', linestyle='--', label='h=0')\n", + "\n", + "# Include known solution\n", + "plt.axvline(x=0.038, color='red', linestyle='--', label='r=0.038 m')\n", + "\n", + "plt.title('Height at $t_{target}$ vs Orifice Radius (Conic Vessel)')\n", + "plt.xlabel('Orifice Radius $r$ (m)')\n", + "plt.ylabel('Height $h(t_{target})$ (m)')\n", + "plt.legend()\n", + "plt.grid(True)\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 568 + }, + "id": "Zd_OZdKyygnx", + "outputId": "f5aee4bf-95b5-464d-812d-aa401712a6a1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x600 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Newton's Method\n", + "\n", + "We can find the root of the above function using, for example, Newton's method, and detemine the optimal radius of the outlet orifice." + ], + "metadata": { + "id": "ZpDou3GMspeU" + } + }, + { + "cell_type": "code", + "source": [ + "def newtons_method(f, r_o_init, tol=1e-6, rtol=1e-6, max_iter=20):\n", + " r_o = torch.tensor(r_o_init, dtype=torch.float32, requires_grad=True)\n", + " for i in range(max_iter):\n", + " h_tend, r_o = f(r_o)\n", + " f_r_o = h_tend # We aim for h_tend = 0\n", + "\n", + " if torch.abs(f_r_o) < tol:\n", + " print(f\"Converged at iteration {i}: r_o = {r_o.item():.6f} m\")\n", + " return r_o.item()\n", + "\n", + " f_r_o.backward()\n", + " f_prime = r_o.grad.item()\n", + "\n", + " if f_prime == 0:\n", + " print(\"Derivative zero. Stopping iteration.\")\n", + " return r_o.item()\n", + "\n", + " # Update r_o using Newton's method\n", + " r_o_new = r_o - f_r_o / f_prime\n", + "\n", + " # Check for convergence based on change in r_o\n", + " delta_r_o = torch.abs(r_o_new - r_o)\n", + " if delta_r_o < rtol:\n", + " print(f\"Converged at iteration {i}: r_o = {r_o_new.item():.6f} m (delta_r_o < {rtol})\")\n", + " return r_o_new.item()\n", + "\n", + " # Prepare for next iteration\n", + " r_o = r_o_new.detach().requires_grad_(True)\n", + " print(f\"Iteration {i}: r_o = {r_o.item():.6f} m, h(t_end) = {h_tend.item():.6f}, f'(r_o) = {f_prime:.6f}, delta_r_o = {delta_r_o.item():.6f}\")\n", + "\n", + " print(\"Maximum iterations reached without convergence.\")\n", + " return r_o.item()" + ], + "metadata": { + "id": "T5I5RaEeszoC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Define the function f(r_o)\n", + "def f(r_o):\n", + " h_tend, r_o = compute_h_at_tend(r_o)\n", + " return h_tend, r_o\n", + "\n", + "# Initial guess for r_o (in meters)\n", + "r_o_initial = 0.025 # 25 mm\n", + "\n", + "# Run Newton's method\n", + "t_start = datetime.now()\n", + "optimal_r_o = newtons_method(f, r_o_initial, tol=1e-5, rtol=1e-6, max_iter=50)\n", + "t_stop = datetime.now()\n", + "print(f\"\\nOptimal orifice radius found: {optimal_r_o * 1000:.2f} mm\")\n", + "print(f'Time taken: {t_stop - t_start}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "W9tlOcaNs2tY", + "outputId": "0798d66d-d770-47d3-f5c4-476be420fcc9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Iteration 0: r_o = 0.035460 m, h(t_end) = 0.871790, f'(r_o) = -83.348442, delta_r_o = 0.010460\n", + "Iteration 1: r_o = 0.037223 m, h(t_end) = 0.081241, f'(r_o) = -46.081654, delta_r_o = 0.001763\n", + "Iteration 2: r_o = 0.038015 m, h(t_end) = 0.018847, f'(r_o) = -23.784437, delta_r_o = 0.000792\n", + "Iteration 3: r_o = 0.038396 m, h(t_end) = 0.004587, f'(r_o) = -12.040705, delta_r_o = 0.000381\n", + "Iteration 4: r_o = 0.038583 m, h(t_end) = 0.001134, f'(r_o) = -6.053280, delta_r_o = 0.000187\n", + "Iteration 5: r_o = 0.038676 m, h(t_end) = 0.000282, f'(r_o) = -3.034362, delta_r_o = 0.000093\n", + "Iteration 6: r_o = 0.038722 m, h(t_end) = 0.000070, f'(r_o) = -1.519046, delta_r_o = 0.000046\n", + "Iteration 7: r_o = 0.038746 m, h(t_end) = 0.000018, f'(r_o) = -0.759962, delta_r_o = 0.000023\n", + "Converged at iteration 8: r_o = 0.038746 m\n", + "\n", + "Optimal orifice radius found: 38.75 mm\n", + "Time taken: 0:00:01.596860\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now plot the final function of height vs time for the optimal radius\n", + "\n", + "(remember that we cannot add another argument to the function ```dhdt```, so we need to define it again with the optimal radius).\n" + ], + "metadata": { + "id": "XD0WIuTeuw1y" + } + }, + { + "cell_type": "code", + "source": [ + "def dhdt_opt(t, h):\n", + " h = h.clamp(min=0.0)\n", + " r = R1 + s * h\n", + " A = torch.pi * r ** 2\n", + " sqrt_term = torch.sqrt(2 * g * h)\n", + " a_opt = torch.pi * optimal_r_o ** 2\n", + " dh = - (a_opt / A) * sqrt_term\n", + " return dh\n", + "\n", + "t_values = torch.linspace(0.0, t_target.item(), steps=200)\n", + "h_values_opt = odeint(dhdt_opt, h0, t_values, method='dopri5')\n", + "h_values_opt = h_values_opt.view(-1)\n", + "h_values_opt = h_values_opt.clamp(min=0.0).detach().numpy()\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.plot(t_values.numpy(), h_values_opt)\n", + "plt.title('Height of Liquid in Truncated Cone Over Time (Optimal r_o via Newton\\'s Method)')\n", + "plt.xlabel('Time (s)')\n", + "plt.ylabel('Height (m)')\n", + "plt.grid(True)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 564 + }, + "id": "sMYY2gAvu1mT", + "outputId": "808bc199-cbdc-4707-87dd-8b340e6d7b29" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 1000x600 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Optimising Outlet Radius - Iterative Approach\n", + "\n", + "Instead of using a package to solve the differential equation, we can also use an iterative approach and discretise the differential equation.\n", + "The following function computes the height at a specific target time ```desired_time``` as a function of the radius ```r``` of the output orifice.\n", + "\n", + "The remainnig parameters (```R1, R2, initial_height```) specifiy the geometry and initial height of the molten steel in the vessel. We can make these parameters argument to the function here as we are not constrained by the calling function like ```odeint``` earlier.\n", + "\n", + "N.B. We need to work with PyTorch tensors (or types that are easily converted) to be able to call Newton's method efficiently later on." + ], + "metadata": { + "id": "t1jsBFi-1zF-" + } + }, + { + "cell_type": "code", + "source": [ + "def calculate_height_fixpoint(r: torch.tensor, delta_t: float = 1.0, t_max: float = 100000.0,\n", + " R1: float = 0.9, R2: float = 1.2, initial_height: float = 2.0,\n", + " desired_time: float = 428.2) -> torch.tensor:\n", + " \"\"\"\n", + " Calculate the height at a specific desired time based on the given radius value.\n", + "\n", + " Parameters:\n", + " r (torch.tensor): Radius value with requires_grad=True.\n", + " delta_t (float): Time step for calculations (default is 1.0).\n", + " t_max (float): Maximum time for simulation in seconds (default is 100000.0).\n", + " R1 (float): First radius constant in meters (default is 0.9).\n", + " R2 (float): Second radius constant in meters (default is 1.2).\n", + " initial_height (float): The starting height in meters (default is 2.0).\n", + " desired_time (float): The specific time at which to calculate the height.\n", + "\n", + " Returns:\n", + " torch.tensor: The height at the desired time.\n", + " \"\"\"\n", + "\n", + " # Ensure r has requires_grad=True\n", + " if not r.requires_grad:\n", + " r.requires_grad = True\n", + "\n", + " # Number of steps\n", + " num_steps = int(torch.ceil(torch.tensor(t_max / delta_t)).item())\n", + " desired_step = int(torch.ceil(torch.tensor(desired_time / delta_t)).item())\n", + " max_step = min(num_steps, desired_step)\n", + "\n", + " # Initialize heights as a list to avoid in-place operations\n", + " heights = []\n", + " current_height = torch.tensor(initial_height, dtype=torch.float32)\n", + "\n", + " # convert the numerical constants used in the code below\n", + " # into torch.tensors, so we can use them without breaking the graph.\n", + " # (PyTorch does not contain a set of mathematical or physical constants)\n", + " pi = torch.tensor(np.pi, dtype=torch.float32)\n", + " g = torch.tensor(scipy.constants.g, dtype=torch.float32)\n", + "\n", + " for i in range(max_step):\n", + " # Ensure no negative heights for sqrt\n", + " current_height_pos = torch.clamp(current_height, min=0.0)\n", + "\n", + " effective_radius = R1 + (current_height_pos / initial_height) * (R2 - R1)\n", + " flow_rate = (r / effective_radius)**2 * torch.sqrt(2 * g * current_height_pos)\n", + "\n", + " next_height = current_height - delta_t * flow_rate\n", + "\n", + " # Ensure next_height is not negative\n", + " next_height = torch.clamp(next_height, min=0.0)\n", + "\n", + " # Append current_height to the list\n", + " heights.append(current_height)\n", + "\n", + " # Update current_height for the next iteration\n", + " current_height = next_height\n", + "\n", + " # The height at the desired time\n", + " height_at_desired_time = current_height\n", + "\n", + " return height_at_desired_time" + ], + "metadata": { + "id": "34g7UoXu2A0I" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "\n", + "Use the above function to call the function ```newtons_method``` we defined earlier and find the optimal radius of the output orifice." + ], + "metadata": { + "id": "kkMJ_cT9E-H4" + } + }, + { + "cell_type": "code", + "source": [ + "##\n", + "## your code goes here\n", + "##" + ], + "metadata": { + "id": "ybu1ouSSFQhG" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "oKGUQSaqFOin" + } + }, + { + "cell_type": "code", + "source": [ + "# with Newton's Method above\n", + "\n", + "# Define the function f(r_o)\n", + "def f(r_o):\n", + " h_tend = calculate_height_fixpoint(r_o)\n", + " return h_tend, r_o\n", + "\n", + "# Initial guess for r_o (in meters)\n", + "r_o_initial = 0.025 # 25 mm\n", + "\n", + "# Run Newton's method\n", + "t_start = datetime.now()\n", + "optimal_r_o = newtons_method(f, r_o_initial, tol=1e-5, rtol=1e-6, max_iter=50)\n", + "t_stop = datetime.now()\n", + "print(f\"\\nOptimal orifice radius found: {optimal_r_o * 1000:.2f} mm\")\n", + "print(f'Time taken: {t_stop - t_start}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vKIG_b6d2VcF", + "outputId": "8cda474d-9262-4147-9a00-cc371621ad6b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Iteration 0: r_o = 0.035422 m, h(t_end) = 0.870002, f'(r_o) = -83.478127, delta_r_o = 0.010422\n", + "Iteration 1: r_o = 0.037166 m, h(t_end) = 0.080678, f'(r_o) = -46.268208, delta_r_o = 0.001744\n", + "Iteration 2: r_o = 0.037940 m, h(t_end) = 0.018590, f'(r_o) = -23.999514, delta_r_o = 0.000775\n", + "Iteration 3: r_o = 0.038304 m, h(t_end) = 0.004466, f'(r_o) = -12.270845, delta_r_o = 0.000364\n", + "Iteration 4: r_o = 0.038475 m, h(t_end) = 0.001076, f'(r_o) = -6.296812, delta_r_o = 0.000171\n", + "Iteration 5: r_o = 0.038552 m, h(t_end) = 0.000253, f'(r_o) = -3.300025, delta_r_o = 0.000077\n", + "Iteration 6: r_o = 0.038582 m, h(t_end) = 0.000055, f'(r_o) = -1.833591, delta_r_o = 0.000030\n", + "Converged at iteration 7: r_o = 0.038582 m\n", + "\n", + "Optimal orifice radius found: 38.58 mm\n", + "Time taken: 0:00:01.100965\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/datascienceintro/solutions/Solution_CyclicBoosting.ipynb b/datascienceintro/solutions/Solution_CyclicBoosting.ipynb new file mode 100644 index 0000000..9e7f1fe --- /dev/null +++ b/datascienceintro/solutions/Solution_CyclicBoosting.ipynb @@ -0,0 +1,2872 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Explainable Machine Learning with Cyclic Boosting\n", + "\n", + "In many application areas, it is paramount that we can explain how how predictions are made. We can either use post-hoc methods that can locally explain any machine learning model (e.g. a neural network) or use so-called *white box* models that are inherently explainable.\n", + "\n", + "The key challenge is that we cannot have it all: We want a powerful model that can make accurate predictions for complex datasets, and it should be fully explainable.\n", + "Therefore, we need to decide on the best compromise for each application. For example, simple linear regression is easy to explain, both from a model perspective, as well for each prediction (as the coefficients directly relate to the importance of a feature) - however, in general, this method is not powerful enough for many applications. Random Forrests and other methods are much more powerful - but less explainable.\n", + "\n", + "A different approach is to use **generalised additive models** (GAM): They are, essentially, more powerful versions of linear regressions that retain most of the explainablilty of linear regresion models.\n", + "For linear regression, the prediction model is given by $$\\hat{y} = \\sum_j \\alpha_j x_j + \\beta $$\n", + "where the $c_j$ are the coefficients optimised during training and $x_j$ are the features (variables).\n", + "In Generalised Additive Models, this is extended to $$g(E[\\hat{y}]) = \\beta_0 + \\sum_j f_j(x_j)$$.\n", + "Here, $E[\\cdot]$ is the expectation value, $g(\\cdot)$ is called a *link function*, and $f_j$ are some functions that operate on the features (variables) $x_j$.\n", + "\n", + "One method is called *Cyclic Boosting*, you can find more information in [Cyclic Boosting - an explainable supervised machine learning algorithm](https://arxiv.org/abs/2002.03425) and [Demand Forecasting of Individual Probability Density Functions with Machine Learning](https://arxiv.org/abs/2009.07052), as well as on the [Cyclic Boosting GitHub](https://github.com/Blue-Yonder-OSS/cyclic-boosting).\n" + ], + "metadata": { + "id": "XK5m6PqEfRGg" + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lqW01yddrFMz", + "outputId": "816757bf-085d-40fd-c032-35d027c727c8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: cyclic-boosting in /usr/local/lib/python3.11/dist-packages (1.4.0)\n", + "Requirement already satisfied: decorator>=5.1.1 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (5.2.1)\n", + "Requirement already satisfied: hypothesis>=6.70.0 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (6.129.0)\n", + "Requirement already satisfied: matplotlib>=1.5.1 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (3.10.0)\n", + "Requirement already satisfied: numba>=0.56.4 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (0.60.0)\n", + "Requirement already satisfied: numexpr>=2.5.2 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (2.10.2)\n", + "Requirement already satisfied: numpy>=1.12.1 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (1.26.4)\n", + "Requirement already satisfied: pandas>=0.20.3 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (2.2.2)\n", + "Requirement already satisfied: scikit-learn>=0.18.2 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (1.6.1)\n", + "Requirement already satisfied: scipy>=1.10 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (1.14.1)\n", + "Requirement already satisfied: six>=1.16.0 in /usr/local/lib/python3.11/dist-packages (from cyclic-boosting) (1.17.0)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.11/dist-packages (from hypothesis>=6.70.0->cyclic-boosting) (25.1.0)\n", + "Requirement already satisfied: sortedcontainers<3.0.0,>=2.1.0 in /usr/local/lib/python3.11/dist-packages (from hypothesis>=6.70.0->cyclic-boosting) (2.4.0)\n", + "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (1.3.1)\n", + "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (0.12.1)\n", + "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (4.56.0)\n", + "Requirement already satisfied: kiwisolver>=1.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (1.4.8)\n", + "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (24.2)\n", + "Requirement already satisfied: pillow>=8 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (11.1.0)\n", + "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (3.2.1)\n", + "Requirement already satisfied: python-dateutil>=2.7 in /usr/local/lib/python3.11/dist-packages (from matplotlib>=1.5.1->cyclic-boosting) (2.8.2)\n", + "Requirement already satisfied: llvmlite<0.44,>=0.43.0dev0 in /usr/local/lib/python3.11/dist-packages (from numba>=0.56.4->cyclic-boosting) (0.43.0)\n", + "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.11/dist-packages (from pandas>=0.20.3->cyclic-boosting) (2025.1)\n", + "Requirement already satisfied: tzdata>=2022.7 in /usr/local/lib/python3.11/dist-packages (from pandas>=0.20.3->cyclic-boosting) (2025.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=0.18.2->cyclic-boosting) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.11/dist-packages (from scikit-learn>=0.18.2->cyclic-boosting) (3.5.0)\n" + ] + } + ], + "source": [ + "# install the package if not avaialable\n", + "!pip install cyclic-boosting\n" + ] + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "from sklearn import metrics\n", + "\n", + "from cyclic_boosting import CBClassifier\n", + "from cyclic_boosting import flags\n", + "from cyclic_boosting import observers\n", + "from cyclic_boosting.plots import plot_analysis\n", + "from cyclic_boosting import common_smoothers\n", + "from cyclic_boosting import binning\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n" + ], + "metadata": { + "id": "84AwAHKUt_xk" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## Data\n", + "\n", + "We will use the [adult](https://archive.ics.uci.edu/ml/datasets/adult) that focuses on a (binary) classification task whether or not a person makes more than 50k USD per year. The data are taken from a 1994 census and were first discussed in the paper [Ron Kohavi, \"Scaling Up the Accuracy of Naive-Bayes Classifiers: a Decision-Tree Hybrid\", Proceedings of the Second International Conference on Knowledge Discovery and Data Mining, 1996](https://www.academia.edu/download/40088603/Scaling_Up_the_Accuracy_of_Naive-Bayes_C20151116-5477-1fw84ob.pdf)\n" + ], + "metadata": { + "id": "5gGVyjScxxCK" + } + }, + { + "cell_type": "code", + "source": [ + "df = pd.read_csv(\n", + " \"https://archive.ics.uci.edu/ml/machine-learning-databases/adult/adult.data\",\n", + " header=None)\n", + "df.columns = [\n", + " \"Age\", \"WorkClass\", \"fnlwgt\", \"Education\", \"EducationNum\",\n", + " \"MaritalStatus\", \"Occupation\", \"Relationship\", \"Race\", \"Gender\",\n", + " \"CapitalGain\", \"CapitalLoss\", \"HoursPerWeek\", \"NativeCountry\", \"Income\"\n", + "]\n", + "\n", + "# change the type of the variables to \"categorial\" for the respective variables\n", + "df = df.astype({'WorkClass': 'category', 'Education': 'category', 'MaritalStatus' : 'category', 'Occupation' : 'category',\n", + "'Relationship' : 'category', 'Race' : 'category', 'Gender': 'category', 'NativeCountry': 'category' })" + ], + "metadata": { + "id": "-ryzXarVsXfe" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "df.head(10)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 484 + }, + "id": "yfOU0f4vtiFT", + "outputId": "fed6cb48-e9c0-4583-f0b8-b9c11a33b2a5" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Age WorkClass fnlwgt Education EducationNum \\\n", + "0 39 State-gov 77516 Bachelors 13 \n", + "1 50 Self-emp-not-inc 83311 Bachelors 13 \n", + "2 38 Private 215646 HS-grad 9 \n", + "3 53 Private 234721 11th 7 \n", + "4 28 Private 338409 Bachelors 13 \n", + "5 37 Private 284582 Masters 14 \n", + "6 49 Private 160187 9th 5 \n", + "7 52 Self-emp-not-inc 209642 HS-grad 9 \n", + "8 31 Private 45781 Masters 14 \n", + "9 42 Private 159449 Bachelors 13 \n", + "\n", + " MaritalStatus Occupation Relationship Race \\\n", + "0 Never-married Adm-clerical Not-in-family White \n", + "1 Married-civ-spouse Exec-managerial Husband White \n", + "2 Divorced Handlers-cleaners Not-in-family White \n", + "3 Married-civ-spouse Handlers-cleaners Husband Black \n", + "4 Married-civ-spouse Prof-specialty Wife Black \n", + "5 Married-civ-spouse Exec-managerial Wife White \n", + "6 Married-spouse-absent Other-service Not-in-family Black \n", + "7 Married-civ-spouse Exec-managerial Husband White \n", + "8 Never-married Prof-specialty Not-in-family White \n", + "9 Married-civ-spouse Exec-managerial Husband White \n", + "\n", + " Gender CapitalGain CapitalLoss HoursPerWeek NativeCountry Income \n", + "0 Male 2174 0 40 United-States <=50K \n", + "1 Male 0 0 13 United-States <=50K \n", + "2 Male 0 0 40 United-States <=50K \n", + "3 Male 0 0 40 United-States <=50K \n", + "4 Female 0 0 40 Cuba <=50K \n", + "5 Female 0 0 40 United-States <=50K \n", + "6 Female 0 0 16 Jamaica <=50K \n", + "7 Male 0 0 45 United-States >50K \n", + "8 Female 14084 0 50 United-States >50K \n", + "9 Male 5178 0 40 United-States >50K " + ], + "text/html": [ + "\n", + " <div id=\"df-7f36a7bb-c6b9-4761-b6a4-320262d2d03e\" 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>Age</th>\n", + " <th>WorkClass</th>\n", + " <th>fnlwgt</th>\n", + " <th>Education</th>\n", + " <th>EducationNum</th>\n", + " <th>MaritalStatus</th>\n", + " <th>Occupation</th>\n", + " <th>Relationship</th>\n", + " <th>Race</th>\n", + " <th>Gender</th>\n", + " <th>CapitalGain</th>\n", + " <th>CapitalLoss</th>\n", + " <th>HoursPerWeek</th>\n", + " <th>NativeCountry</th>\n", + " <th>Income</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>39</td>\n", + " <td>State-gov</td>\n", + " <td>77516</td>\n", + " <td>Bachelors</td>\n", + " <td>13</td>\n", + " <td>Never-married</td>\n", + " <td>Adm-clerical</td>\n", + " <td>Not-in-family</td>\n", + " <td>White</td>\n", + " <td>Male</td>\n", + " <td>2174</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>United-States</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>50</td>\n", + " <td>Self-emp-not-inc</td>\n", + " <td>83311</td>\n", + " <td>Bachelors</td>\n", + " <td>13</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Exec-managerial</td>\n", + " <td>Husband</td>\n", + " <td>White</td>\n", + " <td>Male</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>13</td>\n", + " <td>United-States</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>38</td>\n", + " <td>Private</td>\n", + " <td>215646</td>\n", + " <td>HS-grad</td>\n", + " <td>9</td>\n", + " <td>Divorced</td>\n", + " <td>Handlers-cleaners</td>\n", + " <td>Not-in-family</td>\n", + " <td>White</td>\n", + " <td>Male</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>United-States</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>53</td>\n", + " <td>Private</td>\n", + " <td>234721</td>\n", + " <td>11th</td>\n", + " <td>7</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Handlers-cleaners</td>\n", + " <td>Husband</td>\n", + " <td>Black</td>\n", + " <td>Male</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>United-States</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>28</td>\n", + " <td>Private</td>\n", + " <td>338409</td>\n", + " <td>Bachelors</td>\n", + " <td>13</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Prof-specialty</td>\n", + " <td>Wife</td>\n", + " <td>Black</td>\n", + " <td>Female</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>Cuba</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>5</th>\n", + " <td>37</td>\n", + " <td>Private</td>\n", + " <td>284582</td>\n", + " <td>Masters</td>\n", + " <td>14</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Exec-managerial</td>\n", + " <td>Wife</td>\n", + " <td>White</td>\n", + " <td>Female</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>United-States</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>6</th>\n", + " <td>49</td>\n", + " <td>Private</td>\n", + " <td>160187</td>\n", + " <td>9th</td>\n", + " <td>5</td>\n", + " <td>Married-spouse-absent</td>\n", + " <td>Other-service</td>\n", + " <td>Not-in-family</td>\n", + " <td>Black</td>\n", + " <td>Female</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>16</td>\n", + " <td>Jamaica</td>\n", + " <td><=50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7</th>\n", + " <td>52</td>\n", + " <td>Self-emp-not-inc</td>\n", + " <td>209642</td>\n", + " <td>HS-grad</td>\n", + " <td>9</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Exec-managerial</td>\n", + " <td>Husband</td>\n", + " <td>White</td>\n", + " <td>Male</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>45</td>\n", + " <td>United-States</td>\n", + " <td>>50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>8</th>\n", + " <td>31</td>\n", + " <td>Private</td>\n", + " <td>45781</td>\n", + " <td>Masters</td>\n", + " <td>14</td>\n", + " <td>Never-married</td>\n", + " <td>Prof-specialty</td>\n", + " <td>Not-in-family</td>\n", + " <td>White</td>\n", + " <td>Female</td>\n", + " <td>14084</td>\n", + " <td>0</td>\n", + " <td>50</td>\n", + " <td>United-States</td>\n", + " <td>>50K</td>\n", + " </tr>\n", + " <tr>\n", + " <th>9</th>\n", + " <td>42</td>\n", + " <td>Private</td>\n", + " <td>159449</td>\n", + " <td>Bachelors</td>\n", + " <td>13</td>\n", + " <td>Married-civ-spouse</td>\n", + " <td>Exec-managerial</td>\n", + " <td>Husband</td>\n", + " <td>White</td>\n", + " <td>Male</td>\n", + " <td>5178</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>United-States</td>\n", + " <td>>50K</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-7f36a7bb-c6b9-4761-b6a4-320262d2d03e')\"\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-7f36a7bb-c6b9-4761-b6a4-320262d2d03e 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-7f36a7bb-c6b9-4761-b6a4-320262d2d03e');\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-26f066fc-24e7-44d9-82e4-cc925539f553\">\n", + " <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-26f066fc-24e7-44d9-82e4-cc925539f553')\"\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-26f066fc-24e7-44d9-82e4-cc925539f553 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", + "variable_name": "df", + "summary": "{\n \"name\": \"df\",\n \"rows\": 32561,\n \"fields\": [\n {\n \"column\": \"Age\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 13,\n \"min\": 17,\n \"max\": 90,\n \"num_unique_values\": 73,\n \"samples\": [\n 28,\n 73,\n 35\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"WorkClass\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 9,\n \"samples\": [\n \" Without-pay\",\n \" Self-emp-not-inc\",\n \" ?\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fnlwgt\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 105549,\n \"min\": 12285,\n \"max\": 1484705,\n \"num_unique_values\": 21648,\n \"samples\": [\n 128485,\n 469907,\n 235951\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Education\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 16,\n \"samples\": [\n \" Bachelors\",\n \" HS-grad\",\n \" Some-college\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"EducationNum\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 1,\n \"max\": 16,\n \"num_unique_values\": 16,\n \"samples\": [\n 13,\n 9,\n 10\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"MaritalStatus\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 7,\n \"samples\": [\n \" Never-married\",\n \" Married-civ-spouse\",\n \" Married-AF-spouse\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Occupation\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 15,\n \"samples\": [\n \" Machine-op-inspct\",\n \" ?\",\n \" Adm-clerical\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Relationship\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 6,\n \"samples\": [\n \" Not-in-family\",\n \" Husband\",\n \" Other-relative\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Race\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 5,\n \"samples\": [\n \" Black\",\n \" Other\",\n \" Asian-Pac-Islander\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Gender\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 2,\n \"samples\": [\n \" Female\",\n \" Male\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalGain\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 7385,\n \"min\": 0,\n \"max\": 99999,\n \"num_unique_values\": 119,\n \"samples\": [\n 3781,\n 15831\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalLoss\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 402,\n \"min\": 0,\n \"max\": 4356,\n \"num_unique_values\": 92,\n \"samples\": [\n 419,\n 2051\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"HoursPerWeek\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12,\n \"min\": 1,\n \"max\": 99,\n \"num_unique_values\": 94,\n \"samples\": [\n 6,\n 22\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"NativeCountry\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 42,\n \"samples\": [\n \" El-Salvador\",\n \" Philippines\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Income\",\n \"properties\": {\n \"dtype\": \"category\",\n \"num_unique_values\": 2,\n \"samples\": [\n \" >50K\",\n \" <=50K\"\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Exploratory Data Analaysis\n", + "\n", + "As a first step, we look at the variables to understand how the target we want to predict is correlated with the features.\n", + "\n", + "The function ```displot``` from the [Seaborn](https://seaborn.pydata.org/) package can handle the text values from the data directly.\n", + "\n", + "***Exercise***\n", + "\n", + "Explore the influence of the various variables on the target, e.g. the education level, gender or race.\n", + "Try to understand if or how the behaviour you see would make sense with your understanding." + ], + "metadata": { + "id": "Q_uRjXFxyGGZ" + } + }, + { + "cell_type": "code", + "source": [ + "sns.displot(data=df,y='Education',hue='Income')\n", + "plt.xlabel('count', size = 20)\n", + "plt.ylabel('Education', size = 20)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 520 + }, + "id": "J8Y5WDVIyFyx", + "outputId": "f9c9517d-2cb2-421b-edc3-15ad542cfd7d" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 604.125x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.displot(data=df,x='MaritalStatus',hue='Income')\n", + "plt.ylabel('count', size = 20)\n", + "plt.xlabel('Marital Status', size = 20)\n", + "plt.xticks(rotation=-45)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 632 + }, + "id": "25_RVS2dySMe", + "outputId": "594204f1-71eb-478d-f2c7-38062a468276" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 604.125x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.displot(data=df,x='Gender',hue='Income')\n", + "plt.ylabel('count', size = 20)\n", + "plt.xlabel('Gender', size = 20)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 520 + }, + "id": "g1XIGRanyVay", + "outputId": "7f180c54-d819-4034-e1fc-c120f02b0752" + }, + "execution_count": 7, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 604.125x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.displot(data=df,x='Race',hue='Income')\n", + "plt.ylabel('count', size = 20)\n", + "plt.xlabel('Race', size = 20)\n", + "plt.xticks(rotation=-45)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 618 + }, + "id": "3VeUcYJ7yYMk", + "outputId": "5f5f9a0b-720e-4834-e0e3-da2c53be75ec" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 604.125x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "sns.displot(data=df,y='Occupation',hue='Income')\n", + "plt.xlabel('count', size = 20)\n", + "plt.ylabel('Occupation', size = 20)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 520 + }, + "id": "ePV1fNp_yaO_", + "outputId": "f104175a-3ee8-48ff-b6b3-563002704b3e" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 604.125x500 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "We can also look at variables with (continuous) numerical values.\n", + "These are binned and we use a histogram which allows us to examine the behaviour of the feature variable w.r.t. the target.\n", + "If you look at the variable ```HoursPerWeek```, using 20 bins works quite well.\n", + "Note the strong peak at 40 hours (default work week), so use a log-scale for the ```y```-axis." + ], + "metadata": { + "id": "NSYMHigPydnt" + } + }, + { + "cell_type": "code", + "source": [ + "g = sns.histplot(data=df, x='HoursPerWeek', hue='Income',bins=20)\n", + "g.set_yscale(\"log\")\n", + "plt.ylabel('count', size = 20)\n", + "plt.xlabel('Hours per week', size = 20)\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 463 + }, + "id": "pZXFiXjaygbj", + "outputId": "b14c82c5-494c-49a5-880f-fd50042ce78d" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Data Preparation\n", + "\n", + "In order to work with the data further, we need to convert the text in the categorial variables into numerical values.\n", + "Pandas provides a datatype ```category``` which we can use for this purpose.\n", + "As a first step, we need to change the variable type of the respective columns to this datatype.\n", + "\n", + "Then, in the next step, we can use ```.cat.codes``` to access a numerical representation.\n", + "An alternative would be to use \"One-Hot-Encoding\". Pandas provides a utitlity function for this called [get_dummies](https://pandas.pydata.org/docs/reference/api/pandas.get_dummies.html)." + ], + "metadata": { + "id": "YCPHEeKfyNqq" + } + }, + { + "cell_type": "code", + "source": [ + "# select all columns with the datatype \"category\"\n", + "cat_columns = df.select_dtypes(['category']).columns\n", + "print(cat_columns)\n", + "\n", + "#convert all text to numerical values\n", + "df[cat_columns] = df[cat_columns].apply(lambda x: x.cat.codes)\n", + "\n", + "# convert target column (income) to 0 or 1\n", + "df['Income'] = df['Income'].apply(lambda x: 0 if x == \" <=50K\" else 1)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "E-4RKwK_yygd", + "outputId": "f03df91d-04eb-4142-e419-cf29f3522b35" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Index(['WorkClass', 'Education', 'MaritalStatus', 'Occupation', 'Relationship',\n", + " 'Race', 'Gender', 'NativeCountry'],\n", + " dtype='object')\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Split the dataframe into two dataframes for the features (variables) ```X``` and the target (label) ```y```." + ], + "metadata": { + "id": "VSyWhFq3zAax" + } + }, + { + "cell_type": "code", + "source": [ + "# the target column is the last column (Income)\n", + "train_cols = df.columns[0:-1]\n", + "X = df[train_cols]\n", + "\n", + "y = df['Income']" + ], + "metadata": { + "id": "yg8ObcYOuiLn" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Check that ```X``` really doesn't contain the target (label)" + ], + "metadata": { + "id": "5LGVWJ1BzIRn" + } + }, + { + "cell_type": "code", + "source": [ + "X.head(5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 206 + }, + "id": "8lPOVWnrmBlk", + "outputId": "b5c34e9c-49e5-4404-d48d-354bbb22caf3" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Age WorkClass fnlwgt Education EducationNum MaritalStatus Occupation \\\n", + "0 39 7 77516 9 13 4 1 \n", + "1 50 6 83311 9 13 2 4 \n", + "2 38 4 215646 11 9 0 6 \n", + "3 53 4 234721 1 7 2 6 \n", + "4 28 4 338409 9 13 2 10 \n", + "\n", + " Relationship Race Gender CapitalGain CapitalLoss HoursPerWeek \\\n", + "0 1 4 1 2174 0 40 \n", + "1 0 4 1 0 0 13 \n", + "2 1 4 1 0 0 40 \n", + "3 0 2 1 0 0 40 \n", + "4 5 2 0 0 0 40 \n", + "\n", + " NativeCountry \n", + "0 39 \n", + "1 39 \n", + "2 39 \n", + "3 39 \n", + "4 5 " + ], + "text/html": [ + "\n", + " <div id=\"df-171303a2-5d76-4c9a-8606-67d4f3746b4c\" 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>Age</th>\n", + " <th>WorkClass</th>\n", + " <th>fnlwgt</th>\n", + " <th>Education</th>\n", + " <th>EducationNum</th>\n", + " <th>MaritalStatus</th>\n", + " <th>Occupation</th>\n", + " <th>Relationship</th>\n", + " <th>Race</th>\n", + " <th>Gender</th>\n", + " <th>CapitalGain</th>\n", + " <th>CapitalLoss</th>\n", + " <th>HoursPerWeek</th>\n", + " <th>NativeCountry</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>39</td>\n", + " <td>7</td>\n", + " <td>77516</td>\n", + " <td>9</td>\n", + " <td>13</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>2174</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>50</td>\n", + " <td>6</td>\n", + " <td>83311</td>\n", + " <td>9</td>\n", + " <td>13</td>\n", + " <td>2</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>13</td>\n", + " <td>39</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>38</td>\n", + " <td>4</td>\n", + " <td>215646</td>\n", + " <td>11</td>\n", + " <td>9</td>\n", + " <td>0</td>\n", + " <td>6</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>53</td>\n", + " <td>4</td>\n", + " <td>234721</td>\n", + " <td>1</td>\n", + " <td>7</td>\n", + " <td>2</td>\n", + " <td>6</td>\n", + " <td>0</td>\n", + " <td>2</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>28</td>\n", + " <td>4</td>\n", + " <td>338409</td>\n", + " <td>9</td>\n", + " <td>13</td>\n", + " <td>2</td>\n", + " <td>10</td>\n", + " <td>5</td>\n", + " <td>2</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>5</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-171303a2-5d76-4c9a-8606-67d4f3746b4c')\"\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-171303a2-5d76-4c9a-8606-67d4f3746b4c 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-171303a2-5d76-4c9a-8606-67d4f3746b4c');\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-3414a247-fc24-4494-882d-d83a54bc5dcb\">\n", + " <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-3414a247-fc24-4494-882d-d83a54bc5dcb')\"\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-3414a247-fc24-4494-882d-d83a54bc5dcb 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", + "variable_name": "X", + "summary": "{\n \"name\": \"X\",\n \"rows\": 32561,\n \"fields\": [\n {\n \"column\": \"Age\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 13,\n \"min\": 17,\n \"max\": 90,\n \"num_unique_values\": 73,\n \"samples\": [\n 28,\n 73,\n 35\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"WorkClass\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 9,\n \"samples\": [\n 8,\n 6,\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fnlwgt\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 105549,\n \"min\": 12285,\n \"max\": 1484705,\n \"num_unique_values\": 21648,\n \"samples\": [\n 128485,\n 469907,\n 235951\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Education\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 16,\n \"samples\": [\n 9,\n 11,\n 15\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"EducationNum\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 1,\n \"max\": 16,\n \"num_unique_values\": 16,\n \"samples\": [\n 13,\n 9,\n 10\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"MaritalStatus\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 7,\n \"samples\": [\n 4,\n 2,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Occupation\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 15,\n \"samples\": [\n 7,\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Relationship\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 6,\n \"samples\": [\n 1,\n 0,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Race\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 5,\n \"samples\": [\n 2,\n 3,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Gender\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalGain\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 7385,\n \"min\": 0,\n \"max\": 99999,\n \"num_unique_values\": 119,\n \"samples\": [\n 3781,\n 15831\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalLoss\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 402,\n \"min\": 0,\n \"max\": 4356,\n \"num_unique_values\": 92,\n \"samples\": [\n 419,\n 2051\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"HoursPerWeek\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12,\n \"min\": 1,\n \"max\": 99,\n \"num_unique_values\": 94,\n \"samples\": [\n 6,\n 22\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"NativeCountry\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 42,\n \"samples\": [\n 8,\n 30\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# split into training and test sample\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25)" + ], + "metadata": { + "id": "OyfWTeWkulYA" + }, + "execution_count": 14, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### Feature Flags\n", + "\n", + "One of the unique capabilities of Cyclic Boosting is the option to set special flags for each individual feature.\n", + "In particular, we can indicate that a given variable is a continuous variable ```IS_CONTINUOUS```, or, if categorial, that the values are ordered (i.e. the order has a meaning) via ```IS_ORDERED``` or not (```IS_UNORDERED```).\n", + "The flag ```IS_LINEAR``` is similar to the continous case, but assumes a linear dependency.\n", + "\n", + "We can also indicate that the feature has missing values (```HAS_MISSING```) that should be treated separately. This is particularly convenient as we do not have to treat, say, NAN values as part of the data preprocessing but it can be included in the machine learning part directly. Additionally, using the flag ```\n", + "MISSING_NOT_LEARNED```, all missing values will be put into a separate neutral category that does not contribute then to the final prediction." + ], + "metadata": { + "id": "6r4QofqhzWcw" + } + }, + { + "cell_type": "markdown", + "source": [ + "***Exercise***:\n", + "\n", + "Set appropriate feature flags for the variables" + ], + "metadata": { + "id": "QcZYUZa_1m0D" + } + }, + { + "cell_type": "code", + "source": [ + "# add feature flags\n", + "\n", + "fp = {}\n", + "\n", + "fp['WorkClass'] = flags.IS_UNORDERED | flags.HAS_MISSING | flags.MISSING_NOT_LEARNED\n", + "fp['MaritalStatus'] = flags.IS_UNORDERED\n", + "fp['Occupation'] = flags.IS_UNORDERED | flags.HAS_MISSING | flags.MISSING_NOT_LEARNED\n", + "fp['Relationship'] = flags.IS_UNORDERED\n", + "fp['Race'] = flags.IS_UNORDERED\n", + "fp['Gender'] = flags.IS_UNORDERED\n", + "fp['NativeCountry'] = flags.IS_UNORDERED | flags.HAS_MISSING | flags.MISSING_NOT_LEARNED\n", + "\n", + "fp['Education'] = flags.IS_ORDERED\n", + "\n", + "fp['Age'] = flags.IS_CONTINUOUS\n", + "fp['fnlwgt'] = flags.IS_CONTINUOUS\n", + "fp['EducationNum'] = flags.IS_CONTINUOUS\n", + "fp['CapitalGain'] = flags.IS_CONTINUOUS\n", + "fp['CapitalLoss'] = flags.IS_CONTINUOUS\n", + "fp['HoursPerWeek'] = flags.IS_CONTINUOUS\n", + "# fp[''] = flags.IS_UNORDERED" + ], + "metadata": { + "id": "uGEmRCw-v2Cy" + }, + "execution_count": 15, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "# Cyclic Boosting Model\n", + "\n", + "Here, we use the classifier ```CBClassifier``` that takes the above dictionary of feature flags as argument.\n", + "\n", + "Cyclic Boosting follows the convention from scikit-learn for training and inference." + ], + "metadata": { + "id": "8FMlfLHU1wtV" + } + }, + { + "cell_type": "code", + "source": [ + "CB_est = CBClassifier(feature_properties=fp)\n", + "CB_est.fit(X_train, y_train)\n", + "\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 257 + }, + "id": "7Ruo3EXQusLm", + "outputId": "20919447-97da-4236-bc5f-5d901789c300" + }, + "execution_count": 16, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "CBClassifier(feature_groups=['Age', 'WorkClass', 'fnlwgt', 'Education',\n", + " 'EducationNum', 'MaritalStatus', 'Occupation',\n", + " 'Relationship', 'Race', 'Gender', 'CapitalGain',\n", + " 'CapitalLoss', 'HoursPerWeek', 'NativeCountry'],\n", + " feature_properties={'Age': 1, 'CapitalGain': 1, 'CapitalLoss': 1,\n", + " 'Education': 2, 'EducationNum': 1, 'Gender': 4,\n", + " 'HoursPerWeek': 1, 'MaritalStatus': 4,\n", + " 'NativeCountry': 52, 'Occupation': 52,\n", + " 'Race': 4, 'Relationship': 4, 'WorkClass': 52,\n", + " 'fnlwgt': 1},\n", + " learn_rate=<function half_linear_learn_rate at 0x7c6e8cdc5a80>,\n", + " observers=[],\n", + " smoother_choice=<cyclic_boosting.common_smoothers.SmootherChoiceWeightedMean object at 0x7c6e89490390>)" + ], + "text/html": [ + "<style>#sk-container-id-1 {\n", + " /* Definition of color scheme common for light and dark mode */\n", + " --sklearn-color-text: #000;\n", + " --sklearn-color-text-muted: #666;\n", + " --sklearn-color-line: gray;\n", + " /* Definition of color scheme for unfitted estimators */\n", + " --sklearn-color-unfitted-level-0: #fff5e6;\n", + " --sklearn-color-unfitted-level-1: #f6e4d2;\n", + " --sklearn-color-unfitted-level-2: #ffe0b3;\n", + " --sklearn-color-unfitted-level-3: chocolate;\n", + " /* Definition of color scheme for fitted estimators */\n", + " --sklearn-color-fitted-level-0: #f0f8ff;\n", + " --sklearn-color-fitted-level-1: #d4ebff;\n", + " --sklearn-color-fitted-level-2: #b3dbfd;\n", + " --sklearn-color-fitted-level-3: cornflowerblue;\n", + "\n", + " /* Specific color for light theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, white)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, black)));\n", + " --sklearn-color-icon: #696969;\n", + "\n", + " @media (prefers-color-scheme: dark) {\n", + " /* Redefinition of color scheme for dark theme */\n", + " --sklearn-color-text-on-default-background: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-background: var(--sg-background-color, var(--theme-background, var(--jp-layout-color0, #111)));\n", + " --sklearn-color-border-box: var(--sg-text-color, var(--theme-code-foreground, var(--jp-content-font-color1, white)));\n", + " --sklearn-color-icon: #878787;\n", + " }\n", + "}\n", + "\n", + "#sk-container-id-1 {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "#sk-container-id-1 pre {\n", + " padding: 0;\n", + "}\n", + "\n", + "#sk-container-id-1 input.sk-hidden--visually {\n", + " border: 0;\n", + " clip: rect(1px 1px 1px 1px);\n", + " clip: rect(1px, 1px, 1px, 1px);\n", + " height: 1px;\n", + " margin: -1px;\n", + " overflow: hidden;\n", + " padding: 0;\n", + " position: absolute;\n", + " width: 1px;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-dashed-wrapped {\n", + " border: 1px dashed var(--sklearn-color-line);\n", + " margin: 0 0.4em 0.5em 0.4em;\n", + " box-sizing: border-box;\n", + " padding-bottom: 0.4em;\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-container {\n", + " /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n", + " but bootstrap.min.css set `[hidden] { display: none !important; }`\n", + " so we also need the `!important` here to be able to override the\n", + " default hidden behavior on the sphinx rendered scikit-learn.org.\n", + " See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n", + " display: inline-block !important;\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-text-repr-fallback {\n", + " display: none;\n", + "}\n", + "\n", + "div.sk-parallel-item,\n", + "div.sk-serial,\n", + "div.sk-item {\n", + " /* draw centered vertical line to link estimators */\n", + " background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n", + " background-size: 2px 100%;\n", + " background-repeat: no-repeat;\n", + " background-position: center center;\n", + "}\n", + "\n", + "/* Parallel-specific style estimator block */\n", + "\n", + "#sk-container-id-1 div.sk-parallel-item::after {\n", + " content: \"\";\n", + " width: 100%;\n", + " border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n", + " flex-grow: 1;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-parallel {\n", + " display: flex;\n", + " align-items: stretch;\n", + " justify-content: center;\n", + " background-color: var(--sklearn-color-background);\n", + " position: relative;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-parallel-item {\n", + " display: flex;\n", + " flex-direction: column;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n", + " align-self: flex-end;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n", + " align-self: flex-start;\n", + " width: 50%;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n", + " width: 0;\n", + "}\n", + "\n", + "/* Serial-specific style estimator block */\n", + "\n", + "#sk-container-id-1 div.sk-serial {\n", + " display: flex;\n", + " flex-direction: column;\n", + " align-items: center;\n", + " background-color: var(--sklearn-color-background);\n", + " padding-right: 1em;\n", + " padding-left: 1em;\n", + "}\n", + "\n", + "\n", + "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n", + "clickable and can be expanded/collapsed.\n", + "- Pipeline and ColumnTransformer use this feature and define the default style\n", + "- Estimators will overwrite some part of the style using the `sk-estimator` class\n", + "*/\n", + "\n", + "/* Pipeline and ColumnTransformer style (default) */\n", + "\n", + "#sk-container-id-1 div.sk-toggleable {\n", + " /* Default theme specific background. It is overwritten whether we have a\n", + " specific estimator or a Pipeline/ColumnTransformer */\n", + " background-color: var(--sklearn-color-background);\n", + "}\n", + "\n", + "/* Toggleable label */\n", + "#sk-container-id-1 label.sk-toggleable__label {\n", + " cursor: pointer;\n", + " display: flex;\n", + " width: 100%;\n", + " margin-bottom: 0;\n", + " padding: 0.5em;\n", + " box-sizing: border-box;\n", + " text-align: center;\n", + " align-items: start;\n", + " justify-content: space-between;\n", + " gap: 0.5em;\n", + "}\n", + "\n", + "#sk-container-id-1 label.sk-toggleable__label .caption {\n", + " font-size: 0.6rem;\n", + " font-weight: lighter;\n", + " color: var(--sklearn-color-text-muted);\n", + "}\n", + "\n", + "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n", + " /* Arrow on the left of the label */\n", + " content: \"▸\";\n", + " float: left;\n", + " margin-right: 0.25em;\n", + " color: var(--sklearn-color-icon);\n", + "}\n", + "\n", + "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n", + " color: var(--sklearn-color-text);\n", + "}\n", + "\n", + "/* Toggleable content - dropdown */\n", + "\n", + "#sk-container-id-1 div.sk-toggleable__content {\n", + " max-height: 0;\n", + " max-width: 0;\n", + " overflow: hidden;\n", + " text-align: left;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-toggleable__content.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-toggleable__content pre {\n", + " margin: 0.2em;\n", + " border-radius: 0.25em;\n", + " color: var(--sklearn-color-text);\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n", + " /* Expand drop-down */\n", + " max-height: 200px;\n", + " max-width: 100%;\n", + " overflow: auto;\n", + "}\n", + "\n", + "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n", + " content: \"▾\";\n", + "}\n", + "\n", + "/* Pipeline/ColumnTransformer-specific style */\n", + "\n", + "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator-specific style */\n", + "\n", + "/* Colorize estimator box */\n", + "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n", + "#sk-container-id-1 div.sk-label label {\n", + " /* The background is the default theme color */\n", + " color: var(--sklearn-color-text-on-default-background);\n", + "}\n", + "\n", + "/* On hover, darken the color of the background */\n", + "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "/* Label box, darken color on hover, fitted */\n", + "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n", + " color: var(--sklearn-color-text);\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Estimator label */\n", + "\n", + "#sk-container-id-1 div.sk-label label {\n", + " font-family: monospace;\n", + " font-weight: bold;\n", + " display: inline-block;\n", + " line-height: 1.2em;\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-label-container {\n", + " text-align: center;\n", + "}\n", + "\n", + "/* Estimator-specific */\n", + "#sk-container-id-1 div.sk-estimator {\n", + " font-family: monospace;\n", + " border: 1px dotted var(--sklearn-color-border-box);\n", + " border-radius: 0.25em;\n", + " box-sizing: border-box;\n", + " margin-bottom: 0.5em;\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-0);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-estimator.fitted {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-0);\n", + "}\n", + "\n", + "/* on hover */\n", + "#sk-container-id-1 div.sk-estimator:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-2);\n", + "}\n", + "\n", + "#sk-container-id-1 div.sk-estimator.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-2);\n", + "}\n", + "\n", + "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n", + "\n", + "/* Common style for \"i\" and \"?\" */\n", + "\n", + ".sk-estimator-doc-link,\n", + "a:link.sk-estimator-doc-link,\n", + "a:visited.sk-estimator-doc-link {\n", + " float: right;\n", + " font-size: smaller;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1em;\n", + " height: 1em;\n", + " width: 1em;\n", + " text-decoration: none !important;\n", + " margin-left: 0.5em;\n", + " text-align: center;\n", + " /* unfitted */\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted,\n", + "a:link.sk-estimator-doc-link.fitted,\n", + "a:visited.sk-estimator-doc-link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n", + ".sk-estimator-doc-link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover,\n", + "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n", + ".sk-estimator-doc-link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "/* Span, style for the box shown on hovering the info icon */\n", + ".sk-estimator-doc-link span {\n", + " display: none;\n", + " z-index: 9999;\n", + " position: relative;\n", + " font-weight: normal;\n", + " right: .2ex;\n", + " padding: .5ex;\n", + " margin: .5ex;\n", + " width: min-content;\n", + " min-width: 20ex;\n", + " max-width: 50ex;\n", + " color: var(--sklearn-color-text);\n", + " box-shadow: 2pt 2pt 4pt #999;\n", + " /* unfitted */\n", + " background: var(--sklearn-color-unfitted-level-0);\n", + " border: .5pt solid var(--sklearn-color-unfitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link.fitted span {\n", + " /* fitted */\n", + " background: var(--sklearn-color-fitted-level-0);\n", + " border: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "\n", + ".sk-estimator-doc-link:hover span {\n", + " display: block;\n", + "}\n", + "\n", + "/* \"?\"-specific style due to the `<a>` HTML tag */\n", + "\n", + "#sk-container-id-1 a.estimator_doc_link {\n", + " float: right;\n", + " font-size: 1rem;\n", + " line-height: 1em;\n", + " font-family: monospace;\n", + " background-color: var(--sklearn-color-background);\n", + " border-radius: 1rem;\n", + " height: 1rem;\n", + " width: 1rem;\n", + " text-decoration: none;\n", + " /* unfitted */\n", + " color: var(--sklearn-color-unfitted-level-1);\n", + " border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n", + "}\n", + "\n", + "#sk-container-id-1 a.estimator_doc_link.fitted {\n", + " /* fitted */\n", + " border: var(--sklearn-color-fitted-level-1) 1pt solid;\n", + " color: var(--sklearn-color-fitted-level-1);\n", + "}\n", + "\n", + "/* On hover */\n", + "#sk-container-id-1 a.estimator_doc_link:hover {\n", + " /* unfitted */\n", + " background-color: var(--sklearn-color-unfitted-level-3);\n", + " color: var(--sklearn-color-background);\n", + " text-decoration: none;\n", + "}\n", + "\n", + "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n", + " /* fitted */\n", + " background-color: var(--sklearn-color-fitted-level-3);\n", + "}\n", + "</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>CBClassifier(feature_groups=['Age', 'WorkClass', 'fnlwgt', 'Education',\n", + " 'EducationNum', 'MaritalStatus', 'Occupation',\n", + " 'Relationship', 'Race', 'Gender', 'CapitalGain',\n", + " 'CapitalLoss', 'HoursPerWeek', 'NativeCountry'],\n", + " feature_properties={'Age': 1, 'CapitalGain': 1, 'CapitalLoss': 1,\n", + " 'Education': 2, 'EducationNum': 1, 'Gender': 4,\n", + " 'HoursPerWeek': 1, 'MaritalStatus': 4,\n", + " 'NativeCountry': 52, 'Occupation': 52,\n", + " 'Race': 4, 'Relationship': 4, 'WorkClass': 52,\n", + " 'fnlwgt': 1},\n", + " learn_rate=<function half_linear_learn_rate at 0x7c6e8cdc5a80>,\n", + " observers=[],\n", + " smoother_choice=<cyclic_boosting.common_smoothers.SmootherChoiceWeightedMean object at 0x7c6e89490390>)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator fitted sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label fitted sk-toggleable__label-arrow\"><div><div>CBClassifier</div></div><div><span class=\"sk-estimator-doc-link fitted\">i<span>Fitted</span></span></div></label><div class=\"sk-toggleable__content fitted\"><pre>CBClassifier(feature_groups=['Age', 'WorkClass', 'fnlwgt', 'Education',\n", + " 'EducationNum', 'MaritalStatus', 'Occupation',\n", + " 'Relationship', 'Race', 'Gender', 'CapitalGain',\n", + " 'CapitalLoss', 'HoursPerWeek', 'NativeCountry'],\n", + " feature_properties={'Age': 1, 'CapitalGain': 1, 'CapitalLoss': 1,\n", + " 'Education': 2, 'EducationNum': 1, 'Gender': 4,\n", + " 'HoursPerWeek': 1, 'MaritalStatus': 4,\n", + " 'NativeCountry': 52, 'Occupation': 52,\n", + " 'Race': 4, 'Relationship': 4, 'WorkClass': 52,\n", + " 'fnlwgt': 1},\n", + " learn_rate=<function half_linear_learn_rate at 0x7c6e8cdc5a80>,\n", + " observers=[],\n", + " smoother_choice=<cyclic_boosting.common_smoothers.SmootherChoiceWeightedMean object at 0x7c6e89490390>)</pre></div> </div></div></div></div>" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Get Predictions" + ], + "metadata": { + "id": "-zB29CsH2K23" + } + }, + { + "cell_type": "code", + "source": [ + "y_hat = CB_est.predict(X_test)\n", + "y_hat_proba = CB_est.predict_proba(X_test)" + ], + "metadata": { + "id": "694wnChAvKPt" + }, + "execution_count": 17, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "We now use the model on the test data to derive predictions. We take a (deep) copy of the test data to be able to manipulate the dataframe and not touch the original test data.\n", + "\n", + "We access the predictions with\n", + "- ```model.predict(X_test)``` for a binary (0/1) output\n", + "- ```model.predict_proba(X_test)``` for the probability for each class.\n", + "\n", + "```predict_proba``` returns an array for each prediction. Since we only have two classes in this example, the first value for each prediction is for the first class (```y=0```), the second for the other class (```y=1```).\n", + "In case we had more classes, there would be more numbers and we could, for example, assign the class with the highes probability and/or require that each assignment also exceeds a certain threshold.\n", + "\n", + "For convenience, we append the predictions (and the true labels) to the copy of the test data. This allows us to look at a few values and also collects all information in a single dataframe" + ], + "metadata": { + "id": "AYGWVrvR2N4K" + } + }, + { + "cell_type": "code", + "source": [ + "predictions = X_test.copy()\n", + "predictions.loc[:,'y_hat'] = y_hat\n", + "predictions.loc[:,'y_hat_proba_class1'] = y_hat_proba[:,1]\n", + "predictions.loc[:,'y'] = y_test\n", + "\n", + "predictions.head(15)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 539 + }, + "id": "63XmRUKxD5SC", + "outputId": "35a4ff2b-d2f9-4499-f892-7486e6c381aa" + }, + "execution_count": 18, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " Age WorkClass fnlwgt Education EducationNum MaritalStatus \\\n", + "688 41 4 195124 12 14 4 \n", + "20970 20 4 147884 11 9 4 \n", + "31476 45 4 358701 2 8 4 \n", + "30348 29 4 250967 8 11 2 \n", + "25768 19 4 236879 15 10 4 \n", + "7200 35 4 194690 5 4 0 \n", + "24934 18 4 189487 15 10 4 \n", + "10960 36 4 175232 11 9 2 \n", + "17830 37 4 123833 15 10 4 \n", + "27631 18 4 423024 2 8 4 \n", + "29248 58 4 172333 11 9 2 \n", + "10969 29 4 179008 11 9 2 \n", + "29220 27 4 367390 15 10 4 \n", + "11308 55 2 84564 14 15 0 \n", + "7583 28 4 175262 15 10 2 \n", + "\n", + " Occupation Relationship Race Gender CapitalGain CapitalLoss \\\n", + "688 4 1 4 1 0 0 \n", + "20970 1 3 4 0 0 0 \n", + "31476 8 3 4 1 0 0 \n", + "30348 7 0 4 1 0 1887 \n", + "25768 4 3 4 0 0 0 \n", + "7200 13 4 4 0 0 0 \n", + "24934 12 3 4 0 0 0 \n", + "10960 3 0 4 1 5178 0 \n", + "17830 12 1 4 1 0 0 \n", + "27631 6 3 4 1 0 0 \n", + "29248 12 0 4 1 7688 0 \n", + "10969 5 0 4 1 0 0 \n", + "29220 3 4 4 1 0 0 \n", + "11308 10 1 4 0 0 0 \n", + "7583 6 0 2 1 0 0 \n", + "\n", + " HoursPerWeek NativeCountry y_hat y_hat_proba_class1 y \n", + "688 35 6 0.0 0.315835 0 \n", + "20970 40 39 0.0 0.002457 0 \n", + "31476 10 26 0.0 0.001243 0 \n", + "30348 48 39 0.0 0.290607 1 \n", + "25768 35 39 0.0 0.005107 0 \n", + "7200 40 39 0.0 0.011591 0 \n", + "24934 35 39 0.0 0.002998 0 \n", + "10960 40 39 0.0 0.308363 1 \n", + "17830 60 39 0.0 0.177292 0 \n", + "27631 20 39 0.0 0.000540 0 \n", + "29248 40 39 0.0 0.476333 1 \n", + "10969 55 39 0.0 0.151834 0 \n", + "29220 50 39 0.0 0.034496 0 \n", + "11308 39 39 0.0 0.430919 0 \n", + "7583 40 26 0.0 0.063604 0 " + ], + "text/html": [ + "\n", + " <div id=\"df-a0a53805-7a63-49d9-a03f-b7662a39e8cc\" 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>Age</th>\n", + " <th>WorkClass</th>\n", + " <th>fnlwgt</th>\n", + " <th>Education</th>\n", + " <th>EducationNum</th>\n", + " <th>MaritalStatus</th>\n", + " <th>Occupation</th>\n", + " <th>Relationship</th>\n", + " <th>Race</th>\n", + " <th>Gender</th>\n", + " <th>CapitalGain</th>\n", + " <th>CapitalLoss</th>\n", + " <th>HoursPerWeek</th>\n", + " <th>NativeCountry</th>\n", + " <th>y_hat</th>\n", + " <th>y_hat_proba_class1</th>\n", + " <th>y</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>688</th>\n", + " <td>41</td>\n", + " <td>4</td>\n", + " <td>195124</td>\n", + " <td>12</td>\n", + " <td>14</td>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>35</td>\n", + " <td>6</td>\n", + " <td>0.0</td>\n", + " <td>0.315835</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>20970</th>\n", + " <td>20</td>\n", + " <td>4</td>\n", + " <td>147884</td>\n", + " <td>11</td>\n", + " <td>9</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.002457</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>31476</th>\n", + " <td>45</td>\n", + " <td>4</td>\n", + " <td>358701</td>\n", + " <td>2</td>\n", + " <td>8</td>\n", + " <td>4</td>\n", + " <td>8</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>10</td>\n", + " <td>26</td>\n", + " <td>0.0</td>\n", + " <td>0.001243</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>30348</th>\n", + " <td>29</td>\n", + " <td>4</td>\n", + " <td>250967</td>\n", + " <td>8</td>\n", + " <td>11</td>\n", + " <td>2</td>\n", + " <td>7</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>1887</td>\n", + " <td>48</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.290607</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>25768</th>\n", + " <td>19</td>\n", + " <td>4</td>\n", + " <td>236879</td>\n", + " <td>15</td>\n", + " <td>10</td>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>35</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.005107</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7200</th>\n", + " <td>35</td>\n", + " <td>4</td>\n", + " <td>194690</td>\n", + " <td>5</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>13</td>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.011591</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>24934</th>\n", + " <td>18</td>\n", + " <td>4</td>\n", + " <td>189487</td>\n", + " <td>15</td>\n", + " <td>10</td>\n", + " <td>4</td>\n", + " <td>12</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>35</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.002998</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>10960</th>\n", + " <td>36</td>\n", + " <td>4</td>\n", + " <td>175232</td>\n", + " <td>11</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>3</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>5178</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.308363</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>17830</th>\n", + " <td>37</td>\n", + " <td>4</td>\n", + " <td>123833</td>\n", + " <td>15</td>\n", + " <td>10</td>\n", + " <td>4</td>\n", + " <td>12</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>60</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.177292</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>27631</th>\n", + " <td>18</td>\n", + " <td>4</td>\n", + " <td>423024</td>\n", + " <td>2</td>\n", + " <td>8</td>\n", + " <td>4</td>\n", + " <td>6</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>20</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.000540</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>29248</th>\n", + " <td>58</td>\n", + " <td>4</td>\n", + " <td>172333</td>\n", + " <td>11</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>12</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>7688</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.476333</td>\n", + " <td>1</td>\n", + " </tr>\n", + " <tr>\n", + " <th>10969</th>\n", + " <td>29</td>\n", + " <td>4</td>\n", + " <td>179008</td>\n", + " <td>11</td>\n", + " <td>9</td>\n", + " <td>2</td>\n", + " <td>5</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>55</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.151834</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>29220</th>\n", + " <td>27</td>\n", + " <td>4</td>\n", + " <td>367390</td>\n", + " <td>15</td>\n", + " <td>10</td>\n", + " <td>4</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>4</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>50</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.034496</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>11308</th>\n", + " <td>55</td>\n", + " <td>2</td>\n", + " <td>84564</td>\n", + " <td>14</td>\n", + " <td>15</td>\n", + " <td>0</td>\n", + " <td>10</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>39</td>\n", + " <td>39</td>\n", + " <td>0.0</td>\n", + " <td>0.430919</td>\n", + " <td>0</td>\n", + " </tr>\n", + " <tr>\n", + " <th>7583</th>\n", + " <td>28</td>\n", + " <td>4</td>\n", + " <td>175262</td>\n", + " <td>15</td>\n", + " <td>10</td>\n", + " <td>2</td>\n", + " <td>6</td>\n", + " <td>0</td>\n", + " <td>2</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>0</td>\n", + " <td>40</td>\n", + " <td>26</td>\n", + " <td>0.0</td>\n", + " <td>0.063604</td>\n", + " <td>0</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-a0a53805-7a63-49d9-a03f-b7662a39e8cc')\"\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-a0a53805-7a63-49d9-a03f-b7662a39e8cc 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-a0a53805-7a63-49d9-a03f-b7662a39e8cc');\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-3e4c101e-8db2-4791-80ae-001a73deb93a\">\n", + " <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-3e4c101e-8db2-4791-80ae-001a73deb93a')\"\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-3e4c101e-8db2-4791-80ae-001a73deb93a 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", + "variable_name": "predictions", + "summary": "{\n \"name\": \"predictions\",\n \"rows\": 8141,\n \"fields\": [\n {\n \"column\": \"Age\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 13,\n \"min\": 17,\n \"max\": 90,\n \"num_unique_values\": 70,\n \"samples\": [\n 56,\n 41,\n 52\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"WorkClass\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 9,\n \"samples\": [\n 3,\n 2,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"fnlwgt\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 108699,\n \"min\": 13769,\n \"max\": 1455435,\n \"num_unique_values\": 7128,\n \"samples\": [\n 150324,\n 163530,\n 98881\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Education\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 16,\n \"samples\": [\n 12,\n 11,\n 5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"EducationNum\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 2,\n \"min\": 1,\n \"max\": 16,\n \"num_unique_values\": 16,\n \"samples\": [\n 14,\n 9,\n 4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"MaritalStatus\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 7,\n \"samples\": [\n 4,\n 2,\n 5\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Occupation\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 15,\n \"samples\": [\n 10,\n 0,\n 4\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Relationship\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 6,\n \"samples\": [\n 1,\n 3,\n 2\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Race\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 5,\n \"samples\": [\n 2,\n 1,\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"Gender\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 2,\n \"samples\": [\n 0,\n 1\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalGain\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 8172,\n \"min\": 0,\n \"max\": 99999,\n \"num_unique_values\": 94,\n \"samples\": [\n 4787,\n 2597\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"CapitalLoss\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 394,\n \"min\": 0,\n \"max\": 3900,\n \"num_unique_values\": 67,\n \"samples\": [\n 1258,\n 1719\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"HoursPerWeek\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 12,\n \"min\": 2,\n \"max\": 99,\n \"num_unique_values\": 84,\n \"samples\": [\n 51,\n 35\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"NativeCountry\",\n \"properties\": {\n \"dtype\": \"int8\",\n \"num_unique_values\": 42,\n \"samples\": [\n 13,\n 30\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y_hat\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.4004661242764046,\n \"min\": 0.0,\n \"max\": 1.0,\n \"num_unique_values\": 2,\n \"samples\": [\n 1.0,\n 0.0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y_hat_proba_class1\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0.27098375479263437,\n \"min\": 5.198691751343466e-05,\n \"max\": 0.958661937450008,\n \"num_unique_values\": 8139,\n \"samples\": [\n 0.645385689019674,\n 0.17391834652291707\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n },\n {\n \"column\": \"y\",\n \"properties\": {\n \"dtype\": \"number\",\n \"std\": 0,\n \"min\": 0,\n \"max\": 1,\n \"num_unique_values\": 2,\n \"samples\": [\n 1,\n 0\n ],\n \"semantic_type\": \"\",\n \"description\": \"\"\n }\n }\n ]\n}" + } + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Evaluation\n", + "\n", + "Now we evaluate how well our classifier works.\n", + "\n", + "A good way to visualise this is the confusion matrix for the binary labels and predictions.\n", + "This allows us to see if the predictions are generally quite good (most entries on the diagonal line) and how many off-diagonal elements we have that indicate wrong class assignments.\n", + "\n", + "Here, we normalise the values displayed in the confusion matrix to the number of all entries to get the relative proportions" + ], + "metadata": { + "id": "jAKBxo9-2TKs" + } + }, + { + "cell_type": "code", + "source": [ + "\n", + "cm = metrics.confusion_matrix(y_test, y_hat,normalize='all')\n", + "disp = metrics.ConfusionMatrixDisplay(confusion_matrix=cm,\n", + " display_labels=['<50k', '>50k'])\n", + "disp.plot()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 451 + }, + "id": "pk1HdL1vvcLF", + "outputId": "a2019250-f0da-4a3f-a0a4-b94b654c3fcd" + }, + "execution_count": 19, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 2 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Scikit-Learn also provides a summary report with the most important metrics:" + ], + "metadata": { + "id": "M2_kalrz4d9r" + } + }, + { + "cell_type": "code", + "source": [ + "print(metrics.classification_report(y_test, y_hat, target_names=['<50k', '>50k']))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SS804f7oGTs-", + "outputId": "c33463e4-628c-46bb-c711-5b20307654ed" + }, + "execution_count": 20, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " precision recall f1-score support\n", + "\n", + " <50k 0.88 0.93 0.91 6187\n", + " >50k 0.73 0.61 0.67 1954\n", + "\n", + " accuracy 0.85 8141\n", + " macro avg 0.81 0.77 0.79 8141\n", + "weighted avg 0.85 0.85 0.85 8141\n", + "\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "A key plot to understand the performance is the ROC curve.\n", + "Here, we need probabilities and the curve is constructed by setting subsequent thresholds on the predictied probabilies.\n", + "A model that is only as good as random guessing would lie on the diagonal, the ideal point is (0,1) where all predictions are perfect" + ], + "metadata": { + "id": "1mmLyB6J4h_9" + } + }, + { + "cell_type": "code", + "source": [ + "fpr, tpr, thresholds = metrics.roc_curve(y_test, y_hat_proba[:,1])\n", + "roc_auc = metrics.auc(fpr, tpr)\n", + "display = metrics.RocCurveDisplay(fpr=fpr, tpr=tpr, roc_auc=roc_auc,\n", + " estimator_name='Cyclic Boosting')\n", + "\n", + "display.plot()\n", + "# diagonal line\n", + "plt.plot([0, 1], [0, 1], \"k--\", label=\"random guess (AUC = 0.5)\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 451 + }, + "id": "RLycM16AGYmG", + "outputId": "2a45e88b-9366-425b-eb87-34d7c25b1124" + }, + "execution_count": 21, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcAAAAGyCAYAAABzzxS5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAbhlJREFUeJzt3XdcE/f/B/BXCCSEDbIVGQ7c4qiK1loVxb3aaqvWrXVbrXVW0TqwWq271on2q3VUbf05qzjqam1BXAyVUaICiigbAsnn9wdyEghIgHAZ7+fjkYd3l7vknRPy4u4+9/kIGGMMhBBCiIEx4rsAQgghhA8UgIQQQgwSBSAhhBCDRAFICCHEIFEAEkIIMUgUgIQQQgwSBSAhhBCDRAFICCHEIFEAEkIIMUjGfBdQ3RQKBZ49ewZLS0sIBAK+yyGEEKImxhjS09Ph6uoKI6NKHMcxHl25coX16dOHubi4MADs+PHj79zm0qVLrEWLFkwkErE6deqwPXv2qPWeUqmUAaAHPehBD3ro+EMqlVYsfN7g9QgwMzMTzZs3x5gxYzBo0KB3rh8bG4vevXtj4sSJ2L9/P4KDgzFu3Di4uLjA39+/XO9paWkJAJBKpbCysqpU/YQQQqpfWloa3NzcuO/zihIwph2dYQsEAhw/fhwDBgwodZ25c+fi1KlTuH//Prfs008/xevXr3H27NlyvU9aWhqsra2RmppKAUgI0Wk5eXK8ypLxXUaZcvIUeJSUDqFR5S85NatlAwdLcZV9j+vUNcCbN2/Cz89PaZm/vz++/PLLUrfJzc1Fbm4uN5+Wlqap8gghBi7+ZRYycvO5ebmCITT+FW7Hv0INCzG3/My9BHjYmwMAbkS/hKXYGEKhegGRmZuPPLlWHL9oVH7aCySf+gE1ek7Hvhl90LWhU5W9tk4FYGJiIpyclD+8k5MT0tLSkJ2dDYlEUmKbwMBALF26tLpKJIToGIWCIS0nj5vPkzM8Skrn5jNy8xGZmA4zkRAAEPcyEy/Sc2EhNuHWORr6RO33fZaaw02nFwnNihAJtbtBv0yugK2ZCWrbmam1XfarJFzftRC5yc8gu7gVVvMGVmldOhWAFTF//nzMmjWLmy88d0wI0X+vMmW4+jgZof+9goW44Otu86XHcLAUw9hIAMaAxLScd7yK+hwt3x7tZcnkyMjNh69XDfjUtgEAMAbk5svRorYtAEAoEMDb2aIC7ySARw0zGGt5AFaEVCrFhx+ORFbyM3h5eeFy8G9wc7Or0vfQqQB0dnZGUlKS0rKkpCRYWVmpPPoDALFYDLFYrPI5Qgh/cvLkAIDY5ExuuixpOfmIfp4BsYkRwp+lIV/OYGIsQMLrHARHPgcASEyESttkl/K6L9JzVS4vykQogOeb05SvsvJgZyZCQ5eCRhfJGTI0crVCDXMRgIImiQrG8EkrNzhY0vdNVbhy5QpiYmIKwu/yZY0cuOhUAPr6+uL06dNKy86fPw9fX1+eKiLEMGXL5EjNzkNGbj7ikjNVNnAITyh5vT3kv1d4kZ6Le09TNVNXKYFXy1YCxoBujQouobzMlGFCRy/u+do1zLgjRAAQADCqgkYbpOKGDx8OAOjUqZPGztrxGoAZGRl4/PgxNx8bG4uwsDDY2dmhdu3amD9/Pp4+fYp9+/YBACZOnIjNmzdjzpw5GDNmDC5evIjDhw/j1KlTfH0EQvTKrdgUPHmVBaDgyOx2/GukZMoQnpAGUxMjmImMkZKpmVaHbnaqz+IUlZiaA097c3jUMIf0VTY+9HaA2NgI2TI5XG0k6FC3BsTGykeBjlbiEsuIdpJKpZBIJLC3twfwNgQ1hdcA/Pfff9G5c2duvvBa3ciRIxEUFISEhATEx8dzz3t6euLUqVOYOXMmNmzYgFq1amHnzp3lvgeQEKIsIzcfWbn5mHIgFP/EvSpz3Zw8BXLylMPP2EiAfAVDbTsz2JiZlNjmYVI6+jV3hQBvj6aepWajfR17tPOyQz0nSxgbCWBqQgFl6Aqu+X0Ic3NzXLx4kQtBTdKa+wCrC90HSAyVXMFw5n4Cph64DbGxEXLzFaWu27FewZfP01fZaOhqhdbutrAxM0EjF2sYCQru2/WyN6fThKRKFIZfea/5GeR9gIQQZXIFw/P0HCSlvW3UkSdX4I70NW7FpsDJyhRXH71A3Msspe1KC79vejfE2Pc9qZ9cUm3UDb+qRAFIiI6JTc5E3MtMLDx2T+leMnVYmhpj++etUctWAmdrUwgFAjqaI9WOz/ADKAAJ0WoKBcPIPbcQ/TzjnWFX0+ZtI5KM3HwoGEPTmtZo7WGHV5ky9PNxRUMXK6XWjoTwhe/wAygACal26Tl5eJiUgb9jX0JsLMSlyOe4/ywV+XKGjNx8pVsK5IrSL9E3cLZEZGI6Dk1oh7ZeNaqjdEKqTF5eHvLy8ngLP4ACkJBqc/9pKvpsuvbO9UoLvSV9G6FJTWu42kjgavPuWwYI0WaFwWdiYsJb71wUgIRomCxfgfrfnFH5nJeDObydLJGbr0ATVyv41LZBPUdLiI3fdm0lNBIodaRMiK6Kj49HeHg4evToAaAgBPlEAUiIBmTk5uO320/xzW/3Szz3Vbf6+KJTHYiM9a//RkJKEx8fj86dO0MqleLEiRNcCPKJApCQSsiXKxD3MhOMAQ+TMnA56jlMTYT4+a//VK4fvbJXlYyLRoguKQy/wgYvjRs35rskABSAhKhFoWBIz81Hrw1XYSE2RlSRYXNK09bTDrP9vdGqti3dakAMTvHw46vBiyoUgIS8Q26+HKvORGLP9bhS1zERCmAuNsbrrDy0rG2DpjWt0cjVCkPeq119hRKiZbQ5/AAKQEJK9d/LTHRac7nMdXaOaI1mtazhaGVaPUURoiOeP3+u1eEHUAASotKac5HYcim6xPLJH9bB2Pc9YS0x0ctBSAmpKvb29ujUqRMAaGX4ARSAhCh5+jobHVZdLLE8+KtOqONQkRG7CTFMRkZG2LlzJ5KTk+Ho6Mh3OSpRABKDF/LfK2wIfoSaNhL8cite6bnT0zuikSuNGkJIeUilUmzcuBGBgYEwNjaGkZGR1oYfQAFIDFBCajZ2X4vFjquxpa7TvJY1jk3uQLcsEFJORfv2BIA1a9bwXNG7UQASg8AYw+WoF0jOyMXXv95VuU4jFyv0bOIMn9o26FjPoZorJER3Fe/Yevr06XyXVC4UgERvldUFGVAwmnmvpi6Y3rUe6jiY0xh4hFSANozqUFEUgETvZObmwzcwGGk5+Sqf71TfASJjI+wY0bqaKyNEv+hy+AEUgERPKBQM1x4nY8TuWyqfPzqpPeo6WsBaYlLNlRGin+RyOXr27Kmz4QdQABI9cPZ+Iib+L0Tlczfnd4GLNQ0dREhVEwqFWLduHWbNmoUzZ87oXPgBFIBEB+XLFWi+9A9kyuQqn3ewFOPMjI6wpyGECKlyjDHuenn37t1x584dCIVCnquqGOrKguiUbJkcdReeURl+X/t7I25Vb/yz0I/CjxANkEql6NSpEx4+fMgt09XwA+gIkOiIM/cSsOXyY9x/mqa0/Pjk9rC3EMPNzoynyggxDEUbvIwbNw5XrlzR+ZbTFIBE63nMO1ViWfs6NXBgfDseqiHE8BRv7bl//36dDz+AApBoKcYY/u9uAqb/cltp+fB2tTHC1wP1nSx5qowQw6LrtzqUhQKQaA3GGP4IT8K6Px6qHGj28YqeNAIDIdVIn8MPoAAkPMvNl2Pe0XsQGgnwa8gTlet8UN8BQaPeo9HUCalmX331ld6GH0ABSHgU8yIDXdZeUflc05rW+GGID+o60hBEhPDlp59+AgCsXbtW78IPoAAkPEnNzisRfnN7NICTlRgDW9TUiwvshOiizMxMmJubAwBsbW1x+PBhnivSHApAUq3uSF+j/5brSsusJSb4Z6EfRMZ0fY8QPsXHx6Nz586YPn06ZsyYwXc5GkffOKTaMMZKhJ+JUIA7Ad0p/AjhWWH4xcTEYNOmTcjMzOS7JI2jI0BSLcKfpaHXxqvcfEMXK+wb0wYOltRjCyF8Kxp+Xl5euHTpEncaVJ9RABKNS83KUwo/ADgzoyNP1RBCiioefvrY2rM0dN6JaIxCwfDb7ado/u0f3LLP27kjblVvHqsihBQy5PAD6AiQaEjgmQj8dCWmxPJlA5rwUA0hRJWTJ08abPgBFIBEA34NeVIi/Np42uGHIT78FEQIUWny5MkAgL59+xpc+AEUgKQKyRUMi3+/j/1/x3PLzszoiIYuVjxWRQgp6smTJ7C2toalZUF/uoUhaIgoAEmVuP80FX02XVNatv3zVhR+hGiRwmt+zs7OOHv2LBeChooCkFSaquGKtg1vie6NnXmohhCiStEGLwCQmppKAch3AUR3vc6SYfaRu0rL5vVsgImd6vBUESFEFVWtPWvVqsV3WbyjACQVouqU5/2l/rAQ048UIdrE0G91KAt9WxG1rTkXiS2XopWWbRveisKPEC1D4Vc2+sYiajka8kQp/Bb1aYSx73vyWBEhpDRpaWlIS0uj8CsFBSBRy1dH7nDTO0a0RrdGTjxWQwgpS5MmTXDp0iVYW1tT+KlAXaGRcnuYlM5Nf/GBF4UfIVpIKpXi2rW31+ebNGlC4VcKCkBSbt1/+JOb/tKvPo+VEEJUkUql+PDDD+Hv768UgkQ1CkBSLq8yZdy0l705JCIhj9UQQoorDL+YmBg4OzvD3d2d75K0HgUgeaejIU/QYtl5bv7Y5PY8VkMIKa5o+FGDl/KjACRlevw8Q6nhi7eTJWzMRDxWRAgpisKv4qgVKClVnlwBv3VXuPmv/b0xpXNdHisihBSVmJhI4VcJFIBEpRvRyRi6429u/oP6DhR+hGgZOzs7NG/eHAAo/CqAApAokSsYJu8PwbkHSdyyBs6W2DemDY9VEUJUEYlEOHjwIFJSUuDsTJ3Pq4uuARIlfTZdUwq/r/29cfbLD3isiBBSlFQqxbfffgvGGICCEKTwqxg6AiSc1Ow8RCSkcfO/jG8H3zo1eKyIEFJU0QYvALB48WKeK9JtFIAEAJCTJ0fzpX9w8wcntEM7Lwo/QrRF8daeo0eP5rsknUenQAlk+Qo0WHSWmxcIQOFHiBahWx00gwKQYM25SKX52MDePFVCCCmOwk9zKAANXJ5cgR1XY7n5uFUUfoRoC5lMBj8/Pwo/DaEANHD1Fp7hpgP6NuKxEkJIcSKRCMuWLUP9+vUp/DSAAtCA3Y5/pTQ/ugMNbEuIthk8eDDu3btH4acBFIAGijGGgVtvcPMR3/bgsRpCSKH4+Hj4+/tDKpVyy0Qi6n9XE3gPwC1btsDDwwOmpqZo27Ytbt26Veb669evh7e3NyQSCdzc3DBz5kzk5ORUU7X6Y8/1OG76sza1aXgjQrRAfHw8OnfujD/++APjxo3juxy9x2sAHjp0CLNmzUJAQABCQ0PRvHlz+Pv74/nz5yrXP3DgAObNm4eAgABERERg165dOHToEBYsWFDNleu+VWfetvxcObAJj5UQQoC34VfY4GXnzp18l6T3eA3AdevWYfz48Rg9ejQaNWqEbdu2wczMDLt371a5/o0bN9ChQwcMHToUHh4e6N69Oz777LN3HjUSZTceJ0MmVwAAOtazh0Ag4LkiQgxb8fCjBi/Vg7cAlMlkCAkJgZ+f39tijIzg5+eHmzdvqtymffv2CAkJ4QIvJiYGp0+fRq9evUp9n9zcXKSlpSk9DN3QnW9HeVj1UTMeKyGEUPjxh7eu0JKTkyGXy+Hk5KS03MnJCZGRkSq3GTp0KJKTk/H++++DMYb8/HxMnDixzFOggYGBWLp0aZXWrsu2XHrMTc/uXh81bSQ8VkMImTRpEoUfT3hvBKOOy5cvY+XKldi6dStCQ0Nx7NgxnDp1CsuWLSt1m/nz5yM1NZV7FG1ZZWgYY1hzLoqbn/BBHR6rIYQAwM6dO9G7d28KPx7wdgRob28PoVCIpKQkpeVJSUmlDu2xaNEifP7551zrqKZNmyIzMxMTJkzAwoULYWRUMs/FYjHEYnHVfwAd9ORVNje9Z/R7EBnr1N8/hOiN3Nxc7nvJxcUFJ0+e5Lkiw8TbN6BIJEKrVq0QHBzMLVMoFAgODoavr6/KbbKyskqEnFBY0Hy/cGwsUrpfbsVz0529HXmshBDDJZVK0bRpU+zbt4/vUgwer4cAs2bNwo4dO7B3715ERERg0qRJyMzM5Ib5GDFiBObPn8+t37dvX/z44484ePAgYmNjcf78eSxatAh9+/blgpColi2TY+vlaL7LIMSgFXZs/ejRIyxfvhy5ubl8l2TQeB0PcMiQIXjx4gUWL16MxMRE+Pj44OzZs1zDmPj4eKUjvm+++QYCgQDffPMNnj59CgcHB/Tt2xcrVqzg6yPojH//S+Gmt3/eisdKCDFMxUd1CA4OpsszPBMwAzt3mJaWBmtra6SmpsLKyorvcqqNx7xT3DSN+EBI9aIhjapWVX2PUysIAxCZSPc+EsIXCj/tRQGo507ceYYe669y89ErS+80gBBS9fbv30/hp6V4vQZING/6L7e56Ymd6kBoRN2eEVKd5s6dCwAYNmwYhZ+WoQDUY703vj3yW9CrAd34Tkg1efbsGezs7GBqagqBQIB58+bxXRJRgU6B6qn7T1Px4Nnba38UfoRUD6lUio4dO2LQoEE0VJuWoyNAPdVn0zVu+vjk9jxWQojhKNrgBQBSUlLg6urKc1WkNHQEqIf23ojjpjvVd0CL2rb8FUOIgVDV2pPCT7tRAOoZxhgCTjzg5veOacNjNYQYBrrVQTdRAOqZz3e9HRy4TzMXHishxDBQ+OkuCkA9c+1xMje96bMWPFZCiGFISEjAixcvKPx0EDWC0SObgh9x0wF9G0EgoHv+CNG0Nm3a4MKFC3BxcaHw0zEUgHpi7404rD3/kJsf8h79IhKiKVKpFC9fvoSPjw+AghAkuodOgeqB5+k5Sg1fNnzqAzMR/W1DiCYUXvPr0qULwsLC+C6HVAIFoB5os+LtoMLff9Ic/X1q8lgNIfqraIMXW1tb1KhRg++SSCVQAOq4GQdvK81/3KoWT5UQot+otaf+ofNkOqzz95cRm5zJzYct7sZjNYToLwo//URHgDpq0W/3lcLv4ledYGMm4rEiQvTT06dPKfz0FB0B6qDHzzPw81//cfOhi7rBzpzCjxBNsLW1hbu7OwBQ+OkZCkAdk5Ipg9+6K9z81TmdKfwI0SAzMzOcPHkSr169Qs2a1MBMn1AA6og8uQItl51Hek6+0nI3OzOeKiJEf8XHx+PYsWOYMWMGBAIBzMzMYGZGv2v6hgJQR9RbeKbEstjAXjxUQoh+i4+PR+fOnbkhjb788kt+CyIaQwGoAx4/T1eavzm/C1ysJTxVQ4j+Khp+Xl5e+Oijj/guiWgQBaAO8Fv3Jzf9eEVPGAup8S4hVa14+FGDF/1H36RaTq5g3LStmQmFHyEaQOFnmOjbVMudD0/ipk9O78hjJYTop+zsbHTp0oXCzwBRAGq5pf/3tpPrmjZ03Y+QqiaRSPD111+jbt26FH4GhgJQizHGkJCaAwDwdrLkuRpC9NcXX3yBu3fvUvgZGApALeY5/zQ3vXJQUx4rIUS/SKVSDBw4EMnJydwyiYTOsBgaagWqpXZejVGab+Vuy1MlhOiXoh1bA8Dx48d5rojwhY4AtdA/cSlYfiqCm3+4vCeP1RCiP4qP6rBx40a+SyI8ogDUQp9su8lN/zisJUTG9N9ESGXRkEakOPpm1TIn7jzjpr/p3RA9m7rwWA0h+oHCj6hCAahl1p9/yE2P6+jFYyWE6I+RI0dS+JESKAC1TMybQW6p0QshVWfnzp3o3LkzhR9RQq1AtUhEQho3/d1HdNsDIZWRn58PY+OCrzgvLy9cvHiR54qItqEjQC3Sc8NVbrquI934TkhFSaVSNG3aFCdOnOC7FKLFKAC1xOqzkXyXQIheKGzwEhkZiblz5yI/P//dGxGDRAGoBVKz8rD1cjQ3f3dJdx6rIUR3FW/t+ccff3CnQQkpjgJQCzT/9g9uetvwlrAyNeGxGkJ0E93qQNRFAcizMOlrpfkeTei+P0LUReFHKoICkGcri3R5FhvYi8dKCNFd27Zto/AjaqOT4zy7FZcCAKhhLoJAIOC5GkJ007JlywAAEydOpPAj5VapAMzJyYGpqWlV1WJwNlx4xE2v/9SHv0II0UFJSUmoUaMGjI2NYWRkhBUrVvBdEtExap8CVSgUWLZsGWrWrAkLCwtuSJFFixZh165dVV6gPvvhwttuz96va89jJYToFqlUivbt22PEiBF0mwOpMLUDcPny5QgKCsLq1ashEom45U2aNMHOnTurtDh9du3R24E494x+j05/ElJORRu8/P3333j58iXfJREdpXYA7tu3D9u3b8ewYcMgFAq55c2bN0dkJN3MXV5f/PwvN93Z25HHSgjRHapaezo5OfFdFtFRagfg06dPUbdu3RLLFQoF8vLyqqQoQ5ApkwMA7MxF71iTEALQrQ6k6qkdgI0aNcLVq1dLLP/111/RokWLKilK3/0e9pSbDujbiMdKCNENFH5EE9RuBbp48WKMHDkST58+hUKhwLFjxxAVFYV9+/bh5MmTmqhR78w4GMZN92vuyl8hhOiIR48e4enTpxR+pEqpfQTYv39//N///R8uXLgAc3NzLF68GBEREfi///s/dOvWTRM16pXkjFxuesIHXtT4hZBy6NKlC06fPk3hR6pUhe4D7NixI86fP1/VtRiE3ddiuel5PRrwWAkh2i0+Ph45OTmoX78+gIIQJKQqqX0E6OXlpbLZ8evXr+Hl5VUlRemzoqM+GBnR0R8hqsTHx6Nz58748MMP8fDhw3dvQEgFqB2AcXFxkMvlJZbn5ubi6dOnKrYghVIyZdz0XDr6I0SlwvCLiYmBRCKBRCLhuySip8p9CrToyMrnzp2DtbU1Ny+XyxEcHAwPD48qLU7fXH/89ub3SR/W4bESQrRT0fCjBi9E08odgAMGDAAACAQCjBw5Uuk5ExMTeHh4YO3atVVanL6Z9sttvksgRGtR+JHqVu4AVCgUAABPT0/8888/sLenvisrqk8zGvOPkKKePHlC4UeqndqtQGNjY9+9EinhpytvG7+sHNSUx0oI0T7m5uaws7MDAAo/Um0qdBtEZmYmrly5gvj4eMhkMqXnpk+fXiWF6ZvAM2/7SbUyNeGxEkK0j62tLf744w9kZmaiVq1afJdDDITaAXj79m306tULWVlZyMzMhJ2dHZKTk2FmZgZHR0cKwHdY1Ie6PiMEKOje7Pz58xgzZgyAghC0tbXluSpiSNS+DWLmzJno27cvXr16BYlEgr/++gv//fcfWrVqhe+//14TNeq81Ky3nYT3bOLMYyWEaIfCvj3Hjh2L3bt3810OMVBqB2BYWBi++uorGBkZQSgUIjc3F25ubli9ejUWLFigiRp13q5rMdy0qw3d00QMW/GOrakLRcIXtQPQxMQERkYFmzk6OiI+Ph4AYG1tDalUWrXV6Yk/iwx+S4gho1EdiDZROwBbtGiBf/75BwDQqVMnLF68GPv378eXX36JJk2aqF3Ali1b4OHhAVNTU7Rt2xa3bt0qc/3Xr19jypQpcHFxgVgsRv369XH69Gm137c6hUlfAwD8GtLAncRwUfgRbaN2AK5cuRIuLgX3sa1YsQK2traYNGkSXrx4gZ9++kmt1zp06BBmzZqFgIAAhIaGonnz5vD398fz589Vri+TydCtWzfExcXh119/RVRUFHbs2IGaNWuq+zGqzf2nqdw0Xf8jhio9PZ3Cj2gdAWOM8fXmbdu2xXvvvYfNmzcDKLjZ3s3NDdOmTcO8efNKrL9t2zasWbMGkZGRMDGp2K0EaWlpsLa2RmpqKqysrCpVf3l4zDvFTUcu6wFTE6HG35MQbbRy5Urs2rWLwo9UWlV9j6t9BFia0NBQ9OnTp9zry2QyhISEwM/P720xRkbw8/PDzZs3VW5z4sQJ+Pr6YsqUKXByckKTJk2wcuVKlZ1zF8rNzUVaWprSo7psDH7ETft61aDwIwZtwYIFCAsLo/AjWkOtADx37hxmz56NBQsWICamoGVjZGQkBgwYgPfee4/rLq08kpOTIZfL4eSkfF3MyckJiYmJKreJiYnBr7/+CrlcjtOnT2PRokVYu3Ytli9fXur7BAYGwtramntU1y/fo6R0rDv/dhiX/ePaVsv7EqItpFIphg8fjvT0dG6ZpaUljxURoqzcN8Lv2rUL48ePh52dHV69eoWdO3di3bp1mDZtGoYMGYL79++jYcOGmqwVCoUCjo6O2L59O4RCIVq1aoWnT59izZo1CAgIULnN/PnzMWvWLG4+LS2tWkJw2akIbnr/uLY09h8xKEUbvADA//73P54rIqSkcgfghg0b8N133+Hrr7/G0aNH8cknn2Dr1q24d+9ehbousre3h1AoRFJSktLypKQkODurbizi4uICExMTCIVvTyU2bNgQiYmJkMlkEIlEJbYRi8UQi8Vq11dZt/97BQAwFwnRoS51HE4MR/HWnoGBgXyXRIhK5T4FGh0djU8++QQAMGjQIBgbG2PNmjUV7rdPJBKhVatWCA4O5pYpFAoEBwfD19dX5TYdOnTA48ePlU61Pnz4EC4uLirDj0/pufkAgKFta/NcCSHVh251ILqk3AGYnZ0NMzMzAAVjAorFYu52iIqaNWsWduzYgb179yIiIgKTJk1CZmYmRo8eDQAYMWIE5s+fz60/adIkpKSkYMaMGXj48CFOnTqFlStXYsqUKZWqo6rlyd8GdA+69YEYCAo/omvU6gx7586dsLCwAADk5+cjKCioxLiA6nSGPWTIELx48QKLFy9GYmIifHx8cPbsWa5hTHx8PNfrDAC4ubnh3LlzmDlzJpo1a4aaNWtixowZmDt3rjofQ+MSU3O46RZu1Lkv0X+MMQwePJjCj+iUct8H6OHhAYGg7IYcAoGAu+itrarjPsDoFxnouvYKRMZGeLi8p0begxBtc//+fYwfPx6HDx+m8CMaVVXf4+U+AoyLi6vwmxiawdsK7mMUG1fZbZaEaCWFQsGdpWnSpAlu3Ljxzj+UCdEW9A2tAS8zCwYJTs/J57kSQjRHKpWiRYsWuHLlCreMwo/oEgpADVoxUP3OwQnRBYUNXu7evYvp06er1QkGIdqCArCK5RdpAdq1AY3+QPRP8daeJ0+eVGqsRoiuoJ/aKlZ4+hMAbMwq1mE3IdqKbnUg+oQCsIodC33KTVPn10SfUPgRfVOhAIyOjsY333yDzz77jBu778yZM3jw4EGVFqeLbkTT6O9EP61Zs4bCj+gVtQPwypUraNq0Kf7++28cO3YMGRkZAIA7d+6U2iG1Ibn6qCAAuzei639Ev3z//feYNm0ahR/RG2oH4Lx587B8+XKcP39eqf/NLl264K+//qrS4nTZoJYV6yOVEG2SnJyMwr4yRCIRNm7cSOFH9IbaAXjv3j0MHDiwxHJHR0ckJxv26b/M3Lf3/TV3s+axEkIqLz4+Hm3btsWUKVNQzg6jCNEpagegjY0NEhISSiy/ffs2atasWSVF6apnr7O5aWcrUx4rIaRy4uPj0blzZ8TExODcuXN4+fIl3yURUuXUDsBPP/0Uc+fORWJiIgQCARQKBa5fv47Zs2djxIgRmqhRZ+y6FstNU48YRFcVDb/CBi/FO70nRB+oHYArV65EgwYN4ObmhoyMDDRq1AgffPAB2rdvj2+++UYTNeqEzNx8HPxHyncZhFSKqvCja35EX6k1HBJQcCF8x44dWLRoEe7fv4+MjAy0aNEC9erV00R9OuPqoxfc9O5RrXmshJCKofAjhkbtALx27Rref/991K5dG7Vr02jnhYr0gIYu1AUa0UFhYWH477//KPyIwVD7FGiXLl3g6emJBQsWIDw8XBM16aT4lCwAQPNa1PqT6KZ+/frh2LFjFH7EYKgdgM+ePcNXX32FK1euoEmTJvDx8cGaNWvw5MkTTdSnM0L+ewUAyFdQc3GiO6RSKaTSt9eu+/XrR+FHDIbaAWhvb4+pU6fi+vXriI6OxieffIK9e/fCw8MDXbp00USNOuFCRBIA6gCb6I7Cvj0//PBDpRAkxFBUqjNsT09PzJs3D6tWrULTpk2VBsY0JPIiR32d6jvwWAkh5VO0Y2tCDFWFA/D69euYPHkyXFxcMHToUDRp0gSnTp2qytp0RtCNOG56hK8Hb3UQUh40qgMhBdRuBTp//nwcPHgQz549Q7du3bBhwwb0798fZmZmmqhPJxz59+3pIxoCiWgzCj9C3lI7AP/88098/fXXGDx4MPUO8UZkYjoAoFdTZ54rIaR0FH6EKFM7AK9fv66JOnRWXHImN/15Ow/+CiHkHYyNjSESiSj8CHmjXAF44sQJ9OzZEyYmJjhx4kSZ6/br169KCtMVa88/5KZ969TgsRJCyubi4oKLFy8iPz+fwo8QlDMABwwYgMTERDg6OmLAgAGlricQCCCXy6uqNp3wKKng9KeLNY3+QLSPVCrFX3/9hU8++QRAQQgSQgqUKwAVCoXKafL2+t+XfobdFyrRPoXX/GJjC0YpKQxBQkgBtW+D2LdvH3Jzc0ssl8lk2LdvX5UUpStSMmXcdA1zMY+VEKKsaIMXT09PtGvXju+SCNE6agfg6NGjkZqaWmJ5eno6Ro8eXSVF6Yo5v97lpjs3cOSxEkLeotaehJSP2gHIGFM52OuTJ09gbW1YHUEXdn8GAEIjGgCX8I/Cj5DyK/dtEC1atIBAIIBAIEDXrl1hbPx2U7lcjtjYWPTo0UMjRWor9xpm+O9lFr729+a7FELw6tUrCj9C1FDuACxs/RkWFgZ/f39YWFhwz4lEInh4eOCjjz6q8gK12X8vC4ZAauNpx3MlhAA2NjYYNGgQDWlESDkJGGNqjd+zd+9eDBkyBKamutnsPy0tDdbW1khNTYWVlVWFX+d5eg7arAgGAPw1vyuc6TYIogUYY3j9+jVsbW35LoUQjamq73G1rwGOHDlSZ8OvKklTsrlpCj/CF6lUiokTJyInJwdAwb24FH6ElE+5ToHa2dnh4cOHsLe3h62trcpGMIVSUlKqrDhtVtgFmqe9Oc+VEENVfEijbdu28VwRIbqlXAH4ww8/wNLSkpsuKwANRdSbHmBii/QFSkh1Kd7ac+HChXyXRIjOKVcAjhw5kpseNWqUpmrRKcdCnwAA6jpavGNNQqoW3epASNVQ+xpgaGgo7t27x83//vvvGDBgABYsWACZTFbGlvqllm3B+IfUByipThR+hFQdtQPwiy++wMOHBSMgxMTEYMiQITAzM8ORI0cwZ86cKi9QW4VJXwMABremLx9SPRQKBfr370/hR0gVUTsAHz58CB8fHwDAkSNH0KlTJxw4cABBQUE4evRoVden9UTGau9CQirEyMgIW7duRYsWLSj8CKkCag+IyxjjRoS4cOEC+vTpAwBwc3NDcnJy1VanpV5mvO0MvEVtG/4KIQahaPeD7dq1w7///gsjI/rDi5DKUvu3qHXr1li+fDl+/vlnXLlyBb179wYAxMbGwsnJqcoL1EZ3n77tDNzRkq4BEs2Jj49HmzZtEBoayi2j8COkaqj9m7R+/XqEhoZi6tSpWLhwIerWrQsA+PXXX9G+ffsqL1AbXYx4zncJxADEx8ejc+fO+Pfff/HFF19AzU6bCCHvoPYp0GbNmim1Ai20Zs0aCIXCKilK22XnFYx6b2cu4rkSoq8Kw6+wwcuxY8fo/ltCqpjaAVgoJCQEERERAIBGjRqhZcuWVVaUtvs1pOAewI9b1eK5EqKPiocfNXghRDPUDsDnz59jyJAhuHLlCmxsbAAAr1+/RufOnXHw4EE4ODhUdY1ay96CjgBJ1aLwI6T6qH0NcNq0acjIyMCDBw+QkpKClJQU3L9/H2lpaZg+fbomatQqqdl53LR/Y2ceKyH6aMmSJRR+hFQTtY8Az549iwsXLqBhw4bcskaNGmHLli3o3r17lRanjYr2/VnbzozHSog+2rx5MwBg6dKlFH6EaJjaAahQKGBiYlJiuYmJCXd/oD6TKwpa4jlaiqlRAqkShWOaCQQCmJmZYffu3XyXRIhBUPsUaJcuXTBjxgw8e/aMW/b06VPMnDkTXbt2rdLitFG2rKAFqIVphdsPEcKRSqVo2bIlFi9eTLc5EFLN1A7AzZs3Iy0tDR4eHqhTpw7q1KkDT09PpKWlYdOmTZqoUavEJGcAALJy5TxXQnRd0Y6tDxw4gLS0NL5LIsSgqH0Y4+bmhtDQUAQHB3O3QTRs2BB+fn5VXpw2epFe0A2aRGQY9zwSzVA1qoO1tTXfZRFiUNQKwEOHDuHEiROQyWTo2rUrpk2bpqm6tFZ8ShYAwMlKzHMlRFfRkEaEaIdyB+CPP/6IKVOmoF69epBIJDh27Biio6OxZs0aTdandfLfNIKxNaN7AIn6KPwI0R7lvga4efNmBAQEICoqCmFhYdi7dy+2bt2qydq00tWHLwAA9WgkeFIBV65cofAjREuUOwBjYmIwcuRIbn7o0KHIz89HQkKCRgrTVmk5+QAAS9OSt4IQ8i7Dhw/Hzz//TOFHiBYo9ynQ3NxcmJubc/NGRkYQiUTIzs7WSGHaqPAeQABoXNOKx0qILpFKpZBIJLC3twdQEIKEEP6p1Qhm0aJFMDN72/uJTCbDihUrlFqvrVu3ruqq0zKvs2TcdMvatjxWQnRF4TU/c3NzXLx4kQtBQgj/yh2AH3zwAaKiopSWtW/fHjExMdy8vveM8qpIAJqa0G0QpGzFG7wY0tkSQnRBuQPw8uXLGixDN9yKfQUAsDWj63+kbNTakxDtp3ZPMIZswfGCgYBfZeW9Y01iyCj8CNENFIDlJMt/29H3F528eKyEaDMKP0J0h1YE4JYtW+Dh4QFTU1O0bdsWt27dKtd2Bw8ehEAgwIABAzRbIIDrj5O56Tn+DTT+fkQ35efnIz8/n8KPEB3AewAeOnQIs2bNQkBAAEJDQ9G8eXP4+/vj+fPnZW4XFxeH2bNno2PHjtVS59yjd7lpoZF+N/YhFefp6YnLly9T+BGiA3gPwHXr1mH8+PEYPXo0GjVqhG3btr1zTDS5XI5hw4Zh6dKl8PKqntORlm+GPzIRUvgRZVKpFGfPnuXmPT09KfwI0QEVCsCrV69i+PDh8PX1xdOnTwEAP//8M65du6bW68hkMoSEhCiNJGFkZAQ/Pz/cvHmz1O2+/fZbODo6YuzYse98j9zcXKSlpSk9KiL6RcFI8Ev7NanQ9kQ/FV7z69evn1IIEkK0n9oBePToUfj7+0MikeD27dvIzS0YHig1NRUrV65U67WSk5Mhl8vh5OSktNzJyQmJiYkqt7l27Rp27dqFHTt2lOs9AgMDYW1tzT0q+5e5gyWNAkEKFG3w4ubmhsaNG/NdEiFEDWoH4PLly7Ft2zbs2LEDJiZv74fr0KEDQkNDq7S44tLT0/H5559jx44d5e5RY/78+UhNTeUeUqlU7feNeZHBTdeylai9PdE/1NqTEN2n9oC4UVFR+OCDD0ost7a2xuvXr9V6LXt7ewiFQiQlJSktT0pKgrOzc4n1o6OjERcXh759+3LLFIqC2xOMjY0RFRWFOnXqKG0jFoshFlfuqC0xNYebbuBsWanXIrqPwo8Q/aD2EaCzszMeP35cYvm1a9fUbpAiEonQqlUrBAcHc8sUCgWCg4Ph6+tbYv0GDRrg3r17CAsL4x79+vVD586dERYWprEvoVx5Qcg2crHS++7eSNlevHhB4UeInlD7CHD8+PGYMWMGdu/eDYFAgGfPnuHmzZuYPXs2Fi1apHYBs2bNwsiRI9G6dWu0adMG69evR2ZmJkaPHg0AGDFiBGrWrInAwECYmpqiSRPlRig2NjYAUGJ5Vfo3LgUA3f5AgBo1aqBTp04AQOFHiI5TOwDnzZsHhUKBrl27IisrCx988AHEYjFmz56NadOmqV3AkCFD8OLFCyxevBiJiYnw8fHB2bNnuYYx8fHxMDLi926Nq48KboJPy6Eu0AydkZERdu7ciZcvX8LBwYHvcgghlSBgjLF3r1aSTCbD48ePkZGRgUaNGsHCQjdGSE9LS4O1tTVSU1NhZVW+Mf0+3/U3rj5KRsd69vh5bFsNV0i0jVQqxcaNGxEYGAhjY7X/ZiSEVLGKfI+rUuHfZpFIhEaNGlX4jXVJYSMY/8YlG+YQ/Va0wQsArFmzhueKCCFVRe0A7Ny5c5kNQS5evFipgrTRo+cZ716J6J3irT2nT5/Od0mEkCqkdgD6+Pgozefl5SEsLAz379/HyJEjq6ourWJvIUZyRi6crEz5LoVUE7rVgRD9p3YA/vDDDyqXL1myBBkZ+nmklP/mXkP3GmY8V0KqA4UfIYahyppXDh8+vMwOrHUVYwyv3wyAa0y3Qeg9uVyOnj17UvgRYgCqLABv3rwJU1P9O0WYlJbLTdewoH5A9Z1QKMS6devQuHFjCj9C9Jzap0AHDRqkNM8YQ0JCAv79998K3Qiv7XZejeGmrSUmZaxJdBljjGvc1b17d9y5cwdCoZDnqgghmqT2EWDRkRWsra1hZ2eHDz/8EKdPn0ZAQIAmauQVhZ7+k0ql+OCDDxAVFcUto/AjRP+pdQQol8sxevRoNG3aFLa2tpqqSavkKwr6Cfi8nTvPlRBNKNrgZdy4cfjzzz+pv1dCDIRaR4BCoRDdu3dXe9QHXZaaXdAAhvoB1T/FW3seOHCAwo8QA6L2KdAmTZpwvWIYgmuPk/kugWgA3epACKnQgLizZ8/GyZMnkZCQgLS0NKWHvolPyQJA1wL1CYUfIQRQ4xrgt99+i6+++gq9evUCAPTr10/pdFFhKzq5XF71VfKotp0ZHj/PgJeDOd+lkCry1VdfUfgRQsofgEuXLsXEiRNx6dIlTdajdeRvGsG42kh4roRUlZ9++gkAsHbtWgo/QgxYuQOwcNSkwsFADUVsciYA6gVG12VmZsLcvOAo3tbWFocPH+a5IkII39S6BmjILeTExnRfmK6SSqVo3rw51q9fz3cphBAtotZ9gPXr139nCKakpFSqIG2SnPG2G7RadnQKVBcVbfCyefNmjB8/njsSJIQYNrUCcOnSpbC2ttZULVrnUdLb0S2sTKkVqK4p3trz0qVLFH6EEI5aAfjpp5/C0dFRU7VonTtPXgOgYZB0Ed3qQAh5l3JfAzTE639pb3qBKewNhugGCj9CSHmUOwALW4Eakq2XowEAvZq68FwJUcepU6co/Agh71TuU6CKN6OiG5K6jhZ4/DwDImGVDZtIqsHEiRMBAL1796bwI4SUSu3xAA1JZm4+AKBPMzoC1HZPnjyBtbU1LC0tAbwNQUIIKQ0d2pQhITUHAGBEN8FrNalUik6dOqFHjx5IT0/nuxxCiI6gI8BSFG344mVPTee1VdEGLwCQmprKHQUSQkhZ6AiwFEVvgrcxE/FYCSmNqtaetWrV4rssQoiOoAAsxessuvVBm9GtDoSQyqIALMWL9ILrf2Yi6gNU21D4EUKqAgVgKWTygvseaSBc7ZOWlob09HQKP0JIpVAjmFLcf5oKgMYB1EaNGzfGpUuXYGVlReFHCKkwOgIsRch/rwC8vReQ8EsqleLatWvcfOPGjSn8CCGVQgFYCps3pz6drEx5roQUXvPz9/dXCkFCCKkMCsBS/PnoBQDAr6HhjH6hjYo2eHF2doa7uzvfJRFC9AQFYCny3jSCMRfTZVK+UGtPQogmUQC+Q30n6lWEDxR+hBBNowBU4XWWjJt2tBLzWIlhSkxMpPAjhGgcnd9T4cGzNG7a0ZIawVQ3Ozs7NG/eHAAo/AghGkMBqEJUIo0owCeRSISDBw8iJSUFzs7OfJdDCNFTdApUhYdJBQFYy5Zugq8uUqkUS5cu5QZeFolEFH6EEI2iI0AVYpIzAQCeNAxStSg+pFFAQADPFRFCDAEdAargaFnQ8MW9hhnPlei/4q09x4wZw3dJhBADQQGoQpZMDoBugdA0utWBEMInCkAV7khfAwAEAgG/hegxCj9CCN8oAFXweHPtj+JPM2QyGfz8/Cj8CCG8ogBUoXAkiJo0FJJGiEQiLFu2DPXr16fwI4TwhgJQBRfrgpvf6Qyo5gwePBj37t2j8COE8IYCsBjGGBJScwAAztbUC0xViY+PR/fu3SGVSrllIpGIx4oIIYaOArCYF+m53LQzjQVYJeLj49G5c2ecP38e48aN47scQggBQAFYQkqRjrBtzOgIpbIKw6+wwcvOnTv5LokQQgBQAJaQkiF790qkXIqHHzV4IYRoEwrAYsITCkaC8HKgbtAqg8KPEKLtKACLuR3/GgCQlp3PbyE6bvLkyRR+hBCtRgFYjK25CQDA3oKu/1XGzp070bt3bwo/QojWotEgirkVmwIA6N3UhedKdE9ubi7E4oKOxJ2dnXHy5EmeKyKEkNLREWAxjBX8m5Un57cQHSOVStG0aVPs27eP71IIIaRcKACLSc8puPZHYwGWX2HH1o8ePcLy5cuRm5v77o0IIYRnFIDFJKYV9ALjRDfBl0vxUR2Cg4O506CEEKLNKACLSMvJ46ZrmFMjmHehIY0IIbqMArCIR0np3HRjVyseK9F+FH6EEF1HAVhEUlrBtauaNhIaDPcdDhw4QOFHCNFpdBtEEanZBadAX2ZSI453mTNnDgBg6NChFH6EEJ1EAVjEytMRAIAmrtY8V6Kdnj17Bjs7O5iamkIgEGDu3Ll8l0QIIRWmFadAt2zZAg8PD5iamqJt27a4detWqevu2LEDHTt2hK2tLWxtbeHn51fm+upo62kHADAyotOfxUmlUnTs2BGDBg1CTk4O3+UQQkil8R6Ahw4dwqxZsxAQEIDQ0FA0b94c/v7+eP78ucr1L1++jM8++wyXLl3CzZs34ebmhu7du+Pp06eVrkXx5ib4j1vVqvRr6ZOiDV6ioqKQkpLCd0mEEFJpvAfgunXrMH78eIwePRqNGjXCtm3bYGZmht27d6tcf//+/Zg8eTJ8fHzQoEED7Ny5EwqFAsHBwZWuRf4mAY2oAQxHVWtPV1dXvssihJBK4zUAZTIZQkJC4Ofnxy0zMjKCn58fbt68Wa7XyMrKQl5eHuzs7FQ+n5ubi7S0NKVHaRRv+kET8v5ngXagWx0IIfqM16/65ORkyOVyODk5KS13cnJCYmJiuV5j7ty5cHV1VQrRogIDA2Ftbc09yvoC/zfuFQA6AgQo/Agh+k+nj3VWrVqFgwcP4vjx4zA1Vd112fz585Gamso9pFJpqa+X/aYD7Hw500i9uiQhIQEvXryg8COE6C1eb4Owt7eHUChEUlKS0vKkpCQ4OzuXue3333+PVatW4cKFC2jWrFmp64nF4nL3TWllaoy0nHx40mjwaNOmDS5cuAAXFxcKP0KIXuL1CFAkEqFVq1ZKDVgKG7T4+vqWut3q1auxbNkynD17Fq1bt66yetLejARhb26YnTlLpVKEhoZy823atKHwI4ToLd5vhJ81axZGjhyJ1q1bo02bNli/fj0yMzMxevRoAMCIESNQs2ZNBAYGAgC+++47LF68GAcOHICHhwd3rdDCwgIWFhYVriMjN5+bNhMLK/GJdFPhNb+UlBQEBwejZcuWfJdECCEaxXsADhkyBC9evMDixYuRmJgIHx8fnD17lmsYEx8fDyOjtweqP/74I2QyGT7++GOl1wkICMCSJUsqXEdy+tvuz+wtDOsIsHiDFwcHB75LIoQQjRMwxgyqxUdaWhqsra2RmpoKK6u3Iz6EP0tDr41XAQBxq3rzVV61o9aehBBdU9r3uLp0uhVoVXr2OhsAYGtmwnMl1YfCjxBiyCgA33j+5hRo4a0Q+u7p06cUfoQQg8b7NUBtUdgLjLnIMHaJra0t3N3dAYDCjxBikAzj274cCvsB9XGz4beQamJmZoaTJ0/i1atXqFmzJt/lEEJItaNToG9cefgCAGBhqr9/E8THx+OHH35AYbsnMzMzCj9CiMHS3297NT1PLxjjLiMn/x1r6qb4+Hh07twZMTExAICZM2fyXBEhhPCLjgDfeJWZBwBoWkv/RoMvGn5eXl4l7qEkhBBDRAH4hti4YFc4WanuVFtXFQ8/avBCCCEFKADfiEnOBADUtjPjuZKqQ+FHCCGlowB8w+pN4xeRsX7skuzsbHTp0oXCjxBCSqEf3/ZVwMioYBBcWzMRz5VUDYlEgjlz5qBu3boUfoQQogIF4BuF9wEa6dFg8BMmTMDdu3cp/AghRAUKwDcKuwQX6nACSqVSDBw4EMnJydwyiUTCY0WEEKK96D7ANwq7QjMS6GYAFu3YGgCOHz/Oc0WEEKLd6AjwjTy5AgCgi/lXfFSHjRs38l0SIYRoPToCREH45cl18wjQUIc0ksvlyMvL47sMQogGmJiYQCgUavx9KADxdixAQLduhDfE8GOMITExEa9fv+a7FEKIBtnY2MDZ2RkCDR6UUAACiEpM56Z1qRHMqFGjDCr8AHDh5+joCDMzM43+chBCqh9jDFlZWXj+/DkAwMXFRWPvRQEIcKc/dc3OnTsxbtw4BAUFGUT4yeVyLvxq1KjBdzmEEA0pbL3+/PlzODo6aux0KAUgAPmbFqCt3W15ruTd8vPzYWxc8N/m6emJ4OBgniuqPoXX/MzM9Ke7OkKIaoW/53l5eRoLQGoFCnDj45maaP6ia2VIpVI0bdoUJ06c4LsUXtFpT0L0X3X8nlMA4m0vMNr8vVrY4CUyMhJz585Ffr5+jltICCHVhQIQQKZMDkB7G8AUb+35xx9/cKdBCSkUFxcHgUCAsLAwAMDly5chEAj0ssVs8c+qaYsWLcKECROq5b0MQXh4OGrVqoXMzExe66AABJCYWnAbRPabINQmhnirg75KTEzEtGnT4OXlBbFYDDc3N/Tt21dj13Hbt2+PhIQEWFtXbJDnwgAtfEgkEjRu3Bjbt2+v4krLNmrUKAwYMEBpmZubGxISEtCkSRONv39iYiI2bNiAhQsXlnju5s2bEAqF6N27d4nnyvoDxMPDA+vXr1dadunSJfTq1Qs1atSAmZkZGjVqhK+++gpPnz6tqo9SQk5ODqZMmYIaNWrAwsICH330EZKSksrcJikpCaNGjYKrqyvMzMzQo0cPPHr0SK3XbdSoEdq1a4d169Zp5HOVFwUgAAuxCYC3p0K1BYWf/oiLi0OrVq1w8eJFrFmzBvfu3cPZs2fRuXNnTJkyRSPvKRKJquQ+qqioKCQkJCA8PBxffPEFJk2axHvjK6FQCGdn52o5E7Jz5060b98e7u7uJZ7btWsXpk2bhj///BPPnj2r8Hv89NNP8PPzg7OzM44ePYrw8HBs27YNqampWLt2bWXKL9PMmTPxf//3fzhy5AiuXLmCZ8+eYdCgQaWuzxjDgAEDEBMTg99//x23b9+Gu7s7/Pz8lI7myvO6o0ePxo8//sjv5RxmYFJTUxkAlpqayi1bcuI+c597ks07eofHykpasGABA8C8vLxYfHw83+XwLjs7m4WHh7Ps7GxumUKhYJm5edX+UCgUatXes2dPVrNmTZaRkVHiuVevXjHGGBs9ejTr3bu30nMymYw5ODiwnTt3MsYYk8vl7LvvvmN16tRhIpGIubm5seXLlzPGGIuNjWUA2O3btxljjF26dIkB4F6fMcauXbvGOnXqxCQSCbOxsWHdu3dnKSkpKmtWtT1jjNWpU4etXr2am8/JyWHTpk1jDg4OTCwWsw4dOrBbt24pbXP58mX23nvvMZFIxJydndncuXNZXl4e9/yRI0dYkyZNmKmpKbOzs2Ndu3ZlGRkZLCAggAFQely6dKnUz3rhwgXWqlUrJpFImK+vL4uMjFSqY9myZczBwYFZWFiwsWPHsrlz57LmzZur/PyFGjduzDZv3lxieXp6OrOwsGCRkZFsyJAhbMWKFeXaf4wx5u7uzn744QfGGGNSqZSJRCL25Zdfqnx/VdtXhdevXzMTExN25MgRbllERAQDwG7evKlym6ioKAaA3b9/n1sml8uZg4MD27Fjh1qvm5uby8RiMbtw4YLK91L1+15I1fd4RdCFJACvswqa12vbKdBly5YBACZOnEhHfqXIzpOj0eJz1f6+4d/6w0xUvl+flJQUnD17FitWrIC5uXmJ521sbAAA48aNwwcffICEhATu5t+TJ08iKysLQ4YMAQDMnz8fO3bswA8//ID3338fCQkJiIyMLFcdYWFh6Nq1K8aMGYMNGzbA2NgYly5dglxevp97xhjOnTuH+Ph4tG3blls+Z84cHD16FHv37oW7uztWr14Nf39/PH78GHZ2dnj69Cl69eqFUaNGYd++fYiMjMT48eNhamqKJUuWICEhAZ999hlWr16NgQMHIj09HVevXgVjDLNnz0ZERATS0tKwZ88eAICdnV2pR1sLFy7E2rVr4eDggIkTJ2LMmDG4fv06AGD//v1YsWIFtm7dig4dOuDgwYNYu3YtPD09S/3MKSkpCA8PR+vWrUs8d/jwYTRo0ADe3t4YPnw4vvzyS8yfP1/tI+4jR45AJpNhzpw5Kp8v/PlQpWfPnrh69Wqpz7u7u+PBgwcqnwsJCUFeXh78/Py4ZQ0aNEDt2rVx8+ZNtGvXrsQ2ubm5AABT07c9ZhkZGUEsFuPatWsYN25cuV9XJBLBx8cHV69eRdeuXUv9DJpEAQjARFjwAysR8X8bRFJSEmrUqAFjY2MYGRlhxYoVfJdEKunx48dgjKFBgwZlrte+fXt4e3vj559/5r4M9+zZg08++QQWFhZIT0/Hhg0bsHnzZowcORIAUKdOHbz//vvlqmP16tVo3bo1tm7dyi1r3LjxO7erVasWgIIvP4VCgW+//RYffPABACAzMxM//vgjgoKC0LNnTwDAjh07cP78eezatQtff/01tm7dCjc3N2zevBkCgQANGjTAs2fPMHfuXCxevBgJCQnIz8/HoEGDuNOMTZs25d5fIpEgNzcXzs7O76x1xYoV6NSpEwBg3rx56N27N3JycmBqaopNmzZh7NixGD16NABg8eLF+OOPP5CRkVHq68XHx4MxBldX1xLP7dq1C8OHDwcA9OjRA6mpqbhy5Qo+/PDDd9ZZ1KNHj2BlZVWhHk927tyJ7OzsUp83MTEp9bnExESIRKISAevk5ITExESV2xQG2fz58/HTTz/B3NwcP/zwA548eYKEhAS1X9fV1RX//fdfGZ9QsygAAdx9kgoAcLbid+y8wmt+7733Hv73v/9RS89ykJgIEf6tPy/vW16Mlf/a8rhx47B9+3bMmTMHSUlJOHPmDC5evAgAiIiIQG5uboX/Wg4LC8Mnn3yi9nZXr16FpaUlcnNzcevWLUydOhV2dnaYNGkSoqOjkZeXhw4dOnDrm5iYoE2bNoiIiODq9vX1VToy6tChAzIyMvDkyRM0b94cXbt2RdOmTeHv74/u3bvj448/hq2t+h1TNGvWjJsuDJTnz5+jdu3aiIqKwuTJk5XWb9OmDbd/VSkMl6JHPEDBddFbt25xw44ZGxtjyJAh2LVrl9oByBir8HXamjVrVmi7ijIxMcGxY8cwduxY2NnZQSgUws/PDz179lTr57yQRCJBVlaWBiotH/qGBVDbzgyRienIzefvFGjx8fxevnwJJycn3urRFQKBoNynIvlSr149CASCcp2qHDFiBObNm4ebN2/ixo0b8PT0RMeOHQFUfnDjim7v6enJ/TXfuHFj/P3331ixYgUmTZpUqXoKCYVCnD9/Hjdu3MAff/yBTZs2YeHChfj777/LPD2pStEjnsJQUSgUFa7N3t4eAPDq1Ss4ODhwy3ft2oX8/HylI0PGGMRiMTZv3gxra2tYWVkBAFJTU0scDb1+/ZprnVu/fn2kpqYqnfour8qcAnV2doZMJsPr16+V6ktKSirzaLtVq1YICwtDamoqZDIZHBwc0LZtW+40sTqvm5KSgjp16pTjk2oGtQLF28Fwa9vx08WWqtaeFH76w87ODv7+/tiyZYvK+56KNpOvUaMGBgwYgD179iAoKIg7XQcUBKlEIqlwC8xmzZpVSetNoVDIHRnVqVMHIpGIu84GFHRd9c8//6BRo0YAgIYNG+LmzZtKRwjXr1+HpaUld3pVIBCgQ4cOWLp0KW7fvg2RSMQdXYlEonJfpyyLt7c3/vnnH6VlxeeLq1OnDqysrBAeHs4ty8/Px759+7B27VqEhYVxjzt37sDV1RW//PILgIL/LyMjI4SEhCi9ZkxMDFJTU1G/fn0AwMcffwyRSITVq1errKGs+zh37typVEPxx+nTp0vdtlWrVjAxMVH6mYiKikJ8fDx8fX3L3C8AYG1tDQcHBzx69Aj//vsv+vfvr/br3r9/Hy1atHjne2lMpZrQ6CBVrYdG77nF3OeeZIf+qf6WlvHx8czLy4tae5ZDWa3CtF10dDRzdnZmjRo1Yr/++it7+PAhCw8PZxs2bGANGjRQWvePP/5gIpGICYVC9vTpU6XnlixZwmxtbdnevXvZ48eP2c2bN7kWou9qBRoVFcVEIhGbNGkSu3PnDouIiGBbt25lL168UFlz4fZRUVEsISGBxcXFscOHDzNLS0s2evRobr0ZM2YwV1dXdubMGfbgwQM2cuRIZmtry7UuffLkCTMzM2NTpkxhERER7LfffmP29vYsICCAMcbYX3/9xVasWMH++ecf9t9//7HDhw8zkUjETp8+zRhjbMWKFax27dosMjKSvXjxgslksnK1eL19+zYDwGJjYxljjP3vf/9jEomEBQUFsYcPH7Jly5YxKysr5uPjU+b/3aBBg9hXX33FzR8/fpyJRCL2+vXrEuvOmTOHtW7dmpufMGEC8/DwYL///juLiYlhV65cYe3atWPt2rVTakm8ZcsWJhAI2JgxY9jly5dZXFwcu3btGpswYQKbNWtWmfVVxsSJE1nt2rXZxYsX2b///st8fX2Zr6+v0jre3t7s2LFj3Pzhw4fZpUuXWHR0NPvtt9+Yu7s7GzRokNqvGxsbywQCAYuLi1NZW3W0AqUAZIyN2PU3c597kh35V1qttVD4qUeXA5Axxp49e8amTJnC3N3dmUgkYjVr1mT9+vVjly5dUlpPoVAwd3d31qtXrxKvIZfL2fLly5m7uzszMTFhtWvXZitXrmSMle82iMuXL7P27dszsVjMbGxsmL+/f6nN7Au3L3wYGxszT09PNnv2bKXbObKzs9m0adOYvb19hW6DCA8PZ/7+/txtFPXr12ebNm3itn3+/Dnr1q0bs7CweOdtEGUFIGOMffvtt8ze3p5ZWFiwMWPGsOnTp7N27dqp/PyFTp8+zWrWrMnkcjljjLE+ffqo/L9hjLG///6bAWB37tzh9k1AQABr0KABk0gkzNPTk02YMEHlHx3nz59n/v7+zNbWlpmamrIGDRqw2bNns2fPnpVZX2VkZ2ezyZMnM1tbW2ZmZsYGDhzIEhISlNYBwPbs2cPNb9iwgdWqVYv7+fvmm29Ybm6u2q+7cuVK5u/vX2ZtFIBVTNWOG77zL+Y+9yQ7Flq9ARgcHMzEYjGFXznpegCWV3p6OrOysmJHjx7luxS95+fnx4YPH17mOgqFgr333nvswIED1VSV/svNzWW1a9dm165dK3Udug+wmtyIfgkAMKrm3rC7dOmC06dPo169enSfH4FCoUBycjLWrl0LGxsb9OvXj++S9EpWVha2bdsGf39/CIVC/PLLL7hw4QLOnz9f5nYCgQDbt2/HvXv3qqlS/RcfH48FCxYotR7mAwUg3naBVoFWvGqLj49HdnY2vL29ARSEICFAwc+Gp6cnatWqhaCgILoNpooJBAKcPn0aK1asQE5ODry9vXH06FGlG7ZL4+PjAx8fH80XaSDq1q2LunXr8l0GBWCe/G0T6UauVhp9r/j4eHTu3BlZWVm4fPkyF4KEAAUdJLPq+CvMQEkkEly4cIHvMogWMfjbIIoGoJut5m6DKAy/mJgYmJmZ0ajmhBDCM4MPwPwiI0AYaWhvFA0/GtWBEEK0g8EHoKJIABprIAEp/AghRDsZfABm5L4di6qqB4SXSqUUfoQQoqUMvhFMUloON13ZgUOLs7S0hJ2dHQBQ+BFCiJYx+ABMSM1590oVZGNjg/PnzyMjI4Pr85AQQoh2MPhToMZvznt62ZccqLQipFIpdu/ezc3b2NhQ+JFqN2rUKAwYMIDvMnSGTCZD3bp1cePGDb5L0Qnbtm1D3759+S6j0gw+ALPejAJfw0JU6dcqHNVh7NixSiFICNFu27Ztg6enJ9q3b1/iuS+++AJCoRBHjhwp8Vxpf2hcvnwZAoFAaSQHmUyG1atXo3nz5jAzM4O9vT06dOiAPXv2IC8vryo/jpK7d++iY8eOMDU1hZubW6mjThQlEAhKPA4ePMg9P2bMGISGhpY5FJMuMPgAfJVV8IOXkimr1OsUH9KoW7duVVEe0VMyWeV+3kjVYYxh8+bNGDt2bInnsrKycPDgQcyZM6dSf9TKZDL4+/tj1apVmDBhAm7cuIFbt25hypQp2LRpU6lj9lVWWloaunfvDnd3d4SEhGDNmjVYsmQJtm/f/s5t9+zZg4SEBO5RNOhFIhGGDh2KjRs3aqTu6mLwASg2LtgFlRlUVdV4ftTgpXplZmaW+sjJySn3uoXj3JW1bkV8+OGHmDp1Kr788kvY29vD379gFPt169ahadOmMDc3h5ubGyZPnoyMjAxuu6CgINjY2ODcuXNo2LAhLCws0KNHDyQkJHDryOVyzJo1CzY2NqhRowbmzJlTokeZ3NxcTJ8+HY6OjjA1NcX777+vNBZe4RHLuXPn0KJFC0gkEnTp0gXPnz/HmTNn0LBhQ1hZWWHo0KHvHMF7x44dcHNzg5mZGQYOHIh169YpDYyq6qjpyy+/VBpJXaFQIDAwEJ6enpBIJGjevDl+/fVX7vlXr15h2LBhcHBwgEQiQb169bBnzx4ABWEzdepUuLi4wNTUFO7u7ggMDCy13pCQEERHR6N3794lnjty5AgaNWqEefPm4c8//4RUKi3zs5dm/fr1+PPPPxEcHIwpU6bAx8cHXl5eGDp0KP7++2/Uq1evQq/7Lvv374dMJsPu3bvRuHFjfPrpp5g+fTrWrVv3zm1tbGzg7OzMPUxNTZWe79u3L06cOFHid0aXGHwAPniWBgCoXaNiPbNQ+GkHCwuLUh8fffSR0rqOjo6lrtuzZ0+ldT08PEqsU1F79+7lBo/dtm0bAMDIyAgbN27EgwcPsHfvXly8eBFz5sxR2i4rKwvff/89fv75Z/z555+Ij4/H7NmzuefXrl2LoKAg7N69G9euXUNKSgo3mGyhOXPm4OjRo9i7dy9CQ0NRt25d+Pv7IyUlRWm9JUuWYPPmzbhx4wakUikGDx6M9evX48CBAzh16hQ3Yntprl+/jokTJ2LGjBkICwtDt27dsGLFCrX3VWBgIPbt24dt27bhwYMHmDlzJoYPH44rV64AABYtWoTw8HCcOXMGERER+PHHH7nR2zdu3IgTJ07g8OHDiIqKwv79++Hh4VHqe129ehX169eHpaVlied27dqF4cOHw9raGj179kRQUJDanwUoCCI/Pz+Vg7+amJjA3Fx1G4T4+Pgyf7YtLCywcuXKUt/35s2b+OCDDyASvb3E4+/vj6ioKLx69arMmqdMmQJ7e3u0adMGu3fvLvFHVevWrZGfn4+///67zNfRapUaS0IHFR9G4/tzkcx97kk2aOt1tV8rLS2NxvOrRmUNj4Ii49YVfxQfu83MzKzUdTt16qS0rr29fYl1KqJTp06sRYsW71zvyJEjrEaNGtz8nj17GAD2+PFjbtmWLVuYk5MTN+/i4sJWr17Nzefl5bFatWqx/v37M8YYy8jIYCYmJmz//v3cOjKZjLm6unLbFY6nd+HCBW6dwMBABoBFR0dzy7744osyx3AbMmQI6927t9KyYcOGMWtra25+5MiRXG2FZsyYwe37nJwcZmZmxm7cuKG0ztixY9lnn33GGGOsb9++SoPyFjVt2jTWpUsXpQFnyzJjxgzWpUuXEssfPnzITExMuLH7jh8/zjw9PZVeV9VnYazk+IQSiYRNnz69XPUUlZeXxx49elTm4+XLl6Vu361bNzZhwgSlZQ8ePGAAWHh4eKnbffvtt+zatWssNDSUrVq1ionFYrZhw4YS69na2rKgoCC1P1d50HBI1aDw2l8LNxu1t7W0tMT48eOxY8cOOvLjWdHThsUJhUKl+efPn5e6rlGx3oDi4uIqVVdRrVq1KrHswoULCAwMRGRkJNLS0pCfn4+cnBxkZWVx/cWamZmhTp063DYuLi7cZ0hNTUVCQgLatm3LPW9sbIzWrVtzf7FHR0cjLy9PaegZExMTtGnTBhEREUr1NGvWjJt2cnKCmZkZvLy8lJbdunWr1M8YFRWFgQMHKi1r06YNTp48WfqOKebx48fIysoqcR1dJpNxR1CTJk3CRx99hNDQUHTv3h0DBgzgGrCMGjUK3bp1g7e3N3r06IE+ffqge/fupb5fdnZ2idN7ALB79274+/tzR5a9evXC2LFjcfHiRXTt2rXcnwdAhTs5NzY25mXUhEWLFnHTLVq0QGZmJtasWYPp06crrSeRSN55SlybGfwp0PiUgv+8on2CqmPevHkICwuj8OOZubl5qY/iX25lrSuRSN65bmVqLCouLg59+vRBs2bNcPToUYSEhGDLli0AlBvJmJiYKG0nEAg0NmpE0fcSCAQq31uhUBTfTC1GRkYl6i/aCrLwj5lTp04hLCyMe4SHh3PXAXv27In//vsPM2fOxLNnz9C1a1futHDLli0RGxuLZcuWITs7G4MHD8bHH39caj329vYlTgfK5XLs3bsXp06dgrGxMYyNjWFmZoaUlBSlxjBWVlZITU0t8ZqvX7+GUCjk/s/r16+PyMhIdXYTgMqfAnV2dkZSUpLSssJ5Z2fnctfRtm1bPHnyBLm5uUrLU1JS4ODgoMYn0i4GH4D2FmK11pdKpRg+fDjS09O5ZaquHRDyLiEhIVAoFFi7di3atWuH+vXr49mzZ2q9hrW1NVxcXJSuw+Tn5yMkJISbr1OnDnftsVBeXh7++ecfNGrUqPIfpAhvb2+lxjUASsw7ODgoNeIBgLCwMG66UaNGEIvFiI+P58aNK3wU/UPTwcEBI0eOxP/+9z+sX79eqWWjlZUVhgwZgh07duDQoUM4evRoieudhVq0aIHIyEilUD59+jTS09Nx+/ZtpRD+5ZdfcOzYMe72Bm9vbzx48KBEMISGhsLT05P7A2Lo0KG4cOECbt++XeL98/LySm1c5erqqvT+qh4TJ05UuS0A+Pr64s8//1T6A+P8+fPw9vaGra1tqdsVFxYWBltbW4jFb78vo6OjkZOTo/K6ps6o1AlUHVT83HHnNZeY+9yTbPe1mHduGx8fz13zGzZsmKZLJcWUdU1A23Xq1InNmDFDaVlYWBgDwNavX8+io6PZvn37WM2aNZWuHe3Zs0fp+hljBdeiiv7qrlq1itnZ2bHjx4+ziIgINn78eGZpaal0bWrGjBnM1dWVnTlzhj148ICNHDmS2draspSUFMZYyWtWpb13QEAAa968eamf89q1a8zIyIitXbuWPXz4kG3bto3VqFGD2djYcOucPXuWCQQCtnfvXvbw4UO2ePFiZmVlpXT9deHChaxGjRosKCiIPX78mIWEhLCNGzdy15sWLVrEfvvtN/bo0SN2//591qdPH9amTRvGGGNr165lBw4cYBERESwqKoqNHTuWOTs7M7lcrrLm5ORkZmJiwu7du8ct69+/PxsyZEiJdeVyOXN2dmabN29mjDH26tUr5ujoyAYPHsz+/fdf9ujRI7Zr1y5maWnJfvzxR267nJwc1rFjR2Zra8s2b97MwsLCWHR0NDt06BBr2bIlu337dqn7tDJev37NnJyc2Oeff87u37/PDh48yMzMzNhPP/3ErXPs2DHm7e3NzZ84cYLt2LGD3bt3jz169Iht3bqVmZmZscWLFyu99p49e5iXl5dG6maseq4BGnwAdl17mbnPPck2X3xU5nZFw48avPBD3wKQMcbWrVvHXFxcmEQiYf7+/mzfvn1qB2BeXh6bMWMGs7KyYjY2NmzWrFlsxIgRSgGYnZ3Npk2bxuzt7ZlYLGYdOnRgt27d4p6vqgBkjLHt27ezmjVrMolEwgYMGMCWL1/OnJ2dldZZvHgxc3JyYtbW1mzmzJls6tSpSgGoUCjY+vXrmbe3NzMxMWEODg7M39+fXblyhTHG2LJly1jDhg2ZRCJhdnZ2rH///iwmJoZ7fx8fH2Zubs6srKxY165dWWhoaJk1Dx48mM2bN48xxlhiYiIzNjZmhw8fVrnupEmTlBo0RUVFsYEDBzJXV1dmbm7Omjdvznbs2FGiEU5OTg4LDAxkTZs2ZaampszOzo516NCBBQUFsby8vDLrq4w7d+6w999/n4nFYlazZk22atUqpecLG1oVOnPmDPPx8WEWFhbc59m2bVuJPyC6d+/OAgMDNVZ3dQSggDHDGoI6LS0N1tbWSE1NhZWVFep/cwayfAW2DW+FHk1UnxOnWx20Q05ODmJjY+Hp6amy0QLRTuPHj0dkZKRW9xpy9+5ddOvWDdHR0ZW61cVQPHjwAF26dMHDhw9hbW2tkfco6/e9+Pd4RRn8NcCiI8KrQuFHiHq+//573LlzB48fP8amTZuwd+9ejBw5ku+yytSsWTN89913iI2N5bsUnZCQkIB9+/ZpLPyqi8HfBlF4/OtiXfKIgjGGwYMHU/gRooZbt25h9erVSE9Ph5eXFzZu3Ihx48bxXdY7jRo1iu8SdIafnx/fJVQJgw9AoZEAcgWDo1XJ1qACgQA7duzA+PHjcfjwYQo/Qsrh8OHDfJdASLkYdAAqFAzyN/f/iYRvzwbL5XLu5ukmTZrgxo0bVT5YLiGEEH4Z9DXA9Nx8bloiKgg8qVSKFi1a4PLly9xzFH7axcDabRFikKrj99ygAzA3T85Nm4mMuQYv9+7dw/Tp0yGXy8vYmlS3wpuKdbnrJUJI+RT+nhfvjagqacUp0C1btmDNmjVITExE8+bNsWnTJrRp06bU9Y8cOYJFixYhLi4O9erVw3fffYdevXqp/b6FvZ8ZGwlKtPY8depUiT4kCb+EQiFsbGy4fjDNzMzo6JwQPcMYQ1ZWFp4/fw4bGxuNfg/zHoCHDh3CrFmzsG3bNrRt2xbr16/nhutwdHQssf6NGzfw2WefITAwEH369MGBAwcwYMAAhIaGokmTJmq9t/zNIbY8I5luddARhf0XltWhNSFE9xWOR6hJvN8I37ZtW7z33nvYvHkzgIKBMN3c3DBt2jTMmzevxPpDhgxBZmamUu/y7dq1g4+PDzfGWlmK3kCZmm8M328O4/kv85H3OpHCT4fI5XKl/g0JIfrDxMSkzCO/qroRntcjQJlMhpCQEMyfP59bZmRkBD8/P9y8eVPlNjdv3sSsWbOUlvn7++O3335TuX5ubq5SR7VpaWnctIIxpN06RuGng4RCIZ2iJoRUCq+NYJKTkyGXy+Hk5KS03MnJCYmJiSq3SUxMVGv9wMBAWFtbc4+iASdXMNh2HgO7Nv0o/AghxMDofSvQ+fPnF5zufPOQSqXcc7VszfDnvG4IOXWAwo8QQgwMr6dA7e3tIRQKVQ7YWNrFz9IGeCxtfbFYrDSGVVEiYyO416j4AKeEEEJ0F68BKBKJ0KpVKwQHB2PAgAEAChrBBAcHY+rUqSq38fX1RXBwML788ktu2fnz5+Hr61uu9yxs81P0WiAhhBDdUfj9Xek2nJUaTKkKHDx4kInFYhYUFMTCw8PZhAkTmI2NDUtMTGSMMfb5559z43Qxxtj169eZsbEx+/7771lERAQLCAgoMZhlWaRSKQNAD3rQgx700PGHVCqtVP7wfh/gkCFD8OLFCyxevBiJiYnw8fHB2bNnuYYu8fHxMDJ6e6myffv2OHDgAL755hssWLAA9erVw2+//VbuewBdXV0hlUphaWkJgUCAtLQ0uLm5QSqVVqo5rb6i/fNutI/KRvvn3Wgfla34/mGMIT09Ha6urpV6Xd7vA+RbVd1Poq9o/7wb7aOy0f55N9pHZdPU/tH7VqCEEEKIKhSAhBBCDJLBB6BYLEZAQECpt0oYOto/70b7qGy0f96N9lHZNLV/DP4aICGEEMNk8EeAhBBCDBMFICGEEINEAUgIIcQgUQASQggxSAYRgFu2bIGHhwdMTU3Rtm1b3Lp1q8z1jxw5ggYNGsDU1BRNmzbF6dOnq6lSfqizf3bs2IGOHTvC1tYWtra28PPze+f+1Afq/gwVOnjwIAQCAdfXrb5Sd/+8fv0aU6ZMgYuLC8RiMerXr0+/Z8WsX78e3t7ekEgkcHNzw8yZM5GTk1NN1VavP//8E3379oWrqysEAkGp47sWdfnyZbRs2RJisRh169ZFUFCQ+m9cqY7UdMDBgweZSCRiu3fvZg8ePGDjx49nNjY2LCkpSeX6169fZ0KhkK1evZqFh4ezb775Rq2+RnWNuvtn6NChbMuWLez27dssIiKCjRo1illbW7MnT55Uc+XVR919VCg2NpbVrFmTdezYkfXv3796iuWBuvsnNzeXtW7dmvXq1Ytdu3aNxcbGssuXL7OwsLBqrrz6qLuP9u/fz8RiMdu/fz+LjY1l586dYy4uLmzmzJnVXHn1OH36NFu4cCE7duwYA8COHz9e5voxMTHMzMyMzZo1i4WHh7NNmzYxoVDIzp49q9b76n0AtmnThk2ZMoWbl8vlzNXVlQUGBqpcf/Dgwax3795Ky9q2bcu++OILjdbJF3X3T3H5+fnM0tKS7d27V1Ml8q4i+yg/P5+1b9+e7dy5k40cOVKvA1Dd/fPjjz8yLy8vJpPJqqtE3qm7j6ZMmcK6dOmitGzWrFmsQ4cOGq1TG5QnAOfMmcMaN26stGzIkCHM399frffS61OgMpkMISEh8PPz45YZGRnBz88PN2/eVLnNzZs3ldYHAH9//1LX12UV2T/FZWVlIS8vD3Z2dpoqk1cV3UfffvstHB0dMXbs2OookzcV2T8nTpyAr68vpkyZAicnJzRp0gQrV66EXC6vrrKrVUX2Ufv27RESEsKdJo2JicHp06fRq1evaqlZ21XV9zTvo0FoUnJyMuRyOTeyRCEnJydERkaq3CYxMVHl+omJiRqrky8V2T/FzZ07F66uriV+GPVFRfbRtWvXsGvXLoSFhVVDhfyqyP6JiYnBxYsXMWzYMJw+fRqPHz/G5MmTkZeXh4CAgOoou1pVZB8NHToUycnJeP/998EYQ35+PiZOnIgFCxZUR8lar7Tv6bS0NGRnZ0MikZTrdfT6CJBo1qpVq3Dw4EEcP34cpqamfJejFdLT0/H5559jx44dsLe357scraRQKODo6Ijt27ejVatWGDJkCBYuXIht27bxXZrWuHz5MlauXImtW7ciNDQUx44dw6lTp7Bs2TK+S9Mren0EaG9vD6FQiKSkJKXlSUlJcHZ2VrmNs7OzWuvrsorsn0Lff/89Vq1ahQsXLqBZs2aaLJNX6u6j6OhoxMXFoW/fvtwyhUIBADA2NkZUVBTq1Kmj2aKrUUV+hlxcXGBiYgKhUMgta9iwIRITEyGTySASiTRac3WryD5atGgRPv/8c4wbNw4A0LRpU2RmZmLChAlYuHCh0hiphqi072krK6tyH/0Ben4EKBKJ0KpVKwQHB3PLFAoFgoOD4evrq3IbX19fpfUB4Pz586Wur8sqsn8AYPXq1Vi2bBnOnj2L1q1bV0epvFF3HzVo0AD37t1DWFgY9+jXrx86d+6MsLAwuLm5VWf5GleRn6EOHTrg8ePH3B8GAPDw4UO4uLjoXfgBFdtHWVlZJUKu8A8GRt03V933tHrtc3TPwYMHmVgsZkFBQSw8PJxNmDCB2djYsMTERMYYY59//jmbN28et/7169eZsbEx+/7771lERAQLCAjQ+9sg1Nk/q1atYiKRiP36668sISGBe6Snp/P1ETRO3X1UnL63AlV3/8THxzNLS0s2depUFhUVxU6ePMkcHR3Z8uXL+foIGqfuPgoICGCWlpbsl19+YTExMeyPP/5gderUYYMHD+brI2hUeno6u337Nrt9+zYDwNatW8du377N/vvvP8YYY/PmzWOff/45t37hbRBff/01i4iIYFu2bKHbIEqzadMmVrt2bSYSiVibNm3YX3/9xT3XqVMnNnLkSKX1Dx8+zOrXr89EIhFr3LgxO3XqVDVXXL3U2T/u7u4MQIlHQEBA9RdejdT9GSpK3wOQMfX3z40bN1jbtm2ZWCxmXl5ebMWKFSw/P7+aq65e6uyjvLw8tmTJElanTh1mamrK3Nzc2OTJk9mrV6+qv/BqcOnSJZXfK4X7ZOTIkaxTp04ltvHx8WEikYh5eXmxPXv2qP2+NBwSIYQQg6TX1wAJIYSQ0lAAEkIIMUgUgIQQQgwSBSAhhBCDRAFICCHEIFEAEkIIMUgUgIQQQgwSBSAhhBCDRAFIiApBQUGwsbHhu4wKEwgE+O2338pcZ9SoURgwYEC11EOINqIAJHpr1KhREAgEJR6PHz/muzQEBQVx9RgZGaFWrVoYPXo0nj9/XiWvn5CQgJ49ewIA4uLiIBAISoxPuGHDBgQFBVXJ+5VmyZIl3OcUCoVwc3PDhAkTkJKSotbrUFgTTdDr4ZAI6dGjB/bs2aO0zMHBgadqlFlZWSEqKgoKhQJ37tzB6NGj8ezZM5w7d67Sr12e4busra0r/T7l0bhxY1y4cAFyuRwREREYM2YMUlNTcejQoWp5f0JKQ0eARK+JxWI4OzsrPYRCIdatW4emTZvC3Nwcbm5umDx5MjIyMkp9nTt37qBz586wtLSElZUVWrVqhX///Zd7/tq1a+jYsSMkEgnc3Nwwffp0ZGZmllmbQCCAs7MzXF1d0bNnT0yfPh0XLlxAdnY2FAoFvv32W9SqVQtisRg+Pj44e/Yst61MJsPUqVPh4uICU1NTuLu7IzAwUOm1C0+Benp6AgBatGgBgUCADz/8EIDyUdX27dvh6uqqNEQRAPTv3x9jxozh5n///Xe0bNkSpqam8PLywtKlS5Gfn1/m5zQ2NoazszNq1qwJPz8/fPLJJzh//jz3vFwux9ixY+Hp6QmJRAJvb29s2LCBe37JkiXYu3cvfv/9d+5o8vLlywAAqVSKwYMHw8bGBnZ2dujfvz/i4uLKrIeQQhSAxCAZGRlh48aNePDgAfbu3YuLFy9izpw5pa4/bNgw1KpVC//88w9CQkIwb948mJiYACgYBLdHjx746KOPcPfuXRw6dAjXrl3D1KlT1apJIpFAoVAgPz8fGzZswNq1a/H999/j7t278Pf3R79+/fDo0SMAwMaNG3HixAkcPnwYUVFR2L9/Pzw8PFS+7q1btwAAFy5cQEJCAo4dO1ZinU8++QQvX77EpUuXuGUpKSk4e/Yshg0bBgC4evUqRowYgRkzZiA8PBw//fQTgoKCsGLFinJ/xri4OJw7d05p3D+FQoFatWrhyJEjCA8Px+LFi7FgwQIcPnwYADB79mwMHjwYPXr0QEJCAhISEtC+fXvk5eXB398flpaWuHr1Kq5fvw4LCwv06NEDMpms3DURA1bZYSwI0VYjR45kQqGQmZubc4+PP/5Y5bpHjhxhNWrU4Ob37NnDrK2tuXlLS0sWFBSkctuxY8eyCRMmKC27evUqMzIyYtnZ2Sq3Kf76Dx8+ZPXr12etW7dmjDHm6urKVqxYobTNe++9xyZPnswYY2zatGmsS5cuTKFQqHx9AOz48eOMMcZiY2MZAHb79m2ldYoP09S/f382ZswYbv6nn35irq6uTC6XM8YY69q1K1u5cqXSa/z888/MxcVFZQ2MFYxrZ2RkxMzNzZmpqSk3zM26detK3YYxxqZMmcI++uijUmstfG9vb2+lfZCbm8skEgk7d+5cma9PCGOM0TVAotc6d+6MH3/8kZs3NzcHUHA0FBgYiMjISKSlpSE/Px85OTnIysqCmZlZideZNWsWxo0bh59//pk7jVenTh0ABadH7969i/3793PrM8agUCgQGxuLhg0bqqwtNTUVFhYWUCgUyMnJwfvvv4+dO3ciLS0Nz549Q4cOHZTW79ChA+7cuQOg4PRlt27d4O3tjR49eqBPnz7o3r17pfbVsGHDMH78eGzduhVisRj79+/Hp59+yo1MfufOHVy/fl3piE8ul5e53wDA29sbJ06cQE5ODv73v/8hLCwM06ZNU1pny5Yt2L17N+Lj45GdnQ2ZTAYfH58y671z5w4eP34MS0tLpeU5OTmIjo6uwB4ghoYCkOg1c3Nz1K1bV2lZXFwc+vTpg0mTJmHFihWws7PDtWvXMHbsWMhkMpVf5EuWLMHQoUNx6tQpnDlzBgEBATh48CAGDhyIjIwMfPHFF5g+fXqJ7WrXrl1qbZaWlggNDYWRkRFcXFwgkUgAAGlpae/8XC1btkRsbCzOnDmDCxcuYPDgwfDz88Ovv/76zm1L07dvXzDGcOrUKbz33nu4evUqfvjhB+75jIwMLF26FIMGDSqxrampaamvKxKJuP+DVatWoXfv3li6dCmWLVsGADh48CBmz56NtWvXwtfXF5aWllizZg3+/vvvMuvNyMhAq1atlP7wKKQtDZ2IdqMAJAYnJCQECoUCa9eu5Y5uCq83laV+/fqoX78+Zs6cic8++wx79uzBwIED0bJlS4SHh5cI2ncxMjJSuY2VlRVcXV1x/fp1dOrUiVt+/fp1tGnTRmm9IUOGYMiQIfj444/Ro0cPpKSkwM7OTun1Cq+3yeXyMusxNTXFoEGDsH//fjx+/Bje3t5o2bIl93zLli0RFRWl9ucs7ptvvkGXLl0wadIk7nO2b98ekydP5tYpfgQnEolK1N+yZUscOnQIjo6OsLKyqlRNxDBRIxhicOrWrYu8vDxs2rQJMTEx+Pnnn7Ft27ZS18/OzsbUqVNx+fJl/Pfff7h+/Tr++ecf7tTm3LlzcePGDUydOhVhYWF49OgRfv/9d7UbwRT19ddf47vvvsOhQ4cQFRWFefPmISwsDDNmzAAArFu3Dr/88gsiIyPx8OFDHDlyBM7Ozipv3nd0dIREIsHZs2eRlJSE1NTUUt932LBhOHXqFHbv3s01fim0ePFi7Nu3D0uXLsWDBw8QERGBgwcP4ptvvlHrs/n6+qJZs2ZYuXIlAKBevXr4999/ce7cOTx8+BCLFi3CP//8o7SNh4cH7t69i6ioKCQnJyMvLw/Dhg2Dvb09+vfvj6tXryI2NhaXL1/G9OnT8eTJE7VqIgaK74uQhGiKqoYThdatW8dcXFyYRCJh/v7+bN++fQwAe/XqFWNMuZFKbm4u+/TTT5mbmxsTiUTM1dWVTZ06VamBy61bt1i3bt2YhYUFMzc3Z82aNSvRiKWo4o1gipPL5WzJkiWsZs2azMTEhDVv3pydOXOGe3779u3Mx8eHmZubMysrK9a1a1cWGhrKPY8ijWAYY2zHjh3Mzc2NGRkZsU6dOpW6f+RyOXNxcWEAWHR0dIm6zp49y9q3b88kEgmzsrJibdq0Ydu3by/1cwQEBLDmzZuXWP7LL78wsVjM4uPjWU5ODhs1ahSztrZmNjY2bNKkSWzevHlK2z1//pzbvwDYpUuXGGOMJSQksBEjRjB7e3smFouZl5cXGz9+PEtNTS21JkIKCRhjjN8IJoQQQqofnQIlhBBikCgACSGEGCQKQEIIIQaJApAQQohBogAkhBBikCgACSGEGCQKQEIIIQaJApAQQohBogAkhBBikCgACSGEGCQKQEIIIQbp/wGkpRyr6SFZawAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Since Cyclic Boosting is a fully explainable (\"white box\") model, we can get detailed information about which feature contributes how to each individual prediction.\n", + "\n", + "To investigate more wen get a dictionary of the feature contributions for the test data. The dictionary contains each variable used in the model, together with an array of the numerical values of how much this variable contributes for each prediction.\n", + "\n", + "For classification, the features contributions are centered around 0.5, i.e. the value of 0.5 is the \"neutral\" element. Values larger than this indicate this feature is particularly important for this prediction, and vice versa for smaller values." + ], + "metadata": { + "id": "CR7EePnS4ju4" + } + }, + { + "cell_type": "code", + "source": [ + "feature_contributions = CB_est.get_feature_contributions(X_test)" + ], + "metadata": { + "id": "plmMUe9lzGhk" + }, + "execution_count": 22, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "print(feature_contributions)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cSnT6IoD0JQC", + "outputId": "b019276c-a5d8-4ca8-e970-0585abe7f8b7" + }, + "execution_count": 23, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Age': array([0.56552353, 0.14468231, 0.60204227, ..., 0.19732741, 0.32425085,\n", + " 0.19732741]), 'WorkClass': array([0.53114851, 0.53114851, 0.53114851, ..., 0.53114851, 0.53114851,\n", + " 0.46545386]), 'fnlwgt': array([0.49929637, 0.49915531, 0.49971289, ..., 0.49926855, 0.49927962,\n", + " 0.49953604]), 'Education': array([0.61247986, 0.43119116, 0.36438462, ..., 0.57128696, 0.43119116,\n", + " 0.29214504]), 'EducationNum': array([0.62121937, 0.44180738, 0.40740085, ..., 0.58332728, 0.44180738,\n", + " 0.30875204]), 'MaritalStatus': array([0.27355185, 0.27355185, 0.27355185, ..., 0.27355185, 0.27355185,\n", + " 0.30854674]), 'Occupation': array([0.63579665, 0.46507476, 0.24979187, ..., 0.57122167, 0.32915655,\n", + " 0.448426 ]), 'Relationship': array([0.4292497 , 0.21512424, 0.21512424, ..., 0.21512424, 0.21512424,\n", + " 0.4292497 ]), 'Race': array([0.53382892, 0.53382892, 0.53382892, ..., 0.53382892, 0.53382892,\n", + " 0.53382892]), 'Gender': array([0.53138809, 0.39192276, 0.53138809, ..., 0.39192276, 0.53138809,\n", + " 0.39192276]), 'CapitalGain': array([0.42999849, 0.42999849, 0.42999849, ..., 0.42999849, 0.42999849,\n", + " 0.42999849]), 'CapitalLoss': array([0.4743547, 0.4743547, 0.4743547, ..., 0.4743547, 0.4743547,\n", + " 0.4743547]), 'HoursPerWeek': array([0.52241507, 0.57260521, 0.26002657, ..., 0.57260521, 0.63487309,\n", + " 0.52241507]), 'NativeCountry': array([0.44234036, 0.526976 , 0.35107406, ..., 0.526976 , 0.526976 ,\n", + " 0.526976 ])}\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "For convenience, we can also make a nice plot of the feature contributions:" + ], + "metadata": { + "id": "7QKz9FlU5iSF" + } + }, + { + "cell_type": "code", + "source": [ + "##\n", + "## Individual prediction for which we want to get more information\n", + "## about the how the features contribute to the final result\n", + "##\n", + "prediction_index = 12\n", + "\n", + "# Number of variables\n", + "num_vars = len(feature_contributions)\n", + "\n", + "# set a new baseline at 0.5: for classification, all feature contributions are centered around 0.5\n", + "baseline = 0.5\n", + "\n", + "variables = []\n", + "values = []\n", + "\n", + "for key, value in feature_contributions.items():\n", + " variables.append(key)\n", + " value = value[prediction_index] - baseline\n", + " values.append(value)\n", + "\n", + "threshold = 0.5 - baseline\n", + "colors = ['orange' if value > threshold else 'blue' for value in values]\n", + "\n", + "\n", + "# Create figure and axis objects\n", + "fig, ax = plt.subplots()\n", + "\n", + "# Generate positions for each bar (one row per variable)\n", + "positions = np.arange(num_vars)\n", + "\n", + "# Create bars\n", + "bars = ax.barh(positions, values, align='center', color=colors)\n", + "\n", + "# Add labels to the y-axis\n", + "ax.set_yticks(positions)\n", + "ax.set_yticklabels(variables)\n", + "\n", + "# Label x-axis and title\n", + "ax.set_xlabel('Values')\n", + "ax.set_title('Feature Contributions for Individual Predictions')\n", + "\n", + "\n", + "# now some \"magic\" to shift the axis label, etc to the appropriate place\n", + "# add vertical line, etc.\n", + "\n", + "# Set x-axis limits to ensure proper centering around 1 with range from -1 to +1 (relative to baseline)\n", + "ax.set_xlim(-1, 1)\n", + "\n", + "# Set x-axis labels\n", + "range = np.arange(-0.5, 1, step=0.5)\n", + "ax.set_xticks(range)\n", + "range = range + baseline\n", + "ax.set_xticklabels([str(i) for i in range])\n", + "\n", + "# Add a vertical line at x=0 to represent the baseline at value of the baseline after adjustment\n", + "ax.axvline(x=0, color='black', linewidth=0.8)\n", + "\n", + "\n", + "# Show the plot\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "O7P2iSh-6oSW", + "outputId": "2a38bc80-51fd-42b5-f1e9-ee84e06503b4" + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnMAAAHHCAYAAADUA97wAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAex5JREFUeJzt3XlcTun/P/DX3Xa33HWnRCGSFkXWZAnVYG5DfWrGyK5GtrFNQ5aGGRlMlmHs61AY+9hmMPayZF+yJkmpIcugO6FFnd8fvp2fW0VF6s7r+Xich851rnNd73OO0/3uOsstEQRBABERERGpJY2yDoCIiIiISo7JHBEREZEaYzJHREREpMaYzBERERGpMSZzRERERGqMyRwRERGRGmMyR0RERKTGmMwRERERqTEmc0RERERqjMkcEZUpKysr+Pv7i/Ph4eGQSCQ4e/bsR+nf3d0d7u7uH6WvktizZw8aNWoEXV1dSCQSpKamlnVIxZKYmAiJRILw8HCxLCQkBBKJpETtSSQShISEvLPe+/RRVJGRkZBIJIiMjCzVfj6EN8+z0oi9qMeGPjwmc6S28j70C5rGjRtXKn0eP34cISEh5foDNT4+HoMGDYK1tTV0dXVhZGQEV1dXzJ07Fy9evCi1fq9du4aQkBAkJiaWWh8lVZ5je5tHjx7B19cXenp6WLhwIdasWQMDA4NS6+9jJ9Kfijd/V+nq6sLOzg7Dhg3D/fv3yzq8Ytm9ezcTtnJIq6wDIHpfP//8M2rXrq1SVr9+/VLp6/jx45g0aRL8/f1hbGxcKn28j127dqFr166QSqXo27cv6tevj6ysLBw7dgyjR4/G1atXsWzZslLp+9q1a5g0aRLc3d1hZWVV5PViY2OhoVG6f1e+LbZ9+/aVat/v48yZM3j69CkmT56M9u3bl3U4H8yECRNK/AfXixcvoKWlnh9deb+rMjIycOzYMSxevBi7d+/GlStXoK+v/1Fjadu2LV68eAEdHZ1irbd7924sXLiwwIROnY+NuuNeJ7X3xRdfwNnZuazDeC/Pnj177xGXhIQEdO/eHbVq1cKhQ4dgYWEhLhs6dChu3ryJXbt2vW+oH4QgCMjIyICenh6kUmmZxlLcD7OP6cGDBwDwQf9w+BD/196XlpZWiT/0dXV1P3A0H8/rv6v69+8PU1NTzJ49Gzt27ECPHj0KXKe0jpeGhsYH35fqfGzUHS+zUoX3zz//oE2bNjAwMIChoSE6d+6Mq1evqtS5dOkS/P39xUuT5ubm6NevHx49eiTWCQkJwejRowEAtWvXFi+ZJCYmFnhfUJ437yPJu5fn2rVr6NmzJypVqoTWrVuLy//44w80bdoUenp6MDExQffu3ZGcnPzO7ZwxYwbS09OxYsUKlUQuj42NDb777jtx/uXLl5g8eTLq1KkDqVQKKysr/PDDD8jMzFRZz8rKCp6enjh27BhcXFygq6sLa2trrF69WqwTHh6Orl27AgA8PDzEfZN3P05eG3v37oWzszP09PSwdOlScdnr9/Lkef78OQYNGgRTU1MYGRmhb9++ePLkyVv37esx57X5rtgKumfuwYMHCAgIQNWqVaGrq4uGDRti1apVKnXyjvmvv/6KZcuWifuxWbNmOHPmjErde/fu4ZtvvkGNGjUglUphYWEBb2/vt172dXd3h5+fHwCgWbNmkEgkKvtp8+bN4v+TypUro3fv3rhz545KG/7+/pDJZIiPj0enTp1gaGiIXr16FdpnQfLauHPnDnx8fCCTyWBmZoagoCDk5OSo1E1NTYW/vz/kcjmMjY3h5+dX4C0Jb97PVr9+fXh4eOSrl5ubi+rVq+Prr78Wywo65seOHUOzZs2gq6uLOnXqiP+3Xlecc/T27dsYMmQI7O3toaenB1NTU3Tt2vWDX6b/7LPPALz6Qwx4+/HKzc3FnDlzUK9ePejq6qJq1aoYNGhQvnNCEARMmTIFNWrUgL6+Pjw8PPL9vgMKv2fu1KlT6NSpEypVqgQDAwM0aNAAc+fOFeNbuHAhAKhcNs5T0LG5cOECvvjiCxgZGUEmk6Fdu3Y4efKkSp28y9BRUVEYOXIkzMzMYGBggC+//BIPHz5UqXv27FkoFApUrlwZenp6qF27Nvr161eU3V2hcWSO1J5SqcR///2nUla5cmUAwJo1a+Dn5weFQoHp06fj+fPnWLx4MVq3bo0LFy6Il9z279+PW7du4ZtvvoG5ubl4OfLq1as4efIkJBIJvvrqK9y4cQPr16/Hb7/9JvZhZmaW7xdOUXTt2hW2trb45ZdfIAgCAGDq1Kn48ccf4evri/79++Phw4eYP38+2rZtiwsXLrx1hObvv/+GtbU1WrVqVaT++/fvj1WrVuHrr7/GqFGjcOrUKYSGhiImJgbbtm1TqXvz5k18/fXXCAgIgJ+fH1auXAl/f380bdoU9erVQ9u2bTFixAjMmzcPP/zwAxwcHABA/Bd4dTm1R48eGDRoEAYMGAB7e/u3xjds2DAYGxsjJCQEsbGxWLx4MW7fvi1+CBVVUWJ73YsXL+Du7o6bN29i2LBhqF27NjZv3gx/f3+kpqaqJMQAsG7dOjx9+hSDBg2CRCLBjBkz8NVXX+HWrVvQ1tYGAHTp0gVXr17F8OHDYWVlhQcPHmD//v1ISkoq9JL0+PHjYW9vj2XLlomX5+rUqQPg1YffN998g2bNmiE0NBT379/H3LlzERUVle//ycuXL6FQKNC6dWv8+uuvJbqcl5OTA4VCgebNm+PXX3/FgQMHMGvWLNSpUwfffvstgFdJhLe3N44dO4bBgwfDwcEB27ZtExPSt+nWrRtCQkJw7949mJubi+XHjh3D3bt30b1790LXvXz5Mj7//HOYmZkhJCQEL1++xMSJE1G1atVib2eeM2fO4Pjx4+jevTtq1KiBxMRELF68GO7u7rh27doHuyQaHx8PADA1NRXLCjtegwYNEo/7iBEjkJCQgAULFuDChQuIiooS/6/99NNPmDJlCjp16oROnTrh/Pnz+Pzzz5GVlfXOePbv3w9PT09YWFjgu+++g7m5OWJiYrBz50589913GDRoEO7evYv9+/djzZo172zv6tWraNOmDYyMjDBmzBhoa2tj6dKlcHd3x+HDh9G8eXOV+sOHD0elSpUwceJEJCYmYs6cORg2bBg2btwI4NUfWXnHety4cTA2NkZiYiK2bt1atB1ekQlEaiosLEwAUOAkCILw9OlTwdjYWBgwYIDKevfu3RPkcrlK+fPnz/O1v379egGAcOTIEbFs5syZAgAhISFBpW5CQoIAQAgLC8vXDgBh4sSJ4vzEiRMFAEKPHj1U6iUmJgqamprC1KlTVcovX74saGlp5St/nVKpFAAI3t7ehdZ5XXR0tABA6N+/v0p5UFCQAEA4dOiQWFarVq18++HBgweCVCoVRo0aJZZt3rxZACBERETk6y+vjT179hS4zM/PT5zPO65NmzYVsrKyxPIZM2YIAIQdO3aIZW/u28LafFtsbm5ugpubmzg/Z84cAYDwxx9/iGVZWVlCy5YtBZlMJqSlpQmC8P+PuampqfD48WOx7o4dOwQAwt9//y0IgiA8efJEACDMnDkzX9/vkrcvzpw5oxJLlSpVhPr16wsvXrwQy3fu3CkAEH766SexzM/PTwAgjBs3rsT95bXx888/q9Rt3Lix0LRpU3F++/btAgBhxowZYtnLly+FNm3a5Ds38s6BPLGxsQIAYf78+Sp9DBkyRJDJZCrn55vH3MfHR9DV1RVu374tll27dk3Q1NRU6aM452hBvw9OnDghABBWr14tlkVERBT6/+p1efv1wIEDwsOHD4Xk5GRhw4YNgqmpqaCnpyf8+++/giAUfryOHj0qABDWrl2rUr5nzx6V8gcPHgg6OjpC586dhdzcXLHeDz/8IABQOSfejP3ly5dC7dq1hVq1aglPnjxR6ef1toYOHaqyX19X0LHR0dER4uPjxbK7d+8KhoaGQtu2bfPtn/bt26v09f333wuamppCamqqIAiCsG3btnz/P+kVXmYltbdw4ULs379fZQJe/ZWZmpqKHj164L///hMnTU1NNG/eHBEREWIbenp64s8ZGRn477//0KJFCwDA+fPnSyXuwYMHq8xv3boVubm58PX1VYnX3Nwctra2KvG+KS0tDQBgaGhYpL53794NABg5cqRK+ahRowAg3711jo6OaNOmjThvZmYGe3t73Lp1q0j9Aa8uTSsUiiLXHzhwoDjaAADffvsttLS0xNhLy+7du2Fubq5yD5O2tjZGjBiB9PR0HD58WKV+t27dUKlSJXE+bz/l7Rs9PT3o6OggMjIy3yWxkjh79iwePHiAIUOGqNyj1LlzZ9StW7fA+yLzRs/ex5v/X9u0aaNy/Hfv3g0tLS2VvjQ1NTF8+PB3tm1nZ4dGjRqJIzDAq9HAP//8E15eXirn5+tycnKwd+9e+Pj4oGbNmmK5g4NDsf6vven1/rKzs/Ho0SPY2NjA2Nj4vX4ftG/fHmZmZrC0tET37t0hk8mwbds2VK9eXaXem8dr8+bNkMvl6NChg8rvhqZNm0Imk4m/Gw4cOICsrCwMHz5cZfQ6MDDwnbFduHABCQkJCAwMzHcFoCSveMnJycG+ffvg4+MDa2trsdzCwgI9e/bEsWPHxN9beQYOHKjSV5s2bZCTk4Pbt28D+P/3ju7cuRPZ2dnFjqki42VWUnsuLi4FPgARFxcH4P/fl/ImIyMj8efHjx9j0qRJ2LBhg3jTeR6lUvkBo/3/3nwCNy4uDoIgwNbWtsD6ryc2b8rblqdPnxap79u3b0NDQwM2NjYq5ebm5jA2NhZ/eeZ5/YMyT6VKlYqVnLy5ve/y5n6QyWSwsLAo9deL3L59G7a2tvmesM27LPuufZOX2OXtG6lUiunTp2PUqFGoWrUqWrRoAU9PT/Tt21flkmJx4gNQ4GXqunXr4tixYyplWlpaqFGjRrH7eZ2uri7MzMxUyt48/rdv34aFhQVkMplKvXddTs/TrVs3/PDDD7hz5w6qV6+OyMhIPHjwAN26dSt0nYcPH+LFixcFnjP29vYlTvxfvHiB0NBQhIWF4c6dO+JtEMD7/T5YuHAh7OzsoKWlhapVq8Le3j7f/7OCjldcXByUSiWqVKlSYLt5v7Py/m+8uT/MzMxU/uAoSN4l3w/1JoCHDx/i+fPnBR5/BwcH5ObmIjk5GfXq1RPL33Uuubm5oUuXLpg0aRJ+++03uLu7w8fHBz179izzB6nKGpM5qrByc3MBvLpvrqAPzdefpvP19cXx48cxevRoNGrUCDKZDLm5uejYsaPYztsU9pfrmzeIv+7N0Ybc3FxIJBL8888/0NTUzFf/zQ/J1xkZGaFatWq4cuXKO2N9XVH/4i4oHgAqH3LvUtjoSml4237/0IqybwIDA+Hl5YXt27dj7969+PHHHxEaGopDhw6hcePGpRqfVCp971e/FLaNH1K3bt0QHByMzZs3IzAwEJs2bYJcLkfHjh0/SPvFOUeHDx+OsLAwBAYGomXLlpDL5ZBIJOjevXuRfh8UprA/PF9X0PHKzc1FlSpVsHbt2gLXeTPRVlfvOpckEgn+/PNPnDx5En///Tf27t2Lfv36YdasWTh58uRbf0dWdEzmqMLKu1m8SpUqb31H15MnT3Dw4EFMmjQJP/30k1ieN7L3usI+EPL+gnzzyb03R3HeFa8gCKhduzbs7OyKvF4eT09PLFu2DCdOnEDLli3fWrdWrVrIzc1FXFycyoMA9+/fR2pqKmrVqlXs/j/02/bj4uJUnnBMT09HSkoKOnXqJJZVqlQp3z7PyspCSkpKiWOrVasWLl26hNzcXJUP1evXr4vLS6JOnToYNWoURo0ahbi4ODRq1AizZs3CH3/8Uax28vqPjY3NN+ocGxtb4vjeV61atXDw4EGkp6erfKjGxsYWaf3atWvDxcUFGzduxLBhw7B161b4+Pi8dcTFzMwMenp6BZ6rb/ZbnHP0zz//hJ+fH2bNmiWWZWRklNnLwuvUqYMDBw7A1dX1rX8U5R37uLg4lUubDx8+fOcoet7vyytXrrz192VRzyUzMzPo6+sXePyvX78ODQ0NWFpaFqmtN7Vo0QItWrTA1KlTsW7dOvTq1QsbNmxA//79S9ReRcB75qjCUigUMDIywi+//FLg/RV5T6Dm/TX45ijTnDlz8q2T976nN3+pGxkZoXLlyjhy5IhK+aJFi4oc71dffQVNTU1MmjQpXyyCIKi8JqUgY8aMgYGBAfr371/gW+Xj4+PFVwzkJURvbuPs2bMBvLr/qrgK2zcltWzZMpXjtnjxYrx8+RJffPGFWFanTp18+3zZsmX5RluKE1unTp1w7949lfu3Xr58ifnz50Mmk8HNza1Y2/H8+XNkZGSolNWpUweGhob5XgNTFM7OzqhSpQqWLFmisv4///yDmJiYEh27D6FTp054+fIlFi9eLJbl5ORg/vz5RW6jW7duOHnyJFauXIn//vvvrZdYgVfnrkKhwPbt25GUlCSWx8TEYO/evSp1i3OOampq5jsH58+f/1FHfF/n6+uLnJwcTJ48Od+yly9fiv+v27dvD21tbcyfP18l/oJ+l72pSZMmqF27NubMmZPvPHm9raKeS5qamvj888+xY8cOlVsj7t+/j3Xr1qF169Yqt7oUxZMnT/Idl0aNGgFAic6lioQjc1RhGRkZYfHixejTpw+aNGmC7t27w8zMDElJSdi1axdcXV2xYMECGBkZoW3btpgxYways7NRvXp17Nu3T3z30+uaNm0K4NVrI7p37w5tbW14eXmJSdS0adPQv39/ODs748iRI7hx40aR461Tpw6mTJmC4OBgJCYmwsfHB4aGhkhISMC2bdswcOBABAUFvXX9devWoVu3bnBwcFD5Bojjx4+Lr9cAgIYNG8LPzw/Lli1Damoq3NzccPr0aaxatQo+Pj4FvvPrXRo1agRNTU1Mnz4dSqUSUqkUn332WaH3+bxLVlYW2rVrB19fX8TGxmLRokVo3bo1/ve//4l1+vfvj8GDB6NLly7o0KEDLl68iL1794qvjSlJbAMHDsTSpUvh7++Pc+fOwcrKCn/++SeioqIwZ86cIj9kkufGjRvidjg6OkJLSwvbtm3D/fv33/rKjcJoa2tj+vTp+Oabb+Dm5oYePXqIryaxsrLC999/X+w2PwQvLy+4urpi3LhxSExMhKOjI7Zu3Vqse8x8fX0RFBSEoKAgmJiYFOlbLyZNmoQ9e/agTZs2GDJkiJh416tXD5cuXVKpW9Rz1NPTE2vWrIFcLoejoyNOnDiBAwcOqLxC5GNyc3PDoEGDEBoaiujoaHz++efQ1tZGXFwcNm/ejLlz5+Lrr78W3/8XGhoKT09PdOrUCRcuXMA///yT75x4k4aGBhYvXgwvLy80atQI33zzDSwsLHD9+nVcvXpVTI7zfgeOGDECCoUCmpqahf4/njJlCvbv34/WrVtjyJAh0NLSwtKlS5GZmYkZM2YUez+sWrUKixYtwpdffok6derg6dOnWL58OYyMjFRG7D9JZfIMLdEHUNBrFAoSEREhKBQKQS6XC7q6ukKdOnUEf39/4ezZs2Kdf//9V/jyyy8FY2NjQS6XC127dhXu3r1b4KsvJk+eLFSvXl3Q0NBQeU3J8+fPhYCAAEEulwuGhoaCr6+v8ODBg0JfTfLw4cMC492yZYvQunVrwcDAQDAwMBDq1q0rDB06VIiNjS3Sfrlx44YwYMAAwcrKStDR0REMDQ0FV1dXYf78+UJGRoZYLzs7W5g0aZJQu3ZtQVtbW7C0tBSCg4NV6gjCq9d8dO7cOV8/b77SQxAEYfny5YK1tbX4Woi81x4U1kbesoJeTXL48GFh4MCBQqVKlQSZTCb06tVLePTokcq6OTk5wtixY4XKlSsL+vr6gkKhEG7evJmvzbfFVtB23L9/X/jmm2+EypUrCzo6OoKTk1O+V1rkveqioFeOvH7M//vvP2Ho0KFC3bp1BQMDA0EulwvNmzcXNm3aVOD+eN3b/o9v3LhRaNy4sSCVSgUTExOhV69e4isu8vj5+QkGBgbv7Odt/RXWxpuvFxEEQXj06JHQp08fwcjISJDL5UKfPn2ECxcuvPPVJK9zdXUt8LU5eQo6Jw8fPiw0bdpU0NHREaytrYUlS5YU2EdRz9EnT56Ix18mkwkKhUK4fv16vv9XxX01ybt+V73reC1btkxo2rSpoKenJxgaGgpOTk7CmDFjhLt374p1cnJyhEmTJgkWFhaCnp6e4O7uLly5cqXIsR87dkzo0KGDYGhoKBgYGAgNGjRQeWXMy5cvheHDhwtmZmaCRCJR2ccFHZvz588LCoVCkMlkgr6+vuDh4SEcP368SPvnzRjPnz8v9OjRQ6hZs6YglUqFKlWqCJ6eniq/yz9VEkEoxh3MRERERFSu8J45IiIiIjXGZI6IiIhIjTGZIyIiIlJjTOaIiIiI1BiTOSIiIiI1xmSOiIiISI3xpcGfgNzcXNy9exeGhoYf/CuXiIiIqHQIgoCnT5+iWrVqb/2OZSZzn4C7d++W+DvwiIiIqGwlJyejRo0ahS5nMvcJyPv6oeTk5GJ/Fx4RlW9paWmwtLTk+U1UAeWd3+/6GkEmc5+AvEurRkZG/GVPVEHx/CaquN51ixQfgCAiIiJSY0zmiIiIiNQYkzkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5oiIiIjUGJM5IiIiIjXGZI6IiIhIjTGZIyIiIlJjTOaIiIiI1BiTOSIiIiI1xmSOiIiISI0xmSMiIiJSY0zmiIiIiNSYVlkHQEREH8AmOaD/RllPoUxCIaKPiyNzRERERGqMyRwRERGRGmMyR0RERKTGyl0yFxkZCYlEgtTU1LIOhYiIiKjcK1Ey5+/vD4lEgmnTpqmUb9++HRKJpMjtuLu7IzAwUKWsVatWSElJgVwuL0lohUpLS8P48eNRt25d6OrqwtzcHO3bt8fWrVshCB/3JmErKyvMmTPno/ZJREREFVOJR+Z0dXUxffp0PHny5EPGAx0dHZibmxcrKXyX1NRUtGrVCqtXr0ZwcDDOnz+PI0eOoFu3bhgzZgyUSuUH6+tDycnJQW5ublmHQUREROVciZO59u3bw9zcHKGhoQUuf/ToEXr06IHq1atDX18fTk5OWL9+vbjc398fhw8fxty5cyGRSCCRSJCYmKhymTUtLQ16enr4559/VNretm0bDA0N8fz5cwBAcnIyfH19YWxsDBMTE3h7eyMxMVGs/8MPPyAxMRGnTp2Cn58fHB0dYWdnhwEDBiA6OhoymQwA8OTJE/Tt2xeVKlWCvr4+vvjiC8TFxYnthISEoFGjRiqxzJkzB1ZWVirb5ePjg19//RUWFhYwNTXF0KFDkZ2dDeDVaOTt27fx/fffi9sNAOHh4TA2NsZff/0FR0dHSKVSHDt2DNra2rh3755Kn4GBgWjTpk0RjhIRERFVdCVO5jQ1NfHLL79g/vz5+Pfff/Mtz8jIQNOmTbFr1y5cuXIFAwcORJ8+fXD69GkAwNy5c9GyZUsMGDAAKSkpSElJgaWlpUobRkZG8PT0xLp161TK165dCx8fH+jr6yM7OxsKhQKGhoY4evQooqKiIJPJ0LFjR2RlZSE3NxcbNmxAr169UK1atXxxymQyaGm9et2ev78/zp49i7/++gsnTpyAIAjo1KmTmIgVVUREBOLj4xEREYFVq1YhPDwc4eHhAICtW7eiRo0a+Pnnn8XtzvP8+XNMnz4dv//+O65evQpnZ2dYW1tjzZo1Yp3s7GysXbsW/fr1K1ZMREREVDG91wMQX375JRo1aoSJEyfmW1a9enUEBQWhUaNGsLa2xvDhw9GxY0ds2rQJACCXy6GjowN9fX2Ym5vD3Nwcmpqa+drp1asXtm/fLo7CpaWlYdeuXejVqxcAYOPGjcjNzcXvv/8OJycnODg4ICwsDElJSYiMjMR///2HJ0+eoG7dum/dlri4OPz111/4/fff0aZNGzRs2BBr167FnTt3sH379mLtl0qVKmHBggWoW7cuPD090blzZxw8eBAAYGJiAk1NTRgaGorbnSc7OxuLFi1Cq1atYG9vD319fQQEBCAsLEys8/fffyMjIwO+vr6F9p+ZmYm0tDSViYiIiCqm936adfr06Vi1ahViYmJUynNycjB58mQ4OTnBxMQEMpkMe/fuRVJSUrHa79SpE7S1tfHXX38BALZs2QIjIyO0b98eAHDx4kXcvHkThoaGkMlkkMlkMDExQUZGBuLj44v8cENMTAy0tLTQvHlzsczU1BT29vb5tu1d6tWrp5KYWlhY4MGDB+9cT0dHBw0aNFAp8/f3x82bN3Hy5EkAry7H+vr6wsDAoNB2QkNDIZfLxenNEU8iIiKqON47mWvbti0UCgWCg4NVymfOnIm5c+di7NixiIiIQHR0NBQKBbKysorVvo6ODr7++mvxUuu6devQrVs38dJoeno6mjZtiujoaJXpxo0b6NmzJ8zMzGBsbIzr16+/76ZCQ0MjX3JY0CVYbW1tlXmJRFKkhxn09PTyPfhRpUoVeHl5ISwsDPfv38c///zzzkuswcHBUCqV4pScnPzOvomIiEg9fZDvZp02bRoaNWoEe3t7sSwqKgre3t7o3bs3ACA3Nxc3btyAo6OjWEdHRwc5OTnvbL9Xr17o0KEDrl69ikOHDmHKlCnisiZNmmDjxo2oUqUKjIyMCly/e/fuWLNmDSZOnJjvvrn09HTo6urCwcEBL1++xKlTp9CqVSsArx7iiI2NFWM2MzPDvXv3IAiCmHRFR0cXYQ+pKup25+nfvz969OiBGjVqoE6dOnB1dX1rfalUCqlUWuy4iIiISP18kJcGOzk5oVevXpg3b55YZmtri/379+P48eOIiYnBoEGDcP/+fZX1rKyscOrUKSQmJuK///4rdPSqbdu2MDc3R69evVC7dm2VS6G9evVC5cqV4e3tjaNHjyIhIQGRkZEYMWKE+GDG1KlTYWlpiebNm2P16tW4du0a4uLisHLlSjRu3Bjp6emwtbWFt7c3BgwYgGPHjuHixYvo3bs3qlevDm9vbwCvnkR9+PAhZsyYgfj4eCxcuDDfk7ZFYWVlhSNHjuDOnTv477//3llfoVDAyMgIU6ZMwTfffFPs/oiIiKji+mDfAPHzzz+rJGMTJkxAkyZNoFAo4O7uDnNzc/j4+KisExQUBE1NTTg6OsLMzKzQ++kkEgl69OiBixcvig8+5NHX18eRI0dQs2ZNfPXVV3BwcEBAQAAyMjLEkToTExOcPHkSvXv3xpQpU9C4cWO0adMG69evx8yZM8UXFIeFhaFp06bw9PREy5YtIQgCdu/eLV42dXBwwKJFi7Bw4UI0bNgQp0+fRlBQUIn2VWJiIurUqQMzM7N31tfQ0IC/vz9ycnLQt2/fYvdHREREFZdE+Nhff0AlEhAQgIcPH4oPghRHWloa5HI5lEploZeiiUg9ief3csBI/42FPfnrnUidFfXz+4PcM0elR6lU4vLly1i3bl2JEjkiIiKq2JjMlXPe3t44ffo0Bg8ejA4dOpR1OERERFTOMJkr5yIjI8s6BCIiIirHmMwREVUEvkqA98QSfZI+2NOsRERERPTxMZkjIiIiUmNM5oiIiIjUGJM5IiIiIjXGByCIiCqCTXLgzZcGlxW+rJjoo+LIHBEREZEaYzJHREREpMaYzBERERGpMSZzRERERGqMyVw5lpiYCIlEgujo6LIOhYiIiMqpYidz/v7+8PHxyVceGRkJiUSC1NTUDxBWyeQlP3mTqakpPv/8c1y4cOG92m3RogUGDx6sUrZkyRJIJBKEh4erlPv7+6NNmzbv1R8RERFRUanVyFx2dnaR6h04cAApKSnYu3cv0tPT8cUXX5Q4yczKyoKHh0e+L7yPiIiApaVlvvLIyEh89tlnJeqLiIiIqLhKLZnbsmUL6tWrB6lUCisrK8yaNUtluUQiwfbt21XKjI2NxZGuvFG2jRs3ws3NDbq6uli7di1u374NLy8vVKpUCQYGBqhXrx52796t0o6pqSnMzc3h7OyMX3/9Fffv38epU6cAAMeOHUObNm2gp6cHS0tLjBgxAs+ePRPXtbKywuTJk9G3b18YGRlh4MCB8PDwQGxsLO7duyfWO3z4MMaNG6eSzCUkJOD27dvw8PAAACQnJ8PX1xfGxsYwMTGBt7c3EhMTVWL9/fff4eDgAF1dXdStWxeLFi0qdJ/m5OSgX79+qFu3LpKSkt66/4mIiOjTUCrJ3Llz5+Dr64vu3bvj8uXLCAkJwY8//pjvkmRRjBs3Dt999x1iYmKgUCgwdOhQZGZm4siRI7h8+TKmT58OmUxW6Pp6enoAXo2wxcfHo2PHjujSpQsuXbqEjRs34tixYxg2bJjKOr/++isaNmyICxcu4Mcff4Srqyu0tbUREREBALh27RpevHiBgIAAPHr0CAkJCQBejdbp6uqiZcuWyM7OhkKhgKGhIY4ePYqoqCjIZDJ07NgRWVlZAIC1a9fip59+wtSpUxETE4NffvkFP/74I1atWpVvOzIzM9G1a1dER0fj6NGjqFmzZqHbnJmZibS0NJWJiIiIKqYSfQPEzp078yVQOTk54s+zZ89Gu3bt8OOPPwIA7OzscO3aNcycORP+/v7F6iswMBBfffWVOJ+UlIQuXbrAyckJAGBtbV3ouqmpqZg8eTJkMhlcXFwwfvx49OrVC4GBgQAAW1tbzJs3D25ubli8eDF0dXUBAJ999hlGjRql0paLiwsiIyPRo0cPREZGonXr1pBKpWjVqhUiIyNRu3ZtREZGomXLlpBKpfjjjz+Qm5uL33//HRKJBAAQFhYGY2NjREZG4vPPP8fEiRMxa9Yscftq166Na9euYenSpfDz8xP7Tk9PR+fOnZGZmYmIiAjI5fK37rPQ0FBMmjSpiHuYiIiI1FmJRuY8PDwQHR2tMv3+++/i8piYGLi6uqqs4+rqiri4OJWkryicnZ1V5keMGIEpU6bA1dUVEydOxKVLl/Kt06pVK8hkMlSqVAkXL17Exo0bUbVqVVy8eBHh4eGQyWTipFAokJubK46uFdQnALi7u4uXVCMjI+Hu7g4AcHNzUynPu8R68eJF3Lx5E4aGhmJfJiYmyMjIQHx8PJ49e4b4+HgEBASoxDNlyhTEx8er9N2jRw88e/YM+/bte2ciBwDBwcFQKpXilJyc/M51iIiISD2VaGTOwMAANjY2KmX//vtvsdqQSCQQBNXv7yvoAQcDAwOV+f79+0OhUGDXrl3Yt28fQkNDMWvWLAwfPlyss3HjRjg6OsLU1BTGxsZieXp6OgYNGoQRI0bk6+f1y5Zv9gm8SmCnTp2KO3fuIDIyEkFBQQBeJXNLly5FfHw8kpOTxYcf0tPT0bRpU6xduzZfW2ZmZkhPTwcALF++HM2bN1dZrqmpqTLfqVMn/PHHHzhx4kSRHq6QSqWQSqXvrEdERETqr0TJ3Ls4ODggKipKpSwqKgp2dnZiomJmZoaUlBRxeVxcHJ4/f16k9i0tLTF48GAMHjwYwcHBWL58uUoyZ2lpiTp16uRbr0mTJrh27Vq+RLQoWrVqBR0dHSxatAgZGRlo2rQpAKBZs2Z4+PAhVq5cCQMDA7i4uIh9bdy4EVWqVIGRkVG+9uRyOapVq4Zbt26hV69eb+3722+/Rf369fG///0Pu3btgpubW7HjJyIiooqpVB6AGDVqFA4ePIjJkyfjxo0bWLVqFRYsWCCOZgGv7ktbsGABLly4gLNnz2Lw4MHQ1tZ+Z9uBgYHYu3cvEhIScP78eURERMDBwaFIcY0dOxbHjx/HsGHDEB0djbi4OOzYsSPfAxAF0dPTQ4sWLTB//ny4urqKSamOjo5Ked429OrVC5UrV4a3tzeOHj2KhIQEREZGYsSIEeIo5qRJkxAaGop58+bhxo0buHz5MsLCwjB79ux8/Q8fPhxTpkyBp6cnjh07VqTtJSIiooqvVJK5Jk2aYNOmTdiwYQPq16+Pn376CT///LPKww+zZs2CpaUl2rRpg549eyIoKAj6+vrvbDsnJwdDhw6Fg4MDOnbsCDs7u7e+zuN1DRo0wOHDh3Hjxg20adMGjRs3xk8//YRq1aoVaX0PDw88ffpUvF8uj5ubG54+fSreLwcA+vr6OHLkCGrWrImvvvoKDg4OCAgIQEZGhjhS179/f/z+++8ICwuDk5MT3NzcEB4ejtq1axfYf2BgICZNmoROnTrh+PHjRYqZiIiIKjaJ8OaNa1ThpKWlQS6XQ6lUFnjJl4jUl3h+LweM3v338MfRkx8rRB9CUT+/1eobIIiIiIhIFZM5IiIiIjXGZI6IiIhIjZXKq0mIiOgj81UCvCeW6JPEkTkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5oiIiIjUGB+AICJSAxJJWUdAROUVR+aIiIiI1BiTOSIiIiI1xmSOiIiISI19cslcSEgIGjVqVG7aISIiInof5SqZu3fvHoYPHw5ra2tIpVJYWlrCy8sLBw8e/GB9BAUFqbTn7+8PHx+f926XyR0RERGVhXLzNGtiYiJcXV1hbGyMmTNnwsnJCdnZ2di7dy+GDh2K69evf5B+ZDIZZDLZB2mLiIiIqKyVm5G5IUOGQCKR4PTp0+jSpQvs7OxQr149jBw5EidPngQAzJ49G05OTjAwMIClpSWGDBmC9PR0sY3w8HAYGxtj+/btsLW1ha6uLhQKBZKTk8U6r4+ghYSEYNWqVdixYwckEgkkEgkiIyMBAGPHjoWdnR309fVhbW2NH3/8EdnZ2SXevsuXL+Ozzz6Dnp4eTE1NMXDgQJXYIyMj4eLiAgMDAxgbG8PV1RW3b98GAFy8eBEeHh4wNDSEkZERmjZtirNnz5Y4FiIiIqo4ykUy9/jxY+zZswdDhw6FgYFBvuXGxsYAAA0NDcybNw9Xr17FqlWrcOjQIYwZM0al7vPnzzF16lSsXr0aUVFRSE1NRffu3QvsNygoCL6+vujYsSNSUlKQkpKCVq1aAQAMDQ0RHh6Oa9euYe7cuVi+fDl+++23Em3fs2fPoFAoUKlSJZw5cwabN2/GgQMHMGzYMADAy5cv4ePjAzc3N1y6dAknTpzAwIEDIfm/F0v16tULNWrUwJkzZ3Du3DmMGzcO2trahfaXmZmJtLQ0lYmIiIgqpnJxmfXmzZsQBAF169Z9a73AwEDxZysrK0yZMgWDBw/GokWLxPLs7GwsWLAAzZs3BwCsWrUKDg4OOH36NFxcXFTak8lk0NPTQ2ZmJszNzVWWTZgwQaWvoKAgbNiwIV/yWBTr1q1DRkYGVq9eLSarCxYsgJeXF6ZPnw5tbW0olUp4enqiTp06AAAHBwdx/aSkJIwePVrcP7a2tm/tLzQ0FJMmTSp2nERERKR+ysXInCAIRap34MABtGvXDtWrV4ehoSH69OmDR48e4fnz52IdLS0tNGvWTJyvW7cujI2NERMTU6yYNm7cCFdXV5ibm0Mmk2HChAlISkoqVht5YmJi0LBhQ5VRR1dXV+Tm5iI2NhYmJibw9/eHQqGAl5cX5s6di5SUFLHuyJEj0b9/f7Rv3x7Tpk1DfHz8W/sLDg6GUqkUp9cvMxMREVHFUi6SOVtbW0gkkrc+5JCYmAhPT080aNAAW7Zswblz57Bw4UIAQFZW1geN58SJE+jVqxc6deqEnTt34sKFCxg/fvwH7+d1YWFhOHHiBFq1aoWNGzfCzs5OvFcwJCQEV69eRefOnXHo0CE4Ojpi27ZthbYllUphZGSkMhEREVHFVC6SORMTEygUCixcuBDPnj3Ltzw1NRXnzp1Dbm4uZs2ahRYtWsDOzg53797NV/fly5cqDwfExsYiNTVV5bLl63R0dJCTk6NSdvz4cdSqVQvjx4+Hs7MzbG1txYcRSsLBwQEXL15U2baoqChoaGjA3t5eLGvcuDGCg4Nx/Phx1K9fH+vWrROX2dnZ4fvvv8e+ffvw1VdfISwsrMTxEBERUcVRLpI5AFi4cCFycnLg4uKCLVu2IC4uDjExMZg3bx5atmwJGxsbZGdnY/78+bh16xbWrFmDJUuW5GtHW1sbw4cPx6lTp3Du3Dn4+/ujRYsW+e6Xy2NlZYVLly4hNjYW//33H7Kzs2Fra4ukpCRs2LAB8fHxmDdv3ltHwvK8ePEC0dHRKlN8fDx69eoFXV1d+Pn54cqVK4iIiMDw4cPRp08fVK1aFQkJCQgODsaJEydw+/Zt7Nu3D3FxcXBwcMCLFy8wbNgwREZG4vbt24iKisKZM2cKTU6JiIjoEyOUI3fv3hWGDh0q1KpVS9DR0RGqV68u/O9//xMiIiIEQRCE2bNnCxYWFoKenp6gUCiE1atXCwCEJ0+eCIIgCGFhYYJcLhe2bNkiWFtbC1KpVGjfvr1w+/ZtsY+JEycKDRs2FOcfPHggdOjQQZDJZAIAsa/Ro0cLpqamgkwmE7p16yb89ttvglwuL7SdiRMnCgDyTe3atRMEQRAuXbokeHh4CLq6uoKJiYkwYMAA4enTp4IgCMK9e/cEHx8fwcLCQtDR0RFq1aol/PTTT0JOTo6QmZkpdO/eXbC0tBR0dHSEatWqCcOGDRNevHhR5P2qVCoFAIJSqSz6wSCicgUobOL5TVRRFfXzWyIIRXz6QA2Eh4cjMDAQqampZR1KuZKWlga5XA6lUsn754jU1P+9qagAaQB4fhNVREX9/C43l1mJiIiIqPiYzBERERGpsQqVzPn7+/MSKxEREX1SKlQyR0RUURX6+IOyrCMjorLGZI6IiIhIjTGZIyIiIlJjTOaIiIiI1BiTOSIiIiI1plXWARARfaoKfxEwEVHRcWSOiIiISI0xmSMiIiJSY0zmiIiIiNTYJ5XMhYSEoFGjRuWmnYJERkZCIpHwmyyIiIioSMpNMnfv3j0MHz4c1tbWkEqlsLS0hJeXFw4ePPjB+ggKClJpz9/fHz4+Ph+k7bS0NPz444+oV68e9PT0YGpqimbNmmHGjBl48uRJkdtp1aoVUlJSIJfLP0hcREREVLGVi6dZExMT4erqCmNjY8ycORNOTk7Izs7G3r17MXToUFy/fv2D9COTySCTyT5IW697/PgxWrdujbS0NEyePBlNmzaFXC5HbGwswsLCsG7dOgwdOrRIbeno6MDc3PyDx0hEREQVlFAOfPHFF0L16tWF9PT0fMuePHkiCIIgzJo1S6hfv76gr68v1KhRQ/j222+Fp0+fivXCwsIEuVwubNu2TbCxsRGkUqnw+eefC0lJSWKdiRMnCg0bNhR/BqAyRURECIIgCGPGjBFsbW0FPT09oXbt2sKECROErKysAtsRBEEYNGiQYGBgINy5c6fA7cvNzRV/Xr16tdC0aVNBJpMJVatWFXr06CHcv39fXB4RESEAELc7b7v27Nkj1K1bVzAwMBAUCoVw9+7dIu1bQRAEpVIpABCUSmWR1yGi0lf4N64WZ+L5TVRRFfXzu8wvsz5+/Bh79uzB0KFDYWBgkG+5sbExAEBDQwPz5s3D1atXsWrVKhw6dAhjxoxRqfv8+XNMnToVq1evRlRUFFJTU9G9e/cC+w0KCoKvry86duyIlJQUpKSkoFWrVgAAQ0NDhIeH49q1a5g7dy6WL1+O3377rcB2cnNzsXHjRvTu3RvVqlUrsI7ktZdJZWdnY/Lkybh48SK2b9+OxMRE+Pv7v3UfPX/+HL/++ivWrFmDI0eOICkpCUFBQW9dh4iIiD4NZX6Z9ebNmxAEAXXr1n1rvcDAQPFnKysrTJkyBYMHD8aiRYvE8uzsbCxYsADNmzcHAKxatQoODg44ffo0XFxcVNqTyWTQ09NDZmZmvsuaEyZMUOkrKCgIGzZsyJc8AsDDhw+RmpoKe3t7lfKmTZsiNjYWAODl5YX169cDAPr16yfWsba2xrx589CsWTOkp6cXegk4OzsbS5YsQZ06dQAAw4YNw88//1zwjgKQmZmJzMxMcT4tLa3QukRERKTeynxkThCEItU7cOAA2rVrh+rVq8PQ0BB9+vTBo0eP8Pz5c7GOlpYWmjVrJs7XrVsXxsbGiImJKVZMGzduhKurK8zNzSGTyTBhwgQkJSUVq41t27YhOjoaCoUCL168EMvPnTsHLy8v1KxZE4aGhnBzcwOAt7avr68vJnIAYGFhgQcPHhRaPzQ0FHK5XJwsLS2LFTsRERGpjzJP5mxtbSGRSN76kENiYiI8PT3RoEEDbNmyBefOncPChQsBAFlZWR80nhMnTqBXr17o1KkTdu7ciQsXLmD8+PGF9mNmZgZjY2NxFC5PzZo1YWNjA0NDQ7Hs2bNnUCgUMDIywtq1a3HmzBls27btnduhra2tMi+RSN6aBAcHB0OpVIpTcnLyO7ebiIiI1FOZJ3MmJiZQKBRYuHAhnj17lm95amoqzp07h9zcXMyaNQstWrSAnZ0d7t69m6/uy5cvcfbsWXE+NjYWqampcHBwKLBvHR0d5OTkqJQdP34ctWrVwvjx4+Hs7AxbW1vcvn270Pg1NDTg6+uLP/74o8CYXnf9+nU8evQI06ZNQ5s2bVC3bt23jrCVlFQqhZGRkcpEREREFVOZJ3MAsHDhQuTk5MDFxQVbtmxBXFwcYmJiMG/ePLRs2RI2NjbIzs7G/PnzcevWLaxZswZLlizJ1462tjaGDx+OU6dO4dy5c/D390eLFi3y3S+Xx8rKCpcuXUJsbCz+++8/ZGdnw9bWFklJSdiwYQPi4+Mxb948cfSsML/88guqV68OFxcXrFy5EpcuXUJ8fDy2bduGEydOQFNTE8Cr0TodHR1xO/766y9Mnjz5/XcgERERfbLKRTJnbW2N8+fPw8PDA6NGjUL9+vXRoUMHHDx4EIsXL0bDhg0xe/ZsTJ8+HfXr18fatWsRGhqarx19fX2MHTsWPXv2hKurK2QyGTZu3FhovwMGDIC9vT2cnZ1hZmaGqKgo/O9//8P333+PYcOGoVGjRjh+/Dh+/PHHt8ZvamqK06dPo2/fvpg5cyZcXFzg5OSEkJAQdOvWDcuXLwfw6pJseHg4Nm/eDEdHR0ybNg2//vrr++08IiIi+qRJhKI+gVDOhYeHIzAwkF+DVYC0tDTI5XIolUpeciUqR157a9F7SAPA85uoIirq53e5GJkjIiIiopJhMkdERESkxipMMufv789LrERERPTJKfNvgCAi+lR9iDuW09IAufz92yEi9VVhRuaIiIiIPkVM5oiIiIjUGJM5IiIiIjXGZI6IiIhIjfEBCCKiimCTHNAvoLxnhXgvPBG9BUfmiIiIiNQYkzkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5sqQu7s7AgMDyzoMIiIiUmOffDJ37949fPfdd7CxsYGuri6qVq0KV1dXLF68GM+fPy/r8IiIiIje6pN+NcmtW7fg6uoKY2Nj/PLLL3BycoJUKsXly5exbNkyVK9eHf/73//KOsxC5eTkQCKRQEPjk8/JiYiIPlmfdBYwZMgQaGlp4ezZs/D19YWDgwOsra3h7e2NXbt2wcvLCwCQmpqK/v37w8zMDEZGRvjss89w8eJFsZ2QkBA0atQIa9asgZWVFeRyObp3746nT5+KdZ49e4a+fftCJpPBwsICs2bNyhdPZmYmgoKCUL16dRgYGKB58+aIjIwUl4eHh8PY2Bh//fUXHB0dIZVKkZSUVHo7iIiIiMq9TzaZe/ToEfbt24ehQ4fCwMCgwDoSiQQA0LVrVzx48AD//PMPzp07hyZNmqBdu3Z4/PixWDc+Ph7bt2/Hzp07sXPnThw+fBjTpk0Tl48ePRqHDx/Gjh07sG/fPkRGRuL8+fMq/Q0bNgwnTpzAhg0bcOnSJXTt2hUdO3ZEXFycWOf58+eYPn06fv/9d1y9ehVVqlTJF3dmZibS0tJUJiIiIqqYPtnLrDdv3oQgCLC3t1cpr1y5MjIyMgAAQ4cOhZeXF06fPo0HDx5AKpUCAH799Vds374df/75JwYOHAgAyM3NRXh4OAwNDQEAffr0wcGDBzF16lSkp6djxYoV+OOPP9CuXTsAwKpVq1CjRg2x36SkJISFhSEpKQnVqlUDAAQFBWHPnj0ICwvDL7/8AgDIzs7GokWL0LBhw0K3LTQ0FJMmTfoQu4mIiIjKuU82mSvM6dOnkZubi169eiEzMxMXL15Eeno6TE1NVeq9ePEC8fHx4ryVlZWYyAGAhYUFHjx4AODVqF1WVhaaN28uLjcxMVFJJC9fvoycnBzY2dmp9JOZmanSt46ODho0aPDWbQgODsbIkSPF+bS0NFhaWhZl84mIiEjNfLLJnI2NDSQSCWJjY1XKra2tAQB6enoAgPT0dFhYWKjcu5bH2NhY/FlbW1tlmUQiQW5ubpHjSU9Ph6amJs6dOwdNTU2VZTKZTPxZT09PvPxbGKlUKo4iEhERUcX2ySZzpqam6NChAxYsWIDhw4cXet9ckyZNcO/ePWhpacHKyqpEfdWpUwfa2to4deoUatasCQB48uQJbty4ATc3NwBA48aNkZOTgwcPHqBNmzYl6oeIiIg+PZ/sAxAAsGjRIrx8+RLOzs7YuHEjYmJiEBsbiz/++APXr1+HpqYm2rdvj5YtW8LHxwf79u1DYmIijh8/jvHjx+Ps2bNF6kcmkyEgIACjR4/GoUOHcOXKFfj7+6u8UsTOzg69evVC3759sXXrViQkJOD06dMIDQ3Frl27SmsXEBERkZr7ZEfmgFcjZhcuXMAvv/yC4OBg/Pvvv5BKpXB0dERQUBCGDBkCiUSC3bt3Y/z48fjmm2/w8OFDmJubo23btqhatWqR+5o5cybS09Ph5eUFQ0NDjBo1CkqlUqVOWFgYpkyZglGjRuHOnTuoXLkyWrRoAU9Pzw+96URERFRBSARBEMo6CCpdaWlpkMvlUCqVMDIyKutwiOgDEs/v5YCRfgEVevJXPJG6Kurn9yd9mZWIiIhI3TGZIyIiIlJjTOaIiIiI1Ngn/QAEEVGF4asEeE8s0SeJI3NEREREaozJHBEREZEaYzJHREREpMaYzBERERGpMT4AQURUEWySAwW9NBjgi4OJKjiOzBERERGpMSZzRERERGqMyRwRERGRGmMyR0RERKTGmMy9B39/f0gkEkgkEmhra6N27doYM2YMMjIyyjo0IiIi+kTwadb31LFjR4SFhSE7Oxvnzp2Dn58fJBIJpk+fXtahERER0SeAI3PvSSqVwtzcHJaWlvDx8UH79u2xf/9+AMCjR4/Qo0cPVK9eHfr6+nBycsL69etV1s/NzcWMGTNgY2MDqVSKmjVrYurUqeLy5ORk+Pr6wtjYGCYmJvD29kZiYuLH3EQiIiIqx5jMfUBXrlzB8ePHoaOjAwDIyMhA06ZNsWvXLly5cgUDBw5Enz59cPr0aXGd4OBgTJs2DT/++COuXbuGdevWoWrVqgCA7OxsKBQKGBoa4ujRo4iKioJMJkPHjh2RlZVVaByZmZlIS0tTmYiIiKhikgiCwLdJlpC/vz/++OMP6Orq4uXLl8jMzISGhgY2bdqELl26FLiOp6cn6tati19//RVPnz6FmZkZFixYgP79++er+8cff2DKlCmIiYmBRCIBAGRlZcHY2Bjbt2/H559/XmAfISEhmDRpUr5ypVIJIyOj99hiIipv0tLSIJfLoVwOGPGlwUQVinh+v+Pzm/fMvScPDw8sXrwYz549w2+//QYtLS0xkcvJycEvv/yCTZs24c6dO8jKykJmZib09V/9xo2JiUFmZibatWtXYNsXL17EzZs3YWhoqFKekZGB+Pj4QmMKDg7GyJEjxfm0tDRYWlq+76YSERFROcRk7j0ZGBjAxsYGALBy5Uo0bNgQK1asQEBAAGbOnIm5c+dizpw5cHJygoGBAQIDA8VLpHp6em9tOz09HU2bNsXatWvzLTMzMyt0PalUCqlU+h5bRUREROqC98x9QBoaGvjhhx8wYcIEvHjxAlFRUfD29kbv3r3RsGFDWFtb48aNG2J9W1tb6Onp4eDBgwW216RJE8TFxaFKlSqwsbFRmeRy+cfaLCIiIirHmMx9YF27doWmpiYWLlwIW1tb7N+/H8ePH0dMTAwGDRqE+/fvi3V1dXUxduxYjBkzBqtXr0Z8fDxOnjyJFStWAAB69eqFypUrw9vbG0ePHkVCQgIiIyMxYsQI/Pvvv2W1iURERFSO8DLrB6alpYVhw4ZhxowZuHDhAm7dugWFQgF9fX0MHDgQPj4+UCqVYv0ff/wRWlpa+Omnn3D37l1YWFhg8ODBAAB9fX0cOXIEY8eOxVdffYWnT5+ievXqaNeuHR9kICIiIgB8mvWTUNSnYYhI/fBpVqKKq6if37zMSkRERKTGmMwRERERqTEmc0RERERqjA9AEBFVBL5KgPfEEn2SODJHREREpMaYzBERERGpMSZzRERERGqMyRwRERGRGuMDEEREb5BIyjoCIqKi48gcERERkRpjMkdERESkxpjMEREREakxtUvmIiMjIZFIkJqaWi7aKQ6JRILt27eXq5iIiIhIvX30ZM7f3x8SiQQSiQTa2tqoXbs2xowZg4yMjFLr093dHYGBgSplrVq1QkpKCuRyean1W1zlMSYiIiIq38rkadaOHTsiLCwM2dnZOHfuHPz8/CCRSDB9+vSPFoOOjg7Mzc0/Wn9FUR5jIiIiovKtTC6zSqVSmJubw9LSEj4+Pmjfvj32798PAMjNzUVoaChq164NPT09NGzYEH/++WehbT169Ag9evRA9erVoa+vDycnJ6xfv15c7u/vj8OHD2Pu3LniiGBiYmKBlzS3bNmCevXqQSqVwsrKCrNmzVLpy8rKCr/88gv69esHQ0ND1KxZE8uWLROXZ2VlYdiwYbCwsICuri5q1aqF0NBQlTb+++8/fPnll9DX14etrS3++usvcdmbMYWHh8PY2Bjbt2+Hra0tdHV1oVAokJycXOx9TkRERBVTmd8zd+XKFRw/fhw6OjoAgNDQUKxevRpLlizB1atX8f3336N37944fPhwgetnZGSgadOm2LVrF65cuYKBAweiT58+OH36NABg7ty5aNmyJQYMGICUlBSkpKTA0tIyXzvnzp2Dr68vunfvjsuXLyMkJAQ//vgjwsPDVerNmjULzs7OuHDhAoYMGYJvv/0WsbGxAIB58+bhr7/+wqZNmxAbG4u1a9fCyspKZf1JkybB19cXly5dQqdOndCrVy88fvy40P3z/PlzTJ06FatXr0ZUVBRSU1PRvXv3ou5eIiIiquiEj8zPz0/Q1NQUDAwMBKlUKgAQNDQ0hD///FPIyMgQ9PX1hePHj6usExAQIPTo0UMQBEGIiIgQAAhPnjwptI/OnTsLo0aNEufd3NyE7777TqXOm+307NlT6NChg0qd0aNHC46OjuJ8rVq1hN69e4vzubm5QpUqVYTFixcLgiAIw4cPFz777DMhNze3wLgACBMmTBDn09PTBQDCP//8U2BMYWFhAgDh5MmT4joxMTECAOHUqVOFbn9GRoagVCrFKTk5WQAgKJXKQtchov8PUKdJyfObqIJSKot2fpfJyJyHhweio6Nx6tQp+Pn54ZtvvkGXLl1w8+ZNPH/+HB06dIBMJhOn1atXIz4+vsC2cnJyMHnyZDg5OcHExAQymQx79+5FUlJSsWKKiYmBq6urSpmrqyvi4uKQk5MjljVo0ED8WSKRwNzcHA8ePADw6pJudHQ07O3tMWLECOzbty9fP6+vb2BgACMjI3H9gmhpaaFZs2bifN26dWFsbIyYmJhC1wkNDYVcLhengkYiiYiIqGIokwcgDAwMYGNjAwBYuXIlGjZsiBUrVqB+/foAgF27dqF69eoq60il0gLbmjlzJubOnYs5c+bAyckJBgYGCAwMRFZWVqnErq2trTIvkUiQm5sLAGjSpAkSEhLwzz//4MCBA/D19UX79u1V7vl72/ofSnBwMEaOHCnOp6WlMaEjIiKqoMr8u1k1NDTwww8/YOTIkbhx4wakUimSkpLg5uZWpPWjoqLg7e2N3r17A3j1AMWNGzfg6Ogo1tHR0VEZXSuIg4MDoqKi8rVtZ2cHTU3NIm+PkZERunXrhm7duuHrr79Gx44d8fjxY5iYmBS5jde9fPkSZ8+ehYuLCwAgNjYWqampcHBwKHQdqVRaaPJLREREFUuZJ3MA0LVrV4wePRpLly5FUFAQvv/+e+Tm5qJ169ZQKpWIioqCkZER/Pz88q1ra2uLP//8E8ePH0elSpUwe/Zs3L9/XyWZs7KywqlTp5CYmAiZTFZgYjVq1Cg0a9YMkydPRrdu3XDixAksWLAAixYtKvJ2zJ49GxYWFmjcuDE0NDSwefNmmJubw9jYuET7BXg1kjd8+HDMmzcPWlpaGDZsGFq0aCEmd0RERPRpKxfJXF6SMmPGDCQkJMDMzAyhoaG4desWjI2N0aRJE/zwww8FrjthwgTcunULCoUC+vr6GDhwIHx8fKBUKsU6QUFB8PPzg6OjI168eIGEhIR87TRp0gSbNm3CTz/9hMmTJ8PCwgI///wz/P39i7wdhoaGmDFjBuLi4qCpqYlmzZph9+7d0NAo+a2J+vr6GDt2LHr27Ik7d+6gTZs2WLFiRYnbIyIioopFIgiCUNZBUMHCw8MRGBj43l/vlZaWBrlcDqVSCSMjow8THFEFJpGUdQTFkQaA5zdRRVTUz+8yf88cEREREZUckzkiIiIiNcZkrhzz9/d/70usREREVLGViwcgiIjKE3W6kzgtDZDLyzoKIipLHJkjIiIiUmNM5oiIiIjUGJM5IiIiIjXGZI6IiIhIjfEBCCKicki9XlxMRGWJI3NEREREaozJHBEREZEaYzJHREREpMaYzBERERGpMSZzH5mVlRXmzJlT1mEQERFRBVHukrnk5GT069cP1apVg46ODmrVqoXvvvsOjx49KuvQiiU8PBzGxsb5ys+cOYOBAwd+/ICIiIioQipXydytW7fg7OyMuLg4rF+/Hjdv3sSSJUtw8OBBtGzZEo8fPy7rEN+bmZkZ9PX1yzoMIiIiqiDKVTI3dOhQ6OjoYN++fXBzc0PNmjXxxRdf4MCBA7hz5w7Gjx8PAMjMzMTYsWNhaWkJqVQKGxsbrFixQmzn6tWr8PT0hJGREQwNDdGmTRvEx8cDANzd3REYGKjSr4+PD/z9/cV5KysrTJ48GT169ICBgQGqV6+OhQsXqqwze/ZsODk5wcDAAJaWlhgyZAjS09MBAJGRkfjmm2+gVCohkUggkUgQEhIitv36ZdakpCR4e3tDJpPByMgIvr6+uH//vrg8JCQEjRo1wpo1a2BlZQW5XI7u3bvj6dOn77u7iYiIqAIoN8nc48ePsXfvXgwZMgR6enoqy8zNzdGrVy9s3LgRgiCgb9++WL9+PebNm4eYmBgsXboUMpkMAHDnzh20bdsWUqkUhw4dwrlz59CvXz+8fPmyWPHMnDkTDRs2xIULFzBu3Dh899132L9/v7hcQ0MD8+bNw9WrV7Fq1SocOnQIY8aMAQC0atUKc+bMgZGREVJSUpCSkoKgoKB8feTm5sLb2xuPHz/G4cOHsX//fty6dQvdunVTqRcfH4/t27dj586d2LlzJw4fPoxp06YVGntmZibS0tJUJiIiIqqYys03QMTFxUEQBDg4OBS43MHBAU+ePMGZM2ewadMm7N+/H+3btwcAWFtbi/UWLlwIuVyODRs2QFtbGwBgZ2dX7HhcXV0xbtw4cf2oqCj89ttv6NChAwCojO5ZWVlhypQpGDx4MBYtWgQdHR3I5XJIJBKYm5sX2sfBgwdx+fJlJCQkwNLSEgCwevVq1KtXD2fOnEGzZs0AvEr6wsPDYWhoCADo06cPDh48iKlTpxbYbmhoKCZNmlTsbSYiIiL1U25G5vIIgvDW5YmJidDU1ISbm1uBy6Ojo9GmTRsxkSupli1b5puPiYkR5w8cOIB27dqhevXqMDQ0RJ8+ffDo0SM8f/68yH3ExMTA0tJSTOQAwNHREcbGxip9WVlZiYkcAFhYWODBgweFthscHAylUilOycnJRY6JiIiI1Eu5SeZsbGwgkUhUkpjXxcTEoFKlSvkuwb7pXcs1NDTyJYzZ2dnFijUxMRGenp5o0KABtmzZgnPnzon31GVlZRWrraJ4MzGVSCTIzc0ttL5UKoWRkZHKRERERBVTuUnmTE1N0aFDByxatAgvXrxQWXbv3j2sXbsW3bp1g5OTE3Jzc3H48OEC22nQoAGOHj1aaIJmZmaGlJQUcT4nJwdXrlzJV+/kyZP55vMuAZ87dw65ubmYNWsWWrRoATs7O9y9e1elvo6ODnJyct66zQ4ODkhOTlYZObt27RpSU1Ph6Oj41nWJiIiIgHKUzAHAggULkJmZCYVCgSNHjiA5ORl79uxBhw4dUL16dUydOhVWVlbw8/NDv379sH37diQkJCAyMhKbNm0CAAwbNgxpaWno3r07zp49i7i4OKxZswaxsbEAgM8++wy7du3Crl27cP36dXz77bdITU3NF0tUVBRmzJiBGzduYOHChdi8eTO+++47AK9GEbOzszF//nzcunULa9aswZIlS1TWt7KyQnp6Og4ePIj//vuvwMuv7du3h5OTE3r16oXz58/j9OnT6Nu3L9zc3ODs7PyB9y4RERFVROUqmbO1tcXZs2dhbW0NX19f1KlTBwMHDoSHhwdOnDgBExMTAMDixYvx9ddfY8iQIahbty4GDBiAZ8+eAXg1wnfo0CGkp6fDzc0NTZs2xfLly8VLlf369YOfn5+YNFlbW8PDwyNfLKNGjcLZs2fRuHFjTJkyBbNnz4ZCoQAANGzYELNnz8b06dNRv359rF27FqGhoSrrt2rVCoMHD0a3bt1gZmaGGTNm5OtDIpFgx44dqFSpEtq2bYv27dvD2toaGzdu/KD7lYiIiCouifCuJw4+QVZWVggMDMz3Pjp1lZaWBrlcDqVSyfvniNSERFLUmmkAeH4TVURF/fwuVyNzRERERFQ8TOaIiIiI1Fi5eWlweZKYmFjWIRAREREVCUfmiIjKIUEo2qRUlnWkRFTWmMwRERERqTEmc0RERERqjMkcERERkRpjMkdERESkxvg0KxFVaEV/+S4RkXriyBwRERGRGmMyR0RERKTGmMwRERERqTG1TebCw8NhbGxcbtohIiIiKgulksz5+/tDIpFg8ODB+ZYNHToUEokE/v7+79VHt27dcOPGDXE+JCQEjRo1eq82ASAnJwfTpk1D3bp1oaenBxMTEzRv3hy///67WMfd3R2BgYHFbtvf3x8+Pj7vHSMRERFRnlJ7mtXS0hIbNmzAb7/9Bj09PQBARkYG1q1bh5o1a75X29nZ2dDT0xPb/ZAmTZqEpUuXYsGCBXB2dkZaWhrOnj2LJ0+efPC+iIiIiN5XqV1mbdKkCSwtLbF161axbOvWrahZsyYaN24slu3ZswetW7eGsbExTE1N4enpifj4eHF5YmIiJBIJNm7cCDc3N+jq6mLt2rUql0fDw8MxadIkXLx4ERKJBBKJBOHh4QCA2bNnw8nJCQYGBrC0tMSQIUOQnp5eaNx//fUXhgwZgq5du6J27dpo2LAhAgICEBQUBODV6Nrhw4cxd+5csa/ExETk5OQgICAAtWvXhp6eHuzt7TF37lyx3ZCQEKxatQo7duwQ14uMjERkZCQkEglSU1PFutHR0WK7AHD79m14eXmhUqVKMDAwQL169bB79+6SHhoiIiKqQEr1nrl+/fohLCxMnF+5ciW++eYblTrPnj3DyJEjcfbsWRw8eBAaGhr48ssvkZubq1Jv3Lhx+O677xATEwOFQqGyrFu3bhg1ahTq1auHlJQUpKSkoFu3bgAADQ0NzJs3D1evXsWqVatw6NAhjBkzptCYzc3NcejQITx8+LDA5XPnzkXLli0xYMAAsS9LS0vk5uaiRo0a2Lx5M65du4affvoJP/zwAzZt2gQACAoKgq+vLzp27Ciu16pVqyLtx6FDhyIzMxNHjhzB5cuXMX36dMhkskLrZ2ZmIi0tTWUiIiKiiqlUXxrcu3dvBAcH4/bt2wCAqKgobNiwAZGRkWKdLl26qKyzcuVKmJmZ4dq1a6hfv75YHhgYiK+++qrAfvT09CCTyaClpQVzc3OVZa/f22ZlZYUpU6Zg8ODBWLRoUYFtzZ49G19//TXMzc1Rr149tGrVCt7e3vjiiy8AAHK5HDo6OtDX11fpS1NTE5MmTRLna9eujRMnTmDTpk3w9fWFTCaDnp4eMjMz88X4LklJSejSpQucnJwAANbW1m+tHxoaqhILERERVVylOjJnZmaGzp07Izw8HGFhYejcuTMqV66sUicuLg49evSAtbU1jIyMYGVlBeBVAvM6Z2fnEsVw4MABtGvXDtWrV4ehoSH69OmDR48e4fnz5wXWd3R0xJUrV3Dy5En069cPDx48gJeXF/r37//OvhYuXIimTZvCzMwMMpkMy5Yty7cdJTFixAhMmTIFrq6umDhxIi5duvTW+sHBwVAqleKUnJz83jEQERFR+VTqrybp168fwsPDsWrVKvTr1y/fci8vLzx+/BjLly/HqVOncOrUKQBAVlaWSj0DA4Ni952YmAhPT080aNAAW7Zswblz57Bw4cIC23+dhoYGmjVrhsDAQGzduhXh4eFYsWIFEhISCl1nw4YNCAoKQkBAAPbt24fo6Gh88803b+0nry8AEARBLMvOzlap079/f9y6dQt9+vTB5cuX4ezsjPnz5xfaplQqhZGRkcpEREREFVOpJ3MdO3ZEVlYWsrOz893r9ujRI8TGxmLChAlo164dHBwcSvzUqI6ODnJyclTKzp07h9zcXMyaNQstWrSAnZ0d7t69W+y2HR0dAby6v6+wvqKiotCqVSsMGTIEjRs3ho2NjcqDHIWtZ2ZmBgBISUkRy6Kjo/PFYGlpicGDB2Pr1q0YNWoUli9fXuztICIiooqnVO+ZA17dSxYTEyP+/LpKlSrB1NQUy5Ytg4WFBZKSkjBu3LgS9WNlZYWEhARER0ejRo0aMDQ0hI2NDbKzszF//nx4eXkhKioKS5YseWs7X3/9NVxdXdGqVSuYm5sjISEBwcHBsLOzQ926dcW+Tp06hcTERMhkMpiYmMDW1harV6/G3r17Ubt2baxZswZnzpxB7dq1VWLcu3cvYmNjYWpqCrlcDhsbG1haWiIkJARTp07FjRs3MGvWLJWYAgMD8cUXX8DOzg5PnjxBREQEHBwcSrSfiIiIqGL5KN8AUdilPg0NDWzYsAHnzp1D/fr18f3332PmzJkl6qNLly7o2LEjPDw8YGZmhvXr16Nhw4aYPXs2pk+fjvr162Pt2rUIDQ19azsKhQJ///03vLy8YGdnBz8/P9StWxf79u2Dltar3DcoKAiamppwdHSEmZkZkpKSMGjQIHz11Vfo1q0bmjdvjkePHmHIkCEqbQ8YMAD29vZwdnaGmZkZoqKioK2tjfXr1+P69eto0KABpk+fjilTpqisl5OTg6FDh8LBwQEdO3aEnZ1doQ9wEBER0adFIrx+sxZVSGlpaZDL5VAqlbx/jj45EklZR1Da0gDw/CaqiIr6+a22381KREREREzmiIiIiNQakzkiIiIiNVbqT7MSEZWlin5XcFoaIJeXdRREVJY4MkdERESkxpjMEREREakxJnNEREREaozJHBEREZEa4wMQRERqouK/AJmISoIjc0RERERqjMkcERERkRpjMkdERESkxpjMEREREamxUk/mJBIJtm/fXtrdvJO/vz98fHzKOgwiIiKiD6pYyZy/vz8kEkm+qWPHjqUVX7ElJiZCIpEgOjpapXzu3LkIDw//oH2Fh4cXuP2pqamQSCSIjIz8oP0RERERvanYrybp2LEjwsLCVMqkUukHC6i0yEvpywu1tLRw4MABREREwMPDo1T6ICIiIipMsS+zSqVSmJubq0yVKlUCAMTFxaFt27bQ1dWFo6Mj9u/fr7JuZGQkJBIJUlNTxbLo6GhIJBIkJiaKZVFRUXB3d4e+vj4qVaoEhUKBJ0+eAAD27NmD1q1bw9jYGKampvD09ER8fLy4bu3atQEAjRs3hkQigbu7O4D8l1kzMzMxYsQIVKlSBbq6umjdujXOnDmTL9aDBw/C2dkZ+vr6aNWqFWJjY1W2ycDAAP369cO4ceMK3WdF2e7w8HAYGxtj586dsLe3h76+Pr7++ms8f/4cq1atgpWVFSpVqoQRI0YgJyen0L6IiIjo0/LB7pnLzc3FV199BR0dHZw6dQpLlizB2LFji91OdHQ02rVrB0dHR5w4cQLHjh2Dl5eXmMA8e/YMI0eOxNmzZ3Hw4EFoaGjgyy+/RG5uLgDg9OnTAIADBw4gJSUFW7duLbCfMWPGYMuWLVi1ahXOnz8PGxsbKBQKPH78WKXe+PHjMWvWLJw9exZaWlro169fvrZCQkJw+fJl/Pnnn8Xe3tc9f/4c8+bNw4YNG7Bnzx5ERkbiyy+/xO7du7F7926sWbMGS5cufWc/mZmZSEtLU5mIiIioghKKwc/PT9DU1BQMDAxUpqlTpwp79+4VtLS0hDt37oj1//nnHwGAsG3bNkEQBCEiIkIAIDx58kSsc+HCBQGAkJCQIAiCIPTo0UNwdXUtckwPHz4UAAiXL18WBEEQEhISBADChQsX8sXu7e0tCIIgpKenC9ra2sLatWvF5VlZWUK1atWEGTNmqMR64MABsc6uXbsEAMKLFy8EQRCEsLAwQS6XC4IgCOPGjRPs7OyE7Oxs4cmTJwIAISIiosjbHRYWJgAQbt68KdYZNGiQoK+vLzx9+lQsUygUwqBBg966TyZOnCgAyDcplcq370wiKteAgiYlz2+iCkqpLNr5XeyROQ8PD0RHR6tMgwcPRkxMDCwtLVGtWjWxbsuWLYudXOaNzBUmLi4OPXr0gLW1NYyMjGBlZQUASEpKKnIf8fHxyM7Ohqurq1imra0NFxcXxMTEqNRt0KCB+LOFhQUA4MGDB/naHDt2LB4+fIiVK1cWOY436evro06dOuJ81apVYWVlBZlMplJWUP+vCw4OhlKpFKfk5OQSx0RERETlW7EfgDAwMICNjU2JOtPQeJU7CoIglmVnZ6vU0dPTe2sbXl5eqFWrFpYvX45q1aohNzcX9evXR1ZWVoliehdtbW3xZ8n/fTFi3iXd1xkbGyM4OBiTJk2Cp6enyrKibPebfeX1V1BZQf2/TiqVqsVDKURERPT+Ptg9cw4ODkhOTkZKSopYdvLkSZU6ZmZmAKBS581XiDRo0AAHDx4ssI9Hjx4hNjYWEyZMQLt27eDg4CA+GJFHR0cHAN76kECdOnWgo6ODqKgosSw7OxtnzpyBo6PjW7by7YYPHw4NDQ3MnTtXpbwo201ERERUEsUemcvMzMS9e/dUG9HSQvv27WFnZwc/Pz/MnDkTaWlpGD9+vEo9GxsbWFpaIiQkBFOnTsWNGzcwa9YslTrBwcFwcnLCkCFDMHjwYOjo6CAiIgJdu3aFiYkJTE1NsWzZMlhYWCApKSnfU6RVqlSBnp4e9uzZgxo1akBXVzffa0kMDAzw7bffYvTo0TAxMUHNmjUxY8YMPH/+HAEBAcXdJSJdXV1MmjQJQ4cOLfZ2ExEREZVEsUfm9uzZAwsLC5WpdevW0NDQwLZt2/DixQu4uLigf//+mDp1qsq62traWL9+Pa5fv44GDRpg+vTpmDJlikodOzs77Nu3DxcvXoSLiwtatmyJHTt2QEtLCxoaGtiwYQPOnTuH+vXr4/vvv8fMmTNV1tfS0sK8efOwdOlSVKtWDd7e3gVux7Rp09ClSxf06dMHTZo0wc2bN7F3717xNSsl5efnB2tr62JvNxEREVFJSITXb+SiCiktLQ1yuRxKpRJGRkZlHQ4RldD/3bb7hjQAPL+JKqKifn6X+nezEhEREVHpYTJHREREpMaYzBERERGpMSZzRERqosDvf1CWdVREVNaYzBERERGpMSZzRERERGqMyRwRERGRGiv2N0AQEVHZKfhdc0T0KePIHBEREZEaYzJHREREpMaYzBERERGpMSZzRERERGrsk0jmJBIJtm/fXtZhwN/fHz4+PmUdBhEREVUgapfM+fv7QyKR5Js6duxY1qGJEhMTIZFIEB0drVI+d+5chIeHl0lMREREVDGp5atJOnbsiLCwMJUyqVRaRtEUnVwuL+sQiIiIqIJRu5E54FXiZm5urjJVqlQJABAXF4e2bdtCV1cXjo6O2L9/v8q6kZGRkEgkSE1NFcuio6MhkUiQmJgolkVFRcHd3R36+vqoVKkSFAoFnjx5AgDYs2cPWrduDWNjY5iamsLT0xPx8fHiurVr1wYANG7cGBKJBO7u7gDyX2bNzMzEiBEjUKVKFejq6qJ169Y4c+ZMvlgPHjwIZ2dn6Ovro1WrVoiNjf0Qu5GIiIgqALVM5gqTm5uLr776Cjo6Ojh16hSWLFmCsWPHFrud6OhotGvXDo6Ojjhx4gSOHTsGLy8v5OTkAACePXuGkSNH4uzZszh48CA0NDTw5ZdfIjc3FwBw+vRpAMCBAweQkpKCrVu3FtjPmDFjsGXLFqxatQrnz5+HjY0NFAoFHj9+rFJv/PjxmDVrFs6ePQstLS3069fvrfFnZmYiLS1NZSIiIqKKSS0vs+7cuRMymUyl7IcffoCzszOuX7+OvXv3olq1agCAX375BV988UWx2p8xYwacnZ2xaNEisaxevXriz126dFGpv3LlSpiZmeHatWuoX78+zMzMAACmpqYwNzcvsI9nz55h8eLFCA8PF+Nbvnw59u/fjxUrVmD06NFi3alTp8LNzQ0AMG7cOHTu3BkZGRnQ1dUtsO3Q0FBMmjSpWNtMRERE6kktR+Y8PDwQHR2tMg0ePBgxMTGwtLQUEzkAaNmyZbHbzxuZK0xcXBx69OgBa2trGBkZwcrKCgCQlJRU5D7i4+ORnZ0NV1dXsUxbWxsuLi6IiYlRqdugQQPxZwsLCwDAgwcPCm07ODgYSqVSnJKTk4scFxEREakXtRyZMzAwgI2NTYnW1dB4lb8KgiCWZWdnq9TR09N7axteXl6oVasWli9fjmrVqiE3Nxf169dHVlZWiWJ6F21tbfFnyf99MWPeJd2CSKVStXgghIiIiN6fWo7MFcbBwQHJyclISUkRy06ePKlSJ+8S6Ot13nyFSIMGDXDw4MEC+3j06BFiY2MxYcIEtGvXDg4ODuKDEXl0dHQAQLzHriB16tSBjo4OoqKixLLs7GycOXMGjo6Ob9lKIiIiov9PLUfmMjMzce/ePZUyLS0ttG/fHnZ2dvDz88PMmTORlpaG8ePHq9SzsbGBpaUlQkJCMHXqVNy4cQOzZs1SqRMcHAwnJycMGTIEgwcPho6ODiIiItC1a1eYmJjA1NQUy5Ytg4WFBZKSkjBu3DiV9atUqQI9PT3s2bMHNWrUgK6ubr7XkhgYGODbb7/F6NGjYWJigpo1a2LGjBl4/vw5AgICPuDeIiIioopMLUfm9uzZAwsLC5WpdevW0NDQwLZt2/DixQu4uLigf//+mDp1qsq62traWL9+Pa5fv44GDRpg+vTpmDJlikodOzs77Nu3DxcvXoSLiwtatmyJHTt2QEtLCxoaGtiwYQPOnTuH+vXr4/vvv8fMmTNV1tfS0sK8efOwdOlSVKtWDd7e3gVux7Rp09ClSxf06dMHTZo0wc2bN7F3717xNStERERE7yIRXr95jCqktLQ0yOVyKJVKGBkZlXU4RPQe/u+22dekAeD5TVQRFfXzWy1H5oiIiIjoFSZzRERERGqMyRwRERGRGmMyR0SkRgRBdVIqyzoiIiprTOaIiIiI1BiTOSIiIiI1xmSOiIiISI0xmSMiIiJSY0zmiIiIiNQYkzkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5gohCAIGDhwIExMTSCQSREdHv3MdiUSC7du3l3psRERERHmYzBViz549CA8Px86dO5GSkoL69euXdUiwsrLCnDlzyjoMIiIiKke0yjqA8io+Ph4WFhZo1apVWYdCREREVCiOzBXA398fw4cPR1JSEiQSCaysrODu7o4RI0ZgzJgxMDExgbm5OUJCQgpt4+uvv8awYcPE+cDAQEgkEly/fh0AkJWVBQMDAxw4cAAA8PTpU/Tq1QsGBgawsLDAb7/9Bnd3dwQGBgIA3N3dcfv2bXz//feQSCSQSCSltv1ERESkPpjMFWDu3Ln4+eefUaNGDaSkpODMmTMAgFWrVsHAwACnTp3CjBkz8PPPP2P//v0FtuHm5obIyEhx/vDhw6hcubJYdubMGWRnZ4sjfyNHjkRUVBT++usv7N+/H0ePHsX58+fF9bdu3YoaNWrg559/RkpKClJSUgqNPzMzE2lpaSoTERERVUxM5gogl8thaGgITU1NmJubw8zMDADQoEEDTJw4Eba2tujbty+cnZ1x8ODBAttwd3fHtWvX8PDhQzx58gTXrl3Dd999JyZzkZGRaNasGfT19fH06VOsWrUKv/76K9q1a4f69esjLCwMOTk5YnsmJibQ1NSEoaEhzM3NYW5uXmj8oaGhkMvl4mRpafnhdg4RERGVK0zmiqFBgwYq8xYWFnjw4EGBdevXrw8TExMcPnwYR48eRePGjeHp6YnDhw8DeDVS5+7uDgC4desWsrOz4eLiIq4vl8thb29fojiDg4OhVCrFKTk5uUTtEBERUfnHByCKQVtbW2VeIpEgNze3wLoSiQRt27ZFZGQkpFIp3N3d0aBBA2RmZuLKlSs4fvw4goKCSiVOqVQKqVRaKm0TERFR+cKRuVKUd99cZGQk3N3doaGhgbZt22LmzJnIzMyEq6srAMDa2hra2trivXkAoFQqcePGDZX2dHR0VC69EhERETGZK0V5981dvXoVrVu3FsvWrl0LZ2dnGBgYAAAMDQ3h5+eH0aNHIyIiAlevXkVAQAA0NDRUnlq1srLCkSNHcOfOHfz3339lsk1ERERUvjCZK0VOTk4wNjZGo0aNIJPJALxK5nJycsT75fLMnj0bLVu2hKenJ9q3bw9XV1c4ODhAV1dXrPPzzz8jMTERderUER/KICIiok+bRBAEoayDoPyePXuG6tWrY9asWQgICHivttLS0iCXy6FUKmFkZPSBIiSi8oDnN1HFVdTzmw9AlBMXLlzA9evX4eLiAqVSiZ9//hkA4O3tXcaRERERUXnGZK4c+fXXXxEbGwsdHR00bdoUR48eReXKlcs6LCIiIirHmMyVE40bN8a5c+fKOgwiIiJSM3wAgoiIiEiNMZkjIiIiUmNM5oiIiIjUGJM5IiIiIjXGZI6IiIhIjfFpViKiimCTHNAvoLwn3wtPVNFxZI6IiIhIjTGZIyIiIlJjTOaIiIiI1BiTOSIiIiI1xmTuNSEhIWjUqNF7t+Pv7w8fH5/3boeIiIjoXcp9MrdkyRIYGhri5cuXYll6ejq0tbXh7u6uUjcyMhISiQTx8fGlFo8gCFi2bBmaN28OmUwGY2NjODs7Y86cOXj+/Hmp9UtERERUkHKfzHl4eCA9PR1nz54Vy44ePQpzc3OcOnUKGRkZYnlERARq1qyJOnXqFKsPQRBUksW36dOnDwIDA+Ht7Y2IiAhER0fjxx9/xI4dO7Bv375i9UtERET0vsp9Mmdvbw8LCwtERkaKZZGRkfD29kbt2rVx8uRJlXIPDw9kZmZixIgRqFKlCnR1ddG6dWucOXNGpZ5EIsE///yDpk2bQiqV4tixY/n6jo+Ph7W1NYYNGwZBELBp0yasXbsW69evxw8//IBmzZrBysoK3t7eOHToEDw8PArchj179qB169YwNjaGqakpPD09VUYPs7KyMGzYMFhYWEBXVxe1atVCaGgogFeJZkhICGrWrAmpVIpq1aphxIgR77tbiYiIqIIo98kc8Gp0LiIiQpyPiIiAu7s73NzcxPIXL17g1KlT8PDwwJgxY7BlyxasWrUK58+fh42NDRQKBR4/fqzS7rhx4zBt2jTExMSgQYMGKssuXbqE1q1bo2fPnliwYAEkEgnWrl0Le3t7eHt754tRIpFALpcXGP+zZ88wcuRInD17FgcPHoSGhga+/PJL5ObmAgDmzZuHv/76C5s2bUJsbCzWrl0LKysrAMCWLVvw22+/YenSpYiLi8P27dvh5OT01v2VmZmJtLQ0lYmIiIgqJrX4BggPDw8EBgbi5cuXePHiBS5cuAA3NzdkZ2djyZIlAIATJ04gMzMT7u7uGDBgAMLDw/HFF18AAJYvX479+/djxYoVGD16tNjuzz//jA4dOuTr7/jx4/D09MT48eMxatQosTwuLg729vbFjr9Lly4q8ytXroSZmRmuXbuG+vXrIykpCba2tmjdujUkEglq1aol1k1KSoK5uTnat28PbW1t1KxZEy4uLm/tLzQ0FJMmTSp2nERERKR+1GJkzt3dHc+ePcOZM2dw9OhR2NnZwczMDG5ubuJ9c5GRkbC2toZSqUR2djZcXV3F9bW1teHi4oKYmBiVdp2dnfP1lZSUhA4dOuCnn35SSeSAV5c8SyIuLg49evSAtbU1jIyMxFG3pKQkAK+efo2Ojoa9vT1GjBihcu9d165d8eLFC1hbW2PAgAHYtm3bO+/vCw4OhlKpFKfk5OQSxU1ERETln1okczY2NqhRowYiIiIQEREBNzc3AEC1atVgaWmJ48ePIyIiAp999lmx2jUwMMhXZmZmBhcXF6xfvz7f5Uk7Oztcv3692PF7eXnh8ePHWL58OU6dOoVTp04BeHWvHAA0adIECQkJmDx5Ml68eAFfX198/fXXAABLS0vExsZi0aJF0NPTw5AhQ9C2bVtkZ2cX2p9UKoWRkZHKRERERBWTWiRzwKtLrZGRkYiMjFR5JUnbtm3xzz//4PTp0/Dw8ECdOnWgo6ODqKgosU52djbOnDkDR0fHd/ajp6eHnTt3QldXFwqFAk+fPhWX9ezZEzdu3MCOHTvyrScIApRKZb7yR48eITY2FhMmTEC7du3g4OCAJ0+e5KtnZGSEbt26Yfny5di4cSO2bNki3uOnp6cHLy8vzJs3D5GRkThx4gQuX778zm0hIiKiik+tkrljx44hOjpaHJkDADc3NyxduhRZWVnw8PCAgYEBvv32W4wePRp79uzBtWvXMGDAADx//hwBAQFF6svAwAC7du2ClpYWvvjiC6SnpwMAfH190a1bN/To0QO//PILzp49i9u3b2Pnzp1o3769ykMaeSpVqgRTU1MsW7YMN2/exKFDhzBy5EiVOrNnz8b69etx/fp13LhxA5s3b4a5uTmMjY0RHh6OFStW4MqVK7h16xb++OMP6OnpqdxXR0RERJ8utXgAAniVzL148QJ169ZF1apVxXI3Nzc8ffpUfIUJAEybNg25ubno06cPnj59CmdnZ+zduxeVKlUqcn8ymQz//PMPFAoFOnfujN27d8PAwADr1q3DsmXLsHLlSkydOhVaWlqwtbVF3759oVAo8rWjoaGBDRs2YMSIEahfvz7s7e0xb948ldFFQ0NDzJgxA3FxcdDU1ESzZs2we/duaGhowNjYGNOmTcPIkSORk5MDJycn/P333zA1NS35ziQiIqIKQyKU9K5+UhtpaWmQy+VQKpW8f46oghHP7+WAkX4BFXryVzyRuirq57faXGYlIiIiovyYzBERERGpMSZzRERERGpMbR6AICKit/BVArwnluiTxJE5IiIiIjXGZI6IiIhIjTGZIyIiIlJjvGeOiD5JEklZR0BE9GFwZI6IiIhIjTGZIyIiIlJjTOaIiIiI1BiTOSIiIiI1xmSOiIiISI0xmStlJ06cgKamJjp37lzWoRAREVEFxGSulK1YsQLDhw/HkSNHcPfu3bIOh4iIiCoYJnOlKD09HRs3bsS3336Lzp07Izw8XGX5X3/9BVtbW+jq6sLDwwOrVq2CRCJBamqqWOfYsWNo06YN9PT0YGlpiREjRuDZs2cfd0OIiIio3GIyV4o2bdqEunXrwt7eHr1798bKlSshCAIAICEhAV9//TV8fHxw8eJFDBo0COPHj1dZPz4+Hh07dkSXLl1w6dIlbNy4EceOHcOwYcPe2m9mZibS0tJUJiIiIqqYmMyVohUrVqB3794AgI4dO0KpVOLw4cMAgKVLl8Le3h4zZ86Evb09unfvDn9/f5X1Q0ND0atXLwQGBsLW1hatWrXCvHnzsHr1amRkZBTab2hoKORyuThZWlqW2jYSERFR2WIyV0piY2Nx+vRp9OjRAwCgpaWFbt26YcWKFeLyZs2aqazj4uKiMn/x4kWEh4dDJpOJk0KhQG5uLhISEgrtOzg4GEqlUpySk5M/8NYRERFRecHvZi0lK1aswMuXL1GtWjWxTBAESKVSLFiwoEhtpKenY9CgQRgxYkS+ZTVr1ix0PalUCqlUWvygiYiISO0wmSsFL1++xOrVqzFr1ix8/vnnKst8fHywfv162NvbY/fu3SrLzpw5ozLfpEkTXLt2DTY2NqUeMxEREaknJnOlYOfOnXjy5AkCAgIgl8tVlnXp0gUrVqzApk2bMHv2bIwdOxYBAQGIjo4Wn3aVSCQAgLFjx6JFixYYNmwY+vfvDwMDA1y7dg379+8v8ugeERERVWy8Z64UrFixAu3bt8+XyAGvkrmzZ8/i6dOn+PPPP7F161Y0aNAAixcvFp9mzbtE2qBBAxw+fBg3btxAmzZt0LhxY/z0008ql26JiIjo0yYR8t6VQWVu6tSpWLJkyQd/YCEtLQ1yuRxKpRJGRkYftG0idfV/A+AVQBoAnt9EFVFRP795mbUMLVq0CM2aNYOpqSmioqIwc+bMd75DjoiIiOh1TObKUFxcHKZMmYLHjx+jZs2aGDVqFIKDg8s6LCIiIlIjvMz6CeBlVqL8eJmViMo7XmYlInqLivJnbFoaUMCzVkT0CeHTrERERERqjMkcERERkRpjMkdERESkxpjMEREREakxJnNEREREaozJHBEREZEaYzJHREREpMaYzBERERGpMSZzRERERGqMyRwRERGRGmMyR0RERKTGmMwRERERqTEmc0RERERqjMkcERERkRpjMkdERESkxrTKOgAqfYIgAADS0tLKOBIi+tDyzmue30QVT955nfc5Xhgmc5+Ap0+fAgAsLS3LOBIiKi08v4kqrqdPn0Iulxe6XCK8K90jtZebm4u7d+/C0NAQEomkrMOhUpaWlgZLS0skJyfDyMiorMOhUsbj/Wnh8f60CIKAp0+folq1atDQKPzOOI7MfQI0NDRQo0aNsg6DPjIjIyP+sv+E8Hh/Wni8Px1vG5HLwwcgiIiIiNQYkzkiIiIiNcZkjqiCkUqlmDhxIqRSaVmHQh8Bj/enhcebCsIHIIiIiIjUGEfmiIiIiNQYkzkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5ojU0MKFC2FlZQVdXV00b94cp0+ffmv9zZs3o27dutDV1YWTkxN27979kSKlD6E4xzs8PBwSiURl0tXV/YjRUkkdOXIEXl5eqFatGiQSCbZv3/7OdSIjI9GkSRNIpVLY2NggPDy81OOk8ofJHJGa2bhxI0aOHImJEyfi/PnzaNiwIRQKBR48eFBg/ePHj6NHjx4ICAjAhQsX4OPjAx8fH1y5cuUjR04lUdzjDbz6doCUlBRxun379keMmErq2bNnaNiwIRYuXFik+gkJCejcuTM8PDwQHR2NwMBA9O/fH3v37i3lSKm84atJiNRM8+bN0axZMyxYsADAq+/etbS0xPDhwzFu3Lh89bt164Znz55h586dYlmLFi3QqFEjLFmy5KPFTSVT3OMdHh6OwMBApKamfuRI6UOSSCTYtm0bfHx8Cq0zduxY7Nq1S+UPs+7duyM1NRV79uz5CFFSecGROSI1kpWVhXPnzqF9+/ZimYaGBtq3b48TJ04UuM6JEydU6gOAQqEotD6VHyU53gCQnp6OWrVqwdLSEt7e3rh69erHCJc+Mp7blIfJHJEa+e+//5CTk4OqVauqlFetWhX37t0rcJ179+4Vqz6VHyU53vb29li5ciV27NiBP/74A7m5uWjVqhX+/fffjxEyfUSFndtpaWl48eJFGUVFZUGrrAMgIqIPp2XLlmjZsqU436pVKzg4OGDp0qWYPHlyGUZGRKWFI3NEaqRy5crQ1NTE/fv3Vcrv378Pc3PzAtcxNzcvVn0qP0pyvN+kra2Nxo0b4+bNm6URIpWhws5tIyMj6OnplVFUVBaYzBGpER0dHTRt2hQHDx4Uy3Jzc3Hw4EGV0ZjXtWzZUqU+AOzfv7/Q+lR+lOR4vyknJweXL1+GhYVFaYVJZYTnNokEIlIrGzZsEKRSqRAeHi5cu3ZNGDhwoGBsbCzcu3dPEARB6NOnjzBu3DixflRUlKClpSX8+uuvQkxMjDBx4kRBW1tbuHz5clltAhVDcY/3pEmThL179wrx8fHCuXPnhO7duwu6urrC1atXy2oTqIiePn0qXLhwQbhw4YIAQJg9e7Zw4cIF4fbt24IgCMK4ceOEPn36iPVv3bol6OvrC6NHjxZiYmKEhQsXCpqamsKePXvKahOojDCZI1JD8+fPF2rWrCno6OgILi4uwsmTJ8Vlbm5ugp+fn0r9TZs2CXZ2doKOjo5Qr149YdeuXR85YnofxTnegYGBYt2qVasKnTp1Es6fP18GUVNxRURECADyTXnH18/PT3Bzc8u3TqNGjQQdHR3B2tpaCAsL++hxU9nje+aIiIiI1BjvmSMiIiJSY0zmiIiIiNQYkzkiIiIiNcZkjoiIiEiNMZkjIiIiUmNM5oiIiIjUGJM5IiIiIjXGZI6ISE24u7sjMDCwrMMgonKGyRwR0Ufg5eWFjh07Frjs6NGjkEgkuHTp0keOiogqAiZzREQfQUBAAPbv349///0337KwsDA4OzujQYMGZRAZEak7JnNERB+Bp6cnzMzMEB4erlKenp6OzZs3w8fHBz169ED16tWhr68PJycnrF+//q1tSiQSbN++XaXM2NhYpY/k5GT4+vrC2NgYJiYm8Pb2RmJiorg8MjISLi4uMDAwgLGxMVxdXXH79u333Foi+piYzBERfQRaWlro27cvwsPD8fpXYm/evBk5OTno3bs3mjZtil27duHKlSsYOHAg+vTpg9OnT5e4z+zsbCgUChgaGuLo0aOIioqCTCZDx44dkZWVhZcvX8LHxwdubm64dOkSTpw4gYEDB0IikXyITSaij0SrrAMgIvpU9OvXDzNnzsThw4fh7u4O4NUl1i5duqBWrVoICgoS6w4fPhx79+7Fpk2b4OLiUqL+Nm7ciNzcXPz+++9ighYWFgZjY2NERkbC2dkZSqUSnp6eqFOnDgDAwcHh/TaSiD46jswREX0kdevWRatWrbBy5UoAwM2bN3H06FEEBAQgJycHkydPhpOTE0xMTCCTybB3714kJSWVuL+LFy/i5s2bMDQ0hEwmg0wmg4mJCTIyMhAfHw8TExP4+/tDoVDAy8sLc+fORUpKyofaXCL6SJjMERF9RAEBAdiyZQuePn2KsLAw1KlTB25ubpg5cybmzp2LsWPHIiIiAtHR0VAoFMjKyiq0LYlEonLJFnh1aTVPeno6mjZtiujoaJXpxo0b6NmzJ4BXI3UnTpxAq1atsHHjRtjZ2eHkyZOls/FEVCqYzBERfUS+vr7Q0NDAunXrsHr1avTr1w8SiQRRUVHw9vZG79690bBhQ1hbW+PGjRtvbcvMzExlJC0uLg7Pnz8X55s0aYK4uDhUqVIFNjY2KpNcLhfrNW7cGMHBwTh+/Djq16+PdevWffgNJ6JSw2SOiOgjkslk6NatG4KDg5GSkgJ/f38AgK2tLfbv34/jx48jJiYGgwYNwv3799/a1meffYYFCxbgwoULOHv2LAYPHgxtbW1xea9evVC5cmV4e3vj6NGjSEhIQGRkJEaMGIF///0XCQkJCA4OxokTJ3D79m3s27cPcXFxvG+OSM0wmSMi+sgCAgLw5MkTKBQKVKtWDQAwYcIENGnSBAqFAu7u7jA3N4ePj89b25k1axYsLS3Rpk0b9OzZE0FBQdDX1xeX6+vr48iRI6hZsya++uorODg4ICAgABkZGTAyMoK+vj6uX7+OLl26wM7ODgMHDsTQoUMxaNCg0tx8IvrAJMKbN1wQERERkdrgyBwRERGRGmMyR0RERKTGmMwRERERqTEmc0RERERqjMkcERERkRpjMkdERESkxpjMEREREakxJnNEREREaozJHBEREZEaYzJHREREpMaYzBERERGpMSZzRERERGrs/wFR7MqSJPi+wgAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "AzU7KNkmuL4A" + }, + "execution_count": 24, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/datascienceintro/solutions/Solution_RootFinding_Newton.ipynb b/datascienceintro/solutions/Solution_RootFinding_Newton.ipynb new file mode 100644 index 0000000..473cab0 --- /dev/null +++ b/datascienceintro/solutions/Solution_RootFinding_Newton.ipynb @@ -0,0 +1,386 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Newton's Method for Root Finding\n", + "\n", + "In many applications, we need to find the root of a function, i.e. the point where the function crosses the $x$-axis: $f(x_r) = 0$\n", + "\n", + "A variety of methods exist for this problem, in this examle we want to use Newton's method. The general idea is the following:\n", + "We start at some point, our initial guess $x_0$. Then, we calculate the value of the function at point $x_n$ (starting from the initial guess) $f(x_n)$, as well as the derivative $f'(x_n)$, the derivative is the slope of the tangent line to the function $f(x)$ at this point $x_n$:\n", + "$$ y = f(x_n) + f'(x_n)(x-x_n)$$\n", + "We now want to find the point where the tangent line intersects with the $x$-axis, i.e. we set $y=0$, leading to:\n", + "$$f'(x_n)(x-x_n) = -f(x_n)$$\n", + "Assuming $f'(x_n) \\neq 0$, we can divide both sides by $f'(x_n)$, solve for $x$ and then iterate.\n", + "\n", + "More concisely, the overall approach is:\n", + "\n", + "\n", + "1. Choose an initial guess $ x_0 $.\n", + "2. Iterate using the formula:\n", + "$$x_{n+1} = x_n - \\frac{f(x_n)}{f'(x_n)}$$\n", + " where $ n = 0, 1, 2, \\ldots $\n", + "\n", + "The process continues until the difference between successive approximations is less than a predetermined tolerance level or until a maximum number of iterations is reached.\n", + "\n", + "Note that if our initial guess $x_0$ is not suitable, the method may not converge.\n", + "\n", + "One of the underrated features of modern deep learning frameworks is the automatic differentiation. In \"conventional\" deep learning, we use this as a tool behind the scenes to train a neural network and do not really interact with this. However, this method is useful in a range of applications, such as physics-informed neural networks or, indeed, this example of finding the root of a function efficiently.\n", + "While we perceive deep-learning frameworks such as [PyTorch](https://pytorch.org/) or [TensorFlow](https://www.tensorflow.org/) primarily as libraries for deep learning (and we do indeed use them for this purpose), they are, essentially, heavily optimised libraries for matrix operations and numerical handling of equations that can, in addition, levarage the computation power of GPUs.\n", + "\n", + "Note that while we would ideally work with functions where we can caluclate the derivative analytically, this is not necessary.\n", + "We will use the example of a conic steel vessel discussed in the lecture \"Numerical Models in Processing\" by [PD Dr. W. Lenz](https://www.iob.rwth-aachen.de/habilitation-von-dr-wolfgang-lenz/). In this example, a numerical solution is derived which we will use as starting point.\n", + "\n", + "First, we will start with a motivating generic example to get familiar with the method and general code structure before then turning to the concrete example." + ], + "metadata": { + "id": "mlFU2iWsADAb" + } + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "import torch\n", + "\n", + "from datetime import datetime\n" + ], + "metadata": { + "id": "FTDBpsfQAJUu" + }, + "execution_count": 1, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## General Example\n", + "\n", + "We start with a generic example using the function\n", + "$f(x) = \\cos(x) -x$.\n", + "\n", + "First, we plot the function.\n", + "Note that we directly use [torch.tensor](https://pytorch.org/docs/stable/tensors.html) as we will later on use the automatic differentiation to implement Newton's method for finding roots.\n", + "\n" + ], + "metadata": { + "id": "gbNrWJBShOFE" + } + }, + { + "cell_type": "code", + "source": [ + "def f(x):\n", + " return torch.cos(x) - x" + ], + "metadata": { + "id": "fQA-El5LATbi" + }, + "execution_count": 12, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Let's first make a plot of this function.\n", + "Assuming that we already know that the root of the function is at $x=0.755$, we add a vertical line to indicate this root." + ], + "metadata": { + "id": "5Kh08W8faFrI" + } + }, + { + "cell_type": "code", + "source": [ + "x_space = np.linspace(-10, 10, 500)\n", + "y_space = f(torch.tensor(x_space))\n", + "\n", + "sns.lineplot(x=x_space, y=y_space, label='f(x)')\n", + "plt.axhline(y=0, color='black', linestyle='--', label='y=0')\n", + "\n", + "# we use the value we have found below for illustration.\n", + "plt.axvline(x=0.755, color='red', linestyle='--', label='x=0.755')\n", + "plt.title('Plot of f(x) = cos(x) - x')\n", + "plt.xlabel('x')\n", + "plt.ylabel('f(x)')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "Os50IvYqAV2S", + "outputId": "1e6aff52-9d90-4c90-d07c-f5e1b916b4d9" + }, + "execution_count": 13, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "x = torch.tensor([0.1], requires_grad=True)\n", + "tolerance = 1e-6\n", + "max_iterations = 100\n", + "\n", + "t_start = datetime.now()\n", + "for i in range(max_iterations):\n", + " y = f(x)\n", + " y.backward()\n", + " with torch.no_grad():\n", + " # Replacing in-place copy with out-of-place operation\n", + " x_new = x - y / x.grad\n", + "\n", + " if torch.abs(x_new - x).item() < tolerance: #add .item() to get a python number\n", + " t_stop = datetime.now()\n", + " print(f'Converged after {i+1} iterations.')\n", + " print(f'Time taken: {t_stop - t_start}')\n", + " break\n", + "\n", + " x = x_new.clone().detach().requires_grad_(True) # Create a new tensor with gradient enabled\n", + "\n", + "print(f'Root approximated at x = {x.item()}')\n", + "print(f'Function value at root approximation f(x) = {f(x).item()}')" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0f4dvR4FBVAl", + "outputId": "9e2e810a-1f9f-4436-ea38-78f07d8ed591" + }, + "execution_count": 14, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Converged after 5 iterations.\n", + "Time taken: 0:00:00.017358\n", + "Root approximated at x = 0.7390851378440857\n", + "Function value at root approximation f(x) = 0.0\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# With Optimiser\n", + "\n", + "In the above code, we have implemented Newton's method directly.\n", + "However, modern deep learning packages include poweful optimisers that perform the calculation of the gradient, as well as the subsequent updates of the parameters.\n", + "\n", + "As an exercise, re-write the code to use the [Adam](https://pytorch.org/docs/stable/generated/torch.optim.Adam.html) optimiser.\n", + "\n", + "*Hint*: You need to think of a suitable loss function;\n", + "\n", + "*Note*: Depending on the problem at hand, using an optimiser and loss function may (or may not) improve convergence. You may find that the standard approach works sufficiently well for your problem." + ], + "metadata": { + "id": "Svek5D1zaYaJ" + } + }, + { + "cell_type": "markdown", + "source": [ + "**Exercise**\n", + "Modify the above code to use the Adam optimiser" + ], + "metadata": { + "id": "aOVC7XJle_fr" + } + }, + { + "cell_type": "code", + "source": [ + "##\n", + "## Your code goes here\n", + "##" + ], + "metadata": { + "id": "pyeAplQKevqA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "**Solution**" + ], + "metadata": { + "id": "iH84kEVD8mFa" + } + }, + { + "cell_type": "code", + "source": [ + "# Optimization using Adam optimizer\n", + "x = torch.tensor([0.1], requires_grad=True, dtype=torch.float64)\n", + "tolerance = 1e-6\n", + "max_iterations = 10000\n", + "\n", + "eps = 0.001 # small value to avoid dividig by zero\n", + "\n", + "\n", + "# Initialize the Adam optimizer with a smaller learning rate\n", + "optimizer = torch.optim.Adam([x], lr=0.001) # Adjusted learning rate\n", + "\n", + "t_start = datetime.now()\n", + "for i in range(max_iterations):\n", + " if (i % 10 == 0 or i < 10):\n", + " print(f'Iteration {i+1}, x = {x.item()}')\n", + "\n", + " optimizer.zero_grad() # Clear gradients\n", + "\n", + " # Calculate the height at the desired time\n", + " y = f(x)\n", + "\n", + " # Check for NaN or Inf in y\n", + " if torch.isnan(y) or torch.isinf(y):\n", + " print(f\"NaN or Inf detected in y at iteration {i+1}. y = {y.item()}\")\n", + " break\n", + "\n", + " # Check for convergence\n", + " if torch.abs(y).item() < tolerance:\n", + " t_stop = datetime.now()\n", + " print(f'Converged after {i+1} iterations.')\n", + " print(f'Time taken: {t_stop - t_start}')\n", + " break\n", + "\n", + " # Define a suitable loss function.\n", + " # Here, we aim for y = 0\n", + " # instead of using the normalised loss directly, we add a small\n", + " # contribution eps to make sure the loss function is always well behaved.\n", + " loss_1 = (y) ** 2\n", + " loss = loss_1 / (loss_1 + eps)\n", + "\n", + " # Backpropagation\n", + " loss.backward()\n", + "\n", + " # Check for NaN or Inf in gradients\n", + " if torch.isnan(x.grad) or torch.isinf(x.grad):\n", + " print(f\"NaN or Inf detected in gradients at iteration {i+1}. x.grad = {x.grad.item()}\")\n", + " break\n", + "\n", + " # Optional: Gradient clipping\n", + " torch.nn.utils.clip_grad_norm_([x], max_norm=0.1)\n", + "\n", + " # Update parameters\n", + " optimizer.step()\n", + "\n", + " # Keep x within bounds using in-place clamping\n", + " with torch.no_grad():\n", + " x.clamp_(-5.0, 5.0) # Modify x in-place without breaking optimizer's reference" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kd2FGitu8npe", + "outputId": "0386b368-2162-48ca-e754-0a22fb93e67e" + }, + "execution_count": 22, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Iteration 1, x = 0.1\n", + "Iteration 2, x = 0.10099999673261355\n", + "Iteration 3, x = 0.10200011044436759\n", + "Iteration 4, x = 0.10300041908334917\n", + "Iteration 5, x = 0.10400100037775635\n", + "Iteration 6, x = 0.1050019316830876\n", + "Iteration 7, x = 0.10600328983345642\n", + "Iteration 8, x = 0.10700515099814113\n", + "Iteration 9, x = 0.10800759054439886\n", + "Iteration 10, x = 0.10901068290747899\n", + "Iteration 11, x = 0.11001450146866591\n", + "Iteration 21, x = 0.12010782089419586\n", + "Iteration 31, x = 0.13034356776889294\n", + "Iteration 41, x = 0.1407691440633229\n", + "Iteration 51, x = 0.15141798444594942\n", + "Iteration 61, x = 0.16231463653195177\n", + "Iteration 71, x = 0.17347928741416305\n", + "Iteration 81, x = 0.1849307374093407\n", + "Iteration 91, x = 0.19668810368985853\n", + "Iteration 101, x = 0.20877177835967936\n", + "Iteration 111, x = 0.22120402809044454\n", + "Iteration 121, x = 0.23400945696152126\n", + "Iteration 131, x = 0.24721544794349035\n", + "Iteration 141, x = 0.26085264449495554\n", + "Iteration 151, x = 0.2749555107729198\n", + "Iteration 161, x = 0.289563002076966\n", + "Iteration 171, x = 0.30471937852469216\n", + "Iteration 181, x = 0.32047520108949706\n", + "Iteration 191, x = 0.3368885586694067\n", + "Iteration 201, x = 0.3540265872567576\n", + "Iteration 211, x = 0.3719673568265278\n", + "Iteration 221, x = 0.39080221606839755\n", + "Iteration 231, x = 0.4106386932852906\n", + "Iteration 241, x = 0.43160403728642205\n", + "Iteration 251, x = 0.45384940396289863\n", + "Iteration 261, x = 0.47755445160808896\n", + "Iteration 271, x = 0.5029314524461943\n", + "Iteration 281, x = 0.5302263422793498\n", + "Iteration 291, x = 0.5595582586060651\n", + "Iteration 301, x = 0.5885031662349146\n", + "Iteration 311, x = 0.6151798116487809\n", + "Iteration 321, x = 0.6396521603239107\n", + "Iteration 331, x = 0.6623189827162203\n", + "Iteration 341, x = 0.6835490453049341\n", + "Iteration 351, x = 0.7036280924837964\n", + "Iteration 361, x = 0.7227696519108118\n", + "Iteration 371, x = 0.7407727561124511\n", + "Iteration 381, x = 0.7418034202846798\n", + "Iteration 391, x = 0.7370450318486789\n", + "Iteration 401, x = 0.7395462808085576\n", + "Iteration 411, x = 0.7390046213514914\n", + "Iteration 421, x = 0.7388322109519164\n", + "Iteration 431, x = 0.7384914069776777\n", + "Iteration 441, x = 0.7389556408359775\n", + "Iteration 451, x = 0.7391372240953635\n", + "Iteration 461, x = 0.7389927799168022\n", + "Iteration 471, x = 0.738965346523297\n", + "Iteration 481, x = 0.7390324072129005\n", + "Iteration 491, x = 0.7393768757578784\n", + "Converged after 495 iterations.\n", + "Time taken: 0:00:00.332195\n" + ] + } + ] + } + ] +} \ No newline at end of file -- GitLab