From e983d448ca8fbfe0d32e5661dabfd66b65516c7a Mon Sep 17 00:00:00 2001 From: fzh <1155233259@link.cuhk.edu.hk> Date: Tue, 31 Mar 2026 18:24:28 +0800 Subject: [PATCH 1/3] Add a folder containing codes for examples of loss and constraint selection --- .../STAR2000_GridSearchCV_SVM_losses.ipynb | 731 +++++++++++ .../STAR2000_GridSearchCV_reg losses.ipynb | 727 +++++++++++ .../STAR2000_constraint_Monotonicity.ipynb | 1118 ++++++++++++++++ examples_FEI/STAR2000_constraint_custom.ipynb | 1134 ++++++++++++++++ .../STAR2000_constraint_fairness.ipynb | 1120 ++++++++++++++++ examples_FEI/STAR2000_loss_MAE.ipynb | 1135 +++++++++++++++++ examples_FEI/STAR2000_loss_MSE.ipynb | 1119 ++++++++++++++++ examples_FEI/STAR2000_loss_QR.ipynb | 1096 ++++++++++++++++ examples_FEI/STAR2000_loss_QR_with_tol.ipynb | 1111 ++++++++++++++++ examples_FEI/STAR2000_loss_SVM.ipynb | 1111 ++++++++++++++++ examples_FEI/STAR2000_loss_SVR.ipynb | 1122 ++++++++++++++++ examples_FEI/STAR2000_loss_Smooth_SVM.ipynb | 1102 ++++++++++++++++ examples_FEI/STAR2000_loss_Squared_SVM.ipynb | 1105 ++++++++++++++++ examples_FEI/STAR2000_loss_huber.ipynb | 1135 +++++++++++++++++ 14 files changed, 14866 insertions(+) create mode 100644 examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb create mode 100644 examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb create mode 100644 examples_FEI/STAR2000_constraint_Monotonicity.ipynb create mode 100644 examples_FEI/STAR2000_constraint_custom.ipynb create mode 100644 examples_FEI/STAR2000_constraint_fairness.ipynb create mode 100644 examples_FEI/STAR2000_loss_MAE.ipynb create mode 100644 examples_FEI/STAR2000_loss_MSE.ipynb create mode 100644 examples_FEI/STAR2000_loss_QR.ipynb create mode 100644 examples_FEI/STAR2000_loss_QR_with_tol.ipynb create mode 100644 examples_FEI/STAR2000_loss_SVM.ipynb create mode 100644 examples_FEI/STAR2000_loss_SVR.ipynb create mode 100644 examples_FEI/STAR2000_loss_Smooth_SVM.ipynb create mode 100644 examples_FEI/STAR2000_loss_Squared_SVM.ipynb create mode 100644 examples_FEI/STAR2000_loss_huber.ipynb diff --git a/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb b/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb new file mode 100644 index 0000000..a84611e --- /dev/null +++ b/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb @@ -0,0 +1,731 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WaRThRkBIA5j", + "outputId": "c09f7839-f24b-449e-be17-70e66396bafd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-viuqut75\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-viuqut75\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=5c5be6969b966988219f8979e617a21f59ae88278f8d50cc95f710a096c4c4b4\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-cr7ssxvm/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "O76jxeIHIALp" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "IDityv5qCrQv" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 749 + }, + "id": "JKowJ-3KHCrF", + "outputId": "5e320f7f-0b17-427d-c5f3-7a8f5264c6d6" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf',\n", + " plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n", + " param_grid={'clf__C': [0.1, 1.0, 10.0],\n", + " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n", + " {'name': 'squared SVM'}]})" + ], + "text/html": [ + "
GridSearchCV(cv=5,\n",
+              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                                       ('clf',\n",
+              "                                        plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n",
+              "             param_grid={'clf__C': [0.1, 1.0, 10.0],\n",
+              "                         'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n",
+              "                                       {'name': 'squared SVM'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## compare SVM losses via GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Classifier\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))\n", + "])\n", + "\n", + "# Define the parameter grid to search\n", + "param_grid = {\n", + " 'clf__C': [0.1, 1.0, 10.0],\n", + " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'}, {'name': 'squared SVM'}]\n", + "}\n", + "\n", + "# Create the GridSearchCV object\n", + "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", + "grid_search.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C5_7b71QM9XK", + "outputId": "7258d1c2-318d-4319-eca5-7b6d2f4522a8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Overall Best Params: {'clf__C': 0.1, 'clf__loss': {'name': 'svm'}}\n", + "Overall Best Score: 0.8922\n" + ] + } + ], + "source": [ + "# Print the best loss function and score\n", + "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", + "print(f\"Overall Best Score: {grid_search.best_score_:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TxnC0FjziZvD" + }, + "source": [ + "#Compare SVM & Smooth SVM & Squared SVM" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eiqipAokiYf5", + "outputId": "5b4db390-faaa-445c-997a-e17450e6b538" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Loss Best C CV Score\n", + " svm 0.1 0.8922\n", + " sSVM 0.1 0.8920\n", + "squared SVM 0.1 0.8913\n" + ] + } + ], + "source": [ + "## print best results per loss\n", + "import pandas as pd\n", + "df = pd.DataFrame(grid_search.cv_results_)\n", + "df['Loss'] = df['param_clf__loss'].apply(lambda x: x['name'])\n", + "df = df.sort_values('mean_test_score', ascending=False)\n", + "best = df.drop_duplicates(subset=['Loss'])\n", + "table = best[['Loss', 'param_clf__C', 'mean_test_score']].rename(\n", + " columns={'param_clf__C': 'Best C', 'mean_test_score': 'CV Score'}\n", + ")\n", + "\n", + "print(table.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 341 + }, + "id": "27SVRgNeIp7G", + "outputId": "f3506667-d777-470f-af04-7ed54f2ed128" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot score distributions for best models\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "y_label = 2*y - 1\n", + "for i in range(len(best)):\n", + " loss = best['Loss'].iloc[i]\n", + " c = best['param_clf__C'].iloc[i]\n", + "\n", + " pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': loss}, C=c))\n", + " ])\n", + " pipe.fit(X, y)\n", + "\n", + " score = pipe.decision_function(X)\n", + " df = pd.DataFrame({'score': score, 'y': y_label})\n", + " sns.histplot(df, x=\"score\", hue=\"y\", ax=axes[i]).set_title(loss)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb b/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb new file mode 100644 index 0000000..7663f41 --- /dev/null +++ b/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb @@ -0,0 +1,727 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "O_SFIipUcSyD", + "outputId": "77c9f603-de96-4c8f-9ca8-727c475e211c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-qbh74ba5\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-qbh74ba5\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=743e41d2730cd6d801ec5c3acbc3d6ace163b9c318a9ba67a4592dec9587353d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-5c6fypql/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "\n", + "X, y = make_regression(n_samples=10000, n_features=5, noise=30.0, random_state=42)\n", + "y = y / y.std()\n", + "y[-40:] += 20" + ], + "metadata": { + "id": "mLPT_rZskyrr" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## compare Huber, MAE and MSE via GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Regressor\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mse'}))\n", + "])\n", + "\n", + "# Define the parameter grid to search\n", + "param_grid = {\n", + " 'reg__C': [0.1, 1.0, 10.0],\n", + " 'reg__loss': [{'name': 'huber', 'tau': 1.0}, {'name': 'mae'}, {'name': 'mse'}]\n", + "}\n", + "\n", + "# Create the GridSearchCV object\n", + "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", + "grid_search.fit(X, y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 898 + }, + "id": "cd-YVK8UpDD0", + "outputId": "883eb665-7c89-4910-f2f1-7c03335725b0" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n", + " param_grid={'reg__C': [0.1, 1.0, 10.0],\n", + " 'reg__loss': [{'name': 'huber', 'tau': 1.0},\n", + " {'name': 'mae'}, {'name': 'mse'}]})" + ], + "text/html": [ + "
GridSearchCV(cv=5,\n",
+              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                                       ('reg',\n",
+              "                                        plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n",
+              "             param_grid={'reg__C': [0.1, 1.0, 10.0],\n",
+              "                         'reg__loss': [{'name': 'huber', 'tau': 1.0},\n",
+              "                                       {'name': 'mae'}, {'name': 'mse'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print the best loss function and score\n", + "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", + "print(f\"Overall Best Score: {grid_search.best_score_:.5f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cHQEgKt8pMKr", + "outputId": "e5c4d1ea-241b-4a99-a921-71e23e3f0fb9" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Overall Best Params: {'reg__C': 1.0, 'reg__loss': {'name': 'mae'}}\n", + "Overall Best Score: 0.77874\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print best results per loss\n", + "import pandas as pd\n", + "df = pd.DataFrame(grid_search.cv_results_)\n", + "df['Loss'] = df['param_reg__loss'].apply(lambda x: x['name'])\n", + "df = df.sort_values('mean_test_score', ascending=False)\n", + "best = df.drop_duplicates(subset=['Loss'])\n", + "table = best[['Loss', 'param_reg__C', 'mean_test_score']].rename(\n", + " columns={'param_reg__C': 'Best C', 'mean_test_score': 'CV Score'}\n", + ")\n", + "\n", + "print(table.to_string(index=False))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IgxOOM3_pIwW", + "outputId": "23690687-ec0f-456b-f5d0-57431d715d42" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Loss Best C CV Score\n", + " mae 1.0 0.778740\n", + "huber 0.1 0.778691\n", + " mse 0.1 0.769240\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "\n", + "for i in range(len(best)):\n", + " loss = best['Loss'].iloc[i]\n", + " c = best['param_reg__C'].iloc[i]\n", + "\n", + " pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': loss}, C=c))\n", + " ])\n", + " pipe.fit(X, y)\n", + "\n", + " pred_y = pipe.predict(X_sample)\n", + " df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'pred': pred_y})\n", + " df = df.melt(id_vars='x0')\n", + "\n", + " sns.scatterplot(data=df, x='x0', y='value', hue='variable', ax=axes[i], alpha=0.8).set_title(f\"{loss} (C={c})\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 378 + }, + "id": "SrjMX-b9pVus", + "outputId": "9326400e-29fd-4f4f-efb4-6288377b4d75" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_Monotonicity.ipynb b/examples_FEI/STAR2000_constraint_Monotonicity.ipynb new file mode 100644 index 0000000..bd4a1aa --- /dev/null +++ b/examples_FEI/STAR2000_constraint_Monotonicity.ipynb @@ -0,0 +1,1118 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g0aAqkkRKc6z", + "outputId": "06c1fb56-1382-4149-dde3-b26e56885079" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2rmdz0d2\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2rmdz0d2\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=38277498b08288819d7a48307b30d8730b6eb14a44a4d7599dce3f918735056d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmjsudwd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "4ibK-1gsR0ZB" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, n_redundant=0, random_state=42)\n", + "y = 2*y - 1\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "#SVM as baseline" + ], + "metadata": { + "id": "Oak-k1Ps9hDS" + } + }, + { + "cell_type": "code", + "source": [ + "## we first run a SVM\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=0.001, max_iter=10000)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "Uk31Pe_cg702", + "outputId": "b0a34980-ffd2-44a1-dcd6-d7232221510e" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Monotonic constraint" + ], + "metadata": { + "id": "OU3yWxlR9d29" + } + }, + { + "cell_type": "code", + "source": [ + "## solve SVM with Monotonicity Constraint via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Classifier\n", + "mclf = plq_Ridge_Classifier(\n", + " loss={'name': 'svm'},\n", + " constraint = [{'name': 'monotonic', 'decreasing': True}],\n", + " C=0.001,\n", + " max_iter=10000\n", + ")\n", + "mclf.fit(X=X, y=y)" + ], + "metadata": { + "id": "APrF6OYJl1_t", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 114 + }, + "outputId": "c90e1964-a77b-4d24-a0e6-0f41a06a92d9" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(C=0.001,\n", + " constraint=[{'decreasing': True, 'name': 'monotonic'}],\n", + " loss={'name': 'svm'}, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(C=0.001,\n",
+              "                     constraint=[{'decreasing': True, 'name': 'monotonic'}],\n",
+              "                     loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Results" + ], + "metadata": { + "id": "GbDGb79w9aOh" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "##score\n", + "score = clf.decision_function(X)\n", + "mscore = mclf.decision_function(X)\n", + "\n", + "svm_perf = len(y[score*y > 0])/ n\n", + "msvm_perf = len(y[mscore*y > 0])/ n\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['SVM', 'MonotonicSVM'],\n", + " 'Train Performance': [svm_perf, msvm_perf]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))\n", + "\n", + "#Print the results of monotonic constraint\n", + "print(\"\\nCoefficients (no constraint):\")\n", + "print(clf.coef_)\n", + "print(\"\\nCoefficients (monotonic increasing):\")\n", + "print(mclf.coef_)\n", + "print(\"Monotonic descreasing satisfied:\",\n", + " np.all(mclf.coef_[:-1] >= mclf.coef_[1:]))" + ], + "metadata": { + "id": "fDmbka9Wx-jd", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4b2f868f-fdf0-45d0-de3a-0c62b1116f5d" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train Performance\n", + " SVM 0.8870\n", + "MonotonicSVM 0.7332\n", + "\n", + "Coefficients (no constraint):\n", + "[-0.00464203 1.30915325 0.11882663 -0.02067285 0.00381067]\n", + "\n", + "Coefficients (monotonic increasing):\n", + "[ 0.6899007 0.68988743 0.05962067 -0.01259596 -0.01275567]\n", + "Monotonic descreasing satisfied: True\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "df = pd.DataFrame({'score': score, 'mscore': mscore, 'y': y})\n", + "\n", + "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", + "plt.show()\n", + "sns.histplot(df, x=\"mscore\", hue=\"y\").set_title(\"Monotonic SVM\")\n", + "plt.show()" + ], + "metadata": { + "id": "GmOPIjrhyAZ3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 885 + }, + "outputId": "c70e7404-5c70-49a2-b5d0-dde4a5dbcc99" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_custom.ipynb b/examples_FEI/STAR2000_constraint_custom.ipynb new file mode 100644 index 0000000..b8b5102 --- /dev/null +++ b/examples_FEI/STAR2000_constraint_custom.ipynb @@ -0,0 +1,1134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "350gRKl8oZO8", + "outputId": "9c10c6b4-3bd4-4b8d-8fef-7a0e794a21ba" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ecam8nvm\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ecam8nvm\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=afb3663e756869bae441a557cc1076d200b509a9bcedfa3e89973806add3d6e3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-ojkpm13e/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "MbOVhGJWC1bM" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "X = scaler.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "FGHO9F1QZK5M" + }, + "outputs": [], + "source": [ + "# Example: beta_0 + beta_1 >= 3\n", + "A = np.zeros((1, d))\n", + "A[0, 0] = 1\n", + "A[0, 1] = 1\n", + "b = np.array([-3.0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jAQHQ9HRcbzd" + }, + "source": [ + "#QR as baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "F4kiv_VqJF6t", + "outputId": "1d12d12d-fee1-4273-8d89-2980b4a80d2d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "## we first run a QR\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(\n", + " loss={'name': 'QR', 'qt': 0.5},\n", + " C=1.0,\n", + " max_iter=10000,\n", + " fit_intercept=False\n", + ")\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NHjMQ-vnclTL" + }, + "source": [ + "#Custom Constraint" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 114 + }, + "id": "beKf5mp-R3_5", + "outputId": "43fdfed2-38da-42a5-dcdc-88427e06a1fb" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n", + " 'b': array([-3.]), 'name': 'custom'}],\n", + " fit_intercept=False, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n",
+              "                                 'b': array([-3.]), 'name': 'custom'}],\n",
+              "                    fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "## solve custom via `plq_Ridge_Regressor` by adding `constraint`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "cclf = plq_Ridge_Regressor(\n", + " loss={'name': 'QR', 'qt': 0.5},\n", + " constraint=[{'name': 'custom', 'A': A, 'b': b}],\n", + " C=1.0,\n", + " max_iter=10000,\n", + " fit_intercept=False\n", + ")\n", + "cclf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zQOfvMjRR6Fn", + "outputId": "a7964e49-afd3-4f1a-d4b5-38a55b214dfc" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train MSE\n", + " QR 0.000097\n", + "Custom QR 1.352705\n", + "\n", + "coef_0 + coef_1 = 3.00000008, >= 3: True\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "## score\n", + "score = clf.predict(X)\n", + "cscore = cclf.predict(X)\n", + "\n", + "qr_perf = np.mean((y - score)**2)\n", + "cqr_perf = np.mean((y - cscore)**2)\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['QR', 'Custom QR'],\n", + " 'Train MSE': [qr_perf, cqr_perf]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))\n", + "#Print the results of custom constraint\n", + "lhs = cclf.coef_[0] + cclf.coef_[1]\n", + "print(f\"\\ncoef_0 + coef_1 = {lhs:.8f}, >= 3: {lhs >= 3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 884 + }, + "id": "zWGh56JmZ00l", + "outputId": "9809836c-af7d-4461-fb3d-05bf25ae7908" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "qr_sample = clf.predict(X_sample)\n", + "cqr_sample = cclf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({\n", + " 'x0': X_sample[:, 0],\n", + " 'real_y': y_sample,\n", + " 'QR': qr_sample,\n", + " 'Custom_QR': cqr_sample\n", + "})\n", + "\n", + "df1 = df[['x0', 'real_y', 'QR']].melt(id_vars='x0')\n", + "sns.scatterplot(data=df1, x='x0', y='value', hue='variable').set_title(\"QR\")\n", + "plt.show()\n", + "df2 = df[['x0', 'real_y', 'Custom_QR']].melt(id_vars='x0')\n", + "sns.scatterplot(data=df2, x='x0', y='value', hue='variable').set_title(\"Custom QR\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_fairness.ipynb b/examples_FEI/STAR2000_constraint_fairness.ipynb new file mode 100644 index 0000000..1e782f7 --- /dev/null +++ b/examples_FEI/STAR2000_constraint_fairness.ipynb @@ -0,0 +1,1120 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CdpIoLwYNrOE", + "outputId": "4f08447f-8eac-4a9b-fab2-348e48c3f162" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-aslp0p5z\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-aslp0p5z\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e70f4bd1f1915f6a955fc096395a6757bc4c0b710df4f11b2be6f22239334ed7\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-5e872vry/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "FcaI-p84K6m4" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, n_redundant=2, random_state=42)\n", + "y = 2*y - 1\n", + "X = scaler.fit_transform(X)\n", + "\n", + "## we take the first column of X as sensitive features, and tol is 0.1\n", + "sen_idx = [0]\n", + "tol_sen = 0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VEQKzCdrM3ii" + }, + "source": [ + "#SVM as baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "uUMv2d0ZM1X5", + "outputId": "204172ec-5440-4945-a18e-caf1695b6ef0" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ], + "source": [ + "## we first run a SVM\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0, max_iter=50000)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4S9GFijHNPCC" + }, + "source": [ + "#FairSVM" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 172 + }, + "id": "F17oa5oUNGed", + "outputId": "5977c594-17c7-4be0-a558-cb998a249fc8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n", + " 'tol_sen': 0.1}],\n", + " loss={'name': 'svm'}, max_iter=50000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n",
+              "                                  'tol_sen': 0.1}],\n",
+              "                     loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve FairSVM via `plq_Ridge_Classifier` by adding `constraint`\n", + "fclf = plq_Ridge_Classifier(loss={'name': 'svm'},\n", + " constraint=[{'name': 'fair',\n", + " 'sen_idx': sen_idx,\n", + " 'tol_sen': tol_sen}],\n", + " C=1.0,\n", + " max_iter=50000)\n", + "fclf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4PsZ5ASPO2lN" + }, + "source": [ + "#Results" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WNhi1tI_NJc_", + "outputId": "b238f852-af11-49ed-d2c4-e3677e248a7c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train Performance Correlation with Sensitive Features\n", + " SVM 0.8927 2.417714\n", + "FairSVM 0.5278 0.100728\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "## score\n", + "X_sen = X[:, sen_idx]\n", + "score = clf.decision_function(X)\n", + "fscore = fclf.decision_function(X)\n", + "\n", + "svm_perf = len(y[score*y > 0])/n\n", + "fsvm_perf = len(y[fscore*y > 0])/n\n", + "\n", + "svm_corr = score.dot(X_sen) / n\n", + "fsvm_corr = fscore.dot(X_sen) / n\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['SVM', 'FairSVM'],\n", + " 'Train Performance': [svm_perf, fsvm_perf],\n", + " 'Correlation with Sensitive Features': [svm_corr[0], fsvm_corr[0]]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 926 + }, + "id": "rKNP993vNMAo", + "outputId": "9df96109-c2d8-495d-a889-ff3cc61613f0" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN9NJREFUeJzt3Xl8FfW9//F3AlnYkhSysSQBAQkBBGQNqBWISSG9iqCiICIiVhqoglUai4K0giIVahqgtRj0llRKq60CiiEsKgkRo1j2K15sMDvFENYknMzvD2/Or8fkJCQ5Ocvwej4e59Ge+X5n5vPNGHgz850ZL8MwDAEAAJiUt6sLAAAAaEmEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQBu7+DBg7rrrrsUFRUlf39/de3aVbfddptSUlL02WefycvLS4sWLbK7/pdffikvLy8tWLBAkrRkyRJ5eXnJ29tbp06dqtW/vLxcbdq0kZeXl+bOndti4wLgHIQdAG4tKytLQ4cO1RdffKHZs2frd7/7nR5++GF5e3vrt7/9rW688UZFR0frz3/+s91tpKenS5Luv/9+m+V+fn51rvfWW285dhAAXKq1qwsAgPo8//zzCgwM1P79+xUUFGTTVlJSIkmaNm2annnmGe3bt08jR46stY0///nPio6O1o033mizfMKECfrzn/+sp556ymZ5enq6EhMT9be//c2xgwHgEpzZAeDWvvrqK/Xr169W0JGk0NBQSd+FHen/n8H5T7m5uTp+/Li1z3+aOnWqDhw4oGPHjlmXFRUVaefOnZo6daqDRgDA1Qg7ANxaVFSUcnNzdejQIbt9evTooVGjRukvf/mLLBaLTVtNAKorvNxyyy3q1q2bTUjatGmT2rdvr8TERAeNAICrEXYAuLWf//znunjxogYNGqRRo0Zp4cKF+uCDD1RVVWXTb9q0aSouLlZmZqZ1WXV1tTZt2qTY2Fhdd911tbbt5eWle++912bezsaNGzVp0iT5+fm13KAAOBVhB4Bbu+2225Sdna3bb79dX3zxhVasWKGEhAR17dpV77zzjrXflClT5OPjY3OWZs+ePcrPz6/zElaNqVOn6sSJE9q/f7/1f7mEBZgLYQeA2xs2bJjeeustffvtt/rkk0+UnJysc+fO6a677tKRI0ckSZ06dVJCQoLefvttXb58WdJ3l7Bat26te+65x+62Bw8erOjoaKWnp2vjxo0KDw/X2LFjnTIuAM5B2AHgMXx9fTVs2DAtW7ZMa9euVVVVlTZv3mxtv//++1VeXq4tW7aosrJSf/vb3xQfH6+QkJB6tzt16lRt2rRJ6enpmjJliry9+aMRMBN+owF4pKFDh0qSCgsLrctuv/12dejQQenp6Xrvvff07bff1nsJq8bUqVNVWFio//mf/+ESFmBCPGcHgFvbtWuXbr31Vnl5edks37ZtmySpT58+1mVt2rTRnXfeqU2bNunixYtq166d7rjjjgb30bNnT61evVqXLl3S8OHDHTsAAC5H2AHg1ubNm6eLFy/qzjvvVHR0tCorK5WVlaVNmzape/fumjlzpk3/+++/X2+88Ya2b9+uadOmqV27dle1n8cee6wlygfgBgg7ANzaypUrtXnzZm3btk1/+MMfVFlZqcjISP30pz/VokWLaj1scOzYsercubMKCwuv6hIWAPPzMgzDcHURAAAALYUJygAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNR4zo6k6upqFRQUqEOHDrWe0goAANyTYRg6d+6cunTpUu877Qg7kgoKChQREeHqMgAAQBOcOnVK3bp1s9tO2JHUoUMHSd/9sAICAlxcDQAAuBrl5eWKiIiw/j1uD2FHsl66CggIIOwAAOBhGpqCwgRlAABgaoQdAABgaoQdAABgaszZAQDAQ1gsFlVVVbm6DKfx8fFRq1atmr0dwg4AAG7OMAwVFRWprKzM1aU4XVBQkMLDw5v1HDzCDgAAbq4m6ISGhqpt27bXxANwDcPQxYsXVVJSIknq3Llzk7dF2AEAwI1ZLBZr0OnUqZOry3GqNm3aSJJKSkoUGhra5EtaTFAGAMCN1czRadu2rYsrcY2acTdnrhJhBwAAD3AtXLqqiyPGTdgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAAA23njjDXXq1EkVFRU2yydOnKjp06e7qKqmI+wAAAAbd999tywWi9555x3rspKSEm3dulUPPfSQCytrGh4qCMCpxo4Zo9LSUrvtISEh2rlrlxMrAvB9bdq00dSpU5WWlqa7775bkvSnP/1JkZGRuvXWW11bXBMQdgA4VWlpqXJ2bLfbPiIuwYnVALBn9uzZGjZsmPLz89W1a1dt2LBBDz74oEc+74ewAwAAahk8eLAGDhyoN954Q/Hx8Tp8+LC2bt3q6rKahLADAADq9PDDD2v16tXKz89XXFycIiIiXF1SkzBBGQAA1Gnq1Kn65ptv9Oqrr3rkxOQanNkB4Fby8/M1oH9/u+1MYAacJzAwUJMnT9bWrVs1ceJEV5fTZIQdAG7FMKqZwAy4kfz8fE2bNk1+fn6uLqXJCDsAAKCWb7/9Vrt379bu3bu1Zs0aV5fTLIQdAABQy+DBg/Xtt9/qxRdfVJ8+fVxdTrMQdgAAQC1ff/21q0twGO7GAgAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApsbdWADggW4afbOKi4vstoeFhevjvR85sSLAfRF2AMADFRcXaX7S03bbV6Uuc2I1cJW8vDydPn3aKfsKDg5WZGSkU/blaIQdADCh/PwC9e7V2247Z348X15envr27auLFy86ZX9t27bV0aNHmxV43nrrLa1bt065ubk6c+aMPv/8cw0aNMhxRdpB2AEAE7JYLJz5MbnTp0/r4sWLWv+7V9Snt/1g6wjHv/xSs+b+TKdPn25W2Llw4YJuuukm3XPPPZo9e7YDK6wfYQcAAA/Wp3dvDb5hgKvLuCrTp0+X5PynM3M3FgAAMDXCDgAAMDXCDgAAcLiNGzeqffv21s9HH7luQjxzdgAAgMPdfvvtGjFihPV7165dXVYLYQeAQ40dM0alpaV22wsLCpxYDQBX6dChgzp06ODqMiQRdgA4WGlpqXJ2bLfb3jU6xonVAHAnZ86cUV5engr+7x89x48flySFh4crPDy8xfZL2AEAwIMd//JLj9nHO++8o5kzZ1q/33vvvZKkxYsXa8mSJQ7ZR10IOwAAeKDg4GC1bdtWs+b+zCn7a9u2rYKDg5u1jQcffFAPPvigYwpqBMIOAAAeKDIyUkePHuXdWFeBsAMAgIeKjIz02ADiTDxnBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBrP2QEAwEPl5eXxUMGrQNgBAMAD5eXlKTo6WpcuXXLK/tq0aaNjx441KvB8+OGHeumll5Sbm6vCwkK9/fbbmjhxYssVaQdhBwAAD3T69GldunRJM6bNVnhYlxbdV1FxgV7f+KpOnz7dqLBz4cIFDRw4UA899JAmTZrUghXWj7ADAIAHCw/roshuUa4uo07jx4/X+PHjXV0GE5QBAIC5EXYAAICpEXYAAICpEXYAAICpMUEZQKOMHTNGpaWldtsLCwqcWA2aKj+/QL179a63T1hYuD7e+5GTKgJaDmEHgFVDQUb6LszkHTlot71rdIyjy0ILsFgsmp/0dL19VqUuc1I1MKvz58/rxIkT1u8nT57UgQMH1LFjR6c+oJCwA8CqtLRUOTu219uHMAO4l6Lilj+b2tR9fPrppxozZoz1+4IFCyRJM2bM0IYNGxxR2lVxm7DzwgsvKDk5WY899phWr14tSbp8+bKeeOIJvfnmm6qoqFBCQoLWrFmjsLAw63p5eXmaM2eOdu3apfbt22vGjBlavny5Wrd2m6EBAOBwwcHBatOmjV7f+KpT9temTRsFBwc3ap1bb71VhmG0UEVXzy0Swf79+/X73/9eN9xwg83y+fPna+vWrdq8ebMCAwM1d+5cTZo0SXv37pX03WnYxMREhYeHKysrS4WFhXrggQfk4+OjZcs4/QoAMK/IyEgdO3aMd2NdBZeHnfPnz2vatGl69dVX9etf/9q6/OzZs1q/fr3S09M1duxYSVJaWpr69u2rffv2aeTIkfrggw905MgR7dixQ2FhYRo0aJB+9atfaeHChVqyZIl8fX1dNSwAaJabRt+s4uIiu+35+UwEx3eBx1MDiDO5POwkJSUpMTFRcXFxNmEnNzdXVVVViouLsy6Ljo5WZGSksrOzNXLkSGVnZ2vAgAE2l7USEhI0Z84cHT58WIMHD65znxUVFaqoqLB+Ly8vb4GRAUDTFRcX1TuBeP7COU6sBvBsLg07b775pj777DPt37+/VltRUZF8fX0VFBRkszwsLExFRUXWPv8ZdGraa9rsWb58uZ577rlmVg8ATceZG8B5XBZ2Tp06pccee0wZGRny9/d36r6Tk5OtM8Kl787sREREOLUGANc2ztygsdxhoq8rOGLcLnuCcm5urkpKSnTjjTeqdevWat26tfbs2aNXXnlFrVu3VlhYmCorK1VWVmazXnFxscLDwyVJ4eHhKi4urtVe02aPn5+fAgICbD4AALgjHx8fSdLFixddXIlr1Iy75ufQFC47szNu3DgdPGj7YLKZM2cqOjpaCxcuVEREhHx8fJSZmanJkydLko4fP668vDzFxsZKkmJjY/X888+rpKREoaGhkqSMjAwFBAQoJoZngQAAPF+rVq0UFBSkkpISSVLbtm3l5eXl4qpanmEYunjxokpKShQUFKRWrVo1eVsuCzsdOnRQ//79bZa1a9dOnTp1si6fNWuWFixYoI4dOyogIEDz5s1TbGysRo4cKUmKj49XTEyMpk+frhUrVqioqEiLFi1SUlKS/Pz8nD4mAABaQs3ViprAcy0JCgqq92rN1XD53Vj1WbVqlby9vTV58mSbhwrWaNWqlbZs2aI5c+YoNjZW7dq104wZM7R06VIXVg0AgGN5eXmpc+fOCg0NVVVVlavLcRofH59mndGp4VZhZ/fu3Tbf/f39lZqaqtTUVLvrREVFadu2bS1cGQAArteqVSuH/OV/rXHZBGUAAABnIOwAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTc6u3ngNAQ/Lz8zWgf/96+4SEhGjnrl1OqgiAuyPsAPAohlGtnB3b6+0zIi7BSdUA8ARcxgIAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKbW2tUFAIDZ3DT6ZhUXF9XbJz+/wEnVACDsAICDFRcXaX7S0/X2mb9wjpOqAcBlLAAAYGqc2QFgOvn5+RrQv7/d9pCQEO3ctcuJFQFwJcIOANMxjGrl7Nhut31EXIITq/Fc+fkF6t2rt932sLBwfbz3IydWBDQNYQcAUCeLxVLv3KNVqcucWA3QdMzZAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAAptba1QUAgKe5afTNKi4ustuen1/gxGoANISwAwCNVFxcpPlJT9ttn79wjhOrAdAQLmMBAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABT424sAECT5OcXqHev3nbbw8LC9fHej5xYEVA3wg4AoEksFku9t+CvSl3mxGoA+1x6GWvt2rW64YYbFBAQoICAAMXGxuq9996ztl++fFlJSUnq1KmT2rdvr8mTJ6u4uNhmG3l5eUpMTFTbtm0VGhqqJ598UleuXHH2UAAAgJtyadjp1q2bXnjhBeXm5urTTz/V2LFjdccdd+jw4cOSpPnz5+vdd9/V5s2btWfPHhUUFGjSpEnW9S0WixITE1VZWamsrCy9/vrr2rBhg5599llXDQkAALgZl17G+q//+i+b788//7zWrl2rffv2qVu3blq/fr3S09M1duxYSVJaWpr69u2rffv2aeTIkfrggw905MgR7dixQ2FhYRo0aJB+9atfaeHChVqyZIl8fX1dMSwAAOBG3OZuLIvFojfffFMXLlxQbGyscnNzVVVVpbi4OGuf6OhoRUZGKjs7W5KUnZ2tAQMGKCwszNonISFB5eXl1rNDdamoqFB5ebnNBwAAmJPLw87BgwfVvn17+fn56dFHH9Xbb7+tmJgYFRUVydfXV0FBQTb9w8LCVFT03Qv4ioqKbIJOTXtNmz3Lly9XYGCg9RMREeHYQQEAALfh8rDTp08fHThwQDk5OZozZ45mzJihI0eOtOg+k5OTdfbsWevn1KlTLbo/AADgOi6/9dzX11e9evWSJA0ZMkT79+/Xb3/7W02ZMkWVlZUqKyuzObtTXFys8PBwSVJ4eLg++eQTm+3V3K1V06cufn5+8vPzc/BIAACAO3L5mZ3vq66uVkVFhYYMGSIfHx9lZmZa244fP668vDzFxsZKkmJjY3Xw4EGVlJRY+2RkZCggIEAxMTFOrx0AALgfl57ZSU5O1vjx4xUZGalz584pPT1du3fv1vbt2xUYGKhZs2ZpwYIF6tixowICAjRv3jzFxsZq5MiRkqT4+HjFxMRo+vTpWrFihYqKirRo0SIlJSVx5gYAAEhycdgpKSnRAw88oMLCQgUGBuqGG27Q9u3bddttt0mSVq1aJW9vb02ePFkVFRVKSEjQmjVrrOu3atVKW7Zs0Zw5cxQbG6t27dppxowZWrp0qauGBAAA3IxLw8769evrbff391dqaqpSU1Pt9omKitK2bdscXRoAADAJt5uzAwAA4EiEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGoufxEoALibm0bfrOLiIrvt+fkFTqwGQHMRdgDge4qLizQ/6Wm77fMXznFiNQCai8tYAADA1Ag7AADA1Ag7AADA1Ag7AADA1Ag7AADA1JoUdq677jr9+9//rrW8rKxM1113XbOLAgAAcJQmhZ2vv/5aFoul1vKKigrl5+c3uygAAABHadRzdt555x3r/9++fbsCAwOt3y0WizIzM9W9e3eHFQfAscaOGaPS0lK77YUFPCwPgPk0KuxMnDhRkuTl5aUZM2bYtPn4+Kh79+76zW9+47DiADhWaWmpcnZst9veNTrGidUAgHM0KuxUV1dLknr06KH9+/crODi4RYoCAABwlCa9LuLkyZOOrgOAA3CZCgBqa/K7sTIzM5WZmamSkhLrGZ8ar732WrMLA9B4XKYCgNqaFHaee+45LV26VEOHDlXnzp3l5eXl6LoAAAAcoklhZ926ddqwYYOmT5/u6HoAAAAcqknP2amsrNSoUaMcXQsAAIDDNSnsPPzww0pPT3d0LQAAAA7XpMtYly9f1h/+8Aft2LFDN9xwg3x8fGzaX375ZYcUBwAA0FxNCjv//Oc/NWjQIEnSoUOHbNqYrAwAANxJk8LOrl27HF0HAABAi2jSnB0AAABP0aQzO2PGjKn3ctXOnTubXBAAAIAjNSns1MzXqVFVVaUDBw7o0KFDtV4QCgAA4EpNCjurVq2qc/mSJUt0/vz5ZhUEAADgSA6ds3P//ffzXiwAAOBWHBp2srOz5e/v78hNAgAANEuTLmNNmjTJ5rthGCosLNSnn36qZ555xiGFAQAAOEKTwk5gYKDNd29vb/Xp00dLly5VfHy8QwoDAABwhCaFnbS0NEfXAQAA0CKaFHZq5Obm6ujRo5Kkfv36afDgwQ4pCgAAwFGaFHZKSkp07733avfu3QoKCpIklZWVacyYMXrzzTcVEhLiyBoBAACarEl3Y82bN0/nzp3T4cOHdebMGZ05c0aHDh1SeXm5fvaznzm6RgAAgCZr0pmd999/Xzt27FDfvn2ty2JiYpSamsoEZQAA4FaadGanurpaPj4+tZb7+Piourq62UUBAAA4SpPCztixY/XYY4+poKDAuiw/P1/z58/XuHHjHFYcAABAczUp7Pzud79TeXm5unfvrp49e6pnz57q0aOHysvLlZKS4ugaAQAAmqxJc3YiIiL02WefaceOHTp27JgkqW/fvoqLi3NocQAAAM3VqDM7O3fuVExMjMrLy+Xl5aXbbrtN8+bN07x58zRs2DD169dPH330UUvVCgAA0GiNCjurV6/W7NmzFRAQUKstMDBQP/nJT/Tyyy87rDgAAIDmatRlrC+++EIvvvii3fb4+HitXLmy2UUBQEvKz8/XgP797baXlpY4sRoALa1RYae4uLjOW86tG2vdWqWlpc0uCgBakmFUK2fHdrvtXa7va7cNVy8/v0C9e/W22x4WFq6P9zL1AS2vUWGna9euOnTokHr16lVn+z//+U917tzZIYUBADybxWLR/KSn7bavSl3mxGpwLWvUnJ0JEybomWee0eXLl2u1Xbp0SYsXL9aPf/xjhxUHAADQXI06s7No0SK99dZbuv766zV37lz16dNHknTs2DGlpqbKYrHol7/8ZYsUCgAA0BSNCjthYWHKysrSnDlzlJycLMMwJEleXl5KSEhQamqqwsLCWqRQAACApmj0QwWjoqK0bds2ffvttzpx4oQMw1Dv3r31gx/8oCXqAwAAaJYmPUFZkn7wgx9o2LBhjqwFAADA4Zr0biwAAABPQdgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACm5tKws3z5cg0bNkwdOnRQaGioJk6cqOPHj9v0uXz5spKSktSpUye1b99ekydPVnFxsU2fvLw8JSYmqm3btgoNDdWTTz6pK1euOHMoAADATbk07OzZs0dJSUnat2+fMjIyVFVVpfj4eF24cMHaZ/78+Xr33Xe1efNm7dmzRwUFBZo0aZK13WKxKDExUZWVlcrKytLrr7+uDRs26Nlnn3XFkAAAgJtp8usiHOH999+3+b5hwwaFhoYqNzdXt9xyi86ePav169crPT1dY8eOlSSlpaWpb9++2rdvn0aOHKkPPvhAR44c0Y4dOxQWFqZBgwbpV7/6lRYuXKglS5bI19fXFUMDAABuwq3m7Jw9e1aS1LFjR0lSbm6uqqqqFBcXZ+0THR2tyMhIZWdnS5Kys7M1YMAAm7etJyQkqLy8XIcPH65zPxUVFSovL7f5AAAAc3KbsFNdXa3HH39co0ePVv/+/SVJRUVF8vX1VVBQkE3fsLAwFRUVWfv8Z9Cpaa9pq8vy5csVGBho/URERDh4NAAAwF24TdhJSkrSoUOH9Oabb7b4vpKTk3X27Fnr59SpUy2+TwAA4BounbNTY+7cudqyZYs+/PBDdevWzbo8PDxclZWVKisrszm7U1xcrPDwcGufTz75xGZ7NXdr1fT5Pj8/P/n5+Tl4FAAAwB259MyOYRiaO3eu3n77be3cuVM9evSwaR8yZIh8fHyUmZlpXXb8+HHl5eUpNjZWkhQbG6uDBw+qpKTE2icjI0MBAQGKiYlxzkAAAIDbcumZnaSkJKWnp+sf//iHOnToYJ1jExgYqDZt2igwMFCzZs3SggUL1LFjRwUEBGjevHmKjY3VyJEjJUnx8fGKiYnR9OnTtWLFChUVFWnRokVKSkri7A0AAHBt2Fm7dq0k6dZbb7VZnpaWpgcffFCStGrVKnl7e2vy5MmqqKhQQkKC1qxZY+3bqlUrbdmyRXPmzFFsbKzatWunGTNmaOnSpc4aBgAAcGMuDTuGYTTYx9/fX6mpqUpNTbXbJyoqStu2bXNkaQAAwCTc5m4sAACAlkDYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAApkbYAQAAptba1QUAAK5N+fkF6t2rt932sLBwfbz3IydWBLMi7AAAXMJisWh+0tN221elLnNiNTAzLmMBAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABT49ZzANecK1csSklJsd9usTixGgAtjbAD4BpkKHbYzfW02w9CADwPl7EAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICp8QRlwI2MHTNGpaWldttDQkK0c9cuJ1YEAJ6PsAO4kdLSUuXs2G63vVvf/hrQv7/d9sKCgpYoCwA8GmEH8CCGUV1vGOoaHePEagDAMxB2AOB7jOpqvfjyErvt3t5ezisGQLMRdgDge7y9vfXfKWvstk+Ydo8TqwHQXNyNBQAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATI2wAwAATK21qwsAAEe7csWilJQU+x0M59UCwPUIOwBMyFDssJvraa8nCF3N1qur9eLLS+y2e3t7NWv7AByLsAMAjeTt7a3/Tlljt33CtHucWA2AhjBnBwAAmBphBwAAmBphBwAAmBpzdgAAbik/v0C9e/Wut09YWLg+3vuRkyqCp3Jp2Pnwww/10ksvKTc3V4WFhXr77bc1ceJEa7thGFq8eLFeffVVlZWVafTo0Vq7dq169/7///GfOXNG8+bN07vvvitvb29NnjxZv/3tb9W+fXsXjAgA4CgWi0Xzk56ut8+q1GVOqgaezKWXsS5cuKCBAwcqNTW1zvYVK1bolVde0bp165STk6N27dopISFBly9ftvaZNm2aDh8+rIyMDG3ZskUffvihHnnkEWcNAQAAuDmXntkZP368xo8fX2ebYRhavXq1Fi1apDvuuEOS9MYbbygsLEx///vfde+99+ro0aN6//33tX//fg0dOlSSlJKSogkTJmjlypXq0qWL08YCAADck9tOUD558qSKiooUFxdnXRYYGKgRI0YoOztbkpSdna2goCBr0JGkuLg4eXt7Kycnx+62KyoqVF5ebvMBAADm5LZhp6ioSJIUFhZmszwsLMzaVlRUpNDQUJv21q1bq2PHjtY+dVm+fLkCAwOtn4iICAdXDwAA3MU1eTdWcnKyFixYYP1eXl5O4EGLGztmjEpLS+vtU1hQ4KRqAODa4bZhJzw8XJJUXFyszp07W5cXFxdr0KBB1j4lJSU26125ckVnzpyxrl8XPz8/+fn5Ob5ooB6lpaXK2bG93j5do2OcVA0AXDvc9jJWjx49FB4erszMTOuy8vJy5eTkKDY2VpIUGxursrIy5ebmWvvs3LlT1dXVGjFihNNrBgAA7selZ3bOnz+vEydOWL+fPHlSBw4cUMeOHRUZGanHH39cv/71r9W7d2/16NFDzzzzjLp06WJ9Fk/fvn31ox/9SLNnz9a6detUVVWluXPn6t577+VOLMCkrlyxKCWlgbeWG86pBa7X0IMHeeggJBeHnU8//VRjxoyxfq+ZRzNjxgxt2LBBTz31lC5cuKBHHnlEZWVluummm/T+++/L39/fus7GjRs1d+5cjRs3zvpQwVdeecXpYwHgLIZih93cQJ8GwhBMo6EHD/LQQUguDju33nqrDMP+P8G8vLy0dOlSLV261G6fjh07Kj09vSXKAwAAJuC2c3YAAAAcgbADAABMjbADAABMzW2fswN4moYeGsgDAwHANQg7gIM09NBAHhgIAK7BZSwAAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqPFQQABzMqK7Wiy8vqbePt7eXc4oBQNgBAEfz9vbWf6esqbfPhGn3OKkaAFzGAgAApsaZHeAq8aJPAPBMhB3gKvGiTwDwTFzGAgAApkbYAQAApsZlLABwgYZuT+fWdMBxCDu4ZjQ0wTgkJEQ7d+1yYkW4ljV0ezq3pgOOQ9jBNaOhCcYj4hKcWA0AwFkIOwAA08rPL1DvXr3ttoeFhevjvR85sSK4AmEH+D/5+fka0L+/3Xaeo+McV65YlJKSYr+D4bxa4PksFovmJz1tt31V6jInVgNXIewA/8cwqnmOjlswFDvs5nra6wlCAFAHbj0HAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmxruxADgVL/oE4GyEHQBOxos+ATgXYQcAPJC3t5defHlJve0AvkPYAQAP1KqVt/47ZY3d9gnT7nFiNZ4rP79AvXv1ttseFhauj/d+5MSK0BIIOwCAa5bFYtH8pKfttq9KXebEatBSuBsLAACYGmEHAACYGpexYApjx4xRaWlpvX0KCwqcVA0AwJ0QduARGgozhQUFyjtysN5tdI2OcXRZAAAPQNiBRygtLVXOju122wkyAAB7mLMDAABMjbADAABMjctYAOCGjOrqep+Q3Nz1ecIyriWEHQCN0tCLPK9UXeFFnw7g7V3/E5ITG3hCckPr84RlXEsIOwAaqeEXefKiTwDuhLADt3A1t5YDANAUhB04RXOfk8Ot5QCApiLswCl4Tg4AT8Rb0c2BsAMAgB28Fd0cCDsAcA26mlvbuT0dZkHYAYBrUEO3pkvcng7z4AnKAADA1DizA8CqoQcGSuKhgLDy9va65p/S3NAEZolJzO6AsAOH4Dk5ZtHQAwMlHgqIGq1a8ZTmhiYwS9LPn57LHV0uRtiBQ3BrOQDUjTu6XI+wAwCoU3NfRgq4C9OEndTUVL300ksqKirSwIEDlZKSouHDh7u6LKdo6BJSSEiIdu7a5cSKAJhBc19GypvX4S5MEXY2bdqkBQsWaN26dRoxYoRWr16thIQEHT9+XKGhoa4ur8U1dAlpRFxCs7bfUJiSmJMDoLaGwtL4++4iDMEpTBF2Xn75Zc2ePVszZ86UJK1bt05bt27Va6+9pl/84hcurq75Wnryb3PfWyUxJ8ddNHQ31ZWqK/XfbcWdVnCihsLQtTDBWeKVFM7g8WGnsrJSubm5Sk5Oti7z9vZWXFycsrOzXViZ47T05F8mF1+dBoPEFYsTq7GnobupUhpsBzyJGW5/ZwJzy/P4sHP69GlZLBaFhYXZLA8LC9OxY8fqXKeiokIVFRXW72fPnpUklZeXO7y+Hycm6vTp03bbg4ODtWXr1nq3YbFYVH7unN12wzDqbbdYLPWOLT8/Xy+tXGm3varqSr3br+nTnG00NIbmtl9VjZVV9bYb1dW6od+Qetvd4ed44eLFFmt3xj6o0T3a3aGGaotFy1c+W2+N3t5eWvei/d+ZyQ9Nr3cbXl7SpcuX6m1vzvqO2EZ1dXWL/P30n+JvS1BpaYnd9pCQUH2QYf8fxc1dv6lqfi6G0cBpacPD5efnG5KMrKwsm+VPPvmkMXz48DrXWbx4saHvTtjz4cOHDx8+fDz8c+rUqXqzgsef2QkODlarVq1UXFxss7y4uFjh4eF1rpOcnKwFCxZYv1dXV+vMmTPq1KmTvLwaf8qzvLxcEREROnXqlAICAhq9vidizIzZrBiz+cd8rY1XMu+YDcPQuXPn1KVLl3r7eXzY8fX11ZAhQ5SZmamJEydK+i68ZGZmau7cuXWu4+fnJz8/P5tlQUFBza4lICDAVP8RXQ3GfG1gzNeGa23M19p4JXOOOTAwsME+Hh92JGnBggWaMWOGhg4dquHDh2v16tW6cOGC9e4sAABw7TJF2JkyZYpKS0v17LPPqqioSIMGDdL7779fa9IyAAC49pgi7EjS3Llz7V62aml+fn5avHhxrUtjZsaYrw2M+dpwrY35WhuvdG2O+T95GUZD92sBAAB4Lm9XFwAAANCSCDsAAMDUCDsAAMDUCDsAAMDUCDtX4fnnn9eoUaPUtm1buw8fzMvLU2Jiotq2bavQ0FA9+eSTunLlSr3bPXPmjKZNm6aAgAAFBQVp1qxZOn/+fAuMoPl2794tLy+vOj/79++3u96tt95aq/+jjz7qxMqbp3v37rXqf+GFF+pd5/Lly0pKSlKnTp3Uvn17TZ48udYTvt3V119/rVmzZqlHjx5q06aNevbsqcWLF6uysrLe9TztOKempqp79+7y9/fXiBEj9Mknn9Tbf/PmzYqOjpa/v78GDBigbdu2OanS5lu+fLmGDRumDh06KDQ0VBMnTtTx48frXWfDhg21jqe/v7+TKm6+JUuW1Ko/Ojq63nU8+RhLdf9Z5eXlpaSkpDr7e/oxbizCzlWorKzU3XffrTlz5tTZbrFYlJiYqMrKSmVlZen111/Xhg0b9Oyz9b/Abtq0aTp8+LAyMjK0ZcsWffjhh3rkkUdaYgjNNmrUKBUWFtp8Hn74YfXo0UNDhw6td93Zs2fbrLdixQonVe0YS5cutal/3rx59fafP3++3n33XW3evFl79uxRQUGBJk2a5KRqm+fYsWOqrq7W73//ex0+fFirVq3SunXr9PTT9t/IXMNTjvOmTZu0YMECLV68WJ999pkGDhyohIQElZTU/RLDrKws3XfffZo1a5Y+//xzTZw4URMnTtShQ4ecXHnT7NmzR0lJSdq3b58yMjJUVVWl+Ph4Xbhwod71AgICbI7nv/71LydV7Bj9+vWzqf/jjz+229fTj7Ek7d+/32a8GRkZkqS7777b7jqefowbxTGv47w2pKWlGYGBgbWWb9u2zfD29jaKioqsy9auXWsEBAQYFRUVdW7ryJEjhiRj//791mXvvfee4eXlZeTn5zu8dkerrKw0QkJCjKVLl9bb74c//KHx2GOPOaeoFhAVFWWsWrXqqvuXlZUZPj4+xubNm63Ljh49akgysrOzW6DClrdixQqjR48e9fbxpOM8fPhwIykpyfrdYrEYXbp0MZYvX15n/3vuucdITEy0WTZixAjjJz/5SYvW2VJKSkoMScaePXvs9rH3Z52nWLx4sTFw4MCr7m+2Y2wYhvHYY48ZPXv2NKqrq+ts9/Rj3Fic2XGA7OxsDRgwwOaJzQkJCSovL9fhw4ftrhMUFGRzViQuLk7e3t7Kyclp8Zqb65133tG///3vq3olx8aNGxUcHKz+/fsrOTlZFy9edEKFjvPCCy+oU6dOGjx4sF566aV6L0/m5uaqqqpKcXFx1mXR0dGKjIxUdna2M8p1uLNnz6pjx44N9vOE41xZWanc3Fyb4+Pt7a24uDi7xyc7O9umv/Td77cnH09JDR7T8+fPKyoqShEREbrjjjvs/lnmrr788kt16dJF1113naZNm6a8vDy7fc12jCsrK/WnP/1JDz30UL0vt/b0Y9wYpnmCsisVFRXVejVFzfeioiK764SGhtosa926tTp27Gh3HXeyfv16JSQkqFu3bvX2mzp1qqKiotSlSxf985//1MKFC3X8+HG99dZbTqq0eX72s5/pxhtvVMeOHZWVlaXk5GQVFhbq5ZdfrrN/UVGRfH19a83tCgsL84jj+n0nTpxQSkqKVq5cWW8/TznOp0+flsViqfP39dixY3WuY+/32xOPZ3V1tR5//HGNHj1a/fv3t9uvT58+eu2113TDDTfo7NmzWrlypUaNGqXDhw83+DvvDkaMGKENGzaoT58+Kiws1HPPPaebb75Zhw4dUocOHWr1N9MxlqS///3vKisr04MPPmi3j6cf40Zz9aklV1m4cKEhqd7P0aNHbdaxd9pv9uzZRnx8vM2yCxcuGJKMbdu21bn/559/3rj++utrLQ8JCTHWrFnT9IE1UlN+DqdOnTK8vb2Nv/71r43eX2ZmpiHJOHHihKOG0GhNGXON9evXG61btzYuX75cZ/vGjRsNX1/fWsuHDRtmPPXUUw4dR2M0ZczffPON0bNnT2PWrFmN3p87HOe65OfnG5KMrKwsm+VPPvmkMXz48DrX8fHxMdLT022WpaamGqGhoS1WZ0t59NFHjaioKOPUqVONWq+ystLo2bOnsWjRohaqrGV9++23RkBAgPHHP/6xznYzHWPDMIz4+Hjjxz/+caPW8fRj3JBr9szOE088UW/qlaTrrrvuqrYVHh5e626OmrtvwsPD7a7z/QmRV65c0ZkzZ+yu0xKa8nNIS0tTp06ddPvttzd6fyNGjJD03RmDnj17Nnp9R2jOsR8xYoSuXLmir7/+Wn369KnVHh4ersrKSpWVldmc3SkuLnbqcf2+xo65oKBAY8aM0ahRo/SHP/yh0ftzh+Ncl+DgYLVq1arW3XH1HZ/w8PBG9XdXc+fOtd4I0dh/ufv4+Gjw4ME6ceJEC1XXsoKCgnT99dfbrd8sx1iS/vWvf2nHjh2NPqvq6ce4Idds2AkJCVFISIhDthUbG6vnn39eJSUl1ktTGRkZCggIUExMjN11ysrKlJubqyFDhkiSdu7cqerqautfFM7Q2J+DYRhKS0vTAw88IB8fn0bv78CBA5Kkzp07N3pdR2nOsT9w4IC8vb1rXYKsMWTIEPn4+CgzM1OTJ0+WJB0/flx5eXmKjY1tcs3N1Zgx5+fna8yYMRoyZIjS0tLk7d34qX3ucJzr4uvrqyFDhigzM1MTJ06U9N2lnczMTLsvEo6NjVVmZqYef/xx67KMjAyXHs/GMAxD8+bN09tvv63du3erR48ejd6GxWLRwYMHNWHChBaosOWdP39eX331laZPn15nu6cf4/+Ulpam0NBQJSYmNmo9Tz/GDXL1qSVP8K9//cv4/PPPjeeee85o37698fnnnxuff/65ce7cOcMwDOPKlStG//79jfj4eOPAgQPG+++/b4SEhBjJycnWbeTk5Bh9+vQxvvnmG+uyH/3oR8bgwYONnJwc4+OPPzZ69+5t3HfffU4fX2Ps2LHD7mWeb775xujTp4+Rk5NjGIZhnDhxwli6dKnx6aefGidPnjT+8Y9/GNddd51xyy23OLvsJsnKyjJWrVplHDhwwPjqq6+MP/3pT0ZISIjxwAMPWPt8f8yG8d2lgsjISGPnzp3Gp59+asTGxhqxsbGuGEKjffPNN0avXr2McePGGd98841RWFho/fxnH08+zm+++abh5+dnbNiwwThy5IjxyCOPGEFBQda7KadPn2784he/sPbfu3ev0bp1a2PlypXG0aNHjcWLFxs+Pj7GwYMHXTWERpkzZ44RGBho7N692+Z4Xrx40drn+2N+7rnnjO3btxtfffWVkZuba9x7772Gv7+/cfjwYVcModGeeOIJY/fu3cbJkyeNvXv3GnFxcUZwcLBRUlJiGIb5jnENi8ViREZGGgsXLqzVZrZj3FiEnaswY8aMOuc47Nq1y9rn66+/NsaPH2+0adPGCA4ONp544gmjqqrK2r5r1y5DknHy5Enrsn//+9/GfffdZ7Rv394ICAgwZs6caQ1Q7uq+++4zRo0aVWfbyZMnbX4ueXl5xi233GJ07NjR8PPzM3r16mU8+eSTxtmzZ51YcdPl5uYaI0aMMAIDAw1/f3+jb9++xrJly2zm63x/zIZhGJcuXTJ++tOfGj/4wQ+Mtm3bGnfeeadNWHBnaWlpduf01DDDcU5JSTEiIyMNX19fY/jw4ca+ffusbT/84Q+NGTNm2PT/y1/+Ylx//fWGr6+v0a9fP2Pr1q1Orrjp7B3PtLQ0a5/vj/nxxx+3/nzCwsKMCRMmGJ999pnzi2+iKVOmGJ07dzZ8fX2Nrl27GlOmTLGZP2a2Y1xj+/bthiTj+PHjtdrMdowby8swDMOJJ5IAAACciufsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAICkyspKV5cAoIUQdgC4tb/+9a8aMGCA2rRpo06dOikuLk4XLlyQJL322mvq16+f/Pz81LlzZ5s3l+fl5emOO+5Q+/btFRAQoHvuuUfFxcXW9iVLlmjQoEH64x//qB49esjf31+SVFZWpocfflghISEKCAjQ2LFj9cUXXzh30AAcirADwG0VFhbqvvvu00MPPaSjR49q9+7dmjRpkgzD0Nq1a5WUlKRHHnlEBw8e1DvvvKNevXpJkqqrq3XHHXfozJkz2rNnjzIyMvS///u/mjJlis32T5w4ob/97W966623dODAAUnS3XffrZKSEr333nvKzc3VjTfeqHHjxunMmTPOHj4AB+FFoADc1meffaYhQ4bo66+/VlRUlE1b165dNXPmTP3617+utV5GRobGjx+vkydPKiIiQpJ05MgR9evXT5988omGDRumJUuWaNmyZcrPz1dISIgk6eOPP1ZiYqJKSkrk5+dn3V6vXr301FNP6ZFHHmnB0QJoKa1dXQAA2DNw4ECNGzdOAwYMUEJCguLj43XXXXepqqpKBQUFGjduXJ3rHT16VBEREdagI0kxMTEKCgrS0aNHNWzYMElSVFSUNehI0hdffKHz58+rU6dONtu7dOmSvvrqqxYYIQBnIOwAcFutWrVSRkaGsrKy9MEHHyglJUW//OUvlZmZ6ZDtt2vXzub7+fPn1blzZ+3evbtW36CgIIfsE4DzEXYAuDUvLy+NHj1ao0eP1rPPPquoqChlZGSoe/fuyszM1JgxY2qt07dvX506dUqnTp2yuYxVVlammJgYu/u68cYbVVRUpNatW6t79+4tNSQATkbYAeC2cnJylJmZqfj4eIWGhionJ0elpaXq27evlixZokcffVShoaEaP368zp07p71792revHmKi4vTgAEDNG3aNK1evVpXrlzRT3/6U/3whz/U0KFD7e4vLi5OsbGxmjhxolasWKHrr79eBQUF2rp1q+6888561wXgvgg7ANxWQECAPvzwQ61evVrl5eWKiorSb37zG40fP16SdPnyZa1atUo///nPFRwcrLvuukvSd2eD/vGPf2jevHm65ZZb5O3trR/96EdKSUmpd39eXl7atm2bfvnLX2rmzJkqLS1VeHi4brnlFoWFhbX4eAG0DO7GAgAApsZzdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKn9P4kW/zOkgH9fAAAAAElFTkSuQmCC\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "df = pd.DataFrame({'score': score, 'fscore': fscore, 'y': y})\n", + "\n", + "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", + "plt.show()\n", + "sns.histplot(df, x=\"fscore\", hue=\"y\").set_title(\"FairSVM\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_MAE.ipynb b/examples_FEI/STAR2000_loss_MAE.ipynb new file mode 100644 index 0000000..c437f51 --- /dev/null +++ b/examples_FEI/STAR2000_loss_MAE.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D62H7LVT-hpG", + "outputId": "ed81047f-8751-4916-e05f-c4714b78af83" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-hxsznegq\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-hxsznegq\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=fa1c481dc179bf912d9670fdd130ef2b2453c3c7a9fa06f72250a49b917d4a98\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-4_bmvjlq/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "tHPsW2Eq6lN9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "M8dZ_mRK9YDK" + }, + "outputs": [], + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_mae = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_mae.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 137 + }, + "id": "9JP5VwfV9aCY", + "outputId": "781ff38e-6850-4617-db7c-7e809c111007" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'name': 'mae'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'name': 'mae'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve MAE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "JC3sBscd9bWU", + "outputId": "31665e66-9570-4c7f-e6b4-9e6ea3a86c89" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot MAE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mae_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5IX8zjUk6yJF" + }, + "outputs": [], + "source": [ + "#With pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "Y-nBBodB6xEB" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "wbCrxMoaD6zd" + }, + "outputs": [], + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 213 + }, + "id": "W8QLXxxOD8AO", + "outputId": "911ca74c-24c1-418c-b74f-6b488c3db343" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve MAE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "f-I1H7joD9Mm", + "outputId": "02983dca-6556-499c-f6a8-07bb9ddbada0" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot MAE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mae_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_MSE.ipynb b/examples_FEI/STAR2000_loss_MSE.ipynb new file mode 100644 index 0000000..c1a9527 --- /dev/null +++ b/examples_FEI/STAR2000_loss_MSE.ipynb @@ -0,0 +1,1119 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cY_04uxlIp6C", + "outputId": "5beb3838-f250-4576-9c68-125d40d4056d" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-jyd_21no\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-jyd_21no\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e40a18d1e851c1aebab381bc6b01312b662c6800df1685e03ad8f6a9d4dfc433\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-84yy9nhd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "6A65T6tzF3Lj" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_mse = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", + "X = scaler_mse.fit_transform(X)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "iH3AockWGKbl" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve MSE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "id": "1OGXUMlKGL3U", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "outputId": "ff13a10a-9fa4-496f-fd98-a3b1341d3094" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'name': 'mse'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'name': 'mse'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot MSE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mse_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "id": "EPp4wl_8GNA7", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "outputId": "4b063c03-568c-44c0-9222-804217bce4b2" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#With Pipeline" + ], + "metadata": { + "id": "unUUe9ZEASBd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression" + ], + "metadata": { + "id": "Vb4eJISeAU5O" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "Uy9loVbWCw8A" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve MSE Regression via `plq_Ridge_Regressor`\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0))\n", + "])\n", + "pipe.fit(X, y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "3oUouDgWC3ao", + "outputId": "78a04eca-6d3e-4eda-bfc2-7485e63544e8" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot MSE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mse_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "JjNnypf6DI9L", + "outputId": "f8788e70-6c62-4e89-ad2e-5b47dcbad1b0" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_QR.ipynb b/examples_FEI/STAR2000_loss_QR.ipynb new file mode 100644 index 0000000..737f8d9 --- /dev/null +++ b/examples_FEI/STAR2000_loss_QR.ipynb @@ -0,0 +1,1096 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rTzmChto1ltC", + "outputId": "e72f4d4a-58e2-4d45-d134-4633ae86ee38" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting rehline\n", + " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", + "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: rehline\n", + "Successfully installed rehline-0.1.1\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BWLs6_gP1YHE" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "X = scaler.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "L8KI3Odl4l_Z", + "outputId": "d9b79b7c-7871-4510-bf43-dfba92823c7f" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve QR with different `qt` via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf5 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", + "clf5.fit(X=X, y=y)\n", + "\n", + "clf95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", + "clf95.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "WR-5hLZe4oEE", + "outputId": "df6aa0ca-eba6-4011-b1e9-c85abaf06cfa" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAGwCAYAAABFFQqPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAc1FJREFUeJzt3Xd8k+X6x/FPkrZp0kl3CwXKRtlTUBEEBVEERVwooogL9TDUI3ocuHDLcfwc5wjiQNSj4DwIoogDUVAElU3ZnXSvpE3y+yPHam1TVps0zff9euUlua/nyXM1QnPlfu5hcLlcLkREREQCkNHXCYiIiIj4igohERERCVgqhERERCRgqRASERGRgKVCSERERAKWCiEREREJWCqEREREJGAF+TqBps7pdHLw4EEiIiIwGAy+TkdERESOgMvlori4mJSUFIxGz/0+KoQO4+DBg6Smpvo6DRERETkG+/bto1WrVh7jKoQOIyIiAnC/kZGRkT7ORkRERI5EUVERqamp1Z/jnqgQOozfb4dFRkaqEBIREfEzhxvWosHSIiIiErBUCImIiEjAUiEkIiIiAUuFkIiIiAQsFUIiIiISsFQIiYiISMDyq0Jo9erVjBkzhpSUFAwGA0uXLq33+FWrVmEwGGo9MjMzvZOwiIiINGl+VQiVlpbSs2dPnnvuuaM6b+vWrWRkZFQ/EhISGilDERER8Sd+taDiWWedxVlnnXXU5yUkJBAdHd3wCYmIiIhf86seoWPVq1cvkpOTOeOMM/jmm2/qPdZms1FUVFTjISIiIg2voMxOTnEFpbYqn+XQrAuh5ORkXnjhBd59913effddUlNTGTp0KD/++KPHc+bOnUtUVFT1QxuuioiINKyCMjubs/exLvMnVu79nI3ZW0jPy6Ki0uH1XAwul8vl9as2AIPBwJIlSxg3btxRnXfaaafRunVrXnvttTrjNpsNm81W/fz3TdsKCwu115iIiMhxKrFVsjVvO3//+mayyrKq2/slDuSugXNo16Jlg1ynqKiIqKiow35+N+seoboMGDCAHTt2eIybzebqDVa10aqIiEjDyi3P5pavptUoggDWZa3lpU3Pk1NS7NV8Aq4Q2rBhA8nJyb5OQ0REJCDtLdpHbnlunbFP93xMUWW+V/Pxq1ljJSUlNXpz0tPT2bBhAzExMbRu3ZrZs2dz4MABXn31VQDmzZtHWloaJ554IhUVFfz73//m888/Z/ny5b76EURERAJadnmWx1iVswqbo8KL2fhZIbRu3TqGDRtW/XzmzJkAXHHFFbzyyitkZGSwd+/e6rjdbmfWrFkcOHAAq9VKjx49+Oyzz2q8hoiIiHhPxxbtPMbCg8OJCAnzYjZ+PFjaW450sJWISHPhcDjJKrZRZq/CHGQiLiIES7BffW+WJiy7NIebPr+R3/J+qxW7ufffuPLEyQSZjv/vmwZLi4jIUcsrtfHVrgNsz9vDzsIt7CjYyartu8ksKvd1atJMJJjMPDXgToa2PBUDBgAsQRZu7HoF57cc0iBF0NFQiS8iIgBUOZzsLczms8z5fJy+lCqXe5G7HnE9iYu8lxBTKjFhZh9nKX6vNIeUl89ibt9J5J38GOWuKiKcTuI3vEXw94vhik8gwntbYakQEhERAHJLy/h4z2Le3/WfGu0bc3/m/nUzmTfkRWLCNOtWjlPGz2AvIXzN/xG+5v9qxyvyvVoI6daYiIgAUOrIZ+nOt+uMpRemk1Oe6eWMpFkyBdcfN3i3NFEhJCIiANid5VTUM3U5o2y/F7ORZiuxGxg93JBK6Q2WFl5NR4WQiIgAEBZsIdjo+dt6akQrL2YjzVZ4Apz9RO32kHA49xkIi/NqOhojJCIiACRaExjfcTyLty6uFWsV3orUiIbZA6opslXZqHRWYg22YvTyrZmAExIGJ54Pyb1g7QtQsBfangI9L4Ho1l5PR4WQiIgAYA4yM7XzxRSW5bBs3+e4cC8z1z66Pf88aQ4JQVYfZ9jwCisK2VW4i9c3v05eRR6ntRrKGW1H0DK8+RZ9TUJoJKT0gjFPg8MGwVYwmnySihZUPAwtqCgiAaM4C14dQ1Hns8hrP4S8qnLCg0KJzU0ndvWTMPljiPW8KrC/KbIVseCXBfz7l3/XaI8JjWHhqFdpG9XGR5lJQzjSz2/1CImIiFtFAeRsJTJnK5Ffz6Ot0QROxx/xzI3NqhDKLM2qVQQB5FXkMe/HeTx4ygOEBXt3uwfxPt0IFRGR/zHUfPrnIgg8z/TxU1/uX+0x9sW+zzlU7t1d0MU3VAiJiIibpYV7anNdjEGeY36qoqrSY8zpcuJwauRIIFAhJCIibuHxMPY598DVvxr9uDvejJyUdIrH2IDEkzAbdVssEDSvfk4RETk+id3g+m/gp9dhz7cQ3QZOuh5i2rmnPTcjra0xnN36TD7eu7xGuyXIwm19Z9DCogkygUCzxg5Ds8ZEJCA5HFBZAkGhENQ8N1p1Zv5K/sHvWRcSxILdH1NoK2RwQm8ubz2KVpv/S9DQ2e5p3uKXNGtMRESOnckEpihfZ9GojNs/JXblHEbGdmBg9/FUxUYQcfBnzKvGg7PS3ROmQqjZUyEkIk2WzWEjtzyXnLIcjAYj8ZZ44q3xBDWz2UviY4d2EL3qkZptBkPdxx6jYnsxueW5fHvwW+wOO4NTBpNoTSQ6NLpBryNHT79NRKRJKrIVsWz3pzz2w6PVG4FGBEfw4CkPclLySViCLT7OUPxexzNh5Zy6Yx3OgAYqUgpthSzesphnNzxb3fbk+icZ234sM/rOINYS2yDXkWOjWWMi0iRty9/O/d/dV2M39OLKYqavms7+4gM+zEyajcgU6DeldntoFJz5QIPdFttTtKdGEfS793e+z7qsdQ1yDTl2KoREpMkpthfz4s8v1Blzupws3rqYKkeVl7OSZscaA8PugMvehbTTIKk7nDITrvkSYjs2yCXsDjtvbH7DY3z+pvkUVBQ0yLXk2OjWmIg0OcW2MvYW7/UY31W4k7KqciJNEV7MSpqlsDjoMAJaDQSH3d0LZApusJevclaRU57jMZ5vy6fS6XlhR2l86hESkSbHhJl2Ue09xjtEdcVEiBczkmYvNALCYhu0CAIINYUyKOlUj/G+CQMwm+pYwFK8RoWQiDQ5kaHhTO12TZ2xYGMw4zuchyVYhZA0feWVTgYnnUYLc4taMbPJzGWdJ1FhN/kgM/mdCiERaXIswUF0dDh4csCdRJujq9sTrYm8NOh+2rgcGI0NO71ZpDEEm4y0tFfw2qD7GdryVIwG98du3/hevH7KIyQX5RJiar4fxXnleWzL38Y3B75hW942DpUf8nVKtWiMkIg0PeUFRCy/g9OB7ifNID/EgtFgpEVJLvErHoTkXnDOPAhSr5A0bSEGB0E/vUD0b0uZ2+sSCk96CBcQkbGRqP9cjyumPYZL3oRmeKv3YMlBbvnyFjblbqpu6xrTlSeHPkWriJY+zKwmFUIi0vRUVUDRQUwFe0na+x1Jf42HRoPDpkJImr4qG8a8XVBRSPh3LxD+Xc3ZkAZTsPvvezNTaCvkzq/vrFEEAWzO28zfV9/GM6c/Q4wlxkfZ1dR8++NExH+FREDLfp7jbU+pe4d0kaYm2AKtB3mOJ/eCkHCvpeMt2aW5HtdI2pi7kZwmdItMhZCIND3mMBhyCxjrGEQaEgY9L6k7JtLUGE3Q6xJ3QfRXBiOc9ncwN79CqKSytN54sa3ES5kcngohEWmaYtrDpA8gpt0fbUnd4cplEN3ad3mJHK2o1jD5E4jr9Ke2VjDxHYjt4Lu8GlFYUAQGPE9oCA9pOpvZaoyQiDRNwaHuW2BXLoPyfPc3a0sL9wJ4Iv7EFAQt+8Dkj6AsH1wOsMRAZLKvM2s04cHRnJ56Jiv3fVordmrKaYQHRXs/KQ9UCIlI0xaR6H6Iz+WU5bCrcBef7/2cFuYWnNH2DBKsCUSEaIXvIxKe6H4EgDhrJH/v8zesJgOf7FmBw+XAaDByZurpzOg9gxhrtK9TrGZwuVwuXyfRlBUVFREVFUVhYSGRkU2nK09ExJuySrP42xd/49dDv9Zov7XfrZzf8XzCm+GAXzkOZXm43r6C8oTO5HY6g1IchBmCiN32GWEHN8DFixq9d/dIP7/VIyQiIvWqclbx1ta3axVBAI+te4xBKYPoGNIwm5RKM1Gai2H3aqy7V9P6+3/VGW8qt7k1WFpEROqVV57HW1sXe4x/suu/XsxG/IL9MLPCbEXeyeMIqBASEZF62RxVlNYzHfpQRZ4XsxG/EBoFhnq2wWkiiymCnxVCq1evZsyYMaSkpGAwGFi6dOlhz1m1ahV9+vTBbDbToUMHXnnllUbPU0SkOQkilH6JAzzGT0oc6r1kxD+EJUC3CXXHupzTZG6LgZ8VQqWlpfTs2ZPnnnvuiI5PT0/n7LPPZtiwYWzYsIHp06dz9dVX8+mntafziYhI3czGMKb3vpkgY+1hpZ2iO9I5ul0dZ0lAC42AM++H3pfD739vjCbocRGMfhws0T5N78/8dtaYwWBgyZIljBs3zuMxf//73/n444/55ZdfqtsuvvhiCgoKWLZsWZ3n2Gw2bDZb9fOioiJSU1M1a0xEApejivKf32RPTEue2PI6a7PWYQmyMKHtaC5LPpm4sFYEJXbxdZbSFNlLoSQbbMVgjoCweK+tpK1ZY8CaNWsYMWJEjbaRI0cyffp0j+fMnTuXOXPmNHJmIiJ+pDQby4q76GI08USfSZQOHIfRYSfmlyUEr/wnrlNmQeKdvs5SmqKQMIhJ83UW9WrWhVBmZiaJiTUXr0pMTKSoqIjy8nIsltp7v8yePZuZM2dWP/+9R0hEJGC5XFBRCC4nkV89yV+/WxtKsnySlkhDaNaF0LEwm82YzWZfpyEi0nSEhEPbUyH9y7rjXc7xbj4iDahZF0JJSUlkZdX8ppKVlUVkZGSdvUEi0nQU24vJKcth5d6VFNuLGZo6lNaRrYmzNJ3ZJgHDEgVnPgD/GgbOqpqx+C7uzXBF/FSzLoQGDRrEJ598UqNtxYoVDBo0yEcZiciRKLYX8972JTy+7rHqtgW/LqBfYj8eGfIICdYEH2YXoOI6wdWfwad3wp5vINjinhF08t+a9eah0vz5VSFUUlLCjh07qp+np6ezYcMGYmJiaN26NbNnz+bAgQO8+uqrAFx33XU8++yz3HbbbVx11VV8/vnnvP3223z88ce++hFE5AgcLMmoUQT9bl3WOj7c+SFXdrsSo8GvVv/wf8GhkNIbLnrDvWqwweCeARSkoQTi3/zqN8m6devo3bs3vXv3BmDmzJn07t2bu+++G4CMjAz27t1bfXxaWhoff/wxK1asoGfPnjzxxBP8+9//ZuTIkT7JX0SOzPs73vcYe2PzG+SW53oxG6nB2gKiUyGqlYogaRb8qkdo6NCh1LfsUV2rRg8dOpSffvqpEbMSkYZWX6FTZC/CVuXwYjYi0pz5VY+QiASGk5KGeYz1TxxIEKFezEZEmjMVQiLS5PSI7UqbyDa12oOMQdzYcxqhpjAfZCUizZEKIRFpcto6yvlXr5lc2O5czCb3OJQBif1489QnaJf5Ky0sfnVXX0SaMP02EZEmx/TzGySvfYHbTjiXqX3vxGkMIvzgBiLfuQZMwZB2KkQk+TpNEWkGVAiJSJNjKDoIDjvmTf8hadN/agaDQsGpwdIi0jB0a0xEmp6u9WzZ0PYUr+1eLSLNn3qERKTpaTUAWrSF/N01241BMOJeCI3yQVLHzulyklOWw6GKQzhcDmJDY4m3xBNsCvZ1aiIBT4WQiDQ9US3hig/g84fg13fBUQmt+sNZj0BsR19nd1TsDjs/Zf/EbatvI68iDwBLkIXb+t/GmW3OJNL8173cRcSbDK76VigUioqKiIqKorCwkMhI/cIS8Sp7GZQdApcDzBFgjfV1RkctvXA3539wHlV/3awUePnM+QxI7u+DrESavyP9/NYYIRFpukKs7u0cWrT1yyLI6XKyZPuSOosggOd//j+KbEVezkpE/kyFkIhII7FV2diSv9ljfHfRbkrsZV7MSET+SoWQiEgjMRBE+4guHuNtI9picIV4MSMR+SsVQiIijSTYaOKstDEEGeuel3JF12uwBGkpABFfUiEkItJITCYj7UNCeWnwg8RZ4qrbw4LDuL/PTHqGxxNtVY+QiC9p+ryISCOybPmQvj8vYvHJN5JnbYEDJzFVDuK/f5mgzatg3P9BiDaRFfEVFUIiIo2lshzjjs8gcxOJ715L4l/j4YlQUaRCSMSHdGtMRKSxGIMhqpXneHiCexNZEfEZFUIiIo3FFAT9p3iOnzIDwuI8x0Wk0akQEhFpTC3S4KzHwPCXX7d9roC0Ib7JSUSqaYyQHLfc8lzyyvOocFQQExpDrCUWS5DF12mJNA2hkdDrUug4AvZ+B5UV0Gawe3yQtYWvsxMJeCqE5LjsLNjJ9C+ms7toNwBBxiAu73o5k7tNJiY0xrfJiTQV5nD3I6adrzMRkb/QrTE5ZhklGVz16VXVRRBAlbOKBb8u4JNdn+B0OX2XnIiIyBFQISTHbHPeFvIq8uqM/WvTv8guy/ZyRiIiIkdHhZAcs615Wz3G8irysFXZvZiNiIjI0VMhJMesTUQHj7GY0BhwaQiaiIg0bSqE5Ji1De/gcUD0lSdcRYgh2rsJiYiIHCV9ZZdj1i7IyMsn3ceMHx//Y9aYIYjLOpzH6LA2hJpcvk1QRKQeh8oPsatgFx/s/ACj0ch5Hc6jdWRrzXgNMCqE5JgF71tDhy/uZ/6QGeS1aI3NWUmMIZiYX5ZiXXUpTFsLaA8lEWl6cspyuPubu/n64NfVbe9tf4+z087m1v63EmuJ9WF24k0qhOSYmYr2QeE+4j+cSXxdBzgqvZ2SiMgRWZuxtkYR9LuP0z9mTPsxnNzyZB9kJb6gMUJy7FIHeo61SINgq/dyERE5QgUVBby2+TWP8dd/e53yynIvZiS+pEJIjl1cR4jvXHfszAcgIsm7+YiIHAGHy1FvoVNSWUKVq8qLGYkvqRCSYxeRBBPfhRPPB6PJ3RaZAhcsgLan+DY3EREPokKiOK3V6R7jZ7QeRXhwuBczEl/SGCE5PtGpcO4zMOIecNghJMJdIBkMvs5MRKROxRVOzmg1hg92Lam1On5SWBLdWwyivNKBNUQfkYFA/5fl+P2+oaSIiB9wuFykVNp5/aT7eXnPJyzbvwqTwcSY1OFc3mo4wY4qHE4t/xEoVAiJiEhAaRFcheuHfxK3+T1mn3ge13efDi4nLbYsI+Tz86kcOI3glnf7Ok3xEr8bI/Tcc8/Rtm1bQkNDGThwIN9//73HY1955RUMBkONR2hoqBezFRGRpsZUWUrQwe+hyob558Ukvnstie9dT8hv74OziuD9a8Be6us0xUv8qhB66623mDlzJvfccw8//vgjPXv2ZOTIkWRne97lPDIykoyMjOrHnj17vJixiIg0OUGhENHSczyqNQSZvZeP+JRfFUJPPvkkU6dO5corr+SEE07ghRdewGq1Mn/+fI/nGAwGkpKSqh+JiYn1XsNms1FUVFTjISIizUhoJJw6y3N80DQI1t2DQOE3hZDdbmf9+vWMGDGius1oNDJixAjWrFnj8bySkhLatGlDamoqY8eO5ddff633OnPnziUqKqr6kZqa2mA/g4iINBHJPWDYnWD408eg0QSjH4fYDr7LS7zObwZL5+bm4nA4avXoJCYmsmXLljrP6dy5M/Pnz6dHjx4UFhby+OOPM3jwYH799VdatWpV5zmzZ89m5syZ1c+LiopUDImINDfWGDjpeuh2AWT87C6CknpAeDyEaI/EQOI3hdCxGDRoEIMGDap+PnjwYLp27cqLL77I/fffX+c5ZrMZs1n3hkVEmj1zhPsR287XmYgP+U0hFBcXh8lkIisrq0Z7VlYWSUlHtpVDcHAwvXv3ZseOHY2RoojIUSuoKCDflk9ZZRmR5khiQ2Oxap8+Ea/xmzFCISEh9O3bl5UrV1a3OZ1OVq5cWaPXpz4Oh4NNmzaRnJzcWGmKiByx/cX7ufnzmzl36blc/PHFnLvkXOatn0duea6vUxMJGH7TIwQwc+ZMrrjiCvr168eAAQOYN28epaWlXHnllQBMmjSJli1bMnfuXADuu+8+TjrpJDp06EBBQQGPPfYYe/bs4eqrr/bljyEiQk5ZDjesvIH0wvTqtipXFW9ufRNrsJUbet1AiCnEhxmKBAa/KoQuuugicnJyuPvuu8nMzKRXr14sW7asegD13r17MRr/6OTKz89n6tSpZGZm0qJFC/r27cu3337LCSec4KsfQUQEgIzSjBpF0J8t2rKICztfSEp4ipezEgk8BpfLpQ1V6lFUVERUVBSFhYVERkb6Oh0RaSY+2vkxs7++3WN8yblL6NBC07hFjtWRfn77zRghEZHmJMnqeaxiiDGEEKMW9BPxBhVCIiI+EGZKICWs7ltf57Ybh9EV4eWMRAKTCiERER8ItRt5YfBDpEWl1Wgf2WoYUztegLPK5KPMRAKLXw2WFhFpLloFFRL8xkTmn3YLeT3aUOyoIDYojNhdq4lYdBG2SZ8A4b5O06/ZqmzkVeThcDmwBlmJscT4OiVpglQIiYj4gCn7VyjOIO6jWcQBGIPAWVUdN1eV+Cw3XyurLCOnPIcfMn+g2F7MwOSBJIUlERN65IVMZmkmL296mSU7lmBz2OgY3ZHbB9xOt7huWrBSalAhJCLiA8bQv8xi+VMRBIAp2HvJNCEllSUsS1/GfWvuw8Ufk5qHtRrG3YPvJs4Sd9jXyCnL4ebPb2Zz3ubqtu0F25myfArzR86nf1L/Rsld/JPGCImI+EJCFwi21B1rc4p7U9AAlFmayZw1c2oUQQBf7P+C5buXcyQrvuwu2l2jCPqzh79/mEPlhxokV2keVAiJiPhCeBJMeNV9S6xGeyKc+0+wtPBNXj72/o73PcYW/rrwiLYf+e7gWo+xbfnbKK8qP6bcpHnSrTEREV8ICoG0ITDte9jyERzaAWmnQepJEN3K19n5hMvlIqMkw2M835aP0+U87OvE1nP7zBJkwWTQjDz5gwohERFfCQ6F2PZw8t98nUmTYDAYGJxyGp/u+bTOeK+43hgxH/Z1esYOwGgw1lk0jW4zVms0SQ26NSYiIk2Cy+WiZegJJIUl1YqZDCYu73IDjqrDF0IHc008evLcWj0/3WJO4LLOE7FV6qNP/qAeIRERaRIMBgMxDhPzBz/EPze/xmcHVuNwOega05U7Trya+KBwTEbDYV9nUGwVQavf5sNTn+S7gq3k2gsZ0OIE2pTkEfrbh1T1neqFn0b8hTZdPQxtuioi4j2Vu74mePGFlPW8mPyOw3ECYbk7iPn+31R1GEnQqAchqP5eIceGtzAtvcb9JPFECAmD3O1Qng/WWLjua4ise3sTaT6O9PNbPUIiItJkBP38BthLsf7wMtYfXq4Z++UdGDLzsEWM6dC2P55k/VozWHYIHPaGSleaAd0o9aGqvy6gJiIS4Oq98WU4/G0xAFr29RyLSoWg0KNJSZo59Qh5md1h52DJQT7a9RHb8rfRK74XZ7Q9g+SwZIL+up6IiEig6XM5/Lyo7lj3Ce5bW4eT3AMikqA4s3Zs+N3umMj/qEfIi6qcVazPWs9575/Hixtf5It9X/DUj08x/oPxbMnb4uv0RER8L7YDdD6ndntEMgy68bDjgwCIagVXfAwpvf9oM0fAyLnQYUTD5SrNggZLH0ZDDpbOKM3ggg8uoMheVCuWGpHKwlELibfGH9c1pOEdKj9EWWUZJqOJmNAYQgOoW720spRD5Yf4Ndc9zuLEuBOJtcQSFhzm48ykWSvOgv3fw3f/B/YyOPE86HY+RLc+utcpPQRluVBlc6/UHZEUsHu4BSINlm6CMkuy6iyCAPYV7yOvIl+FUBNSVlnGL7m/MPf7uewo2EGwMZhz2p3D9b2uJzks2dfpNbpCWyH/2fYfnv7p6eqF6YwGIzf1vokJnSYQZY7ycYbSbEUkQtcx7pW2nVUQGg3GY7iBERbrfojUQ7fGvKjiMDMV7A4Nnm5KNudt5urlV7OjYAcAlc5KluxYwvUrrie7LNvH2TW+nQU7mffjvBqr8zpdTv754z+r3xORRhUa6d589liKIJEjpL9dXhRnTvQ4IDoyJJIwk9YpairyK/J59PtHa+2ADbCzcCc7C3b6ICvvKassY/4v8z3GF/yygLLKMi9mJCLSOFQIeVGM0cy0EybXGZvd6yZiTFbvJiQelVeV81vebx7j3x781ovZeJ/dYSeztI4ZN/+TWZqJzWHzYkYiIo1DhZAXRdvymFBawTMD7qJrTFciQyLpHd+LBYPnMjT9ByIq832dovyP0WCsd0BwvCXBi9l4X7AxlB5xvT3Gu8f2ItgQOIPGRaT5UiHkRaayHKI+f4ihyx/ixej+vNf1ep6xdKbfB7cQ/v2/MdmLfZ2i/E9YUDTnt7+wzpjRYGRQ8ilezsi7bJUGLuw4AbOp9lRls8nMxZ0uwl6lXx8i4v/0m8ybwv/Xi5CfTouVD5C4dBpRXz4GxRlgMLoHBkqTUFLhYmKH8+gT16NGu8lg4tEBd2Esa97/dMJCgkjOz+CVwQ/RuUXn6vbOLTrzyuCHSMw7QFiIJp2KiP/TbzJvCouHVv1h/w+1YyeMc8elSQh3lWL972082WUU+ztfyveHfiMmJIIB0Z2IX/tv7H1TgDa+TrPRmB2lmL99lKiCvbw0YCpFXacAEJm7g5gPZrm3KWjTB4JVvIuIf1Mh5E1hcXDBAlhyHez5+o/2rmNg5IPulU+lSbA6yzDtWE7sjuXEmiPpGdfBvbBbjnsF8OCYjtBxsI+zbETOSrAVQ8FeYpbfRcxf46HR7mNERPycCiFvi06Fi16D0hz3B01otLsnyKLF6ZoSk8kIphD3LtW2IjjwY424IbSZF62h0dD1XMj4ue5413PBHO3NjEREGoUKIV+wxrgf0qQU24updFYSGRxJkDUWV4+LMPz0Wp3HGrvUsRdSc2I0QY8LYe0L7qL9z8LioedFYDL5JrdmyuVykV2WTXZZNiWVJaSEpxATGkNESDMvukV8TIWQBLxD5YfYkLOBhb8upNhezGmtTuOCThfQcugdkL4aCvbUPOH0u9wbQDZ30a1hygpY/Tj88h93W7cLYMgtR7/nk9TL4XSwJW8L01ZO41DFIQAMGDi/4/nc1PsmYi3aJkKksWjT1cNoyE1XpenJK8/j4e8f5r+7/1ujPTIkkkWjF9GGYNj7Dfy6BMISoN9kiG4LlmhfpOsb9nIoz3P/2RIDIRbf5tMMHSw5yPkfnE9pZWmt2My+M5l0wiRMRvXAiRyNI/38bt5zgEUO40DpgVpFEECRvYhnNjxDmTUauk+AC1+Fc56C5F6BVQSBu/CJaul+qAhqFD/n/FxnEQQw/5f55JTn1BkTkeOnQkgC2ordKzzGPtvzGUX2IvcTYxAYDF7KSgLNroJdHmMFtgIqNUNPpNGoEJIA57m4MajwES/pEnOCx1hSWBJBhhAvZiMSWFQISUA7NWW4x9jprc7E6PS835hIQ4kPSSPeUveCqld0uRaTU8triDQWvyuEnnvuOdq2bUtoaCgDBw7k+++/r/f4d955hy5duhAaGkr37t355JNPvJSp+INwVyTnp9WeCh8TGsMNPabicGhipTQ+R7GBfw95ghNi/+gZsgZZuaX7tQyJ7429yunD7ESaN7+aNfbWW28xadIkXnjhBQYOHMi8efN455132Lp1KwkJtXcD//bbbxkyZAhz587lnHPOYdGiRTzyyCP8+OOPdOvW7YiuqVljzVvZnp+oyFzDlqgEFu5dTlFlMcMT+nFWXC/itn5J5cm3Eh7h3XVccstyKbIXYTKaiDZHE2VWb0BzZzv4K+ZF48gfdAP5SSdic1YS5XIRv/51DJiwn/Mc1ohoX6cp4leO9PPbrwqhgQMH0r9/f5599lkAnE4nqamp3HTTTdx+++21jr/ooosoLS3lo48+qm476aST6NWrFy+88EKd17DZbNhsturnRUVFpKamqhBqppyf3Yfx6ycgIpmyrmOoNFsJ37ce0+6v3CtL37zBPVvKC2xVNjblbuK+NfeRXpQOQK/4Xtwz+B7aR7UP2DFLueW55JXnUe4oJyY0htjQWKzB1qN6jbzyPHLKc9hbtJd4azzJYckkhiU2UsZHz/n1PIyf3VN30GCEv/2stZtEjtKRFkJ+0+9vt9tZv349s2fPrm4zGo2MGDGCNWvW1HnOmjVrmDlzZo22kSNHsnTpUo/XmTt3LnPmzGmQnKXpMzrs7j8UZ2D9/qWaQWcV4L3vCelF6Vy9/GocLkd124acDVzx3yt4+5y3aRnhnYKsKdmev51Zq2ZVF4Ymg4mLu1zM1O5Tj3iRwczSTG5ffTvrs9dXtyVaE3nhjBfoEN2hUfI+Wkanw3PQ5QT/+b4q4nf8ZoxQbm4uDoeDxMSa3+ISExPJzMys85zMzMyjOh5g9uzZFBYWVj/27dt3/MlL03XCuZ5jnUdDqHduS5VWlvL8hudrFEG/K7IX8dnez/CjztsGsbdoL1OXT60uggAcLgdvbH6DJTuW4KivePifssoynlj3RI0iCCCrLIvrVlxHVmlWg+d9TDqe4TmWNvSwfw+dLidFtiLKKssaNC2RQOA3hZC3mM1mIiMjazykGWuRBp3Prt1ujoDh97j/6wWllaX8nONhg1NgzcE12Bw2j/Hmxu6w8+uhX6u3m/irBb8sOKJFBg9VHGLFnrrXisoqy+Jg6cHjyrPBRLWE7hfVbg+2wqiH6l3E82DJQV755RWu/+x6ZqyawTcHviGvIq/xchVpZvzm1lhcXBwmk4msrJrf4LKyskhKSqrznKSkpKM6XgJQeLx7xegTzoU1z0FFIXQ6E066wb2VhpcEG4OJt8Z7/OBPCUsh2BjstXx8rdhezLa8bR7jRfYiyqsqDvs6FVUVdfay/S67NPuY8mtw1lgY+QB0GQ3f/NO9pUn702HQtHr/Hu4r3sfln1xe4+/Ntwe/ZVyHcczsO5MWoS28kLyIf/ObHqGQkBD69u3LypUrq9ucTicrV65k0KBBdZ4zaNCgGscDrFixwuPxEqAiEqHnxXD5UpiyHM58EGLagdF7/zzCgiK5vMtVHuNj218QUHtNOVwOUiNTPcajzFEEcfhFBsOCw7AEed4WpE1km2PKr1GEJ8CJ4+Cyd+Gq5TBqLsR2AFPd31fLq8p58ecX6yyel+5YysGSxuntqnRUsq94H29vfZsn1j3Bqn2ryCz1PNxApKnzmx4hgJkzZ3LFFVfQr18/BgwYwLx58ygtLeXKK68EYNKkSbRs2ZK5c+cC8Le//Y3TTjuNJ554grPPPpvFixezbt06XnrppfouI4EqzHc7fBeWVdI3uiMT243jjV1Lq9uDDEHc3ftmYp2h2KocmIMCoxgKNoSSZE0izhJHbnlurfikrlcQ5Dr8+K0YcyyTT5jM8xufrxXrGdeTaHMT3NXdGnNEhxXaCvkk3fO6aJ+k/5cT405sqKwAqHJU8WP2j1z/2fXV23688usrJIUl8fLIl2kdoZlt4n/8qhC66KKLyMnJ4e677yYzM5NevXqxbNmy6gHRe/fuxfinb/GDBw9m0aJF/OMf/+COO+6gY8eOLF269IjXEBLxllAqiP78AW6ITuGi0/7JL4W7MBtDOCGsJbHrFuJIrsCUcK2v0/Qauy2YFGsKD5z8AI/+8Ci7Ct17cQUZgji/4/mc3fZMgk2HLwrtpaVcaG2DocskFux4h/KqcowGI8NbncZtaecTWVEO4Y390zQOl8uFq55ZjUcymPxoZZdnc9PnN9Xa+yyzNJMH1jzAE0OfICLEu+tuiRwvv1pHyBe0oKJ4g6soA8NLQ6Ak271uTHRrcFRC0QH3AR1GwEVvQHCobxP1kqyicmIr9pBhL2SHowSjMQiHy0FCaCwJ9nLiV9yP4aLXDtt7Ysvegfn5flR2OYfsXhdSajQRajARu/1zwn58jfIL38LScYiXfqqGlVVcyMM/3M9n+z6tM/7C6a9wcmrfBr3mNwe+4brPrvMY//i8j2kdqV4haRqa3TpCIs2ZwRQM1jh3IeRyQv7uGnFXRDIGY+D8c40NrsT004ekfvU48d3Opyi1P8bKMmJ/WYJh/zr3QRWFhy2EjFUV4HIRvPlDWm7+sFbcVHb4mWdNldMRwlUnXMMP2d9RaCusETuj9Qic9iO7xXY08isK643bf1+XS8SPBM5vVpGmLCwOTp4OS66pM2zof7XHQbPNUVBVOeCCqgpCNywidMOimgcYDBBkPuzrGCyR7jV4PHyAGxM6N0C2vhFmNmHNOMDikx7k3Yyv+SL7B8KDw7mizVn0dhgxhzV8Z3/7KM8LUMZZ4ggxapNi8T9+M2tMpNlrPwx6XFyzzWCAkQ9BTJpvcvIVlwNa9qkzVNbjQnZP+S9vHljFixtfZGPORg6V173sQFBkCs7TZtcZc7YfjinSf5fSiHQUEvXFbFotHMe09J+ZHzOY/zN34IyVjxP33nVYM39o8Gva7WGc2frMOmPTe8/EWanxQeJ/NEboMDRGSLyqLA+KM2DXKgiyQLvT3NOqvbSwY5PhqIItH8HBH93r6vxPSe+JLEvry30//bPGQOGTkk/iwVMeJMFae/NlSg/h/G0pxlUPQWkuBIXi7H05hlNnYYhM9sZP0zgK98NT9cwK63sVjHmqQS+Zl7kHZ+EvLC3awsKdSymwFZAWlcasLpPobnfhTD2TuBbaJFiaBo0REvFH1hj3I7Fhpz37HVMQpA6E4kyYsBB+fQ/K88kacBVzll9Z6/DvMr7jo10fMfnEyRgNf+noDovF2PdK6DQKKkvBFIoxIgGC/HzguTEIIlv+MaD+rxK6NPglI22ZBL15KVemncaYPjfgMEcQkr+PuM8ehoJ9OG5YC6gQEv+iQkhEmqbIZOh2HuTtga5jIboNHx38yuPhr//2Oue0O6fuXiGj0b2NRXMSnghDboWPpteOBZmhY923sI6HqWCP+7/pX5KY/mXteFV5g19TpLGpEBKRpis80f1gAACZu9/1eGi+LR+ny+mlxJoAgwG6nAPZv8EP//pjh/rQaLj4DYhq1fCXrG+sWrDFvTeaiJ9RISTSTFQ6Ksm35YMLokOjCTEdfgsKfzO89XA+2vVRnbF+if0ICw6wWUvh8XD6XTDwOsjbBeZwiEqF8KTGmWUYnQqx7eHQztqxflPc29WI+BkVQiLNwMGSgyzavIiPdn2E0+VkdNpoLj/hclpGNK/bQV2ju9IqohX7i/fXaDcZTEzvfXNgrmocGul+xLZv/GtFJMHEd+E/V8LBn9xtBiP0vhwG3+z/464kIGnW2GFo1pg0dRklGVyx7AoySjNqtMdb4nl99OukhKf4KLOGV5axjQJbBs/t/pBP9q2kylnFibEnMvuEK0kJakFJZAJb87cQYgqhU4tOxFniCNWHc8MrzYWyXLCVgrUFhCW4e6NEmhDNGhMJAC6Xi5V7V9YqggByynP4aNdHTOk2pdnsXG/c9DYp3z/DP7pPYNqA+3AaDITlbIP8Ayywfc8r29+pnlYfZAxizuA5DG89PPBumTW2sDj3Q6QZOOYFFXfs2MGnn35Kebl7loA6lkS8r8hexH/T/+sx/unuT2ttv+DPQor3QFUFlp9eI+XNy2i1aCIt1r/GTxYrC7a/XWNtoSpnFXd+fScHij1MLxcR4RgKoUOHDjFixAg6derE6NGjychwfxOdMmUKs2bNavAERcQzk8FU762fUFNos+kNAnB2OKNWW0HPi3hx1xKP57y19a1G2YldRJqHoy6EZsyYQVBQEHv37sVq/WOq5EUXXcSyZcsaNDkRqV94SDiXdrnUY/ySLpcSZW4+C9wZ2wyCiJqrQdvD4sipZ/PU/SX7qXRWNnZqIuKnjroQWr58OY888gitWtVco6Jjx47s2bOnwRITkSPTLbIDp6ecXKt9cGJ/+sV080FGjccYnYpz8ie4Op7hXkcHCCvJoVus55W4+yb0x2w6/AatIhKYjnqwdGlpaY2eoN/l5eVhNuuXjYi3lFWWYau0E7X1M+6O7s1lbUbxbsY3OF0uzk8eTIfSAsK/fYnSYXcSVse/WX9ljG0H4+dD2SFwVmEKCmdyeS5fHlhda0HF8OBw+if1ZUveFlpHtCYsRIOmRaSmo+4ROvXUU3n11VernxsMBpxOJ48++ijDhg1r0OREpLbc8ly+3P8l01dNZ/qXf+NDi4vK6Nb0/2wuD2Xn8HDOIU768O/EfTCD0D0rMdmLfZ1ywwuNhJg0iOtISVALUu1VvDToQVIjUqsPOTH2RB4Z8ggPrn2QCz+6kNUHVmN32H2YtIg0RUfdI/Too48yfPhw1q1bh91u57bbbuPXX38lLy+Pb775pjFyFJH/OVR+iPvX3M/n+z6vbvsx+0dSI1J5edSDJL92wR9bLQAuaxwh5ua9jk6MqQK+uJv40ixeOv8FtlcW4sTJzoKdzFkzh+yybADu+fYeesb3bFbrKonI8TvqQqhbt25s27aNZ599loiICEpKSjj//POZNm0aycnJh38BETlmOwp21CiCfreveB/vZv/Ade2HE7Tjs+p2x6CbCbIc/WDpSmcltiobliBLk591Zqwsh9ytUJJFaWk2N39za53HlVeVk1maqUJIRGo4pgUVo6KiuPPOOxs6FxGpR5Wzire3vu0xvnTfSi7schEJ/yuEnP2vIahVn6O6RmllKfuK97Fo8yL2Fe+jT0IfxnYYS0p4CkHGJrr+arAFYtpDSdZhD3UE0qasInJEjvo32+rVq+uNDxky5JiTEZH6OVye18NxuBy4knrgOPMhDO2HYYxMBkuLI35tW5WNlXtXcufXf3zJWZe1jtc2v8aCkQs4Mc7zzCyfskTDsDtg4TlElxcQZ4kjtzy31mFmk5lYszYFFZGajroQGjp0aK02w/+msQI4HFq4TKQxBBmDOLvtOFbuXVln/IzWZxEe3xNTq4HH9Po55Tnc++29tdrLq8q585s7efnMl4m1xB7Taze6pO5wzlMk/PAK9598E9PWzqk1g+zvfW/FXtF8Zs+JSMM46llj+fn5NR7Z2dksW7aM/v37s3z58sbIUUQAe5WTttY29I3vVSsWb4nnkk4TKK449q1u0gvTPS48uLNgJwW2gmN+7UZniYZeE3Ge+xx9Lcm8M+pVRrcdRVpUGkNTTuH1Ux7lrINbaRVU6utMRaSJOeoeoaio2gMvzzjjDEJCQpg5cybr169vkMREpCaT0UBC3m4ebTOOb1qexpt7l1PhqOCs5MGMTRhA1KYPqew79Zhfv9JZVW/8rz0sTU6QGZxVWBacRadgK/eeeB5lsUMILcog7D/XQ3k+js5nA619namINCENNvoxMTGRrVu3NtTLichfmHAQ+ctCDL8u4byk7gztejZOUwjR277BtOxh99YTfSYAlmN6/dYRaZgMpjrHIbUMb4nZGHGcP0HjMzkq3MsH2Eux/PR6rXfCZC/xSV4i0nQddSG0cePGGs9dLhcZGRk8/PDD9OrVq6HyEpG/coHB8b9bV5mbaJG5qWbcWQXHfmeMstJQru9xLc/+/H812k0GE3cN+AeOyvBjf3FvsbSAYCtUltWOGQwQ1ap2u4gEtKMuhHr16oXBYMDlqvkb96STTmL+/PkNlpiI/IUpCPpMgi0f1R3vNgGsxz6YOS24gjalNnqcdB8v7XqfjLJMukV35pr2Y2m14xvsPbsATbwYCk+EU2fB5/fXjvW8DMLivZ+TiDRpR10Ipaen13huNBqJj48nNLR5r14r0iQk94TWg2Dvmprt4Ykw8FoICjnml7aWH8S04h4GRSRzYs+LsLXsR1juDqyLLofKUszdxwNxx5d/YwsyQ98rwRoDqx52ry0UGg2DboS+V7i35hAR+ZOjLoTatGnTGHmIyJGISIIJC2DbCvjhJagshxPPhz6XQ/TxDQI2lf1v7Z3iDCK/nlc77rAd1+t7TVgs9JkMnUZBZYW7OAxPcveoiYj8xRH9Znj66aeP+AVvvvnmY05GRI5ARDL0nQRdzgaXAywxDfMhH9vBc8wc6X74C6MRIrWVhogc3hH99nzqqaeO6MUMBoMKIRFvCWvgxQ3DE6HDCPjTXmXVhtzm7o0SEWlmjqgQ+uu4IBFphsJiYeyzsPoJ+OlVqLK5x9qcdjt0uwBMwb7OUESkwemmuYj8ISIZznwABt8EVRUQEu7uCWriO9CLiByrYyqE9u/fzwcffMDevXux2+01Yk8++WSDJCYiPhIcCi00KUJEAsNRF0IrV67k3HPPpV27dmzZsoVu3bqxe/duXC4Xffr0aYwcAcjLy+Omm27iww8/xGg0Mn78eP75z38SHu55XZOhQ4fy5Zdf1mi79tpreeGFFxotTxER8V/ZZdnkV+Rjd9qJMccQZ4nDHGT2dVrSiI66EJo9eza33HILc+bMISIignfffZeEhAQmTpzIqFGjGiNHACZOnEhGRgYrVqygsrKSK6+8kmuuuYZFixbVe97UqVO57777qp9brdp9WkREanK6nGzJ28KML2ZwsPQgACHGEK7reR0TOk0gOjTatwlKoznqQmjz5s28+eab7pODgigvLyc8PJz77ruPsWPHcv311zd4kps3b2bZsmX88MMP9OvXD4BnnnmG0aNH8/jjj5OS4nmarNVqJSlJs11E5NhUVFWQb8vH5XIRFhxGlLn2xtPi/zJKM7jq06sorSytbrM77Tz909O0Cm/FWe3O8mF20piMR3tCWFhY9big5ORkdu7cWR3Lzc1tuMz+ZM2aNURHR1cXQQAjRozAaDSydu3aes994403iIuLo1u3bsyePZuysjr2IPoTm81GUVFRjYeIBKYDJQd4cO2DnP3e2Yx8dyQzVs1gS94WKn/f860B5Zbl8mvur3y+93N+O/QbueWN8/tU6rY2Y22NIujPntnwDLll+v/RXB11j9BJJ53E119/TdeuXRk9ejSzZs1i06ZNvPfee5x00kmNkSOZmZkkJCTUaAsKCiImJobMzEyP51166aW0adOGlJQUNm7cyN///ne2bt3Ke++95/GcuXPnMmfOnAbLXUT8U2ZpJlM+ncKBkgPVbT9k/sClH1/K22PepkN0PQtQHqV9xfu4ceWN7CrcVd3WqUUnnjn9GVLCtTCkN/yS+4vH2L7ifVS6Gr74labhqHuEnnzySQYOHAjAnDlzGD58OG+99RZt27bl5ZdfPqrXuv322zEYDPU+tmzZcrQpVrvmmmsYOXIk3bt3Z+LEibz66qssWbKkRi/WX82ePZvCwsLqx759+475+iLiv37M+rFGEfS7Smcl//fT/3nsPThaeeV5zFw1s0YRBLAtfxu3r76dgoqCBrmO1O/E2BM9xlIjUgk2aB2t5uqoe4QeeughLrvsMsB9m+x4ZmDNmjWLyZMn13tMu3btSEpKIjs7u0Z7VVUVeXl5RzX+5/cCbseOHbRv377OY8xmM2azZgiIBDKH08HyPcs9xr/L+I4SewlhwWHHfa08Wx5b8ur+wvdTzk/kVeRpoK4X9EscgDXISllV7eET1/eYRpy1iW84LMfsqAuhnJwcRo0aRXx8PBdffDGXXXYZPXv2PKaLx8fHEx8ff9jjBg0aREFBAevXr6dv374AfP755zidzuri5khs2LABcI9tEmnOqpxVOF1OQkzHvhu9NxXZisi35WN32IkIiSDeEo/Jh4s4Gg1G4iyeP/iizFEYDUfdoV6nEntJvfG6Ppil4Zkqgnl56NPMXHMXGaUZgHvW2DVdJtI76kSKyiuJtKhXqDk66kLo/fffJz8/n3feeYdFixbx5JNP0qVLFyZOnMill15K27ZtGzzJrl27MmrUKKZOncoLL7xAZWUlN954IxdffHH1jLEDBw4wfPhwXn31VQYMGMDOnTtZtGgRo0ePJjY2lo0bNzJjxgyGDBlCjx49GjxHkaagoKKAPUV7WLx1MUX2IkanjaZvYl+SwpruzMn9xfuZs2YO32V8B7iLjOl9pjOizQiizdE+yclgMHBO23G8tfWtOuPjO1xCZEiLBrlWVD0/o9FgJDw4okGuI/ULK8uk1Uc38PqpfyMvMhm7s5IYTMRteAtHRia2oXeBCqFm6ZhWlm7RogXXXHMN11xzDfv37+fNN99k/vz53H333VRVVTV0joB79teNN97I8OHDqxdUfPrpp6vjlZWVbN26tXpWWEhICJ999hnz5s2jtLSU1NRUxo8fzz/+8Y9GyU/E1wpsBfxr07949bdXq9tW719N64jW/PvMf5Mc3vR6QrNKs7h6+dU1xuIU2gqZs2YOYcFhnJXmmynLTqeLshIr03vewLyf/69GbHDSAE5LPo380iqSoo5/l6IgIjg9dQSf76u92e2otmcTTORxX0MOz7r9Azi0g4SlN5Hw12BIOEGn3ASoKG2OjutfcWVlJevWrWPt2rXs3r2bxMTEhsqrlpiYmHoXT2zbti0ul6v6eWpqaq1VpaV+2WXZ2Bw2go3BxFniCDJqKzp/crDkYI0i6Hd7i/fy2ubXmN5nepO7VbajYEedA5IB5q2fR7/EfsRbD3/7vDF0NhXR/cB2hg6Zx6qcDZQ6bZwW15NWefsw7liFs8fFDXKdslIjt3W/lkhTMB/tWUGVq4ogYxDntx3NlC5XUFJmBC1d1OiCK+tZKqWyjOCGuRMqTdAxfdJ98cUXLFq0iHfffRen08n555/PRx99xOmnn97Q+YkXFFQU8PXBr/nnj/8kszSTyJBIJp0wifGdxtc7TkKalo92fuQxtmT7Eq444QoSwxrvy8qx2Jiz0WPsYOlBKhwVXszmD0ajgegtizH98DIR6xfSPqU3mEIg6wWoKITYDji6jwKO//1MDS7C+soYZnc5i2sGPUQZTsIwEvvbR1hePZeyK5ajSsgLup4LP/yrzpCr/ekYQ/X/oLk66kKoZcuW5OXlMWrUKF566SXGjBmjWVZ+rMpZxbLdy3hw7YPVbUX2Ip7d8CzphencMfAOIs3qmvcH5VXlHmM2hw0XLo9xX2kd2dpjLCI4gmBjw4zJKK8sp8hehMFgIDY09vADsZ1VmAr3Vf+Z/T/UjJfmYHI5GiQ3sy0XSrOxrl+Idf3COuJ5gOf3SRqGMb4zrtSBGPb9ZZHeIDOGM+6DUP0ebK6OurPv3nvvJSMjgyVLlnDBBReoCGoEBRUFHCw5SGZpZqOsYPtnOWU5PP3j03XGPk7/mEMVhxr1+tJwRrQe6TF2WqthWE2eNyj2le6xPbEEWeqMXdrl0np7JIttxeRX5FPl9DwuscpZxa7CXdz97d2MfX8sl3x8CS//8jJZpVn1J2YMgo6e309SB0BIw7yfpsMUqCZD0ytgm6WIRAwTFsLpd0F4IgRboMvZcM2XENvJ19lJIzrqHqGpU6c2Rh6C+1vrtvxtPPLDI2zK3YQlyMJFnS/isq6XNdotjSJ7EcWVxR7je4r2kBaV1ijXloaVEJxE3/jerM/5qUa7NcjKDd2vpdxmIjLUR8l5EF1l4KXBDzHtu3sosv8xRuOMlkO4oOVQSsodRIfV/DV1qPwQG3M2svC3hRTbixmWOozzOpxHSngKBoOhxrF7i/Zy8ccXV/eWlVaW8sxPz7Bq3yr+Oeyf9Y8/aj8MwhOgpOYaZhiM7g/LhuohCE+AkDCw17FAo6UFhPlmjFRAikyGU2ZA74ngcoI5EswaIN3caTRsE7I1fytXLLsCp8sJuG91vPLrK6zLXMczpz/TKAt6BRnqHzwbHqRfAv4irjibR9PG81nSQN7Y/QmllaUMSRrAVW3PIWHjUuz9Gn5D5ONlzNhI928e5j+n3cY+g4vCyiLahbUkbs9aot6cSNnlH0FYavXxeeV5PPbDY3yc/nF127b8bby19S3eGP1GjVttpZWlPP3T03XeMtyUu4kdBTvqL4SiU2Hyf2HZ32HnSnC5IL4LnP0kxDVgD0F4Eox+HJbW8f/nnKfccfEeowkimt4MS2k8KoSaiPyKfOZ+P7e6CPqzXw79wu6i3Y1SCJmNEfRN6Mv67PW1YtHmaOJCa00klSYqctt/MH3/Ipe06s+Z3c7DGWwhcu/3hH41AYwmzH0u5Uim//7eMxMZ0vhjIkKyNmDK2EDy4kkkmyMg2AplueB0j78JctprHH+w9GCNIuh3BbYCntvwHPcMugdrsBWAYnsxX+3/yuO1P9n1CYNSBtWfYFwHuGA+lOW7xwqFRrp7cBpSUAh0OQemdIAvH4ND2yGhKwy51V1wmfRrWqQx6V9YE1FWVcZvh37zGP/6wNf0S+rX4NeNrrRxX7epTFl7gMzSPzawtQRZeG7AXcRV1S7MpGky/m88mWH/D8T9dXBvUCimv9w2+qus0iy+Pfgt725/F4AJnSYwKGUQCdbGK4aN8Z3/eGIrdj9+Z2lBUHDNMYif7v7U42st372cGX1nVBdCBoOB0KBQ7HZ7nceHh9RdFBZUFFBWVYbRYCQmNIaQ0Cho7BlDoZHucUcT5oO9zH2rzNz0xnSJNEcqhJoIA0YsQRaPM39amGMa5brmynxavzOV1856kO1UsqlwF2lhSfSwJJG0ci6u0+6E+DaNcm1pWIYeE2D9/DpjrhPGYrB4Xgk5qzSLaSunsTV/a3Xbzzk/c0LsCTxz+jONVgwZU/u5x2DYao9Tc550I8ajuUXxlzrPaozm3HbjeX3LgjoPH9n67BrPK6oq2Jq3tcYYvfM7ns/kEyd7b2Vuc4TGpIh4mZaIaiJMzgjGthtbZ8yAgX4JgxvlukFGIxQdIOmtyZz6yV3c8OvnnPXFP2n5+kWYDvyI0Vh/L4I0IbEdoFMdM50sLTCc9ncIsXo89asDX9Uogn7326HfWHNwTUNmWYMxqiWuSR/UGhDs7Hkpxr6Xg6nmNPeRbTzP5BrVZhRR5j96bkoqnFzaaTwdotrVOvbqLhOxOGq+H1vztzJp2SQ25W4C3GP03tj8Bjd9fhM5ZTlH/bOJiH9Qj1BT4TIyud1Yfsxez7aC7dXNBgw80GcWsa7G2YDSYI2BFmmQnw7Fme7H70whGGM7NMp1pRGEJ8CYZyD9S/ju/8BWBJ3Pgf5XQbTnXr0CWwH/2fYfj/F3tr3DsNRhjbOelNGEIbmXe4py0UGwFUJ0W4xh8WCpfTsqOjiBsWljeD/9wxrtMaExXN1tKsGGP26lhRkrCVn1DC92nMQvBjsfZ/1AdLCV85NPodWetVCyH3DPiCyoKODR7x+tc4zelrwt7Crc5bMVrkWkcakQaiJaOPMJeXsSLwyZxa5QK18d2khcSBRDY3uQ8OPrBFeZIbERprFHJMG45+HVMfDXNYtGP97wA0OlcUUkQo8LocMI9+BeSwswHd+ihH/euqZRGI0Q1dL9OIywkgJmWNsxcsDdLNz7KcWVxQxP6MfZ8f2I2LmWwi4pxEa41wgIdxVj3PQGoT/+i9NbtGVoSh+MVQdh9Xywl+LsmwedTwXcY/Q25npe5fqrA18xMHlgw/y8ItKkqBBqIkKogkM7iV9yA/Fh8QxMOAHsJXBwDricOCNSD/8ix6plX7h+DXz3AhxYBy3awsk3Q2xH96Ji4n+sRz6mLNoczTlp4/j10K91xse0O6/JrC4esucLwlbcxqmRLelzwhiqrKmEb/ka0ycPQGQK5e2HAO6CyojBveYPQP5ujPm7a7yWwfDHyACjwYg1yEpZVVmd122sMXoi4nsqhJqKIDNEpULhPijNcd/e+BNjqz6NeO0QiOsIo+a6i6/gUPc05gDhdDnJq8jD5XIRbY4m+Dh7UPxNUXklPWMG0iG6PTsKdtaIdWrRiROi+lJcUUlEqO/fl9D8be4/FB0g7LsXagaLDhLMn7a9sMZA9wmwvu7B0oael1T/OYgIzm03nsXbXqt9HAYGJQ057txFpGlSIdRURCS5V6tdck3tWFgcpPRt/ByCQiAosL75ZpVm8enuT3ln2zvYHXZGpY3iws4X0jL88Ldpmosqp5Pk0kO80OVqVpXt4739q8AAF7Q8nSHWlpjKC3A4msj7kToQ1v277lhcJ4JC/rR0dnAonDIdtv235tg3gBPHQ8wfg6jtlQau6DyBjTnf89ufBo0bMHBf31sJrtCvSpHmyuBq9AEA/q2oqIioqCgKCwuJjGzk2wOlh2DD67DqYaj8Xxd9wgkw4RX483or0iCyy7KZ9tk0tuRvqdEeZ4nj9dGvB0wx5LSV4lo6DdPmJZDSh4KOIwCI3r4CDv6Eo9sEDOc+gzGkCdwmLdgH/xoKpbm1Qs6L38TYZXTd5/y6BH5bAiERMGgapPSuMf6tpPAQlo9vJO+E0aRbwvkm7xdigsM5La4nCevfwNVrCmHtG2fmpog0jiP9/NbXnKYkLBYGXgcnngdlee7bZdY4CNdslcawIXtDrSIIILc8l7e3vs2NvW4MiNtkxqpyyPvfLaeDPxJ98McacdOhbVBVBk2hEIpOhcmfwHtTIeNnd1toNJxxH8Y2HlaJjk6FQTdC78vdA8frWKgwzFWGYdsnxG/7hHhrLAMSToDKUjh43//G6KWACiGRZkmFUFMTZIbo1u6HNBpblY0lO5Z4jH+S/gmXdb0sMKZMh4S5ex6z6h4sTcKJEBzm3ZzqE98ZLnsPyg6Bw+6eGReeXGvNoRqMRrB6XlDSYDC4/+1V2dyvu7vm1hyGJjJYXEQanhZUlIBkMBgINnru7QkxhtTaybzZCrbAyX+Dun5egxEG3+geb9OUhMW5C6Kk7hDVqv4i6EhYY6H7RR7Dhq7nHN/ri0iTpUJIAlKIKYSLOl/sMX5BxwnEhAbQwPGY9nDxoprT7q2xcMli94KbzV2wBU67te6FJ4fdqd3IRZox3RqTgNXW2prhrYaycv+qGu2dWnTijNTTMRoC6HtCiBU6joRrv3IPRDYY3OPTIpLA2Dirmjc50a3hyk9gz7fuwdVhCdDvSve6WpZoX2cnIo1Es8YOw6uzxsRrqhxOind+j7PoF7ZFxPDm/s+xOSs5L+lkepvCCS2xQ7fzibKG+DpV8QVHlbsADJTboyLNkGaNidTDUWUnYuPLBP3yNoMikujTYQQuYyihXz4Nudsh8UTKOg4Fq5d2HZemxaRfjSKBQv/aJSCFGJwYyv+3Fk1xJuafXq95QFkeIcbaG3CKiEjzEkCDIET+YAix4uh0tse4s90wguqZbt1cVFRVsL94Pzvyd3Cg5AB2h93XKYmIeJV6hCRgmTqPhK8fq739QrAFw6kzmv2GszllOTz/8/Ms3bGUSmclliALE7tMZOIJE4mzxPk6PRERr1CPkASu6FS4chmubhPA6P5O4EobClevxNCiXb2n+rtCWyEPrn2Qd7a9Q6WzEoDyqnL+/cu/eXnTy5RXlfs4QxER79CsscPQrLEAYCuF8jxwuSA0MiCmSu8u3M2YpWPqjAUZg/hg3AekRqR6OSsRkYajWWMiR8oc5n4EkJyyHI+xKmcVxfZiL2YjIuI7ujUmEoDCgmtvPPpnZlPzHh8lIvI7FUIiASjUFE3byLZ1xvom9CPYVX+hJCLSXKgQEglAtrJQ5p3yKMlhNffQah/dnjkD7sRmb2KbrIqINBKNERIJQG3NRVj+M5XXT76RA6HhZJRlkxqWTHJRFnHvXUPp+a8BEb5O87hUOiopshcRYgohIsS/fxYRaTwqhEQCkLk8BzI3kfDutSSEhNPb0gLKcqHSPW3eUlkAtPRpjsfK6XJyoPgAi7cu5usDXxNljuLKE6+kR3wPYi2xvk5PRJoYFUIiAcjosP3xxF7ifvw57qryckYNZ3fhbi795FJKK0ur237K/omx7cdyS79biA6N9l1yItLkaIyQSCCKbFm9iGQtoVFgifFuPg2k2F7M4+ser1EE/e79ne+TWZpZx1kiEsj8phB68MEHGTx4MFarlejo6CM6x+Vycffdd5OcnIzFYmHEiBFs3769cRMV8Qfh8XDa3+uOjXwIIpLrjjVxxfZivj7wtcf4qv2rvJeMiPgFvymE7HY7EyZM4Prrrz/icx599FGefvppXnjhBdauXUtYWBgjR46koqKiETMV8QMhYdB/Clz4KiR0de+rltIbLl8KXc4Bk//eNTcYDB5jJoPJi5mIiD/wm992c+bMAeCVV145ouNdLhfz5s3jH//4B2PHjgXg1VdfJTExkaVLl3LxxRc3Vqoi/sEaCyeMhdaDwWGH4FB3mx+LColiaKthfL5vZZ3xU1oO8XJGItLU+U0hdLTS09PJzMxkxIgR1W1RUVEMHDiQNWvWeCyEbDYbNtsfA0mLiooaPVfxf+WV5WSXZ/P53s/JLM3klJan0KlFJxLDEn2d2uGFx/s6gwZTYQvipp438mP2egpsBTVil3a6EKtTC0WKSE3NthDKzHQPikxMrPlBlJiYWB2ry9y5c6t7n0SOREVVBV/u/5LbVt+GC/cexou2LKJtZFteOuMlksP9c7yNPzI4bKSuf4PFA+/j45z1fJnzEy3MUUxKPZOOubugvBB/XRZARBqHT8cI3X777RgMhnofW7Zs8WpOs2fPprCwsPqxb98+r15f/E9OeQ63f3V7dRH0u91Fu3l2w7OUV5X7KLPAE+7Ix7z2WVouHMeUzat5PqQ9j9nMDPjgFlqsmIN1z2e+TlFEmhif9gjNmjWLyZMn13tMu3btjum1k5KSAMjKyiI5+Y9v5FlZWfTq1cvjeWazGbPZfEzXlMD0Q+YPOFyOOmOfpH/CtF7TsIRrE1NvCDLiHu8EmNK/JDL9y5pxu251i0hNPi2E4uPjiY9vnPEJaWlpJCUlsXLlyurCp6ioiLVr1x7VzDORw8mvyPcYq3JWUeX038UJ/Y3RHIGrVX8M+3+oM27oeIaXMxKRps5vps/v3buXDRs2sHfvXhwOBxs2bGDDhg2UlPyxIm6XLl1YsmQJ4J5CO336dB544AE++OADNm3axKRJk0hJSWHcuHE++imkOeqT0M9jrGN0R6xBVi9mE+CsMRjOerTOxSJdbU/FGJPmg6REpCnzm8HSd999NwsXLqx+3rt3bwC++OILhg4dCsDWrVspLCysPua2226jtLSUa665hoKCAk455RSWLVtGaKh21paGE22KpX9CX37IXl+j3YCBW/vegsuhmUpelXACTP0CVtwDe75yr5I98DoMvS6F8ARfZyciTYzB5XK5Dn9Y4CoqKiIqKorCwkIiIyN9nY40QYX7N2Mr3ck7+b+wKP1DiuxFdIvrxq1dJtHpwG/Yu00mJsa/1+fxS+WF7j3UDEZ3AWTUYooigeRIP7/9pkdIpKmy7PuSqOW3c23707mg5804Q8IIzd5Mi/dnQXEG9hPOB1QIeZ0lyv0QEamHCiGR42Ry2MHlImjHShJ31F7RONhvRuKJiAQe/YoWOU6mDsM8xlytBmAIVa+EiEhTpUJI5HhFtoQedWzZEmTGMPoxsMZ4PycRETkiujUmcrysMXDm/dDxDPhmHpTmQtshMGQWtNB0bRGRpkyFkEhDCE+A7hdAu6HgrAJzJIRo/SARkaZOhZBIQwqL83UGIiJyFDRGSERERAKWCiEREREJWCqEREREJGCpEBIREZGApUJIREREApYKIREREQlYKoREREQkYKkQEhERkYClQkhEREQClgohERERCVgqhERERCRgqRASERGRgKVCSERERAKWCiEREREJWCqEREREJGCpEBIREZGApUJIREREApYKIREREQlYQb5OQEREpLlxuVxUVVXhcDh8nUqzZTKZCAoKwmAwHNfrqBASERFpQHa7nYyMDMrKynydSrNntVpJTk4mJCTkmF9DhZCIiEgDcTqdpKenYzKZSElJISQk5Lh7LKQ2l8uF3W4nJyeH9PR0OnbsiNF4bKN9VAiJiIg0ELvdjtPpJDU1FavV6ut0mjWLxUJwcDB79uzBbrcTGhp6TK+jwdIiIiIN7Fh7J+ToNMT7rP9TIiIiErBUCImIiEjAUiEkIiISQHbv3o3BYGDDhg1HfM7kyZMZN25cvccMHTqU6dOnH1duvqDB0iIiIgEkNTWVjIwM4uLifJ1Kk6BCSEREJEDY7XZCQkJISkrydSpNht/cGnvwwQcZPHgwVquV6OjoIzpn8uTJGAyGGo9Ro0Y1bqIiIiIN4KWXXiIlJQWn01mjfezYsVx11VXs3LmTsWPHkpiYSHh4OP379+ezzz6rcWzbtm25//77mTRpEpGRkVxzzTW1bo05HA6mTJlCWloaFouFzp07889//rPOnObMmUN8fDyRkZFcd9112O12j/nbbDZuueUWWrZsSVhYGAMHDmTVqlXH9Z40Br8phOx2OxMmTOD6668/qvNGjRpFRkZG9ePNN99spAxFREQazoQJEzh06BBffPFFdVteXh7Lli1j4sSJlJSUMHr0aFauXMlPP/3EqFGjGDNmDHv37q3xOo8//jg9e/bkp59+4q677qp1HafTSatWrXjnnXf47bffuPvuu7njjjt4++23axy3cuVKNm/ezKpVq3jzzTd57733mDNnjsf8b7zxRtasWcPixYvZuHEjEyZMYNSoUWzfvv0435kG5vIzCxYscEVFRR3RsVdccYVr7Nixx3W9wsJCF+AqLCw8rtcREZHmr7y83PXbb7+5ysvLG+T1xo4d67rqqquqn7/44ouulJQUl8PhqPP4E0880fXMM89UP2/Tpo1r3LhxNY5JT093Aa6ffvrJ43WnTZvmGj9+fPXzK664whUTE+MqLS2tbnv++edd4eHh1bmcdtpprr/97W8ul8vl2rNnj8tkMrkOHDhQ43WHDx/umj17dv0/9FGo7/0+0s9vv+kROlarVq0iISGBzp07c/3113Po0KF6j7fZbBQVFdV4iIiI+MLEiRN59913sdlsALzxxhtcfPHFGI1GSkpKuOWWW+jatSvR0dGEh4ezefPmWj1C/fr1O+x1nnvuOfr27Ut8fDzh4eG89NJLtV6nZ8+eNVbLHjRoECUlJezbt6/W623atAmHw0GnTp0IDw+vfnz55Zfs3LnzWN6KRtOsB0uPGjWK888/n7S0NHbu3Mkdd9zBWWedxZo1azCZTHWeM3fu3Hq7+kRERLxlzJgxuFwuPv74Y/r3789XX33FU089BcAtt9zCihUrePzxx+nQoQMWi4ULLrig1ridsLCweq+xePFibrnlFp544gkGDRpEREQEjz32GGvXrj3mvEtKSjCZTKxfv77W5214ePgxv25j8GkhdPvtt/PII4/Ue8zmzZvp0qXLMb3+xRdfXP3n7t2706NHD9q3b8+qVasYPnx4nefMnj2bmTNnVj8vKioiNTX1mK4vIiJyPEJDQzn//PN544032LFjB507d6ZPnz4AfPPNN0yePJnzzjsPcBcfu3fvPuprfPPNNwwePJgbbrihuq2uXpuff/6Z8vJyLBYLAN999x3h4eF1fkb27t0bh8NBdnY2p5566lHn5E0+LYRmzZrF5MmT6z2mXbt2DXa9du3aERcXx44dOzwWQmazGbPZ3GDXFBEROR4TJ07knHPO4ddff+Wyyy6rbu/YsSPvvfceY8aMwWAwcNddd9WaYXYkOnbsyKuvvsqnn35KWloar732Gj/88ANpaWk1jrPb7UyZMoV//OMf7N69m3vuuYcbb7yxzv2+OnXqxMSJE5k0aRJPPPEEvXv3Jicnh5UrV9KjRw/OPvvso38jGolPC6H4+Hji4+O9dr39+/dz6NAhkpOTvXZNERGR43H66acTExPD1q1bufTSS6vbn3zySa666ioGDx5MXFwcf//7349pXOu1117LTz/9xEUXXYTBYOCSSy7hhhtu4L///W+N44YPH07Hjh0ZMmQINpuNSy65hHvvvdfj6y5YsIAHHniAWbNmceDAAeLi4jjppJM455xzjjrHxmRwuVwuXydxJPbu3UteXh4ffPABjz32GF999RUAHTp0qL7f2KVLF+bOnct5551HSUkJc+bMYfz48SQlJbFz505uu+02iouL2bRp0xH3+hQVFREVFUVhYSGRkZGN9vOJiIj/q6ioID09nbS0NEJDQ32dTrNX3/t9pJ/ffjNY+u6772bhwoXVz3v37g3AF198wdChQwHYunUrhYWFAJhMJjZu3MjChQspKCggJSWFM888k/vvv1+3vkRERATwo0LolVde4ZVXXqn3mD93blksFj799NNGzkpERET8WbNfR0hERETEExVCIiIiErBUCImIiEjAUiEkIiIiAUuFkIiIiAQsv5k1JiJyPIptxRyyHaLIVkRYcBgxoTG0CG3h67RExMdUCIlIs5ddls2jPzzK8t3LceFeZqNHXA8eHfIoLSNa+jg7EfEl3RoTkWatrLKMZ356hk93f1pdBAFszN3IzV/czKHyQz7MTqR52717NwaDgQ0bNvg6FY/UIyQizdqhikN8tPOjOmPb8reRXZZNrCXWy1mJHF5hmZ3cEjtFFZVEWoKJCwshyhri67SaHRVCItKslVWWUeWq8hjPLsuma2xXL2YkcngHC8r5+7sb+Wp7bnXbkI5xPDy+BynRFq/kYLfbCQlp/oWXbo2JSLNmDbYSZPD8nS/RmujFbEQOr7DMXqsIAli9PZfb391IYZm9Ua47dOhQbrzxRqZPn05cXBwjR47kl19+4ayzziI8PJzExEQuv/xycnP/yGvZsmWccsopREdHExsbyznnnMPOnTuP+toul4sOHTrw+OOP12jfsGEDBoOBHTt2HPfP54kKIRFp1mJDYzmn/Tl1xjq16ES8Nd7LGYnUL7fEXqsI+t3q7bnkljROIQSwcOFCQkJC+Oabb3j44Yc5/fTT6d27N+vWrWPZsmVkZWVx4YUXVh9fWlrKzJkzWbduHStXrsRoNHLeeefhdDqP6roGg4GrrrqKBQsW1GhfsGABQ4YMoUOHDg3y89VFt8ZEpFmzBlu5scskKmzFfLrv8+oB0z3juvNw/zuINph9nKFITUUVlfXGiw8TPx4dO3bk0UcfBeCBBx6gd+/ePPTQQ9Xx+fPnk5qayrZt2+jUqRPjx4+vcf78+fOJj4/nt99+o1u3bkd17cmTJ3P33Xfz/fffM2DAACorK1m0aFGtXqKGph4hEWnW7PkHSHztAu6uCufDU59k0cmPsvTUp3gmuh+tFo7DWZLj6xRFaogMDa43HnGY+PHo27dv9Z9//vlnvvjiC8LDw6sfXbp0Aai+/bV9+3YuueQS2rVrR2RkJG3btgVg7969R33tlJQUzj77bObPnw/Ahx9+iM1mY8KECcf5U9VPPUIi0ryV50HBbiK+fYaIb5+pFXYe2gFxaT5ITKRuceEhDOkYx+o6bo8N6RhHXHjjDWAOCwur/nNJSQljxozhkUceqXVccnIyAGPGjKFNmzb861//IiUlBafTSbdu3bDbj+323dVXX83ll1/OU089xYIFC7jooouwWq3H9sMcIRVCItKsuQ7T8e3C5KVMRI5MlDWEh8f34PZ3N9YohoZ0jOOR8T28NoW+T58+vPvuu7Rt25agoNrlwqFDh9i6dSv/+te/OPXUUwH4+uuvj+uao0ePJiwsjOeff55ly5axevXq43q9I6FCSESaNWdoC4hpB3m7ageDQjHEtvN+UiKHkRJt4ZlLepNbYqe4opKI0GDiwr27jtC0adP417/+xSWXXMJtt91GTEwMO3bsYPHixfz73/+mRYsWxMbG8tJLL5GcnMzevXu5/fbbj+uaJpOJyZMnM3v2bDp27MigQYMa6KfxTGOERKRZC4lOpvyc/4Og2oOiy0Y9hUOzxqSJirKG0D4hnF6tW9A+IdzriymmpKTwzTff4HA4OPPMM+nevTvTp08nOjoao9GI0Whk8eLFrF+/nm7dujFjxgwee+yx477ulClTsNvtXHnllQ3wUxyeweVyuQ5/WOAqKioiKiqKwsJCIiMjfZ2OiByD0rJyjEX7YP0rWDLXYY9Oo7LfdbhapBEeGe3r9KQZqaioID09nbS0NEJDQ32djl/66quvGD58OPv27SMxsf51vup7v4/081u3xkSk2QuzWsDaiaJhd1FlL8MZZCYqPNzXaYnIn9hsNnJycrj33nuZMGHCYYughqJbYyISMCKtFiKiY1UEifjAddddV2Mq/p8f1113HW+++SZt2rShoKCgei0jb9CtscPQrTERETlSujXmWXZ2NkVFRXXGIiMjSUhIOOrX1K0xERER8QsJCQnHVOw0Nt0aExERkYClHiGRo5RfkU9eRR7lVeVEhkQSa4klLDjs8CeKiEiTo0JI5CjsL97PbatvY1PuJgCMBiNj24/lpt43aRdzERE/pFtjIkcotzyXG1beUF0EAThdTpbsWML8X+Zjq7L5MDsRETkWKoREjlBGaQbphel1xt7e+ja55bU3SBQRkaZNhZDIETpQfMBjzO60U1ZV5sVsRESkIagQEjlCKeEpHmPBxmAsQRYvZiMizV55PuRug/3rIHe7+7kPuVwu7r77bpKTk7FYLIwYMYLt27fXOKZt27YYDIYaj4cffthHGR8ZDZYWOUKJ1iTaRLZhT9GeWrHzOpxHnCXOB1mJSLNUeADevxF2ff5HW/vhcO4zENXSJyk9+uijPP300yxcuJC0tDTuuusuRo4cyW+//VZjMcP77ruPqVOnVj+PiIjwRbpHTD1CIkcowu7i//r/g84tOle3GTBwVupwrml9Fo5Kpw+zE5Fmozy/dhEEsHMlfHBTo/UMlZaWMmnSJMLDw0lOTuaJJ55g6NChTJ8+HZfLxbx58/jHP/7B2LFj6dGjB6+++ioHDx5k6dKlNV4nIiKCpKSk6kdYWNNeXkSFkMgRMhYfpPWbl/FiwjCWDHmK109+hA+HPMVdVeEkvjaeoNJsX6coIs1BaU7tIuh3O1e6443g1ltv5csvv+T9999n+fLlrFq1ih9//BGA9PR0MjMzGTFiRPXxUVFRDBw4kDVr1tR4nYcffpjY2Fh69+7NY489RlVVVaPk21B0a0x8pqyyjEMVh6ioqiAsOIx4SzzBpmBfp+XZoZ1QmkPssjuIBTAY4M9b9dlLfJWZiDQnFXXvx3XE8WNQUlLCyy+/zOuvv87w4cMBWLhwIa1atQIgMzMToNaO8ImJidUxgJtvvpk+ffoQExPDt99+y+zZs8nIyODJJ59s8Jwbigoh8Yms0iweX/c4K/aswOFyYA2ycmW3K5nQaQKxllhfp1cnU4u/3Jf/cxFkDMIYYvVuQiLSPIUeZoPvw8WPwc6dO7Hb7QwcOLC6LSYmhs6dO9dzVm0zZ86s/nOPHj0ICQnh2muvZe7cuZjN5gbLtyH5xa2x3bt3M2XKFNLS0rBYLLRv35577rkHu91e73kVFRVMmzaN2NhYwsPDGT9+PFlZWV7KWjzJK8/jttW3sWz3MhwuBwBlVWU8t+E5/rPtP1Q6Kn2coQdRqRBZ9yBFxwnnY4pIrDMmInJUwuLdA6Pr0n64O+5lSUlJALU+Q7OysqpjdRk4cCBVVVXs3r27MdM7Ln5RCG3ZsgWn08mLL77Ir7/+ylNPPcULL7zAHXfcUe95M2bM4MMPP+Sdd97hyy+/5ODBg5x//vleylo8yS7P5sfsH+uMzf9lPjnljXP/+3gFt2iFY+J77oLoT5xth+AacS9Gc9MeECgifsLSwj077K/F0O+zxiwtGvyS7du3Jzg4mLVr11a35efns23bNgDS0tJISkpi5cqV1fGioiLWrl3LoEGDPL7uhg0bMBqNTXLX+d/5xa2xUaNGMWrUqOrn7dq1Y+vWrTz//PM8/vjjdZ5TWFjIyy+/zKJFizj99NMBWLBgAV27duW7777jpJNOqvM8m82GzfbHVglFRQ1/LzbQ1TX9/HdlVWWUVpZ6MZujY0rsgnPKclyFB3CV5GBo0QZTRBLGsKZ5O09E/FRUS7jgZffA6Ioi9+2wsPhGKYIAwsPDmTJlCrfeeiuxsbEkJCRw5513YjS6+0sMBgPTp0/ngQceoGPHjtXT51NSUhg3bhwAa9asYe3atQwbNoyIiAjWrFnDjBkzuOyyy2jRonHybgh+UQjVpbCwkJiYGI/x9evXU1lZWWOEe5cuXWjdujVr1qzxWAjNnTuXOXPmNHi+8ocEq+dvBkaDkVBTqMd4U2CMTIFIz4sriog0CEuLRit86vLYY49RUlLCmDFjiIiIYNasWRQWFlbHb7vtNkpLS7nmmmsoKCjglFNOYdmyZdVrCJnNZhYvXsy9996LzWYjLS2NGTNm1Bg31BT5ZSG0Y8cOnnnmGY+9QeAe4R4SEkJ0dHSN9r+OcP+r2bNn1/ifVlRURGpqqsfj5eilhKWQYE0gu6z2dPMzWo8gxuK5wBURkcYRHh7Oa6+9xmuvvVbd9vHHH1f/2WAwcN9993HffffVeX6fPn347rvvGj3PhubTMUK33357raW4//rYsmVLjXMOHDjAqFGjmDBhQo2VKxuK2WwmMjKyxkMaVqzDxYsD59TqGeoV151bOl1CmNYlFBERL/Fpj9CsWbOYPHlyvce0a9eu+s8HDx5k2LBhDB48mJdeeqne85KSkrDb7RQUFNToFTrcCHfxgrzddPjgJhadPpuDZivZFYdoE5ZMQs4OYl4dT+XVXxBsbnf41xERETlOPi2E4uPjiY8/smmABw4cYNiwYfTt25cFCxZUD+DypG/fvgQHB7Ny5UrGjx8PwNatW9m7d2+9I9yl8VUVHCAobxeJ/5lKYkgYmCOh7BA43MshuOzaxV1EpClYtWqVr1NodH4xff7AgQMMHTqU1q1b8/jjj5OTk0NmZmaNsT4HDhygS5cufP/994B76e8pU6Ywc+ZMvvjiC9avX8+VV17JoEGDPA6UFu9wxaT98cReCsUZ1UUQwRacwZqGLiIi3uEXg6VXrFjBjh072LFjR/Vy379z/W9138rKSrZu3UpZ2R+9CU899RRGo5Hx48djs9kYOXIk//d//+fV3KU2Z3gyzqReGDM31IqV9bmGKksCTXvemIiINBcGl+vP+wTIXxUVFREVFUVhYaEGTjeQ8koHtkN7iVhxK6Zdn7m3qggyU9braioHTiMqvu7Vm0VEmrqKigrS09NJS0urnlYujae+9/tIP7/9okdImhdLsImq6Fbkjvw/XKU5uGylGCxRmCKTaBEZ4ev0REQkgKgQEp+ICA0mIjQBW1Ustkon1hATQSa/GLImIiLNiAoh8SlzkAlzkOmYzs0szWRP0R72FO2hXVQ7Wke2rnfVahERkb9SISR+aVfBLqaumFpjdeqW4S156YyXaB3Z2oeZiYiIP9G9CPE7OWU53PzFzbW26DhQcoBbV99Kfnm+jzITEWk4hbZC0gvT2ZizkfTCdApthYc/qRFlZWUxefJkUlJSsFqtjBo1iu3bt9c4ZujQobV2iLjuuut8lPGRUY+Q+J28ijyPO9j/dug38mx5tPDiRoUiIg0tszSTe769h28PflvddnLKydw7+F6Swry/O4LL5WLcuHEEBwfz/vvvExkZyZNPPsmIESP47bffCAv7Y/23qVOn1tiPzGq1ej3fo6EeIfE7pZWl9cYrqiq8lImISMMrtBXWKoIAvjn4Dfd+e2+j9QyVlpYyadIkwsPDSU5O5oknnmDo0KFMnz6d7du389133/H888/Tv39/OnfuzPPPP095eTlvvvlmjdexWq0kJSVVP5r60jMqhMTvxFpiMWCoMxZkDCLKHOXljEREGk5eRV6tIuh33xz8hryKvEa57q233sqXX37J+++/z/Lly1m1ahU//vgjADabDaDGWj1GoxGz2czXX39d43XeeOMN4uLi6NatG7Nnz66x0HFTpFtj4ndiQ2MZ2/5clu58v1bsks4XE2uJ9UFWIiINo9hefFzxY1FSUsLLL7/M66+/zvDhwwFYuHBh9W4OXbp0oXXr1syePZsXX3yRsLAwnnrqKfbv309GRkb161x66aW0adOGlJQUNm7cyN///ne2bt3Ke++91+A5NxQVQuJ3gp1Gbmo/gViThUW73qe8qpzw4HAmdxjPealnEOQ6tun4IiJNQURI/QvLHi5+LHbu3IndbmfgwIHVbTExMXTu3BmA4OBg3nvvPaZMmUJMTAwmk4kRI0Zw1lln8ecNKq655prqP3fv3p3k5GSGDx/Ozp07ad++fYPn3RBUCInfMZRkkbDgLKa1P50L+96JzRREaKWN+A2LCfr8GWxTv4JYTaEXEf8UExrDySkn883Bb2rFTk45mZjQGB9kBX379mXDhg0UFhZit9uJj49n4MCB9OvXz+M5vxdWO3bsaLKFkMYIif8pyQJ7KcGbPyRl8STS3riU5LevJGjbp1BRgKEs19cZiogcsyhzFPcOvpeTU06u0f77rLHGGAfZvn17goODWbt2bXVbfn4+27Ztq51fVBTx8fFs376ddevWMXbsWI+vu2HDBgCSk5MbPOeGoh4h8T/Gw/y1NerWmIj4t6SwJB4Z8gh5FXkU24uJCIkgJjSm0SaDhIeHM2XKFG699VZiY2NJSEjgzjvvxGj8o7/knXfeIT4+ntatW7Np0yb+9re/MW7cOM4880zAfXtt0aJFjB49mtjYWDZu3MiMGTMYMmQIPXr0aJS8G4IKIfE/YQlgaQF1LZwYmYJLg6VFpBmIMkd5dRbsY489RklJCWPGjCEiIoJZs2ZRWPjHVP2MjAxmzpxJVlYWycnJTJo0ibvuuqs6HhISwmeffca8efMoLS0lNTWV8ePH849//MNrP8OxMLj+PMpJaikqKiIqKorCwsImvxZCoHBWVeHY+QXBb10ETscfAVMIlRPfIzjtFDDUPb1eRKQxVVRUkJ6eTlpaWo2p5v5q6NCh9OrVi3nz5vk6lTrV934f6ee3eoTE7xiDgnC2PZmqa7/Ftf4VgnM3U5nYC0PvyzC2aKMiSEREjpgKIfFLQWYrJHaBkQ+Co4LgoFCNDRIRkaOmQkj8m8kEprDDHyciIkdt1apVvk6h0Wn6vIiIiAQsFUIiIiINTPOQvKMh3mcVQiIiIg0kODgYoMlvNNpc/P4+//6+HwuNERIREWkgJpOJ6OhosrOzAbBarRg0k7XBuVwuysrKyM7OJjo6GpPp2CfLqBASERFpQElJSQDVxZA0nujo6Or3+1ipEBIREWlABoOB5ORkEhISqKys9HU6zVZwcPBx9QT9ToWQiIhIIzCZTA3yQS2NS4OlRUREJGCpEBIREZGApUJIREREApbGCB3G74s1FRUV+TgTEREROVK/f24fbtFFFUKHUVxcDEBqaqqPMxEREZGjVVxcTFRUlMe4waV1wOvldDo5ePAgERERWhSrARQVFZGamsq+ffuIjIz0dTrNht7XxqH3tXHofW0cel9rcrlcFBcXk5KSgtHoeSSQeoQOw2g00qpVK1+n0exERkbqH2oj0PvaOPS+Ng69r41D7+sf6usJ+p0GS4uIiEjAUiEkIiIiAUuFkHiV2WzmnnvuwWw2+zqVZkXva+PQ+9o49L42Dr2vx0aDpUVERCRgqUdIREREApYKIREREQlYKoREREQkYKkQEhERkYClQkh8Yvfu3UyZMoW0tDQsFgvt27fnnnvuwW63+zo1v/fggw8yePBgrFYr0dHRvk7Hbz333HO0bduW0NBQBg4cyPfff+/rlPze6tWrGTNmDCkpKRgMBpYuXerrlJqFuXPn0r9/fyIiIkhISGDcuHFs3brV12n5DRVC4hNbtmzB6XTy4osv8uuvv/LUU0/xwgsvcMcdd/g6Nb9nt9uZMGEC119/va9T8VtvvfUWM2fO5J577uHHH3+kZ8+ejBw5kuzsbF+n5tdKS0vp2bMnzz33nK9TaVa+/PJLpk2bxnfffceKFSuorKzkzDPPpLS01Nep+QVNn5cm47HHHuP5559n165dvk6lWXjllVeYPn06BQUFvk7F7wwcOJD+/fvz7LPPAu49B1NTU7npppu4/fbbfZxd82AwGFiyZAnjxo3zdSrNTk5ODgkJCXz55ZcMGTLE1+k0eeoRkiajsLCQmJgYX6chAc5ut7N+/XpGjBhR3WY0GhkxYgRr1qzxYWYiR6awsBBAv0+PkAohaRJ27NjBM888w7XXXuvrVCTA5ebm4nA4SExMrNGemJhIZmamj7ISOTJOp5Pp06dz8skn061bN1+n4xdUCEmDuv322zEYDPU+tmzZUuOcAwcOMGrUKCZMmMDUqVN9lHnTdizvq4gEnmnTpvHLL7+wePFiX6fiN4J8nYA0L7NmzWLy5Mn1HtOuXbvqPx88eJBhw4YxePBgXnrppUbOzn8d7fsqxy4uLg6TyURWVlaN9qysLJKSknyUlcjh3XjjjXz00UesXr2aVq1a+Todv6FCSBpUfHw88fHxR3TsgQMHGDZsGH379mXBggUYjeqg9ORo3lc5PiEhIfTt25eVK1dWD+R1Op2sXLmSG2+80bfJidTB5XJx0003sWTJElatWkVaWpqvU/IrKoTEJw4cOMDQoUNp06YNjz/+ODk5OdUxfes+Pnv37iUvL4+9e/ficDjYsGEDAB06dCA8PNy3yfmJmTNncsUVV9CvXz8GDBjAvHnzKC0t5corr/R1an6tpKSEHTt2VD9PT09nw4YNxMTE0Lp1ax9m5t+mTZvGokWLeP/994mIiKgeyxYVFYXFYvFxdk2fps+LT7zyyiseP1T0V/L4TJ48mYULF9Zq/+KLLxg6dKj3E/JTzz77LI899hiZmZn06tWLp59+moEDB/o6Lb+2atUqhg0bVqv9iiuu4JVXXvF+Qs2EwWCos33BggWHvaUuKoREREQkgGlQhoiIiAQsFUIiIiISsFQIiYiISMBSISQiIiIBS4WQiIiIBCwVQiIiIhKwVAiJiIhIwFIhJCIiIgFLhZCIiIgELBVCIhLwVq1aRZ8+fTCbzXTo0EHbPYgEEBVCIhLQ0tPTOfvssxk2bBgbNmxg+vTpXH311Xz66ae+Tk1EvEB7jYlIs5aTk0P37t25+eabueOOOwD49ttvGTp0KP/9739Zvnw5H3/8Mb/88kv1ORdffDEFBQUsW7bMV2mLiJeoR0hEmrX4+Hjmz5/Pvffey7p16yguLubyyy/nxhtvZPjw4axZs4YRI0bUOGfkyJGsWbPGRxmLiDcF+ToBEZHGNnr0aKZOncrEiRPp168fYWFhzJ07F4DMzEwSExNrHJ+YmEhRURHl5eVYLBZfpCwiXqIeIREJCI8//jhVVVW88847vPHGG5jNZl+nJCJNgAohEQkIO3fu5ODBgzidTnbv3l3dnpSURFZWVo1js7KyiIyMVG+QSADQrTERafbsdjuXXXYZF110EZ07d+bqq69m06ZNJCQkMGjQID755JMax69YsYJBgwb5KFsR8SbNGhORZu/WW2/lP//5Dz///DPh4eGcdtppREVF8dFHH5Genk63bt2YNm0aV111FZ9//jk333wzH3/8MSNHjvR16iLSyFQIiUiztmrVKs444wy++OILTjnlFAB2795Nz549efjhh7n++utZtWoVM2bM4LfffqNVq1bcddddTJ482beJi4hXqBASERGRgKXB0iIiIhKwVAiJiIhIwFIhJCIiIgFLhZCIiIgELBVCIiIiErBUCImIiEjAUiEkIiIiAUuFkIiIiAQsFUIiIiISsFQIiYiISMBSISQiIiIB6/8BDfcqHKAU2tEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## plot QR results\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = clf5.predict(X_sample)\n", + "q95_sample = clf95.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eezf3egK8S32" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "t99I5I5E8s0S", + "outputId": "63b686c2-40ec-450e-b833-440f72c82aac" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(C=0.001,\n",
+              "                                     loss={'name': 'QR', 'qt': 0.95}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(C=0.001,\n", + " loss={'name': 'QR', 'qt': 0.95}))])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve QR with different `qt` via `plq_Ridge_Regressor` with Pipeline\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe5 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n))\n", + "])\n", + "pipe5.fit(X=X, y=y)\n", + "\n", + "pipe95 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n))\n", + "])\n", + "pipe95.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "D0n0ZqKC8uoj", + "outputId": "f9280f7b-77a7-4030-8b80-840d527ec240" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## plot QR results\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = pipe5.predict(X_sample)\n", + "q95_sample = pipe95.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples_FEI/STAR2000_loss_QR_with_tol.ipynb b/examples_FEI/STAR2000_loss_QR_with_tol.ipynb new file mode 100644 index 0000000..6f223d2 --- /dev/null +++ b/examples_FEI/STAR2000_loss_QR_with_tol.ipynb @@ -0,0 +1,1111 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "id": "OYf6ieCxG5Is", + "outputId": "3c5d6592-1e5c-4dd3-9f62-0312c6dbb623", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-mha0b2ca\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-mha0b2ca\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=d53fa588ab159c0770b7caee4454e2c23159fd702245525d843f6a754cc8d391\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-edl2raxl/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate Data\n", + "import numpy as np\n", + "\n", + "np.random.seed(42)\n", + "n = 2000\n", + "x = np.random.randn(n)\n", + "noise = np.random.randn(n) * (0.3 + 0.5 * np.abs(x))\n", + "y = 2 * x + noise\n", + "X = x.reshape(-1, 1)" + ], + "metadata": { + "id": "54zIQq6-Bqm8" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from rehline import plq_Ridge_Regressor\n", + "\n", + "# Check Loss with epsilon-tolerance\n", + "clf = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.9, 'epsilon': 0.1}, C=10.0/n)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "id": "LpdGRLz3CKFM", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 97 + }, + "outputId": "45d86e36-a471-4e23-dc0b-13fc0a3ca56c" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.005,\n", + " loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.005,\n",
+              "                    loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot Check Loss with epsilon results\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "# Parameters\n", + "epsilon = 0.3\n", + "\n", + "# Fit Check Loss with epsilon (two quantiles)\n", + "clf05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", + "clf05.fit(X=X, y=y)\n", + "\n", + "clf95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", + "clf95.fit(X=X, y=y)\n", + "\n", + "# Plot\n", + "n_sample = 100\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = clf05.predict(X_sample)\n", + "q95_sample = clf95.predict(X_sample)\n", + "\n", + "# sort by x0\n", + "sort_idx = np.argsort(X_sample[:,0])\n", + "x0_sorted = X_sample[sort_idx, 0]\n", + "y_sorted = y_sample[sort_idx]\n", + "q05_sorted = q05_sample[sort_idx]\n", + "q95_sorted = q95_sample[sort_idx]\n", + "\n", + "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", + "plt.plot(x0_sorted, q05_sorted, 'orange', linewidth=2, label='q05')\n", + "plt.plot(x0_sorted, q95_sorted, 'green', linewidth=2, label='q95')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "fdFQpu9gCOlT", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 427 + }, + "outputId": "2af32392-8aa2-4a3b-efba-448086b57091" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Comparison: Original QR vs Check Loss with epsilon\n", + "import numpy as np\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "# Parameters\n", + "epsilon = 0.2\n", + "\n", + "# Fit original QR\n", + "clf_qr05 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", + "clf_qr05.fit(X=X, y=y)\n", + "\n", + "clf_qr95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", + "clf_qr95.fit(X=X, y=y)\n", + "\n", + "# Fit Check Loss with epsilon\n", + "clf_eps05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", + "clf_eps05.fit(X=X, y=y)\n", + "\n", + "clf_eps95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", + "clf_eps95.fit(X=X, y=y)" + ], + "metadata": { + "id": "ElZCOJ2lB0mP", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 97 + }, + "outputId": "8d47c878-bddf-49a8-937e-11bbb0a2cee0" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.005,\n", + " loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.005,\n",
+              "                    loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot\n", + "n_sample = 300\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "\n", + "sort_idx = np.argsort(X_sample[:,0])\n", + "x0_sorted = X_sample[sort_idx, 0]\n", + "y_sorted = y_sample[sort_idx]\n", + "\n", + "qr05_sorted = clf_qr05.predict(X_sample)[sort_idx]\n", + "qr95_sorted = clf_qr95.predict(X_sample)[sort_idx]\n", + "eps05_sorted = clf_eps05.predict(X_sample)[sort_idx]\n", + "eps95_sorted = clf_eps95.predict(X_sample)[sort_idx]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", + "plt.plot(x0_sorted, qr05_sorted, 'orange', linewidth=2, label='QR_05')\n", + "plt.plot(x0_sorted, qr95_sorted, 'orange', linewidth=2, linestyle='--', label='QR_95')\n", + "plt.plot(x0_sorted, eps05_sorted, 'green', linewidth=2, label='QR_eps_05')\n", + "plt.plot(x0_sorted, eps95_sorted, 'green', linewidth=2, linestyle='--', label='QR_eps_95')\n", + "plt.legend()\n", + "plt.title(f'Original QR vs Check Loss with epsilon (eps={epsilon})')\n", + "plt.show()" + ], + "metadata": { + "id": "Q3fIo_UwC7yN", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 364 + }, + "outputId": "a9e1fcb4-81be-47a3-c28a-be5a3ac8c575" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_SVM.ipynb b/examples_FEI/STAR2000_loss_SVM.ipynb new file mode 100644 index 0000000..12ca4ac --- /dev/null +++ b/examples_FEI/STAR2000_loss_SVM.ipynb @@ -0,0 +1,1111 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OW25uH0Trqxn" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p_7oxpX8Nqqd", + "outputId": "2f3541b7-0b9b-4aaa-fb6c-ff47e84eccf1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting rehline\n", + " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", + "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: rehline\n", + "Successfully installed rehline-0.1.1\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NVVj0auob6c6" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 137 + }, + "id": "WpgI_saqFj-r", + "outputId": "a5baf759-778c-47eb-ef92-ad95398e2646" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'svm'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'svm'})" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 469 + }, + "id": "x2PIL0esFrQ6", + "outputId": "163ac4e8-51e7-4b63-e744-874ee510a087" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WDsb-OMtFwz-" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_MKFw7E4pF1b" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 213 + }, + "id": "VHj2Y6zOLb1M", + "outputId": "4f030161-735d-49c5-a4d0-1dba300bbaa2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 426 + }, + "id": "ogQFzB34LdvI", + "outputId": "88c2f1a5-fbe5-42d5-9166-e7aac31ec80a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/examples_FEI/STAR2000_loss_SVR.ipynb b/examples_FEI/STAR2000_loss_SVR.ipynb new file mode 100644 index 0000000..74e97e8 --- /dev/null +++ b/examples_FEI/STAR2000_loss_SVR.ipynb @@ -0,0 +1,1122 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NjjjqDBE4pkX", + "outputId": "de7ec7ea-4d4e-4bd0-93a8-45ce9586dd67" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-09286p2r\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-09286p2r\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=9bb240a05e1f7c3d447e7374f4286a1cb179ec22a749e284dced975b93ff3b27\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-ullopi_j/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "sIbawm0_3iq9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_svr = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_svr.fit_transform(X)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "eq-Bqnt14Xcf" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve SVR via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "HgExVVV54a58", + "outputId": "35f56019-877c-49a9-a72e-9c135a136cfc" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot SVR results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "svr_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "URF-gXRN45jb", + "outputId": "4c0a1b1f-3189-4972-a4fd-161c700bffa6" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#With pipeline" + ], + "metadata": { + "id": "gVGSI7iz5RLm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ], + "metadata": { + "id": "3-rs8zHc3vVb" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "6RXuMsWQ5aNh" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve SVR via `plq_Ridge_Regressor` with Pipeline\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "Iq5LJkIj5b49", + "outputId": "da81add6-dc6c-4e06-b7f0-ed386812737f" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot SVR results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "svr_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "tLkX5wvV5qPJ", + "outputId": "47af9451-b318-4cfd-a4c8-3e432899932e" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb b/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb new file mode 100644 index 0000000..9373488 --- /dev/null +++ b/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb @@ -0,0 +1,1102 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "lRz5G7RAaFtj" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-GNV_K9al_tQ", + "outputId": "9cae07ee-03d0-4ede-848d-d3201cbcaca2" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-al6i7zz6\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-al6i7zz6\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=bc61970eef67d92d0256e4429ad1bbd576c2e0ed03185a2e257b2abec3348aa1\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-egsuyb_8/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "ZawpNRuQR9Uu" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "lskTdleDZwpa", + "outputId": "b3f748ec-1837-43ae-fa9d-cb1f90e6a58e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'sSVM'})" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'sSVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "## solve Smooth SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 429 + }, + "id": "g5DCBXT5Z5uR", + "outputId": "9b94bd5a-511d-4a08-e5c5-a18dd1be2d71" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sZPCmCtOaXY8" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "MCEXWUchaaP_" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "PwMysLRWaiv_", + "outputId": "9e65777b-3a1b-478d-beb8-02a2d81b8a1e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 429 + }, + "id": "ZMofqZ_zakNc", + "outputId": "357b460b-59ed-489b-85bb-14abf025c4b7" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_Squared_SVM.ipynb b/examples_FEI/STAR2000_loss_Squared_SVM.ipynb new file mode 100644 index 0000000..a7648b1 --- /dev/null +++ b/examples_FEI/STAR2000_loss_Squared_SVM.ipynb @@ -0,0 +1,1105 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "QvfFVk7WRUAb" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lrklwkcyDvTw", + "outputId": "5b429a02-890e-4cd2-8bd7-099fb6790a78" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2nf2n7rx\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2nf2n7rx\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=566656c57e2918bd1d23613f29cfa356fec6e937d1ec37f8bb98febb77371d0f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-2u6y9ak2/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "w08Rlr8La4Mv" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "MlOfn-UmRCuN", + "outputId": "06ee1d8d-8e54-4f32-e413-b0c17c380fdc" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'squared SVM'})" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'squared SVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 432 + }, + "id": "mcbLDBYGRM4W", + "outputId": "eee04718-16ad-4ce5-e9e3-540d9c4bdb23" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u1wBO4l9zL1z" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "1XPWQmcpSRYy" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "Hu-ipK_n1_Br", + "outputId": "d119f0a0-fde5-45a1-e0c1-f1933eac9f37" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "## solve Squared SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0))\n", + "])\n", + "pipe.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 432 + }, + "id": "WXuTX7ok2Drw", + "outputId": "1443d2b1-db05-4d49-8f6e-e1ff49127827" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## visualization\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_huber.ipynb b/examples_FEI/STAR2000_loss_huber.ipynb new file mode 100644 index 0000000..f611a57 --- /dev/null +++ b/examples_FEI/STAR2000_loss_huber.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8MeXCyHX0hSB", + "outputId": "93160eee-b883-4588-d043-05a97c4e3ee2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ir2yao1k\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ir2yao1k\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=4819e8f088a3974b692227a2d9811df20e294ee6ba9f04586146333463688d7d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-qqgkwxb1/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ], + "metadata": { + "id": "l1yoptXqUxlc" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "96X3ttm4Em6O" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "np.random.seed(42)\n", + "scaler_huber = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_huber.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "vSCgN97C0ei6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "outputId": "a95d354f-4c50-4b23-d4f8-b12c481c1853" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve Huber Regression with different `tau` via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf_tau01 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001)\n", + "clf_tau01.fit(X=X, y=y)\n", + "clf_tau5 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001)\n", + "clf_tau5.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "-lHj744W0gFS", + "outputId": "b6b978ad-e980-4fee-f4e5-5863f17bbb0e" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot Huber Regression results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "tau01_sample = clf_tau01.predict(X_sample)\n", + "tau5_sample = clf_tau5.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample,'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "l4oYORhVDgfa" + }, + "outputs": [], + "source": [ + "#With pipeline" + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ], + "metadata": { + "id": "HsIykQjgXxJ8" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "XgGUDZnNEDnU" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "dsos8G2nEQqX", + "outputId": "6121b652-a083-4d52-d569-bcf0b1cca69f" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(C=0.001,\n", + " loss={'name': 'huber', 'tau': 5.0}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(C=0.001,\n",
+              "                                     loss={'name': 'huber', 'tau': 5.0}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve Huber Regression with different 'tau' via 'plq_Ridge_Regressor'\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe_tau01 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001))\n", + "])\n", + "pipe_tau01.fit(X, y)\n", + "\n", + "pipe_tau5 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001))\n", + "])\n", + "pipe_tau5.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "jSJn1AaSEVfg", + "outputId": "8f3ecb7e-a79f-46a3-d794-103b62742843" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot Huber Regression results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "tau01_sample = pipe_tau01.predict(X_sample)\n", + "tau5_sample = pipe_tau5.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file From d5a202be4ba7292372a56d38ddc23d43813b6fae Mon Sep 17 00:00:00 2001 From: fzh <1155233259@link.cuhk.edu.hk> Date: Thu, 2 Apr 2026 01:11:01 +0800 Subject: [PATCH 2/3] Move notebooks to examples folder and update rst files --- doc/source/examples/CustomQR.ipynb | 1134 ++++++++++++++++ doc/source/examples/FairSVM_new.ipynb | 1120 ++++++++++++++++ .../examples/GridSearchCV_SVM_losses.ipynb | 731 +++++++++++ .../examples/GridSearchCV_reg_losses.ipynb | 727 +++++++++++ doc/source/examples/Huber_new.ipynb | 1135 +++++++++++++++++ doc/source/examples/MAE_new.ipynb | 1135 +++++++++++++++++ doc/source/examples/MSE_new.ipynb | 1119 ++++++++++++++++ doc/source/examples/MonotonicSVM.ipynb | 1118 ++++++++++++++++ doc/source/examples/QR_eps_new.ipynb | 1111 ++++++++++++++++ doc/source/examples/QR_new.ipynb | 1096 ++++++++++++++++ doc/source/examples/SVM_new.ipynb | 1111 ++++++++++++++++ doc/source/examples/SVR_new.ipynb | 1122 ++++++++++++++++ doc/source/examples/Smooth_SVM_new.ipynb | 1102 ++++++++++++++++ doc/source/examples/Squared_SVM_new.ipynb | 1105 ++++++++++++++++ doc/source/tutorials/constraint.rst | 15 + doc/source/tutorials/loss.rst | 49 + 16 files changed, 14930 insertions(+) create mode 100644 doc/source/examples/CustomQR.ipynb create mode 100644 doc/source/examples/FairSVM_new.ipynb create mode 100644 doc/source/examples/GridSearchCV_SVM_losses.ipynb create mode 100644 doc/source/examples/GridSearchCV_reg_losses.ipynb create mode 100644 doc/source/examples/Huber_new.ipynb create mode 100644 doc/source/examples/MAE_new.ipynb create mode 100644 doc/source/examples/MSE_new.ipynb create mode 100644 doc/source/examples/MonotonicSVM.ipynb create mode 100644 doc/source/examples/QR_eps_new.ipynb create mode 100644 doc/source/examples/QR_new.ipynb create mode 100644 doc/source/examples/SVM_new.ipynb create mode 100644 doc/source/examples/SVR_new.ipynb create mode 100644 doc/source/examples/Smooth_SVM_new.ipynb create mode 100644 doc/source/examples/Squared_SVM_new.ipynb diff --git a/doc/source/examples/CustomQR.ipynb b/doc/source/examples/CustomQR.ipynb new file mode 100644 index 0000000..b8b5102 --- /dev/null +++ b/doc/source/examples/CustomQR.ipynb @@ -0,0 +1,1134 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "350gRKl8oZO8", + "outputId": "9c10c6b4-3bd4-4b8d-8fef-7a0e794a21ba" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ecam8nvm\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ecam8nvm\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=afb3663e756869bae441a557cc1076d200b509a9bcedfa3e89973806add3d6e3\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-ojkpm13e/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "MbOVhGJWC1bM" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "X = scaler.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "FGHO9F1QZK5M" + }, + "outputs": [], + "source": [ + "# Example: beta_0 + beta_1 >= 3\n", + "A = np.zeros((1, d))\n", + "A[0, 0] = 1\n", + "A[0, 1] = 1\n", + "b = np.array([-3.0])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jAQHQ9HRcbzd" + }, + "source": [ + "#QR as baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "F4kiv_VqJF6t", + "outputId": "1d12d12d-fee1-4273-8d89-2980b4a80d2d" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "## we first run a QR\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(\n", + " loss={'name': 'QR', 'qt': 0.5},\n", + " C=1.0,\n", + " max_iter=10000,\n", + " fit_intercept=False\n", + ")\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NHjMQ-vnclTL" + }, + "source": [ + "#Custom Constraint" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 114 + }, + "id": "beKf5mp-R3_5", + "outputId": "43fdfed2-38da-42a5-dcdc-88427e06a1fb" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n", + " 'b': array([-3.]), 'name': 'custom'}],\n", + " fit_intercept=False, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n",
+              "                                 'b': array([-3.]), 'name': 'custom'}],\n",
+              "                    fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "## solve custom via `plq_Ridge_Regressor` by adding `constraint`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "cclf = plq_Ridge_Regressor(\n", + " loss={'name': 'QR', 'qt': 0.5},\n", + " constraint=[{'name': 'custom', 'A': A, 'b': b}],\n", + " C=1.0,\n", + " max_iter=10000,\n", + " fit_intercept=False\n", + ")\n", + "cclf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zQOfvMjRR6Fn", + "outputId": "a7964e49-afd3-4f1a-d4b5-38a55b214dfc" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train MSE\n", + " QR 0.000097\n", + "Custom QR 1.352705\n", + "\n", + "coef_0 + coef_1 = 3.00000008, >= 3: True\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "## score\n", + "score = clf.predict(X)\n", + "cscore = cclf.predict(X)\n", + "\n", + "qr_perf = np.mean((y - score)**2)\n", + "cqr_perf = np.mean((y - cscore)**2)\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['QR', 'Custom QR'],\n", + " 'Train MSE': [qr_perf, cqr_perf]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))\n", + "#Print the results of custom constraint\n", + "lhs = cclf.coef_[0] + cclf.coef_[1]\n", + "print(f\"\\ncoef_0 + coef_1 = {lhs:.8f}, >= 3: {lhs >= 3}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 884 + }, + "id": "zWGh56JmZ00l", + "outputId": "9809836c-af7d-4461-fb3d-05bf25ae7908" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "qr_sample = clf.predict(X_sample)\n", + "cqr_sample = cclf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({\n", + " 'x0': X_sample[:, 0],\n", + " 'real_y': y_sample,\n", + " 'QR': qr_sample,\n", + " 'Custom_QR': cqr_sample\n", + "})\n", + "\n", + "df1 = df[['x0', 'real_y', 'QR']].melt(id_vars='x0')\n", + "sns.scatterplot(data=df1, x='x0', y='value', hue='variable').set_title(\"QR\")\n", + "plt.show()\n", + "df2 = df[['x0', 'real_y', 'Custom_QR']].melt(id_vars='x0')\n", + "sns.scatterplot(data=df2, x='x0', y='value', hue='variable').set_title(\"Custom QR\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/FairSVM_new.ipynb b/doc/source/examples/FairSVM_new.ipynb new file mode 100644 index 0000000..1e782f7 --- /dev/null +++ b/doc/source/examples/FairSVM_new.ipynb @@ -0,0 +1,1120 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CdpIoLwYNrOE", + "outputId": "4f08447f-8eac-4a9b-fab2-348e48c3f162" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-aslp0p5z\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-aslp0p5z\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e70f4bd1f1915f6a955fc096395a6757bc4c0b710df4f11b2be6f22239334ed7\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-5e872vry/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "FcaI-p84K6m4" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, n_redundant=2, random_state=42)\n", + "y = 2*y - 1\n", + "X = scaler.fit_transform(X)\n", + "\n", + "## we take the first column of X as sensitive features, and tol is 0.1\n", + "sen_idx = [0]\n", + "tol_sen = 0.1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "VEQKzCdrM3ii" + }, + "source": [ + "#SVM as baseline" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "uUMv2d0ZM1X5", + "outputId": "204172ec-5440-4945-a18e-caf1695b6ef0" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ], + "source": [ + "## we first run a SVM\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0, max_iter=50000)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4S9GFijHNPCC" + }, + "source": [ + "#FairSVM" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 172 + }, + "id": "F17oa5oUNGed", + "outputId": "5977c594-17c7-4be0-a558-cb998a249fc8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n", + " 'tol_sen': 0.1}],\n", + " loss={'name': 'svm'}, max_iter=50000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n",
+              "                                  'tol_sen': 0.1}],\n",
+              "                     loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve FairSVM via `plq_Ridge_Classifier` by adding `constraint`\n", + "fclf = plq_Ridge_Classifier(loss={'name': 'svm'},\n", + " constraint=[{'name': 'fair',\n", + " 'sen_idx': sen_idx,\n", + " 'tol_sen': tol_sen}],\n", + " C=1.0,\n", + " max_iter=50000)\n", + "fclf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4PsZ5ASPO2lN" + }, + "source": [ + "#Results" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WNhi1tI_NJc_", + "outputId": "b238f852-af11-49ed-d2c4-e3677e248a7c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train Performance Correlation with Sensitive Features\n", + " SVM 0.8927 2.417714\n", + "FairSVM 0.5278 0.100728\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "## score\n", + "X_sen = X[:, sen_idx]\n", + "score = clf.decision_function(X)\n", + "fscore = fclf.decision_function(X)\n", + "\n", + "svm_perf = len(y[score*y > 0])/n\n", + "fsvm_perf = len(y[fscore*y > 0])/n\n", + "\n", + "svm_corr = score.dot(X_sen) / n\n", + "fsvm_corr = fscore.dot(X_sen) / n\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['SVM', 'FairSVM'],\n", + " 'Train Performance': [svm_perf, fsvm_perf],\n", + " 'Correlation with Sensitive Features': [svm_corr[0], fsvm_corr[0]]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 926 + }, + "id": "rKNP993vNMAo", + "outputId": "9df96109-c2d8-495d-a889-ff3cc61613f0" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "df = pd.DataFrame({'score': score, 'fscore': fscore, 'y': y})\n", + "\n", + "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", + "plt.show()\n", + "sns.histplot(df, x=\"fscore\", hue=\"y\").set_title(\"FairSVM\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/GridSearchCV_SVM_losses.ipynb b/doc/source/examples/GridSearchCV_SVM_losses.ipynb new file mode 100644 index 0000000..a84611e --- /dev/null +++ b/doc/source/examples/GridSearchCV_SVM_losses.ipynb @@ -0,0 +1,731 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WaRThRkBIA5j", + "outputId": "c09f7839-f24b-449e-be17-70e66396bafd" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-viuqut75\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-viuqut75\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=5c5be6969b966988219f8979e617a21f59ae88278f8d50cc95f710a096c4c4b4\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-cr7ssxvm/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "O76jxeIHIALp" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "IDityv5qCrQv" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 749 + }, + "id": "JKowJ-3KHCrF", + "outputId": "5e320f7f-0b17-427d-c5f3-7a8f5264c6d6" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf',\n", + " plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n", + " param_grid={'clf__C': [0.1, 1.0, 10.0],\n", + " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n", + " {'name': 'squared SVM'}]})" + ], + "text/html": [ + "
GridSearchCV(cv=5,\n",
+              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                                       ('clf',\n",
+              "                                        plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n",
+              "             param_grid={'clf__C': [0.1, 1.0, 10.0],\n",
+              "                         'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n",
+              "                                       {'name': 'squared SVM'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## compare SVM losses via GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Classifier\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))\n", + "])\n", + "\n", + "# Define the parameter grid to search\n", + "param_grid = {\n", + " 'clf__C': [0.1, 1.0, 10.0],\n", + " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'}, {'name': 'squared SVM'}]\n", + "}\n", + "\n", + "# Create the GridSearchCV object\n", + "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", + "grid_search.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C5_7b71QM9XK", + "outputId": "7258d1c2-318d-4319-eca5-7b6d2f4522a8" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Overall Best Params: {'clf__C': 0.1, 'clf__loss': {'name': 'svm'}}\n", + "Overall Best Score: 0.8922\n" + ] + } + ], + "source": [ + "# Print the best loss function and score\n", + "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", + "print(f\"Overall Best Score: {grid_search.best_score_:.4f}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TxnC0FjziZvD" + }, + "source": [ + "#Compare SVM & Smooth SVM & Squared SVM" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "eiqipAokiYf5", + "outputId": "5b4db390-faaa-445c-997a-e17450e6b538" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Loss Best C CV Score\n", + " svm 0.1 0.8922\n", + " sSVM 0.1 0.8920\n", + "squared SVM 0.1 0.8913\n" + ] + } + ], + "source": [ + "## print best results per loss\n", + "import pandas as pd\n", + "df = pd.DataFrame(grid_search.cv_results_)\n", + "df['Loss'] = df['param_clf__loss'].apply(lambda x: x['name'])\n", + "df = df.sort_values('mean_test_score', ascending=False)\n", + "best = df.drop_duplicates(subset=['Loss'])\n", + "table = best[['Loss', 'param_clf__C', 'mean_test_score']].rename(\n", + " columns={'param_clf__C': 'Best C', 'mean_test_score': 'CV Score'}\n", + ")\n", + "\n", + "print(table.to_string(index=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 341 + }, + "id": "27SVRgNeIp7G", + "outputId": "f3506667-d777-470f-af04-7ed54f2ed128" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot score distributions for best models\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "y_label = 2*y - 1\n", + "for i in range(len(best)):\n", + " loss = best['Loss'].iloc[i]\n", + " c = best['param_clf__C'].iloc[i]\n", + "\n", + " pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': loss}, C=c))\n", + " ])\n", + " pipe.fit(X, y)\n", + "\n", + " score = pipe.decision_function(X)\n", + " df = pd.DataFrame({'score': score, 'y': y_label})\n", + " sns.histplot(df, x=\"score\", hue=\"y\", ax=axes[i]).set_title(loss)\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/GridSearchCV_reg_losses.ipynb b/doc/source/examples/GridSearchCV_reg_losses.ipynb new file mode 100644 index 0000000..7663f41 --- /dev/null +++ b/doc/source/examples/GridSearchCV_reg_losses.ipynb @@ -0,0 +1,727 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "O_SFIipUcSyD", + "outputId": "77c9f603-de96-4c8f-9ca8-727c475e211c" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-qbh74ba5\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-qbh74ba5\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=743e41d2730cd6d801ec5c3acbc3d6ace163b9c318a9ba67a4592dec9587353d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-5c6fypql/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "\n", + "X, y = make_regression(n_samples=10000, n_features=5, noise=30.0, random_state=42)\n", + "y = y / y.std()\n", + "y[-40:] += 20" + ], + "metadata": { + "id": "mLPT_rZskyrr" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## compare Huber, MAE and MSE via GridSearchCV\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Regressor\n", + "from sklearn.model_selection import GridSearchCV\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mse'}))\n", + "])\n", + "\n", + "# Define the parameter grid to search\n", + "param_grid = {\n", + " 'reg__C': [0.1, 1.0, 10.0],\n", + " 'reg__loss': [{'name': 'huber', 'tau': 1.0}, {'name': 'mae'}, {'name': 'mse'}]\n", + "}\n", + "\n", + "# Create the GridSearchCV object\n", + "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", + "grid_search.fit(X, y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 898 + }, + "id": "cd-YVK8UpDD0", + "outputId": "883eb665-7c89-4910-f2f1-7c03335725b0" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n", + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "GridSearchCV(cv=5,\n", + " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n", + " param_grid={'reg__C': [0.1, 1.0, 10.0],\n", + " 'reg__loss': [{'name': 'huber', 'tau': 1.0},\n", + " {'name': 'mae'}, {'name': 'mse'}]})" + ], + "text/html": [ + "
GridSearchCV(cv=5,\n",
+              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                                       ('reg',\n",
+              "                                        plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n",
+              "             param_grid={'reg__C': [0.1, 1.0, 10.0],\n",
+              "                         'reg__loss': [{'name': 'huber', 'tau': 1.0},\n",
+              "                                       {'name': 'mae'}, {'name': 'mse'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print the best loss function and score\n", + "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", + "print(f\"Overall Best Score: {grid_search.best_score_:.5f}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cHQEgKt8pMKr", + "outputId": "e5c4d1ea-241b-4a99-a921-71e23e3f0fb9" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Overall Best Params: {'reg__C': 1.0, 'reg__loss': {'name': 'mae'}}\n", + "Overall Best Score: 0.77874\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Print best results per loss\n", + "import pandas as pd\n", + "df = pd.DataFrame(grid_search.cv_results_)\n", + "df['Loss'] = df['param_reg__loss'].apply(lambda x: x['name'])\n", + "df = df.sort_values('mean_test_score', ascending=False)\n", + "best = df.drop_duplicates(subset=['Loss'])\n", + "table = best[['Loss', 'param_reg__C', 'mean_test_score']].rename(\n", + " columns={'param_reg__C': 'Best C', 'mean_test_score': 'CV Score'}\n", + ")\n", + "\n", + "print(table.to_string(index=False))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IgxOOM3_pIwW", + "outputId": "23690687-ec0f-456b-f5d0-57431d715d42" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Loss Best C CV Score\n", + " mae 1.0 0.778740\n", + "huber 0.1 0.778691\n", + " mse 0.1 0.769240\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "\n", + "for i in range(len(best)):\n", + " loss = best['Loss'].iloc[i]\n", + " c = best['param_reg__C'].iloc[i]\n", + "\n", + " pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': loss}, C=c))\n", + " ])\n", + " pipe.fit(X, y)\n", + "\n", + " pred_y = pipe.predict(X_sample)\n", + " df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'pred': pred_y})\n", + " df = df.melt(id_vars='x0')\n", + "\n", + " sns.scatterplot(data=df, x='x0', y='value', hue='variable', ax=axes[i], alpha=0.8).set_title(f\"{loss} (C={c})\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 378 + }, + "id": "SrjMX-b9pVus", + "outputId": "9326400e-29fd-4f4f-efb4-6288377b4d75" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/doc/source/examples/Huber_new.ipynb b/doc/source/examples/Huber_new.ipynb new file mode 100644 index 0000000..f611a57 --- /dev/null +++ b/doc/source/examples/Huber_new.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8MeXCyHX0hSB", + "outputId": "93160eee-b883-4588-d043-05a97c4e3ee2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ir2yao1k\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ir2yao1k\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=4819e8f088a3974b692227a2d9811df20e294ee6ba9f04586146333463688d7d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-qqgkwxb1/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ], + "metadata": { + "id": "l1yoptXqUxlc" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "96X3ttm4Em6O" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "np.random.seed(42)\n", + "scaler_huber = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_huber.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "vSCgN97C0ei6", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "outputId": "a95d354f-4c50-4b23-d4f8-b12c481c1853" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve Huber Regression with different `tau` via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf_tau01 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001)\n", + "clf_tau01.fit(X=X, y=y)\n", + "clf_tau5 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001)\n", + "clf_tau5.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "-lHj744W0gFS", + "outputId": "b6b978ad-e980-4fee-f4e5-5863f17bbb0e" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot Huber Regression results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "tau01_sample = clf_tau01.predict(X_sample)\n", + "tau5_sample = clf_tau5.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample,'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "l4oYORhVDgfa" + }, + "outputs": [], + "source": [ + "#With pipeline" + ] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ], + "metadata": { + "id": "HsIykQjgXxJ8" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "XgGUDZnNEDnU" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "dsos8G2nEQqX", + "outputId": "6121b652-a083-4d52-d569-bcf0b1cca69f" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(C=0.001,\n", + " loss={'name': 'huber', 'tau': 5.0}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(C=0.001,\n",
+              "                                     loss={'name': 'huber', 'tau': 5.0}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve Huber Regression with different 'tau' via 'plq_Ridge_Regressor'\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe_tau01 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001))\n", + "])\n", + "pipe_tau01.fit(X, y)\n", + "\n", + "pipe_tau5 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001))\n", + "])\n", + "pipe_tau5.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 424 + }, + "id": "jSJn1AaSEVfg", + "outputId": "8f3ecb7e-a79f-46a3-d794-103b62742843" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot Huber Regression results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "tau01_sample = pipe_tau01.predict(X_sample)\n", + "tau5_sample = pipe_tau5.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/MAE_new.ipynb b/doc/source/examples/MAE_new.ipynb new file mode 100644 index 0000000..c437f51 --- /dev/null +++ b/doc/source/examples/MAE_new.ipynb @@ -0,0 +1,1135 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D62H7LVT-hpG", + "outputId": "ed81047f-8751-4916-e05f-c4714b78af83" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-hxsznegq\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-hxsznegq\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=fa1c481dc179bf912d9670fdd130ef2b2453c3c7a9fa06f72250a49b917d4a98\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-4_bmvjlq/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "tHPsW2Eq6lN9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "M8dZ_mRK9YDK" + }, + "outputs": [], + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_mae = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_mae.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 137 + }, + "id": "9JP5VwfV9aCY", + "outputId": "781ff38e-6850-4617-db7c-7e809c111007" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'name': 'mae'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'name': 'mae'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve MAE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "JC3sBscd9bWU", + "outputId": "31665e66-9570-4c7f-e6b4-9e6ea3a86c89" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot MAE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mae_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "5IX8zjUk6yJF" + }, + "outputs": [], + "source": [ + "#With pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "Y-nBBodB6xEB" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "wbCrxMoaD6zd" + }, + "outputs": [], + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 213 + }, + "id": "W8QLXxxOD8AO", + "outputId": "911ca74c-24c1-418c-b74f-6b488c3db343" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve MAE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "f-I1H7joD9Mm", + "outputId": "02983dca-6556-499c-f6a8-07bb9ddbada0" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "## plot MAE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mae_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/MSE_new.ipynb b/doc/source/examples/MSE_new.ipynb new file mode 100644 index 0000000..c1a9527 --- /dev/null +++ b/doc/source/examples/MSE_new.ipynb @@ -0,0 +1,1119 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cY_04uxlIp6C", + "outputId": "5beb3838-f250-4576-9c68-125d40d4056d" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-jyd_21no\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-jyd_21no\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e40a18d1e851c1aebab381bc6b01312b662c6800df1685e03ad8f6a9d4dfc433\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-84yy9nhd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "6A65T6tzF3Lj" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_mse = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", + "X = scaler_mse.fit_transform(X)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "iH3AockWGKbl" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve MSE Regression via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "id": "1OGXUMlKGL3U", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "outputId": "ff13a10a-9fa4-496f-fd98-a3b1341d3094" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'name': 'mse'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'name': 'mse'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot MSE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mse_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "id": "EPp4wl_8GNA7", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "outputId": "4b063c03-568c-44c0-9222-804217bce4b2" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#With Pipeline" + ], + "metadata": { + "id": "unUUe9ZEASBd" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression" + ], + "metadata": { + "id": "Vb4eJISeAU5O" + }, + "execution_count": 8, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "Uy9loVbWCw8A" + }, + "execution_count": 9, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve MSE Regression via `plq_Ridge_Regressor`\n", + "from sklearn.pipeline import Pipeline\n", + "from sklearn.preprocessing import StandardScaler\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0))\n", + "])\n", + "pipe.fit(X, y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "3oUouDgWC3ao", + "outputId": "78a04eca-6d3e-4eda-bfc2-7485e63544e8" + }, + "execution_count": 10, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot MSE results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "mse_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "JjNnypf6DI9L", + "outputId": "f8788e70-6c62-4e89-ad2e-5b47dcbad1b0" + }, + "execution_count": 11, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/doc/source/examples/MonotonicSVM.ipynb b/doc/source/examples/MonotonicSVM.ipynb new file mode 100644 index 0000000..bd4a1aa --- /dev/null +++ b/doc/source/examples/MonotonicSVM.ipynb @@ -0,0 +1,1118 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g0aAqkkRKc6z", + "outputId": "06c1fb56-1382-4149-dde3-b26e56885079" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2rmdz0d2\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2rmdz0d2\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=38277498b08288819d7a48307b30d8730b6eb14a44a4d7599dce3f918735056d\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-kmjsudwd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "4ibK-1gsR0ZB" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, n_redundant=0, random_state=42)\n", + "y = 2*y - 1\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "markdown", + "source": [ + "#SVM as baseline" + ], + "metadata": { + "id": "Oak-k1Ps9hDS" + } + }, + { + "cell_type": "code", + "source": [ + "## we first run a SVM\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=0.001, max_iter=10000)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "Uk31Pe_cg702", + "outputId": "b0a34980-ffd2-44a1-dcd6-d7232221510e" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Monotonic constraint" + ], + "metadata": { + "id": "OU3yWxlR9d29" + } + }, + { + "cell_type": "code", + "source": [ + "## solve SVM with Monotonicity Constraint via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Classifier\n", + "mclf = plq_Ridge_Classifier(\n", + " loss={'name': 'svm'},\n", + " constraint = [{'name': 'monotonic', 'decreasing': True}],\n", + " C=0.001,\n", + " max_iter=10000\n", + ")\n", + "mclf.fit(X=X, y=y)" + ], + "metadata": { + "id": "APrF6OYJl1_t", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 114 + }, + "outputId": "c90e1964-a77b-4d24-a0e6-0f41a06a92d9" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(C=0.001,\n", + " constraint=[{'decreasing': True, 'name': 'monotonic'}],\n", + " loss={'name': 'svm'}, max_iter=10000)" + ], + "text/html": [ + "
plq_Ridge_Classifier(C=0.001,\n",
+              "                     constraint=[{'decreasing': True, 'name': 'monotonic'}],\n",
+              "                     loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#Results" + ], + "metadata": { + "id": "GbDGb79w9aOh" + } + }, + { + "cell_type": "code", + "source": [ + "import pandas as pd\n", + "##score\n", + "score = clf.decision_function(X)\n", + "mscore = mclf.decision_function(X)\n", + "\n", + "svm_perf = len(y[score*y > 0])/ n\n", + "msvm_perf = len(y[mscore*y > 0])/ n\n", + "\n", + "# Create a pandas DataFrame to store the results\n", + "results = pd.DataFrame({\n", + " 'Model': ['SVM', 'MonotonicSVM'],\n", + " 'Train Performance': [svm_perf, msvm_perf]\n", + "})\n", + "\n", + "# Print the results as a table\n", + "print(results.to_string(index=False))\n", + "\n", + "#Print the results of monotonic constraint\n", + "print(\"\\nCoefficients (no constraint):\")\n", + "print(clf.coef_)\n", + "print(\"\\nCoefficients (monotonic increasing):\")\n", + "print(mclf.coef_)\n", + "print(\"Monotonic descreasing satisfied:\",\n", + " np.all(mclf.coef_[:-1] >= mclf.coef_[1:]))" + ], + "metadata": { + "id": "fDmbka9Wx-jd", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "4b2f868f-fdf0-45d0-de3a-0c62b1116f5d" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + " Model Train Performance\n", + " SVM 0.8870\n", + "MonotonicSVM 0.7332\n", + "\n", + "Coefficients (no constraint):\n", + "[-0.00464203 1.30915325 0.11882663 -0.02067285 0.00381067]\n", + "\n", + "Coefficients (monotonic increasing):\n", + "[ 0.6899007 0.68988743 0.05962067 -0.01259596 -0.01275567]\n", + "Monotonic descreasing satisfied: True\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "df = pd.DataFrame({'score': score, 'mscore': mscore, 'y': y})\n", + "\n", + "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", + "plt.show()\n", + "sns.histplot(df, x=\"mscore\", hue=\"y\").set_title(\"Monotonic SVM\")\n", + "plt.show()" + ], + "metadata": { + "id": "GmOPIjrhyAZ3", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 885 + }, + "outputId": "c70e7404-5c70-49a2-b5d0-dde4a5dbcc99" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/doc/source/examples/QR_eps_new.ipynb b/doc/source/examples/QR_eps_new.ipynb new file mode 100644 index 0000000..6f223d2 --- /dev/null +++ b/doc/source/examples/QR_eps_new.ipynb @@ -0,0 +1,1111 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "id": "OYf6ieCxG5Is", + "outputId": "3c5d6592-1e5c-4dd3-9f62-0312c6dbb623", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-mha0b2ca\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-mha0b2ca\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=d53fa588ab159c0770b7caee4454e2c23159fd702245525d843f6a754cc8d391\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-edl2raxl/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate Data\n", + "import numpy as np\n", + "\n", + "np.random.seed(42)\n", + "n = 2000\n", + "x = np.random.randn(n)\n", + "noise = np.random.randn(n) * (0.3 + 0.5 * np.abs(x))\n", + "y = 2 * x + noise\n", + "X = x.reshape(-1, 1)" + ], + "metadata": { + "id": "54zIQq6-Bqm8" + }, + "execution_count": 2, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "from rehline import plq_Ridge_Regressor\n", + "\n", + "# Check Loss with epsilon-tolerance\n", + "clf = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.9, 'epsilon': 0.1}, C=10.0/n)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "id": "LpdGRLz3CKFM", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 97 + }, + "outputId": "45d86e36-a471-4e23-dc0b-13fc0a3ca56c" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.005,\n", + " loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.005,\n",
+              "                    loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot Check Loss with epsilon results\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "# Parameters\n", + "epsilon = 0.3\n", + "\n", + "# Fit Check Loss with epsilon (two quantiles)\n", + "clf05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", + "clf05.fit(X=X, y=y)\n", + "\n", + "clf95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", + "clf95.fit(X=X, y=y)\n", + "\n", + "# Plot\n", + "n_sample = 100\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = clf05.predict(X_sample)\n", + "q95_sample = clf95.predict(X_sample)\n", + "\n", + "# sort by x0\n", + "sort_idx = np.argsort(X_sample[:,0])\n", + "x0_sorted = X_sample[sort_idx, 0]\n", + "y_sorted = y_sample[sort_idx]\n", + "q05_sorted = q05_sample[sort_idx]\n", + "q95_sorted = q95_sample[sort_idx]\n", + "\n", + "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", + "plt.plot(x0_sorted, q05_sorted, 'orange', linewidth=2, label='q05')\n", + "plt.plot(x0_sorted, q95_sorted, 'green', linewidth=2, label='q95')\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "id": "fdFQpu9gCOlT", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 427 + }, + "outputId": "2af32392-8aa2-4a3b-efba-448086b57091" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "## Comparison: Original QR vs Check Loss with epsilon\n", + "import numpy as np\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "# Parameters\n", + "epsilon = 0.2\n", + "\n", + "# Fit original QR\n", + "clf_qr05 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", + "clf_qr05.fit(X=X, y=y)\n", + "\n", + "clf_qr95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", + "clf_qr95.fit(X=X, y=y)\n", + "\n", + "# Fit Check Loss with epsilon\n", + "clf_eps05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", + "clf_eps05.fit(X=X, y=y)\n", + "\n", + "clf_eps95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", + "clf_eps95.fit(X=X, y=y)" + ], + "metadata": { + "id": "ElZCOJ2lB0mP", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 97 + }, + "outputId": "8d47c878-bddf-49a8-937e-11bbb0a2cee0" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(C=0.005,\n", + " loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})" + ], + "text/html": [ + "
plq_Ridge_Regressor(C=0.005,\n",
+              "                    loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# Plot\n", + "n_sample = 300\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "\n", + "sort_idx = np.argsort(X_sample[:,0])\n", + "x0_sorted = X_sample[sort_idx, 0]\n", + "y_sorted = y_sample[sort_idx]\n", + "\n", + "qr05_sorted = clf_qr05.predict(X_sample)[sort_idx]\n", + "qr95_sorted = clf_qr95.predict(X_sample)[sort_idx]\n", + "eps05_sorted = clf_eps05.predict(X_sample)[sort_idx]\n", + "eps95_sorted = clf_eps95.predict(X_sample)[sort_idx]\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", + "plt.plot(x0_sorted, qr05_sorted, 'orange', linewidth=2, label='QR_05')\n", + "plt.plot(x0_sorted, qr95_sorted, 'orange', linewidth=2, linestyle='--', label='QR_95')\n", + "plt.plot(x0_sorted, eps05_sorted, 'green', linewidth=2, label='QR_eps_05')\n", + "plt.plot(x0_sorted, eps95_sorted, 'green', linewidth=2, linestyle='--', label='QR_eps_95')\n", + "plt.legend()\n", + "plt.title(f'Original QR vs Check Loss with epsilon (eps={epsilon})')\n", + "plt.show()" + ], + "metadata": { + "id": "Q3fIo_UwC7yN", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 364 + }, + "outputId": "a9e1fcb4-81be-47a3-c28a-be5a3ac8c575" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/doc/source/examples/QR_new.ipynb b/doc/source/examples/QR_new.ipynb new file mode 100644 index 0000000..737f8d9 --- /dev/null +++ b/doc/source/examples/QR_new.ipynb @@ -0,0 +1,1096 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rTzmChto1ltC", + "outputId": "e72f4d4a-58e2-4d45-d134-4633ae86ee38" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting rehline\n", + " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", + "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: rehline\n", + "Successfully installed rehline-0.1.1\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BWLs6_gP1YHE" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "X = scaler.fit_transform(X)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "L8KI3Odl4l_Z", + "outputId": "d9b79b7c-7871-4510-bf43-dfba92823c7f" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve QR with different `qt` via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf5 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", + "clf5.fit(X=X, y=y)\n", + "\n", + "clf95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", + "clf95.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "WR-5hLZe4oEE", + "outputId": "df6aa0ca-eba6-4011-b1e9-c85abaf06cfa" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## plot QR results\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = clf5.predict(X_sample)\n", + "q95_sample = clf95.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "eezf3egK8S32" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", + "y = y / y.std()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "t99I5I5E8s0S", + "outputId": "63b686c2-40ec-450e-b833-440f72c82aac" + }, + "outputs": [ + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(C=0.001,\n",
+              "                                     loss={'name': 'QR', 'qt': 0.95}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(C=0.001,\n", + " loss={'name': 'QR', 'qt': 0.95}))])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve QR with different `qt` via `plq_Ridge_Regressor` with Pipeline\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe5 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n))\n", + "])\n", + "pipe5.fit(X=X, y=y)\n", + "\n", + "pipe95 = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n))\n", + "])\n", + "pipe95.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "D0n0ZqKC8uoj", + "outputId": "f9280f7b-77a7-4030-8b80-840d527ec240" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "## plot QR results\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 50\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "q05_sample = pipe5.predict(X_sample)\n", + "q95_sample = pipe95.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/doc/source/examples/SVM_new.ipynb b/doc/source/examples/SVM_new.ipynb new file mode 100644 index 0000000..12ca4ac --- /dev/null +++ b/doc/source/examples/SVM_new.ipynb @@ -0,0 +1,1111 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "OW25uH0Trqxn" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p_7oxpX8Nqqd", + "outputId": "2f3541b7-0b9b-4aaa-fb6c-ff47e84eccf1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting rehline\n", + " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", + "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: rehline\n", + "Successfully installed rehline-0.1.1\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "NVVj0auob6c6" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 137 + }, + "id": "WpgI_saqFj-r", + "outputId": "a5baf759-778c-47eb-ef92-ad95398e2646" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'svm'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'svm'})" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 469 + }, + "id": "x2PIL0esFrQ6", + "outputId": "163ac4e8-51e7-4b63-e744-874ee510a087" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "WDsb-OMtFwz-" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "_MKFw7E4pF1b" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 213 + }, + "id": "VHj2Y6zOLb1M", + "outputId": "4f030161-735d-49c5-a4d0-1dba300bbaa2" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 426 + }, + "id": "ogQFzB34LdvI", + "outputId": "88c2f1a5-fbe5-42d5-9166-e7aac31ec80a" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/doc/source/examples/SVR_new.ipynb b/doc/source/examples/SVR_new.ipynb new file mode 100644 index 0000000..74e97e8 --- /dev/null +++ b/doc/source/examples/SVR_new.ipynb @@ -0,0 +1,1122 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NjjjqDBE4pkX", + "outputId": "de7ec7ea-4d4e-4bd0-93a8-45ce9586dd67" + }, + "execution_count": 1, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-09286p2r\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-09286p2r\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=9bb240a05e1f7c3d447e7374f4286a1cb179ec22a749e284dced975b93ff3b27\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-ullopi_j/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "sIbawm0_3iq9" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler" + ] + }, + { + "cell_type": "code", + "source": [ + "# Simulate data\n", + "np.random.seed(42)\n", + "scaler_svr = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "X = scaler_svr.fit_transform(X)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "eq-Bqnt14Xcf" + }, + "execution_count": 3, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve SVR via `plq_Ridge_Regressor`\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "clf = plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "HgExVVV54a58", + "outputId": "35f56019-877c-49a9-a72e-9c135a136cfc" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})" + ], + "text/html": [ + "
plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot SVR results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "svr_sample = clf.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "URF-gXRN45jb", + "outputId": "4c0a1b1f-3189-4972-a4fd-161c700bffa6" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "#With pipeline" + ], + "metadata": { + "id": "gVGSI7iz5RLm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import warnings\n", + "from sklearn.datasets import make_regression\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline" + ], + "metadata": { + "id": "3-rs8zHc3vVb" + }, + "execution_count": 6, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "#Simulate data\n", + "np.random.seed(42)\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", + "y = y / y.std()" + ], + "metadata": { + "id": "6RXuMsWQ5aNh" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "## solve SVR via `plq_Ridge_Regressor` with Pipeline\n", + "from rehline import plq_Ridge_Regressor\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('reg', plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "Iq5LJkIj5b49", + "outputId": "da81add6-dc6c-4e06-b7f0-ed386812737f" + }, + "execution_count": 8, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('reg',\n", + " plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('reg',\n",
+              "                 plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "## plot SVR results\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "\n", + "n_sample = 200\n", + "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", + "svr_sample = pipe.predict(X_sample)\n", + "\n", + "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", + "df = df.melt(id_vars='x0')\n", + "\n", + "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 433 + }, + "id": "tLkX5wvV5qPJ", + "outputId": "47af9451-b318-4cfd-a4c8-3e432899932e" + }, + "execution_count": 9, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/doc/source/examples/Smooth_SVM_new.ipynb b/doc/source/examples/Smooth_SVM_new.ipynb new file mode 100644 index 0000000..9373488 --- /dev/null +++ b/doc/source/examples/Smooth_SVM_new.ipynb @@ -0,0 +1,1102 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "lRz5G7RAaFtj" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-GNV_K9al_tQ", + "outputId": "9cae07ee-03d0-4ede-848d-d3201cbcaca2" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-al6i7zz6\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-al6i7zz6\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=bc61970eef67d92d0256e4429ad1bbd576c2e0ed03185a2e257b2abec3348aa1\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-egsuyb_8/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "ZawpNRuQR9Uu" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "lskTdleDZwpa", + "outputId": "b3f748ec-1837-43ae-fa9d-cb1f90e6a58e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'sSVM'})" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'sSVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "## solve Smooth SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 429 + }, + "id": "g5DCBXT5Z5uR", + "outputId": "9b94bd5a-511d-4a08-e5c5-a18dd1be2d71" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "sZPCmCtOaXY8" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "MCEXWUchaaP_" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "PwMysLRWaiv_", + "outputId": "9e65777b-3a1b-478d-beb8-02a2d81b8a1e" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0))\n", + "])\n", + "pipe.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 429 + }, + "id": "ZMofqZ_zakNc", + "outputId": "357b460b-59ed-489b-85bb-14abf025c4b7" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/examples/Squared_SVM_new.ipynb b/doc/source/examples/Squared_SVM_new.ipynb new file mode 100644 index 0000000..a7648b1 --- /dev/null +++ b/doc/source/examples/Squared_SVM_new.ipynb @@ -0,0 +1,1105 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "QvfFVk7WRUAb" + }, + "outputs": [], + "source": [ + "## set up plotting style\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "custom_palette = ['#FFE4E1', '#3D325C']\n", + "sns.set_palette(custom_palette)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lrklwkcyDvTw", + "outputId": "5b429a02-890e-4cd2-8bd7-099fb6790a78" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting git+https://github.com/softmin/ReHLine-python.git\n", + " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2nf2n7rx\n", + " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2nf2n7rx\n", + " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", + " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", + " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", + " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", + "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", + "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", + "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", + "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", + "Building wheels for collected packages: rehline\n", + " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", + " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=566656c57e2918bd1d23613f29cfa356fec6e937d1ec37f8bb98febb77371d0f\n", + " Stored in directory: /tmp/pip-ephem-wheel-cache-2u6y9ak2/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", + "Successfully built rehline\n", + "Installing collected packages: rehline\n", + "Successfully installed rehline-0.1.2\n" + ] + } + ], + "source": [ + "pip install git+https://github.com/softmin/ReHLine-python.git" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "w08Rlr8La4Mv" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "import numpy as np\n", + "\n", + "scaler = StandardScaler()\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", + "X = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 80 + }, + "id": "MlOfn-UmRCuN", + "outputId": "06ee1d8d-8e54-4f32-e413-b0c17c380fdc" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "plq_Ridge_Classifier(loss={'name': 'squared SVM'})" + ], + "text/html": [ + "
plq_Ridge_Classifier(loss={'name': 'squared SVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 4 + } + ], + "source": [ + "## solve SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "clf = plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0)\n", + "clf.fit(X=X, y=y)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 432 + }, + "id": "mcbLDBYGRM4W", + "outputId": "eee04718-16ad-4ce5-e9e3-540d9c4bdb23" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = clf.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "u1wBO4l9zL1z" + }, + "outputs": [], + "source": [ + "#With Pipeline" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "1XPWQmcpSRYy" + }, + "outputs": [], + "source": [ + "## simulate data\n", + "from sklearn.datasets import make_classification\n", + "from sklearn.preprocessing import StandardScaler\n", + "from sklearn.pipeline import Pipeline\n", + "import numpy as np\n", + "\n", + "n, d = 10000, 5\n", + "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 155 + }, + "id": "Hu-ipK_n1_Br", + "outputId": "d119f0a0-fde5-45a1-e0c1-f1933eac9f37" + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Pipeline(steps=[('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])" + ], + "text/html": [ + "
Pipeline(steps=[('scaler', StandardScaler()),\n",
+              "                ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "## solve Squared SVM via `plq_Ridge_Classifier`\n", + "from rehline import plq_Ridge_Classifier\n", + "\n", + "pipe = Pipeline([\n", + " ('scaler', StandardScaler()),\n", + " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0))\n", + "])\n", + "pipe.fit(X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 432 + }, + "id": "WXuTX7ok2Drw", + "outputId": "1443d2b1-db05-4d49-8f6e-e1ff49127827" + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGzCAYAAADJ3dZzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAL9lJREFUeJzt3X9cVHW+x/E3EOJPYFWYUQO0NBV/UWo61+qKspK53Vzp53oNzWzjoltyt8wyNSttrU3vEmrbLa3dfLi3tt+Whphaima0tvnz5q5daHCGMQP8kYDD3D9a5hGrAwrDnJnD6/l4zOPRnO935nxOU/nu+/2e7wnzeDweAQAAmFS40QUAAAC0JMIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwtUuMPPnChQv12GOP1TvWt29fHTx4UJJ05swZ/ed//qfWrVunqqoqpaena8WKFbJYLN7+xcXFysrK0kcffaSOHTsqMzNTS5Ys0SWXXPil1dbWqrS0VJ06dVJYWJh/Lg4AALQoj8ejEydOqHv37goP9z1+Y2jYkaQBAwZo06ZN3vc/DimzZ8/W+vXr9dprrykmJkYzZ87UpEmTtH37dkmS2+3WhAkTZLVatWPHDh09elR33nmnIiMjtXjx4guuobS0VAkJCf67KAAAEDAlJSW69NJLfbaHGfkg0IULF+qtt97Snj17zmmrqKhQXFyc1q5dq5tvvlmSdPDgQfXv31+FhYUaOXKkPvjgA/3sZz9TaWmpd7Rn1apVmjNnjlwul9q0aXNBdVRUVCg2NlYlJSWKjo722/UBAICWU1lZqYSEBJWXlysmJsZnP8NHdr766it1795dbdu2lc1m05IlS5SYmKiioiLV1NQoLS3N27dfv35KTEz0hp3CwkINGjSo3rRWenq6srKytG/fPl155ZXnPWdVVZWqqqq870+cOCFJio6OJuwAABBiGluCYugC5REjRmjNmjXasGGDVq5cqSNHjujaa6/ViRMn5HA41KZNG8XGxtb7jMVikcPhkCQ5HI56Qaeuva7NlyVLligmJsb7YgoLAADzMnRkZ/z48d6/Hjx4sEaMGKGkpCT9z//8j9q1a9di5507d65ycnK87+uGwQAAgPkE1a3nsbGxuuKKK3T48GFZrVZVV1ervLy8Xh+n0ymr1SpJslqtcjqd57TXtfkSFRXlnbJi6goAAHMzfM3Oj508eVJ/+9vfNGXKFA0dOlSRkZEqKChQRkaGJOnQoUMqLi6WzWaTJNlsNj355JMqKytTfHy8JCk/P1/R0dFKTk427DoAAGgJbrdbNTU1RpcRMJGRkYqIiGj29xgadn7961/rxhtvVFJSkkpLS7VgwQJFRETojjvuUExMjKZPn66cnBx17txZ0dHRmjVrlmw2m0aOHClJGjdunJKTkzVlyhQtXbpUDodD8+bNU3Z2tqKiooy8NAAA/Mbj8cjhcJwz29EaxMbGymq1NmsfPEPDzjfffKM77rhD3377reLi4nTNNddo586diouLkyQtW7ZM4eHhysjIqLepYJ2IiAi99957ysrKks1mU4cOHZSZmalFixYZdUkAAPhdXdCJj49X+/btW8UGuB6PR6dPn1ZZWZkkqVu3bk3+LkP32QkWlZWViomJUUVFBet3AABBxe1263//938VHx+vLl26GF1OwH377bcqKyvTFVdccc6U1oX++R1UC5QBAEB9dWt02rdvb3Alxqi77uasVSLsAAAQAlrD1NX5+OO6CTsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAKCeV155RV26dFFVVVW94xMnTtSUKVMMqqrpCDsAAKCeW265RW63W++88473WFlZmdavX6+77rrLwMqaJqiejQXA/Makpsrlcvlsj4uL0+aPPgpgRQD+Wbt27fSLX/xCq1ev1i233CJJ+uMf/6jExESNHj3a2OKagLADIKBcLpd2bdros31EWnoAqwHgy4wZMzR8+HDZ7Xb16NFDa9as0dSpU0Nyvx/CDgAAOMeVV16pIUOG6JVXXtG4ceO0b98+rV+/3uiymoSwAwAAzuvuu+/W8uXLZbfblZaWpoSEBKNLahIWKAMAgPP6xS9+oW+++UYvvPBCSC5MrkPYAQAA5xUTE6OMjAx17NhREydONLqcJiPsAAAAn+x2uyZPnqyoqCijS2ky1uwAAIBzfPfdd9qyZYu2bNmiFStWGF1OsxB2AADAOa688kp99913+s1vfqO+ffsaXU6zEHYAAMA5vv76a6NL8BvW7AAAAFMj7AAAAFMj7AAAAFMj7AAAAFNjgTKAoGK32zVo4ECf7TwVHcDFIuwACCoeTy1PRQfgV4QdAABCVHFxsY4dOxaQc3Xt2lWJiYkBOZe/EXYAAAhBxcXF6t+/v06fPh2Q87Vv314HDhxoVuB54403tGrVKhUVFen48eP6y1/+opSUFP8V6QNhBwCAEHTs2DGdPn1aLz73O/Xt06dFz3Xoq680feavdOzYsWaFnVOnTumaa67RrbfeqhkzZvixwoYRdgAACGF9+/TRlYMHGV3GBZkyZYqkwO/OTNgBgBB0zahr5XQ6fLZbLFZ9sv3jAFYEBC/CDgCEIKfTodnZD/tsX5a3OIDVAMGNsAMAJmS3l6pPb9/rOBj5QUt79dVX9ctf/tL7/oMPPtC1115rSC2EHQAwIbfbzcgPDPVv//ZvGjFihPd9jx49DKuFsAMAAPyuU6dO6tSpk9FlSCLsAACAADl+/LiKi4tVWloqSTp06JAkyWq1ymq1tth5CTsAAISwQ199FTLneOeddzRt2jTv+9tvv12StGDBAi1cuNAv5zgfwg4AACGoa9euat++vabP/FVAzte+fXt17dq1Wd8xdepUTZ061T8FXQTCDgAAISgxMVEHDhzg2VgXgLADAECISkxMDNkAEkjhRhcAAADQkgg7AADA1Ag7AADA1Ag7AADA1Ag7AADA1Ag7AADA1Ag7AADA1NhnB4BfjUlNlcvl8tl+9B/PxAHQfMXFxWwqeAEIOwD8yuVyademjT7be/RLDmA1gHkVFxerX79++v777wNyvnbt2ungwYMXFXi2bdump59+WkVFRTp69KjefPNNTZw4seWK9IGwAwBACDp27Ji+//57ZU6eIaule4uey+Es1cuvvqBjx45dVNg5deqUhgwZorvuukuTJk1qwQobRtgBgCB0zahr5XQ6fLbb7UwH4gdWS3clXppkdBnnNX78eI0fP97oMgg7ABCMnE6HZmc/7LN99pysAFYDhDbCDoCLwgJkAKGGsAPgorAAGUCoYZ8dAABgaoQdAABgakxjAQCAFnHy5EkdPnzY+/7IkSPas2ePOnfuHNANCgk7AACEMIez5W8KaOo5PvvsM6Wmpnrf5+TkSJIyMzO1Zs0af5R2QQg7AACEoK5du6pdu3Z6+dUXAnK+du3aqWvXrhf1mdGjR8vj8bRQRReOsAMAQAhKTEzUwYMHeTbWBSDsAAAQohITE0M2gAQSd2MBAABTI+wAAABTI+wAABACgmGhrxH8cd1BE3aeeuophYWF6f777/ceO3PmjLKzs9WlSxd17NhRGRkZcjqd9T5XXFysCRMmqH379oqPj9cDDzygs2fPBrh6AABaRmRkpCTp9OnTBldijLrrrvv70BRBsUB59+7dev755zV48OB6x2fPnq3169frtddeU0xMjGbOnKlJkyZp+/btkiS3260JEybIarVqx44dOnr0qO68805FRkZq8eLFRlwKAAB+FRERodjYWJWVlUmS2rdvr7CwMIOrankej0enT59WWVmZYmNjFRER0eTvMjzsnDx5UpMnT9YLL7ygJ554wnu8oqJCL774otauXasxY8ZIklavXq3+/ftr586dGjlypD788EPt379fmzZtksViUUpKih5//HHNmTNHCxcuVJs2bYy6LAAA/MZqtUqSN/C0JrGxsd7rbyrDw052drYmTJigtLS0emGnqKhINTU1SktL8x7r16+fEhMTVVhYqJEjR6qwsFCDBg2SxWLx9klPT1dWVpb27dunK6+88rznrKqqUlVVlfd9ZWVlC1wZAAD+ERYWpm7duik+Pl41NTVGlxMwkZGRzRrRqWNo2Fm3bp0+//xz7d69+5w2h8OhNm3aKDY2tt5xi8Uih8Ph7fPjoFPXXtfmy5IlS/TYY481s3oAAAIrIiLCL3/4tzaGhZ2SkhLdd999ys/PV9u2bQN67rlz53qfzyH9MLKTkJAQ0BoAtG7XjLpWTqfv/ymz21v+eUdAa2FY2CkqKlJZWZmuuuoq7zG3261t27bpueee08aNG1VdXa3y8vJ6oztOp9M7d2e1WvXpp5/W+966u7Uamt+LiopSVFSUH68GAC6O0+nQ7OyHfbbPnpMVwGoAczMs7IwdO1ZffvllvWPTpk1Tv379NGfOHCUkJCgyMlIFBQXKyMiQJB06dEjFxcWy2WySJJvNpieffFJlZWWKj4+XJOXn5ys6OlrJycmBvSAACCF2e6n69O7TYB+LxapPtn8coIqAlmNY2OnUqZMGDhxY71iHDh3UpUsX7/Hp06crJydHnTt3VnR0tGbNmiWbzaaRI0dKksaNG6fk5GRNmTJFS5culcPh0Lx585Sdnc3IDQA0wO12NziyJEnL8tjCA+Zg+N1YDVm2bJnCw8OVkZGhqqoqpaena8WKFd72iIgIvffee8rKypLNZlOHDh2UmZmpRYsWGVg1AAAIJkEVdrZs2VLvfdu2bZWXl6e8vDyfn0lKStL777/fwpUBAIBQFTSPiwAAAGgJhB0AAGBqhB0AAGBqQbVmB4CxxqSmyuVyNdjnaCmb3QEILYQdAF4ul0u7Nm1ssE+PfuxhBSC0MI0FAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjcdFAICfXTPqWjmdjgb72O08YwwIFMIOAPiZ0+nQ7OyHG+wze05WgKoBwDQWAAAwNUZ2AIQUu92uQQMHNtgnLi5Omz/6KEAVAQh2hB0AIcXjqdWuTRsb7DMiLT1A1QAIBUxjAQAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAU2OfHQCm09jGg2w6CLQuhB0AptPYxoNsOgi0LkxjAQAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAU+PZWACA87LbS9Wndx+f7RaLVZ9s/ziAFQFNQ9gBAJyX2+3W7OyHfbYvy1scwGqApmMaCwAAmBphBwAAmBphBwAAmBphBwAAmBoLlAHgIl0z6lo5nQ6f7XZ7aQCrAdAYwg4AXCSn09HgXUqz52QFsBoAjWEaCwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmJqhYWflypUaPHiwoqOjFR0dLZvNpg8++MDbfubMGWVnZ6tLly7q2LGjMjIy5HQ6631HcXGxJkyYoPbt2ys+Pl4PPPCAzp49G+hLAQAAQcrQsHPppZfqqaeeUlFRkT777DONGTNGN910k/bt2ydJmj17tt5991299tpr2rp1q0pLSzVp0iTv591utyZMmKDq6mrt2LFDL7/8stasWaP58+cbdUkAACDIXGLkyW+88cZ675988kmtXLlSO3fu1KWXXqoXX3xRa9eu1ZgxYyRJq1evVv/+/bVz506NHDlSH374ofbv369NmzbJYrEoJSVFjz/+uObMmaOFCxeqTZs2RlwWAAAIIkGzZsftdmvdunU6deqUbDabioqKVFNTo7S0NG+ffv36KTExUYWFhZKkwsJCDRo0SBaLxdsnPT1dlZWV3tGh86mqqlJlZWW9FwAAMCfDw86XX36pjh07KioqSvfee6/efPNNJScny+FwqE2bNoqNja3X32KxyOFwSJIcDke9oFPXXtfmy5IlSxQTE+N9JSQk+PeiAABA0DA87PTt21d79uzRrl27lJWVpczMTO3fv79Fzzl37lxVVFR4XyUlJS16PgAAYBxD1+xIUps2bdS7d29J0tChQ7V7927913/9l2677TZVV1ervLy83uiO0+mU1WqVJFmtVn366af1vq/ubq26PucTFRWlqKgoP18JAAAIRoaP7Pyz2tpaVVVVaejQoYqMjFRBQYG37dChQyouLpbNZpMk2Ww2ffnllyorK/P2yc/PV3R0tJKTkwNeOwAACD6GjuzMnTtX48ePV2Jiok6cOKG1a9dqy5Yt2rhxo2JiYjR9+nTl5OSoc+fOio6O1qxZs2Sz2TRy5EhJ0rhx45ScnKwpU6Zo6dKlcjgcmjdvnrKzsxm5AQAAkgwOO2VlZbrzzjt19OhRxcTEaPDgwdq4caN++tOfSpKWLVum8PBwZWRkqKqqSunp6VqxYoX38xEREXrvvfeUlZUlm82mDh06KDMzU4sWLTLqkgAAQJAxNOy8+OKLDba3bdtWeXl5ysvL89knKSlJ77//vr9LA9CKXTPqWjmdvu/otNtLA1gNgOYyfIEyAAQbp9Oh2dkP+2yfPScrgNUAaK6gW6AMAADgT4QdAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgatx6DrQiY1JT5XK5fLYfLWX/GFw4u71UfXr38dlusVj1yfaPA1gRcH6EHaAVcblc2rVpo8/2Hv14phwunNvtbnA/omV5iwNYDeAb01gAAMDUmhR2LrvsMn377bfnHC8vL9dll13W7KIAAAD8pUlh5+uvv5bb7T7neFVVlex2e7OLAgAA8JeLWrPzzjvveP9648aNiomJ8b53u90qKChQz549/VYcAABAc11U2Jk4caIkKSwsTJmZmfXaIiMj1bNnT/32t7/1W3EAAADNdVFhp7a2VpLUq1cv7d69W127dm2RogAAAPylSbeeHzlyxN91AAAAtIgm77NTUFCggoIClZWVeUd86rz00kvNLgwAAMAfmhR2HnvsMS1atEjDhg1Tt27dFBYW5u+6AAAA/KJJYWfVqlVas2aNpkyZ4u96AAAA/KpJ++xUV1frX/7lX/xdCwAAgN81KezcfffdWrt2rb9rAQAA8LsmTWOdOXNGv//977Vp0yYNHjxYkZGR9dqfffZZvxQHAADQXE0KO3/961+VkpIiSdq7d2+9NhYrAwCAYNKksPPRRx/5uw4AAIAW0aQ1OwAAAKGiSSM7qampDU5Xbd68uckFAQAA+FOTwk7dep06NTU12rNnj/bu3XvOA0IBBM6Y1FS5XC6f7UdLSwNYDQAEhyaFnWXLlp33+MKFC3Xy5MlmFQSg6Vwul3Zt2uizvUe/5ABWAwDBwa9rdv793/+d52IBAICg4tewU1hYqLZt2/rzKwEAAJqlSdNYkyZNqvfe4/Ho6NGj+uyzz/Too4/6pTAAAAB/aFLYiYmJqfc+PDxcffv21aJFizRu3Di/FAYAAOAPTQo7q1ev9ncdAAAALaJJYadOUVGRDhw4IEkaMGCArrzySr8UBQAA4C9NCjtlZWW6/fbbtWXLFsXGxkqSysvLlZqaqnXr1ikuLs6fNQIAADRZk+7GmjVrlk6cOKF9+/bp+PHjOn78uPbu3avKykr96le/8neNAAAATdakkZ0NGzZo06ZN6t+/v/dYcnKy8vLyWKAMAACCSpNGdmpraxUZGXnO8cjISNXW1ja7KAAAAH9pUtgZM2aM7rvvPpX+6Dk7drtds2fP1tixY/1WHAAAQHM1Kew899xzqqysVM+ePXX55Zfr8ssvV69evVRZWanc3Fx/1wgAANBkTVqzk5CQoM8//1ybNm3SwYMHJUn9+/dXWlqaX4sDAABorosa2dm8ebOSk5NVWVmpsLAw/fSnP9WsWbM0a9YsDR8+XAMGDNDHH3/cUrUCAABctIsKO8uXL9eMGTMUHR19TltMTIx++ctf6tlnn/VbcQAAAM11UWHniy++0PXXX++zfdy4cSoqKmp2UQAAAP5yUWHH6XSe95bzOpdccolcLleziwIAAPCXiwo7PXr00N69e322//Wvf1W3bt2aXRQAAIC/XFTYueGGG/Too4/qzJkz57R9//33WrBggX72s5/5rTgAAIDmuqhbz+fNm6c33nhDV1xxhWbOnKm+fftKkg4ePKi8vDy53W498sgjLVIoAABAU1xU2LFYLNqxY4eysrI0d+5ceTweSVJYWJjS09OVl5cni8XSIoUCAAA0xUVvKpiUlKT3339f3333nQ4fPiyPx6M+ffroJz/5SUvUBwAA0CxN2kFZkn7yk59o+PDh/qwFAADA75ocdgAAaIjdXqo+vfv4bLdYrPpkO7vuo+URdgC0Ona7XYMGDvTZ7nKVBbAa83K73Zqd/bDP9mV5iwNYDVozwg6AVsfjqdWuTRt9tne/on8AqwHQ0i5qnx0AAIBQQ9gBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmZmjYWbJkiYYPH65OnTopPj5eEydO1KFDh+r1OXPmjLKzs9WlSxd17NhRGRkZcjqd9foUFxdrwoQJat++veLj4/XAAw/o7NmzgbwUAAAQpAwNO1u3blV2drZ27typ/Px81dTUaNy4cTp16pS3z+zZs/Xuu+/qtdde09atW1VaWqpJkyZ5291utyZMmKDq6mrt2LFDL7/8stasWaP58+cbcUkAACDIGPq4iA0bNtR7v2bNGsXHx6uoqEjXXXedKioq9OKLL2rt2rUaM2aMJGn16tXq37+/du7cqZEjR+rDDz/U/v37tWnTJlksFqWkpOjxxx/XnDlztHDhQrVp08aISwMAAEEiqNbsVFRUSJI6d+4sSSoqKlJNTY3S0tK8ffr166fExEQVFhZKkgoLCzVo0CBZLBZvn/T0dFVWVmrfvn3nPU9VVZUqKyvrvQAAgDkFTdipra3V/fffr1GjRmngP55G7HA41KZNG8XGxtbra7FY5HA4vH1+HHTq2uvazmfJkiWKiYnxvhISEvx8NQAAIFgETdjJzs7W3r17tW7duhY/19y5c1VRUeF9lZSUtPg5AQCAMQxds1Nn5syZeu+997Rt2zZdeuml3uNWq1XV1dUqLy+vN7rjdDpltVq9fT799NN631d3t1Zdn38WFRWlqKgoP18FAAAIRoaO7Hg8Hs2cOVNvvvmmNm/erF69etVrHzp0qCIjI1VQUOA9dujQIRUXF8tms0mSbDabvvzyS5WVlXn75OfnKzo6WsnJyYG5EAAAELQMHdnJzs7W2rVr9fbbb6tTp07eNTYxMTFq166dYmJiNH36dOXk5Khz586Kjo7WrFmzZLPZNHLkSEnSuHHjlJycrClTpmjp0qVyOByaN2+esrOzGb0BAADGhp2VK1dKkkaPHl3v+OrVqzV16lRJ0rJlyxQeHq6MjAxVVVUpPT1dK1as8PaNiIjQe++9p6ysLNlsNnXo0EGZmZlatGhRoC4DAAAEMUPDjsfjabRP27ZtlZeXp7y8PJ99kpKS9P777/uzNAAAYBJBczcWAABASyDsAAAAUyPsAAAAUyPsAAAAUwuKTQUBIJDOnnUrNzfXd7vbHcBqALQ0wg6AVsgj2/BrG2j3HYQAhB6msQAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKldYnQBAC7cmNRUuVwun+1HS0sDWA0AhAbCDhBCXC6Xdm3a6LO9R7/kAFYDAKGBaSwAAGBqjOwAAAxht5eqT+8+PtstFqs+2f5xACuCWRF2AACGcLvdmp39sM/2ZXmLA1gNzIxpLAAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGrsswMA/8RTW6vfPLvQZ3t4eFjgigHQbIQdAPgn4eHh+kPuCp/tN0y+NYDVAGguprEAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpcTcWEETGpKbK5XL5bD9aWhrAagDAHAg7QBBxuVzatWmjz/Ye/ZIDWA0AmAPTWAAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNR46jkA0zl71q3c3FzfHTyBqwWA8Qg7AEzII9vwaxtobyAIATAdprEAAICpMbIDABfJU1ur3zy70Gd7eHhY4IoB0CjCDgBcpPDwcP0hd4XP9hsm3xrAagA0hrADBMiY1FS5XK4G+xwtLQ1QNQDQehi6Zmfbtm268cYb1b17d4WFhemtt96q1+7xeDR//nx169ZN7dq1U1pamr766qt6fY4fP67JkycrOjpasbGxmj59uk6ePBnAqwAujMvl0q5NGxt8uWvdRpcJAKZj6MjOqVOnNGTIEN11112aNGnSOe1Lly7V7373O7388svq1auXHn30UaWnp2v//v1q27atJGny5Mk6evSo8vPzVVNTo2nTpumee+7R2rVrA305AAKg0dvKJW4tB1CPoWFn/PjxGj9+/HnbPB6Pli9frnnz5ummm26SJL3yyiuyWCx66623dPvtt+vAgQPasGGDdu/erWHDhkmScnNzdcMNN+iZZ55R9+7dA3YtAAKlsdvKJW4tB/BjQXvr+ZEjR+RwOJSWluY9FhMToxEjRqiwsFCSVFhYqNjYWG/QkaS0tDSFh4dr165dPr+7qqpKlZWV9V4AAMCcgjbsOBwOSZLFYql33GKxeNscDofi4+PrtV9yySXq3Lmzt8/5LFmyRDExMd5XQkKCn6sHAADBImjDTkuaO3euKioqvK+SkhKjSwIAAC0kaMOO1WqVJDmdznrHnU6nt81qtaqsrKxe+9mzZ3X8+HFvn/OJiopSdHR0vRcAADCnoN1np1evXrJarSooKFBKSookqbKyUrt27VJWVpYkyWazqby8XEVFRRo6dKgkafPmzaqtrdWIESOMKh0A4Ad2e6n69O7TYB+LxapPtn8coIoQqgwNOydPntThw4e9748cOaI9e/aoc+fOSkxM1P33368nnnhCffr08d563r17d02cOFGS1L9/f11//fWaMWOGVq1apZqaGs2cOVO33347d2IBQIhzu92anf1wg32W5S0OUDUIZYaGnc8++0ypqane9zk5OZKkzMxMrVmzRg8++KBOnTqle+65R+Xl5brmmmu0YcMG7x47kvTqq69q5syZGjt2rMLDw5WRkaHf/e53Ab8WAAAQnAwNO6NHj5bH43v3r7CwMC1atEiLFi3y2adz585sIIig0NjjIHgUBAAYI2jX7AChpu5xEL706JccwGqA1qGxdT2s6YFE2AEAhLDG1vWwpgdSEN96DgAA4A+EHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGrsswMAfuaprdVvnl3YYJ/w8LDAFAOAsAMA/hYeHq4/5K5osM8Nk28NUDUAmMYCAACmxsgOcIF40CcAhCbCDnCBeNAnAIQmprEAAICpEXYAAICpEXYAAICpEXYAAICpsUAZrUZjd1PFxcVp80cfBbAiAEAgEHbQajR2N9WItPQAVgMACBSmsQAAgKkRdgAAgKkRdgAAgKmxZgf4B7vdrkEDB/ps53EQABCaCDvAP3g8tTwOAgBMiGksAABgaozsAAgqZ8+6lZub67uDJ3C1ADAHwg6AIOORbfi1DbQ3EIQA4DyYxgIAAKbGyA4AwLTs9lL16d3HZ7vFYtUn2z8OYEUwAmEHAAzgqa3Vb55d6LM9PDwscMWYmNvt1uzsh322L8tbHMBqYBTCDgAYIDw8XH/IXeGz/YbJtwawGsDcWLMDAABMjbADAABMjbADAABMjbADAABMjQXKAAKKHZIBBBphB0CAsUMygMBiGgsAAJgaYQcAAJgaYQcAAJgaa3ZgCmNSU+VyuRrsc7S0NEDVAC0vPDyMx034Ac/Oah0IOzAFl8ulXZs2NtinR7/kAFUDtLyICB434Q88O6t1IOwgJDQ2csOoDcymsQeFArhwhB2EhMZGbhi1gdk09qDQCYzcABeMBcoAAMDUCDsAAMDUmMYC4Fc8DgJAsCHsAPAzHgcBILgwjQUAAEyNsAMAAEyNaSwAF4U1OaGhsX162GEZrQlhBwHR2KaAcXFx2vzRRwGsCE3HmpxQ0Ng+PeywjNaEsIOAaGxTwEv7D9SggQN9trNDMgCgqQg7CAoeTy07JAMAWgQLlAEAgKkxsgMAgA92e6n69O7js91iseqT7R8HsCI0BWEHAAAf3G63Zmc/7LN9Wd7iAFaDpiLsAEAr1Nit6RK3p8M8CDvwi8ZuLeduqtDQ6B46EvvomERjt6ZL0vg7bmavnkY0Ns0lSWUul+Lj4ny2MxXW8gg78IvGbi3nbqpQ0dgeOhL76LQe7NXTuMamuSRp9pwspsIMRtgBADQJuzQjVBB2TIDdiQEYobGRH6bBECxME3by8vL09NNPy+FwaMiQIcrNzdXVV19tdFkB0dgU0oi09GZ9f2NhSmJNDoBzMQ2GYGGKsPOnP/1JOTk5WrVqlUaMGKHly5crPT1dhw4dUnx8vNHlhbzGwpTEmpxQwUM8AbRGpgg7zz77rGbMmKFp06ZJklatWqX169frpZde0kMPPWRwdc3X0nc6cSfVhWksKJw96w5gNb5raDjM8BBPBA9/rPkJDw8L+akyNi5seSEfdqqrq1VUVKS5c+d6j4WHhystLU2FhYXn/UxVVZWqqqq87ysqKiRJlZWVfq/vZxMm6NixYz7bu3btqvfWr2/wOxwOhza/86bP9n7DrlbliRM+27/55hsl9+/vs72kuFi/zrrHZ/vTK3/f4PdLUk3NWT39zDMNtjf0HR6Pp1ntjZ1fkmqqa5pZY60GDxjqu722tlnfX9enRWv0eHTq9Okmt/vjO1q6PRhqoMYLaw8LC9Oq3/j+5z3jrila8sz8BmsMD2/4O26+O1Pfn/m+wRobag8LU4M1hIc33F73HQ2d4+zZs7p3+myf7Ste+G2L/Pl0Mcb9NF0uV5nPdtexY4rr2tVne1xcvD7Mb3iGoCnq/r54PI0MS3tCnN1u90jy7Nixo97xBx54wHP11Vef9zMLFizw6IcBe168ePHixYtXiL9KSkoazAohP7LTFHPnzlVOTo73fW1trY4fP64uXbooLCz4hzzPp7KyUgkJCSopKVF0dLTR5eA8+I2CH79R8OM3Cn6B/I08Ho9OnDih7t27N9gv5MNO165dFRERIafTWe+40+mU1Wo972eioqIUFRVV71hsbGxLlRhQ0dHR/AcgyPEbBT9+o+DHbxT8AvUbxcTENNonvMWraGFt2rTR0KFDVVBQ4D1WW1urgoIC2Ww2AysDAADBIORHdiQpJydHmZmZGjZsmK6++motX75cp06d8t6dBQAAWi9ThJ3bbrtNLpdL8+fPl8PhUEpKijZs2CCLxWJ0aQETFRWlBQsWnDM9h+DBbxT8+I2CH79R8AvG3yjM42nsfi0AAIDQFfJrdgAAABpC2AEAAKZG2AEAAKZG2AEAAKZG2DG5qqoqpaSkKCwsTHv27DG6HPzD119/renTp6tXr15q166dLr/8ci1YsEDV1dVGl9aq5eXlqWfPnmrbtq1GjBihTz/91OiS8A9LlizR8OHD1alTJ8XHx2vixIk6dOiQ0WWhAU899ZTCwsJ0//33G10KYcfsHnzwwUa30UbgHTx4ULW1tXr++ee1b98+LVu2TKtWrdLDDz9sdGmt1p/+9Cfl5ORowYIF+vzzzzVkyBClp6errMz3ww8ROFu3blV2drZ27typ/Px81dTUaNy4cTp16pTRpeE8du/ereeff16DBw82uhRJ3Hpuah988IFycnL05z//WQMGDNBf/vIXpaSkGF0WfHj66ae1cuVK/f3vfze6lFZpxIgRGj58uJ577jlJP+zEnpCQoFmzZumhhx4yuDr8M5fLpfj4eG3dulXXXXed0eXgR06ePKmrrrpKK1as0BNPPKGUlBQtX77c0JoY2TEpp9OpGTNm6A9/+IPat29vdDm4ABUVFercubPRZbRK1dXVKioqUlpamvdYeHi40tLSVFhYaGBl8KWiokKS+HcmCGVnZ2vChAn1/n0ymil2UEZ9Ho9HU6dO1b333qthw4bp66+/NrokNOLw4cPKzc3VM888Y3QprdKxY8fkdrvP2XXdYrHo4MGDBlUFX2pra3X//fdr1KhRGjhwoNHl4EfWrVunzz//XLt37za6lHoY2QkhDz30kMLCwhp8HTx4ULm5uTpx4oTmzp1rdMmtzoX+Rj9mt9t1/fXX65ZbbtGMGTMMqhwIHdnZ2dq7d6/WrVtndCn4kZKSEt1333169dVX1bZtW6PLqYc1OyHE5XLp22+/bbDPZZddpltvvVXvvvuuwsLCvMfdbrciIiI0efJkvfzyyy1daqt1ob9RmzZtJEmlpaUaPXq0Ro4cqTVr1ig8nP//MEJ1dbXat2+v119/XRMnTvQez8zMVHl5ud5++23jikM9M2fO1Ntvv61t27apV69eRpeDH3nrrbf085//XBEREd5jbrdbYWFhCg8PV1VVVb22QCLsmFBxcbEqKyu970tLS5Wenq7XX39dI0aM0KWXXmpgdahjt9uVmpqqoUOH6o9//KNh/xHAD0aMGKGrr75aubm5kn6YKklMTNTMmTNZoBwEPB6PZs2apTfffFNbtmxRnz59jC4J/+TEiRP6v//7v3rHpk2bpn79+mnOnDmGTjmyZseEEhMT673v2LGjJOnyyy8n6AQJu92u0aNHKykpSc8884xcLpe3zWq1GlhZ65WTk6PMzEwNGzZMV199tZYvX65Tp05p2rRpRpcG/TB1tXbtWr399tvq1KmTHA6HJCkmJkbt2rUzuDpIUqdOnc4JNB06dFCXLl0MX1tF2AEMkJ+fr8OHD+vw4cPnBFAGW41x2223yeVyaf78+XI4HEpJSdGGDRvOWbQMY6xcuVKSNHr06HrHV69eralTpwa+IIQUprEAAICpsRoSAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAPTDk88BmBNhB0BQe/311zVo0CC1a9dOXbp0UVpamk6dOiVJeumllzRgwABFRUWpW7dumjlzpvdzxcXFuummm9SxY0dFR0fr1ltvldPp9LYvXLhQKSkp+u///m/16tVLbdu2lSSVl5fr7rvvVlxcnKKjozVmzBh98cUXgb1oAH5F2AEQtI4ePao77rhDd911lw4cOKAtW7Zo0qRJ8ng8WrlypbKzs3XPPffoyy+/1DvvvKPevXtLkmpra3XTTTfp+PHj2rp1q/Lz8/X3v/9dt912W73vP3z4sP785z/rjTfe0J49eyRJt9xyi8rKyvTBBx+oqKhIV111lcaOHavjx48H+vIB+AkPAgUQtD7//HMNHTpUX3/9tZKSkuq19ejRQ9OmTdMTTzxxzufy8/M1fvx4HTlyRAkJCZKk/fv3a8CAAfr00081fPhwLVy4UIsXL5bdbldcXJwk6ZNPPtGECRNUVlamqKgo7/f17t1bDz74oO65554WvFoALeUSowsAAF+GDBmisWPHatCgQUpPT9e4ceN08803q6amRqWlpRo7dux5P3fgwAElJCR4g44kJScnKzY2VgcOHNDw4cMlSUlJSd6gI0lffPGFTp48qS5dutT7vu+//15/+9vfWuAKAQQCYQdA0IqIiFB+fr527NihDz/8ULm5uXrkkUdUUFDgl+/v0KFDvfcnT55Ut27dtGXLlnP6xsbG+uWcAAKPsAMgqIWFhWnUqFEaNWqU5s+fr6SkJOXn56tnz54qKChQamrqOZ/p37+/SkpKVFJSUm8aq7y8XMnJyT7PddVVV8nhcOiSSy5Rz549W+qSAAQYYQdA0Nq1a5cKCgo0btw4xcfHa9euXXK5XOrfv78WLlyoe++9V/Hx8Ro/frxOnDih7du3a9asWUpLS9OgQYM0efJkLV++XGfPntV//Md/6F//9V81bNgwn+dLS0uTzWbTxIkTtXTpUl1xxRUqLS3V+vXr9fOf/7zBzwIIXoQdAEErOjpa27Zt0/Lly1VZWamkpCT99re/1fjx4yVJZ86c0bJly/TrX/9aXbt21c033yzph9Ggt99+W7NmzdJ1112n8PBwXX/99crNzW3wfGFhYXr//ff1yCOPaNq0aXK5XLJarbruuutksVha/HoBtAzuxgIAAKbGPjsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDUCDsAAMDU/h+03HZavsoX2wAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ], + "source": [ + "## visualization\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "import warnings\n", + "import matplotlib.pyplot as plt\n", + "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", + "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", + "\n", + "score = pipe.decision_function(X)\n", + "y_label = 2*y - 1\n", + "df = pd.DataFrame({'score': score, 'y': y_label})\n", + "sns.histplot(df, x=\"score\", hue=\"y\")\n", + "plt.show()" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/doc/source/tutorials/constraint.rst b/doc/source/tutorials/constraint.rst index e81c25a..964cdfc 100644 --- a/doc/source/tutorials/constraint.rst +++ b/doc/source/tutorials/constraint.rst @@ -55,6 +55,7 @@ Constrains the correlation between predictions and sensitive attributes to be wi :name: fair-gallery ../examples/FairSVM.ipynb + ../examples/FaireSVM_new.ipynb Monotonicity ^^^^^^^^^^^^ @@ -73,6 +74,13 @@ Increasing: :math:`\beta_i \le \beta_{i+1}`. Decreasing: :math:`\beta_i \ge \bet # Monotonically decreasing constraint = [{'name': 'monotonic', 'decreasing': True}] +**Related Example** + +.. nblinkgallery:: + :name: monotonic-gallery + + ../examples/MonotonicSVM.ipynb + Custom Constraints ^^^^^^^^^^^^^^^^^^ Define arbitrary linear constraints of the form :math:`A\beta + b \ge 0`. @@ -94,6 +102,13 @@ Define arbitrary linear constraints of the form :math:`A\beta + b \ge 0`. constraint = [{'name': 'custom', 'A': A, 'b': b}] +**Related Example** + +.. nblinkgallery:: + :name: custom-gallery + + ../examples/CustomQR.ipynb + References ---------- diff --git a/doc/source/tutorials/loss.rst b/doc/source/tutorials/loss.rst index cb336c0..bb2b236 100644 --- a/doc/source/tutorials/loss.rst +++ b/doc/source/tutorials/loss.rst @@ -35,6 +35,7 @@ Standard Support Vector Machine loss [1]_. :name: svm-gallery ../examples/SVM.ipynb + ../examples/SVM_new.ipynb Smooth SVM ^^^^^^^^^^ @@ -53,6 +54,7 @@ A smoothed version of the Hinge loss (using ReHU) that is differentiable everywh :name: ssvm-gallery ../examples/SVM.ipynb + ../examples/Smooth_SVM_new.ipynb Squared SVM ^^^^^^^^^^^ @@ -71,6 +73,19 @@ Squared Hinge loss. :name: squared-svm-gallery ../examples/SVM.ipynb + ../examples/Squared_SVM_new.ipynb + + +Grid Search for SVM Family +^^^^^^^^^^^^^^^^^^^^^^^^^^ +Uses ``GridSearchCV`` to select the optimal loss function among SVM, Smooth SVM, and Squared SVM. + +**Related Example** + +.. nblinkgallery:: + :name: gridsearch-svm-gallery + + ../examples/GridSearchCV_SVM_losses.ipynb Regression @@ -94,6 +109,7 @@ Minimizes the check loss (pinball loss) for estimating conditional quantiles [2] :name: qr-gallery ../examples/QR.ipynb + ../examples/QR_new.ipynb Quantile Regression with Epsilon Tolerance ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -114,6 +130,7 @@ Minimizes the check loss with an epsilon-insensitive zone for robust conditional :name: qr-eps-gallery ../examples/QR_eps.ipynb + ../examples/QR_eps_new.ipynb Huber Regression ^^^^^^^^^^^^^^^^ @@ -127,6 +144,13 @@ Robust regression loss that is quadratic for small errors and linear for large e loss = {'name': 'huber', 'tau': 1.0} +**Related Example** + +.. nblinkgallery:: + :name: huber-gallery + + ../examples/Huber_new.ipynb + Support Vector Regression (SVR) ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Epsilon-insensitive loss [4]_. @@ -145,6 +169,7 @@ Epsilon-insensitive loss [4]_. :name: svr-gallery ../examples/SVR.ipynb + ../examples/SVR_new.ipynb Mean Absolute Error (MAE) ^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -157,6 +182,13 @@ L1 loss, robust to outliers. loss = {'name': 'mae'} +**Related Example** + +.. nblinkgallery:: + :name: mae-gallery + + ../examples/MAE_new.ipynb + Mean Squared Error (MSE) ^^^^^^^^^^^^^^^^^^^^^^^^ Standard L2 loss (Least Squares). @@ -168,6 +200,23 @@ Standard L2 loss (Least Squares). loss = {'name': 'mse'} +**Related Example** + +.. nblinkgallery:: + :name: mse-gallery + + ../examples/MSE_new.ipynb + +Grid Search for Regression Losses +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ +Uses ``GridSearchCV`` to select the optimal loss function among Huber, MAE, and MSE. + +**Related Example** + +.. nblinkgallery:: + :name: gridsearch-reg-gallery + + ../examples/GridSearchCV_reg_losses.ipynb References ---------- From 2f1f28fd552eecbcbd0ec11b8598d3b57258c12a Mon Sep 17 00:00:00 2001 From: fzh <1155233259@link.cuhk.edu.hk> Date: Thu, 2 Apr 2026 02:16:31 +0800 Subject: [PATCH 3/3] Move notebooks to examples folder and update rst files --- .../STAR2000_GridSearchCV_SVM_losses.ipynb | 731 ----------- .../STAR2000_GridSearchCV_reg losses.ipynb | 727 ----------- .../STAR2000_constraint_Monotonicity.ipynb | 1118 ---------------- examples_FEI/STAR2000_constraint_custom.ipynb | 1134 ---------------- .../STAR2000_constraint_fairness.ipynb | 1120 ---------------- examples_FEI/STAR2000_loss_MAE.ipynb | 1135 ----------------- examples_FEI/STAR2000_loss_MSE.ipynb | 1119 ---------------- examples_FEI/STAR2000_loss_QR.ipynb | 1096 ---------------- examples_FEI/STAR2000_loss_QR_with_tol.ipynb | 1111 ---------------- examples_FEI/STAR2000_loss_SVM.ipynb | 1111 ---------------- examples_FEI/STAR2000_loss_SVR.ipynb | 1122 ---------------- examples_FEI/STAR2000_loss_Smooth_SVM.ipynb | 1102 ---------------- examples_FEI/STAR2000_loss_Squared_SVM.ipynb | 1105 ---------------- examples_FEI/STAR2000_loss_huber.ipynb | 1135 ----------------- 14 files changed, 14866 deletions(-) delete mode 100644 examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb delete mode 100644 examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb delete mode 100644 examples_FEI/STAR2000_constraint_Monotonicity.ipynb delete mode 100644 examples_FEI/STAR2000_constraint_custom.ipynb delete mode 100644 examples_FEI/STAR2000_constraint_fairness.ipynb delete mode 100644 examples_FEI/STAR2000_loss_MAE.ipynb delete mode 100644 examples_FEI/STAR2000_loss_MSE.ipynb delete mode 100644 examples_FEI/STAR2000_loss_QR.ipynb delete mode 100644 examples_FEI/STAR2000_loss_QR_with_tol.ipynb delete mode 100644 examples_FEI/STAR2000_loss_SVM.ipynb delete mode 100644 examples_FEI/STAR2000_loss_SVR.ipynb delete mode 100644 examples_FEI/STAR2000_loss_Smooth_SVM.ipynb delete mode 100644 examples_FEI/STAR2000_loss_Squared_SVM.ipynb delete mode 100644 examples_FEI/STAR2000_loss_huber.ipynb diff --git a/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb b/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb deleted file mode 100644 index a84611e..0000000 --- a/examples_FEI/STAR2000_GridSearchCV_SVM_losses.ipynb +++ /dev/null @@ -1,731 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "WaRThRkBIA5j", - "outputId": "c09f7839-f24b-449e-be17-70e66396bafd" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-viuqut75\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-viuqut75\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=5c5be6969b966988219f8979e617a21f59ae88278f8d50cc95f710a096c4c4b4\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-cr7ssxvm/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "O76jxeIHIALp" - }, - "outputs": [], - "source": [ - "## set up plotting style\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "custom_palette = ['#FFE4E1', '#3D325C']\n", - "sns.set_palette(custom_palette)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "IDityv5qCrQv" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "import numpy as np\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 749 - }, - "id": "JKowJ-3KHCrF", - "outputId": "5e320f7f-0b17-427d-c5f3-7a8f5264c6d6" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "GridSearchCV(cv=5,\n", - " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('clf',\n", - " plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n", - " param_grid={'clf__C': [0.1, 1.0, 10.0],\n", - " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n", - " {'name': 'squared SVM'}]})" - ], - "text/html": [ - "
GridSearchCV(cv=5,\n",
-              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                                       ('clf',\n",
-              "                                        plq_Ridge_Classifier(loss={'name': 'svm'}))]),\n",
-              "             param_grid={'clf__C': [0.1, 1.0, 10.0],\n",
-              "                         'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'},\n",
-              "                                       {'name': 'squared SVM'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ], - "source": [ - "## compare SVM losses via GridSearchCV\n", - "from sklearn.pipeline import Pipeline\n", - "from sklearn.preprocessing import StandardScaler\n", - "from rehline import plq_Ridge_Classifier\n", - "from sklearn.model_selection import GridSearchCV\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))\n", - "])\n", - "\n", - "# Define the parameter grid to search\n", - "param_grid = {\n", - " 'clf__C': [0.1, 1.0, 10.0],\n", - " 'clf__loss': [{'name': 'svm'}, {'name': 'sSVM'}, {'name': 'squared SVM'}]\n", - "}\n", - "\n", - "# Create the GridSearchCV object\n", - "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", - "grid_search.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "C5_7b71QM9XK", - "outputId": "7258d1c2-318d-4319-eca5-7b6d2f4522a8" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Overall Best Params: {'clf__C': 0.1, 'clf__loss': {'name': 'svm'}}\n", - "Overall Best Score: 0.8922\n" - ] - } - ], - "source": [ - "# Print the best loss function and score\n", - "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", - "print(f\"Overall Best Score: {grid_search.best_score_:.4f}\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "TxnC0FjziZvD" - }, - "source": [ - "#Compare SVM & Smooth SVM & Squared SVM" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "eiqipAokiYf5", - "outputId": "5b4db390-faaa-445c-997a-e17450e6b538" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Loss Best C CV Score\n", - " svm 0.1 0.8922\n", - " sSVM 0.1 0.8920\n", - "squared SVM 0.1 0.8913\n" - ] - } - ], - "source": [ - "## print best results per loss\n", - "import pandas as pd\n", - "df = pd.DataFrame(grid_search.cv_results_)\n", - "df['Loss'] = df['param_clf__loss'].apply(lambda x: x['name'])\n", - "df = df.sort_values('mean_test_score', ascending=False)\n", - "best = df.drop_duplicates(subset=['Loss'])\n", - "table = best[['Loss', 'param_clf__C', 'mean_test_score']].rename(\n", - " columns={'param_clf__C': 'Best C', 'mean_test_score': 'CV Score'}\n", - ")\n", - "\n", - "print(table.to_string(index=False))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 341 - }, - "id": "27SVRgNeIp7G", - "outputId": "f3506667-d777-470f-af04-7ed54f2ed128" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## plot score distributions for best models\n", - "import seaborn as sns\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", - "y_label = 2*y - 1\n", - "for i in range(len(best)):\n", - " loss = best['Loss'].iloc[i]\n", - " c = best['param_clf__C'].iloc[i]\n", - "\n", - " pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': loss}, C=c))\n", - " ])\n", - " pipe.fit(X, y)\n", - "\n", - " score = pipe.decision_function(X)\n", - " df = pd.DataFrame({'score': score, 'y': y_label})\n", - " sns.histplot(df, x=\"score\", hue=\"y\", ax=axes[i]).set_title(loss)\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb b/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb deleted file mode 100644 index 7663f41..0000000 --- a/examples_FEI/STAR2000_GridSearchCV_reg losses.ipynb +++ /dev/null @@ -1,727 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "O_SFIipUcSyD", - "outputId": "77c9f603-de96-4c8f-9ca8-727c475e211c" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-qbh74ba5\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-qbh74ba5\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=743e41d2730cd6d801ec5c3acbc3d6ace163b9c318a9ba67a4592dec9587353d\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-5c6fypql/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_regression\n", - "\n", - "X, y = make_regression(n_samples=10000, n_features=5, noise=30.0, random_state=42)\n", - "y = y / y.std()\n", - "y[-40:] += 20" - ], - "metadata": { - "id": "mLPT_rZskyrr" - }, - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "## compare Huber, MAE and MSE via GridSearchCV\n", - "from sklearn.pipeline import Pipeline\n", - "from sklearn.preprocessing import StandardScaler\n", - "from rehline import plq_Ridge_Regressor\n", - "from sklearn.model_selection import GridSearchCV\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'mse'}))\n", - "])\n", - "\n", - "# Define the parameter grid to search\n", - "param_grid = {\n", - " 'reg__C': [0.1, 1.0, 10.0],\n", - " 'reg__loss': [{'name': 'huber', 'tau': 1.0}, {'name': 'mae'}, {'name': 'mse'}]\n", - "}\n", - "\n", - "# Create the GridSearchCV object\n", - "grid_search = GridSearchCV(pipe, param_grid, cv=5)\n", - "grid_search.fit(X, y)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 898 - }, - "id": "cd-YVK8UpDD0", - "outputId": "883eb665-7c89-4910-f2f1-7c03335725b0" - }, - "execution_count": 3, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n", - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "GridSearchCV(cv=5,\n", - " estimator=Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('reg',\n", - " plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n", - " param_grid={'reg__C': [0.1, 1.0, 10.0],\n", - " 'reg__loss': [{'name': 'huber', 'tau': 1.0},\n", - " {'name': 'mae'}, {'name': 'mse'}]})" - ], - "text/html": [ - "
GridSearchCV(cv=5,\n",
-              "             estimator=Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                                       ('reg',\n",
-              "                                        plq_Ridge_Regressor(loss={'name': 'mse'}))]),\n",
-              "             param_grid={'reg__C': [0.1, 1.0, 10.0],\n",
-              "                         'reg__loss': [{'name': 'huber', 'tau': 1.0},\n",
-              "                                       {'name': 'mae'}, {'name': 'mse'}]})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 3 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Print the best loss function and score\n", - "print(f\"Overall Best Params: {grid_search.best_params_}\")\n", - "print(f\"Overall Best Score: {grid_search.best_score_:.5f}\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cHQEgKt8pMKr", - "outputId": "e5c4d1ea-241b-4a99-a921-71e23e3f0fb9" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Overall Best Params: {'reg__C': 1.0, 'reg__loss': {'name': 'mae'}}\n", - "Overall Best Score: 0.77874\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Print best results per loss\n", - "import pandas as pd\n", - "df = pd.DataFrame(grid_search.cv_results_)\n", - "df['Loss'] = df['param_reg__loss'].apply(lambda x: x['name'])\n", - "df = df.sort_values('mean_test_score', ascending=False)\n", - "best = df.drop_duplicates(subset=['Loss'])\n", - "table = best[['Loss', 'param_reg__C', 'mean_test_score']].rename(\n", - " columns={'param_reg__C': 'Best C', 'mean_test_score': 'CV Score'}\n", - ")\n", - "\n", - "print(table.to_string(index=False))" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "IgxOOM3_pIwW", - "outputId": "23690687-ec0f-456b-f5d0-57431d715d42" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Loss Best C CV Score\n", - " mae 1.0 0.778740\n", - "huber 0.1 0.778691\n", - " mse 0.1 0.769240\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import seaborn as sns\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "fig, axes = plt.subplots(1, 3, figsize=(15, 4))\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "\n", - "for i in range(len(best)):\n", - " loss = best['Loss'].iloc[i]\n", - " c = best['param_reg__C'].iloc[i]\n", - "\n", - " pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': loss}, C=c))\n", - " ])\n", - " pipe.fit(X, y)\n", - "\n", - " pred_y = pipe.predict(X_sample)\n", - " df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'pred': pred_y})\n", - " df = df.melt(id_vars='x0')\n", - "\n", - " sns.scatterplot(data=df, x='x0', y='value', hue='variable', ax=axes[i], alpha=0.8).set_title(f\"{loss} (C={c})\")\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 378 - }, - "id": "SrjMX-b9pVus", - "outputId": "9326400e-29fd-4f4f-efb4-6288377b4d75" - }, - "execution_count": 11, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_Monotonicity.ipynb b/examples_FEI/STAR2000_constraint_Monotonicity.ipynb deleted file mode 100644 index bd4a1aa..0000000 --- a/examples_FEI/STAR2000_constraint_Monotonicity.ipynb +++ /dev/null @@ -1,1118 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "g0aAqkkRKc6z", - "outputId": "06c1fb56-1382-4149-dde3-b26e56885079" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2rmdz0d2\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2rmdz0d2\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=38277498b08288819d7a48307b30d8730b6eb14a44a4d7599dce3f918735056d\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-kmjsudwd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "4ibK-1gsR0ZB" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, n_redundant=0, random_state=42)\n", - "y = 2*y - 1\n", - "X = scaler.fit_transform(X)" - ] - }, - { - "cell_type": "markdown", - "source": [ - "#SVM as baseline" - ], - "metadata": { - "id": "Oak-k1Ps9hDS" - } - }, - { - "cell_type": "code", - "source": [ - "## we first run a SVM\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=0.001, max_iter=10000)\n", - "clf.fit(X=X, y=y)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "Uk31Pe_cg702", - "outputId": "b0a34980-ffd2-44a1-dcd6-d7232221510e" - }, - "execution_count": 3, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)" - ], - "text/html": [ - "
plq_Ridge_Classifier(C=0.001, loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 3 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "#Monotonic constraint" - ], - "metadata": { - "id": "OU3yWxlR9d29" - } - }, - { - "cell_type": "code", - "source": [ - "## solve SVM with Monotonicity Constraint via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Classifier\n", - "mclf = plq_Ridge_Classifier(\n", - " loss={'name': 'svm'},\n", - " constraint = [{'name': 'monotonic', 'decreasing': True}],\n", - " C=0.001,\n", - " max_iter=10000\n", - ")\n", - "mclf.fit(X=X, y=y)" - ], - "metadata": { - "id": "APrF6OYJl1_t", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 114 - }, - "outputId": "c90e1964-a77b-4d24-a0e6-0f41a06a92d9" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(C=0.001,\n", - " constraint=[{'decreasing': True, 'name': 'monotonic'}],\n", - " loss={'name': 'svm'}, max_iter=10000)" - ], - "text/html": [ - "
plq_Ridge_Classifier(C=0.001,\n",
-              "                     constraint=[{'decreasing': True, 'name': 'monotonic'}],\n",
-              "                     loss={'name': 'svm'}, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "#Results" - ], - "metadata": { - "id": "GbDGb79w9aOh" - } - }, - { - "cell_type": "code", - "source": [ - "import pandas as pd\n", - "##score\n", - "score = clf.decision_function(X)\n", - "mscore = mclf.decision_function(X)\n", - "\n", - "svm_perf = len(y[score*y > 0])/ n\n", - "msvm_perf = len(y[mscore*y > 0])/ n\n", - "\n", - "# Create a pandas DataFrame to store the results\n", - "results = pd.DataFrame({\n", - " 'Model': ['SVM', 'MonotonicSVM'],\n", - " 'Train Performance': [svm_perf, msvm_perf]\n", - "})\n", - "\n", - "# Print the results as a table\n", - "print(results.to_string(index=False))\n", - "\n", - "#Print the results of monotonic constraint\n", - "print(\"\\nCoefficients (no constraint):\")\n", - "print(clf.coef_)\n", - "print(\"\\nCoefficients (monotonic increasing):\")\n", - "print(mclf.coef_)\n", - "print(\"Monotonic descreasing satisfied:\",\n", - " np.all(mclf.coef_[:-1] >= mclf.coef_[1:]))" - ], - "metadata": { - "id": "fDmbka9Wx-jd", - "colab": { - "base_uri": "https://localhost:8080/" - }, - "outputId": "4b2f868f-fdf0-45d0-de3a-0c62b1116f5d" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Model Train Performance\n", - " SVM 0.8870\n", - "MonotonicSVM 0.7332\n", - "\n", - "Coefficients (no constraint):\n", - "[-0.00464203 1.30915325 0.11882663 -0.02067285 0.00381067]\n", - "\n", - "Coefficients (monotonic increasing):\n", - "[ 0.6899007 0.68988743 0.05962067 -0.01259596 -0.01275567]\n", - "Monotonic descreasing satisfied: True\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "import seaborn as sns\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "df = pd.DataFrame({'score': score, 'mscore': mscore, 'y': y})\n", - "\n", - "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", - "plt.show()\n", - "sns.histplot(df, x=\"mscore\", hue=\"y\").set_title(\"Monotonic SVM\")\n", - "plt.show()" - ], - "metadata": { - "id": "GmOPIjrhyAZ3", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 885 - }, - "outputId": "c70e7404-5c70-49a2-b5d0-dde4a5dbcc99" - }, - "execution_count": 8, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_custom.ipynb b/examples_FEI/STAR2000_constraint_custom.ipynb deleted file mode 100644 index b8b5102..0000000 --- a/examples_FEI/STAR2000_constraint_custom.ipynb +++ /dev/null @@ -1,1134 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "350gRKl8oZO8", - "outputId": "9c10c6b4-3bd4-4b8d-8fef-7a0e794a21ba" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ecam8nvm\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ecam8nvm\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=afb3663e756869bae441a557cc1076d200b509a9bcedfa3e89973806add3d6e3\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-ojkpm13e/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "MbOVhGJWC1bM" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", - "X = scaler.fit_transform(X)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "FGHO9F1QZK5M" - }, - "outputs": [], - "source": [ - "# Example: beta_0 + beta_1 >= 3\n", - "A = np.zeros((1, d))\n", - "A[0, 0] = 1\n", - "A[0, 1] = 1\n", - "b = np.array([-3.0])" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "jAQHQ9HRcbzd" - }, - "source": [ - "#QR as baseline" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "F4kiv_VqJF6t", - "outputId": "1d12d12d-fee1-4273-8d89-2980b4a80d2d" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)" - ], - "text/html": [ - "
plq_Ridge_Regressor(fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 5 - } - ], - "source": [ - "## we first run a QR\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf = plq_Ridge_Regressor(\n", - " loss={'name': 'QR', 'qt': 0.5},\n", - " C=1.0,\n", - " max_iter=10000,\n", - " fit_intercept=False\n", - ")\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NHjMQ-vnclTL" - }, - "source": [ - "#Custom Constraint" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 114 - }, - "id": "beKf5mp-R3_5", - "outputId": "43fdfed2-38da-42a5-dcdc-88427e06a1fb" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n", - " 'b': array([-3.]), 'name': 'custom'}],\n", - " fit_intercept=False, max_iter=10000)" - ], - "text/html": [ - "
plq_Ridge_Regressor(constraint=[{'A': array([[1., 1., 0., 0., 0.]]),\n",
-              "                                 'b': array([-3.]), 'name': 'custom'}],\n",
-              "                    fit_intercept=False, max_iter=10000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 7 - } - ], - "source": [ - "## solve custom via `plq_Ridge_Regressor` by adding `constraint`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "cclf = plq_Ridge_Regressor(\n", - " loss={'name': 'QR', 'qt': 0.5},\n", - " constraint=[{'name': 'custom', 'A': A, 'b': b}],\n", - " C=1.0,\n", - " max_iter=10000,\n", - " fit_intercept=False\n", - ")\n", - "cclf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "zQOfvMjRR6Fn", - "outputId": "a7964e49-afd3-4f1a-d4b5-38a55b214dfc" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Model Train MSE\n", - " QR 0.000097\n", - "Custom QR 1.352705\n", - "\n", - "coef_0 + coef_1 = 3.00000008, >= 3: True\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "## score\n", - "score = clf.predict(X)\n", - "cscore = cclf.predict(X)\n", - "\n", - "qr_perf = np.mean((y - score)**2)\n", - "cqr_perf = np.mean((y - cscore)**2)\n", - "\n", - "# Create a pandas DataFrame to store the results\n", - "results = pd.DataFrame({\n", - " 'Model': ['QR', 'Custom QR'],\n", - " 'Train MSE': [qr_perf, cqr_perf]\n", - "})\n", - "\n", - "# Print the results as a table\n", - "print(results.to_string(index=False))\n", - "#Print the results of custom constraint\n", - "lhs = cclf.coef_[0] + cclf.coef_[1]\n", - "print(f\"\\ncoef_0 + coef_1 = {lhs:.8f}, >= 3: {lhs >= 3}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 884 - }, - "id": "zWGh56JmZ00l", - "outputId": "9809836c-af7d-4461-fb3d-05bf25ae7908" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "qr_sample = clf.predict(X_sample)\n", - "cqr_sample = cclf.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({\n", - " 'x0': X_sample[:, 0],\n", - " 'real_y': y_sample,\n", - " 'QR': qr_sample,\n", - " 'Custom_QR': cqr_sample\n", - "})\n", - "\n", - "df1 = df[['x0', 'real_y', 'QR']].melt(id_vars='x0')\n", - "sns.scatterplot(data=df1, x='x0', y='value', hue='variable').set_title(\"QR\")\n", - "plt.show()\n", - "df2 = df[['x0', 'real_y', 'Custom_QR']].melt(id_vars='x0')\n", - "sns.scatterplot(data=df2, x='x0', y='value', hue='variable').set_title(\"Custom QR\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_constraint_fairness.ipynb b/examples_FEI/STAR2000_constraint_fairness.ipynb deleted file mode 100644 index 1e782f7..0000000 --- a/examples_FEI/STAR2000_constraint_fairness.ipynb +++ /dev/null @@ -1,1120 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "CdpIoLwYNrOE", - "outputId": "4f08447f-8eac-4a9b-fab2-348e48c3f162" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-aslp0p5z\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-aslp0p5z\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e70f4bd1f1915f6a955fc096395a6757bc4c0b710df4f11b2be6f22239334ed7\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-5e872vry/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "FcaI-p84K6m4" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, n_redundant=2, random_state=42)\n", - "y = 2*y - 1\n", - "X = scaler.fit_transform(X)\n", - "\n", - "## we take the first column of X as sensitive features, and tol is 0.1\n", - "sen_idx = [0]\n", - "tol_sen = 0.1" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "VEQKzCdrM3ii" - }, - "source": [ - "#SVM as baseline" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "uUMv2d0ZM1X5", - "outputId": "204172ec-5440-4945-a18e-caf1695b6ef0" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)" - ], - "text/html": [ - "
plq_Ridge_Classifier(loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 3 - } - ], - "source": [ - "## we first run a SVM\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0, max_iter=50000)\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4S9GFijHNPCC" - }, - "source": [ - "#FairSVM" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 172 - }, - "id": "F17oa5oUNGed", - "outputId": "5977c594-17c7-4be0-a558-cb998a249fc8" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n", - " 'tol_sen': 0.1}],\n", - " loss={'name': 'svm'}, max_iter=50000)" - ], - "text/html": [ - "
plq_Ridge_Classifier(constraint=[{'name': 'fair', 'sen_idx': [0],\n",
-              "                                  'tol_sen': 0.1}],\n",
-              "                     loss={'name': 'svm'}, max_iter=50000)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ], - "source": [ - "## solve FairSVM via `plq_Ridge_Classifier` by adding `constraint`\n", - "fclf = plq_Ridge_Classifier(loss={'name': 'svm'},\n", - " constraint=[{'name': 'fair',\n", - " 'sen_idx': sen_idx,\n", - " 'tol_sen': tol_sen}],\n", - " C=1.0,\n", - " max_iter=50000)\n", - "fclf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "4PsZ5ASPO2lN" - }, - "source": [ - "#Results" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "WNhi1tI_NJc_", - "outputId": "b238f852-af11-49ed-d2c4-e3677e248a7c" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - " Model Train Performance Correlation with Sensitive Features\n", - " SVM 0.8927 2.417714\n", - "FairSVM 0.5278 0.100728\n" - ] - } - ], - "source": [ - "import pandas as pd\n", - "## score\n", - "X_sen = X[:, sen_idx]\n", - "score = clf.decision_function(X)\n", - "fscore = fclf.decision_function(X)\n", - "\n", - "svm_perf = len(y[score*y > 0])/n\n", - "fsvm_perf = len(y[fscore*y > 0])/n\n", - "\n", - "svm_corr = score.dot(X_sen) / n\n", - "fsvm_corr = fscore.dot(X_sen) / n\n", - "\n", - "# Create a pandas DataFrame to store the results\n", - "results = pd.DataFrame({\n", - " 'Model': ['SVM', 'FairSVM'],\n", - " 'Train Performance': [svm_perf, fsvm_perf],\n", - " 'Correlation with Sensitive Features': [svm_corr[0], fsvm_corr[0]]\n", - "})\n", - "\n", - "# Print the results as a table\n", - "print(results.to_string(index=False))" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 926 - }, - "id": "rKNP993vNMAo", - "outputId": "9df96109-c2d8-495d-a889-ff3cc61613f0" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHHCAYAAABZbpmkAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAOulJREFUeJzt3Xl4FeX9///XScjClhyTkA0JmwoECSAIHDcQIhHRQkEsmGKwiC0FFFOtoshmFcEFFEGsrVD7NbjUrQVBIRqxEhAjm2GpUDSQkITFrJAAyfz+8Mf5eEpIwsnZMnk+rutcF2fmnpn3nVzIy5l77ttiGIYhAAAAk/LzdgEAAADuRNgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgB0ChkZGTIYrEoIyPD26UAaGQIOwDcbuXKlbJYLDV+HnnkEbdcs7q6Wq+//rr69++vsLAwtW7dWldccYXuuusubd68WZJ03333yWKxaP/+/Rc8z2OPPSaLxaKdO3dKkjp06CCLxaLExMQa27/66qv2vn399deu7xiAi9bM2wUAaDrmzZunjh07Omy78sor63XsDTfcoFOnTikwMLBe7e+77z4tXbpUI0aMUHJyspo1a6Z9+/Zp7dq16tSpkwYMGKDk5GQtWbJEaWlpmjVrVo3nWbVqlXr06KGEhAT7tuDgYH322WfKz89XdHS0Q/s33nhDwcHBqqioqFedANyPsAPAY4YNG6a+ffs6dayfn5+Cg4PrbHfy5EmVlpZq2bJlmjRpkv785z877F+8eLGOHj0qSerfv78uu+wyrVq1qsawk5mZqYMHD+rpp5922H7ttddq69ateuutt3T//ffbtx8+fFhffPGFfvnLX+rdd991ppsA3IDHWAC86ocfftDvf/97denSRc2bN1d4eLjGjBmj77//3qFdTWN2Bg0apCuvvFJZWVm64YYb1KJFCz366KM6ePCgDMPQtddee971LBaLIiMj7d+Tk5O1d+9effPNN+e1TUtLk8Vi0bhx4xy2BwcHa9SoUUpLS3PYvmrVKl1yySVKSkpy4icBwF0IOwA8pri4WMeOHXP4bN26VZs2bdLYsWP14osv6ne/+53S09M1aNAgnTx5ss5zHj9+XMOGDVOvXr20ePFi3XjjjWrfvr0k6Z133qnzHMnJyZJ0XnCpqqrS22+/reuvv15xcXHnHXfnnXfqq6++0oEDB+zb0tLSdPvttysgIKDOugF4Do+xAHhMTYN6T548qdtvv91h22233SabzaZ3331X48ePr/Wc+fn5Wr58uX772986bL/rrrv0+uuv69JLL9WgQYN07bXXavjw4eratatDu8svv1xXX3213nrrLS1cuFB+fj/9P+CGDRtUWFioJ554osbrDh48WNHR0Vq1apVmzpypPXv2aPv27XrhhRf03//+t86fBQDP4c4OAI9ZunSp1q9f7/Bp3ry5ff+ZM2d0/PhxXXbZZbJarTU+WvpfQUFBuvvuu8/bvmLFCr300kvq2LGj3n//fT344IPq1q2bhgwZotzcXIe2v/71r3X48GFt3LjRvi0tLU2BgYEaM2ZMjdf19/fXHXfcoVWrVkn6aWByu3btdP3119frZwHAcwg7ADymX79+SkxMdPicOnVKs2bNUrt27RQUFKSIiAi1adNGRUVFKi4urvOcbdu2rfENLT8/P02ZMkVZWVk6duyYPvzwQw0bNkyffvqpxo4d69B27Nix8vf3tz/Kqqio0Pvvv69hw4bpkksuueC177zzTu3evVs7duxQWlqaxo4dK4vFcpE/FQDuRtgB4FXTpk3Tk08+qTvuuENvv/22PvnkE61fv17h4eGqrq6u8/if3xm6kPDwcP3iF7/QRx99pIEDB+rf//63fvjhB/v+yMhI3XTTTXr33Xd15swZ/etf/1Jpaal9PM+F9O/fX507d9b06dN18OBB3XnnnXV3GIDHEXYAeNU//vEPpaSk6LnnntPtt9+um266Sdddd52Kiorccr1zr74fOXLEYXtycrJOnDihtWvXKi0tTSEhIbrtttvqPN+4ceOUkZGhbt26qVevXu4oGUADMUAZgFf5+/vLMAyHbUuWLFFVVZXT58zPz9eJEycUHx/vsP306dNKT0+Xn5+fLrvsMod9I0eOVIsWLbRs2TJlZGRo3Lhx9ZrX55577pG/v7/69+/vdL0A3IuwA8Crbr31Vv39739XaGio4uPjlZmZqQ0bNig8PNzpcx4+fFj9+vXT4MGDNWTIEEVHR6uwsFCrVq3Sjh07NH36dEVERDgc06pVK40cOdI+bqeuR1jntG/fXnPmzHG6VgDuR9gB4FUvvPCC/P399cYbb6iiokLXXnutNmzY0KCJ+bp06aLFixfro48+0rJly1RQUKDg4GBdeeWVevXVVzVx4sQaj0tOTlZaWppiYmI0ePBgp68PwLdYjP+9fwwAAGAiDFAGAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACm5tV5dubMmaO5c+c6bOvSpYv27t0r6afF+P7whz/ozTffVGVlpZKSkrRs2TJFRUXZ2+fk5Gjy5Mn67LPP1KpVK6WkpGj+/Plq1qz+XauurlZeXp5at27NIn4AADQShmGotLRUsbGx8vO78P0br08q2L17d23YsMH+/ech5YEHHtCaNWv0zjvvKDQ0VFOnTtWoUaP05ZdfSpKqqqo0fPhwRUdHa9OmTTpy5IjuuusuBQQE6Kmnnqp3DXl5eWrXrp3rOgUAADzm0KFDuvTSSy+436uTCs6ZM0cffPCBtm/fft6+4uJitWnTRmlpabr99tslSXv37lW3bt2UmZmpAQMGaO3atbr11luVl5dnv9uzfPlyPfzwwzp69KgCAwPrVUdxcbGsVqsOHTqkkJAQl/UPAAC4T0lJidq1a6eioiKFhoZesJ3X7+x89913io2NVXBwsGw2m+bPn6+4uDhlZWXpzJkzSkxMtLft2rWr4uLi7GEnMzNTPXr0cHislZSUpMmTJys7O1u9e/eu8ZqVlZWqrKy0fy8tLZUkhYSEEHYAAGhk6hqC4tUByv3799fKlSu1bt06vfzyyzp48KCuv/56lZaWKj8/X4GBgbJarQ7HREVFKT8/X9JPKxv/POic239u34XMnz9foaGh9g+PsAAAMC+v3tkZNmyY/c8JCQnq37+/2rdvr7ffflvNmzd323VnzJih1NRU+/dzt8EAAID5+NSr51arVVdccYX279+v6OhonT59WkVFRQ5tCgoKFB0dLUmKjo5WQUHBefvP7buQoKAg+yMrHl0BAGBuXh+z83NlZWU6cOCAxo8frz59+iggIEDp6ekaPXq0JGnfvn3KycmRzWaTJNlsNj355JMqLCxUZGSkJGn9+vUKCQlRfHy81/oBAIA7VFVV6cyZM94uw2MCAgLk7+/f4PN4New8+OCDuu2229S+fXvl5eVp9uzZ8vf317hx4xQaGqqJEycqNTVVYWFhCgkJ0bRp02Sz2TRgwABJ0tChQxUfH6/x48dr4cKFys/P18yZMzVlyhQFBQV5s2sAALiMYRjKz88/72lHU2C1WhUdHd2gefC8GnYOHz6scePG6fjx42rTpo2uu+46bd68WW3atJEkLVq0SH5+fho9erTDpILn+Pv7a/Xq1Zo8ebJsNptatmyplJQUzZs3z1tdAgDA5c4FncjISLVo0aJJTIBrGIZOnjypwsJCSVJMTIzT5/LqPDu+oqSkRKGhoSouLmb8DgDAp1RVVek///mPIiMjFR4e7u1yPO748eMqLCzUFVdccd4jrfr+++1TA5QBAICjc2N0WrRo4eVKvONcvxsyVomwAwBAI9AUHl3VxBX9JuwAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAAAHr7/+usLDw1VZWemwfeTIkRo/fryXqnIeYQcAADgYM2aMqqqq9M9//tO+rbCwUGvWrNFvfvMbL1bmHJ9aGwsAzKhnQoJyc3NrbdO2bVvt2LnTQxUBtWvevLnuvPNOrVixQmPGjJEk/b//9/8UFxenQYMGebc4JxB2AMDNcnNzlZNde5CJ657goWqA+pk0aZKuvvpq5ebmqm3btlq5cqUmTJjQKOf7IewAAIDz9O7dWz179tTrr7+uoUOHKjs7W2vWrPF2WU4h7AAAgBrdc889Wrx4sXJzc5WYmKh27dp5uySnMEAZAADU6M4779Thw4f16quvNsqByecQdgAAQI1CQ0M1evRotWrVSiNHjvR2OU4j7AAAgAvKzc1VcnKygoKCvF2K0xizAwAAzvPjjz8qIyNDGRkZWrZsmbfLaRDCDgAAOE/v3r31448/asGCBerSpYu3y2kQwg4AADjP999/7+0SXIYxOwAAwNQIOwAAwNQIOwAAwNQYswMAPqC8vFwR4eG1tmGxUMA5hB0A8AFV1VUsFgq4CY+xAACAqXFnBwCARionJ0fHjh3zyLUiIiIUFxfnkWu5GmEHAIBGKCcnR926ddPJkyc9cr0WLVpoz549DQo87733npYvX66srCydOHFC27ZtU69evVxX5AUQdgAAaISOHTumkydP6q8vvagul1/u1mvt++47TZx6n44dO9agsFNeXq7rrrtOd9xxhyZNmuTCCmtH2AEAoBHrcvnl6p3Qw9tl1Mv48eMleX52ZgYoAwAAUyPsAAAAUyPsAAAAl3vjjTfUqlUr++eLL77wWi2M2QEAAC73i1/8Qv3797d/b9u2rddqIewAAACXa926tVq3bu3tMiQRdgAAgIecOHFCOTk5ysvLkyTt27dPkhQdHa3o6Gi3XZewAwBAI7bvu+8azTX++c9/6u6777Z/Hzt2rCRp9uzZmjNnjkuuURPCDgAAjVBERIRatGihiVPv88j1WrRooYiIiAadY8KECZowYYJrCroIhB0AABqhuLg47dmzh7Wx6oGwAwBAIxUXF9doA4gnMc8OAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNV49B4BGory8XBHh4bW2adu2rXbs3OmhioDGgbADAI1EVXWVcrJrDzJx3RM8VA18QU5ODpMK1gNhBwCARignJ0ddu3bVqVOnPHK95s2ba+/evRcVeDZu3KhnnnlGWVlZOnLkiN5//32NHDnSfUVeAGEHAIBG6NixYzp16pRSkicpOirWrdfKL8jT3954VceOHbuosFNeXq6ePXvqN7/5jUaNGuXGCmtH2AEAoBGLjopV3KXtvV1GjYYNG6Zhw4Z5uwzexgIAAOZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKbG21gAAMAtysrKtH//fvv3gwcPavv27QoLC/PoBIWEHQAAGrH8gjyfvcbXX3+tG2+80f49NTVVkpSSkqKVK1e6orR6IewAANAIRUREqHnz5vrbG6965HrNmzdXRETERR0zaNAgGYbhporqj7ADAEAjFBcXp71797I2Vj0QdgAAaKTi4uIabQDxJN7GAgAApkbYAQAApkbYAQCgEfCFgb7e4Ip++0zYefrpp2WxWDR9+nT7toqKCk2ZMkXh4eFq1aqVRo8erYKCAofjcnJyNHz4cLVo0UKRkZF66KGHdPbsWQ9XDwCAewQEBEiSTp486eVKvONcv8/9HJzhEwOUt27dqldeeUUJCQkO2x944AGtWbNG77zzjkJDQzV16lSNGjVKX375pSSpqqpKw4cPV3R0tDZt2qQjR47orrvuUkBAgJ566ilvdAUAAJfy9/eX1WpVYWGhJKlFixayWCxersr9DMPQyZMnVVhYKKvVKn9/f6fP5fWwU1ZWpuTkZL366qv605/+ZN9eXFysv/71r0pLS9PgwYMlSStWrFC3bt20efNmDRgwQJ988ol2796tDRs2KCoqSr169dITTzyhhx9+WHPmzFFgYKC3ugUAgMtER0dLkj3wNCVWq9Xef2d5PexMmTJFw4cPV2JiokPYycrK0pkzZ5SYmGjf1rVrV8XFxSkzM1MDBgxQZmamevTooaioKHubpKQkTZ48WdnZ2erdu3eN16ysrFRlZaX9e0lJiRt6BgCAa1gsFsXExCgyMlJnzpzxdjkeExAQ0KA7Oud4Ney8+eab+uabb7R169bz9uXn5yswMFBWq9Vhe1RUlPLz8+1tfh50zu0/t+9C5s+fr7lz5zawegAAPMvf398l//g3NV4boHzo0CHdf//9euONNxQcHOzRa8+YMUPFxcX2z6FDhzx6fQAA4DleCztZWVkqLCzUVVddpWbNmqlZs2b6/PPP9eKLL6pZs2aKiorS6dOnVVRU5HBcQUGB/dlddHT0eW9nnfte2/O9oKAghYSEOHwAAIA5eS3sDBkyRLt27dL27dvtn759+yo5Odn+54CAAKWnp9uP2bdvn3JycmSz2SRJNptNu3btchiwtX79eoWEhCg+Pt7jfQIAAL7Ha2N2WrdurSuvvNJhW8uWLRUeHm7fPnHiRKWmpiosLEwhISGaNm2abDabBgwYIEkaOnSo4uPjNX78eC1cuFD5+fmaOXOmpkyZoqCgII/3CQAA+B6vv41Vm0WLFsnPz0+jR49WZWWlkpKStGzZMvt+f39/rV69WpMnT5bNZlPLli2VkpKiefPmebFqAADgSyxGU51/+mdKSkoUGhqq4uJixu8AcLmI8HDlZO+stY01roOKcr5vcJu47gk6dvz4RVYINE71/ffbZ5aLAAAAcAfCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMDXCDgAAMLVm3i4AABqzngkJys3NrbVNWVmZh6oBUBPCDgA0QG5urnKyd9baxhrXwTPFAKgRj7EAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpeTXsvPzyy0pISFBISIhCQkJks9m0du1a+/6KigpNmTJF4eHhatWqlUaPHq2CggKHc+Tk5Gj48OFq0aKFIiMj9dBDD+ns2bOe7goAAPBRXg07l156qZ5++mllZWXp66+/1uDBgzVixAhlZ2dLkh544AH961//0jvvvKPPP/9ceXl5GjVqlP34qqoqDR8+XKdPn9amTZv0t7/9TStXrtSsWbO81SUAAOBjLIZhGN4u4ufCwsL0zDPP6Pbbb1ebNm2Ulpam22+/XZK0d+9edevWTZmZmRowYIDWrl2rW2+9VXl5eYqKipIkLV++XA8//LCOHj2qwMDAel2zpKREoaGhKi4uVkhIiNv6BsB8IsLDlZO9s9Y21rgOKsr53iNt4ron6Njx47W2Acyivv9++8yYnaqqKr355psqLy+XzWZTVlaWzpw5o8TERHubrl27Ki4uTpmZmZKkzMxM9ejRwx50JCkpKUklJSX2u0MAAKBpa+btAnbt2iWbzaaKigq1atVK77//vuLj47V9+3YFBgbKarU6tI+KilJ+fr4kKT8/3yHonNt/bt+FVFZWqrKy0v69pKTERb0BAAC+xut3drp06aLt27dry5Ytmjx5slJSUrR79263XnP+/PkKDQ21f9q1a+fW6wEAAO/xetgJDAzUZZddpj59+mj+/Pnq2bOnXnjhBUVHR+v06dMqKipyaF9QUKDo6GhJUnR09HlvZ537fq5NTWbMmKHi4mL759ChQ67tFAAA8BleDzv/q7q6WpWVlerTp48CAgKUnp5u37dv3z7l5OTIZrNJkmw2m3bt2qXCwkJ7m/Xr1yskJETx8fEXvEZQUJD9dfdzHwAAYE5eHbMzY8YMDRs2THFxcSotLVVaWpoyMjL08ccfKzQ0VBMnTlRqaqrCwsIUEhKiadOmyWazacCAAZKkoUOHKj4+XuPHj9fChQuVn5+vmTNnasqUKQoKCvJm1wAAgI/watgpLCzUXXfdpSNHjig0NFQJCQn6+OOPddNNN0mSFi1aJD8/P40ePVqVlZVKSkrSsmXL7Mf7+/tr9erVmjx5smw2m1q2bKmUlBTNmzfPW10CAAA+xufm2fEG5tkB4Czm2QG8p9HNswMAAOAOhB0AAGBqhB0AAGBqhB0AAGBqXl8uAgDgOuXl5YoID6+zXdu2bbVjZ+0DqwGzIOwAgIlUVVfV+XaY9NNbW0BTwWMsAABgaoQdAABgaoQdAABgaoQdAABgaoQdAABgak6FnU6dOul4DWuvFBUVqVOnTg0uCgAAwFWcCjvff/+9qqqqztteWVmp3NzcBhcFAADgKhc1z84///lP+58//vhjhYaG2r9XVVUpPT1dHTp0cFlxAAAADXVRYWfkyJGSJIvFopSUFId9AQEB6tChg5577jmXFQcAANBQFxV2qqurJUkdO3bU1q1bFRER4ZaiAAAAXMWp5SIOHjzo6joAAADcwum1sdLT05Wenq7CwkL7HZ9zXnvttQYXBgAA4ApOhZ25c+dq3rx56tu3r2JiYmSxWFxdFwAAgEs4FXaWL1+ulStXavz48a6uBwB8Qs+EhHpNpVFWVuaBagA0hFNh5/Tp07rmmmtcXQsA+Izc3FzlZO+ss501roP7iwHQIE5NKnjPPfcoLS3N1bUAAAC4nFN3dioqKvTnP/9ZGzZsUEJCggICAhz2P//88y4pDgAAoKGcCjs7d+5Ur169JEnffvutwz4GKwMAAF/iVNj57LPPXF0HAACAWzg1ZgcAAKCxcOrOzo033ljr46pPP/3U6YIAAABcyamwc268zjlnzpzR9u3b9e233563QCgAAIA3ORV2Fi1aVOP2OXPmMMEWAADwKU6vjVWTX//61+rXr5+effZZV54WAOBiZWVlslovqbVNbGysdu/OrrVNfHx35eXlNfg8gDu5NOxkZmYqODjYlacEALhBdXW1nppd+5xoj85NrfM8eXl5LjkP4E5OhZ1Ro0Y5fDcMQ0eOHNHXX3+txx9/3CWFAQAAuIJTYSc0NNThu5+fn7p06aJ58+Zp6NChLikMAADAFZwKOytWrHB1HQAAAG7RoDE7WVlZ2rNnjySpe/fu6t27t0uKAgAAcBWnwk5hYaHGjh2rjIwMWa1WSVJRUZFuvPFGvfnmm2rTpo0rawTQBPBWj+8pKy2t842tstJSD1UDOM+psDNt2jSVlpYqOztb3bp1kyTt3r1bKSkpuu+++7Rq1SqXFgnA/Hirx/dUG0adv5Opf7jHQ9UAznMq7Kxbt04bNmywBx1Jio+P19KlSxmgDAAAfIpTYae6uloBAQHnbQ8ICFB1dXWDiwIAnM8wpAULFtTZBoAjp8LO4MGDdf/992vVqlWKjY2VJOXm5uqBBx7QkCFDXFogAOD/DBmYVOv+p1562UOVAI2HnzMHvfTSSyopKVGHDh3UuXNnde7cWR07dlRJSYmWLFni6hoBAACc5tSdnXbt2umbb77Rhg0btHfvXklSt27dlJiY6NLiAAAXr65HXZLE0y40JRcVdj799FNNnTpVmzdvVkhIiG666SbddNNNkqTi4mJ1795dy5cv1/XXX++WYgEAdavrUZfE4y40LRf1GGvx4sWaNGmSQkJCztsXGhqq3/72t3r++dpfUwQAAPCki7qzs2PHjlpvjw4dOlTPPvtsg4sCYB71mSxQYnI6AO5zUWGnoKCgxlfO7Sdr1kxHjx5tcFEAzKM+kwVKTE4HwH0u6jFW27Zt9e23315w/86dOxUTE9PgogAAAFzlou7s3HLLLXr88cd18803Kzg42GHfqVOnNHv2bN16660uLRAA0LjVZ40t1j2DO11U2Jk5c6bee+89XXHFFZo6daq6dOkiSdq7d6+WLl2qqqoqPfbYY24pFADQONVnjS3WPYM7XVTYiYqK0qZNmzR58mTNmDFDxv8/L7nFYlFSUpKWLl2qqKgotxQKAADgjIueVLB9+/b66KOP9OOPP2r//v0yDEOXX365Lrmk9luUAAAA3uDUDMqSdMkll+jqq692ZS0AAAAu53TYAQBPY6ArAGcQdgA4rT4TBrpyskAGugJwBmEHgNPqM2EgkwUC8DbCDgC4mWHUvRK5wTLkgNsQdgDAA+paiZxVyAH3uajlIgAAABobwg4AADA1wg4AADA1wg4AADA1wg4AADA13sYCAB9R1+vpAJzj1Ts78+fP19VXX63WrVsrMjJSI0eO1L59+xzaVFRUaMqUKQoPD1erVq00evRoFRQUOLTJycnR8OHD1aJFC0VGRuqhhx7S2bNnPdkVAGiwIQOTav0AcI5Xw87nn3+uKVOmaPPmzVq/fr3OnDmjoUOHqry83N7mgQce0L/+9S+98847+vzzz5WXl6dRo0bZ91dVVWn48OE6ffq0Nm3apL/97W9auXKlZs2a5Y0uAQAAH+PVx1jr1q1z+L5y5UpFRkYqKytLN9xwg4qLi/XXv/5VaWlpGjx4sCRpxYoV6tatmzZv3qwBAwbok08+0e7du7VhwwZFRUWpV69eeuKJJ/Twww9rzpw5CgwM9EbXAACAj/CpAcrFxcWSpLCwMElSVlaWzpw5o8TERHubrl27Ki4uTpmZmZKkzMxM9ejRQ1FRUfY2SUlJKikpUXZ2zSsfV1ZWqqSkxOEDwFF8fHdZrZfU+nHlIp8A4C4+M0C5urpa06dP17XXXqsrr7xSkpSfn6/AwEBZrVaHtlFRUcrPz7e3+XnQObf/3L6azJ8/X3PnznVxDwBzYZFPAGbhM3d2pkyZom+//VZvvvmm2681Y8YMFRcX2z+HDh1y+zUBAIB3+MSdnalTp2r16tXauHGjLr30Uvv26OhonT59WkVFRQ53dwoKChQdHW1v89VXXzmc79zbWufa/K+goCAFBQW5uBcAfEFZaams1ktqbRMbG6vdu2t+zA3AfLwadgzD0LRp0/T+++8rIyNDHTt2dNjfp08fBQQEKD09XaNHj5Yk7du3Tzk5ObLZbJIkm82mJ598UoWFhYqMjJQkrV+/XiEhIYqPj/dshwB4XbVh1Pn47dG5qR6qBoAv8GrYmTJlitLS0vThhx+qdevW9jE2oaGhat68uUJDQzVx4kSlpqYqLCxMISEhmjZtmmw2mwYMGCBJGjp0qOLj4zV+/HgtXLhQ+fn5mjlzpqZMmcLdGwAA4N2w8/LLL0uSBg0a5LB9xYoVmjBhgiRp0aJF8vPz0+jRo1VZWamkpCQtW7bM3tbf31+rV6/W5MmTZbPZ1LJlS6WkpGjevHme6gYAAPBhXn+MVZfg4GAtXbpUS5cuvWCb9u3b66OPPnJlaQAAwCR85m0sAAAAdyDsAAAAUyPsAAAAUyPsAAAAUyPsAAAAU/OJGZQBwJPqM8tyxamTHqoGgLsRdgA0OfWZZXn6H+/1UDUA3I2wAzRB8fHdlZeXV2ubstJSD1UDAO5F2AGaoLy8vDrvbEz9wz0eqgYA3IsBygAAwNQIOwAAwNR4jAU0Ej0TEpSbm1tnu7Zt22rHzp0eqEhq5u+nR2bdX2cbAPAmwg7QSOTm5ionu+4QE9c9wQPV/MSQtPrvq2ptM2TMSI/UAgAXQtgB0OTU546U4aFaALgfYQdAk8MdKaBp4WE6AAAwNcIOAAAwNcIOAAAwNcIOAAAwNQYoAwC8rj4r0UtSbGysdu/O9kBFMBPCDgDA6+qzEr0kPTo31QPVwGwIOwBwAQsWLKizjcGEPIDPI+wAwAUMGZhUZ5unXnrZA5UAaAgGKAMAAFPjzg6AGtVnSQUAaAwIO4DJlJeXKyI8vNY2p06W12ttKJZUAGAGhB3AZKqqq+pcHT20XQeCDIAmg7ADAA1Un7e2AHgPYQcAGqiut7Z4YwvwLt7GAgAApsadHcDNeiYkKDc3t9Y2bdu21Y6dtY+zqS/D4LEKAPwcYQdws9zc3DoHDId36FznG1RlZWX1viaPVQDg/xB2AB9QnzeorHEdPFMMAJgMY3YAAICpEXYAAICp8RgLAJogP4ulzlm0m/nz/8MwB8IO0AD1edPqYgYWA55SbRjMoo0mg7ADNEB93rRiYDEAeBf3KAEAgKkRdgAAgKkRdgAAgKkRdgAAgKkRdgAAgKnxNhbQSLDAJwA4h7ADNCJ1LfApscgnzK2stFRW6yW1tomNjdXu3dkeqgiNAWEHANBoVBuGnpr9fK1tHp2b6qFq0FgwZgcAAJgad3YANBrN/P3qXM8poJl/nW0ANC2EHQA+oT5BxpDqtZ4Taz4B+DnCDgCfUN8gAwAXizE7AADA1Ag7AADA1HiMBcCt/CwWBgwD8CrCDgC3qjaMOsfiSIzHAeA+PMYCAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACmRtgBAACm5tWws3HjRt12222KjY2VxWLRBx984LDfMAzNmjVLMTExat68uRITE/Xdd985tDlx4oSSk5MVEhIiq9WqiRMnqqyszIO9AAAAvsyrYae8vFw9e/bU0qVLa9y/cOFCvfjii1q+fLm2bNmili1bKikpSRUVFfY2ycnJys7O1vr167V69Wpt3LhR9957r6e6gEaoZ0KCIsLD6/z0TEjwdqkAABfw6nIRw4YN07Bhw2rcZxiGFi9erJkzZ2rEiBGSpNdff11RUVH64IMPNHbsWO3Zs0fr1q3T1q1b1bdvX0nSkiVLdMstt+jZZ59VbGysx/qCxiM3N1c52TvrbBfXnbADAGbgs2N2Dh48qPz8fCUmJtq3hYaGqn///srMzJQkZWZmymq12oOOJCUmJsrPz09btmy54LkrKytVUlLi8AEAAObkswuB5ufnS5KioqIctkdFRdn35efnKzIy0mF/s2bNFBYWZm9Tk/nz52vu3LkurhhwnmFICxYs8HYZAGBKPht23GnGjBlKTU21fy8pKVG7du28WBEgDRmYVOv+p1562UOVAI1bWWmprNZLam0TGxur3buzPVQRvM1nw050dLQkqaCgQDExMfbtBQUF6tWrl71NYWGhw3Fnz57ViRMn7MfXJCgoSEFBQa4vGgDgddWGoadmP19rm0fnpta6H+bis2N2OnbsqOjoaKWnp9u3lZSUaMuWLbLZbJIkm82moqIiZWVl2dt8+umnqq6uVv/+/T1eMwAA8D1evbNTVlam/fv3278fPHhQ27dvV1hYmOLi4jR9+nT96U9/0uWXX66OHTvq8ccfV2xsrEaOHClJ6tatm26++WZNmjRJy5cv15kzZzR16lSNHTuWN7EAAIAkL4edr7/+WjfeeKP9+7lxNCkpKVq5cqX++Mc/qry8XPfee6+Kiop03XXXad26dQoODrYf88Ybb2jq1KkaMmSI/Pz8NHr0aL344ose7wsAAPBNXg07gwYNkmEYF9xvsVg0b948zZs374JtwsLClJaW5o7yAACACfjsmB0AAABX8Nm3sQBvKy8vV0R4eK1tWIcNAHwfYQe4gKrqqjqXlbDGdfBMMYAX+FksemTW/bW2aebPAwL4PsIOAKBG1Yah1X9fVWubIWNGeqYYoAEIOzCVngkJys3NrbUNj54AoGkh7MBU6rOiOY+eAKBp4WErAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNVY9BwA0OWWlpbJaL6m1TWxsrHbvzvZQRXAnwg4AoMmpNgw9Nfv5Wts8OjfVQ9XA3Qg7aDR6JiQoNze31jZlZWUeqgYA0FgQdtBo5ObmKid7Z61trHEdPFMMAKDRIOwAbmYY0oIFC7xdBgA0WYQdwAOGDEyqdf9TL73soUoAoOnh1XMAAGBqhB0AAGBqhB0AAGBqjNmB29XnlfG2bdtqx87a37QCAMAZhB24XX1eGY/rnuChagAATQ2PsQAAgKkRdgAAgKnxGAtoACYMBADfR9gBGogJAwHAtxF2AACoQVlpqazWS2ptExsbq927sz1UEZxF2AEAoAbVhqGnZj9fa5tH56Z6qBo0BAOUAQCAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqfE2FnxCeXm5IsLDa21TVlbmoWoAAGZC2IFPqKquqnOxUGtcB88UAwAwFcIOAMBpfhaLHpl1f61tmvmbd8REfSYelJh80NsIO3Baz4QE5ebm1tmOx0+AeVUbhlb/fVWtbYaMGemZYrygPhMPSkw+6G2EHTgtNze3zkdPEo+fAADeZd57iwAAACLsAAAAk+MxFpocw5AWLFjgsnYAAN9G2EGTNGRgUp1tnnrp5TrbPfXSy64qCQDgJjzGAgAApsadHdSoPq+V80o5AKAxIOygRvV5rZxXygEAjQGPsQAAgKkRdgAAgKkRdgAAgKkxZgcA4FZNfbFQeB9hB6bCRICA72nqi4XC+wg7MB0mAgQA/BxhBwAANysrLZXVekmtbWJjY7V7d7aHKmpaCDsAALhZtWHoqdnP19rmvgcnEYjchLDTiNRnVuPKykoFBQXV2qZt27basbP2CQMBAJ5Vn0D06NxUD1VjLqYJO0uXLtUzzzyj/Px89ezZU0uWLFG/fv28XVa91CfESD8tz3Dih//W2sYa10EF+/fV2ia8Q2dFhIfXeS0AAMzAFGHnrbfeUmpqqpYvX67+/ftr8eLFSkpK0r59+xQZGenV2uq7xlRdIUZy3fIMVdVVjXIpCN60AgA4wxRh5/nnn9ekSZN09913S5KWL1+uNWvW6LXXXtMjjzzi1dpYY8q1eNMKQFPGQGfnNPqwc/r0aWVlZWnGjBn2bX5+fkpMTFRmZqYXKzO/+t5pMQzXnQuAOdVn4kFJCmjm75IJCpv5+zXKiQ5dNdBZkioqKhQcHFxrm/oEp/j47srLy2vwedyp0YedY8eOqaqqSlFRUQ7bo6KitHfv3hqPqaysVGVlpf17cXGxJKmkpMTl9VUbhkpKS2ttY9SjTX3bebrNgKuvr7XNT+2Wad68Jxp8LsNYpvKTJ+s8jyvauPJcnmzjizVRt++18cWaqqqr9dYrf621jSTddte4OtuNSLlTDz9+X61tqg3DJefx97PoVMWpWttIP/0M6mrnqjZV1dV6/OEn66zpwUen6snZz9XaZt7Tj9b5b2Nubq5mPfJUg8/jjHPnNOr6v2qjkcvNzTUkGZs2bXLY/tBDDxn9+vWr8ZjZs2cbkvjw4cOHDx8+JvgcOnSo1qzQ6O/sREREyN/fXwUFBQ7bCwoKFB0dXeMxM2bMUGrq/72+V11drRMnTig8PFwWi8Wt9XpDSUmJ2rVrp0OHDikkJMTb5XgUfafv9L3poO9Nr++GYai0tFSxsbG1tmv0YScwMFB9+vRRenq6Ro4cKemn8JKenq6pU6fWeExQUNB5c9FYrVY3V+p9ISEhTeovwc/Rd/re1NB3+t5UhIaG1tmm0YcdSUpNTVVKSor69u2rfv36afHixSovL7e/nQUAAJouU4SdX/3qVzp69KhmzZql/Px89erVS+vWrTtv0DIAAGh6TBF2JGnq1KkXfGzV1AUFBWn27Nl1LiNhRvSdvjc19J2+43wWw6jPLCgAAACNk+/NmAQAAOBChB0AAGBqhB0AAGBqhB0AAGBqhB0TevLJJ3XNNdeoRYsW9Z4sccKECbJYLA6fm2++2b2FuoEzfTcMQ7NmzVJMTIyaN2+uxMREfffdd+4t1E1OnDih5ORkhYSEyGq1auLEiSorK6v1mEGDBp33u//d737noYqdt3TpUnXo0EHBwcHq37+/vvrqq1rbv/POO+ratauCg4PVo0cPffTRRx6q1PUupu8rV6487/db1+KPvmjjxo267bbbFBsbK4vFog8++KDOYzIyMnTVVVcpKChIl112mVauXOn2Ot3hYvuekZFx3u/cYrEoPz/fMwX7IMKOCZ0+fVpjxozR5MmTL+q4m2++WUeOHLF/Vq1a5aYK3ceZvi9cuFAvvviili9fri1btqhly5ZKSkpSRUWFGyt1j+TkZGVnZ2v9+vVavXq1Nm7cqHvvvbfO4yZNmuTwu1+4cKEHqnXeW2+9pdTUVM2ePVvffPONevbsqaSkJBUWFtbYftOmTRo3bpwmTpyobdu2aeTIkRo5cqS+/fZbD1fecBfbd+mnWXV//vv94YcfPFixa5SXl6tnz55aunRpvdofPHhQw4cP14033qjt27dr+vTpuueee/Txxx+7uVLXu9i+n7Nv3z6H33tkZKSbKmwEXLIaJ3zSihUrjNDQ0Hq1TUlJMUaMGOHWejypvn2vrq42oqOjjWeeeca+raioyAgKCjJWrVrlxgpdb/fu3YYkY+vWrfZta9euNSwWi5Gbm3vB4wYOHGjcf//9HqjQdfr162dMmTLF/r2qqsqIjY015s+fX2P7O+64wxg+fLjDtv79+xu//e1v3VqnO1xs3y/mvwONhSTj/fffr7XNH//4R6N79+4O2371q18ZSUlJbqzM/erT988++8yQZPz4448eqakx4M4O7DIyMhQZGakuXbpo8uTJOn78uLdLcruDBw8qPz9fiYmJ9m2hoaHq37+/MjMzvVjZxcvMzJTValXfvn3t2xITE+Xn56ctW7bUeuwbb7yhiIgIXXnllZoxY4ZOnjzp7nKddvr0aWVlZTn8zvz8/JSYmHjB31lmZqZDe0lKSkpqdL9jZ/ouSWVlZWrfvr3atWunESNGKDs72xPlepVZfucN0atXL8XExOimm27Sl19+6e1yvMo0MyijYW6++WaNGjVKHTt21IEDB/Too49q2LBhyszMlL+/v7fLc5tzz7D/d2mRqKioRvd8Oz8//7zb1M2aNVNYWFitfbnzzjvVvn17xcbGaufOnXr44Ye1b98+vffee+4u2SnHjh1TVVVVjb+zvXv31nhMfn6+KX7HzvS9S5cueu2115SQkKDi4mI9++yzuuaaa5Sdna1LL73UE2V7xYV+5yUlJTp16pSaN2/upcrcLyYmRsuXL1ffvn1VWVmpv/zlLxo0aJC2bNmiq666ytvleQVhp5F45JFHtGDBglrb7NmzR127dnXq/GPHjrX/uUePHkpISFDnzp2VkZGhIUOGOHVOV3F3331dffvvrJ+P6enRo4diYmI0ZMgQHThwQJ07d3b6vPANNptNNpvN/v2aa65Rt27d9Morr+iJJ57wYmVwly5duqhLly7279dcc40OHDigRYsW6e9//7sXK/Mewk4j8Yc//EETJkyotU2nTp1cdr1OnTopIiJC+/fv93rYcWffo6OjJUkFBQWKiYmxby8oKFCvXr2cOqer1bf/0dHR5w1SPXv2rE6cOGHvZ330799fkrR//36fDDsRERHy9/dXQUGBw/aCgoIL9jM6Ovqi2vsqZ/r+vwICAtS7d2/t37/fHSX6jAv9zkNCQkx9V+dC+vXrp3//+9/eLsNrCDuNRJs2bdSmTRuPXe/w4cM6fvy4QwDwFnf2vWPHjoqOjlZ6ero93JSUlGjLli0X/Tabu9S3/zabTUVFRcrKylKfPn0kSZ9++qmqq6vtAaY+tm/fLkk+8buvSWBgoPr06aP09HSNHDlSklRdXa309PQLLgZss9mUnp6u6dOn27etX7/e4Y5HY+BM3/9XVVWVdu3apVtuucWNlXqfzWY7b3qBxvg7d5Xt27f77N9pj/D2CGm43g8//GBs27bNmDt3rtGqVStj27ZtxrZt24zS0lJ7my5duhjvvfeeYRiGUVpaajz44INGZmamcfDgQWPDhg3GVVddZVx++eVGRUWFt7rhlIvtu2EYxtNPP21YrVbjww8/NHbu3GmMGDHC6Nixo3Hq1ClvdKFBbr75ZqN3797Gli1bjH//+9/G5ZdfbowbN86+//Dhw0aXLl2MLVu2GIZhGPv37zfmzZtnfP3118bBgweNDz/80OjUqZNxww03eKsL9fLmm28aQUFBxsqVK43du3cb9957r2G1Wo38/HzDMAxj/PjxxiOPPGJv/+WXXxrNmjUznn32WWPPnj3G7NmzjYCAAGPXrl3e6oLTLrbvc+fONT7++GPjwIEDRlZWljF27FgjODjYyM7O9lYXnFJaWmr/+yzJeP75541t27YZP/zwg2EYhvHII48Y48ePt7f/73//a7Ro0cJ46KGHjD179hhLly41/P39jXXr1nmrC0672L4vWrTI+OCDD4zvvvvO2LVrl3H//fcbfn5+xoYNG7zVBa8j7JhQSkqKIem8z2effWZvI8lYsWKFYRiGcfLkSWPo0KFGmzZtjICAAKN9+/bGpEmT7P/xbEwutu+G8dPr548//rgRFRVlBAUFGUOGDDH27dvn+eJd4Pjx48a4ceOMVq1aGSEhIcbdd9/tEPQOHjzo8PPIyckxbrjhBiMsLMwICgoyLrvsMuOhhx4yiouLvdSD+luyZIkRFxdnBAYGGv369TM2b95s3zdw4EAjJSXFof3bb79tXHHFFUZgYKDRvXt3Y82aNR6u2HUupu/Tp0+3t42KijJuueUW45tvvvFC1Q1z7nXq//2c62tKSooxcODA847p1auXERgYaHTq1Mnh731jcrF9X7BggdG5c2cjODjYCAsLMwYNGmR8+umn3ineR1gMwzA8dhsJAADAw5hnBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphBwAAmBphB4DPMQxD9957r8LCwmSxWOxLWACAM5hUEIDPWbt2rUaMGKGMjAz7orTNmrGUHwDn8F8PAD7nwIEDiomJ0TXXXOPxa58+fVqBgYEevy4A9+ExFgCfMmHCBE2bNk05OTmyWCzq0KGD/vGPf6hHjx5q3ry5wsPDlZiYqPLycvsxr732mrp3766goCDFxMQ4rACek5OjESNGqFWrVgoJCdEdd9yhgoIC+/45c+aoV69e+stf/qKOHTsqODhYklRUVKR77rlHbdq0UUhIiAYPHqwdO3Z47gcBwGW4swPAp7zwwgvq3Lmz/vznP2vr1q06c+aMOnXqpIULF+qXv/ylSktL9cUXX+jcE/iXX35ZqampevrppzVs2DAVFxfryy+/lCRVV1fbg87nn3+us2fPasqUKfrVr36ljIwM+zX379+vd999V++99578/f0lSWPGjFHz5s21du1ahYaG6pVXXtGQIUP0n//8R2FhYR7/uQBoAG+uQgoANVm0aJHRvn17wzAMIysry5BkfP/99zW2jY2NNR577LEa933yySeGv7+/kZOTY9+WnZ1tSDK++uorwzAMY/bs2UZAQIBRWFhob/PFF18YISEhRkVFhcP5OnfubLzyyisN6RoAL+AxFgCf1rNnTw0ZMkQ9evTQmDFj9Oqrr+rHH3+UJBUWFiovL09Dhgyp8dg9e/aoXbt2ateunX1bfHy8rFar9uzZY9/Wvn17tWnTxv59x44dKisrU3h4uFq1amX/HDx4UAcOHHBTTwG4C4+xAPg0f39/rV+/Xps2bdInn3yiJUuW6LHHHtOWLVsUERHhkmu0bNnS4XtZWZliYmIcHnWdY7VaXXJNAJ7DnR0APs9isejaa6/V3LlztW3bNgUGBur9999X69at1aFDB6Wnp9d4XLdu3XTo0CEdOnTIvm337t0qKipSfHz8Ba931VVXKT8/X82aNdNll13m8HFVwALgOdzZAeDTtmzZovT0dA0dOlSRkZHasmWLjh49qm7dukn66W2q3/3ud4qMjNSwYcNUWlqqL7/8UtOmTVNiYqJ69Oih5ORkLV68WGfPntXvf/97DRw4UH379r3gNRMTE2Wz2TRy5EgtXLhQV1xxhfLy8rRmzRr98pe/rPVYAL6HsAPAp4WEhGjjxo1avHixSkpK1L59ez333HMaNmyYJCklJUUVFRVatGiRHnzwQUVEROj222+X9NMdoQ8//FDTpk3TDTfcID8/P918881asmRJrde0WCz66KOP9Nhjj+nuu+/W0aNHFR0drRtuuEFRUVFu7zMA12IGZQAAYGqM2QEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKb2/wGiEShF6mlFrQAAAABJRU5ErkJggg==\n" - }, - "metadata": {} - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "df = pd.DataFrame({'score': score, 'fscore': fscore, 'y': y})\n", - "\n", - "sns.histplot(df, x=\"score\", hue=\"y\").set_title(\"SVM\")\n", - "plt.show()\n", - "sns.histplot(df, x=\"fscore\", hue=\"y\").set_title(\"FairSVM\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_MAE.ipynb b/examples_FEI/STAR2000_loss_MAE.ipynb deleted file mode 100644 index c437f51..0000000 --- a/examples_FEI/STAR2000_loss_MAE.ipynb +++ /dev/null @@ -1,1135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "D62H7LVT-hpG", - "outputId": "ed81047f-8751-4916-e05f-c4714b78af83" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-hxsznegq\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-hxsznegq\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=fa1c481dc179bf912d9670fdd130ef2b2453c3c7a9fa06f72250a49b917d4a98\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-4_bmvjlq/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "tHPsW2Eq6lN9" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "M8dZ_mRK9YDK" - }, - "outputs": [], - "source": [ - "# Simulate data\n", - "np.random.seed(42)\n", - "scaler_mae = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "X = scaler_mae.fit_transform(X)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 137 - }, - "id": "9JP5VwfV9aCY", - "outputId": "781ff38e-6850-4617-db7c-7e809c111007" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(loss={'name': 'mae'})" - ], - "text/html": [ - "
plq_Ridge_Regressor(loss={'name': 'mae'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ], - "source": [ - "## solve MAE Regression via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf = plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "JC3sBscd9bWU", - "outputId": "31665e66-9570-4c7f-e6b4-9e6ea3a86c89" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## plot MAE results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "mae_sample = clf.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "5IX8zjUk6yJF" - }, - "outputs": [], - "source": [ - "#With pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "Y-nBBodB6xEB" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "wbCrxMoaD6zd" - }, - "outputs": [], - "source": [ - "# Simulate data\n", - "np.random.seed(42)\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 213 - }, - "id": "W8QLXxxOD8AO", - "outputId": "911ca74c-24c1-418c-b74f-6b488c3db343" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ], - "source": [ - "## solve MAE Regression via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'mae'}, C=1.0))\n", - "])\n", - "pipe.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "f-I1H7joD9Mm", - "outputId": "02983dca-6556-499c-f6a8-07bb9ddbada0" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## plot MAE results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "mae_sample = pipe.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mae': mae_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_MSE.ipynb b/examples_FEI/STAR2000_loss_MSE.ipynb deleted file mode 100644 index c1a9527..0000000 --- a/examples_FEI/STAR2000_loss_MSE.ipynb +++ /dev/null @@ -1,1119 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "cY_04uxlIp6C", - "outputId": "5beb3838-f250-4576-9c68-125d40d4056d" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-jyd_21no\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-jyd_21no\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=e40a18d1e851c1aebab381bc6b01312b662c6800df1685e03ad8f6a9d4dfc433\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-84yy9nhd/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "6A65T6tzF3Lj" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler" - ] - }, - { - "cell_type": "code", - "source": [ - "# Simulate data\n", - "np.random.seed(42)\n", - "scaler_mse = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", - "X = scaler_mse.fit_transform(X)\n", - "y = y / y.std()" - ], - "metadata": { - "id": "iH3AockWGKbl" - }, - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "## solve MSE Regression via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf = plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ], - "metadata": { - "id": "1OGXUMlKGL3U", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "outputId": "ff13a10a-9fa4-496f-fd98-a3b1341d3094" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(loss={'name': 'mse'})" - ], - "text/html": [ - "
plq_Ridge_Regressor(loss={'name': 'mse'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ] - }, - { - "cell_type": "code", - "source": [ - "## plot MSE results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "mse_sample = clf.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ], - "metadata": { - "id": "EPp4wl_8GNA7", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "outputId": "4b063c03-568c-44c0-9222-804217bce4b2" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "#With Pipeline" - ], - "metadata": { - "id": "unUUe9ZEASBd" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression" - ], - "metadata": { - "id": "Vb4eJISeAU5O" - }, - "execution_count": 8, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "# Simulate data\n", - "np.random.seed(42)\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=5.0)\n", - "y = y / y.std()" - ], - "metadata": { - "id": "Uy9loVbWCw8A" - }, - "execution_count": 9, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "## solve MSE Regression via `plq_Ridge_Regressor`\n", - "from sklearn.pipeline import Pipeline\n", - "from sklearn.preprocessing import StandardScaler\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}, C=1.0))\n", - "])\n", - "pipe.fit(X, y)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "3oUouDgWC3ao", - "outputId": "78a04eca-6d3e-4eda-bfc2-7485e63544e8" - }, - "execution_count": 10, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('clf', plq_Ridge_Regressor(loss={'name': 'mse'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 10 - } - ] - }, - { - "cell_type": "code", - "source": [ - "## plot MSE results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "mse_sample = pipe.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'mse': mse_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "JjNnypf6DI9L", - "outputId": "f8788e70-6c62-4e89-ad2e-5b47dcbad1b0" - }, - "execution_count": 11, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_QR.ipynb b/examples_FEI/STAR2000_loss_QR.ipynb deleted file mode 100644 index 737f8d9..0000000 --- a/examples_FEI/STAR2000_loss_QR.ipynb +++ /dev/null @@ -1,1096 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "rTzmChto1ltC", - "outputId": "e72f4d4a-58e2-4d45-d134-4633ae86ee38" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting rehline\n", - " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", - "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m3.4 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: rehline\n", - "Successfully installed rehline-0.1.1\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "BWLs6_gP1YHE" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", - "X = scaler.fit_transform(X)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "L8KI3Odl4l_Z", - "outputId": "d9b79b7c-7871-4510-bf43-dfba92823c7f" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "plq_Ridge_Regressor(C=0.001, loss={'name': 'QR', 'qt': 0.95})" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## solve QR with different `qt` via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf5 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", - "clf5.fit(X=X, y=y)\n", - "\n", - "clf95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", - "clf95.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "WR-5hLZe4oEE", - "outputId": "df6aa0ca-eba6-4011-b1e9-c85abaf06cfa" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "## plot QR results\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "q05_sample = clf5.predict(X_sample)\n", - "q95_sample = clf95.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "eezf3egK8S32" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline\n", - "import numpy as np\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0, random_state=42)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "t99I5I5E8s0S", - "outputId": "63b686c2-40ec-450e-b833-440f72c82aac" - }, - "outputs": [ - { - "data": { - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('reg',\n",
-              "                 plq_Ridge_Regressor(C=0.001,\n",
-              "                                     loss={'name': 'QR', 'qt': 0.95}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('reg',\n", - " plq_Ridge_Regressor(C=0.001,\n", - " loss={'name': 'QR', 'qt': 0.95}))])" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## solve QR with different `qt` via `plq_Ridge_Regressor` with Pipeline\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "pipe5 = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n))\n", - "])\n", - "pipe5.fit(X=X, y=y)\n", - "\n", - "pipe95 = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n))\n", - "])\n", - "pipe95.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "D0n0ZqKC8uoj", - "outputId": "f9280f7b-77a7-4030-8b80-840d527ec240" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "## plot QR results\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "q05_sample = pipe5.predict(X_sample)\n", - "q95_sample = pipe95.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'q05': q05_sample, 'q95': q95_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples_FEI/STAR2000_loss_QR_with_tol.ipynb b/examples_FEI/STAR2000_loss_QR_with_tol.ipynb deleted file mode 100644 index 6f223d2..0000000 --- a/examples_FEI/STAR2000_loss_QR_with_tol.ipynb +++ /dev/null @@ -1,1111 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ], - "metadata": { - "id": "OYf6ieCxG5Is", - "outputId": "3c5d6592-1e5c-4dd3-9f62-0312c6dbb623", - "colab": { - "base_uri": "https://localhost:8080/" - } - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-mha0b2ca\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-mha0b2ca\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=d53fa588ab159c0770b7caee4454e2c23159fd702245525d843f6a754cc8d391\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-edl2raxl/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Simulate Data\n", - "import numpy as np\n", - "\n", - "np.random.seed(42)\n", - "n = 2000\n", - "x = np.random.randn(n)\n", - "noise = np.random.randn(n) * (0.3 + 0.5 * np.abs(x))\n", - "y = 2 * x + noise\n", - "X = x.reshape(-1, 1)" - ], - "metadata": { - "id": "54zIQq6-Bqm8" - }, - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "from rehline import plq_Ridge_Regressor\n", - "\n", - "# Check Loss with epsilon-tolerance\n", - "clf = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.9, 'epsilon': 0.1}, C=10.0/n)\n", - "clf.fit(X=X, y=y)" - ], - "metadata": { - "id": "LpdGRLz3CKFM", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 97 - }, - "outputId": "45d86e36-a471-4e23-dc0b-13fc0a3ca56c" - }, - "execution_count": 3, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(C=0.005,\n", - " loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})" - ], - "text/html": [ - "
plq_Ridge_Regressor(C=0.005,\n",
-              "                    loss={'epsilon': 0.1, 'name': 'check_eps', 'qt': 0.9})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 3 - } - ] - }, - { - "cell_type": "code", - "source": [ - "## plot Check Loss with epsilon results\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "# Parameters\n", - "epsilon = 0.3\n", - "\n", - "# Fit Check Loss with epsilon (two quantiles)\n", - "clf05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", - "clf05.fit(X=X, y=y)\n", - "\n", - "clf95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", - "clf95.fit(X=X, y=y)\n", - "\n", - "# Plot\n", - "n_sample = 100\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "q05_sample = clf05.predict(X_sample)\n", - "q95_sample = clf95.predict(X_sample)\n", - "\n", - "# sort by x0\n", - "sort_idx = np.argsort(X_sample[:,0])\n", - "x0_sorted = X_sample[sort_idx, 0]\n", - "y_sorted = y_sample[sort_idx]\n", - "q05_sorted = q05_sample[sort_idx]\n", - "q95_sorted = q95_sample[sort_idx]\n", - "\n", - "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", - "plt.plot(x0_sorted, q05_sorted, 'orange', linewidth=2, label='q05')\n", - "plt.plot(x0_sorted, q95_sorted, 'green', linewidth=2, label='q95')\n", - "plt.legend()\n", - "plt.show()" - ], - "metadata": { - "id": "fdFQpu9gCOlT", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 427 - }, - "outputId": "2af32392-8aa2-4a3b-efba-448086b57091" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "## Comparison: Original QR vs Check Loss with epsilon\n", - "import numpy as np\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "# Parameters\n", - "epsilon = 0.2\n", - "\n", - "# Fit original QR\n", - "clf_qr05 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.05}, C=10.0/n)\n", - "clf_qr05.fit(X=X, y=y)\n", - "\n", - "clf_qr95 = plq_Ridge_Regressor(loss={'name': 'QR', 'qt': 0.95}, C=10.0/n)\n", - "clf_qr95.fit(X=X, y=y)\n", - "\n", - "# Fit Check Loss with epsilon\n", - "clf_eps05 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.05, 'epsilon': epsilon}, C=10.0/n)\n", - "clf_eps05.fit(X=X, y=y)\n", - "\n", - "clf_eps95 = plq_Ridge_Regressor(loss={'name': 'check_eps', 'qt': 0.95, 'epsilon': epsilon}, C=10.0/n)\n", - "clf_eps95.fit(X=X, y=y)" - ], - "metadata": { - "id": "ElZCOJ2lB0mP", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 97 - }, - "outputId": "8d47c878-bddf-49a8-937e-11bbb0a2cee0" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(C=0.005,\n", - " loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})" - ], - "text/html": [ - "
plq_Ridge_Regressor(C=0.005,\n",
-              "                    loss={'epsilon': 0.2, 'name': 'check_eps', 'qt': 0.95})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 5 - } - ] - }, - { - "cell_type": "code", - "source": [ - "# Plot\n", - "n_sample = 300\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "\n", - "sort_idx = np.argsort(X_sample[:,0])\n", - "x0_sorted = X_sample[sort_idx, 0]\n", - "y_sorted = y_sample[sort_idx]\n", - "\n", - "qr05_sorted = clf_qr05.predict(X_sample)[sort_idx]\n", - "qr95_sorted = clf_qr95.predict(X_sample)[sort_idx]\n", - "eps05_sorted = clf_eps05.predict(X_sample)[sort_idx]\n", - "eps95_sorted = clf_eps95.predict(X_sample)[sort_idx]\n", - "\n", - "plt.figure(figsize=(10, 6))\n", - "plt.scatter(x0_sorted, y_sorted, alpha=0.5, label='real_y')\n", - "plt.plot(x0_sorted, qr05_sorted, 'orange', linewidth=2, label='QR_05')\n", - "plt.plot(x0_sorted, qr95_sorted, 'orange', linewidth=2, linestyle='--', label='QR_95')\n", - "plt.plot(x0_sorted, eps05_sorted, 'green', linewidth=2, label='QR_eps_05')\n", - "plt.plot(x0_sorted, eps95_sorted, 'green', linewidth=2, linestyle='--', label='QR_eps_95')\n", - "plt.legend()\n", - "plt.title(f'Original QR vs Check Loss with epsilon (eps={epsilon})')\n", - "plt.show()" - ], - "metadata": { - "id": "Q3fIo_UwC7yN", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 364 - }, - "outputId": "a9e1fcb4-81be-47a3-c28a-be5a3ac8c575" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_SVM.ipynb b/examples_FEI/STAR2000_loss_SVM.ipynb deleted file mode 100644 index 12ca4ac..0000000 --- a/examples_FEI/STAR2000_loss_SVM.ipynb +++ /dev/null @@ -1,1111 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "OW25uH0Trqxn" - }, - "outputs": [], - "source": [ - "## set up plotting style\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "custom_palette = ['#FFE4E1', '#3D325C']\n", - "sns.set_palette(custom_palette)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "p_7oxpX8Nqqd", - "outputId": "2f3541b7-0b9b-4aaa-fb6c-ff47e84eccf1" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting rehline\n", - " Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (6.4 kB)\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline) (3.6.0)\n", - "Downloading rehline-0.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (174 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m174.7/174.7 kB\u001b[0m \u001b[31m7.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: rehline\n", - "Successfully installed rehline-0.1.1\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "NVVj0auob6c6" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", - "X = scaler.fit_transform(X)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 137 - }, - "id": "WpgI_saqFj-r", - "outputId": "a5baf759-778c-47eb-ef92-ad95398e2646" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "text/html": [ - "
plq_Ridge_Classifier(loss={'name': 'svm'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "plq_Ridge_Classifier(loss={'name': 'svm'})" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## solve SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "clf = plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 469 - }, - "id": "x2PIL0esFrQ6", - "outputId": "163ac4e8-51e7-4b63-e744-874ee510a087" - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = clf.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "WDsb-OMtFwz-" - }, - "outputs": [], - "source": [ - "#With Pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "_MKFw7E4pF1b" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline\n", - "import numpy as np\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 213 - }, - "id": "VHj2Y6zOLb1M", - "outputId": "4f030161-735d-49c5-a4d0-1dba300bbaa2" - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.12/dist-packages/rehline/_class.py:419: ConvergenceWarning: ReHLine failed to converge, increase the number of iterations: `max_iter`.\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ], - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}))])" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "## solve SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'svm'}, C=1.0))\n", - "])\n", - "pipe.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 426 - }, - "id": "ogQFzB34LdvI", - "outputId": "88c2f1a5-fbe5-42d5-9166-e7aac31ec80a" - }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAM6FJREFUeJzt3Xl0VGWexvEngSSslQhJKoBJQEAggIDIElyBdCLS3dLQrgwiIigdUMFBGqXZXFCkhZEJ0gsGHeXQQ48rIBDCJhAiRFH2Iw4YqFBJEENYJAmVO384qdMlqYQklVou3885dU7Xfd9b9/dyG31873vvDTIMwxAAAIBJBfu6AAAAgPpE2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKZG2AEAAKbW0NcF+IPy8nLl5eWpefPmCgoK8nU5AADgKhiGoXPnzql169YKDnY/f0PYkZSXl6fY2FhflwEAAGrhxIkTuv766922E3YkNW/eXNLPf1gWi8XH1QAAgKtRXFys2NhY57/H3SHsSM5LVxaLhbADAECAqW4JCguUAQCAqRF2AACAqRF2AACAqbFmBwCAAOFwOFRWVubrMrwmJCREDRo0qPPvEHYAAPBzhmHIbrerqKjI16V4XUREhGJiYur0HDzCDgAAfq4i6ERHR6tJkybXxANwDcPQxYsXVVBQIElq1apVrX+LsAMAgB9zOBzOoNOyZUtfl+NVjRs3liQVFBQoOjq61pe0WKAMAIAfq1ij06RJEx9X4hsV467LWiXCDgAAAeBauHRVGU+Mm7ADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABcvPvuu2rZsqVKSkpctg8bNkyjRo3yUVW1x0MFAXjVoIEDVVhY6LY9KipKmzZv9mJFAH7pvvvu01NPPaVPPvlE9913n6SfH+y3Zs0abdiwwcfV1RxhB4BXFRYWKnvjerft/ZJSvFgNgMo0btxYDz/8sNLT051h57333lNcXJzuuusu3xZXC1zGAgAAVxg3bpw2bNggm80mSVq+fLkeffTRgHy4ITM7APyKzWZT927d3LZzmQvwjl69eqlHjx569913lZycrAMHDmjNmjW+LqtWCDsA/IphlHOZC/ATjz/+uBYtWiSbzaakpCTFxsb6uqRa4TIWAACo1MMPP6yTJ0/qb3/7mx577DFfl1NrhB0AAFCp8PBwjRgxQs2aNdOwYcN8XU6tEXYAAIBbNptNI0eOVFhYmK9LqTXW7AAAgCv8+OOP2rJli7Zs2aIlS5b4upw6IewAAIAr9OrVSz/++KNee+01derUydfl1AlhBwAAXOH48eO+LsFjWLMDAABMjZkdAAhAt916u/Lz7W7brdYYbd/xuRcrAvwXYQcAAlB+vl2TU593274w7RUvVgP4Ny5jAQAAUyPsAAAAU+MyFgAAASo3N1enT5/2yrEiIyMVFxfnlWN5GmEHAEzIZstTxw4d3bazgDnw5ebmqkuXLrp48aJXjtekSRMdOnSoToHngw8+0NKlS5WTk6MzZ87oq6++Us+ePT1XpBuEHQAwIYfDwQJmkzt9+rQuXryoZf/5pjp1dB9sPeHIt99q7MSndPr06TqFnQsXLui2227T/fffr3HjxnmwwqoRdgAACGCdOnZUr5u6+7qMqzJq1ChJ3n9gIQuUAQCAqRF2AACAqXEZC4BHDRo4UIWFhW7bT+XlebEaAL7y/vvv64knnnB+/+yzz3T77bf7pBbCDgCPKiwsVPbG9W7b23RO8GI1AHzlt7/9rfr16+f83qZNG5/VQtgBAAAe17x5czVv3tzXZUgi7AAAAC85c+aMcnNzlff/l7OPHDkiSYqJiVFMTEy9HZewAwBAADvy7bcBc4xPPvlEY8aMcX5/8MEHJUmzZs3S7NmzPXKMyhB2AAAIQJGRkWrSpInGTnzKK8dr0qSJIiMj6/Qbjz76qB599FHPFFQDhB0AAAJQXFycDh06xLuxrgJhBwCAABUXFxewAcSbeKggAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNcIOAAAwNZ6zAwBAgMrNzeWhgleBsAMAQADKzc1V586d9dNPP3nleI0bN9bhw4drFHi2bdum119/XTk5OTp16pQ+/PBDDRs2rP6KdIOwAwBAADp9+rR++uknjR45TjHW1vV6LHt+nt55/286ffp0jcLOhQsX1KNHDz322GMaPnx4PVZYNcIOAAABLMbaWnHXx/u6jEoNGTJEQ4YM8XUZLFAGAADmRtgBAACmRtgBAACmxpodADUyaOBAFRYWum0/lZfnxWpQWzZbnjp26FhlH6s1Rtt3fO6lioD6Q9gBUCOFhYXK3rjebXubzglerAa15XA4NDn1+Sr7LEx7xUvVAPWLsAPAqbpZG4mZGwBX7/z58zp69Kjz+7Fjx7R37161aNHCqw8oJOwAcKpu1kZi5gbwN/b8+v8PkNoeY8+ePRo4cKDz+5QpUyRJo0eP1vLlyz1R2lXxm7Dz6quvavr06Xr66ae1aNEiSdKlS5f07LPPauXKlSopKVFKSoqWLFkiq9Xq3C83N1cTJkzQ5s2b1axZM40ePVrz5s1Tw4Z+MzQAADwuMjJSjRs31jvv/80rx2vcuLEiIyNrtM9dd90lwzDqqaKr5xeJYPfu3frLX/6im266yWX75MmTtWbNGq1atUrh4eGaOHGihg8frh07dkj6+Zrz0KFDFRMTo507d+rUqVN65JFHFBISolde4VozAMC84uLidPjwYd6NdRV8HnbOnz+vkSNH6m9/+5teeukl5/azZ89q2bJlWrFihQYNGiRJSk9PV5cuXbRr1y71799fGzZs0MGDB7Vx40ZZrVb17NlTL774oqZNm6bZs2crNDTUV8MCgDq57dbblZ9vd9tus7F2Cj8HnkANIN7k87CTmpqqoUOHKikpySXs5OTkqKysTElJSc5tnTt3VlxcnLKystS/f39lZWWpe/fuLpe1UlJSNGHCBB04cEC9evWq9JglJSUqKSlxfi8uLq6HkQFA7eXn26u8W2rytAlerAYIbD4NOytXrtSXX36p3bt3X9Fmt9sVGhqqiIgIl+1Wq1V2u93Z51+DTkV7RZs78+bN05w5c+pYPQDUHjM3gPf4LOycOHFCTz/9tDIyMtSoUSOvHnv69OnOFeHSzzM7sbGxXq0BwLWNmRvUlD8s9PUFT4zbZ6+LyMnJUUFBgW6++WY1bNhQDRs21NatW/Xmm2+qYcOGslqtKi0tVVFRkct++fn5iomJkSTFxMQoPz//ivaKNnfCwsJksVhcPgAA+KOQkBBJ0sWLF31ciW9UjLviz6E2fDazM3jwYO3bt89l25gxY9S5c2dNmzZNsbGxCgkJUWZmpkaMGCFJOnLkiHJzc5WYmChJSkxM1Msvv6yCggJFR0dLkjIyMmSxWJSQwLNAAACBr0GDBoqIiFBBQYEkqUmTJgoKCvJxVfXPMAxdvHhRBQUFioiIUIMGDWr9Wz4LO82bN1e3bt1ctjVt2lQtW7Z0bh87dqymTJmiFi1ayGKxaNKkSUpMTFT//v0lScnJyUpISNCoUaM0f/582e12zZgxQ6mpqQoLC/P6mAAAqA8VVysqAs+1JCIiosqrNVfD53djVWXhwoUKDg7WiBEjXB4qWKFBgwZavXq1JkyYoMTERDVt2lSjR4/W3LlzfVg1AACeFRQUpFatWik6OlplZWW+LsdrQkJC6jSjU8Gvws6WLVtcvjdq1EhpaWlKS0tzu098fLzWrl1bz5UBAOB7DRo08Mi//K81PlugDAAA4A2EHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGqEHQAAYGp+9dZzAKiOzWZT927dquwTFRWlTZs3e6kiAP6OsAMgoBhGubI3rq+yT7+kFC9VAyAQcBkLAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYGmEHAACYWkNfFwAAZnPbrbcrP99eZR+bLc9L1QAg7ACAh+Xn2zU59fkq+0yeNsFL1QDgMhYAADA1ZnYAmI7NZlP3bt3ctkdFRWnT5s1erCgw2Wx56tiho9t2qzVG23d87sWKgNoh7AAwHcMoV/bG9W7b+yWleLGawOVwOKq8HLcw7RUvVgPUHpexAACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqTX0dQEAEGhuu/V25efb3bbbbHlerAZAdQg7AFBD+fl2TU593m375GkTvFgNgOpwGQsAAJgaYQcAAJgaYQcAAJgaYQcAAJgaYQcAAJgad2MBAGrFZstTxw4d3bZbrTHavuNzL1YEVI6wAwCoFYfDUeUt+AvTXvFiNYB7Pr2M9dZbb+mmm26SxWKRxWJRYmKiPvvsM2f7pUuXlJqaqpYtW6pZs2YaMWKE8vPzXX4jNzdXQ4cOVZMmTRQdHa2pU6fq8uXL3h4KAADwUz4NO9dff71effVV5eTkaM+ePRo0aJDuvfdeHThwQJI0efJkffrpp1q1apW2bt2qvLw8DR8+3Lm/w+HQ0KFDVVpaqp07d+qdd97R8uXLNXPmTF8NCQAA+BmfXsb6zW9+4/L95Zdf1ltvvaVdu3bp+uuv17Jly7RixQoNGjRIkpSenq4uXbpo165d6t+/vzZs2KCDBw9q48aNslqt6tmzp1588UVNmzZNs2fPVmhoqC+GBQAA/Ijf3I3lcDi0cuVKXbhwQYmJicrJyVFZWZmSkpKcfTp37qy4uDhlZWVJkrKystS9e3dZrVZnn5SUFBUXFztnhypTUlKi4uJilw8AADAnn4edffv2qVmzZgoLC9OTTz6pDz/8UAkJCbLb7QoNDVVERIRLf6vVKrv95xfw2e12l6BT0V7R5s68efMUHh7u/MTGxnp2UAAAwG/4POx06tRJe/fuVXZ2tiZMmKDRo0fr4MGD9XrM6dOn6+zZs87PiRMn6vV4AADAd3x+63loaKg6dOggSerdu7d2796t//iP/9ADDzyg0tJSFRUVuczu5OfnKyYmRpIUExOjL774wuX3Ku7WquhTmbCwMIWFhXl4JAAAwB/5fGbnl8rLy1VSUqLevXsrJCREmZmZzrYjR44oNzdXiYmJkqTExETt27dPBQUFzj4ZGRmyWCxKSEjweu0AAMD/+HRmZ/r06RoyZIji4uJ07tw5rVixQlu2bNH69esVHh6usWPHasqUKWrRooUsFosmTZqkxMRE9e/fX5KUnJyshIQEjRo1SvPnz5fdbteMGTOUmprKzA0AAJDk47BTUFCgRx55RKdOnVJ4eLhuuukmrV+/Xr/61a8kSQsXLlRwcLBGjBihkpISpaSkaMmSJc79GzRooNWrV2vChAlKTExU06ZNNXr0aM2dO9dXQwIAAH7Gp2Fn2bJlVbY3atRIaWlpSktLc9snPj5ea9eu9XRpAADAJPxuzQ4AAIAnEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICpEXYAAICp+fyt5wDgb2679Xbl59vdtttseV6sBkBdEXYA4Bfy8+2anPq82/bJ0yZ4sRoAdcVlLAAAYGqEHQAAYGqEHQAAYGqEHQAAYGq1Cjs33HCDfvjhhyu2FxUV6YYbbqhzUQAAAJ5Sq7Bz/PhxORyOK7aXlJTIZrPVuSgAAABPqdGt55988onzf69fv17h4eHO7w6HQ5mZmWrbtq3HigPgWYMGDlRhYaHb9lN5PD8GgPnUKOwMGzZMkhQUFKTRo0e7tIWEhKht27b685//7LHiAHhWYWGhsjeud9vepnOCF6sBAO+oUdgpLy+XJLVr1067d+9WZGRkvRQFAADgKbV6gvKxY8c8XQcAD+AyFQBcqdavi8jMzFRmZqYKCgqcMz4V3n777ToXBqDmuEwFAFeqVdiZM2eO5s6dq1tuuUWtWrVSUFCQp+sCAADwiFqFnaVLl2r58uUaNWqUp+sBAADwqFo9Z6e0tFQDBgzwdC0AAAAeV6uw8/jjj2vFihWergUAAMDjanUZ69KlS/rrX/+qjRs36qabblJISIhL+xtvvOGR4gAAAOqqVmHnm2++Uc+ePSVJ+/fvd2ljsTIAAPAntQo7mzdv9nQdAAAA9aJWa3YAAAACRa1mdgYOHFjl5apNmzbVuiAAAABPqlXYqVivU6GsrEx79+7V/v37r3hBKAAAgC/VKuwsXLiw0u2zZ8/W+fPn61QQAACAJ3l0zc6//du/8V4sAADgVzwadrKystSoUSNP/iQAAECd1Ooy1vDhw12+G4ahU6dOac+ePfrTn/7kkcIAAAA8oVZhJzw83OV7cHCwOnXqpLlz5yo5OdkjhQEAAHhCrcJOenq6p+sAAACoF7UKOxVycnJ06NAhSVLXrl3Vq1cvjxQFAADgKbUKOwUFBXrwwQe1ZcsWRURESJKKioo0cOBArVy5UlFRUZ6sEQAAoNZqdTfWpEmTdO7cOR04cEBnzpzRmTNntH//fhUXF+upp57ydI0AAAC1VquZnXXr1mnjxo3q0qWLc1tCQoLS0tJYoAwAAPxKrWZ2ysvLFRIScsX2kJAQlZeX17koAAAAT6lV2Bk0aJCefvpp5eXlObfZbDZNnjxZgwcP9lhxAAAAdVWrsPOf//mfKi4uVtu2bdW+fXu1b99e7dq1U3FxsRYvXuzpGgEAAGqtVmt2YmNj9eWXX2rjxo06fPiwJKlLly5KSkryaHEAAAB1VaOZnU2bNikhIUHFxcUKCgrSr371K02aNEmTJk1Snz591LVrV33++ef1VSsAAECN1SjsLFq0SOPGjZPFYrmiLTw8XE888YTeeOMNjxUHAABQVzW6jPX111/rtddec9uenJysBQsW1LkoAKhPNptN3bt1c9teWFjgxWoA1LcahZ38/PxKbzl3/ljDhiosLKxzUQBQnwyjXNkb17ttb31jF7dtuHo2W546dujott1qjdH2HSx9QP2rUdhp06aN9u/frw4dOlTa/s0336hVq1YeKQwAENgcDocmpz7vtn1h2iterAbXshqt2bnnnnv0pz/9SZcuXbqi7aefftKsWbP061//2mPFAQAA1FWNZnZmzJihDz74QDfeeKMmTpyoTp06SZIOHz6stLQ0ORwOvfDCC/VSKAAAQG3UKOxYrVbt3LlTEyZM0PTp02UYhiQpKChIKSkpSktLk9VqrZdCAQAAaqPGDxWMj4/X2rVr9eOPP+ro0aMyDEMdO3bUddddVx/1AQAA1EmtnqAsSdddd5369OnjyVoAAAA8rlbvxgIAAAgUhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqhB0AAGBqPg078+bNU58+fdS8eXNFR0dr2LBhOnLkiEufS5cuKTU1VS1btlSzZs00YsQI5efnu/TJzc3V0KFD1aRJE0VHR2vq1Km6fPmyN4cCAAD8lE/DztatW5Wamqpdu3YpIyNDZWVlSk5O1oULF5x9Jk+erE8//VSrVq3S1q1blZeXp+HDhzvbHQ6Hhg4dqtLSUu3cuVPvvPOOli9frpkzZ/piSAAAwM/U+nURnrBu3TqX78uXL1d0dLRycnJ0xx136OzZs1q2bJlWrFihQYMGSZLS09PVpUsX7dq1S/3799eGDRt08OBBbdy4UVarVT179tSLL76oadOmafbs2QoNDfXF0AAAgJ/wqzU7Z8+elSS1aNFCkpSTk6OysjIlJSU5+3Tu3FlxcXHKysqSJGVlZal79+4ub1tPSUlRcXGxDhw4UOlxSkpKVFxc7PIBAADm5Ddhp7y8XM8884xuvfVWdevWTZJkt9sVGhqqiIgIl75Wq1V2u93Z51+DTkV7RVtl5s2bp/DwcOcnNjbWw6MBAAD+wm/CTmpqqvbv36+VK1fW+7GmT5+us2fPOj8nTpyo92MCAADf8OmanQoTJ07U6tWrtW3bNl1//fXO7TExMSotLVVRUZHL7E5+fr5iYmKcfb744guX36u4W6uizy+FhYUpLCzMw6MAAAD+yKczO4ZhaOLEifrwww+1adMmtWvXzqW9d+/eCgkJUWZmpnPbkSNHlJubq8TERElSYmKi9u3bp4KCAmefjIwMWSwWJSQkeGcgAADAb/l0Zic1NVUrVqzQxx9/rObNmzvX2ISHh6tx48YKDw/X2LFjNWXKFLVo0UIWi0WTJk1SYmKi+vfvL0lKTk5WQkKCRo0apfnz58tut2vGjBlKTU1l9gYAAPg27Lz11luSpLvuustle3p6uh599FFJ0sKFCxUcHKwRI0aopKREKSkpWrJkibNvgwYNtHr1ak2YMEGJiYlq2rSpRo8erblz53prGAAAwI/5NOwYhlFtn0aNGiktLU1paWlu+8THx2vt2rWeLA0AAJiE39yNBQAAUB8IOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQa+roAAMC1yWbLU8cOHd22W60x2r7jcy9WBLMi7AAAfMLhcGhy6vNu2xemveLFamBmXMYCAACmRtgBAACmRtgBAACmRtgBAACmxgJlANecy5cdWrx4sft2h8OL1QCob4QdANcgQ4l9bq+i3X0QAhB4uIwFAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjbADAABMjddFAH5k0MCBKiwsdNseFRWlTZs3e7EiAAh8hB3AjxQWFip743q37f2SUrxYDQCYA5exAACAqTGzAwQQm82m7t26uW0/lZfnxWoAIDAQdoAAYhjlVV7matM5wYvVmJdRXq7X3pjttj04OMh7xQCoM8IOAPxCcHCw/mvxErft94y834vVAKgr1uwAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTa+jrAgDA0y5fdmjx4sXuOxjeqwWA7xF2AJiQocQ+t1fRXkUQuppfLy/Xa2/MdtseHBxUp98H4FmEHQCooeDgYP3X4iVu2+8Zeb8XqwFQHdbsAAAAUyPsAAAAU+MyFgDAL9lseerYoWOVfazWGG3f8bmXKkKgIuwAAPySw+HQ5NTnq+yzMO0VL1WDQObTy1jbtm3Tb37zG7Vu3VpBQUH66KOPXNoNw9DMmTPVqlUrNW7cWElJSfr2229d+pw5c0YjR46UxWJRRESExo4dq/Pnz3txFAAAwJ/5NOxcuHBBPXr0UFpaWqXt8+fP15tvvqmlS5cqOztbTZs2VUpKii5duuTsM3LkSB04cEAZGRlavXq1tm3bpvHjx3trCAAAwM/59DLWkCFDNGTIkErbDMPQokWLNGPGDN17772SpHfffVdWq1UfffSRHnzwQR06dEjr1q3T7t27dcstt0iSFi9erHvuuUcLFixQ69atvTYWAADgn/z2bqxjx47JbrcrKSnJuS08PFz9+vVTVlaWJCkrK0sRERHOoCNJSUlJCg4OVnZ2ttvfLikpUXFxscsHAACYk98uULbb7ZIkq9Xqst1qtTrb7Ha7oqOjXdobNmyoFi1aOPtUZt68eZozZ46HKwaqNmjgQBUWFlbZ51RenpeqAYBrh9+Gnfo0ffp0TZkyxfm9uLhYsbGxPqwI14LCwkJlb1xfZZ82nRO8VA0AXDv89jJWTEyMJCk/P99le35+vrMtJiZGBQUFLu2XL1/WmTNnnH0qExYWJovF4vIBAADm5LczO+3atVNMTIwyMzPVs2dPST/PwGRnZ2vChAmSpMTERBUVFSknJ0e9e/eWJG3atEnl5eXq16+fr0oHUI+qfaO5xFvNryHVPXiQhw5C8nHYOX/+vI4ePer8fuzYMe3du1ctWrRQXFycnnnmGb300kvq2LGj2rVrpz/96U9q3bq1hg0bJknq0qWL7r77bo0bN05Lly5VWVmZJk6cqAcffJA7sQDTqu6N5lJd32qOwFHdgwd56CAkH4edPXv2aODAgc7vFetoRo8ereXLl+u5557ThQsXNH78eBUVFem2227TunXr1KhRI+c+77//viZOnKjBgwcrODhYI0aM0Jtvvun1sQAAAP/k07Bz1113yTDczzcHBQVp7ty5mjt3rts+LVq00IoVK+qjPAAAYAJ+u0AZAADAEwg7AADA1Ag7AADA1Pz21nMg0FT3hGSejgwAvkHYATykuick83RkAPANLmMBAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABTI+wAAABT46GCAOBhRnm5XntjdpV9goODvFMMAMIOAHhacHCw/mvxkir73DPyfi9VA4DLWAAAwNSY2QGuEi/6BIDARNgBrhIv+gSAwMRlLAAAYGqEHQAAYGpcxsI1o7o1N1FRUdq0ebMXK8K1rLrb07k1HfAcwg6uGdWtuemXlOLFanCtq+72dG5NBzyHy1gAAMDUmNkB/p/NZlP3bt3ctnNrORB4bLY8dezQ0W271Rqj7Ts+92JF8AXCDvD/DKOcW8v9wOXLDi1evNh9B8N7tSDwORwOTU593m37wrRXvFgNfIWwA8DPGErsc3sV7VUEIQCoBGt2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqRF2AACAqfFuLABexYs+AXgbYQeAl/GiTwDeRdgBgAAUHByk196YXWU7gJ8RdgAgADVoEKz/WrzEbfs9I+/3YjWBy2bLU8cOHd22W60x2r7jcy9WhPpA2AEAXLMcDocmpz7vtn1h2iterAb1hbuxAACAqTGzA1MYNHCgCgsLq+xzKi/PS9UAAPwJYQemUFhYqOyN66vs06ZzgpeqAQD4E8IOAkJ1MzfM2gAA3CHsICBUN3PDrA0AwB0WKAMAAFMj7AAAAFPjMhYA+CGjvLzKJyTXdX+esIxrCWEHQI1U9yLPy2WXedGnBwQHV/2E5KHVPCG5uv15wjKuJYQdADVU/Ys8edEnAH9C2IFf4NZyAEB9IezAK64mzOQe3Oe2nVvLAQC1RdiBV/CcHACBiLeimwNhBwAAN3grujkQdgDgGnQ1t7ZzezrMgrADANeg6m5Nl7g9HebBE5QBAICpMbMDwKm6BwZK4qGAcAoODrrmn9Jc3QJmSSooLFR0VJTbdhY51z/CDjyC5+SYRXUPDJR4KCAqNGjAU5qrW8AsSZOnTWCRs48RduAR3FoOAPBXhB0AQKXq+jJSwF8QdkyguktIUVFR2rR5sxcrAmAGdX0ZKW9eh78wTdhJS0vT66+/Lrvdrh49emjx4sXq27evr8vyiuouIfVLSqnT71cXpiTW5AC4UnVhachDvycMwStMEXb+8Y9/aMqUKVq6dKn69eunRYsWKSUlRUeOHFF0dLSvy6uz+l78W9f3VkmsyfEX1d1NdbnsctV3W3GnFbyoujB0LSxwlnglhTeYIuy88cYbGjdunMaMGSNJWrp0qdasWaO3335bf/zjH31cXd3V9+JfFhdfnWqDxGWHF6txp7q7qRZX2w4EEjPc/s4rKepfwIed0tJS5eTkaPr06c5twcHBSkpKUlZWVqX7lJSUqKSkxPn97NmzkqTi4mKP1/froUN1+vRpt+2RkZFavWZNlb/hcDhUfO6c23bDMKpsdzgcVY7NZrPp9QUL3LaXlV2u8vcr+tTlN6obQ13br6rG0rIq243yct3UtXeV7f7w53jh4sV6a/fGMajRP9r9oYZyh0PzFsysssbg4CAtfc3935kRj42q8jeCgqSfLv1UZXtd9vfEb5SXl9fLv5/+VfKvUlRYWOC2PSoqWhsy3P9HcV33r62KPxfDqGZa2ghwNpvNkGTs3LnTZfvUqVONvn37VrrPrFmzDP08Yc+HDx8+fPjwCfDPiRMnqswKAT+zUxvTp0/XlClTnN/Ly8t15swZtWzZUkFBNZ/yLC4uVmxsrE6cOCGLxeLJUv0WY2bMZsWYGbMZmXW8hmHo3Llzat26dZX9Aj7sREZGqkGDBsrPz3fZnp+fr5iYmEr3CQsLU1hYmMu2iIiIOtdisVhM9X+iq8GYrw2M+drAmM3PjOMNDw+vtk/Avwg0NDRUvXv3VmZmpnNbeXm5MjMzlZiY6MPKAACAPwj4mR1JmjJlikaPHq1bbrlFffv21aJFi3ThwgXn3VkAAODaZYqw88ADD6iwsFAzZ86U3W5Xz549tW7dOlmtVq8cPywsTLNmzbri0piZMeZrA2O+NjBm87vWxvtLQYZR3f1aAAAAgSvg1+wAAABUhbADAABMjbADAABMjbADAABMjbBzFV5++WUNGDBATZo0cfvwwdzcXA0dOlRNmjRRdHS0pk6dqsuXL1f5u2fOnNHIkSNlsVgUERGhsWPH6vz58/UwgrrbsmWLgoKCKv3s3r3b7X533XXXFf2ffPJJL1ZeN23btr2i/ldffbXKfS5duqTU1FS1bNlSzZo104gRI6546KW/On78uMaOHat27dqpcePGat++vWbNmqXS0tIq9wu085yWlqa2bduqUaNG6tevn7744osq+69atUqdO3dWo0aN1L17d61du9ZLldbdvHnz1KdPHzVv3lzR0dEaNmyYjhw5UuU+y5cvv+J8NmrUyEsV193s2bOvqL9z585V7hPI51iq/J9VQUFBSk1NrbR/oJ/jmiLsXIXS0lLdd999mjBhQqXtDodDQ4cOVWlpqXbu3Kl33nlHy5cv18yZVb/AbuTIkTpw4IAyMjK0evVqbdu2TePHj6+PIdTZgAEDdOrUKZfP448/rnbt2umWW26pct9x48a57Dd//nwvVe0Zc+fOdal/0qRJVfafPHmyPv30U61atUpbt25VXl6ehg8f7qVq6+bw4cMqLy/XX/7yFx04cEALFy7U0qVL9fzz7t/IXCFQzvM//vEPTZkyRbNmzdKXX36pHj16KCUlRQUFlb/EcOfOnXrooYc0duxYffXVVxo2bJiGDRum/fv3e7ny2tm6datSU1O1a9cuZWRkqKysTMnJybpw4UKV+1ksFpfz+f3333upYs/o2rWrS/3bt2932zfQz7Ek7d6922W8GRkZkqT77rvP7T6Bfo5rxDOv47w2pKenG+Hh4VdsX7t2rREcHGzY7XbntrfeesuwWCxGSUlJpb918OBBQ5Kxe/du57bPPvvMCAoKMmw2m8dr97TS0lIjKirKmDt3bpX97rzzTuPpp5/2TlH1ID4+3li4cOFV9y8qKjJCQkKMVatWObcdOnTIkGRkZWXVQ4X1b/78+Ua7du2q7BNI57lv375Gamqq87vD4TBat25tzJs3r9L+999/vzF06FCXbf369TOeeOKJeq2zvhQUFBiSjK1bt7rt4+6fdYFi1qxZRo8ePa66v9nOsWEYxtNPP220b9/eKC8vr7Q90M9xTTGz4wFZWVnq3r27y0MMU1JSVFxcrAMHDrjdJyIiwmVWJCkpScHBwcrOzq73muvqk08+0Q8//HBVT6l+//33FRkZqW7dumn69Om6ePGiFyr0nFdffVUtW7ZUr1699Prrr1d5eTInJ0dlZWVKSkpybuvcubPi4uKUlZXljXI97uzZs2rRokW1/QLhPJeWlionJ8fl/AQHByspKcnt+cnKynLpL/389zuQz6ekas/p+fPnFR8fr9jYWN17771u/1nmr7799lu1bt1aN9xwg0aOHKnc3Fy3fc12jktLS/Xee+/pscceq/Ll1oF+jmvCFE9Q9jW73X7F05orvtvtdrf7REdHu2xr2LChWrRo4XYff7Js2TKlpKTo+uuvr7Lfww8/rPj4eLVu3VrffPONpk2bpiNHjuiDDz7wUqV189RTT+nmm29WixYttHPnTk2fPl2nTp3SG2+8UWl/u92u0NDQK9Z2Wa3WgDivv3T06FEtXrxYCxYsqLJfoJzn06dPy+FwVPr39fDhw5Xu4+7vdyCez/Lycj3zzDO69dZb1a1bN7f9OnXqpLfffls33XSTzp49qwULFmjAgAE6cOBAtX/n/UG/fv20fPlyderUSadOndKcOXN0++23a//+/WrevPkV/c10jiXpo48+UlFRkR599FG3fQL9HNeYr6eWfGXatGmGpCo/hw4dctnH3bTfuHHjjOTkZJdtFy5cMCQZa9eurfT4L7/8snHjjTdesT0qKspYsmRJ7QdWQ7X5czhx4oQRHBxs/POf/6zx8TIzMw1JxtGjRz01hBqrzZgrLFu2zGjYsKFx6dKlStvff/99IzQ09Irtffr0MZ577jmPjqMmajPmkydPGu3btzfGjh1b4+P5w3mujM1mMyQZO3fudNk+depUo2/fvpXuExISYqxYscJlW1pamhEdHV1vddaXJ5980oiPjzdOnDhRo/1KS0uN9u3bGzNmzKinyurXjz/+aFgsFuPvf/97pe1mOseGYRjJycnGr3/96xrtE+jnuDrX7MzOs88+W2XqlaQbbrjhqn4rJibmirs5Ku6+iYmJcbvPLxdEXr58WWfOnHG7T32ozZ9Denq6WrZsqd/+9rc1Pl6/fv0k/Txj0L59+xrv7wl1Off9+vXT5cuXdfz4cXXq1OmK9piYGJWWlqqoqMhldic/P9+r5/WXajrmvLw8DRw4UAMGDNBf//rXGh/PH85zZSIjI9WgQYMr7o6r6vzExMTUqL+/mjhxovNGiJr+l3tISIh69eqlo0eP1lN19SsiIkI33nij2/rNco4l6fvvv9fGjRtrPKsa6Oe4Otds2ImKilJUVJRHfisxMVEvv/yyCgoKnJemMjIyZLFYlJCQ4HafoqIi5eTkqHfv3pKkTZs2qby83PkvCm+o6Z+DYRhKT0/XI488opCQkBofb+/evZKkVq1a1XhfT6nLud+7d6+Cg4OvuARZoXfv3goJCVFmZqZGjBghSTpy5Ihyc3OVmJhY65rrqiZjttlsGjhwoHr37q309HQFB9d8aZ8/nOfKhIaGqnfv3srMzNSwYcMk/XxpJzMzUxMnTqx0n8TERGVmZuqZZ55xbsvIyPDp+awJwzA0adIkffjhh9qyZYvatWtX499wOBzat2+f7rnnnnqosP6dP39e3333nUaNGlVpe6Cf43+Vnp6u6OhoDR06tEb7Bfo5rpavp5YCwffff2989dVXxpw5c4xmzZoZX331lfHVV18Z586dMwzDMC5fvmx069bNSE5ONvbu3WusW7fOiIqKMqZPn+78jezsbKNTp07GyZMnndvuvvtuo1evXkZ2draxfft2o2PHjsZDDz3k9fHVxMaNG91e5jl58qTRqVMnIzs72zAMwzh69Kgxd+5cY8+ePcaxY8eMjz/+2LjhhhuMO+64w9tl18rOnTuNhQsXGnv37jW+++4747333jOioqKMRx55xNnnl2M2jJ8vFcTFxRmbNm0y9uzZYyQmJhqJiYm+GEKNnTx50ujQoYMxePBg4+TJk8apU6ecn3/tE8jneeXKlUZYWJixfPly4+DBg8b48eONiIgI592Uo0aNMv74xz86++/YscNo2LChsWDBAuPQoUPGrFmzjJCQEGPfvn2+GkKNTJgwwQgPDze2bNnicj4vXrzo7PPLMc+ZM8dYv3698d133xk5OTnGgw8+aDRq1Mg4cOCAL4ZQY88++6yxZcsW49ixY8aOHTuMpKQkIzIy0igoKDAMw3znuILD4TDi4uKMadOmXdFmtnNcU4SdqzB69OhK1zhs3rzZ2ef48ePGkCFDjMaNGxuRkZHGs88+a5SVlTnbN2/ebEgyjh075tz2ww8/GA899JDRrFkzw2KxGGPGjHEGKH/10EMPGQMGDKi07dixYy5/Lrm5ucYdd9xhtGjRwggLCzM6dOhgTJ061Th79qwXK669nJwco1+/fkZ4eLjRqFEjo0uXLsYrr7zisl7nl2M2DMP46aefjD/84Q/GddddZzRp0sT43e9+5xIW/Fl6errbNT0VzHCeFy9ebMTFxRmhoaFG3759jV27djnb7rzzTmP06NEu/f/7v//buPHGG43Q0FCja9euxpo1a7xcce25O5/p6enOPr8c8zPPPOP887FarcY999xjfPnll94vvpYeeOABo1WrVkZoaKjRpk0b44EHHnBZP2a2c1xh/fr1hiTjyJEjV7SZ7RzXVJBhGIYXJ5IAAAC8iufsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAAAAUyPsAICk0tJSX5cAoJ4QdgD4tX/+85/q3r27GjdurJYtWyopKUkXLlyQJL399tvq2rWrwsLC1KpVK02cONG5X25uru699141a9ZMFotF999/v/Lz853ts2fPVs+ePfX3v/9d7dq1U6NGjSRJRUVFevzxxxUVFSWLxaJBgwbp66+/9u6gAXgUYQeA3zp16pQeeughPfbYYzp06JC2bNmi4cOHyzAMvfXWW0pNTdX48eO1b98+ffLJJ+rQoYMkqby8XPfee6/OnDmjrVu3KiMjQ//7v/+rBx54wOX3jx49qv/5n//RBx98oL1790qS7rvvPhUUFOizzz5TTk6Obr75Zg0ePFhnzpzx9vABeAhvPQfgt7788kv17t1bx48fV3x8vEtbmzZtNGbMGL300ktX7JeRkaEhQ4bo2LFjio2NlSQdPHhQXbt21RdffKE+ffpo9uzZeuWVV2Sz2RQVFSVJ2r59u4YOHaqCggKFhYU5f69Dhw567rnnNH78+HocLYD60tDXBQCAOz169NDgwYPVvXt3paSkKDk5Wb///e9VVlamvLw8DR48uNL9Dh06pNjYWGfQkaSEhARFRETo0KFD6tOnjyQpPj7eGXQk6euvv9b58+fVsmVLl9/76aef9N1339XDCAF4A2EHgN9q0KCBMjIytHPnTm3YsEGLFy/WCy+8oMzMTI/8ftOmTV2+nz9/Xq1atdKWLVuu6BsREeGRYwLwPsIOAL8WFBSkW2+9Vbfeeqtmzpyp+Ph4ZWRkqG3btsrMzNTAgQOv2KdLly46ceKETpw44XIZq6ioSAkJCW6PdfPNN8tut6thw4Zq27ZtfQ0JgJcRdgD4rezsbGVmZio5OVnR0dHKzs5WYWGhunTpotmzZ+vJJ59UdHS0hgwZonPnzmnHjh2aNGmSkpKS1L17d40cOVKLFi3S5cuX9Yc//EF33nmnbrnlFrfHS0pKUmJiooYNG6b58+frxhtvVF5entasWaPf/e53Ve4LwH8RdgD4LYvFom3btmnRokUqLi5WfHy8/vznP2vIkCGSpEuXLmnhwoX693//d0VGRur3v/+9pJ9ngz7++GNNmjRJd9xxh4KDg3X33Xdr8eLFVR4vKChIa9eu1QsvvKAxY8aosLBQMTExuuOOO2S1Wut9vADqB3djAQAAU+M5OwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNQIOwAAwNT+Dzz6sxHLGuknAAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = pipe.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} diff --git a/examples_FEI/STAR2000_loss_SVR.ipynb b/examples_FEI/STAR2000_loss_SVR.ipynb deleted file mode 100644 index 74e97e8..0000000 --- a/examples_FEI/STAR2000_loss_SVR.ipynb +++ /dev/null @@ -1,1122 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - } - }, - "cells": [ - { - "cell_type": "code", - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "NjjjqDBE4pkX", - "outputId": "de7ec7ea-4d4e-4bd0-93a8-45ce9586dd67" - }, - "execution_count": 1, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-09286p2r\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-09286p2r\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=9bb240a05e1f7c3d447e7374f4286a1cb179ec22a749e284dced975b93ff3b27\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-ullopi_j/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "sIbawm0_3iq9" - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler" - ] - }, - { - "cell_type": "code", - "source": [ - "# Simulate data\n", - "np.random.seed(42)\n", - "scaler_svr = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "X = scaler_svr.fit_transform(X)\n", - "y = y / y.std()" - ], - "metadata": { - "id": "eq-Bqnt14Xcf" - }, - "execution_count": 3, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "## solve SVR via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf = plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "HgExVVV54a58", - "outputId": "35f56019-877c-49a9-a72e-9c135a136cfc" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})" - ], - "text/html": [ - "
plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ] - }, - { - "cell_type": "code", - "source": [ - "## plot SVR results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "svr_sample = clf.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "URF-gXRN45jb", - "outputId": "4c0a1b1f-3189-4972-a4fd-161c700bffa6" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "#With pipeline" - ], - "metadata": { - "id": "gVGSI7iz5RLm" - }, - "execution_count": null, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline" - ], - "metadata": { - "id": "3-rs8zHc3vVb" - }, - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "#Simulate data\n", - "np.random.seed(42)\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "y = y / y.std()" - ], - "metadata": { - "id": "6RXuMsWQ5aNh" - }, - "execution_count": 7, - "outputs": [] - }, - { - "cell_type": "code", - "source": [ - "## solve SVR via `plq_Ridge_Regressor` with Pipeline\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'svr', 'epsilon': 0.1}, C=1.0))\n", - "])\n", - "pipe.fit(X=X, y=y)" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "Iq5LJkIj5b49", - "outputId": "da81add6-dc6c-4e06-b7f0-ed386812737f" - }, - "execution_count": 8, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('reg',\n", - " plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('reg',\n",
-              "                 plq_Ridge_Regressor(loss={'epsilon': 0.1, 'name': 'svr'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ] - }, - { - "cell_type": "code", - "source": [ - "## plot SVR results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 200\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "svr_sample = pipe.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'svr': svr_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 433 - }, - "id": "tLkX5wvV5qPJ", - "outputId": "47af9451-b318-4cfd-a4c8-3e432899932e" - }, - "execution_count": 9, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAGwCAYAAABRgJRuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAx8NJREFUeJzs3Xd8FGX+wPHPzGzv6QUCofduQxQRbKCIooiKir2cetbz9DxPvTt7uzt/6qln7wV7wYIiNqQICNJ7SUJ6NrvZPvP7YyAhZDeNdJ7365WXZp7dmWdDsvPdp3y/kqZpGoIgCIIgCJ2c3N4dEARBEARBaAkiqBEEQRAEoUsQQY0gCIIgCF2CCGoEQRAEQegSRFAjCIIgCEKXIIIaQRAEQRC6BBHUCIIgCILQJRjauwNtSVVV8vLycDqdSJLU3t0RBEEQBKERNE2jsrKS7OxsZDnxeMxBFdTk5eWRk5PT3t0QBEEQBKEZduzYQffu3RO2H1RBjdPpBPQfisvlaufeCIIgCILQGF6vl5ycnOr7eCIHVVCzd8rJ5XKJoEYQBEEQOpmGlo6IhcKCIAiCIHQJIqgRBEEQBKFLEEGNIAiCIAhdwkG1pkYQBEEQmiMWixGJRNq7G12W0WhEUZQDPo8IagRBEAQhAU3TKCgooLy8vL270uV5PB4yMzMPKI+cCGoEQRAEIYG9AU16ejo2m00kbm0FmqZRVVVFYWEhAFlZWc0+lwhqBEEQBCGOWCxWHdCkpKS0d3e6NKvVCkBhYSHp6enNnooSC4UFQRAEIY69a2hsNls79+TgsPfnfCBrl0RQIwiCIAj1EFNObaMlfs5i+kkQBEEQ9lMVilLqC6GqWnt3RWgCEdQIgiAIwh7haIytxVU8/s0GthdVcOMRHtIDYRSjCaMiJjc6OvEvJAiCIAh7/J7n5eTHv+fj3/Ip9oUIxzTyKoIUeoNEY2p7d6+OrVu3IkkSy5cvb/RzLrzwQk477bR6HzNhwgSuv/76A+pbexAjNYIgCIIAlPhC3P7+KiKxulNOJf4wKQ4zhgPPD9eicnJyyM/PJzU1tb270iGIkRpBEARBALzBKKvzvQnb/aFoG/amYeFwGEVRyMzMxGAQYxQgghpBEARBAEBuYPPNgezOeeaZZ8jOzkZVa09hTZs2jYsvvphNmzYxbdo0MjIycDgcHHrooXz99de1Hpubm8s//vEPLrjgAlwuF5dffnmd6adYLMYll1xCr169sFqtDBgwgH//+99x+3T33XeTlpaGy+XiyiuvJBwOJ+x/KBTi5ptvplu3btjtdg4//HDmz5/f7J9HaxFBjSAIgiAAHpuJsb2TkSQ4qk8y541OxW6SkfcEM3ZT8+eeZsyYQUlJCd9++231sdLSUubOncusWbPw+XxMmTKFefPmsWzZMk466SSmTp3K9u3ba53n4YcfZsSIESxbtow77rijznVUVaV79+688847rF69mr/97W/85S9/4e233671uHnz5rFmzRrmz5/PG2+8wXvvvcfdd9+dsP/XXHMNP//8M2+++Sa//fYbM2bM4KSTTmLDhg3N/pm0Cu0gUlFRoQFaRUVFe3dFEARB6IC2FVdqm9ev0irm3qMFXp2l/b54gVZRVqz5A0EtGlMP6NzTpk3TLr744urvn376aS07O1uLxWJxHz9kyBDt8ccfr/6+Z8+e2mmnnVbrMVu2bNEAbdmyZQmve/XVV2tnnHFG9fezZ8/WkpOTNb/fX33sqaee0hwOR3VfjjnmGO26667TNE3Ttm3bpimKou3atavWeSdNmqTddttt9b/oJggEAtrq1au1QCBQp62x9+9OM1Lz1FNPMXz4cFwuFy6Xi7Fjx/L555+3d7cEQRCELiQntpNecybj+vkByF+OFKnC5N2GNVKOwoHtfpo1axZz5swhFAoB8Nprr3H22WcjyzI+n4+bb76ZQYMG4fF4cDgcrFmzps5IzSGHHNLgdZ544gnGjBlDWloaDoeDZ555ps55RowYUStT8tixY/H5fOzYsaPO+VauXEksFqN///44HI7qr++++45NmzY150fRajrNyqLu3btz//33069fPzRN46WXXmLatGksW7aMIUOGtHf3BEEQhM4uUIb06U0QrKjTJFXmgdUNcvOnoKZOnYqmaXz66acceuihfP/99zz22GMA3HzzzXz11Vc8/PDD9O3bF6vVyplnnllnnYvdbq/3Gm+++SY333wzjzzyCGPHjsXpdPLQQw/xyy+/NLvfPp8PRVFYunRpnZpMDoej2edtDZ0mqJk6dWqt7++55x6eeuopFi5cmDCoCYVC1RExgNebeFW7IAiCcJALlMG2HxK3h/1gsDT79BaLhenTp/Paa6+xceNGBgwYwOjRowH48ccfufDCCzn99NMBPZDYunVrk6/x448/cuSRR/KHP/yh+li80ZQVK1YQCASqC0kuXLgQh8NBTk5OnceOGjWKWCxGYWEhRx99dJP71JY6zfTTvmKxGG+++SZ+v5+xY8cmfNx9992H2+2u/or3jyUIgiAIAGgNlERoqL0RZs2axaeffsrzzz/PrFmzqo/369eP9957j+XLl7NixQrOPffcOjulGqNfv34sWbKEL774gvXr13PHHXewePHiOo8Lh8NccsklrF69ms8++4w777yTa665BlmuGxb079+fWbNmccEFF/Dee++xZcsWFi1axH333cenn37a5D62pk4V1KxcuRKHw4HZbObKK6/k/fffZ/DgwQkff9ttt1FRUVH9FW+uUBAEQRAAsHgga2TidtOBT7VMnDiR5ORk1q1bx7nnnlt9/NFHHyUpKYkjjzySqVOncuKJJ1aP4jTFFVdcwfTp05k5cyaHH344JSUltUZt9po0aRL9+vVj/PjxzJw5k1NPPZW77ror4XlfeOEFLrjgAm666SYGDBjAaaedxuLFi+nRo0eT+9iaJE1rgdCzjYTDYbZv305FRQXvvvsu//vf//juu+/qDWz25fV6cbvdVFRU4HK5Wrm3giAIQqezaxm8cCJEQwQdOWwZ9wi9uqVhcaeDMxPkTrNqo9MJBoNs2bKFXr16YbHUnuZr7P27U43UmEwm+vbty5gxY7jvvvsYMWJEwqRCgiAIgtBkGUPgih9g5Hng6g4GM7hzwJEhAppOoFP/C6mqWmshsCAIgiAcEIMJ0vrDlIehsgQKKsDsBMXY3j0TGqHTBDW33XYbkydPpkePHlRWVvL6668zf/58vvjii/bumiAIgtDVmKxgTwW5sr17IjRBpwlqCgsLueCCC8jPz8ftdjN8+HC++OILjj/++PbumiAIgiAIHUCnCWqee+659u6CIAiCIAgdWKdaKCwIgiAIgpCICGoEQRAEQegSRFAjCIIgCEKXIIIaQRAEQRC6BBHUCIIgCILQoK1btyJJEsuXL2/vriTUaXY/CYIgCEJnVVEVptgXxhuM4LIaSbWbcNtM7d2tLkcENYIgCILQivLKA/x5zm98v6G4+tj4fqncf8Zwsj3WNulDOBzGZOr6QZSYfhIEQRCEVlJRFa4T0AAs2FDMrXN+o6Iq3CrXnTBhAtdccw3XX389qampnHjiiaxatYrJkyfjcDjIyMjg/PPPp7i4pl9z587lqKOOwuPxkJKSwimnnMKmTZuafG1N0+jbty8PP/xwrePLly9HkiQ2btx4wK8vERHUCIIgCEIrKfaF6wQ0ey3YUEyxr3WCGoCXXnoJk8nEjz/+yP3338/EiRMZNWoUS5YsYe7cuezevZuzzjqr+vF+v58bb7yRJUuWMG/ePGRZ5vTTT0dV1SZdV5IkLr74Yl544YVax1944QXGjx9P3759W+T1xSOmnwRBEAShlXiDkXrbKxtoPxD9+vXjwQcfBOCf//wno0aN4t57761uf/7558nJyWH9+vX079+fM844o9bzn3/+edLS0li9ejVDhw5t0rUvvPBC/va3v7Fo0SIOO+wwIpEIr7/+ep3Rm5YmRmoEQRAEoZW4LPVX93Y20H4gxowZU/3/K1as4Ntvv8XhcFR/DRw4EKB6imnDhg2cc8459O7dG5fLRW5uLgDbt29v8rWzs7M5+eSTef755wH4+OOPCYVCzJgx4wBfVf3ESI0gCIIgtJJUh4nx/VJZEGcKany/VFIdrbd41263V/+/z+dj6tSpPPDAA3Uel5WVBcDUqVPp2bMnzz77LNnZ2aiqytChQwmHmzdFdumll3L++efz2GOP8cILLzBz5kxsNlvzXkwjiaBGEARBEFqJ22bi/jOGc+uc32oFNuP7pfLAGcPbbFv36NGjmTNnDrm5uRgMdW/9JSUlrFu3jmeffZajjz4agB9++OGArjllyhTsdjtPPfUUc+fOZcGCBQd0vsYQQY0gCIIgtKJsj5XHzxlFsS9MZTCC02Ik1dG2eWquvvpqnn32Wc455xxuueUWkpOT2bhxI2+++Sb/+9//SEpKIiUlhWeeeYasrCy2b9/OrbfeekDXVBSFCy+8kNtuu41+/foxduzYFno1iYk1NYIgCILQytw2E33SHYzskUSfdEebJ97Lzs7mxx9/JBaLccIJJzBs2DCuv/56PB4PsiwjyzJvvvkmS5cuZejQodxwww089NBDB3zdSy65hHA4zEUXXdQCr6JhYqRGEARBELqY+fPn1znWr18/3nvvvYTPOe6441i9enWtY5qmVf9/bm5ure8bY9euXRiNRi644IImPa+5RFAjCIIgCEKLCoVCFBUVcddddzFjxgwyMjLa5Lpi+kkQBEEQhCa58sora20P3/fryiuv5I033qBnz56Ul5dX58ppC5LW1LGkTszr9eJ2u6moqMDlcrV3dwRBEIQOLBgMsmXLFnr16oXFYmnv7nQohYWFeL3euG0ul4v09PQmn7O+n3dj799i+kkQBEEQhCZJT09vVuDS2sT0kyAIgiAIXYIIagRBEARB6BJEUCMIgiAIQpcgghpBEARBELoEEdQIgiAIgtAliKBGEARBEIQuQWzpFgRBEITWFigDfxEEvWBxgz0VrEnt3asuRwQ1giAIgtCaKnbBh9fA5m9qjvWZBKc+Du5u7devRojFYkiShCx3jomdztFLQRAEQeiMAmV1AxqATfPgo2v19lbw7rvvMmzYMKxWKykpKRx33HF8+OGHWCwWysvLaz32uuuuY+LEiQC8+OKLeDwePvroIwYPHozZbGb79u2t0sfWIIIaQRAEQWgt/qK6Ac1em+bp7S0sPz+fc845h4svvpg1a9Ywf/58pk+fzoQJE/B4PMyZM6f6sbFYjLfeeotZs2ZVH6uqquKBBx7gf//7H7///nuHzByciJh+EgRBEITWEoxfH6nR7c2Qn59PNBpl+vTp9OzZE4Bhw4YBcPbZZ/P6669zySWXADBv3jzKy8s544wzqp8fiUR48sknGTFiRIv3rbWJkRpBEARBaC2WBoonN9TeDCNGjGDSpEkMGzaMGTNm8Oyzz1JWpk9zzZo1i/nz55OXlwfAa6+9xsknn4zH46l+vslkYvjw4S3er7YgghpBEARBaC32NH1RcDx9JuntLUxRFL766is+//xzBg8ezOOPP86AAQPYsmULhx56KH369OHNN98kEAjw/vvv15p6ArBarUiS1OL9agsiqBEEQRCE1mJN0nc57R/Y7N391ErbuiVJYty4cdx9990sW7YMk8nE+++/D+ijNa+99hoff/wxsixz8sknt0of2oNYUyMIgiAIrcndDc58bp88NS59hKaVAppffvmFefPmccIJJ5Cens4vv/xCUVERgwYNAvSg5q677uKee+7hzDPPxGw2t0o/2oMIagRBEAShtVmT2izZnsvlYsGCBfzrX//C6/XSs2dPHnnkESZPngxA3759Oeyww1i0aBH/+te/2qRPbUXSNE1r7060Fa/Xi9vtpqKiAper5RdnCYIgCF1HMBhky5Yt9OrVC4vF0t7d6fLq+3k39v4t1tQIgiAIgtAliKBGEARBEIQuQQQ1giAIgiB0CSKoEQRBEIR6HERLT9tVS/ycRVAjCIIgCHEYjUZAr4UktL69P+e9P/fmEFu6BUEQBCEORVHweDwUFhYCYLPZOm2m3Y5M0zSqqqooLCzE4/GgKEqzzyWCGkEQBEFIIDMzE6A6sBFaj8fjqf55N5cIagRBEAQhAUmSyMrKIj09nUgk0t7d6bKMRuMBjdDsJYIaQRAEQWiAoijNvumqqkZEVTEpspi+amUiqBEEQRCEVhCIxNhVFuCtxTvYUFjJobnJnDI8i24eKwZF7NNpDSKoEQRBEIQWFo7F+HFDMZe/sgR1z07l+euKeOLbjbx1+ViGdXe3bwe7KBEqCoIgCEILK/SGuO7NZaga9E13MLZPCt2TrFSFY1z/1nKKKkPt3cUuSYzUCIIgCEIL21kWYGCGnXsnJZFSvBhL+Qb8w0eRbx/EtZ8VUuYPk+Y0t3c3uxwR1AiCIAhCCzNJGk8eCxlzjoeInlTOAWQ4Mnj99HcJiPXCraLTTD/dd999HHrooTidTtLT0znttNNYt25de3dLEARBEOoY7Kwi45MLqgOaar7d5My/jm5mkaW4NXSaoOa7777j6quvZuHChXz11VdEIhFOOOEE/H5/e3dNEARBEGoxVeVDVWn8xl2/YouUt2l/DhadZvpp7ty5tb5/8cUXSU9PZ+nSpYwfP76deiUIgiAIdckhb73tUlQsFG4NnSao2V9FRQUAycnJCR8TCoUIhWp+cbze+n/JBEEQBKFFJPcGSYJ4lactbrAmtX2fDgKdZvppX6qqcv311zNu3DiGDh2a8HH33Xcfbre7+isnJ6cNeykIgiActOypMHp2/LZJd4Izq1GnKfWH2e0N4guJEg2NIWlavDCyY7vqqqv4/PPP+eGHH+jevXvCx8UbqcnJyaGiogKXy9UWXRUEQRAOVr5CWPkO/PAY+IsgqRccdyf0OgZsiWcZAEp8IRZtKeWbtYWogM2ocO7hPeiVasdiPPAaSZ2N1+vF7XY3eP/udNNP11xzDZ988gkLFiyoN6ABMJvNmM0iD4AgCILQDhzpcPhVMOR0iEXAYAFnRoNPqwiE+WbVdg5NDnCkZy62ym2UZxxFXimsiXRjVA8xdZVIpwlqNE3j2muv5f3332f+/Pn06tWrvbskCILQrgoqgvyeV8Gnv+WT4jAzfXQ3unmsuKzG9u6asJcsgyu7SU+pqqpionEVKW9eAmoMgLTfXiPNmUXe6XMorrSRKhL3xdVpgpqrr76a119/nQ8//BCn00lBQQEAbrcbq9Xazr0TBEFoW3nlAWa/sIgNu33Vx579fjO3TR7IuYf1wHmQBjYlvhAxVcNjM2IydM5pGluoGPdnl1cHNNUq88n4/nYqTnkWSGuXvnV0nSaoeeqppwCYMGFCreMvvPACF154Ydt3SBAEoZ2EozGe+2FzrYBmr/s+X8uxA9MPuqBmtzfIN2sLeeHHLVSFYxw3KIOLxuXSI9mGJHWu9L3mkt8hFo7bpmydjyNWgQhq4us0QU0nXM8sCILQKkp8Yd5YtIMTBybzh0McJFGJKhv5rczIA9+X8slv+dx4vLO9u9lmiiqD3PjWcnaUBThjiBObAb7b7mXq//3AR1cfRW6qvb272CTGSN1gtZqmoRBtu850Mp0mqBEEQRB0GnDjUWnMMP2E+6P7IazfBHPTBnDI6U/xwa7ONTJxoDYX+jl/mI3R8k7Sf38Qwn7O6jWF3eOn8urCbdx4Qn9sps5zu5O6jUrc6OmJYnW3XWc6mU6Zp0YQBOFg5rIYOCtlC+75f60OaAAoWkf2B2cwe0jnXEvSXIZgCRM2PUD6Z5fAtp8gfwXun+6j/8encd5AjYqqzpXjRXZmog09I26bNvnBRue4ORiJoEYQBKGTcURLcf10X/zGQBmW/F/atkPtrI9hN5YNn9Rt8BWSsfK/2ORONl1jS0Y66X6Y/KC+c0qS0bodAhd9jpQ7rr1716F1nvE4QRAEQReLQMnGhM3KriUw8pw27FD7cq17J2Gbdc0czMfeCnSyNUaOdDjschg8DdQYktHaYMI+QQQ1giAInY9sAHcOVOyI356RuHxMeyrzhyn1h/GForhtRlLtZhyWA78NNbS7Se6scxKSBM7M9u5FpyKCGkEQhM7GmQkTboUPr67bZrRBn2Pbvk8N2FVWxU3vrGDh5lIAZAlOHZnNXyYPIt1lOaBzSyPOhqUvxm8cdhZYUw7o/ELn0VnjV0EQhINb/5Ng3PUg77Mo2JEOsz8CV/0lZNpasS/EVa/9ysLNpZgNMmkOM4os8cGyPB75ch1VoQNc85LSFwadWve4Ix2Ouh6MBxY0CZ2HGKkRBEHojOypMP5PMOZC8OaByabfxB1ZHW6+pagyRHFliBfPzKGfpQLFX0DE2YOlpWbumrebPxzbl57mA7gd2dPg5EdgxNnw8xP6jrDBp8GwM8HTo8Veh9DxiaBGEAShszI79K/kjl0Lr7wqzFtnppHz2flQtrX6eHb2GAad8wSBcAvsTnKkw8CTIfdoUCNg8dQexRIOCiKoEQShxYQiMYp8IXZ7g8iSRLrLQrrDjNHQsUYOhLY11BXE+cbsWgENgJK3lD6/3Inv5Cdb7mIWV6MfGoxE0TQJq0kEP12FCGoEQWgRlYEIn63K586PficYUQFwmg08fNYIju6X2qkyugotyxYugtLNcdsMm7/EqZYDqW3Wn6LKICt3eXnl521EVZWzDsnh0NwkMt2iOHJnJ95lBEFoEesLK/nznJVYjDJjeiahaRqrdnm58tWlzL3uaAZkNv4TtNC1KFXFiRs1DSVS1WZ9KawMcsu7vzF/XVH1se83FDM428Xzsw8RgU0nJ4IaQRAOmC8Y5YlvN/KPE7I4NjOMa/vXqLKRyomT+HCTxos/buXuaUMxiWmog5M7J3GbwdykKaMDtXJnRa2AZq/VeV7mripg9pG5na6qt1BDBDWCIBywQCTKBcPsHL7xMawLarK7en66lwvH/IHvc84jFI2JoOZgZU+D3hNg8/y6bYdeBo6MJp0uElPxh6KYFBlbE3ZNBSJRXvl5GyO7u7jtKDfdTH4kNIpUJ48trOS1X7ZzyohsUh3mJvVH6DhEUCMIwgGzmw2MYg3WNXXT1TuWPsmRZ5+ExTioHXomdAj2FDjtKfjqb/D7e6DGwGjVywCMvUb//0aIqRo7y6p4c9EOftxUTLrTwuXje9E/w4nHZmrw+aoKo7KtnJtZQtqXs6GqBIBuZif/mnAfb3iHomnaAb1UoX1J2kH0L+j1enG73VRUVOByifl9QWgxgTJ49QzYtTRuszbwFKQznhNJ0A52IR/4iyDsB7MTnBlgaPzvxNp8L2f+9ycO6eFmVIaBoqDER7+XcOlRvbhoXC+cFmOD5/DvWo39uaP0wGo/vvPmYu11OIoiRhQ7msbev8VIjSAIBy4WgWB5wmapqhhiYRHUHOz25tVphjJ/mOe+38RHs7qTtvk9nLu+J2LL4A9nXMYHO7wU+0INBzWxCNYVL8YNaADsCx9B6v48KOJDb2clghpBEA6cxQ19JkLJpvjtA6aAqXk3M6HzCYSj5FUE+XhFHluK/RzTP43De6XQLan5O4t8wSjXj1DpNmcyhLwAGIHsdR8za9ztbC5Lh9QGfseiQeTdKxM2S8XrIVLVpguXhZYlghpBEA6cwQyHXwXL39BT1O/LlgJDTu9wqfuF1hGKxJi/roirX/8Vdc/ihg+X55HmMPPWFUfQO615wa1L8uH84fbqgGZf7p/upe/gaQ2fxGCFzOGw7af47an99YKgQqcl3mUEQWgZSblw6dfQ9ziQJD1F/eDT4JKvRP2dg0hhZYib31nB6cNTef/cHD6blcXzZ3SnW5KFOz5cRUUg0qzz2tVK5B0/x2/UNKwFixo+iWKAQy5OXD7hmFvEKE0nJ0ZqBEFoGbIC6YPgzBf2rK+RwJrU7DUUQue0tsDLa2f3ZMCGZ7F+9BpEgwx2ZTNy7O28XTGQMn8Yt7XhBb37MzSQOkbW4q+TqcPTE859F96/DPx7kgKaXXDyw5Amduh1diKoEQShZVlcB92n3apwlGJfmC1F+tRb7zQHqU4zVuPBV1OonyNE969vxrD9h5qD3jySv7iamcf/G788sHkntnogexTkLYvbLOce2bjzGC16zpzLF+g7sTRNr3juzASl6cGW0LGIoEYQBOEAVATCfLAsjye/3cjIHkmAxrJt5dxwQn9OGZ7VqG3G8URjKpGYhsUod6oMt93kstoBzT6Sfvon9kGTgGaM3tlS4JTH4PkTIRqq3Tb2GrCnN/5csgzubvqX0KWIoEYQBOEAbNrtI5lyPjhFI23jM2jIFJ06g1+8pWwucjEix9Ok8/lCUXaUVvHKz9vYUVbFkX1SOXl4Ft09VmS54wc3SuGqxI3+IkyxA6jzlD4UrvwRfvo/2PYDONLhqBsge4w+kiO0C38wSoE3yBe/F1DkC3HsgHQGZDrJcLV9CgcR1AiCIDSTPxRFCRRx4sZ7MG3+svp49srXmdLvZNak3EUg4sBqbNxbbSASY+6qAm5+Z0X1se83FPPktxt556qxDDyAoqCapqFptHpgJDvrKXkgK6AcQAkCgxFS+8HkB/RdUIoZrO7mn084YP5QlE9X5XPLu79VH3vhx60MyHTw4oWHkeVp2wKhIqgRBEHYT0UgQokvRKk/jNNiIMVhjlsPKBJT6VG5vFZAs5d5w6fkDDqLSCSXxq6LLaoM8Y9PfufacRmc0teIIRaiUrPyzLIqbnn3N1686DCS7Q2XA9hXqT/E5iI/by7eTiiicuYh3RmU6SK9tT5Fpw3UswWHKuu2DTxVX79yoIwWkcixgyj0BvnznN9wWQ2cNDAFlwmW5AVZvqOC/363idtPHtymNd9EUCMIgrCP3d4gf/vwd774vaD62KAsJ/89bww9U+y1HmvX/BhX/i/huVJ++x/RgccCjQtENuyu5K2ze9Bnyd8xvj0XNBVMDh449Fq+6TOZ8qpwk4KaEl+I+z5bw7IdFUwbaMekwL++Wo9Blvm/WaNbZ3rAmQWz5sCrp+vlEPZKHwwn/EPshuti5q0t5K8TM5mcWUna6icweksoG3wCBZOO5ZpPiyj2hchuw9EaEdQIgiDsURWK8vAX6/hydQHj+yYzMNVIvk/ly7UlXPziYt64/AjSnTWBgBEVwvWsEYn4MaA2+voDnSEyP7kSpWB5zcGwD+eP93HsUQqVyhVNej0bCyuZ1tfAn3N2krb6JYhFmDl4OjszJvL9hiLOHJPTpPM1imKAbmPgDwshbzmU74BuoyG5l77DSOhSBiVpDN/+Ic45/64+lrTlO5KcmTx36hxUtW3LS4qgRhAEYY9iX4htxV6+vbgnKZvew7l7MSFXLsXnzeaJ5VEKKoK1ghqsHrTB05B2x18cqw05A8nS+DUf6Vpx7YBmH67F/8Ey6iygcetqQtEYtnAJY5b9CcOOmgy6SXm/kpTcG9uUNyj2heJOqx0wxaAnXBRJF7u8MUkBLO/+u25DZQHdlj1GZMpjbdofkVFYEARhj3BM5T/HGsl9+3icCx+BLQswr3iZbm8dx825m4mGg7WfICtII84GR5zFsa5spMHTmlQeQindkLgx5EXadzqnAeGoSvfAmloBTbXSzaRv+QClCaNIghCPaePchG3GtR9gi1a0YW/ESI0gCEK1TEMljnnX6UUN96VpJH99A9YrFtZ9kqcHXPIl/Pg4rHpXLxExbCaMvRo8TZvekffNm5IxFMb+Qc92q6kgKRSGjMRKq+iR3HB9Ii0cIGn1qwnbnWveInb4hUDLrXcIR2NUhWPIkoSriVmDI1GVwsogO8oCBCMxclPspDpMOJqZ50doG3IslLhRiwFi+kkQBKFd2KJeKFobvzEaxFS+GdJ61W1LyoWT7oHxN+05UYpe5LOpknrpuVdS+8Ohl8HcP0PlngXLRhvJE+5kccUkMl29MRnqz1bsDUYbnKhSWiipn6pqBMvyiBSux7zpS2KWJHyDTkF1ZOJyJzf4/FAkxsLNJby6cCvT+xuxGCReWBnB5XRy4VG9SLG3whRZOyrzh4nEVFxWI5bOnnV6wGRY8GD8tj6ToAnTry1BBDWCIAh7yFr90zGKVk8xRoMFXNkH1gF3N7TzP0Dy7YY3zq6dOTdShfWrPzP49DepqMohzVX/zTCIEd+Q83Bs+Cpue2z4OSgtsb0aCJfvxPTuBdjyf605+MM9+I9/CN+wGThcSfU+P98bJClWwsNZ83D//DKEqziy9wkU9rmW33eWMX5A11hgXFwZYtHWUn7aVIyqanhsJs4c050eyTYMSiddDeLpAYOnweoPax832uCEf4qgRhAEod1Yk8DdHSp21m2TFUgd0Opd0NIGo67+CGX/UgB7pC56EH+PMUD927GTrTLm1J6Qcxjs2K+CdVIvtOFnJ65W3QTBYBAWPYdh34BmD/tXfyLU+2hoIKiRKgsY8t0VKLtrkg6aV79NzqbPMc6cS7EvqVELmsOxGIXeENtKqghGYvRJc5DiMDW7VEVLKvOHWbBqC4cmVzHe9AGWqnxKk45nZ0GUmNqTfhnO9u5i89hTYfJDMPAU+Ok/ECiDPsfBkdfqI5htTAQ1giAIe7myYOp/4LUz9XUs+zrmNrCntXoXZC0KBb8lfkDJJqxyPSNGeyTHSuGts+G4u/VP0r9/ALEI9D8RskdhUFpo2sNfhGX58wmbtd/fh6zE1a9VVcNdsaZWQFMtVEnykn8ROOkRoP6gJhCJ8cOGYu7+6HeO6u3CosCD2/1MHJjOZeP7NDlpYUsL+Cs4NvYDSW/cVH0sfdXbpCflkjftbSqqeuG2tW8fm82ZAcPP0qeb1AhYPO2WHLGTjncJgiC0kh5j4fLv9E+erm6Qczic9x4ceknbJI5TjKjZoxK3p/RBNjZicW9Vsb4e5/0r4NdXoOc46DsJNn+rT235Cho+RyPIaHrJggSUqqL6ny+Ba/17CdtNm+Zii8XJTryfvLIA3pJ83jkpyj2xf3FX1b28dvh2JnWLsXRbaYPPb232cAlJ826u21C2lZRFDxOrL99RZ2FP0XMRtWO2ZzFSIwiCsC+TDbKGw+lPQ9in1xey1T99kog3EMEbjCBJEh6rEbu5cW+58tAz4fuH61ajBph4B9gaXnyLtM9n1qK1dRdASy0zUiNZnKg9xiFvi1+ZmwFTGjiBBJZ6pl6MVowNLIoG8JcVMCXvCaxr3q4+lrppHqmp/dg0+TVKfEmktEZOnkYybf8OtPg7gczr3oeJtwOeNu1TVyRGagRBqFckprKrLMCmIh+7ygJEYrH27lLbMDv0T53NCGiiMZX1BZXc+NZyrn1jGVe/9iu3zvmNbSWNzDPjzoELPtJLDuxlssPJj0L26Madw5aaeLrMltwyNZgAoz0J9YR/glw3YFPTh0DGkAbPIY2+IGGbOuZisKXX+/xoTKW7uqtWQFOteAPpG95G0qIN9qM1mSL1jDbFIhgkkTOoJYiRGkEQEir2hXj9l+08u2AzlaEodpPCReNymX1kL9KcXWubbUvaURZgydqN3HWYimPn92iykcqcY/ls8TpOOXwg3ZMayDNjMOrTXpd9A/5ifZ2CPU1P8tfYreLOLJj+rL4+SN3nhi4rcPoztQOmA1Rk6UX6RXORv7oDafvPYLShjr6AyGHXYHQ1fB0pqRcc8QdY+GSt41rGUOQxs6GB9T8GCTyrX0vY7vz9NcKHXwzYEz6mtUl9JsC3/4jfmD0KxdL8CuxCDRHUCIIQV1U4ylPzN/HKz9s4cVAK/ZJkNleoPPv9Fooqw/z1lEFN3lXiD0XxBiPIkkSqw4wit0yelI4kFI1RVZrH6bv/D+v8d6uPJ/F3Zh1+A9tKkunm6YnUUI4YSdK3iDd3m7gs6+uDrvoJlrygLz7OGKqvDfL0aJGdTwBFviDR8jyU+bdDr/Fw+JWgRpC3/EBJWRmKMa3hwpm2ZBj/Jxh6Jix9EUIVMHwmUvaoRr5+DSkWTNwcC2FS2vd3Tfb0ROszEWnTN/s1KDD5wRYbOTvYiaBGEIS4in1hCkrK+WZ2JimrX8ZasIpg0gBuPv8iHlvio8QXbnRQE42pbCn28+hX61mwvgiHxcDssblMH92dTHf7LSpsDf5QlKzypVjXvFunzfnLY2TmTsQf7obD3AbbjI0WSBugV8eOBvVcOkrLXtcQLKfbN3+EXYthxy+12rK3fU/FzI/A1b3hE9mS9a9uo/W1J00oL4GswMhZdXOl7KENPg3J2oh1SE3gD0XxBiIgQZLN1HASPUca0mlPwW9vw8InoKoUrceRSMffrf8bCS1CBDWCIMQVDEe4a6SXtDdPAVVfR2PZsYjuK1/jtlNeoDgcorHD+ZuK/Ex74geOyPVw09GpVIYl3li8na/X7Oa/540hvaFP8p2INerFuvy/CduTfnsetc+hQBvmTlGMLR7M7GWLlCHvWhy/sWQTlnAJ0IigZi9J0r+aSMoaDt0O1YOrfVmTkI78Y4vtyFFVjR1lVezYuYNUYxCQWB+x0bdHN7o1NK3ozISx18DwGaCqSCYHWNs2OV1XJ4IaQRDi6m6owPbVtdUBTTVNJfWr67Bd8h3Q8KffymCEl37ewifn9yB983u4Nn0BZidnT7iUpWo/Nhb5ulZQI8egKvEWYiVQhKJ1ncXWSixQf3u44e3YLcKZBTNfgTUfweJnIRKAQafCYZe3aBK4wopKLEW/c9Qvt0HeMgD69TiKQvs97JYHkOFuYLu9LLfoeiahNhHUCEInE1M1iitDqGi4LI3fJtxU5nAZ+ArjNwbLMQdLgNwGz+MLRrlimEzP96ZCVUn18YxtPzFxwGn87rod6ELrCSwe1N4TkH99KW6z2n8Ksqn9Fqy2NNmWpI8CxeIkBJQkZFecCuatxZWlBzFDTteTJ1qTwdByCe3C0RiWyu143jkVYuHq48r2H8h6dxoVF8xDc/VpeL2U0GrElm5B6EQKKoI8NX8js19YxAXPLeLWOb+xsdBHNNby20GVBqrrKo3cgmqTwmT++u9aAc1elnUf0M9Y93inZrQgH/lHvfbN/uypyIOnNmt6paOSHRmoh1wat00bciayvf7t2C1OkvSioM7MFg1oAEKBKqyL/q9WQFMtWI5h9RyCkYazPXdWpf4wGwt9rNhRzrYSP75Qx3utYqRGEDqJ3d4gz3y7mhkDjMxwliKFKwmmDuWL5es4dmR/+qa3cO0Ye6peCylQVrfN5ABH44oMOrVK5HUfJGx3bPgA+o1tXh87qqRcuPRrmHsrbFmgJ8IbeLJessDTo71717JMNuSjbwSLC35+Qk9YaLTCmIuQxl3XJmtGqsJRQsEAWiyCbLLjaUJV74pAhEA4ilGRG0zOZ4r6MO/8KWG7fcd3RKJXgamTljuox87SKv752RpGpUE3h8TcYhU/Zq45tl+Hmj4WQY0gdBKl5RVcnbOdlDlX6DtZ9jhv8NlsKL0Jv9uCvSV31Dgy9TpI71xQJxNq5aT72VJhobsxRHIDNxC5gYWfXXKoXjHoSefOegWCFfrrtya3TZmF9uBI17dkjzpPX8tisOwZKWn9XEa+0t1Ed6/FtfxZlFA5Fb2n4B84Gdmdg7WeqVl/KMq6gkoe/GItq/O8ZLmtXDepL4f3SSElwe+02WIBRxqUb4vbrjqzMZq6Xv6mosogS9du5u5B+WQs+xd4d3FixgiKx9zA96u3M2V0b6ymjhFOSJqWIG9zF+T1enG73VRUVOByiURHQudSvG01qS8dVXfhLlA28QFiIy8ktaU/MYV8ULIRbcFDSEVriHr6UjT6Wp5bZ+J/i4q5eFwu1x3XH7e1nmAqUgWf3AwrEiRHu/Qb6D6mZfst1CumahRUBNhaUkWJL8SATCdpTku7F31sKl9ZIfL3D2P79enaDc4sgud/iiW9T9znaZrG12sKuemd5Zw/KoUhqQp5fpUXf63glOFZXH1s34TpCmJrPkF5a1b8tku+Rsk59IBeU0e0q7AI57Kncf38UO0GSaZ42utEek0gq6EF0geosffvjhFaCYLQIMfGj+MGNABJS/+P4NCpQLeWvajZQblnMB9m/YUe/WV6uyEW8nPmQCNWYwbPL97BOYf1qD+oMdrgmD/Bxi/Bv19xw2FnQVLPlu2zUK9oTOW3nRVc+MIibCYDDouBXWUBjuiTwgPTh3WoqYSGKL48rPsHNACV+cjfP4zvxIdwOOqOjhV4g/y4ZjtfzHSTtvhBDBtWgKsbpx53PV9UBOrNwaT0OAL10MuRFz9Tc1CSUCfdjZLar6VeWofijpXhWPhI3QZNJfXbP+Hr9jmQ0+b9ikcENYLQSZgrtiRurMzHpLTOoGtFIEIkHGSk/1eSvr5X364sSfTpcyKnnncnS7eV0S+jgfU8yb30lP+/vQ1rPgazE468FrJHdZpMqv5QlGJfiBJfGItJIdVu6lQBwF4F3iD/+Wo1b5zVjVTfWpSqIoJpI1hSZuTln7fyx0n9MDWigGRHICdItgdgWv0u2oTbIE5QE4zEuKZ3IalvzaqZWq0sIH3X+Zx2xM3s8mdAaoIdavZU5Im3w2GXwtYf9Z1fPY9EdqTrv9ddkLlsg76bLJ6KHZijFYigRhCEJtF6T0D67Y34bdmjkOPttmkBZkViumM1SV/cvM8FNYwb59KvfDO2aXGKCMbj6QFH3QCHXKzfCDrRDUCvgbWNbKOffkkylTGJt7aonDu2DwMyO8/rANhRXMGDh1WR/v4Z+vqXPTK7H8macY9R5AvTzdO6UwktRVbj7ELaS42SaLVWOmXYv/1T3KrZzl8epcfIs+u/sNWjfx0kmYDlBtZGKUrHCSXElm5B6CTk3HH6gsw4pOP/rqeYbwUplJH8873xG4vXkx7Z1fiTyYrez04U0MRiKmu25XF22lbO/P1qRswZz+GfTeZPxreJlO8ir7z+5HMdTX9rJekfnVcroAEw7PyJPhv+hxJvu3JHNfjUhE2xfpNRbJ64bZaIF7wJfm81FVPZhhboXNehpPVLvOg7fTByK733NEenCmoWLFjA1KlTyc7ORpIkPvjgg/bukiC0HU8OXPQ55B5Vc8ydA+e8CZnDW+2yxlgQvHkJ25X85a127Y6gxB9mUHQd6e/NgN2/6wfDPhxLnmDg99ehVBXVf4IOxlm0rNbuuX3ZVr6KKxZnC39HldSL2ICT6x43O+G4O1Gs8ReUKg1U/VaMXW8H0wFxZMC0J+vuYjTZ4bSnEn7Yag8dZ8yoEfx+PyNGjODiiy9m+vTp7d0dQWh7KX1h5qv6uhY1AhZ366dcV0z6Yt9IVdxmOamL5V3Zjy1SiuP7v8ZtM+xaiK1qF9B5fgaKr56RtUgARQ21XWcOkNGVTuzkR4kOOhXDwicgWI7a90S0I65CSc5N/ERbMqQPgsI1ddsMFqSUvq3W507JaIH+J8GVP8Li/0HJJug5DoafpX+w6kA6VVAzefJkJk+e3N7dEIT2ZU3Sv9qKIwNGz4ZfnqrbZnJA1si260s7MKtVUJx4OsKyayH0TZw8MBiJYZQlFKVjDIxL3Q9J3JiUi0HuXHmDFFcmjDwb+h0PagTZmtRwfhxHOpz+NLwwGcL+muOStGfkoQ1LO3QWZoeee2nyQxALgcHatErqbaRTBTVNFQqFCIVqPnV4vd527I0gdFIGExx1HRSvg03f1By3uGHWu+DKbr++tQGD0aSPViVYayI74w+97yyrYt6aQr5ZW0iW28L5R/SkR7INZ33b39uA5OqeeJRi3HWwexWk92/7jh0oe0rTHp8xVB95WPkubP8Jkvvoi9iTerRYRe8uSTHoXx1Ux+1ZC7jvvvu4++6727sbgtD5ObNg+v+gMh8KV4M9TZ8Kc2Xri38byRuIoEH9eW06GMmehjZsBtLyOMkDZQNK7pF1Dm8u8vHUvLXMGmJi/GEqMSXGt79vYrk7hdNGdmu1IqSNIckKHP93WPYqrP0U1Ci4uuk704rWobTi+qwORVb0VANH3wTRq0ExQwNrbYSOr9NmFJYkiffff5/TTjst4WPijdTk5OSIjMKC0MYKKoL8tKmYuasKkIBjB6ZzzIC0Vs9C2mIqdqK9eiZS0T6jG7ICM16GvsfV+mTvDURYtnYTo0o/xfXLo3otJCDW4yi2H/0gSnIveqS0zvb7RgmUw3uX62UM+h4HaPqxpS9C/nK4Zimk9G7zbpX6Q+wqC/DhijyiMY1ThmeRm2ontYF6TMLBQWQUBsxmM2az+IMQhPZU4A3y3sJ1nJgrM67fBiRNxe8x8+EvJUw7fGC7BjYl/hAxXxlqoBxJlpFtyZjs7rojSe7uSBd8AEXrYPN3+ghV34n6CNZ+UxWBcIQRlfNxff/3WseV7T/Q67NZFJzxPtCrVV9XvaweOPEeeP5E+PWl2m2TH2qXnSyl/hCPfLmeD5bt4tDcZGRZ4tKXlzCmRxL3nTGMdKeYDhIap0sHNYIgtL/ykiJmmb7D/eadNVlJJYlzj7iZncVJZLp6tktRy7JKP9LuNaTOvx1550KQZCL9puAb/zcqUnrhtu5XB8mZqX/1Pqbe87oixVh/eTjBRbfg9G+lXYMagNR+cPl8ffpp41fg6g6HXgJJvdql6Oa6Ah8DXBG+nOkkZdPbSGqEktHTWFJp5OdNxUwb2b3N+yR0Tp0qqPH5fGzcuLH6+y1btrB8+XKSk5Pp0aPzbKkUhINFZTBCamg77u/uqN2gabh+foiM7MMpD2SRZGv7EVWTdyv2N6dAdM8UtaZiXP8JSXmLCMz+Cqy5zTqvUQvVrXG1D3Px7zDg2Gadu0V5esARV8GYi0A2ttt6kmAkhuov5Myy57B9/2r18ezlL3JSr0msOuReSv0NV4MXBOhkyfeWLFnCqFGjGDVqFAA33ngjo0aN4m9/+1s790wQhHgMaoik5XEKDu6R9OvjmKLx89+0Jl+lF+NPj9UENLUaC4mt+4JoLEGtmwYYjBY9KVkCUjusV6mX0dKuC2RjqspAeRe2Va/WaTNtmUevil8gYcEDQaitUwU1EyZMQNO0Ol8vvvhie3dNEIQ4rFIUpXJnwna5Mh+bHGn5C6sqhCrjBy2AIeLFtP37hE93bPkCLdLM8geODLRDL4vfZvGgZA5r3nm7KJscJem35xK2J/32P9yaSMchNE6nCmoEQehkTA7UnkcnbFZzDkcyt+BORE1DK91K7IfH4PWz0N7/A+qOxfrunn0YDCawJq5Xo9rTMTY3Vb7BhHTEVTD49NrHHRkw+2Nwi/Uh+5LUKHK4nqAlVImixdquQ0Kn1qnW1AiC0MkoBuRDZsPiZ+qWWVBMyEf+sUUTncWK1qE8fyJKsBzQJy2k398lNvFOlMMuA4teSNPgSic69loMH14V9zzqoZch15NgrNgXoqIqgiSBx2asu97DmQlTH4OJf4HSLXoGaFc3fddUOyyK7tDMTtTBpyNv/SFuszZgClJbZtAWOjUR1AiC0LrcPfRCnB9dCwW/6cfSB8HUxyEpt8UuowXKkD6/BfYENPtSvv070YFTMVhqqoPLfSehDp6OvPq9Wo+NTfwbhtQ+ca8Rjsb4Pc/Ln+f8Rl55EFXT6J1m54EzhjMw04WqaVT5ypHCVWgGMyZXb6ypnTA7bxsqqgxhzpmAy90dKvabqrR4kA67TM9qLQiN0GmT7zVHY5P3CILQCvzFECgDTdNzpbRwPpRI8WaM/zcqcfuUxzAedvF+fSpBrdiJtnGeXsiw33HIzkywxH9/2FhYydNfr+LS0U5cgZ0gyZSZs3lqSSV3njIQS8UWzD8+jLFwBbi64T38RpTuo7F7Ok4V446mcHceqXnfIjszYNV7sPoDUKNoA05GPeZWIkm9sRg7TwZqoXWI5HuCIHQs9lT9q5Woav27laKRMHVujfYUZHsKZI9o8PzBSIwtO/O4PXspnnfugpi+wDnLYOGBac+jFC7B/OZZNbl4Knbi2jGTqqP+gv/wK7A7PU1+TQeDlFgx8od/AMUIg06Fkx8FWUHasgBp3VyqRl0ughqh0URQIwhClxAxOjFnj4a8X+O2a7mJFyw3hj8cZZQ5H8/822s3RIPYwsXw9UM1Ac0+bD89QGj4mSCCmjpi0Sjyyrf2fBOBVXP0rz1kZybOwaeBo2f7dFDodMTuJ0EQugSTMxXvcQ+Coe6uJf/wi4jZDmwKyEGA5F//E7/R6oGKHfHb1Bha0doDunZXpcYiSL7diR9QVYKM2PkkNJ4IagRB6BJMBoVo2mCKz/uG4NBz9UXI3Q+h6JQXCR11C3b3gU19mbUIcvm2+I1S/W+lsljoGpdiMKH1mZiwXetxJJoxcSJDQdifmH4SBKHLSHbaKZX7U37svUSrKpANJhR7MikOM7J8gFupzXa0rJFIJRvrtpVvh7SBEG9ExmBBSu13YNduYZXBCMW+MOFoDJvJQLrLjNlQk1U4ElUp8AZZnVdBWVWE3ml2eqbYyXC1bGFJWVH0XEVJvaBsy/6NMPEODK6MFr2m0LWJkRpBELqUZLuJzJQkuufkkp2VTYbLcuABDYDRhnTUDfFHZZa8gDbtCTDaah+XJKKn/AejK/PAr99CdlcE2bxlE6bCFbh2zoeitazeuIVin559ORpTWZdfhrdgMyMDP3O8/2O6+X9nw+ZN5JU3M8tyfdw90M59G4aeoS8WBsgejXb+h0ST+rb89YQuTWzpFuoo84eJaRoeqxGDIuLefYWiMQLhGDaTgsnQfvVyhKbZ7Q1S6g8DkGwzke4yN68yeCQA2xfCh1eDd5d+LKkXnPYUdBtFtHwX0oo3UXYuRE3qhXrIZRhS2qfydTyl/hCR3evJ+Pg8KNtafTza8xiKj/sXyVk9KfMFkPKWkf7hOXqpiT1imSMpmPw/PJm9sJtbfpA/WpGvZxZWVTSjHcXTHWTx/iPoGnv/FkGNUK3QG+SHjcW88vM2QlGVYwemc/ahOeQk2xp+chdXFYqytaSK537YzKYiP8OyXVxwZC49km2YjSK46ahCkRhLt5dx09sryK8IApDltvDQmSM4JDcJS3P+7TQNKgsgUALIYEvWMwjvpcb04Mdgrhl56CAqi7bjfO1kfbpsP+HBZxI44WGkYBmuF46BUN3SBaFBZ+I/8RGSPZ426K0g1Gjs/VuEwQIAhZVB/vvtenoaynjymBjPHRPg9NwIr32/mu2l/vbuXrsKx2J8u66IC19cRK4jxsUjrLiUEOc8s5Al28o4iD4XdDrbS6u499PV3Hd8KvPPT2P++Wncf3wa989dw/bSZlYHlyRwZUHGUMgYXDugAX0tiNnR4QIaAENlXtyABsC09n0s0QoMJeviBjQA5nUfYIuUNvm6vkCQqqJteDf+TMXa+VTt3oTXW9Hk8whCQ5o9hrhx40Y2bdrE+PHjsVqtaJrWvOFcoUMoLqvkql4FpH12WU2aednA1Yddx9oCNxmu3rUWEh5Mirwhtu3axUenQPrSO5HXbSGaOpjzz7iel1ZvpU+anUy3tb272elVBMLIvkIkLYamGMGehtPS/MAgFI2xcP0uXpgQJO3rK6uni3Jd2Qye9C8+X7+Lnin9Dqrfa8VfkLhRjSHHQshVhfU8JoqihuscrgpHKfaFKagIYDIopDvNpDvNGBQZn9+PtP0nbB9eWvPeohjxH/ln/GMuxO5JO7AX1Rl482H377D2Y7Cnw9Dpei2wBJmrheZrclBTUlLCzJkz+eabb5AkiQ0bNtC7d28uueQSkpKSeOSRR1qjn0Ir0jSNNK2YtA/Prc6SCoAaxbnwEXqnDMIbyCHNefC8+e8rFKziXNtiPO/dWn3MULGTzE1fcunJ/8Mb6g/oQU0kFiMc0TAaZEwGMRDaWFVlBUhrPsO56DF9JCF9EN5xt1PZcyxOT/O2YleFYpyYHSTttbP1KaG9vHmkfXgOJ82ahz8UPaiCGjk5N3Gj0YpstELW8MSPcaTXqp8F+hq8NxZt59etxUzoYSQYg883hbjhuP4c1isJk28XpnfOBjVa86RYBPv3/6QqYzCae0q7fiAurAwSUzVMBpmU/QuTtoSKXWivzUAq/L3m2IIH4aT7YeQsEdi0sCa/695www0YDAa2b9+OzVaz1mLmzJnMnTu3RTsntB3Hhg9rBzT7SFn8CPZoedt2qAPJlL14vr8zblvKt7eQLpURjsYIFG8nsPoLtO8fIbjyQwJFWwmE4/9MhRo+bxn88BiuX5+Eo2+Gma/ChNtwmcCcv4RAMNis89qUKJ4Vz9QOaPZSY3hWPItdObgSuxnc3dCyR8dtUw+/CsWVgeLphpZzRPzHTPwbkjOr1rHV+RUcnx3i0ayvOG/tH7h06008N3IDwx3lyIWrMfz2eu2AZh+2Hx8gUFHPyFBzhKsgGmrwYSW+EEs25lG6ayOVO35n9/aN/L6jBG+gBf9mo2HUhU/WDmj2mnsrVOa33LUEoBkjNV9++SVffPEF3bt3r3W8X79+bNuWIDGV0KFJmoa1dHXiB5RtwyIfXG/++zIFChK/SVaVYo56iRZvxPraNKz7vklZPARmfUg4exgmpXOPBoQiMQorQ+z2BlFkiXSXhXSHGWMLjEYZgyWYCxbDcXfrb/R713wYbZiOvpFoxkCw5Db5vGY1AIW/JWw37V4BsQBwEC2Ed6QhzXwF7dMbkTZ8qS96NphRD7sC+Yir9MXNjnSkGS+gzb8facUbEAuDIwOOuwu5/0m1diSV+kP0VEro/sHpsE9mYE/eMug5DsZdB8XrEvenbBtygg9TTRUt2wGbv8Oweg6qyYl66GWQNhCDs+70VmUwQqB0F0NW/gfr76/rf98WN95DrqWCs7B364HSEmkAqoqRl76YsFld9T7ysbcmbBearslBjd/vrzVCs1dpaSlmcysM3QmtT5ZRc8Yir/4wfnv6IH1Y+iClKPX/mcgGC5b3Lqn7qStYjvWdcwnO/hJSusd/cifgDUT4dGU+d3/8O8GIXtvIaTbw6MyRHNU3BavpALf3lm2FCbfCOxdCeJ9F6ZEq+OafyGmDoL5pk0SMVrTkPkgFK+M2ayl9kA7G32t3d6Tpz4K/SB/VsLiQHZlg3Cexnisb6aQH4OibIBYCkwOcWfoi6X1Iapjklf+rFdBU2/YjHHktHH6lvp4kTjZmNW0givnA/w2ipdsxvHJqdQI/GZDXfEh01IVEJ/61TmCjVZWS/t2fMW36suZgsALXD/9EjgXwum4gyV17mq05ItEoxrAvYbtaVSp267SwJv88jz76aF5++eXq7yVJQlVVHnzwQY499tgW7ZzQduSBU8Cc4I/4uLv0basHKcmVDeYE897uHLRoCPJXxG/37kKqb+FlJ7BudyW3vbeSYETFbTXishioDEW54pUl7Cg98GRsijMDdi2tHdDsQ55/H8HyeuoDJWK0IR11fcJmadx1YDqIRmn2ZXFDSl99/UxSbu2AZi+TFZJ6Qmp/cGXXCWgAbJEKbOveT3yd396CTd/A8X+HgSfXaVaP/StGR8oBvBDQIiG0hU/WzUgMGJa9iFZWN5gyBoprBzT7cCx5Ekuo+ID6tFdQthLrmbiQqr/XCS1yHaFGk4OaBx98kGeeeYbJkycTDoe55ZZbGDp0KAsWLOCBBx5ojT4KbcGdAxd+Bvumc7cmwelPQ9aI9utXR+DIhOnP1s0kq5hg+rOo0bq7QWrZJ4FZZ1MZjPD4vA2cPTKFry7swRcnh/jyVJXPZ/fg+P5JvPTzViKx+FOT0WiUqsoyQoHEn1QBJFcWFG9I/IDi9UixBn7GiST31RPj7TsiY7TCtCcgpX/zzilUU7Ro/XWvJFmfTnz3Ihh1vj6NBWBNInra00j1LUpupHBlEcbfXk/chRV12xRvguKjAJEASiT+lvamCihOSsb9Le72/mjmKCodfVrkOkKNJo8bDx06lPXr1/N///d/OJ1OfD4f06dP5+qrryYrK6vhEwgdkyzrn9ou/BSqSiAW1UdnHFnQydeDHDDFAL2Pgat+hiXPQ9EayB4No88HTw+08jz9RhmJM2ohScjubm3f5xYSjKic1MfCydGvcL99X/WCz0yDhfsmPcJ7gREEIyrGfX5H1JhKtGwb6m/vYNvyNTF7OqHDrkJNHYDVVXcnk2JLQs0chrxqTvxOpPTRt3g3h8UJQ6ZD7lFQvudG5snRt9XuPzoR8oO/UP/9N9rAngqOA6vs3dVFQlUYBp0Ki/8X/wH9T4S5t4Gmwo//hnPeRNU0VHs6Bld2y7y3aJq+7icBKVr371K21z86JLfQCF6aw8z8SBaxsz4j/ed7ULYtALML34iL2NrrbNzi96vFNWsy3O12c/vtt7d0X4SOwJFR82lKqGG0QvpAOPFeiAbBYK1+Qza4MokeeSOG7+6p87ToyAuQ7J0jD0dxZYi8igDrd1eS6bLQO82B22Jgcmoh7nf/UfvB0SDJX1zNmbO/xbpfVt5Y8QZML54IgTIAFEBZ+zHBI28mMPZqrM79pjJlBXXgqcjfPRA3MAwd/RcsngOonWS0gKeH/pWIrxD1u4eQlz5Xs1sqfTDaWS93uGKUHYmy7BXofxJs+Krumpl+J+gBYlWJ/v2OhahIaJkjMLTgNvqYxUO4/8mYfn83bnt48Fnsv2pHdncDd3eo2Fnn8VrviRgcLfM3K0kSw3um89yPfuwZf+Pw0SYCEY0560KcPyidLJHfqsU1OahZsGBBve3jx49vdmcEocNTDKDUruMjGy3EDrmIqD0Fw4IH9EWT1iSiR1wLI8/DYHO3U2cbL688wFPfrGdyLgw1RQmHjDw/P8KV43JIWfLvhM9zrXgOOecxwARAsLIM45d/qQ5o9mX56WHCw2fA/kENgCuH8KwPMM2ZrZcgADCYCR11K1rPsS3wCusRi6Aufh558TO1jxeuRnp5GuolX3Xq0bbWJKPCR9fAyY9A0TpY/4X+AWDI6fqo3tx9dvZYk9EsSSgtnBfIZncSGv9n2PQVBGtnKY72PFqvnr5/v93ZaOe+g/TKNPDts+YtfRCc+m+welqsfykOM384pg/FvjA7y6qwewzc0sdChsvSMjushFqaXPtJjlNgbN/ESbEE8+sdgaj9JLQqTSNakYcWCSIZTC03vN7KfMEIy9dtZmjFt3gWPqh/slZMBIfMJHj4dXjePbNW8cNaeh4J57xVnUAsVLQF85Oj9CmBOILH3Ydl3FX6TrFgBcgGsKWALRk1phKp2IXkL0aLhZAcGWBPw2Rt3WKQsbLtKP8dl7A0QPS8jzD0PaZV+9BZRbcvwvD88fo33Q+FyQ/Citdh3VyoqL1uRT32duSjbmqVv4mqUASpfBvSwqewbJ4LJgeVIy/FMGgy1uR6dh5W7ILSTVC2HdIG6KN5zgQj1aoKFTtQN3yNtGMhWuYwpEGnILlywNDxSmJ0NY29fzd5pKasrPYnsEgkwrJly7jjjju45566w++CcNCQJAyezveJ3h8MM6z8K9zf7jOlHAtj+e0VjKl90LJGICUKarofDkZ79bcSWsKABkBO6gHr58KnN4I3DwCt2yFI055ATh+IOTkHknNa4mU1WiwcQEkQ0ADEitaJoCYBQ3Iv1EHTkNd8CDsXw8InIXsUeGtP62i545FHX9BqQb7NbISMvlRMvJvIkTeALCPZ07FaGrjFubvpX70avkasYCXKSycj71n4L618G779J7Hz3kfpMVZUFO8gmhzUuN11h9KPP/54TCYTN954I0uXLm2RjgmC0DackWJsPz8Ut0358RHUCz5CWvOxvthzXwaLvlh630XCFhdqj3HI23+Mc6FMjDY3vHRKrcPSriXw4mS4/Lv61720kphs1tMZJNilFksSO1QScqQhn/wwsaFnoCx8AnavQu0zCekPv8DWHyFQhtT7GCRPT2ihdSr1cTsd4Gz5kb2YtwBlzsV1f0eiIZS3zyd62XcYkto2GBfiO8CsWTUyMjJYt66ezJGC0MVpmkZ+RZCiyhD+cJQMl4VUuwm3zdTeXauXMeqrKTS4v1AlapUX+bw58NG1NQsrU/vBaf8FT89aD7c4U4mc+ADyi8fXWfQbPeE+lG/+Gf86VaXENn6DcsiFB/ZimiFkTkMdfQX2nx+u2+jKRk3p2+hzlVWFKfOHicRUnBZjdVHHLs2RjjJkmr5DUI0iWzz62rO0Ae3dsxaj+otRSjbGb6wq0dfRiaCmQ2hyUPPbb7XTjmuaRn5+Pvfffz8jR45sqX4JQqeiqhqbCysIle4kI7ANOVBEKDyY3wvc9M3tSbozTnKzDsJgtur5RPYfidlDkmXoMwEu/RqqSvXH2lISbndWMgYRuex7+PkJjNu+A3sqoSOuw5A5BKkgQZJCQN4yH8bMjpvkrTV5XHYKh89GrirGuvKVmt1PaQMonPIcBlvjdl7tKvVRUbgdT6QQa6iSiLsna0o85GRl4unggW2LaMHFtR2NGq2/lEMsHGi5EQLhgDT532HkyJFIksT+64uPOOIInn/++RbrmCB0JsVeP56SFaR+NKvWEHVG7kSKPY8SsfXE2EE/sUv2NLSBpyCt+ahuoy0ZJbW3/v/OLP2rAbLBgJzej+jkewn6K5ANJszOFKpK87C5sqFkU9znhdx9MAPtsR/E6sli5yG3Yhp6GcZwOarBSoXkJi2lO8mNqNxcVOHHtHs5gz++oGYLM1A19Fx8tr+ArYt9ivcXga8QrXI3kiN9TyqIzpG6oDlUS5KeVTze2ivZgObMbvtOCXE1OajZsqV2KmpZlklLS8Ni6bifRAWhtVkCu3F9cLZer2gfpq3f4FnxLJXuv5Dsat1dPM1mdiKddC9a2Vakgn1GYq1JcN570Mw3bIPJhmGfJGZBUwqhMdeR9OUf6z5YVggMnI6ljUdp9nJajThzsiiqTCYQiWGQJfo7TbWSCtbHUlWA870Zdf79bateJ5bcjzLnVSQ5ukZOEq18B7xzIdKuJTUBaOYw1JmvIifltn4HYmF9kfnm+XqA3HMsZI7QF/y2krAtncj4v+H66uY6bb7DridmTkHcATuGJgc1PXv2bPhBgnCQUfKW1Lmh7WX77UXkI64AWi6oifhLwV8KagTN7MKUdIBv6O4cpFnv6ttwC1bpicnSBoCrW4vt6kiym9ja7RjMIy7GtmKfUV2jlZKTniJkyyapRa7UfGnO5hXllXf8nPDf37nk/wiOmAGOLjBaU1UGH1ylL+7eV8FKpHcuQjv3baTWHLGJRWH7L/DaGXplbYCf/qP/nl74CST3bpXLuu02SgZMo9iWReov90PRWkjKpeTQm6DXMSS7On4uqoNFo4Ka//znP40+4R//GOdTmCB0cSZf3cyk1cJ+FK3+OfmmiBZuQPnsBuSt3+sHPD2JnPQQWo+xmGwHkH/JmaF/dT+kZTq6H0mSsCdl8lXWZYwYfCHWsrVoRjsl1lyK8TDG0UFHshrBVJ5gESlAVQmyFm27zrSiaGUhhr2/d/uR8n4l6itqsWy8tYQq0SoLQI0ivXlOTUCzl3cX2sfXIZ31Squt7UlJTafAeBzbUocjRUNoshGTJ4N0p6VWrjahfTUqqHnssccadTJJkkRQIxyU5O6HJm5052Cw2BO3N0G4ZBuml6fUzoJavg3jm2cRmT0XerVy9t0DlO6ycPSwPuRXBPmp3INFUhiTnkQvpxmbufMutZTqCwSTcjGYOsbUU0UgQlU4iixJpDnMyE3MaKs2UJxVDVTUORaMxIj4ipEC5YAGFg+KIxWrqXH/3lplASx/HWnRMzDpjoRb76UtC9D8JUituGA5020Bd9unHRAar1G/VfuvoxEEoTYlrZ++zTlOtWn1uLuRG7HAtjG0LT/UDmj27cM3dxKa8TrmOEUjO5Jku5lku5kh2Qc4ZB+L6QUoNVXPM2NpvyzhcvZIcGbWlHjYR+zYv6G4DqB2VQsIRmJsL/FTtHsnHiVCTFJYjZshOWmkuywEy/KgbCvqruVInh7I2cOQXdkYjbUz5apml747LUGCRdVaewLRHwxC4Vqcc2+AvF/1g5nD8Z/4KL6MoThsjQj2Ns1Hmnc3uLIhWH/17GgkiMjte3DrvB+NBKEjcWXBee+hfX4r0vrP9RutPQ3t+L8j95nYYpcxbv02YZuctyx+pfCuyJuPuuwV5EXPQLACrfcxMOkupNT+YGj77dOypzva7E/h/Stq1ptY3KjH/hWl77Ft3p/9FRYXk7R7Kf1/uBOK14PBQmDIORQ7riEcMWJ662zkwtU1TzC7CJ/7HtFuozAYam4TIXMK0sDpmNfUrage6XMC4f0WzBq8OzG/OgXC/pqDBb9hf+1kQpd+D7b6c9nEKvJQ5t+rf+PbDcn1pP61pxE2OEVQc5BrVlCzc+dOPvroI7Zv3044XLvk+6OPPtoiHROETsfTA2n60+AvhlgITE4kZ1aLpk8Pe3on3mXhzESTOua28RZVuRvtnQuRdyysPiRt+Ao2z0e9ZB5y9oh26ZaU2hdmvQ3+Ev3f3+LRR+iU9v3sWO4P4yz6laQPzqk5GA1iXfEC3VJ7ws7FtQMagJAX05szCF26AENKzXSL1emh4ug7cclGzGve0XP6SDKRAadSPv4uXI6aYqXhcAht6Uu1A5rq64dg4ZMET7wXizXx1KwWDddU/1ZjeimGgafA2k/qPLb0qLsIGVJpmYleobNq8l/bvHnzOPXUU+nduzdr165l6NChbN26FU3TGD16dGv0URA6D7NT/2ol8rAz4MeH4ibKCxx+HWZP18+XES1aj2GfgKZaLIL05e0w89X2SwRnS9G/OhBjsBj7gjvitslp/eCbv8d/YqBM3zK9T1BjUhTMSdnkj/sH8qhrkcI+NJODqCWVZE8yZuM+JTOClVh2/pCwX+ZdCwmEKqGeoCYqGTA4s/QCqAA//AumPQGp/eHXF/VkkKn9KB57BwtCfTnOIsZpDnZN/lh32223cfPNN7Ny5UosFgtz5sxhx44dHHPMMcyYMaM1+igIwh4xRzbB018ApfYUS3jo2UiDTmnyws9Oad3nCZukrd8TCdS/7uJgY4xVxV3rBeijHwkySQNocdZvuaxGcrPTcWX3x9BtBM6s/vTuXjdrssFkJeZIHGSrjowGF1Cr9gzUo27c50AU3r8Cdi2FE+9DvXoRnx/yHDcsz+SQgb1wWUVQc7Br8kjNmjVreOONN/QnGwwEAgEcDgd///vfmTZtGldddVWLd1IQBJ3V7iTY73jCVy0imrcSLejFkDOamC0Nm7t5W2k1TSMcVTEoMkonCIoiJnfiNy6jFVWr5zWU74CqYghX6Qt7HemtOrLWEShGk158NBqs2xgN6UkWA2Xxn5sxKOF5PTYTnnqua7DYiYy9BmVd3akigNiRN+gFTuthMxvx95uKtXQL8uKna0pYFK9D9fRkYYkVR3IyD53p1HcmCQe9Jgc1dru9eh1NVlYWmzZtYsiQIQAUFxe3bO86uKpwFK+viqh3N1osjGSyY3Jnku4Sf1xC67FY7WDthSk1waJJTdNvUpKk37ASUFWNneVVrNxRhq+yEoPJwrAeKXRPsnXo7dWxAafA9/fGbQsMnUXIlESdFHrhIFrxOqS3z69ZoyHJaKNnIx37l4R1rLoCxZGOOnIW8pLn6jYufwNtwm1In99Sp0ntdQyKoqB+808kRzpSn0l6IGhq/KoVKW0A0Yl3Yfj27podU5JEdNxNyFnDG3UOW1Im5UfcjGXkhRj9+WC0EbWmUGnJ4rDulq5fMFRokia/cx1xxBH88MMPDBo0iClTpnDTTTexcuVK3nvvPY444ojW6GOHFIzECJXuwrn0aewrXoKwD1L6UHrUnZT1OJKklK5bB0XouLSKXWhrP0Ve8TpIErHRFyP3m4TkqjsNsK24ErliO+Pz38dZ8AshZ0+KXReyqSqb/jmZtdZHdCQReyYV4+/GveDO2g2p/QgedjUeR92brla+DenV02vVZUJTkZa+gOrqhnzUjdDIkgidjtGCfPRNaLuWIuUvrzkuG1APv4JY5kg02Yzpu3v0dAEGC+qo85AGTEH638SaER5JRj39WeSBkxsd2BjsyXD4ZUQHTdWnjDQVuh2CwZXR6C34kiSRlJRCMOwh35yDQZZwWYykWTpu4C20H0nbvzJlAzZv3ozP52P48OH4/X5uuukmfvrpJ/r168ejjz7aocsoeL1e3G43FRUVuFwHltPCV5KP+aPLMW5bUPc6U59DGToNu1nM73Y4sYgegCpm2KcuUVcQK9+J8uppddZPaNmj0Ga+TqmcQsxXhBqowOmwI1WVYH99ap3dKWUnPk5s4DRSkzpm6vdoTKWgsAjZuxPPxvcwBYoo6TmZQOpQXGk9SHbUHqdRq8qQ130KH14d/4QWD7Erf0DxdOAyBpoGWgzkA7iRV+6G0k2w7We9AGXuOL1AqdECqkqoPA8pUoVsMCJv/wn54z/qa1j2JUnErl6KktrnwF6PIDRRY+/fTf4LuffeeznvvPMAfSrqv//9b/N72YnJvry4AQ2Aa8GdVOUeAebubdwrIaFYlGjpVljyHIYdP6M6u6GOvRbS+uufJjs7TUP7/YO4C0KlvGWoW3/A4OxD6hd/hN2r4Ph/wG9vxt1um/T1Tfh6jQM6ZlBjUGSyM9LZbXORnzSASEzFYTGQajXiiLP7RQ1XIZfUU8YgWI4aDtIRx2nC/jIM5VuRlr2C5CvQq6n3Gq/X5mqqvWUweh5Zt02WMSfr54yV7UD+/E91AxrQf8/WfwGpf9jbQQj59DU71o75+9LVRaIqeRUB1ueVEwz4sNoc9M/y0C3J1inWyLW0Jgc1RUVFnHTSSaSlpXH22Wdz3nnnMWJE++SFaE9y3rLEjRU7USJxcjMI7SaavxLDS5Ork9PJLENe9wmRSX8neshFGKztl422JUQqizD+9nrCduXXF/FkDdcDGtCTmO3+Pf6DY2EMJeshs+N+GpdliSx3I7LRRkPI0Srod6Je02rDV7D8db3S8172VGKKucMlbYuU7sDw+zvI8+6uPiat/XRP8cbPIDm3Va4bi8VQ4uWW2UOtLIBoiFjhOvj+YZT85Wi9j0E79DKwuJFNNrCL6fe2oKoa2wtLsPh2cNSmV7CWraMqdSil5llsj+TQK7MLfGBroiavsPrwww/Jz8/njjvuYPHixYwePZohQ4Zw7733snXr1lboYsekuOpZWCgryO2Q1VSIL+wtxPDJtXGz7Rq/uQvNV9QOvWpZ0cS7cnX7p7ZvYNbZQOcvwKhWFqJ+cw/y00fDCyfB27P1ukEzXtBHFvY+btyNhCwda6FwsHQnhvJNtQKaat5dqN/8A0Kt88EpLFsga2TC9kjPY4ntWITy7DEoaz6EI65CSu2P/Pb5yP8ZAS9Pg/VfQqC8Vfon1CitrCJp9890e2MS1uXPw7YfsS19mu5vTsJV/CsllXF2vHVxzVo2npSUxOWXX878+fPZtm0bF154Ia+88gp9+/Zt6f51WFLmcDDG/6QYG3gqxvqCHqFtVZVBwcr4bZqKuqueUbfOwpqMb/C5idsHnQqbvqn5vqoYknLjP1aSkTIGt2j32lwkgPbjv5B/+ndNMKtGYdUcWPQsHHUDGMyoR16Hv9+puO0dZ8diTNXQ8pYjbU2cuE5e/QExfyvtNrWlUH7MP/RAeP++pQ/DlJaL8sFV+qLfMRfpZRe+/CuUbdWD5d2/w+sz0NZ+otfnElqNNVRE8hfX1M01FIuQ8sU1mIPx68R1ZQe0Fy4SibBkyRJ++eUXtm7dSkZGRkv1q8MzuLOJzXyjThI0UvshHf/3Jm17FFpXQyvhtXqSj3UWVrMBafCpkFa3lo7abYy+ILR4fc3BRc/AxL+CXHcliTr+FhRny/wtV/nKCZTswl/RtqNhkYoClMXPxm/cPB+t/4lELl1Aycg/oLhapthoSwn7y7Bu+Sp+Xpm91CgxtXV+bx0WI8GUIRSe8T5k7tl2bbRSNeoS8k9+ES0cgIod+vGBU2Dpi3HPI335V/DltUofu4yqUijZrK+FS1Cotj7GQBEE61ZGB6AyH1Oo9AA72Pk0ayn9t99+y+uvv86cOXNQVZXp06fzySefMHFiyxXu6/AMJpTccWhXL0bd+iNSxQ7oMRY5rT9yB3uTPNipZg+kD4b969sASBJyt1Ft3qfWoDqzKDn9LaSNX5G87k2QFUoGnY+h7wQcO3+ovRC2cA2seg/OfgNt2atIeb/qazWOuQU5ezSYHQfUl4C/ErlsE6YFD2AoWA6ubgTG3gTdD8HazCSBTaEFK2qvm9lP1FdCSfo4Mj2NWJfTxhRZ0kc9Drkk4WO0nCMIyXZaa5I7LSWZfOVwlo5/HrsURJUUQuZkcpKT0Hyb9AeZHPqNONGHgkAZMX8pirsD7yprL5oGRWvh4+thb8mPtIEw9d/61J+xcSOHMvUHtnKDH+m6niYHNd26daO0tJSTTjqJZ555hqlTp2I210l1dXAwmJCSc1FaacGe0DKsSRkEp/wby6un6BlU91E17lawprbazaEtOS1Gwuk9KHNcQEH/qfo0ktWN225Csk5CHXom8qp3a56wfi7qgJORT/k3qGF9m7stfrI+VdUaXYJB0zTkXYswv3FmzQ3Pm4f1nbMJHvkngkdeg8XhOcBX20AfDPVv11fMNpKiBQQCmVitHSuwMdmTCA+dialsC/SZBJvm1X6AYqRywj/rTax4oBRZonuyjXRXHyoCYYyKXF0GoSri0WsvlW0FY/0/55hk7JC7ytpd+TZ4/iQIltccK1oLL54MVyyAjCGNOo3szNT/DSJVdRutSciO1JbpbyfS5KDmrrvuYsaMGXg8nlbojiAcmJDfi+zfTWzrTxALoeSOI+bIRM0YRvCSBUi/PIk5bxExZzbBw/6IlDEEm7P1bg5tzWRQyHApsP9ooTMDpjyEetQNaFt/AJMDudd4JE0lVrYVFCOKo/YISkVVGM23m2hlMVosgtGZhurIINlZ/40sVJaH5bMb4n6Ct/z8COFR50ArBzVhSzKGPpNQ9g8IAJJ7IxetxfzK6QTPfJVgz3FYrC2bs6isKkxpZYCqsgLQVEzOFDwuFxmNzDYu9ToG7d3ZSIddAj3H6ju2AmVoPcYSOfpWKsw9yGmDOkcmg0yas3afzZ4sqk5+EtvrUwEtcZmFjCH4DZ4u8YGhRWka6qoPkPcNaPZSo2jfPYR02hONWsIguzJRT7pfzym0/6lOeUyvEn+QaXLyvc6sJZPvCR1PqLIUVryBed7ttXb3hEfORjv2dszuDCp9PuSwD9Vgxu7wHBwFIOPQqkpRV85BmXdnTa4aT09iZ7yA0m0k3kAECn/H9cnlsDfHi8WDd8I/YOAUXJ7EnwBDeaswPzMuYXtw+stYhk+rc3y3N0heeRXFJaUYjEZ6ZqSQ7rLgaEbJhpiq4S/cguODi5ALltc0eHrAKf+Cj/8IFTtBMRK+chGmtN5NvkYiZf4wgZId2Ne9i3vVKxCpItBnMhWjr8aQ0otUV+NGhiLlu5A2f4dhx4/QcxxhTx/8lgwqTalku23tWh6g0h9AqdyJaes3GNzZMOeS2qOg1iTyp7+HnD6YDFGTqbawH96cBZu/jd/uyobLvtVLUjRG0AuFq9G+ewCpZBNa+iCkY26B1AEHPI3ckbRa8j1B6Kik8q2Yvv5LneOm5S8Ryj0GRp6B0+EAus4fenPFdizC8PnNtQ+Wb0N5ZSrRy3/ApGpY3jhVz768V7Ac19xr8bmziTknoiS4qUoNZL2VjHWnq3d7g1QVbqHXti8Ytf0LYuYkCodeQl5lH7K7dW9yYKPIEpInh7LTXsMZzseU/6ueRTdUCR9fpwc0ALEIsS3fQwsGNYq/gIxPL0LZvaL6mHXlq1g3fIz3/K+IOfo3Kima0dMNRp8Lg6YQiMYIyk6sJoWkDlC+wmm3gr0fZY7u7CgoIuO87zBv/hJ7+Toq0g6hMPUw8iKpHOus+beuDIRR/SXIahhNNqDZ0nDbDr5xnKhsBGe3xDdfRwYBVaHRk6IWF/Q4AmnGSxCpQjLZu3yR1vp0uqDmiSee4KGHHqKgoIARI0bw+OOPc9hhh7V3t4R2FouGkRc/k7Dd/Mu/CfYaj6UNFql2dNHKQgzf/jN+Y9gP6+eCNbV2QLMPxw/3UJU1Apsn/s9SsyRBxtCaRH/7MpiR9tuhFYrEMFZso9cH08C3GwAFyFr/Ka5RlxF2/QnMTd+N5bQYIbM7oaIw/PCovkskTq4iaW+A0xSRKghW1smkq2ka5C2vFdBUC1Zg+uXf+I9/AJezCTcdqwcrNP4m14aSHFa0zEx+3FTMFwVHE1OPwrhT4srcLCbY/SgFK0AxEjG5YOcq3D/eo68dScql4vA/4es7AUfSwbNrFiCiKviHXkjqilfjtpeMvhZNdjX939vianQ9ra6sU5U3feutt7jxxhu58847+fXXXxkxYgQnnngihYUH3158obZYJIzBV5D4Af6ienfDHExikVDt7d37kfOWYgnsTnyCwrUoauLtxmZPBpFTn9B3x+wnfPJ/kPbbLh6oqsT+04N6QJM2AHIOA1sKAPZlz6L48xt4RQ0wWvW+xAloAOTcOGUDEokEiRWsJvbhH+H5E9HePIfYhnmofr1QpqbGcK17J+HTLRs+wxQub0rvO7xkh4mpI7K569Qh/G3qYB44OZfBRZ9heHocPHMMfHUHxtXv45xztp4vKhaB4g24P70cefGz+Cu97f0S2pTFKLNVTads4oN1Uir4Rl3KFusw7Jb2H43rrDrVSM2jjz7KZZddxkUXXQTAf//7Xz799FOef/55br311jqPD4VChEI187xe78H1x3MwMZptBHOPxZJgnjrSfSxSW3+K2VNAUNs4D+xpSP2O1+fJ2zmHUUwyQnJvfVt3HJG0YRgsnsS7VpJ6Ihvq3/FozBpG5PLv0X57G9POn4m6c+HQS5GtSWjFG4nEwmBPxejKwhr1Yg6Vwrlv69vu/UVwyMV6srwv78C0/hPoObLm5N58qNgOpVv1cg+eHD0PTwJmTxaR4+7B+NbMuo2p/fSdPI0U2/UrystTq+siSWVbULb9SHT8n9HGXoNidqCaHIk/LRqtGA1d84aVuqeQqLbpZ/jompqGURfAR9fGfY7tl38RGnkuOA+eEQZJkshMT+PxVaOZNfM7nKUrkaIhqtJH8dHGKJPTsrEaO9WtuUPpND+5cDjM0qVLue2226qPybLMcccdx88//xz3Offddx933x0nzbjQ5UiyjDL4VPj5sbo7MRQjHH0TZlsbzjN789DeOh9p1xKqV098cSvqtP8iDz4l7ihGWzE40/Af+WfsH1wYp9GCNvAUNBn95xaL1HlIdPytDWfMlhWMqb1hwi0QDWCQjUQLVmF48aSaxG1GK9EJd2AYNBVGzIS3ZtW+XtoAmP4shu2Lao6VboZXz9D/u1dybzjvPT3ASaTHEURnvIrhq79A+XaQFWIDT0M77k5MSd3qfy17RCryMX58bdxCj4bvHyI6bCZYXaijZyOviF+HKzb6QhRHF55uqSpBmvf32sckCUIJPlDGIlCZB+ktt6apM+ieZOOCYwZz/+dr+T0vc08tsyruOGUIPZNbdifewabTBDXFxcXEYrE6WYszMjJYu3Zt3Ofcdttt3HjjjdXfe71ecnJEIqiuypDck8iFXyDPvQVly3z9YNYIwic9rN/42kosgvrzU8i7ltQ+rmnIH15JrNtilLR+bdef/ZgMCuGe4/Ad/VccPz1YMy3nSMd76vPgyMZiNhA7dw7Ku7NrgkTZQOzoPyH3OrrxF5NlMNmJFW/C8PIptauCRwIYvvoLWr9J+m6k/QOoonWw/DXkY/Z8kPEXwdsX1A5oQP/+ndl6YGOPvyvLaPfAkKmEs0cjhX2gmFAcaSiWxgeXWqC8ZidYnUaVWN5yDGl9MKT2Qx1zEfLSF2o/JH0I8qjzQKl/pMZXXowSrUKTFBRXBubW/NSuqlCZD948PfBIytV/hpbmVdyOhgIYivZ7P46TtbpWcyMTzXU1ual2Hj5rOOVVEVQN3BbDQblwuqV1mqCmOcxm88GbGPAgJMkyxowBBKa/gBIsQ9NUNLMbi7tt63DFKgtRlj4fv1HT0NZ9Du0Y1AA4ktIpO+QKKgadTtRbgGQwozjT0ByZePbUQVJyx6Fe8T2aNx+iQSRPDoojvVnTZ/L6ubUDmr08PZC2/VgnKWK1NR8jTbxD/39/ceIaXvkr9PYEQc1ejR2ViUej/h1LqrTn5m1PQZ54B9qIc2DJ80jhStQR5yB3G6Nv103A769ELlqDdf7fUXYuBkcG/kOvQRs8FUtSK+QbUWOQtwzemKn/7EAfVRl1gV5Cw9H0v5swBgxJubWnNr15kNIHSjbVfYI9Vd+VdpBymI04zB2tPnzn1mmCmtTUVBRFYffu2gsYd+/eTWZmI/fzCwcFqzMZnMntdv1YLIqSYOcQgOqtZ0FzG0pyu8DtIpDaC0WWMBn2WwmiGJA9OfqalQMQ9ZdiyFsav9HkgPoWeKtRItEYJiAW9NWbnTYWqqxp95eg+QrRKguQ7Kn64uRm3KT3FTV7MGcOh4Lf6jbKBuTMYTXf21OQ7CnQ/VDQVGSl/rdaTdNQdi3B8sbpNTmWyrdh/+pPhHb+TNWJDybcbdZsFTvh5VNrB5uaBr++pK81OuIPDY6y7K/KmETwsD+R/MnFNQd/fhIm3w9zLqs9DWUwEzvzZYyexIGeIDRVp9n9ZDKZGDNmDPPm1WQIVVWVefPmMXbs2HbsmSDsoUYhFiWi2FGzxyR8WCj32DbsVMOsJqVuQNOSQj5I6Ru/rWwrZNVTe8vTk4iirzGIWpJAStBPSSZq1jNDq+U70d46D+mpI5BfPQ3p6aPgldNRS7c2/zUAFncGVZP/HXekyjfpfiLWOKNEsgwNBDQAwbJ8LF/cXCtp5F7mNe9hqKpnN1ozadsXxh89A/jhsert9U2RbDOR7xlN5ZG36muyAMq2wI+PE7v4C2JTHkEbNoPY8f8kduVClJzDmhw4CUJ9Os1IDcCNN97I7NmzOeSQQzjssMP417/+hd/vr94NJQjtwleoD7cvfQFiEayjLyB66hOYnj+uTq4XNW0IamrdStpdmRqLQvdD4teoiVShOTKI9TgSw/afarcZzFROeQLVpo+wlGgukgefheX3N+tcIzjkHEo1F1mBcvjkeqT9z7V7FfLb5xObNQfF2bwRG0WWiKUNxnfRd0jLX8Oev5CwM4fAmMuRU/rgdDZvHQqAHK5MvF4HiG1bCNlDm33+eLSitYkn1KpK0KLhBibc6pJlidT0LN7YdgoTZkzFGd6NppjZEXWza6edE4bPxnHYpaIelNBqOlVQM3PmTIqKivjb3/5GQUEBI0eOZO7cuXUWDwtCm/EVon18A9K6T6oPyWs/wdjzSMIXfY3p46v0dQtGK4Gh51I04irstoPr91W1pxBb9jLK9Gfgsz/pC1MBDGYYew2qLYVNR/+b7mufx77yZX30YOLfUHuNx75+LtrmuUQHTcXt7Mmy/tcx0uLGuuIliAbBaKVq+GyW5VxAd4OdWOUuDBu/it+Rgt/QfIXQzKAGwGmzgK0fZY4/E474kQxmbDYbpgPcpi0pBn09S4KqNa2RjiCUMSpxgjdPD4IYm5XwL8Nl4fTD+rO91M+HWw04zAaOH5LBIJcFh0WsHxFal6j9JLSbYDhK1FeMHA2gyQZUWzpOW+da2K2um4v8Rpz8J0Bs6v+xynU0xoiXGApexUO/7BTSnR1wt0ewQt8JY/XoN9cWFinZivGzm2DoaXoBxFgUFBNRSzJq5giqwlHW7irDrlbSI8mEc9UryD/9u9Y5Yn2Op2TSIzz43W4uGGbBSogAZl5aGcBus/PnkwZi3L0C0/MTE/YjfN7HmPqOb/HXd6Ai/jLk9y5F2fR13UbZQOQPi/Ut8i0ob9tGst+ZEneaqfSkJwkPmk6muyPmMRYORqL2k9Ch+SpKYddSHN/dpafTtyXjH30lgdHnY03uJAsHw37kRU8nbFYWP8PgWSdRomaiyBLDnB0wYKssgG0/waJnIBaC4efAwCng7t6ilzGm5BI6+V9oBauQN3+P5u6O3O9EZLMF4/bv8Wz+liM8OcS6HYYU8dYJaACUTV/hGfANYwccz7nv/I4vFMVhNnDJUb04/4ie2M0GgmaXvu4mToVwANXeMctkGO1JRE96AF4+Wf832UuSiJz6JLKz5Uf3tkY9xKa9S86310Her/pBs5OKsX/m2+gwjj5Ii70KnZsIaoQ2F4nFkLf/gG3O+TUHq0qx/3Av4d3LqTr539g8bbsNuzmi0SiGaOJyAUQDoKlkdtQqxZUFaO9djrTlu5pju36FX56C2R+3eGBjTs6B5BwYPHnP9XejfflXpCGn6aM36z5HUWNoeXHqJu1hWvwUp8yazBE3HE0womI1KaQ5zBj3FNcMm1ORh8zAtOqtOs+N5k4gamm/XXENMaT1JXLRV7D1BwybviLmyYXhM5Hd3VHMLZ+Fuleqnctf9nL20EcZe7SGFAtRrtl5YomfGYeld8wRRUFogAhqhDYXrcjHFqeaNoBpw2do/tugEwQ1QdlGrN903Nt+itvu6zeNqOLC07bdarRY3jKUvQGNKxsGTNELNO5agrrsdeSjb2owUdwBXX/nUpQRZ+sp9L279INJuUjB0sRPClagxaJ0S7HpIxqlW2DNCvD0gMxhOBxZeI/+Kxoy5tVv67lYJIlI38n4Jt2H3Vl/Hpv2ZkzuAcnnwuhzW/3NOctt5f/OHcVfP1jF7V/oeWpS7D7+MmUQR/ROaeWrC0LrEEGN0ObkUGVNqvw41J2/Qrfhbdij5jEbZXZ3n4A7uXfdLLeODLwDz8JtaMbCSF+hvg12zadgssGgU/Wgw+ppkX4DEA2hLH1Rn6o54R96BtlV70O4Enodg5xzCFqgFMnROtM1WsiHUrQaitfVBDSgL6oeegZsnBf3eeHciWgWD5TvgNfO0LMO72V2IZ//AZb04ZRPuAd1zHVoQS+SxQH2NByupANe0NvhxWLgL9Sn3yxuMNefMblnip0nzh1NiT9MOKrishjIcFmQxdST0EmJoEaIz1+sVzWWFbCnNyrXRmNJBlO9Oz0Ue+f4lGhUFML2LNae+DrdNr+Nc82boMbwD5hOwcALCJuyyDY38edWWYD2wdVI+y4YnX8fjP8zHHEV2JJapO/RmIoBDY69HXYshtUf1DTuWATOLLTZn7ZaUBOORDFnDoMFD9ZuKFgJx/xZn/qq2Fm7zWhDO+oGrIoKH91SO6ABPbHba2dgueJ7LKk5BNxuqkIxrCYFm+kgeKvz5sGvr8DiZyFUidZnEtKkOyC5L9QTXLusRlxWsStJ6Bo6TfI9oY2EfLD1R3h1OvxrKDw5Vr/xVLZcFlzZnkqs7wnxGw0WpKxh8ds6oG4eK4VSKneUTeHTI17ni3FvcXfVmawLJNGjqYXpNA1tzSe1A5q9FjyAtv9o0AGIySbKhszWk+LtG9DsVZmP9tN/IFLPmqEDoJmdqPb0uMUh+fwWmPpvGHGOvu1bkqDvcWizP0azp0NVMaz/PP6JA2VoZVsAsBoNpDjMB0dAU1mA9uZ5MP9evUZWNIi07lN45hgoWd/evROENiOCGqG2nYvhxSl6LR2AYDl89wDae1eAr6hFLmGwudFOekBfB7Ev2UB0xssY3Z1k9xNgNioc1TeVP08ZSm7P3mTn9OL6E4dwwpAM7E0dpfEXIv3yZOL2Jc/r0wstwGxUMOQcirZ5fsLHKCvfJlxZ3CLX25/FqBC1pUG/E+s2evPgzXP1GkSnPwNnvgip/ZFePQODfzexSDDhKB/otbcONrHdq5HilaKIhtC+vhuCCapkC0IXcxB8hBEazbcbPv9T3CZpy3zU8h3ILTQdYUjpRXT255C/AmnrArSkXOh3AgZ3NzB0rkq1siyR5bGS5TmwnB6RaBRjsCJhu1RVhKZFkZqbjzVQrk8rRoNgcaPY0tEkKXHWWE1lbxqrUn+IikAEVQWn1dAiO2PKlRSSJvwV49bvIVRZu7HnUZD/K3xxe63DypoP0Iadqe+W2ls9fD/R5P4H3RubtOajxG2bviYW9KK0QgI/QehoDra/faEesWAlSvGGhO3atp+g++gWu54hqTskdYfBJ7fYOTurUDRGQHJg7TkB8+p34z7G2/sULBhoTsinlW6Fj69F2rJAP2B2YTnuLmKDz0ReEr+ieHjANCImN4WFZUS9+VgrtoAaIZjUj83eFLLT07AYm7/wNt1lZUNVd1znfEnKyv9h2PQ1WFwwfCbYkuHj6+o8R6rMR1rxJuoxtyLP/XPdPucey27NQ8+9ByJBfeG1r0BfFO3IAGdWi64R6wiiRlfi3wuTg6iqidIEwkGha/1lCwckioIiG+KvcwDC5qRmpU0XEivxhYh4d6P6S3FYjGhH3QgbPtUXae/L0wNf9pE4labPGKsVecivnl57h1bIi/zpjXDxF4T7noRp49zaT7IlEzv6T0RjURxb5pL01fUQDeltsoL3iJupMl+MJTWzyf3ZV48UBxsLu/Gu5RKyx5zH4Awb/VY+grzy7QRPOBy+vAN5/J8IT/kXpgX36SOMBguBYeextu+l2I0e/bGBClj9Psy9tebnaXHrU1q9jwFjO/82B71QVQKxMJiderDVzGzO/gGnY1pYN2EhgG/o+YQNSXTA1I+C0OJEUCNU8ykeGHAa5jVxRgpkA6GsQ0VQ04JKvT7k/BVkfn1DzU6eoWcSm/05fPtPlM3zQDERHHQmu4Zfg2zLQmrOTa94Xd0t53vI716CPPtTSjeeTvJKfdeMv/dkYiPPB3cP5MLVuOb+ofYaFjWG66cHqMgaTZXzOGxNXTu0D7NRYUg3N92TrfhDMQyyRNR8Oabf5+g5ZvaVMVQvr+Avgs9voXj2z2yc8A5plhhBzcArK4NULPbx0Iw9U2OFq+uO9gQr4M1z4KqfIX1gs/t9wMq26cHW+s/1n60zC068F/pMAmvTC2NWWTJRjrwV10/31zqupg2mfNhFJJtFIj3h4CCCGqGaZLJReOgt5BQug5JN+zTIlEx+moAptcMmkuuMzL4d2N8+Tf+kvteqd1G2/UjFOR+zZVSQqAqfbAgzQU3liKZkJg5VEvMVQyyEsn1h4sd5d6LFIkhDp1Pa51hQo2gWD267lVg0grTsuYSLct1LnyDSbTDari2w4k19p9Ko85CSekETt+W7rSb2lhnyyQOJnv851m/uQNrxC5jsMOwsGHASzLms+jkuKcgtX5ZR4A1iMynMOrwHfz66N8l2EwS9aN89EH+9kKaiLf4f0kn3gdIOW5m9efDKabUDzcp8ePciOOdNGDBZ34VYVaw/1mgDR3q9IzlmZzLfuacxcuYkUjfOwRgqpST3FLYa+5DpyDygwFMQOhPxmy5US7abyTNnsOvol8iNbcWV9z0hWzbl3Sfy/W4TU231J/LqUKpK9RvC+i8ADfqfqCews3WMHDh+vw/DL0/WDmj2qszHvvw5zMNvJhKVuWyilXSnGaOhEVNPkSCUbED75h6UHQv10Y1R5yd+vMlBTDaRZDeBvXZ9ISkSQanYmvi5h12K4aOrkLb+UHNs6Quooy5APu5OsDeQvVeN6VOdhtoTIw6Hk6j1UGLT/ouhcKU+7bXmI3hzFsgGsHhAklAcKXxw9WACkRgmRSbNaapJrhepQqpnC7xUuFpfMN0eQU3hmoQjZ3z5V8gYirbkeaSf/lMzFezMRJv5GlLWyLjrgVIdZo4Y3JvFW0pZpJ2PZoSMSjOnjOhGTpIYXxUOHiKoEWrpn+Fki5LL4z9BeaAbig8mJqcwZVSqfuPrDPzF+qf0Rc/UHPvmH2hjLkKaeDt0gKKGStSPOX9xwnbDzoX0OkrD4mparSItbxnSSycj7Z262fo9HH4FmF16crr9VI28iLA5lXhjQIrJSiznCJS9i4v3lT0KrWx77YBmD3nZy8SGzUDpnaAadqACyrfqW9S9eTDwZH3axZNT/RCDIlMiuzFtWYxz8eOQNRKm7/n3DPmIZQxDNdgT1tWqwow5bSBK+ba47cH0ESiSmfZIOadu+ylxLo2SjWj+QqQfHq19vLIA6eVT0a76GSmpZ9ynpjktTBmezZF9U4mqGm6rAWMrlrkQhI5IBDVCLSaDwoBMJ385eRC+YBSDIpHi6FxLDNX835D3DWj2kJa+gDpgCnL/BIn/2pDJbEN1dkMuXBO3PebqjtnSxCKGviKkT2+ouxbluwdh+tN6jSV/Td6ZSP9TCI25nCRnguvICtKIc2DhExD2124beArSitcSdkVe9LS+qHe/URhClbD8Vfhin9pfG77UdyVdPBeSe1cfNlpdrO55AQNyjsJjjOj937ONW5EkbKNn6xmRHXXrhFVhxX/IDaRt+KJu5xQj3sHnYtOkdglqYu4eiYMaixupfHv8trAfdeM3KIdeVO/5PbZO8uFDEFqBSL4nxGU3G8hwWzpdQEPIpw/bJyD/9J8OkYhMtjhRj7ox8QPGXotkalpG4mhVuT61sb+C32De32Hma3D++3DGc2gXfooyZCqW8k1UleYn7qenB+qFn0L6oJqD7hzUvsfXDXT2IYV9hCORug2Vu2sHNHv5dqN9eUetfDUuq5HePXsgp/WFOZfWzkujaUhLX0Rd9R6oap3TOa1Gfq5IoWTKs3pOm+qGLAqnvckKnxt7O2Ua9maMBSV+4BE75FJY/nrC52q7V7VWtwShSxAjNUKXEo2EMCRIygZAoFR/TAfYDGLIGExs0t9RvrlLL0AIICuox9+Dkj6gyeeLIWNIVFOrcA0UroVdS2D950hVpUiaihUI9zmewMn/wZocJ5OzYkDOHgUXfAyBUn0UyJZElexC6T0Z669Px+1LZb/TMRnqruWIbfo2Yb4Uad1naFWlSGZn9bE0p4XY2gX6+pc45B8ehcHTwJVV67jZoDC8dzdu+rCYP5z0MZkGH0gyW6qsPL3Qz0MzUpu3k6wFLCmzMHraa6R9PBsiVdXHw72Oo3LQLFLWnJXwucH00XSilW2C0OZEUCN0KQHFjtxzEvb85XHbq3pOIirb6RC5VW1JKIddgjZkKmr+SkBCzhqmZ202Nf3WFTC6UXKPxbDlm7qNkgxZw+GTugntTJu+omrHL6ie0xJXZ3ak6V972DWNykMuw7rm7bqZfZN6ofWegDlOYr5YuCpxEjhNJRqN1ZkS0vYvXLkv324i0XDcaaScZBu3nzKM+z5fw7frSlEkiZOHZ3HfGcPpltTEulwtqH92Cn9818rtp39Jmn8TcrCUYOpQvi8wUrZO5cKjbsP+4SV1n2hNItr9iLbvsCB0IiKoEboUo8GId/BM7Cuer3uztbjxDZ2Fw9iB1hyYHUhmB8o+a0maQ9M0ZIubwAkP4Xz1JD2Xy75Oul/fQZSA7ddnCfSegNXZuCrgkiQRcnSn4KzP8Cz5N5YNn4BixD/4bCqGX4LZnlX3SZEA9D0ByrfA7+/rdcX2oWaPIaDY6wQogcxDcJJASl8iGOMGNYos0S/Dyb/PHoU3EAUJkqzGdt/enO40c9bhvZj6ygpS7Q5sZjf55SX0TrPzwoUDKay0kHLM33H9/EDNFF9qPwpOfBri/VwFQagmaVo9leG6GK/Xi9vtpqKiAperQ3xWF1rBxgIvZu8WMhfdi3HTl4BGpPcJ7D78L1S5etE/s+nJzTqyqtJ81PLtqNsXITkzsPUYRSR/NZbf3yBo70Zw2HkY7Ek43jtfX18TT/ZoQue8g9nZwDbs/RR4g5SUVehTU4DiTCfV5SDVuc9arEgASrfAT49D/nI0T0+kkefC5vmw5Dn9MYqR3TM+gqzRZOy3o6lk1yZSXj+xbqAGlEx9AW3AyaR2srVfVaEouyuDfLV6N4WVISYMSKdfuoMMl4WyqjC/btpNhlyBS6tAU8xs8lvo0aMnfdIc7TZtJgjtqbH3bxHUCF2OPxTlu/WFbNiez4Se+qjMgh0RenXLZEL/NByW9tjz0jpCpTtR3rsEw859EuwZzATOeI3NtmGsLAgxumcSOR4Lhl8ex/jt3+OeJ3zcPZjGXd3sNP2haAwJCdP+uXQ0TQ9eXjuj7q6sE+6B/OVEwiGKxlzPMl8KJ43ogbJfKYi88gBq8Qa6f3Md5P2qH7R4KBv3V3ZkHs+wvj273I0+HI1RWBmi1B/GZJBJsZtIa4EiooLQWYmgJg4R1Bw8wrEYhd4Qhd4QGhoZLgvpTnNNcrYuIBioQpp3F+YlcRbrKiZCV/6COa1mWitaug3DiyfpuWH25c4hOvszDMk9Wr6T3jz436S61wQwWPBdvIDHF3mJGe1cMb4Pac66Iy7RmMrveRWs37Kd0akxZDVCiWpjt+bhmD4eHFZr1ylQWVWqj0gFyvRdW7bUJmdnFvaIhvS6YKVbIBaBlD769n9TE1MlCB1CY+/fXeSdQBBqMykK3ZNsdG/HBaGtTfIXYV7xSvzGWBh164+wT1BjSO5J9MK5SIueQVn1NiARGzYT7dBLWyegAWL+EpR4AQ1ANIg5sJtZR48h2W5KOIJmUGSGdvOQ5rRQUBEkqmqMdHoxbvoM6f25evmAwy6HpFyweurvUFVpzVoei0evBt5RVOyE96/UEybu1XOcnnTQ3b39+tUZhX2w7gv48A81O+dkAxz7VxhzIdgat3ZM6HxEUCMInZSkRmttCa7THieYMCT3hOPuhCOvAUCxp7ZqqYCYqiXe7QSARI+Uhj85K7JEtsdKtscKJRvh+RNrJRJk+Wtw/D/1G5YlzrJiNYZWuAY+uQFp5yIAtO6HwSmPIqUNavmRHn8xmr8YLexHsiYhOdLBXM+Otqr/b+++w6MqsweOf6f3mfRGQgu9CNKbJYqADVHBshZQRNZFXfu667rq7rq6K7vqT13LqmAXLFjXVURARRQUEQFBSkIggSSkTtq0O78/LhBCZkLAJJOZnM/z5EHve2fm5TKZe+Yt55TDu9c3DmgAdq2CJXPhopc6VgDW0ZXvgrdnH1GI1Q/L7iWYMQRN9mmR65toU5J8T4hoZbSqQ+ph6LqPC92gN6p5XZzpbV77yGOICz/KYLDgsXU5tiesd8PHdzUOaA5a+kd1uiEEpTwPzfOTDgU0AJo9a9A8NwklTCmF46WU7oRXZqD592i0z56G5okRKB//EcUdum8A1JbAzuWh2/K+DLlIWoQR8KGs+U/YQqysfAjqKtq1S6L9SFAjREfm96rrUaoK1V1EhzHGpeOfeH/IhykpAwk2E/C0GSWgTqMUrINdqzEbtLin/J869H+Espx/4NYf4+hDXSmEKn1wQDB3ZdODAR/BbxeEzoDsq4U1z6rXuRX4K/eifeXChgXNAEoA7boFBFc/oa7zCCFQ13yW60BdZav0r1Pwe9CW7QjbrKnMJ+CtC9suopsENUJ0VBW7Ydl98NR4+PcY+OhOddHjYTRdx+K/6BV1PQmAzkDghEtQLlmEMS5EhuC25PfCrq/g6ZPgPzmwYAqGx0/EVL+f6lnLqTthJqQPxdf/Agov/h8f+Ydjth7bmidFCYb/Bg4oIW5W/rpKdKGCnQO0u77Af5SgosUqdoWtwK1b+wz+ytAlKQLGIxY+6oxgdoVvF2HVY6QubWTYdl/qCdRqZCdZrJI1NbGoZr86XF1bBrYk2UERjSr3wMKz1ZvkQesWwpb3Yc5yOFCpWWeLgwHnEOgyDMVTg0ZnQO9IUaem2r3Pu+HlCyBw2KhHwIvx3WvxXvgKjxln4+rmo7A6iPcnE789PZv4Yyy+WKu1Yc0Yjrbwu5Dt9V1P4sgVOt6gAY09NezanoAtBS/6Vvkw9O/fGf55fHUo3tBroMo1LhJ6TcZQuQsm3Ax6s1pV3ZFGoHw35Zo4Uluhf52BVqenot8MLN/+u8noJhotFSNvQa+L3Q0EnZ0ENbGmIp/gG7PQFDR86Ae7TUBzwdOygyKKKD9/gjbUWo/aUpTvX0Y7cg5U74P928CRhi6+O7rkXsedZyYUf00ZwdpyCCpoLHHoHcnNnh/c+BaaQOhpHPuqB/nNRW+yx2vFatCRZDepmX19dVBdDCU/qSM9qQPBlhJ6sS9QiZ3g6Q/gePWcxsETUNf/InbWOxl8xGM0ZhvuYdcRt31pyOd0D/sNxuYW8R4DxdUtfKPejBKiHhZAvdZO3rgH6KXsQvPOXPWaHKAZfDHOXme2Sv86A6NeS6kuFeWCt0lbdqP6OwLgzGB/znzygumMtEVXskbRchLUxJKa/QTfuKpRQAOg2fUlwfd+i2b6c0ff8hprAn7w16nffNt4UWyr8bjRbnordJvejLbrGIKLr0Cz+7CEe7ZklCuWoE0d9MsDG0XBX7wF7Ue3o931pXosfSj+s/6FLn0QGn2IG4KioAmXrRigLBe7TqFf2mHTKJ5q2PIBvHdDQ4Ci0cJJt8GY65ru9vHVk1a/A3b8Fy57A9a9qO4OsiYRGH0d3rQxaJS4Ji9tMeipSRqIe9RNONY80qjNPeom/MkDiWutit3x3SCuW+MRtgPqh8zEa0km1MRHgt1IVbUfzaKZ6gjNYbQ/LsKUlA0Tbo2dfDxtLC3ezqs/J5N14rMMivdDUCG/zsTnu3X8OufYsmaL6CLJ99qQv2oflOcT3LcRTVwXSO6PPi4TtG2zlClQ9BO6J8MXvFPmfYs2uXebvHaH4/eqN5bvFqqLNpP6weg5ENc9MlMzx8BbV4P+7avQhloQO3wW1FeqtZOOZEtGmbMCbdyBEbmATy1foNGp05At5N+fi/7ZU9TXOZzehH/O5+hT+zUcCwRQ3IXgrUHjcaP5/kXYsKjpgtguw6m/aBFm12GjPfs2quuFQvnVG9BnUuNju9fCgilgsMJFL6rbn+0pUF8FG9+C6iICly9BlzG0SWBX7fGzq2AvDn8Z1n1rIBikNn00bn083TLSWy3LdHW9D//+7cS9dzUUb1YPajR4+s/Ak3MPzuTwo6WBjUvQvTkrdKM5Dq77ClzHuFusE6uo9bK3sp4PN+zFG1A4c1AaWQnWqCupIVSSfC/C/GX56BZf1vjbqzkO/2Vvo+9yYpsENkptebM5QQL1VZ1jZXgwCHvWwkvnqTd2UBewrlsIF7+sFlXUd9xRG5/WSPXgq0kIFdT0mghvzAr9wJoSlNKdalBTngffLoSf3lWDgFFzoc8ZaqK65igBAj8sQn9kQANqoLLqUfxnz0dvsqFU7yf44xvoPv+7mgFXq4f+U2HGQnjrmka7jUpG34micTSMUgR8sOY/4fvx+T8ga6SaVRfUdWIf3qLmGhk+U60jtWNZk4fpXp2OMmdlQ2B3gN2kp3fXDIrdiRTZu0EQXFYjvVs5y7TdbKAiIZvi8xerffa6wZqE1pGM09X8Ti9N6fbwjfUVEAi9c0qEFmc1Emc10j9dFll3Jp3iHtfe/HVVaJbe3XQ4vr4C/asX4q3Y0yavGzA3kyVToyFgCFvrOLa498LbcxoCmoOCipqxtXpfZPrVQjaTgeq4/tT1u7BJW1BvUm/sYQQqC9RdU8+eDqseVnfiFG2E92+At+ZAc7lSAE+dG9OuFWHb9btX46+thICf4IZF6D6+s6EauuKHTW/DF/+CnD+ox8wuys94mP+VpWI4vKZTwAvluU1f4KCqgkajPUp9ZUMxzq5jYednoR9Xsx+l/MDUT10F7N+u5nnZuwFj3X4y460MzIhjYJc4MuOtbVI2I85qJCU9C3OXQWiyRuHo0oekxOSjvpaSNiR8oyOdgE5GGIQ4GhmpaQNKdQnGLe+FbqwrVz9o2yAtfZ0hAX33HPR5TZN4+fqeR60xIeR8fqxRakrRVhWEbvRUoVTtRRuX1X4d8lRDTTHs/REIQvoJ6mLYZhanGlwprOh+M0MGXknytsVoFR/FvaaT6OqJ0exqOjV0UFIf+Orx0Mnp8r6Aok3gCL+PRqM34renh/9gsCcT1JnwVRZi+Pwfoc/ZsxZl8gPsuehj9gdsPPqNm1kT0kmwHbbTSW9B6TYebZit1sGMYWiMDdfHr2gwajTqKFzA1+y27kB1CfrqYoIf/Q7NprcbGhJ6wqWLILlP2Me2JqfFALR8RLDMlk2KK1Pd+XaEijG349UkkNKK/RMiFslITRsI+urVUYEwAkf5tny8FHMcu076O75ekxvWFGi0ePudT96Iu9CaO8cwbCAQOEp7+JGOVldXgfLtAnhsOLxxJbwxEx4bjrL22YYRjhDSXRaG9uvFRxVduUfza/6kvYG3y3pSbkzDPeqmkI8JpA9DZ0uEHxeFfd7g+pdBCf/eNJqs+EddF/6vM/omLM5Egh53Qw2lEOqLt3PDZ34uXbSHU/qlc2LXuMYnaLXU9bsAjCECO42W6jG34dc3rH2q0Tnx9TywxiYYAFMzVXoTs1G+fLhxQAPqqNVL00IX1+wAPsrXkX/uIpQuoxoOGu1UnXwvH3qHUecL/+8mhFDJSE0bCJoc6lqAMDctbUr/NnndRLuJWm8Wb3a9m1Ej7sLgr8Grt/N1sZacxCzijjEnSLTyGuMxWBOhtrRpo8GC15p2DN+fj6K+Ctz71Cy3nmroPQniuoJdXRAbKP4J3dI/Nn5MUEH76T0EMkei6x5moSyQHmdh1vgelNZ4CAYhwWbEoNOyt98MgkEF55pH1Z0yWh2+PudSMu5ukrXGkNl7D9Eajro7SonPpvbUe7GuvK/RiEj98Gshc4T6V9CZQatTMwiHoLGn8cAFg3FaDCTbTZgMjade6n1+HvqmjrkXLiF9+S2w70e1Ib47JTkP8fh3AeYleElxqmOLPr2d4nF/okvR9/DDa+ruqJV/b/K63p5noDM50H77fOi/XFUBgdKd6JztnJiwBU7IdDHthW3cOO7vnDRBgzZQT2XQzpPrasivcDNlpHxcC3E08lvSBrSONOom3Ill6e+atPm7jidgT2uz185KsDLxxD6UuOvZ4/aQ6jJzZqaJxFhb8e+tVteH7FiuTsX0PEUNJqxJBA1W6qb8C8uSWU2mKSpO/jPV2vgmCdqOS10lyvcvov3ksKBl5YMEe09CM/UxMDnQrno07MO1qx6FjKFgDN8bnVZDiqPxpKEzMZ3CAbMpzDwLg78G9Bbc+jgyE5KpJYBhwCVY1z4W8vmqBl6G6yhBjdWVSPWwWdT3Oxtf7leg+DD0mIDflozdpe6i8pkT0fadiuGnELuwrIloErMZkORq2naABg355R4ufNvNTeMeY9jJQVAC7KwxMn9ZBV6/m+sP62eK08zn+1KpPPsdupSuxuV0Epx0P5pVj6iJJg0W6gZfQfmJvyHZV4/uYGXmEJTSXHQ9JjR7DSIhK95KvzQ79y49POtwGRoNvH7tmNj7HRaiDUhQ0waMRiO1Ay+gRqPHtuoBdX2Dzohn0MUET7kTa3zbBTUAyQ4TyY4Y/gD0VMPmd+C96xuCls+AHqfAxHuxv3cD9D6DwJUfoFn9ONrizQTie1Ay7CY+2Z/AWebW2dKtVOxqHNAcoNn2Ccrm9wgMmo7BHX6qQ1NVgLe+FmMzQU0oNpOe3unxVLhs1HkD6HQasg8EPnsr66jufRm9t3/QZCFufd/z2eRJYbSioDvK7ju7Mx6c8ZjTQq8/sTvjqD3tPrQVeej2ft/QYE2gesYbaO3N77IyGXRcMbYbVy1Yyx0fNb1Gvz+zH4m2xiOLQ7PiWL0zwEPbTuC0PvGMzU7Bl3g6+kAdQZ0ZvzWZ9AQX/tpCDEa7GviG4IvPbr2RulaU5DDx8MUn8tqafBZ+lUdFrY9h3eL441kD6JfeSRb5C/ELSVDTRqxxKVQPu5K6PpMIemvQ6E34LMk4HfLh9ItVFcC785oez10Jm98FayJ8+TC6bxegjL2Bkgn38tKGalZ94eVfF/ciqTUCvmBQzYEThvabp1D6nkN9+ijMe38IeU59xij8OivHOymoblltfMxhMvDQ9/XMnPgKmaVfkbjzHRS9leIBs1hT14WA337UgKal9PGZ1F74Kr7y3VD8E0FnBvqU3mgcXVqU92VghpNT+yazYmvjCtS9UuxMHZKBVtt4RMlpMTB5YBpDs+Ko9QYw6jUkObPx+BVMeu2h6dX9viQCw3+NffX8pi+a2AuPPZOOmqko1WnmhpxeXDKyK0owiMWgI94W5dPGtWVQtQc2v6+uh+p/LriyGudO8nvUCuueajWPlC1CpT5E1JPkeyLqBJf/DU2I9RQA2JLhtLvh/RsPHfKc9wz5GWfhshqaTOUcN8UPi2eqGXEPShkA424AkwMUP0rqYOoCGmz/GQdHTofoTVTMXIEtoy8GXetuK/5pbxXnPvYlfdMcnNLdQp0f/rulAp1Gw5vXjSMj7kCq/oBf3d5etRcUHzi7qNfvGG8mdV4/dd4ABr0WxzEmsSt21/PD7kpeXJ2HL6AwY3gW47ITSY8LXU6gJTz+AHl5eWT+9B9s6589tLVfyRzNnpxHMCf3PLRWR7Sxmv2w4kFYe0ROosEzYPLf1OSJ1cXwzVPw9ZNq1XSdAU64BHLuAudR8iqJTkOS74nYVRlmuzaoi4OP2Cpt+uFFeg84C0ytdyPzo6W2x5k4DwY1WaNg3I3w4a3qN05AqzNiOek2aq/6DOu71zRkmE3pT9Gp8wnaM4lr5YAGIDvZxpvXjePe9zby76+K0Gk1nDkojTum9GsIaHz1BPO+QPPW7Ibt4Tojyun3oD3xsoakdy1gMeqxHGeZgRSHmTMGmBnfK5GAEjzmoCgUk15HfEoX3i++iiHTL8MWqMKvs7K+TM9QZ1cJaNpT0aamAQ3Aj2/AgPMg+wxY9SisfryhLeCD719S10pNe7JpuQwhmiFBjYg6dT0nYV3/cujGrmPV9PuH02hRgq2bv0Cv1eLLGqcOo1fuhpNvh8VXNq4KHPCiXfE3TIm9+e60l3EqVQSDQYp9FrqkZNHN1SrLlZsw6nUMzYrj+VmjqPb40Go0JFiNagHJA5SKfLSvXdx491LAi/aTu1CS+6PtfXqb9C0ca2vVXjogxWnmzBN7UlrtodDtwWk2MCHT2HojdeLovDUEVz9B2GXpqx6FtBNgzTOh23/+nzrSI0GNOAYS1IioU2TvT4+EnmrekcNptDB2Hrz/20aHywfOxKAx0zp1mBt4rOnknbuYjNwlGAu+axzQHEa38m8MvuIDigLpBIETLIYDidnaVoLN2Djh3UGKAuteCrsdW7vyb9BlGFhbPlrTEbksBlwWAz2TW/tfXrRIwI+mPnwuJuorCPrqwlZ2BwhU7kHXTskSRWyQ5Hsi6qyrsLD9zFepH3hxQ+Xt9CEEL365Ydj6AH/mWAodg9Fpm9/GfDwy4iwEXV35JnMmwbKmVZkPKduJLugnK8FK1wRr2wY0AT94a5vNuKsEvGhLNod/jvI8vJ6a8O1CtIDPYKO2x+Sw7fU9ziCgb37tVMAU3YG1aH8yUiOizqjuiUx7Ygtn9ZvDhdNuQK9R2FoOvbHQp9fZmOvKQaOjpP8V/GQchFGfiMXQNm/1Hsl20lxmasuGYeO10Ccl9cGj6Np2x019FZTnEVz7LJqKfILZp6EZcJ6au+eIvDR+DPhTh2Hd/mnIpwokD8CrsRz3riwhAGp9QSq7n0PX755sWrbD7KK0/xVYghZc3U9BlxeiXEZCT6oMibS8vrwQMlIjolBGnIUXrh7Filw3017J55yX9/DHT/byeaGWRf6TeCTlfv6Z9GcuWZXOx7ugd2rbbqO3GPVUZ52i7noKYf/oO6k2tOE3Tm81yo9vwNMnoVn3Auxcjmbp3fDMKQRLtjY53aDX4u0/HQyhvyVXjbmDYDNlCIRoCYtBx2tbg+ya9g7efuerma41Wny9z2LPhe/znw1+6rR2csf9HSX1hMYPjuvKnjMX4tbJehpxbGRLt4haxVX1lNV48QYUEmxGLAYdu8tr+WDDXgxaLWefkE6XOEu75Pn4qbCc+KqfSft4bkPSO6ONynG/54f4yYwakI3Z0Po7nQA17f/jw0PWGwt2G4/mklea7GbaV+5Gu+8HUj7+DVQcmDqzxFN26oPUdcuhS1r4opeilXmq1W3NBWvVf8MuI9StzubwGZmjxU97q7jwya+4ZGgi5/Q2owGW5np46btSXpw9ir6pDv619GdOTPQx1FWDviKPgCOD7d4E3vjZz31TB4VeFyY6nZbevyWoEaIVlFZ7eHL5DkYkexng9KJRfFRonLy80cO8MwbQNaHtJp/86xejf2dO2PbA9d+hS+rV+JgSZEdJNSV788k01kBQoSxoJ2BNpX+XeGwmmZluF3UV8P3LsPTuxkHphFvUnEdRvvOn1uvn859LuO2NDVR71EKyFoOOP583kCmD0nCYDRRX1fN/y7axZH0BDpOBqnofJ/VO4t6pA0l3HX++IhFbJKgJQYIa0Zb2uz38WFDJs1/upMYT4KzBaZw1OJ3M+LbNjFq/5gXM/70xbLv3ujUYU/uGbCtxeyiv9RJQgsRZDaQ5zWiOUhtKtKI9a+HZiaHbLn8berXv1vq24AsoFFd5KHbXowSDpDrNpDhMGPUNI5e1Xj/73R7c9X5sJj2JdmOr5CwSsUOS7wnRzpIcJnL6pTCqRzy+QBCn2dAk1X+LeGvVhHha/aFq383xZ4wI35jSH4/eEXbRb1TUCfN71OKlnkowWNWsx+YY+FLiq4Ovngjf/sW/1KkoS3RPQxl0WrrEW+gSH37UxWrU0zVRbkfil5N3kRCtzGY6zm+YAb+ae+eL+bBzhboOZuz10GcS2MOvcfFakqkZcjW2H55v3KDVU5bzDzTmxOPrT0dQUwJrnoWv/k9Noa/RQJ8pcNZDauLDaOb3gruZ7NjV+yDgab/+CBEDomb30/3338+4ceOwWq3ExcVFujuiM6gpVRdwHqgd1OZKtsDTJ8GGRWqphZItaiXy929uuiX2MHprPLmDrqfkrGchfSg40vH1ncreS5dSET+QeFsHGompLIBtS9VRiJ8+hIrd4XPqBHzw7QJY+aAa0IB67taPCL5+ufpvE82MdvzdTg7bHMgaG3ZHnRAitKgZqfF6vcyYMYOxY8fy3HPPRbo7Ipa598GOz9QCe95q6D8VRlwF8d3b7jXrKgj+7040Rxa+BNj6IVTc1riq8WGcFgMZGZls08Xx7YkDMGsDVActDIhLJyuhAy203L8NXjgX3HsbjlniYeYHkDao6fnufWoq/RA0e9cTrCpAY09po862vdpAEHfv6aSueUp9nx1OZ6R0yFyMPh1xsrREiBaLmpGa++67j5tvvpnBgwdHuisillUXwZJfwzvXwb4N6nTQqkfgP6dBWW7bva6nCk3eF2Gbla0fNfvwBJuJ0T0TGT+4D4P79uWMoT3JTrZjbIOCmcelZj+8NbtxQANQVw6vXaxWCj+C4nE3vdkf3l6yrbV72a78gSD/WlNPwQXvoBy+LiptMPsuXML8bzz4Ap1mH4cQrSJqRmqOh8fjweNpmJOuqqqKYG9EVCjZCjuXNz1eWwpfPgJnPhg2ad0v4VdAr9WD4g/ZrugtLfoG0h41pY6HUrMf7d4fQjdW7iHgLkLnTG902K81Y2zmmvjtGXSQkO242E16eiQ7Of+tXK4f8xCjJ2ghGGTDfnj0/XImD4zHZYnpj2ghWl3UjNQcjwceeACXy3XoJysryhcWirb3/avh2za9pY4stAG31omn73lh26u7hdn2GyUCntpm25V6d5NjFdo4vP0vDP0ARxpV5i6t0bWI0Wo1nDMknYAS5E9L9zL5xQImv1TI7R8VUlnr48qx3RttexZCHF1Eg5o777wTjUbT7M+WLVuO+/l///vfU1lZeehn9+7drdj7Tqy6GPb+AJuWQP43UFUY6R61mqCumZEObdt9a67DROGwW8GR3qStasxt/FwX3QtG/aY40JtDN2o0+G1pTQ77tBZ+HnxL08W0zi4UnPsa5brorwqUGW/lrevGce4J6ei1GrQaOGNACkvmjSerjfMbCRGLIjq2eeuttzJr1qxmz+nZs+dxP7/JZMJk6kA7P2JB5R5YdAUUrms45spUE4Ulh07wFk38Qy7D8P2LIdt8gy/FYG2bG2m81cDDP2uYeuabZOxfTUL+//CZkynufznv7DIzOeHo+Wo6Mrc+Ef/IG3Gs/keTtrpBl1Otj+PISb0Up4mPNhr5scefmTA2gKEqH8WazA6Pi1fX+PjLtNhIn989ycbfLzyBO8/qD0FwWQzYzTLtJMTxiOhvTnJyMsnJ0f1h3anUV8GHtzYOaEANdF6ZDld/As6mIw3RZIsniV79p2P56c3GDXHdKOg7E2udQkobDJpYjHquHNedX/3nGxzmfgzLOJFKb5Bli0q5bXIXUp3RHZybLVY2Zkynf04CcWv+qeafscTjHnYdWzKm0TNEMj2DTsv5J3bhze+CnLtoB1qtg3pfDaf1s3H3OQNIskf3NTmc1aTHKqUphPjFoua3KD8/n7KyMvLz8wkEAqxfvx6AXr16YbfbI9u5zqKmBLZ9HLqtIh/chVEd1AS9NeRX+Snt+zv69Z5Oyubn0fpqKOs5lYLkk5j3ViGL5nZrs9fPjLeyaO4Y1udX8N8f95LmMvPWb/qSEWeJzpTxdZXqIl9zHE6Lge5du/JE3kmclDOORHOQKp+GT3druSoji8QwAUqi3cTVE3pwzgkZVHv8WAxaEu0mqU0lhAgpamo/zZo1ixdeeKHJ8eXLl3Pqqae26Dmk9tMvE9y7Ac3TJ4VtVy5dhLbvlHbs0XGo2a+m3dfqwHFgHcfBNULfPAXeGsp6nktx+ml8uMOL4vfxRX49G/ZUMqZnAk9fPhyXNTamPdpMdTHsXgOrH1e3ZPc7F4ZcAvHdqKj1sr/aS3mtF5fFQKLNGDagEUKIg6SgZQgS1Pwy3v25GJ8aA6ESxAG+uV9hSB/Yzr1qofoqKPgWlv4JijaCMxNOvg2yT4dP74GNbzU+P64r285axJSFeQSUIBoNLPnNeIZmxUWk+1GjpgQ+vA02v9P4uC0JZn8KCT0i0i0hRHRr6f07prd0i9ZVQjw1w64N2ebvdjLFSgctvKco8PPH8NL5sO9HNdV+5W749F41wDkyoAGoyCdj64tM6Z9AjyQbL109mt4pMs15VGW5TQMaUEfIPp8P3rp275IQovOQoEa0WL2iZ1XSRVSPvlmtlgyg1eEdMJ3No//BPn8H3YLq3gsf39n0ePcJ6rb0MGw/LeIfZ2awaO4YJvROknUcLbFhcfi2jW9CXVn79UUI0enIp7RosXibkSfXVvKB60xmT70Au6Yer9bMm1u8vL+kgHfmdY90F0OrrwhdEFKjhWAg/OMUBZtRj80RJr+KaEKhmW9KGg1o2rEzQohOR4Ia0WIJNiP/vGgoFz/zNe9tbAgSzAYtL88eTaqzY978A1pD6HT6+avhjD/Dj2+GaqW+73l4tU5k9VXL+QbOwLT2PyHbvAMuJGiIQ5YFCyHaigQ14pj0TLbz7rzx/FhQyXd5ZWSn2BmbnUSGy4xO2zG/htfonDgzhjXNr1NdDH4PSs8ctEfWe7IlUzR4LsaALjqDmuoS8LpBo1MX6Rpt7fKyP9YmMLDv+Vi2HjGtZ0+hcPA8TB4t6ZEqHO6rUxcyK34w2MCRqh6vLVWvl6dKrRpuS1L/FEJEHQlqxDHLiLOQEWdh8sCmqe07oiKfjapT/0XmOxeqN7CDdAZq7d3YNuIBMrPXkLjxefDVUJ19DkW9LuLJ77386Zwo+xXx1sLe9WqSxOLN6tb1/lNh4n0Q/wty7AQCUFOkLrI22sASF/K0j3Z6Kep+MyN6TSN183PgcVPZ4yyKup7NDe+XsPDqCO1+qiyAlf+ADa+pW/oTs+Gsf0J8D3h7DuxZ03Bu78lw7iPgzIhMX4UQx022dIuYt6e8ljkvfMtDkxJIK1+Hq+hraly9KMs8g3JDCte99iPxViMXDbJi1WlYtsvHim2lLPnNeAZnxkW6+8em4Dt4diIElcbH47rCVR+pJS2OVdVeWPcirHkK6iqg23iY9FdI7geGxlOOG3ZXMPWJVWTGWzh/gBO7AT7f7WXVjnKuGNOVP54zAFN7F2l0F6kZr/dtaHx80l9h49tNR/AABpwHUx+HEJmOhRDtr6X37yj7GirEsUtxmJg8KI1zXtxGr5RudE/sT+leL98vzWfaUD+vXTuG+z/YzF8/KyIYhN4pdl65Zgy9om0Ld105fPKnpgENqBmf93x37EFNdTG8eZW6/uigvC/g2dPg6qWQObzR6ZkJVi4dlcVra3bz2KqG7dsZLjNzT8lu/4AGoGxH04AGILFX6IAG4Kf34PR7JKgRIspIUCNinlGvY+a47kzN1qHUlqNodHxbpOfErnFce3JP0lwWHr30RMprvPiVIE6zgSRHFC5n9dbC7tVhm4PbPkYz8Lxje86ynY0DmoOUAMH/3YnmV4vAmnDocILNyG2T+nLekC48vyoXd72fc05IJ6dfChlxkVlMo+Starojy2BRg8BwgkHwuNuyW0KINiBBjYh93lri960l/v3fQnkuAH0yhqFMfRztgeDFYTZEZ32lwwQ1WjS2ZHDvC9muODMb7wJzF6mjGDs/B3sy9MxRa3cZGoIPZdsnYbdoa/asUW/8hwU1oNZrSrSbGNo1joCiYDNF9rr6bWk0KWzhq2vS70Y0WvwGu3xAChFl5HdWxL7SbfDStMbTMoXr0C48E+Z+DvHdI9WzVlWuiUc/9FqcX/y5aaNGQ3XfCziU87mqEF7/FRR+f9g5Wpi+AHpPAqOaSFExx4fPO6M3E0Abers8YDboIGxr+6lOG02CzgABX+OG4i0EM0epwdkRvP3Op1IbT3I79VEI0Toko7CIbR43LP9b6HUm9ZWw+T11qiEGeAJBNiVNwdvzjMYN9jR8s5djqMiFT/8M614gWLkHTI7G5wUVdf3MYSM9NV0nhn29ugEXU6XtoKUxDrOlxsb+sxeArvGIkbJtGZ6pTxHodnLDQY0GX9+pbBp0O8X18p1PiGgjv7Uitnmq1R1B4eSuhFHXNtnFE42sJh1PrHVzbu+7GD/iNqyFqwlaE3Fkj8H4+gwM5XmHztXojDDt3+roxeFrZoIKyvalaBPnAvBdmZETT/sH8Z/d0fjFknqze9B1WBU9HT2jS2ZyPHetTuS2i1YQV/IthroSatNGYUjqwXnPbWP2iPs4fawWvb8aj97B+zv8vPjWbt6/oXukuy6EOEYS1IjYptGo+UZqSkI2K/E90Oqiey3NQS6LkTsm92Pav1dh0uvomTyC6YPiuHzpH+GwgAaAgBfeuxEueKbJQuCgu+jQf6cmJ/Hoz0O4+tIVxOe+j6m2mPKuZ7BD15PF6+r5y7SOf+3SXCaunNCHc19YS4arOzZTL3atquG6U72cOySDvyzbyV8OnV0JwF+nDSLFGYWLxYXo5CSoEbFLCaDs+xHtsJnw4S1N2zUaKvpfhhNNzPwi9E5zsGjuWO55dxObCqv450QXhi8+CX2yr1ZNRmhPUbduH1CbeRIHJ6YyXBZqNRZOe6GAkd0nYTXp+GlpFdWeQpb8ZnxULK426nSM7B7P0ltOYXNhFfvdHk7IdJEeZ0ED9El18PCnP7OnvI5eKXZ+N6UvI7snYNDJ7LwQ0SZWPsuFaMq9F+2Sa2H8zTDiavhuQcP6GZ0R/zmP8n6+kUuyguhj5P5lMegY2T2Bl2aPotrjJ8OX3/yaoboKtWTAAYGUwZSaux0KauJtRu6Y0o/JA9N4+vOd7CmrY+rQDH41qiuZ8R20KnsIRr2OrHgrWSH6fOHwTE7qnYRfCWLUaaNzO78QApCgRsSy2lKoLYOld8OoOfCrN9SdUHozONJx65OxKU5Mhsjv0GltB7dVU+UCRzq494Y+MXUQVBWAwULdwEvJ7XctBkvjPT9JdhOn909lZPcEfAEFp0WPQRdb1yylgxZjFUIcGwlqRMxqtN14zX9g7bPgyADFB9XF+C76kHHZSZHsYpur1CXCyffh+vDaJm3e7Mn44nqzY9qneINaXttYS/JOuC4n9A3eaen4U01CiM5NghoRs+r0cdhdmVC5Rz0QDKqjEgBmF46ULCwRynLbXkprfbxV2IOrzn2RpK/+DKXbweyieug1bO4ynbxdGlZuDRBQ/Fw9oRe9Uxy4JHgRQkQpCWpEzCpU4nCd8QSp71ykVmY+SKPFfdYT7PbYGXA8T1xbCnWV6s4qS3zYitUdxROrS/hfchy/HfMs3V06anzw7PoaPluZyyMXD+Xv0wej12oPJMsTQojoJUGNiFlWo4671hq5+6JPSdz+BvaSH6iL78P+vpfxz7X13HzmMa6j8PugZDN8cHND7psB02DifRDfTQ1yOhiXxcCAdCeb91Zx4/vVjdq0GhiSGYc9wmUMhBCitUhQI6JfTSnU7gdvjVrPx54CBispDhNje6eTs2Azp/Q+h17x57G7IsCyF/cya1wPkuzHuMulIheeO0Md9YnvARPvUbMSf/ssdBkBXYarVbCPN7ipLYWAH8yuVksGmGg38eCFg5nx1Go8/sZZlW+b1Fd2+gghYooENSK6leXCW7MbRk50Bhg5BybcjNGewgUndiHFYeKhj7ey/Oda0pxm7ps6kMkD07CZjuHt76uDVY+pAY0jHc6eD+/8BqobEtVhiYeZH0DaoGP7O1QXq5mNv3pMrRzd8zQYd4Nak0p3DH0MBtUSB0FFDYqsiQD0T3Pyv5tO4oWv8vgmt4x0l4Vfn9KTPqkO7MdyDYQQooPTBIMxUvimBaqqqnC5XFRWVuJ0OiPdHfFLuffCgrOgbGfTtlN/DyfdeqjeT7G7Hp9fQa/TkuIwoTnW0RR3ESyYor7WpL/CD69B0aam57myYPZStdr10dSWQc1++Owv8NN7jdsMVrhmGaS2cNVPdTFsWgKrHlEDm/ShMOkv6p8mOwBef4Bqjx+zXodVghkhRBRp6f07RlKOiU6pLC90QAOw+vFGhRlTHGa6xFtJdZqPPaAB0JvAdmD7d0LP0AENQOXusCUZGqkphS/+Cfu3Ng1oQM32+/Fd6oLko6ktV8/96A61+nZQgcJ1sPBsyPvi0GlGvY4Em0kCGiFEzJKgRkSv0m3h2zxuNTA4FsEgVOTDxrdh6T3qnxUHMvJa4giMu1k9L+Br/nm81c23A5RsgT1rm9RdamTnZ+BpQVBTvQ9+XBy67b+3Q1WYxHtCCBFj5CubiFqBuO6E3YRssBLUq7V9WqxoE7xwjrqu5SBzHMz6kGDqQHaYB9BlyNXYdHp15ObwbeIHabTgSGv+dXz18PWTEAyAtpmdR1odtORvsHd9+LbK3eCpAlowHSaEEFFORmpE1Kq1d1MrcIdQN2Qm5bqElj+Zex8surxxQANQXwGLLsdbUcj1S3axwPgrqlx9CY65PuTTeE+8Co8psfnXUvxQXw57f4BuY8OeFuh3Hoo5/qhdV4xHWR/WXOAkhBAxRIIaEbVW7NOz59zXITG74aBGg6f/dL7PuoKy+mNYA1+zH8pzQ7eV56KvLyMQhPlfFPN1mYPlCTOoOv3v6vZxAGsClSfdzcr0q9lXf5QBUKMNf7+p6jTWzpUwqmkJA+wpFA67lRLP0RPi+ZIGqCNHIQR6nEKtwXXU5xBCiFggQY2IWi6zkYve3M9HI55nz8VL2XvBEnIvWcmTtuu45s3dmPTHkCE31FTSYbQBD9OHZ6qnKkGuXryT2RsHs/LUN9k4fSWrJr7L9bnjmfPWLordzT+XTwlSnJ6jbg3/+t9qXprpC2DAedDjZAKT7mfrue9w2dsleAPNBGbVxVCyBcXvxTvtuQPTVYdxpLFn3P0UeSUXjRCic5A1NSJq9UqxU+sLcN27aj0nvVaDX1HrPF08IpMku7HFz+UzJ2DQGUIvAtYZ8ZsTOW9oGq+tycegU9e5rN1VwcxdFU1Otxyl3IDHH+D+L938btrbZGx4HP2qR9XRmwm3U919En/+0s3b7+WRlWDBpA/xvSPgh6IfYcmvoWQLFoChl+G/ZgW+LZ+gr8ilIn08BY4TuP7tYl68ukeLr4MQQkQzCWoEeKrVbcjFP6nf9pP7HcjK27GLPaa7zLw8ezRXPr+GshovfkUd1RjTM4Gbz+iDxdjyt3dx0IlrxDzs3zzSpK16xDwqg066xFl4/dox5JfV0jvFzrbipruc0l3mo2Yqtuh1dE+0ccaCXN6Y/SeCfeYRUIIs3VnPS5/spNrjB+COyf1IcYbILFy5W83Pc/jurvWvoP/hdSqu+pL7vqxn06oqdu7fxcAMJ3HWGF1TU1MKAY/6PrUcfe2RECL2SVDT2dWVw7cLYflfQAmox3QGOPthta6R2RHJ3jVLo9EwMMPJBzdMIL+0luJqD72SbaQ6zSQeYwmE/fU6vnFcQM7pmcSv+aea2M+RTvmoW1iuGU3Pei1dgIw4C2lOM4//6kR+9Z9vKK3xHnoOh0nPf64cQZqr+RIHOp2WGSOyeG5VLr9ZvJm/nT+YRz79mXX5FQA4zXrumNKPk3onNX2wElAT/4Xarh4M4Prir2TYbub9/TVYDDoevPAEEmwxNv1UW6ZmkF7+N3UdVFJfOP1uSDsBzJJUU4jOTDIKd3a5n8ML54Zuu3YlZAxt1+5Eyu6yWib+ayUD0h1cP9JBslVDSW2Qx9e62bzXzae3nEJWgrXRYwor6tiwp4If91TRN83OsG7xZLgsaLVH34btDyhsKqzilsXrqaj1ceXYbpyQGYfToifFYSbdZUavCzH15K2B1y5R/91CcXbh81MXs2qfjktHdSUz3hL6eaKVrw7WPg+f/KFp27SnYPCMYystIYSICi29f0tQ05nVV6nbmHNXhm4/4WKY+ljYnTWxxOML8OLqXdz/35+atN11Vn+uHNsN01HWyhyPEreHilovgWCQeKuR1FDTTYcL+FA+vBXtuhdCt2eNpn7Ga+hs8RhiKZg5qHwXPDEy9MJuswuu+0otKiqEiCktvX/LV5rOzF+vrs8IpzxPPacTBDUmg47pwzPplmhl/idb2VlSQ89kG7dN6svI7gltEtAAJDtMJB9LpWydAc+wa7B8/6Ka6fgINWNvw2yLRxeLAQ2o04LhdqrVV6prwySoEaLTkqCmMzPZUboMRxumfpKSNQatwdbOnYqceJuRSQPTGNY1Hl9AwaDXHnXRb3ur9/lZvE3LuZP/TcKnN6tBJ4BWR9WY21lals7Jtb5jC5Siie4oi54l0aAQnZoENZ2YX2umdsQNODe93bBI+CCDhZpBl+HohOsTkjp4QLA8t5ZVmm7cfOGnxNflQ8BHjTObhT/U8MUP+zl5SJ9Id7HN+CzJGCzxTTM/A8R1Vbfmt3+3hBAdRIyOUYuWqKjz8a/v/BSfvxjiD8tlktyPfRe8zUPf1OGuP0rxRtGuzAY9l43pxidbKzjzhXwmva/nzI+snL4gn5fWlXLRiCwSbC3PzxNtCgPxlJz5TNMRG4OFokn/Zp8i2ZOF6Mw639dwcYhOo2HtnlouyzNw27gXyHZ4AS0by3X86/1yeiTr0Wsl7u1ohmS6GN0jgW9yy6iq8x863j3RyrQTu6Brwe6raFVU7eXptTb+dPFnJO5cgr1sM1VJJ1La/Rx+t6ycP57rI+sYSn4JIWKLBDWdWLzNyFXje3DbGz8w952mieT+ct5ALMa2WSArjl+K08z/XXoia3PLWPhVHn4lyIXDunB6/1Qy4jp2wsRfKsFmYtm2CpZvr2Bs9mS6OM9mV66PNct3oQGcZpl8EqIzk6Cmkzu5dxLjsxNZtaO00fFzT0hnYIYM5XdUqU4z5wzJ4OQ+ySjBIHHW2J1yOlyi3ciEXol8ub2UVduPeM8OyehwC7uFEO1L8tQIStz1/FxUzRvf7kan1XDJqK70SLLJDUJ0SHsr67j7nY18+lMxAFoNnHNCBned3f/oeX6EEFFJku+FIEFN8w6+FTSa2F2TIWJDVZ2P0moP1R4/DrOBJIcRu0mmnoSIVZJ8TxyzThfMKAq4C9UEhHWVkJgNtiQpjhgFnBYDTosEMUKIxiSoEZ2TEoDCdfDqRWqBxIMGXwST/gqO1Mj1rbVUl6iFL7V6ter60RLXCSFElJOgRnROlXvgxfPUApGH+3ExJPeB8beALkp3fnncasD2v99D0SYwOWDEbBj9a3CmR7p3QgjRZiQJieicdn/TNKA5aPUTUL2vffvTmnavgRemqgENqEHOqkfgrauhujiiXRNCiLYkQY3onEq3h2+rK4dAlGZSdhfBR3eEbtv1FVQ0U8BUCCGinAQ1olMKZAwL3xjXFQxRujXYV9N8wJb/Vfv1RQgh2pmsqRGto2ov1JSoUzqOVLClgMke6V6FVRvfH4ezC1QVNGmrHHsn6BOIytSDWr26IDjcSJMtqX37I4QQ7UhGasQvEwzCvo3w3Bnw9EmwYAo8NhyW/VndfdNBvbE1wK6pi1EyxzQcNLuozHmAt6r6UXlYTaWoYksiOGh66DatHrqObd/+CCFEO4qKoCYvL4/Zs2fTo0cPLBYL2dnZ3HPPPXi93kh3TVTuhoVnq38eFFRgzdOwYbGaCybSPNVQthP2fAtFm6G6GIfFwLRXC1nY7W9sv3gFO6d/zHdnfcBN24fy95XFUVsUMqi3UDX2DpTEvo0btDoqznmOcp1UexRCxK6omH7asmULiqLw9NNP06tXLzZu3MicOXOoqalh/vz5ke5e51awDuorQrd9+U8YdD44M9q1S41UF8OKB2HdQjU3DUBKf6ZNf5FHTXr+vOzwXU5qLaFfjepKoi06aykVVXm44rXd/OmU5+jFHux7V+GzplORcTLzv3ZzhcvH2PZOpn0wyWH5LqgphqS+YE8FW2I7d0QIEeuiIqiZMmUKU6ZMOfT/PXv2ZOvWrTz55JPNBjUejwePx3Po/6uqqtq0n51S8ZbwbbWl4PeEb29rAR+sfRa+fa7x8eKfMLw8jSWXf8ioxzdzeKGQ3ql2rj+tF2ZDdOaoqfcF2FZUzRWLq0m2m8hOORt3vZ9NH+cDMKR7BWOz2zGYUBTY9wO8fEHjJIe9JsLUxyVvjhCiVUVFUBNKZWUlCQnND6U/8MAD3Hfffe3Uow5CUcC9V80kqzOBPRkMljZ7uWD6YMJO1DjSQB/BopjufWrOmVCqCkj07mbFbafw8aYiiqo8nNInmb5pjqguimjQa7AaddR6A5RUeyipbhxUdk2wtm+HqgrgxWlNR/O2fwpfPgKT7gN99F5vIUTHEhVrao60fft2HnvsMebOndvseb///e+prKw89LN7d4zn6KgthXUvwjOnwOMj4IkRalbZqsI2e0lv8mCwJYdsqxt3OwFrBMsN+GrBWx22Wbt/O90S7Vx7cjZ3nzOAk/skR3VAA5BsN3H56K4h22xGHYMz23lPV9Gm8NOT6xZKMkAhRKuKaFBz5513otFomv3ZsqXx9EZBQQFTpkxhxowZzJkzp9nnN5lMOJ3ORj8xKxCAjW/DB79Vt1aDOvXz3QJ4+1qo2d8mL/tlsYk9570JKf0bDurNuMfeztLgKIprIriY22BVSwSEk9S7/frSTox6HbNP6klOv5RGx10WAy9fM5p0V9uN2oVUkR++zV8f2elJIUTMiej006233sqsWbOaPadnz56H/ruwsJCcnBzGjRvHM88808a9izLVe2H5/aHb8r5Qp6TaIEfJj3squWttKXec9BTDkwJoAx7cWgfPrq/l7eW7+bxfdqu/Zos50giMug7dF/9o2ubKxB/fI3rnX5uR6jTzzxlDKHF72F7sJsFmpGuijTSnuf13daUPDt9mS1YDTyGEaCUR/UxPTk4mOTn01MWRCgoKyMnJYfjw4SxYsACtNipnztqOx62m9w+n+CdIa+YGc5wGZ7p4ZNk2bvnw8CR2aj/SXWZMESwKub9WYWfKBQweuh/Lhhcadj+lDiR/4lMo/ni6R6x3bSvBZiTBZqRvWjMjVe0hvgck94WSrU2alJy70DpkobAQovVExRfVgoICTj31VLp168b8+fMpKWlI6paWlhbBnnUgejNotGqOmBAUW2qbzDUOSHeS5jSzr6q+Sdttk/qS6mrhGhW/R11fEfCq395bYVdMVb2PS17dydUjL+Xii67C6q8koLOwrlTP3xYXc8ukOLon2X7x64jwiomjbsqLdPnqT+h3fqImazTHUTnmNvYl5NALDdG5z0wI0RFFRVCzdOlStm/fzvbt28nMzGzUFjx8P24nVmuIx9jnbPRb32/aaInHF9eDttiHlB5n4bVrR3PT6+v5YU8loC5IvfmMPk3WdYRVtRdWPQrrXlAX97oy4fR71W2/1vjj7ptWo0EJwrNrSnh2zaEXO9Ru1svttK3l7a/h6hd3MXvkHZw14y50ioeKgJknvq3mhy+28eENqaTHtfM6HyFEzNIEO1FUUFVVhcvlorKyMuYWDeeWVOMt203vZdegLd7Y0GB2se+818k19mJsdguDjONQVuOlrMaDx6/gshhIdZowtGTqqWY/vDkbclc0bTvv3zDkUjjOqcaKWi9zX/qOb3LLmrRpNbD8tlPpligjNW3pha/yuOe9TWHbl916CtnJHbdGmBCiY2jp/TsqRmrE0fmVIDNez+ehKf9mkLUCU+lm/PYuFJl78IelZcw9pW1rGR1cw3HMqgpDBzQAn94DPXPAdXwZieOsRv56/iCmP7mayrrGBR7/ct4gku0RzKETq4JBNT+Q4ge9kX5p4QMWs0GLSS9r44QQrUeCmhjhtBiIsxiZu2QPdpOedNcAKmp9lFSrW2oHZ3TQkamijeHbakrA6/5FT98r2c4HN0zgk837+Pzn/WTEWbhiTFeyEqxYTfL2b1XVJbD5HfhivhrYJPZixOn38qfTu/DnZXubnH7Z6G6kOKI7L5AQomORT/UYkeo0c//5g5j5/BqqPX62FTcknbt6fHcSHR10VCJM4j5AXfis+2U1mDQaDVkJVq4e34PLRndFr9Wi18noQKurr4KVD6plKQ4q3Y5u8eVcefYjrB80iPc2NiTaO2NAKtee3BOjjNQIIVqRBDUxZES3eN6dN4F/Ld3KD3sqSXWauD6nF2N6JuI0GyLdvZB8CX0wmBzqlvQjBPqcDZakVtkdo9FoMBvk7d5makqa1tg6QL/sXubP+ZyZJ2VTVuOje6KVJLuJ+CgtGiqE6LjkUz6GWIx6Bme6+L9LT6TG48eo05LQwdeN7PQ4iZ/6CinvXKLufDpASepH3oi7sHj0ZMjmmI6vbCeE23NQX4HRW8nwbt3at09CiE5HgpoY5DAbcHTQkZkjbdhbzeJvNNx7/ickV23CUF1AXfIQtvpSuPm13bwxN/PoTyIir7lyFBDZwqZCiE5DghoRUZlxFtbmuzn7RTeZ8SnEWbuwe1UdlXW7Meq0mA2SSyYaBBxd0FniQ2e1zjiRoDUxfDV3IYRoJbJKT0RUt0Tboa3Ve8rr2FhQdWj79fThXUiyy7qLaFBMPMXnLATDEXOFtmT2nvYoJQHJBySEaHsS1IiIyoiz8PI1o0g/opzCqX2SufH0PliMMpgYDbaX1HHD5zq2Tf+U0px/UDdsDsVTnmbDWe9w6ZIySmt8R38SIYT4heSOISKub5qTJb8Zz97KOspqvGQlWEmW3TFRxaDT8s2uKs5YUEX/9P4k2Yeye2steaW7ALVkhRBCtDUJakSHkOYyk9bS4peiw8lMsGAx6KjzBfhprxto2KLfM8lGvC06Fq4LIaKbTD8JIX6xFIeJhy8ewpEDMmaDlocvHiqZg4UQ7UJGaoQQv5hRr+PkPsl8/NuTeeWbXWwvqWZ4twQuHNaFLlKFWwjRTiSoEUK0CqtRT580B3efMwBvQMGk16HTyloaIUT7kaBGCNGq9DqpryWEiAz55BFCCCFETJCgRgghhBAxQYIaIYQQQsQECWqEEEIIERMkqBFCCCFETJCgRgghhBAxQYIaIYQQQsQECWqEEEIIERMkqBFCCCFETJCgRgghhBAxoVOVSQgGgwBUVVVFuCdCCCGEaKmD9+2D9/FwOlVQU1paCkBWVlaEeyKEEEKIY+V2u3G5XGHbO1VQk5CQAEB+fn6zF0W0XFVVFVlZWezevRun0xnp7sQMua5tQ65r65Nr2jbkujYWDAZxu91kZGQ0e16nCmq0WnUJkcvlkjdJK3M6nXJN24Bc17Yh17X1yTVtG3JdG7RkMEIWCgshhBAiJkhQI4QQQoiY0KmCGpPJxD333IPJZIp0V2KGXNO2Ide1bch1bX1yTduGXNfjowkebX+UEEIIIUQU6FQjNUIIIYSIXRLUCCGEECImSFAjhBBCiJggQY0QQgghYkKnDWqmTp1K165dMZvNpKenc8UVV1BYWBjpbkW1vLw8Zs+eTY8ePbBYLGRnZ3PPPffg9Xoj3bWodv/99zNu3DisVitxcXGR7k7UeuKJJ+jevTtms5nRo0ezZs2aSHcpqn3++eece+65ZGRkoNFoeOeddyLdpaj3wAMPMHLkSBwOBykpKUybNo2tW7dGultRpdMGNTk5OSxevJitW7fy1ltvsWPHDqZPnx7pbkW1LVu2oCgKTz/9NJs2beLhhx/mqaee4g9/+EOkuxbVvF4vM2bM4Lrrrot0V6LWokWLuOWWW7jnnntYt24dQ4YMYfLkyRQXF0e6a1GrpqaGIUOG8MQTT0S6KzFj5cqVzJs3j6+//pqlS5fi8/mYNGkSNTU1ke5a1JAt3Qe89957TJs2DY/Hg8FgiHR3YsZDDz3Ek08+yc6dOyPdlai3cOFCbrrpJioqKiLdlagzevRoRo4cyeOPPw6AoihkZWVxww03cOedd0a4d9FPo9GwZMkSpk2bFumuxJSSkhJSUlJYuXIlJ598cqS7ExU67UjN4crKynjllVcYN26cBDStrLKy8lAhUSEiwev18t133zFx4sRDx7RaLRMnTmT16tUR7JkQzausrASQz9Bj0KmDmt/97nfYbDYSExPJz8/n3XffjXSXYsr27dt57LHHmDt3bqS7Ijqx/fv3EwgESE1NbXQ8NTWVffv2RahXQjRPURRuuukmxo8fz6BBgyLdnagRU0HNnXfeiUajafZny5Yth86//fbb+f777/nkk0/Q6XRceeWVyGxcU8d6XQEKCgqYMmUKM2bMYM6cORHqecd1PNdUCNF5zJs3j40bN/L6669HuitRRR/pDrSmW2+9lVmzZjV7Ts+ePQ/9d1JSEklJSfTp04f+/fuTlZXF119/zdixY9u4p9HlWK9rYWEhOTk5jBs3jmeeeaaNexedjvWaiuOXlJSETqejqKio0fGioiLS0tIi1Cshwrv++uv54IMP+Pzzz8nMzIx0d6JKTAU1ycnJJCcnH9djFUUBwOPxtGaXYsKxXNeCggJycnIYPnw4CxYsQKuNqcHAVvNL3qvi2BiNRoYPH86yZcsOLWRVFIVly5Zx/fXXR7ZzQhwmGAxyww03sGTJElasWEGPHj0i3aWoE1NBTUt98803rF27lgkTJhAfH8+OHTu4++67yc7OllGaX6CgoIBTTz2Vbt26MX/+fEpKSg61yTfi45efn09ZWRn5+fkEAgHWr18PQK9evbDb7ZHtXJS45ZZbmDlzJiNGjGDUqFE88sgj1NTUcNVVV0W6a1Grurqa7du3H/r/3Nxc1q9fT0JCAl27do1gz6LXvHnzePXVV3n33XdxOByH1ny5XC4sFkuEexclgp3Qhg0bgjk5OcGEhISgyWQKdu/ePfjrX/86uGfPnkh3LaotWLAgCIT8Ecdv5syZIa/p8uXLI921qPLYY48Fu3btGjQajcFRo0YFv/7660h3KaotX7485Pty5syZke5a1Ar3+blgwYJIdy1qSJ4aIYQQQsQEWfAghBBCiJggQY0QQgghYoIENUIIIYSICRLUCCGEECImSFAjhBBCiJggQY0QQgghYoIENUIIIYSICRLUCCGEECImSFAjhBBCiJggQY0QIqasWLGCYcOGYTKZ6NWrFwsXLox0l4QQ7USCGiFEzMjNzeXss88mJyeH9evXc9NNN3HNNdfw8ccfR7prQoh2ILWfhBBRo6SkhMGDB3PjjTfyhz/8AYCvvvqKU089lY8++ohPPvmEDz/8kI0bNx56zCWXXEJFRQX/+9//ItVtIUQ7kZEaIUTUSE5O5vnnn+fee+/l22+/xe12c8UVV3D99ddz+umns3r1aiZOnNjoMZMnT2b16tUR6rEQoj3pI90BIYQ4FmeddRZz5szhsssuY8SIEdhsNh544AEA9u3bR2pqaqPzU1NTqaqqoq6uDovFEokuCyHaiYzUCCGizvz58/H7/bzxxhu88sormEymSHdJCNEBSFAjhIg6O3bsoLCwEEVRyMvLO3Q8LS2NoqKiRucWFRXhdDpllEaITkCmn4QQUcXr9XL55Zdz8cUX07dvX6655hp+/PFHUlJSGDt2LP/9738bnb906VLGjh0bod4KIdqT7H4SQkSV22+/nTfffJMffvgBu93OKaecgsvl4oMPPiA3N5dBgwYxb948rr76aj777DNuvPFGPvzwQyZPnhzprgsh2pgENUKIqLFixQrOOOMMli9fzoQJEwDIy8tjyJAhPPjgg1x33XWsWLGCm2++mc2bN5OZmcndd9/NrFmzIttxIUS7kKBGCCGEEDFBFgoLIYQQIiZIUCOEEEKImCBBjRBCCCFiggQ1QgghhIgJEtQIIYQQIiZIUCOEEEKImCBBjRBCCCFiggQ1QgghhIgJEtQIIYQQIiZIUCOEEEKImCBBjRBCCCFiwv8DLBMaBfdY97wAAAAASUVORK5CYII=\n" - }, - "metadata": {} - } - ] - } - ] -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb b/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb deleted file mode 100644 index 9373488..0000000 --- a/examples_FEI/STAR2000_loss_Smooth_SVM.ipynb +++ /dev/null @@ -1,1102 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "lRz5G7RAaFtj" - }, - "outputs": [], - "source": [ - "## set up plotting style\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "custom_palette = ['#FFE4E1', '#3D325C']\n", - "sns.set_palette(custom_palette)" - ] - }, - { - "cell_type": "code", - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "-GNV_K9al_tQ", - "outputId": "9cae07ee-03d0-4ede-848d-d3201cbcaca2" - }, - "execution_count": 3, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-al6i7zz6\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-al6i7zz6\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=bc61970eef67d92d0256e4429ad1bbd576c2e0ed03185a2e257b2abec3348aa1\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-egsuyb_8/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "ZawpNRuQR9Uu" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", - "X = scaler.fit_transform(X)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "lskTdleDZwpa", - "outputId": "b3f748ec-1837-43ae-fa9d-cb1f90e6a58e" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(loss={'name': 'sSVM'})" - ], - "text/html": [ - "
plq_Ridge_Classifier(loss={'name': 'sSVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 5 - } - ], - "source": [ - "## solve Smooth SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "clf = plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 429 - }, - "id": "g5DCBXT5Z5uR", - "outputId": "9b94bd5a-511d-4a08-e5c5-a18dd1be2d71" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = clf.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "sZPCmCtOaXY8" - }, - "outputs": [], - "source": [ - "#With Pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "MCEXWUchaaP_" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline\n", - "import numpy as np\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "PwMysLRWaiv_", - "outputId": "9e65777b-3a1b-478d-beb8-02a2d81b8a1e" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ], - "source": [ - "## solve SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'sSVM'}, C=1.0))\n", - "])\n", - "pipe.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 429 - }, - "id": "ZMofqZ_zakNc", - "outputId": "357b460b-59ed-489b-85bb-14abf025c4b7" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = pipe.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_Squared_SVM.ipynb b/examples_FEI/STAR2000_loss_Squared_SVM.ipynb deleted file mode 100644 index a7648b1..0000000 --- a/examples_FEI/STAR2000_loss_Squared_SVM.ipynb +++ /dev/null @@ -1,1105 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "id": "QvfFVk7WRUAb" - }, - "outputs": [], - "source": [ - "## set up plotting style\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "custom_palette = ['#FFE4E1', '#3D325C']\n", - "sns.set_palette(custom_palette)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "lrklwkcyDvTw", - "outputId": "5b429a02-890e-4cd2-8bd7-099fb6790a78" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-2nf2n7rx\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-2nf2n7rx\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=566656c57e2918bd1d23613f29cfa356fec6e937d1ec37f8bb98febb77371d0f\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-2u6y9ak2/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "w08Rlr8La4Mv" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "import numpy as np\n", - "\n", - "scaler = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)\n", - "X = scaler.fit_transform(X)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "id": "MlOfn-UmRCuN", - "outputId": "06ee1d8d-8e54-4f32-e413-b0c17c380fdc" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Classifier(loss={'name': 'squared SVM'})" - ], - "text/html": [ - "
plq_Ridge_Classifier(loss={'name': 'squared SVM'})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ], - "source": [ - "## solve SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "clf = plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0)\n", - "clf.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 432 - }, - "id": "mcbLDBYGRM4W", - "outputId": "eee04718-16ad-4ce5-e9e3-540d9c4bdb23" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = clf.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "u1wBO4l9zL1z" - }, - "outputs": [], - "source": [ - "#With Pipeline" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "1XPWQmcpSRYy" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "from sklearn.datasets import make_classification\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline\n", - "import numpy as np\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_classification(n_samples=n, n_features=d, random_state=42)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "Hu-ipK_n1_Br", - "outputId": "d119f0a0-fde5-45a1-e0c1-f1933eac9f37" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 7 - } - ], - "source": [ - "## solve Squared SVM via `plq_Ridge_Classifier`\n", - "from rehline import plq_Ridge_Classifier\n", - "\n", - "pipe = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('clf', plq_Ridge_Classifier(loss={'name': 'squared SVM'}, C=1.0))\n", - "])\n", - "pipe.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 432 - }, - "id": "WXuTX7ok2Drw", - "outputId": "1443d2b1-db05-4d49-8f6e-e1ff49127827" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## visualization\n", - "import seaborn as sns\n", - "import pandas as pd\n", - "import warnings\n", - "import matplotlib.pyplot as plt\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "warnings.filterwarnings(\"ignore\", \"use_inf_as_na\")\n", - "\n", - "score = pipe.decision_function(X)\n", - "y_label = 2*y - 1\n", - "df = pd.DataFrame({'score': score, 'y': y_label})\n", - "sns.histplot(df, x=\"score\", hue=\"y\")\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file diff --git a/examples_FEI/STAR2000_loss_huber.ipynb b/examples_FEI/STAR2000_loss_huber.ipynb deleted file mode 100644 index f611a57..0000000 --- a/examples_FEI/STAR2000_loss_huber.ipynb +++ /dev/null @@ -1,1135 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "8MeXCyHX0hSB", - "outputId": "93160eee-b883-4588-d043-05a97c4e3ee2" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting git+https://github.com/softmin/ReHLine-python.git\n", - " Cloning https://github.com/softmin/ReHLine-python.git to /tmp/pip-req-build-ir2yao1k\n", - " Running command git clone --filter=blob:none --quiet https://github.com/softmin/ReHLine-python.git /tmp/pip-req-build-ir2yao1k\n", - " Resolved https://github.com/softmin/ReHLine-python.git to commit 42f5b2711630b09ed6f7224522bc5899ed08902e\n", - " Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n", - " Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n", - " Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - "Requirement already satisfied: numpy>=1.23.5 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (2.0.2)\n", - "Requirement already satisfied: scipy>=1.11.4 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.16.3)\n", - "Requirement already satisfied: scikit-learn>=1.2.2 in /usr/local/lib/python3.12/dist-packages (from rehline==0.1.2) (1.6.1)\n", - "Requirement already satisfied: joblib>=1.2.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (1.5.3)\n", - "Requirement already satisfied: threadpoolctl>=3.1.0 in /usr/local/lib/python3.12/dist-packages (from scikit-learn>=1.2.2->rehline==0.1.2) (3.6.0)\n", - "Building wheels for collected packages: rehline\n", - " Building wheel for rehline (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n", - " Created wheel for rehline: filename=rehline-0.1.2-cp312-cp312-linux_x86_64.whl size=176611 sha256=4819e8f088a3974b692227a2d9811df20e294ee6ba9f04586146333463688d7d\n", - " Stored in directory: /tmp/pip-ephem-wheel-cache-qqgkwxb1/wheels/83/73/41/ba319d88afb6305ccf64c1d4050788c2404a57b35ea1a7b508\n", - "Successfully built rehline\n", - "Installing collected packages: rehline\n", - "Successfully installed rehline-0.1.2\n" - ] - } - ], - "source": [ - "pip install git+https://github.com/softmin/ReHLine-python.git" - ] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler" - ], - "metadata": { - "id": "l1yoptXqUxlc" - }, - "execution_count": 2, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "id": "96X3ttm4Em6O" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "np.random.seed(42)\n", - "scaler_huber = StandardScaler()\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "X = scaler_huber.fit_transform(X)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "id": "vSCgN97C0ei6", - "colab": { - "base_uri": "https://localhost:8080/", - "height": 80 - }, - "outputId": "a95d354f-4c50-4b23-d4f8-b12c481c1853" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})" - ], - "text/html": [ - "
plq_Ridge_Regressor(C=0.001, loss={'name': 'huber', 'tau': 5.0})
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 4 - } - ], - "source": [ - "## solve Huber Regression with different `tau` via `plq_Ridge_Regressor`\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "clf_tau01 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001)\n", - "clf_tau01.fit(X=X, y=y)\n", - "clf_tau5 = plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001)\n", - "clf_tau5.fit(X=X, y=y)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 424 - }, - "id": "-lHj744W0gFS", - "outputId": "b6b978ad-e980-4fee-f4e5-5863f17bbb0e" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## plot Huber Regression results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "tau01_sample = clf_tau01.predict(X_sample)\n", - "tau5_sample = clf_tau5.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample,'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "id": "l4oYORhVDgfa" - }, - "outputs": [], - "source": [ - "#With pipeline" - ] - }, - { - "cell_type": "code", - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import pandas as pd\n", - "import seaborn as sns\n", - "import warnings\n", - "from sklearn.datasets import make_regression\n", - "from sklearn.preprocessing import StandardScaler\n", - "from sklearn.pipeline import Pipeline" - ], - "metadata": { - "id": "HsIykQjgXxJ8" - }, - "execution_count": 6, - "outputs": [] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "XgGUDZnNEDnU" - }, - "outputs": [], - "source": [ - "## simulate data\n", - "np.random.seed(42)\n", - "\n", - "n, d = 10000, 5\n", - "X, y = make_regression(n_samples=n, n_features=d, noise=1.0)\n", - "y = y / y.std()" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 155 - }, - "id": "dsos8G2nEQqX", - "outputId": "6121b652-a083-4d52-d569-bcf0b1cca69f" - }, - "outputs": [ - { - "output_type": "execute_result", - "data": { - "text/plain": [ - "Pipeline(steps=[('scaler', StandardScaler()),\n", - " ('reg',\n", - " plq_Ridge_Regressor(C=0.001,\n", - " loss={'name': 'huber', 'tau': 5.0}))])" - ], - "text/html": [ - "
Pipeline(steps=[('scaler', StandardScaler()),\n",
-              "                ('reg',\n",
-              "                 plq_Ridge_Regressor(C=0.001,\n",
-              "                                     loss={'name': 'huber', 'tau': 5.0}))])
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" - ] - }, - "metadata": {}, - "execution_count": 8 - } - ], - "source": [ - "## solve Huber Regression with different 'tau' via 'plq_Ridge_Regressor'\n", - "from rehline import plq_Ridge_Regressor\n", - "\n", - "pipe_tau01 = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 0.1}, C=0.001))\n", - "])\n", - "pipe_tau01.fit(X, y)\n", - "\n", - "pipe_tau5 = Pipeline([\n", - " ('scaler', StandardScaler()),\n", - " ('reg', plq_Ridge_Regressor(loss={'name': 'huber', 'tau': 5.0}, C=0.001))\n", - "])\n", - "pipe_tau5.fit(X, y)" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 424 - }, - "id": "jSJn1AaSEVfg", - "outputId": "8f3ecb7e-a79f-46a3-d794-103b62742843" - }, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ], - "source": [ - "## plot Huber Regression results\n", - "warnings.filterwarnings(\"ignore\", \"is_categorical_dtype\")\n", - "\n", - "n_sample = 50\n", - "X_sample, y_sample = X[:n_sample], y[:n_sample]\n", - "tau01_sample = pipe_tau01.predict(X_sample)\n", - "tau5_sample = pipe_tau5.predict(X_sample)\n", - "\n", - "df = pd.DataFrame({'x0': X_sample[:,0], 'real_y': y_sample, 'tau0.1': tau01_sample, 'tau5.0': tau5_sample})\n", - "df = df.melt(id_vars='x0')\n", - "\n", - "sns.scatterplot(data=df, x='x0', y='value', hue='variable')\n", - "plt.show()" - ] - } - ], - "metadata": { - "colab": { - "provenance": [] - }, - "kernelspec": { - "display_name": "Python 3", - "name": "python3" - }, - "language_info": { - "name": "python" - } - }, - "nbformat": 4, - "nbformat_minor": 0 -} \ No newline at end of file