diff --git a/2024.3/.buildinfo b/2024.3/.buildinfo
new file mode 100644
index 0000000000..79dbc2b999
--- /dev/null
+++ b/2024.3/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 05538de980fa100591b86cc89801ada2
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/2024.3/.doctrees/404.doctree b/2024.3/.doctrees/404.doctree
new file mode 100644
index 0000000000..e9f6567a29
Binary files /dev/null and b/2024.3/.doctrees/404.doctree differ
diff --git a/2024.3/.doctrees/algorithms.doctree b/2024.3/.doctrees/algorithms.doctree
new file mode 100644
index 0000000000..348131bbae
Binary files /dev/null and b/2024.3/.doctrees/algorithms.doctree differ
diff --git a/2024.3/.doctrees/blogs.doctree b/2024.3/.doctrees/blogs.doctree
new file mode 100644
index 0000000000..9186bb0341
Binary files /dev/null and b/2024.3/.doctrees/blogs.doctree differ
diff --git a/2024.3/.doctrees/contribute.doctree b/2024.3/.doctrees/contribute.doctree
new file mode 100644
index 0000000000..dcf0f8c44f
Binary files /dev/null and b/2024.3/.doctrees/contribute.doctree differ
diff --git a/2024.3/.doctrees/deprecation.doctree b/2024.3/.doctrees/deprecation.doctree
new file mode 100644
index 0000000000..eea5dd6825
Binary files /dev/null and b/2024.3/.doctrees/deprecation.doctree differ
diff --git a/2024.3/.doctrees/distributed-mode.doctree b/2024.3/.doctrees/distributed-mode.doctree
new file mode 100644
index 0000000000..eaba0df49d
Binary files /dev/null and b/2024.3/.doctrees/distributed-mode.doctree differ
diff --git a/2024.3/.doctrees/environment.pickle b/2024.3/.doctrees/environment.pickle
new file mode 100644
index 0000000000..56f6fe6899
Binary files /dev/null and b/2024.3/.doctrees/environment.pickle differ
diff --git a/2024.3/.doctrees/guide/acceleration.doctree b/2024.3/.doctrees/guide/acceleration.doctree
new file mode 100644
index 0000000000..2138c3585f
Binary files /dev/null and b/2024.3/.doctrees/guide/acceleration.doctree differ
diff --git a/2024.3/.doctrees/index.doctree b/2024.3/.doctrees/index.doctree
new file mode 100644
index 0000000000..4eebbaa35e
Binary files /dev/null and b/2024.3/.doctrees/index.doctree differ
diff --git a/2024.3/.doctrees/kaggle.doctree b/2024.3/.doctrees/kaggle.doctree
new file mode 100644
index 0000000000..97a6163cfe
Binary files /dev/null and b/2024.3/.doctrees/kaggle.doctree differ
diff --git a/2024.3/.doctrees/kaggle/automl.doctree b/2024.3/.doctrees/kaggle/automl.doctree
new file mode 100644
index 0000000000..cdc7adb6ae
Binary files /dev/null and b/2024.3/.doctrees/kaggle/automl.doctree differ
diff --git a/2024.3/.doctrees/kaggle/classification.doctree b/2024.3/.doctrees/kaggle/classification.doctree
new file mode 100644
index 0000000000..023f54255a
Binary files /dev/null and b/2024.3/.doctrees/kaggle/classification.doctree differ
diff --git a/2024.3/.doctrees/kaggle/regression.doctree b/2024.3/.doctrees/kaggle/regression.doctree
new file mode 100644
index 0000000000..fcd437cd85
Binary files /dev/null and b/2024.3/.doctrees/kaggle/regression.doctree differ
diff --git a/2024.3/.doctrees/license.doctree b/2024.3/.doctrees/license.doctree
new file mode 100644
index 0000000000..a110db12da
Binary files /dev/null and b/2024.3/.doctrees/license.doctree differ
diff --git a/2024.3/.doctrees/nbsphinx/samples/ElasticNet.ipynb b/2024.3/.doctrees/nbsphinx/samples/ElasticNet.ipynb
new file mode 100644
index 0000000000..29e5dca851
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/ElasticNet.ipynb
@@ -0,0 +1,386 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34e460a7",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "00c2277b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06d309c0",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2ff35bc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38637349",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import StandardScaler\n",
+ "\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.28 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"l1_ratio\": 0.7,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0109113399224974'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class ElasticNet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 3.96 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0109113399545733'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a2edbb65",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0109113399224974 MSE metric of unpatched Scikit-learn: 1.0109113399545733 Metrics ratio: 0.9999999999682703 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 14.2 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb b/2024.3/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb
new file mode 100644
index 0000000000..9336772cb3
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb
@@ -0,0 +1,650 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Utilizing daal4py in Data Science Workflows\n",
+ "\n",
+ "The notebook below has been made to demonstrate daal4py in a data science context. It utilizes a Cycling Dataset for pyworkout-toolkit, and attempts to create a linear regression model from the 5 features collected for telemetry to predict the user's Power output in the absence of a power meter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'3.8.10 (default, May 19 2021, 18:05:58) \\n[GCC 7.3.0]'"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import glob\n",
+ "import sys\n",
+ "\n",
+ "%matplotlib inline\n",
+ "sys.version"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This example will be exploring workout data pulled from Strava, processed into a CSV for Pandas and daal4py usage. Below, we utilize pandas to read in the CSV file, and look at the head of dataframe with .head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " altitude \n",
+ " cadence \n",
+ " distance \n",
+ " hr \n",
+ " latitude \n",
+ " longitude \n",
+ " power \n",
+ " speed \n",
+ " time \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 185.800003 \n",
+ " 51 \n",
+ " 3.46 \n",
+ " 81 \n",
+ " 30.313309 \n",
+ " -97.732711 \n",
+ " 45 \n",
+ " 3.459 \n",
+ " 2016-10-20T22:01:26.000Z \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 185.800003 \n",
+ " 68 \n",
+ " 7.17 \n",
+ " 82 \n",
+ " 30.313277 \n",
+ " -97.732715 \n",
+ " 0 \n",
+ " 3.710 \n",
+ " 2016-10-20T22:01:27.000Z \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 186.399994 \n",
+ " 38 \n",
+ " 11.04 \n",
+ " 82 \n",
+ " 30.313243 \n",
+ " -97.732717 \n",
+ " 42 \n",
+ " 3.874 \n",
+ " 2016-10-20T22:01:28.000Z \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 186.800003 \n",
+ " 38 \n",
+ " 15.18 \n",
+ " 83 \n",
+ " 30.313212 \n",
+ " -97.732720 \n",
+ " 5 \n",
+ " 4.135 \n",
+ " 2016-10-20T22:01:29.000Z \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 186.600006 \n",
+ " 38 \n",
+ " 19.43 \n",
+ " 83 \n",
+ " 30.313172 \n",
+ " -97.732723 \n",
+ " 1 \n",
+ " 4.250 \n",
+ " 2016-10-20T22:01:30.000Z \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " altitude cadence distance hr latitude longitude power speed \\\n",
+ "0 185.800003 51 3.46 81 30.313309 -97.732711 45 3.459 \n",
+ "1 185.800003 68 7.17 82 30.313277 -97.732715 0 3.710 \n",
+ "2 186.399994 38 11.04 82 30.313243 -97.732717 42 3.874 \n",
+ "3 186.800003 38 15.18 83 30.313212 -97.732720 5 4.135 \n",
+ "4 186.600006 38 19.43 83 30.313172 -97.732723 1 4.250 \n",
+ "\n",
+ " time \n",
+ "0 2016-10-20T22:01:26.000Z \n",
+ "1 2016-10-20T22:01:27.000Z \n",
+ "2 2016-10-20T22:01:28.000Z \n",
+ "3 2016-10-20T22:01:29.000Z \n",
+ "4 2016-10-20T22:01:30.000Z "
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "workout_data_dd = pd.read_csv(\"data/cycling_dataset.csv\", index_col=0)\n",
+ "workout_data_dd.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data above has several key features that would be of great use here. \n",
+ "- Altitude can affect performance, so it might be a useful feature. \n",
+ "- Cadence is the revolutions per minute of the crank, and may have possible influence. \n",
+ "- Heart Rate is a measure of the body's workout strain, and would have a high possibly of influence.\n",
+ "- Distance may have a loose correlation as it is highly route dependent, but might be possible.\n",
+ "- Speed has possible correlations as it ties directly into power."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Explore and visualize some of the data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In general, we are trying to predict on the 'power' in Watts to see if we can generate a model that can predict one's power output without the usage of a cycling power meter. Below are some basic scatterplots as we explore the data. Scatterplots are great for looking for patterns and correlation in the data itself. Below, we can see that cadence and speed are positively correlated. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABL/ElEQVR4nO2deZwU5Zn4v29VHzPDcGUw6DCgmPEIEBjNrGhQoqBJRMTNiiTRhOwa9ZddNYcXZrPGa3cT72gwh0d2NWoSxWzAI4lRMQgqZjAzCKg4QYUBQRhhgGHoo+r9/VFdTR9VfQzdMz3yfD8fdLq6qvqpt2fe532fU2mtEQRBEAQAo78FEARBECoHUQqCIAhCElEKgiAIQhJRCoIgCEISUQqCIAhCkkB/C7A/jBgxQh922GH9LYYgCMKAYsWKFdu01gd5vTeglcJhhx1GS0tLf4shCIIwoFBKvef3npiPBEEQhCSiFARBEIQkohQEQRCEJKIUBEEQhCSiFARBEIQkohQEQRBS6NwdoW3DDjp3R/pblH5hQIekCoIglJKFrRuZ9/hKgoZBzLa5+eyJzGoa1d9i9SmyUxAEQcDZIcx7fCV7Yza7InH2xmyuenzlAbdjEKUgCIIAdGzvIWikT4lBw6Bje08/SdQ/iFIQBEEAGoZXE7PttGMx26ZheHU/SdQ/iFIQBEEA6mrD3Hz2RKqCBoPDAaqCBjefPZG62nB/i9aniKNZEAQhwaymUUxpHEHH9h4ahlcfcAoBRCkIgiCkUVcbPiCVgYuYjwRBEIQkohQEQRCEJKIUBEEQhCSiFARBEIQkohQEQRCEJKIUBEEQhCRlVQpKqe8qpVYrpVYppX6tlKpSSo1VSi1XSrUrpX6rlAolzg0nXrcn3j+snLIJgiAI2ZRNKSilRgHfApq11hMAE/gycBNwh9a6EdgOfCNxyTeA7YnjdyTOEwRBEPqQcpuPAkC1UioA1ADvA9OABYn3HwD+MfHzWYnXJN6frpRSZZZPEARBSKFsSkFrvRG4FViPowy6gBXADq11PHFaB+AWKx8FbEhcG0+cX5d5X6XURUqpFqVUy9atW8slviAIwgFJOc1Hw3FW/2OBemAQ8IX9va/W+h6tdbPWuvmggw7a39sJgiAIKZTTfHQq8I7WeqvWOgb8DpgCDEuYkwAagI2JnzcCowES7w8FOssonyAIgpBBOZXCeuB4pVRNwjcwHVgDLAZmJ875OrAw8fOixGsS7z+vtdZllE8QBEHIoJw+heU4DuPXgNcTn3UPMA+4TCnVjuMzuD9xyf1AXeL4ZcDV5ZJNEARB8EYN5MV4c3Ozbmlp6W8xBEEQBhRKqRVa62av9ySjWRAEQUgiSkEQBEFIIkpBEARBSCJKQRAEQUgiSkEQBEFIIkpBEARBSCJKQRAEQUgiSkEQBEFIIkpBEARBSCJKQRAEQUgiSkEQBEFIIkpBEARBSCJKQRAEQUgiSkEQBCFB5+4IbRt20Lk70t+i9BuB/KcIgiB89FnYupF5j68kaBjEbJubz57IrKZR+S/8iCE7BUEQDng6d0eY9/hK9sZsdkXi7I3ZXPX4ygNyxyBKQRCEA56O7T0EjfTpMGgYdGzv6SeJ+g9RCoIgHPA0DK8mZttpx2K2TcPw6n6SqP8QpSAIwgFPXW2Ym8+eSFXQYHA4QFXQ4OazJ1JXG+5v0foccTQLgjAg6dwdoWN7Dw3Dq0syec9qGsWUxhElvedARJSCIAgDjnJFCtXVhg9YZeAi5iNBEAYUEilUXkQpCILQJ5QqMUwihcqLmI8EQSg7+2PuyfQdSKRQeZGdgiAIZWV/zD0LWzcy5abn+ep9y5ly0/Msat0okUJlRnYKgiCUFdfcs5d9q3vX3JNrIk9VJu61Vz2+kimNIyRSqIyIUhAEoaz01tyTT5lIpFB5EPORIAhlxTX3hAMGNSGTcKAwc09/+Q4O9EqpslMQBKHsaPe/WiVf5cNVJldlOKjLuTuQSqmgtC7sC6pEmpubdUtLS3+LIQhCDjp3R5hy0/Psje1b9VcFDZbNm1bQBF/qzOVyyTmQUEqt0Fo3e70n5iNBEMrK/uYV1NWGmTR6WNknZsl/cBClIAhCWRkoeQUDRc5yI0pBEISyMlDyCgaKnOVGfAqCIPQJfeUb2F8Gipz7Qy6fgkQfCYLQJ1RSXkGuib+S5OwPRCkIgnBAUWjYaV/sGCpxVyJKQRCEPqESJkC/0hnjDhlCd9RKytYX+QqVmhNRVqWglBoG3AdMwMlYOR94C/gtcBjwLjBHa71dKaWAO4EZwB7gn7XWr5VTPkEQ+oZKmQC9SmdoWzPjJ0sJm45s15wxjhufWuNZc6lUyixXXaf+3jGUO/roTuCPWuujgUnAG8DVwHNa6yOA5xKvAU4Hjkj8uwj4WZllEwQhD6Uo+VBJTXG8wk4jliYa3yfb9U+sJmCotHNKna+welMXhirvZ/SWsikFpdRQYCpwP4DWOqq13gGcBTyQOO0B4B8TP58FPKgdXgGGKaUOKZd8giDkxqtsdW+opKSwzLDToAkhM0M20yBqpUdlljJfYWHrRi58sIU9Uatsn7E/lHOnMBbYCvyPUupvSqn7lFKDgJFa6/cT52wGRiZ+HgVsSLm+I3EsDaXURUqpFqVUy9atW8soviAcuJRydV+qpLBSFaqb1TSKZfOmceHUw1Eoola6bJbWXHvmOMIBRU3QJBxQJctXcMc1Ek9XOoUWCewLyqkUAsCxwM+01scA3ewzFQGgnSSJohIltNb3aK2btdbNBx10UMmEFQRhH6Vc3ZciKaxUu5ZUfvpCe9aOwJ2ca8MBQIGCxH9Kgte41gRN7p3bXBFOZiivo7kD6NBaL0+8XoCjFLYopQ7RWr+fMA99kHh/IzA65fqGxDFBEPqYUpd82J+mOOVwyno5nGuCJj//2qcZXz+EKTc9TyS+771SOYG9xtVGM75+yH7dt5SUbaegtd4MbFBKHZU4NB1YAywCvp449nVgYeLnRcBc5XA80JViZhIEoQ8pR8mH3ha2K4dPItfkXE4fyEAopVHuPIVLgYeVUiFgHfAvOIroUaXUN4D3gDmJc5/GCUdtxwlJ/ZcyyyYIQg4qpeVlOQrV5evVUM7CeIWOa3/ldUjtI0EQKo7MCXFR68asCbwUNni/ibdcn1co5c7ryFX7SJSCIAgVhd+E2Ncr5/5aqfdFsx8piCcIwoAgn1O53JNzpiLoD5OZlxPc9Wn0hTyiFARBqBj8nLl+E2IpV/OVUoqjv5v9SJMdQRAqhkEhM81sArA3ZjMoZGadW8rchXKU4ig22c49H+jXCCXZKQiCUDF0Ry3CpiKSklQWNhXdGSUhSp27UGqTTbG7Dq/zl82b1i8+DdkpCIJQMTQMr8bKCH6xtM4ynZQ6lyCXyaY3K/5idh1+5wO9yuvYX0QpCIJQUaiM6qGZr6H0dne/pLKl7duKNlEVq7AqqWAgiPlIEIQKomN7D6ahiKWYj0xDZZlx8iWf5cLPOZ2ZVAYkQ0OLMVEVq7D627GciSgFQRD6hEIihYpxNPcm4zrTdn/NGeOYMGpoWgiqe5+2DTt65WcoVmHtj4IrB6IUBEHIy/6GfhbqeC3U0exSTC6Bl3P6+79fRW3YJG7rLJmKWcFnjk+xCqtSSoqAKAVBEPKwv/H7xUQKNQyvRhkKUpSCMlRJTCleEUYAuyOWp0yFruD9xqfY5Lf+SpbLRJSCIAi+lCL0s5hwz3KaUrxW/ql4yZRvBV/JvZZ7iygFQRB8KUX8frGO1HKaUi4+uZH5i98mYBhZJik/mXKt4Du296Dt9BBabes+ycAuF6IUBEHwpZAJPd9E57f6B8eZ63VdIaaUYibYVBMPKL752U/wsdoQNz65Ju+OJNfnDAqZaf4PgIilfTOwK6GMRj5EKQiCkBN3dR0yzazJs9CJLnP178b/92aC7Nwd4eHl67l7cTshM//1Xiaeu19oZ9m8aXxh/MF0bO9hUMikO2rRuTuSNvEvbN3IVQtWYhoKy9bcMjv9c7qjFlVBIyti6g+rNnPpyME5ZahUM5MoBUEQPMlcXV809XDOnTwmOYkVO9G5q//2Lbu48rE2opYueoJ0Jum2ZON7t2XmlQvaGFYTZHz90Kx75DKBTRo9jKXt23xLdV/xWFtazsRlj7amfc6gkIllZ7cfmL+4PW2scsngvl8pJiVRCoIgZOG3uj538pjkOR3be7ImRCuHPR2cSf3KBSuJWrnt8F4mG1cmVyGkEolrvvnQa9i6sNDSSNxiUMjMqdhWb+pKUwgAcRv+369WoIE5zQ082tIBHj1pQma638XPDLdqYxdfuuflijIpSZkLQRCyKKT0QixuZU2aMUsTi3vnFLRv2eUohHh2BFCqHd6v+qmXTKnsiVrJukHtW3Yl6xXV1YaZ09yQdq4GZs5fyiPL1+d4zuzyGgA9MZu9MZsHX17P3phNzCOgKdPv4lVG45ozxnHjU2tKWpm1FMhOQRCELApxML/bucfz2nc799A8ti7t2MLWjUmTkRdVQSNp0/dbuecLKXXRtmbGT5YSTvgbrpk5zlnRpz6LpYlZmvmL3yZz8nefs2F4NQHD2R0USk3ITO5WMndLmX6V/m6m44fsFARByMKvQFzqZNU0epjntZnH3YneTyG4pE6UqaROlKkyhQOKf/3s4YQD6edHLE00vm/1ff0TazA9iuoBhEyTS05p9HzOutowt89pIhxQVAfyT5XhgOLnXz2WZfOm+ZqA6mrDycqnlVbzyCXvTkEpZQI3aa2v6AN5BEGoEPLlCzSOHMzcE8bw4Mvrk8fmnjCGxpSoG/DPJAZnhwAkJ+Lt3VEilv9E6SXTJw8Zkgx3jcQtDEOlRQMFTUXMZ7kfs23OnTyGcyePyVskb9WmrrQQVtenkOoPmHrkxwsZWqDyah65KO3hJMk6SalXtNbH94E8RdHc3KxbWlr6WwxBKCkDIcEplfYtu2jdsIOm0cOyFAJ4N6IPmYpHLphMMGAmn9ONdtK2JmLpNIWRz/nqjtmgkMnM+Uuzmt679vve3DvXs6Z+bnfU6tV31h/ft1Jqhda62fO9ApXCz4BRwGNAt3tca/27UgnZG0QpCB81BkqCU7Esat2YtSJOfa5cimNPzAa0Z7hpIZ91zcxxTKgfSixu8W7nHg6rq0lTRpn4TdJ+381A/M5KoRT+x+Ow1lqfv7/C7Q+iFISPEl4TY1XQYNm8aQNix5CPXCvitg07+Op9y9kViSePhU1FzNa4Ua9BU3HbOZMKmnA7d0dYvWknL/99G79c9g5KOSaloAGGofjBzPFpJbNd/Cb4zt0RPvOj59LCYauCBg+dfxzn3rc8zV+S+Z1V4s4vl1IoKPpIa/0vpRVJEA5sMieKzt0RFr/5AQEj3SFaCdEopSJX6QrPXAKPcNcrFxSW5La0fRtXLViZTG5zglBxwkdtnSyZHbNsLjnliGT+hV/k08PL12flR2hb85X7lmeF5aZ+ZwNxF1GQUlBKHQn8DBiptZ6glJoIzNJa/2dZpROEjyCZE8WcTzfw6IoOTJXdN6ASolH6gkyn695Y3DP+31DZXdgy2ZfkljuW1C2Zfduf1zJ/cTuXnNLoGSK6etNO7l7cnnV9ptJySe3tPFBKW6RSaEjqvcD3gBiA1nol8OVyCSUIH1W8mrQ/+IqTBJWqEAaFTc8w0Eqk2Mb2fsxqGsWyedN46ILJ3HjWBM9zYpZ3F7ZU8iW5eRGJ28xf/DZRj8gn0ITM7Pt5HQMn07muNlxxvZcLpdCRq9Fav5pxLO55piAIvhQyYQ0KmVx/5vic8e6Vgl/2cW9x4/jrh9d4vq+0Zub8pTk/p9Akt0z8chbG1w9lb0aWdsAAn9QHHm3poHN3pGLzEPJRqFLYppT6BAnDnFJqNvB+2aQShI8ohUxYltaccvTHK3aH4O4M2rfsytr1lKpMw/j6IXjli8U0eT/HNUVlJrXlw81ZePKSE7n2zHE8dP5xHFo3iHe27sbO7Jmg4fwphxE0szWDqRSL3/wAIG8CYCVSaPTR4cA9wGeA7cA7wHla6/fKK15uJPpIGIhkhkx6JUFV6g4h1R/ilSg2OBzgoQsmM8kn2zkfqQ74Ze3b+O5vW/Ey3RfyOXc/v5Zbnnm7oM8NBwxumT0RjeNsBkf5mOmdQdOoCZnELQtbK+IZSiO173Ol9F5OpRTRR+uAU5VSgwBDa72rlAIKwoGEV1but6cfWXETRyZejtPMGXN/zCOZDvhrzhhHwDSwPBzGPbF43s85tK62oM8NGHDv3GbG1w/JCgnOVZljT8IHFDA04YBBwNgXKOA6sa9YsJKnLz2x10qyPyhof6WU+rtS6mHga8CYfOcLgpCb1Bo4Xq8rES9/SNhUhAL7bx7xcsBf/8RqTxMSgPIz6KdwwifqfOqcZt4L6odW9cpBDVAdDHDv3GaunzU+y2QVjdvMuOvF/fa19CWFVkkdB0wGTgJuUUodBazUWn+xbJIJglBRePlDtFI88o3jcmYI+5FqKvKrj9Qd9fa/VAXMvKGpdbVh7vxyE1c81oplO6t+hZuxkIpi5vylXHPGuLz+Hif5zUgLd43ZNuPrh1A/tMozDDZqaa54rI1xhwzxLANSaRSqFi2ccFQLsIEPEv8EQThASK1S6tYOUlrz1V++ynud3UUphMyopVUbu7Im5FxVVQs1U81qGsXT35rKTWdP5P65nybg4RiOWdrZmTy5hstOPdLXQR0OKG6b08Qts9MrtV58ciPgtOYMe9zffZYZP8kdNVUpFOpo3gO8DtwOPKu17iy3YIUgjmZB6Hvat+xixl0vZpV2ePKSE3MWhctVtC5kKq743FHc/uxaXyc2kJywM3sl+5HpGNdaeybFpcpx7ZnjWda+ladXbUken3J4HdefNT650vfqE53aNMePcEAl/BeF1XEqF6WofXQWcCJwHBAFXgKWaK2fK6WgxSJKQfgoU4k1c8C/TpFWiqChiFk21545nvOOPzT5ftrkbNkorbMygkMBg2tnjmPCqKGeigOgKmCg0dwye1LeqB6vWlKF4CgenVXWwo1QcmshedWpumbmOG58cl81Vi9SG/H0V5RZKaKPFgILlVJHA6cD3wGuAio7C0MQKoxCJ/pKrpnjX6dIE028/v7vV4GC8yYf6h215EE0bnPjU2tYNm8a27uj/NMxo3j8tY0ETEV3Ippnb8Jmf9mjrZiGkVyle42Pl58iZICPmyKJaSjQCsdanvKMcTtZpsKva9qE+qEsmzeNju09xOIW597/alb7UTdqqVJLXhQaffS4UqoduBMYBMwFhhd4ramU+ptS6snE67FKqeVKqXal1G+VUqHE8XDidXvi/cN69USCUKHky/7ti6SwUlBXG6b50PQ/f6+J5Pon1iSVYCZBU3lGFgUNg//4/SpOvWMJj7y6gUjcZlLD0KzSFnHbmaRzjY9noqBSfGd6IyHToDpoEDQgs1qFZWss7a053DIVubKV3Uiy5rF13JrwP9QEs0tzVGrJi0IdzT8EjtJaf15r/Z9a679orfcWeO23gTdSXt8E3KG1bsRJhPtG4vg3gO2J43ckzhOEjwReIZepE1mqwphx14tZ1/f3BJJa36h9yy6Wtqe7Fb2m0KCpkj6ETBNOzNLcOnsiocxWmnGLP6zanHbspb9/mJUclvVZHuNTVxtmzqcb0uXUmp8vWce1Z47jNxedwCv/fip3zGlKyzq+ZfZEbpk9iXDAwymdMvEXkq3s1nP6+dc+neXArtSSF4WGpLYBFyulpiZe/wX4udY6lusipVQDcAbwX8BlygkungacmzjlAeA6nAqsZyV+BlgAzFdKKV2I00MQKpxcTdohu2RzKZPC9pdMU9bZxzTkvwhnxe2Gm4ZNlWVjv+p3q/jyP6Rnc599TAMPv7o+615nHzuK3/1tI0HDIGpZ2Jq0ktVRy8oan87dER5d0ZF2LG5D3La54cnV3Du3mYbh1b5tR6c0juCR5euZn+JMTp3487UrdamrDTP1yIO4ZXbltd70olCl8DMgCPw08fpriWMX5Lnuxzi+Bzc4tw7YobV2PVQdOB3dSPx/A4DWOq6U6kqcvy31hkqpi4CLAMaMkTw6YWCQy9zgpTBcx23YYzLyoxyOaS9/wGMrsidtgO9Mb+Snf1lH0FRYiRIPAF09UbyyyKJxm0dbOtKilrZ3Rz2VwvlTxnL5545KK4Fx2aOtuOZ6W8Oy9m1pfoVcO6tIXPPNh15Lc/hmjlldbZhLpx+R7N/sttzs3B1JSzosdKwLVSL9TaFK4R+01pNSXj+vlGrLdYFSaibwgdZ6hVLq5F7Kl4XW+h6cOkw0NzfLLkIYEORr0p6pMJSheCpPiGcq5XJMeyqsQIDTPjmCp1LMPHNPGMN3TjuKr51wWHICfXrVZq5c8Dwh08DWeNYRMlBs6trL1CMPApxxOqmxjhdTzFMnNdYlQ0FTV/GmYRBPjFvM0lmO21jcyhl5lM/hm6pk3+3sLsn4FqNE+otClYKllPqE1vrvkCyQZ+W5ZgowSyk1A6gChuA4qocppQKJ3UID4HrbNgKjgQ6lVAAYClREPoQglAK/laKfwig0+7V9yy6uXLCSaLz0zVz8djg3/OMEvnvakWlN7N1ncbqetSVDOt0s34BBImR1n2bYE7O48MEWfpASivrX97anfd5f39uetjoHR1mFzPTM4tSOZw+/8h7XLlpV0DN6dbdLVbKp5qqB1CyntxSqFK4EFiul1iVeHwbkbNGptf4eTmMeEjuFK7TW5ymlHgNmA78Bvg4sTFyyKPH65cT7z4s/Qfio4bdS7K1pYWHrRq58rM0z+7cUbTy9FNY1Z4xLyjm7eXTa+fu6nmXLE7fBVJqAAalRmpG4nWyPGbU0tkepicxnyWWOe/iV95yQWA+CBihlpDXTSfXXOL2du5JKzS+EVtv6I9MmNZNClcIy4BfAdGAH8Cecybs3zAN+o5T6T+BvwP2J4/cDv0qEvn6IdHYTDjD8FIafr8CdgL0Uwt5Y/g5lhZKqsFZt7OLGp9YkV9Buf2NXLr8aRi6Wdibm6qBBT4Zpx60smu9Z3PFwE8VSd1cA1z+5xvM+QVNx2ic/zp9Wb0k75prxFrZu5KoFbYDyVGqpRCxdsvGtNApVCg8CO4EbE6/PBX4FnFPIxVrrF4AXEj+vw8mMzjxnb6H3E4QDhVy+glwTcNjM7ve8P7iT/pxfvEwkxUzl9jd2M30LaSIUMs28/ZNTSX0Wr/LaE0YNTSrMtg07CJmKaEZfSJX4l1q6AsBQjn+ic3eEy5OO6/wGiqqgUdLxrSQKzVOYoLW+QGu9OPHvQmB8OQUThAOdfLkNuSZgZaiSh7A+vHy952TuZvq6dv/U+P2QCQEjPfQobmuKsQy7z+I1Hjc+tSZtB9UwvNozp0HjXWAvZDrVVldv2omXnqoOGIQDyrPDWiXmGJSCQpXCa0qp490XSqnJgBQdEoQykq/xe2rbSbeJfNhUZWn72Lk7wt2L/buYpcrlJmw9dMFkXv7eqdw+Z1JaktclpzRSE8o2UtSETMIBxYxPjSQcUFlJYfnGA9IrudaE8k9v+/wJ3kpq3ulH89LV07ntHCeZrSboyFjs+KYm/1U6hZqPPg28pJRyA4jHAG8ppV4HtNZ6YlmkE4QDmEIav+vEfwOGgdYw+9Oj+Zcph5Wsbr9rv+/qiSXMPnHP8zLlSvWPZDrRAe58bm3a9aaCr59wKL9c9i4vru0EFGdOOoTzp4xNPksh45H6eYvf/IDrnljt66tIndzH1w8laKZHRgVNxZmT6qmrDSfGWSUaMhTSumcflVzHyotCq6Qemuv9/urVLFVShY86mf2cUycUvyqgqdU894f0sEwby7azTCyDwmYyUa3Qz+vcHeH4Hz6XNgEHDDAzmtcAhEy49Zym5L0XtW7kygVtmMrA0ja3zJ7k+7m5xueSUxrTHOT77r0S03CS7/JVRF02b1pBCYW9vbaclKJKar9M+oJwoJMrVNUvYze1mmdvJx6vTOagqQgHHDu8l5O30Izqju09VAVMYta+XUfINL2zni2nIqr7LMWs2DPDab2ipVLx2tG0bdhBV0/Mt0RJvvHNVd6kUsNZCzUfCYLQT/iFqnoVmnPJN/Hkm8C9JrOqgMnd5x3D0OpQ1nXFmEi8zECWtn0n+bgNqzftZHz9kEQOxL5r8ym/YvM/3LH22iWlUmgtqkJNXpVE8V2qBUHoc7wclbnaP+6NZxeIc8lXwhv8J7Px9UOZNHqYZ75EoaW+vSqM3jJ7ErfMnkjI53lAF+Ro9vu8SaOHARTk7M18nkjcRilFyFQJZ3i2I9/PkVxoNdVKQnYKglDh+K3CG4ZXowyPgkLgG/LpZRbyWm3nq9WUSm9MJLOaRlE/tIolb29j6hEjaB5bB8C4Q4bw+TuXkJJwTNBUjK8fCmTXiMpcdfvtgIrZyXg9j+NnsBOe/fSxzXfvgVIIz0WUgiBUMPkm8ZvPnsgVHmUuqoMBz0m5Y3sPcSt9Yo1btue5hU5mvTGR/OD3r/PgK04w413PtzP3hDHccNanaBw5mDvmNGU5fN3PzqWo/CbnQhVh6vPsjadHLLlmupiVXkQPssue+ynZSlcGLqIUBKEfaN+yK6uYnBf5VuGzmkYx7pAhzPjJ0rS2j36TcixuZUUQxW3nuBeFTGbF7CrAeXZXIbg8+PJ65h7vhNK6z+Q1Pn6KKtfE35udTL6ozFSz1UBzJOdDlIIg9DGpq2SAGZ8ayY1nfcp31ZpvFd44cjC3FtjA5d3OPZ4yLXl7G2MPqu31RFbIrsI17fxt/XaPO0Drhh00jhycqEGUHRqai1wTf7E7mY7tPVQHA+yKeOdkZF4/0BzJ+RClIAhFsj/NbLxWyU+/voXn3tjqOfkVugov1NTTlHC4ZnL/0nXc8+K6/UqsyrWryIzm8ZOtc3eEKx5rS8thuOzRVobVBBlfP5Sl7dt8/Su5eiYXs5PxMh+ZhtNTOmAYxCwnHLcQk9ZARJSCIBTB/mantm7Y4Xk8V25BKR2VjSMHM/eEMTz4crpi6o6Wr0+Al2nH3QW4zD1hDI0jB7Nk7QdpCgEc89YFD/wVAI3y7WuQVeJ75ri00hvFjGGm+Uihuey0o7ntz2sJBQxufGoNg6sCzGoaNeAcyfkQpSAIBVKsw9ILv5U65LZF57PtF6OsbjjrUzQMq+GmP71J5qK9HPZwT9OOqVBoTGWgsWk+9GOJd7xDUvcVJE2frDP9K2klvjPKanu13PSTN9N8FA6Y3PbMW0QtnazAmvrdDyRHcj4kT0EQCqS3cfKpuCt1L3priy42T6Bzd4Tbn12bpRD2R4ZceJl29sackhkRyyZqkZR3fP0QAkXMSl41lxqGV3PjU2sKHo+C5I1bWRFexX73AwVRCoJQIKXKTr3hrE/x7Hencu5xowkH8ic15auwmUtZeV3rdT5AyCMpq1hZvMgqpx0wspLuUlf8t89pIpijf03QzK6gmsr+Ku9MecMBw7OIatRK79g2UKqg5kPMR4JQIMU6LHPROHIw//1PE7n8c0fltEUXYhbyU1arNnYx5xcvZ0XxNAyvpjujC40Cnr70xJzhsfka3OQi1bQzKGRy+l0vpr2fmoHthqSefteLWf6FoKn4w7dOojtq+X5uKZR3qrxdPTEufvi1rGikS05pzCqJMRCqoOZDlIIgFEGpnYq5bNH7k318zRnjuO6J1WmT6uWPtTGlcQTbu6Nk9qHJVyvZSxa3r3K8wCqp7rN27o5kOXIzXzeOHMxt50zismQ3NEch3HbOpLxlwQtR3i3vdGZlU/vJ275lF5GMaKRwQHHu5DEl8TNVGqIUBKFIeutULDaUtdCkq87dEQ6tG8STl5yYXEGv3tSVtcqOWZrVm7r4YKe3icPNEyhUFtjXV7mYidDLkZuZge0+0x+/PZVNXXsBzfj6oQWPey7l/dX7XmFpeyfgZFOf1FjHry443vM+bs5EoiwrYVOhjH19GNo27JDkNUEQiqc3JgavePk90ThdPdFk60uv+zrF3/wKyynfCKhckVH5ei8HDYPVm7o8K6gWcq+IZTMo5DgSSmWO8VLeLe90JhWCy4vtnbS805m1Y/DKmbA0/PGSE4tu/DOQEEezIJSZQqKD/ByVVoadx9Jw4YMrmHLT8zz8ynu+9/WK4gkYML5+CKvf35mlMk5qrMtrlrn45EbCASM5eaeyN25x4YMtOSuvus8IJB25VUFHSKU1M+cvzflMXviNm9/xP67e4nkfr+Neu624rdnUld7+c05zQ9o5c5obBuwuAWSnIAhlx8v0YgCL3/yAptHDeHrVZu5e/HayeY27Ml69qSvL9g8k+wlc/8RqgqZ3lM2k0cO4fU5TVpcygKsWrMzyIbz67ofJ3UcmqSt30Hzzs41s2L6HR1s6kudYtiamSbbrzDQnea3+n7zkRGYkHM4RS4Olue6JVYQD6UrHzxzjt6PItdNoPGiQxzfkd9x/t+XSvmUXD2VkqD+8fAPfnn7kgFUMohQEocRk+g68TAx7YjbzHl+ZVvU6c0L1n5QSaE13NN28FLMdM0zbhh1MaRzBS1dPT5OlbcMOvGq9mcp74m3fsosrE1VYXaV253NrUSpdtkzllTqRezljr1iwktvPmUg4YBJN6cAWs0Dr9LGKWjZdPbE0peXn4B13yJCcjt/Txh/Mv/9+VZq8hoLTxh+cNSY1QW9DSv3QKsBRSlc81pb17JatefnvncycVO95faUj5iNBKCFeDWzqasNcc8a4rHM92iAA+ybU8fVD8O05A0Q9TPyzJtUzc/5Svnrfcj7zo+d4ZPn6NBv/oJDpWXsobmc35VnYutGpvupRdiLTrJJJql3dK28gGrf57qOt9MSyi85lmsyicZuLH34tzSzll4vQmnD8pmIqlcxRqKsN8+MvNREyDUKmImQa/PhLTZ67kHPvfzVLtrCp6I5aSaXkNw6tAzhnQZSCIJSIXL6DCaOGUhvOkZGVQmohtzu+1JRTMaRSHTT43d82pnQM09z257V85kf7JlO/bm3nfDo9y9p9lmhmnW0fAgaETEVV0CBoKq6Zua9gnJ+T2tkVZN8r85CGrPH0c/A2jR6Wdbw7arFqU1fy9aymUTz9rRP57y9+iqe/dWKWEzvnsyvo6omyelOXZwKgyyPL3/P1rVQ6ohQEoUTkyqRtGF5N3MtBkEHIVGkx9bOaRvHq90/lujPH4WPNSNITs4l7rFwjcZvLHm1NTqbKyFYKC9s25l2J+8ocMDj3uDFonPIVMUtz7cJVyXu5eQMhj/oVIdNRIsXgmqW82lw2jhzsuSu7ftFq2rfscp61dSMz5y/l+ifWMHP+0qyJu2N7D9rjuzKVYyb75kOvccEDLVmRYansidlFl9eoFEQpCEKJaBhenWWaySzfHM5R2CdoKJTH/FhXG+bExhHEPBau4YDBoAJ2IHEb7ntxXdpkmhpFtDtisTdmc8VjbbRv2ZU3BNXFNOCRbxzHb1s60kwpcRuuXNCWnBBnNY3i6UtPzOrB3BO3sW2dLF2RT/Htje0LXZ3VNIpl86bx0AWTWTZvWnLF77Uri1qaGT8pLLppUMh0HN8exCzNnqhTB8mydd46TQOxPpIoBUEoEUvbt2WZHFLDE2c1jeLeuc3U+BT2idmaSFx7ri43dfUQyog0qgoa3Du3mevPHO8ZJprJ/UvfpXN3JDmZXj9rvO/kuax9W0KJKWqCZtZk7nLDWRMIBkxsDzuQ67x2aRw5mFvPmUQ4kH4vSzvO3rvPO4Y/fHtq3onWSWZzqKsNM2n0sDSfQMPwak9bfzRuc/0TqwkY3nWXXLqjVjJU1iVkqiwfkK1h3heOxmPjlWQg5iyIUhCEEtC5O8JVC9qy7OG//WtH2gQ/vn4IUcvf7ADZk9TC1o1c+GCLp4N4fP0QTjn641h52kcCBAMq7b4fH1LlO3leuWAla97f6dj8E5OemTmZmoovjD+YWNzyvE8kbiUjoVJ3DPfObaYmQ4mFTJOh1SEaRw7m9jlN5NJxO3uiOYvPeSlnF9NQ9GRsuVLrLgGek7if5e+WP60l4KMUTMWAbLgjIamCUAI6tvdgKgPI7tiVGeqpEyUT/EhdXbpOz0g8/fxwRkVTt9aPtjURS2Oq7Ogmy9Y0DK9Oi+O3bBvTIKuMdiRu8/O/rAPwVWJVAZOHl69n/vNve75vaZhx1xLCgUBavsD4+qFZOwtXgYCjOOqHVjH7F6943vfyx1YSMvc10plQP5RBIZPuqHMPL+XskqkQILvu0vbuKGcf08BjKzZgGIq9Mdt3N+DXRQ7g0mmNA7IwnigFQSgBDcOrsXT2BGHZmljcYkHLBppGD2NTV09WyGUqmeWrvRLfaoImP//ap5l65EHJY6nN7ofXBNm+J0bH9j389C/rCJpOldSbz57IO1t3c/ljbcRT8g5CJpimygo9zceeqMXdi9/OeV3UIpmH4NUlzVVihqGYOX9pcpJf/s6HnvdTOArLTeD7/v+tIpSQPWyqvIX9vLDsfc7rzP7ZrmYtdmwAYjkURiUjSkEQSkBdbZgvNY9Om1AU8MmDa9NWvKcefZDH1Q4hU2WVr24YXp0Vyx+JW8kEKnB2Ew8vX8/di98G7WQHuzbxa2fuK29957Nrs/pDA4QDAU46YgRPr9pc1DNbWlNlmETIbQ5zMVCs3rSTqUcelFRiM36yFNDsje2b5MMBlbUzcvE66k7Yfs7hfGjgna272PDhHs/xSaUmaBCzdd48DYCa0P5Pr/vTD7y3iFIQhCLx+kPt3B3h0RUdaedpoLVjZ9qxZ9/cigFkriFDpuLWRFno1PsDiezh9KJsZ/zkRW6ZPQmNU7YikmFDdyfZG59aw7J509jeHfWd8KKWxXNvflDUGLhkfm4u9sQsvvHAX7nuzPGcd/yhbOrqIWAooln37N3k7hI08IzUysVlj63MckB7YWnNBSeN5b4l6/J+xuc9sqSLob/6NIhSEIQi8PtD9Sst7cUXj6nnydffx7adiKOQaSRDUTPvf/HJjVQFTGJW5m5Bc+WCNixbk2tedp3Wbydi9L2Y/smP8+LazqImeJdjxwxjxXvbfbOzM4lZmu//fhVtHTtY2LqxVwrAy1+SSgHpIJ7X5DMRuXkKv3zxnbwKoWn0kLwFBl38FhlepUHqh1YRDJhl3TmIUhCEAsnVUKXQuH6AJ1a+z7+e/Al++sLfgX3Oyssfa8NQikh83/3nL27HzymdTyE497bo6okyvCboe85zb3yAX52lmpBJJG559nMG+KdjRvHFY0bxvf9blVuQDFKL6RXLNz97OHe/sM73/XwKaszwKtZv35v7JA8Mlb+8h8voYTUFnVfMIiMat5n9i1fSejqUY+cgIamCUCC5MpbTksLyJJNFLc2dz7V7NsHJXK2HTINLTjnCM+ktl0KoChoEDGdle+EDLXzjwRW+5fVCpsklpzRm5Q84MtmYXhl1Cf6+tZtrfl+cQvDD/fh8Vpxjxwzfr4mrNwrBVBA0CytTAvDE65uTGdR+5CqLkmuREbF0WbOlRSkIQoF4OX17YvG03sLL5k3jZ+cdy79+9nDCAacEQ8CgIHu1FzHb5oTDP8b3Tj+aqUd4t43M5IdfnMA9X2vGNAxH0SSUj98aN2bbnDt5DC9dPZ3LTzsyKbdpKGKWzmlWuXfpO+ynCyCJe5985p9vPrSCYL4MtxJjaYgXuBN0mfGT7BIaqRSyyPAqDZJ5j1JTtpFVSo1WSi1WSq1RSq1WSn07cfxjSqk/K6XeTvx/eOK4UkrdpZRqV0qtVEodWy7ZBKG3ZJaMzny9tH0bF/1qRaLGvuaiqYfzx29PJVBkfZ+akEk4YHD0SCd66bon1rDk7c681yngc+MPZmh1MGdNoaBBWs0gt0vZpdOP4KWrp/HDf/pUztDZ/eXTY4b2+tqYXZyDu1RYtsYsYsaMxnOv5vN1bfMrDeKSWvKjlJRT3caBy7XW44DjgYuVUuOAq4HntNZHAM8lXgOcDhyR+HcR8LMyyiYIRdOxvYeqjAYwAcPggZfepX3LrixzQCSuufuFdoYPCiVNSzWhwv7kPvOJOrTWWdFL+XCVz6qNXcn+yV5o4KKph6fVDHKpqw2zbXfxJpZiaN3Qlf+kCsPSjhnJb5L2Ilfto8yifuGA4uKTG9POcUuDeO0Y3DLepaZsSkFr/b7W+rXEz7uAN4BRwFnAA4nTHgD+MfHzWcCD2uEVYJhS6pByyScIxeK1suuJWdz1fDun3rGEaxa+7msOmNU0imvOGEfczjYlHT92eNZnPfvGB71KmDINxct/38aNT63JeV7chh8/u5bt3ZkBofDwK+9xwxNvFP3ZxeD1aGHTIGjm9yn0J+FAgEunHZGv/VGSzBIambgmxwunHg4o7lmyLqvktt+OQRmqLHWV+sQwp5Q6DDgGWA6M1Fq/n3hrMzAy8fMoYEPKZR2JY5n3ukgp1aKUatm6dWv5hBaEDOpqw1wzM7sss8vTr2/xrJI6KGSyZO1WbnhyDdG4nVVC+6/v7SiZjHtjNpc9utKz9HMmloYv3LkkbQJ6+JX3+P7vVxUQWFt6DAO03buQ0r4iYtmcPuFgPnvkiILOzyyh4ZLZQ/qnL7QTiftXbh0+KMSl05yAA9e0WK66SmUPSVVK1QKPA9/RWu9MtcFqrbVSqqhfAa31PcA9AM3NzRX86yN8FEmts+PFzIkH89Trm5MhhnM+3cDM+UsxUL528N7Y7v9jxtH88A9veq64c9XjySRuO6GwTvtPuG5RaSKJeoNXXaJKQ9uaz/94ScF5GVrvcwa7uQhL27dl5aJk9/Del/3thq26JUFCpneJ9VJRVqWglAriKISHtda/SxzeopQ6RGv9fsI85KZSbgRGp1zekDgmCBWDU+PIf0ZY1LqJK79wNB+rCXFYXQ1f/eWryeziUmEAJx/1cf77D2+W5H4xS7N6UxdDq0NOxFKRUTYHErEiFbil4fk3tvCLF9cRNAyilo1l28RtUnJR3iYzT2RPzOLCB1v4wZnjuPHJNWm/Q65Z8YrH2hh3SOFJcoVSzugjBdwPvKG1vj3lrUXA1xM/fx1YmHJ8biIK6XigK8XMJAgVQb5QwZgN//30m1y7aDXn3rc87/16Yz+/8R8nsKlrb0nNLDt7nNBa3auSckIu7n6hPSX4wM7KL/HLE4nEba5/Yo1vnojb+6LULT/L6VOYAnwNmKaUak38mwH8CDhNKfU2cGriNcDTwDqgHbgX+LcyyiYIecm0+7pMaRzB7edMytklrDvRnSvfLuFLzQ1FyXRW0yGcd/yh7OyJFXVdPv64ahPbu6OcP2VsSe8rOBFquYjELU6fcDD3zm3OaqSkyF1tNV/Ya28om/lIa70Uv9x5mO5xvgYuLpc8glAMqeUHopbNJac0cu7kMWn2YJTCVDqnfdmr+F0qExuG8eu/Fl7yYWHr++ze+1defLu0QRZPvr6FJ1/fQpHpFEIBWBnmuKCpnB2i3lfZ9YyfvMjlpx2V5Q+KxG3+/fSjuf3ZtUmfQiapCW+lQGofCUIGXjWObvvzWn7y/Fo0TpavezwccDrU+CmGfNb5wVVBAkbukhWZ9LaiaSH0svq0kANLQ8CA6uC+ZkP1Q6uYkyip7voIbvrjm4QMiKb8LoRNxeTD61g2bxod23uIxS3Ovf/VtM5ypW75KWUuBCEDr/ID4DSMyaxXZCh6HQkSMBRDqoMU0ElTqEBMKGhnZWswDYO7zzuWZfOmoYFz73s1a8FgaY9SJErRlTAVTho9jOaxddw6e1/CW2pGeqmQnYIgZFBMxdP9CaOMJ7qylSMuP3fDT6EUWFDwIIdMg6HVTqXaeY+v9A0bPvLgwazetK+QXiRuc/HDryV3GFMaR3Bo3SCevOREuqNWWUpoi1IQhAzcCKMrPZrXBAxn1RcwSlNi4MJfrSjL5C0KobKIWjZdPTG6emK+fTcChkpTCC67Ik4RxssebcNQEA6YSSUxafSwksuq/DLuBgLNzc26paWlv8UQPqJ07o7wyPL1zF/8NiHTTFutLX7zA657YnXO+kKCAI6JSSnHp5Cap5BKyFTM/nQDj7y6wfsmHlQFDZbNm9arnYJSaoXWutnrPdkpCIIPbtXQcyePoWN7T1om8ylHf5z/WNh/2b/CwEHhBBK4K/6gqQgHnPyE1Mi2d7buLkoplDrqyEWUgiDkoa42nFWa4OazJ3Lz2RO5Kq38gIFl65wZz8JHi4DhROtEc7iWMvtNVAVM7j7vGIZWh9J8Ah3be4ryBaX28iglEn0kCHnw6pB15YI2htUEeej849CJ8KOoZYtCOAAYFDYJmYrzjhvDby483j8by4eYbVM/1JnMt3dHWbJ2K0vWfsA7W3cV5QvK7OVRKmSnIAh5WL2pC0NlliDQfPOh14hbNkYl13rGsWkfM3oYLet39LcoHwlOPvIgnn3jAxa1bWLBax2MqA2zqauwjOKAAXOanSKJwH7VxaoKmGI+EoS+ZmHrRq5a0EbEo+fkHjf6qMIzviyNKIQS8tTrm4F93d8KVQgAhjL49fL1lKJGYqmT1lzEfCQIPrhmIy+FIAi9IWrZvVIIQVMl+n6rsiWtuchOQRB8cDObvWLKBaEvue2cScxqGsUFJx2e7MtQDoUAohQEwZdiMpsFoVz8eM7EZB/tutpw2ZSBi5iPBMEHN7M5s849OM7bYEbhG6kw+tGilPEDIVMRNHt37bpte2jfkp3pXC5EKQhCDmY1jeLeuc3UhNL/omtCAb417Yi0wmRnH5vVUrwiEd2Vn6ABl57SSCBD02cuBAolamn+7bONTlXdIrnr+XZOvWMJP1j4eq8+u1hEKQhCHsbXD8XOyD+I2TbnTh7DsnnTeOiCyTx5yYksbNvUTxIWh7jN8xOz4c7n25Ndz8KmoipocN2Z4z12iIpQAcri7sXt/GDmOGZMGNkrmR58eX2f7BhEKQhCHlwzkle54rraMJNGD6M7amGqgfvndOonD8rZSe5AxQ07tYGHzj+OCaOGUhVI3zWGg0be7mrgZDbf8OQanlmzpdfytG7Y0etrC0UczYJQALOaRjGlcYRv5EfD8GosPXCd0ic2HsTVX/gkP/zDGzz3Zmm7upUSk0TJaq/3DIVVjjrkOH00vnLfci44cSx741bGe3ZWn41cFNNQKZOmMlRFzUSqpApCCp27I70O+VvUupHLHm3drz/6/qI2bBKzNNG4nWVe+uQhg3nz/eJKMPQlg8ImcUt7Vh/tC0zVN/mLc08Yww1nfaok95IqqYJQAKl9md2id24oYCG4u4kn2jZx0x/f3K8GPIVQHTTpiRVXujtogKEUEUuntQHNVQL8jfdLY8euCZp8/TOH8j8vvZsc4+ZDh7O0vbPgewQNp+aP21PgmjPGMWHUULp6Ylz88GvJSqTFYCjHjh4KmMQsiznNYzh0RA23PrM2re1lX/MfM47m5KM+TuuGHTSNHkbjyMF98rmiFAQB777MVz2+kimNI4raMdTVhjlzUj0/+uOb5RI1SabzOx8G8OsLjycYMHllXSe3/Kn8MqZiac0JnxjB2cc20B21GBQykzWACsUwFE9delJW17HO3ZFe55TYGkxTcfJRB/Hcm05No5ht82+fPZwfP9dewHPl/4zedMI7eGg1jSMH95kycBHXkiDg3ZfZrVdfLK5julyO25qQSTigOPnIEUVdFwwovvrLV1m1qYtbn3mr7KYWBYQDjnM+aCos22ktOXP+Ut7r7KY7aqGL8AGYCm6ZPYnGkYOZNHpYmrJ2x7yQKCAvYpbm6VWbicT3VcL96QvrenUvL8xeJT30j8FOlIIg4J29vD8Fx1re/TCtxk0pE6EOr6sBFIvfKs4hHIlr9sZsrl24ytMxGjIVc08YQzhgUF0CjVYbDnDv3GbuPu8YDLWv0czemM1Vj68kFreIFGiMDwcUATNbps7dEdo27KBzd4RZTaN4+lsnZeUW9BaPj/PlXz97OLlSEMJBwzM/JGDk+t3on4wSUQqCQO6w09SJpxDat+ziwVfWpx3zWhCbqnd/gKve30UkbhPtpXfTb4dw+5wmbjjrU7x09TR+8bXmghK1cskfs23G1w9haHWIkJkexhk0DFZt2lmwzJG4JhK3uWLBymSs/sLWjXzmR8/xlXte4TM/eo5FrRtpHDmY688cX/B9c2FrsiZ601BZmesBAy446XD++O2pBHxm+JilPRIgTX75z//AXV9u8rxmSHX/WPfFpyAICbzCTnvjfF7avq3gzzQNhV2mMMpiMBWc8Im65OsPdu4lHDCIWbkd2Z8bN5Ln3tziWfnzmpnjkiYer13YiNpQ0XJG4zYz7nqRa2eN59qFqxIKzpHxu79tZdwhQzjv+ENBwfVPrCFoKmJFKNBwwCBk7vuuAa5csDIZ7nrLbPdYG6YysLTNLbMnJZ/TKyQ2HDD4wZnjuPHJNWnHba0ZXz8UcDKlU3dvQVMl3+trRCkIQgqpBcd643xe2LqRH/6hQAeuglgZFUIwsYIFuG/pOzlj6b9z6pFpStBUKtmPOhcvtm+FREZv1Eqf+D/cHQX27cKuylCuJ3xiRK/COaOW5vpFa7J2PJaGGXct5dZzJnLe5EP5wviD6djew4YP93DJr/+WdR+vvAatbS6a6vRMdr/jcYcMyYoA8jq2etNOTy/AbedMYuaket56f2faDnJOc0PyM247Z1KW8il34Ts/RCkIgg9epbNzNUvv3B3hqgUrk1mwqRgq3YTkFEgzCpp4Mzl+7HBe29CVM1zSNOCKzx/NHc+uJWgY5MpHMhWcO3lMmhIslO5kc+Ls+89f3J6cXFN3YYNCZvK57/hSE9/9bWsv4vy9L4hadprirqsN0zC8Oi38Fpxnrg4aWaG4UQvufsGRG7LDlK+ZOY7O3VHuXtyetqNwdo/eMg2pDtC5O8KjKzrSjj/a0sG3px+ZNT7lLItdCOJTEAQfvJzPPXGLbbv2evoYHl6+PkshhAMGP/riBL6QUe/m9AkHs7fIHANTwb+ffjS/+X+f4ZFvHOfroAyZihtmTeCOZ9cm+0rnijQyDMXqTTtZvakrKwIrEwVMqB9Mprnbyy8dMtOjt+pqw7zb2c3M+Uv56n3L+cyPnue9zj386TtTufJzR+T83ExymYOChsHqTTuT31FdbZjb5zQRDihqgk7k1g1nTSDus0vTGha/+QHtW3Zl9eb+/v+t4vY/r02LUrrq8ZV07o5QP7Q6yzntmoEKiW5zS6b0p0IAyWgWhJwsat3IVY+vJG6lZ8sGDAiYRnKV2L5lF6ffuSTLth40FYrck1ihBE3FdWeOp7YqwLzHVwLZPX6bGoZy6zmTaN2wg2sXrU7biYRMg7htezq9a4ImlnbKNfTGopW5E3LlfeV709PMcVNuej5L5nBA8YOZ47nuidUFlYvIZ3IKGGAaRtZKPjNbfVHrRq702dnVBA3iGpTWeSOkBocDXDj1cH76gpPTsDdmYyrHPHVrojmO17NXBQ2WzZvWL0pAMpoFoZfMahpF/dAqZv/ilbTjcRvitrNK3LU3zvVPrvF0tsYtXbJo85il+f7vV+WcFFdt6uKMnyzFUCor2zlq2QQU4DGB7yly1+ISNJyKol6KJNOB7tfJLhLXXPfEKs6bPIZfv9qB1vtk9eqEOveEQ/mfl97LOh42FRqNpZ1Cdu5k75qTMpnVNIphNSG+8b+vZn13e4owoUUti7sXt6cpF0s7dZpc/Pwq/b0r8EKUgiDkIVfopKkU1z+5xtO+35ssVhevlbdLroWrq6x83y+xYUDneEozw/+Sq5NdzIL/fWk9BpCoVu0pa8CAI30yfL9y3BgeeXV9lvM4aBg8vHw9P32hnaBhELVsZk48mFOOGsnRBw/GTOwovMj0RWQSDhhcckoj9yxZl7XjiFo6zb9RSX6DXIhPQRDykCt0MmbZvlm0+zP/BovJnMpDOVOgcjWNiVo2g1Ji8/d1svO/xia/0rt20aqsZzp+7HB+07LB00znruRd30AkbvP4a5u45Nd/47Q7ljCnuYGqoMGgcHZrtFwKYcanRvLS1dM4d/KYrMgrl0r1G+RClIIg5OGET4zwdOqGA4przxzv67AslDEfq8o65q46i/kD9cs1K5fXcE7zKKwcPsmwmR3WOqtpFC9dPY3LTzuy1+0po1b2M722fodn4ljIVJw/ZaxvmQkN/ObV9Tx0/nFc+bmjfJPPvPjzmg8AJy/F8tsB7UdWfH8hSkEQ8lBXG+bHX2oiZKpEcpPi8tOO5KWrp3Pe8YfmXf3mY/2He33fqwqZ/PNnxhRU08dQvesTHTJVUWUtgqZi/leO4ebZTcks8EGh7BleGcpzQqyrDXPp9CP4w7emEirRjihoGlm7hFDA4IrPHcUvl73Dnhyhv5YN597/Kjf/8a2iFHzM0jyzejNXPtaWtaMIB4y0rPiBhPgUBKEA/OLswV216qTTNRxQREpkvN8TtXhk+QZmTjyEp1/fzN4c9oyYDWdMOJg/rdlccLG7kGlwxeeO5PZn1xYsU8zSHH2wY9dPHZfl6zq55Zm3MBJOgXwTYuPIwdx6zkQuf6wtGXVkKggYKivipyZkYtn+PRMsrbk2kTWcmlNw45Nr8n4XlgYrbhP1eC9oKgzllOv2yt+4ZuFqT0Vi2TZ//PbUPq9wWgoOSKWwP41UhAOP1N+Xdzu7uSol8/QHM8dx41PpE49t65I2Xolamt/9rbD+z8+8sSWvD8E0SNpfgqbi9mfXMuZj1azd0l2wTG9u3pWc8Opqwyxt38ZNf3or4eR1bt7y3oeeJUHc8RwUMjm0bhB/+NZJbOrqART1Q6ucctopgxcOKH7+1WOpH1rNH1ZtZv7it7E1aeGrc5ob0rKYG4ZX+0Y7ZRIOGJ5hqQDHj/0YP/7yMTzRtonrnliT9b7fziIcMHuVmFgJHHBKYX8bqQgHFqm/L1HLJmalx/n/YNEqqjOM47bt3zKylHjF/fjF+ZsKvvwPY5h29EFs2L6H/3zyDeKa5MRVjEIAuOTXf+Px1zbwP/8ymd+/toHLHl2ZNfU++PJ6PnvEQYwYXEUsbvFu5x4+7I5y6zNvYWtnQg2bCltrph89kgtOGsvwQSEuPrmRnzz/NgHTSCre1g1dXPBACwHTcK7NeM7fvLqeUz85kvH1Q5mU0rIyV48FBXxreiO/WOJfIvvF9k62d0c5c1I9//lUdmkNPyytGRQyaduwY8AtPisqeU0p9QXgTpwQ3/u01j/KdX6xyWuVlkAiVC4t73Qy//l2/tK+jQr6ExEK4FP1Qzhq5CDaOnayacceumO5v8CgglynfGJENdt2R9m518rrtDdwdmKnjTuY597cQshM7xCXqSD6y2oxIJLXlFImcDdwGtAB/FUptUhrnb1n6yUd23uy7IJ7Y7ZvLRvhwOSr971SVItIobJ4fdNOXi+iLHcencHftxXeaMnG2Sk+vWozAJG40x70+79fRW3YJG7rpHWiUq0WlRR9dBzQrrVep7WOAr8BzirlB7yz1bvXrN9x4cCj5Z1OUQhCWdgdsZK1krzqKrk1lPqbSlIKo4ANKa87EsfSUEpdpJRqUUq1bN1aXOepl9d9WNRx4cBjyduF90IQhN4QNAxaN+woWfvXUlNJSqEgtNb3aK2btdbNBx10UFHXfm7cyKKOCwceU48oru+xIBRLzLZpGj2spO1fS0klKYWNwOiU1w2JYyVj+riDOWrkoLRjR40cxPRxB5fyY4QBTPPYOk5qrMt/oiDkQOGEul5+2pH81xcnZLV5bRw52Lf9a39TMdFHSqkAsBaYjqMM/gqcq7Ve7XdNb0tnP7dmM8+s2cLnxo0UhSB40vJOJ/csWceH3RFqQyZvbe3G0Jqt3VFqgoode52/m2oTIpYTwRLVEATPJKi+IAjEEv9XJmDtk6UmAB8fWsOHu/ewM4fZWgGDQtAd3c/aTYAZUBwyJIxWBlUmvPnBnrRzagJQHQ6yZ2+MnkQM78cHBdjWHacmBHFbETJ1Ut6Da4NUhYMElOb9nRGChk5+DyNqTHZGLA6vq6GhrpZhVSZtHTsZXBXg8BE1rN68m+FVJpt2RtkbibF5dwyAxhHVdMdsItEY23tsRg8LM6gqQOeuGJPHDqOmKsSGzt2sfn8XH6sJ8kF3lGFVAU456uNs3hXl4MEhNu+KMv7gWjZ27QUUp084mBGDq9IiivyijCox+qhilAKAUmoG8GOckNRfaq3/K9f50k9BEASheAZESCqA1vpp4On+lkMQBOFApZJ8CoIgCEI/I0pBEARBSCJKQRAEQUgiSkEQBEFIUlHRR8WilNoKZHfwLowRwEBKXxV5y8dAkhVE3nIzkOTtrayHaq09s38HtFLYH5RSLX4hWZWIyFs+BpKsIPKWm4EkbzlkFfORIAiCkESUgiAIgpDkQFYK9/S3AEUi8paPgSQriLzlZiDJW3JZD1ifgiAIgpDNgbxTEARBEDIQpSAIgiAkOSCVglLqC0qpt5RS7Uqpq/tbnlSUUqOVUouVUmuUUquVUt9OHL9OKbVRKdWa+Dejv2V1UUq9q5R6PSFXS+LYx5RSf1ZKvZ34//D+lhNAKXVUyhi2KqV2KqW+U0njq5T6pVLqA6XUqpRjnuOpHO5K/C6vVEodWyHy3qKUejMh0/8ppYYljh+mlOpJGeefV4Csvt+9Uup7ibF9Syn1+b6UNYe8v02R9V2lVGvieGnGVmt9QP3DKcv9d+BwIAS0AeP6W64U+Q4Bjk38PBinx8Q44Drgiv6Wz0fmd4ERGcduBq5O/Hw1cFN/y+nzu7AZOLSSxheYChwLrMo3nsAM4A84rRCOB5ZXiLyfAwKJn29Kkfew1PMqRFbP7z7xd9cGhIGxiXnD7G95M96/DfhBKcf2QNwpHAe0a63Xaa2jwG+As/pZpiRa6/e11q8lft4FvIFHr+oBwFnAA4mfHwD+sf9E8WU68HetdW+z4suC1noJkNk43G88zwIe1A6vAMOUUof0iaAJvOTVWj+jtY4nXr6C00mx3/EZWz/OAn6jtY5ord8B2nHmjz4jl7xKKQXMAX5dys88EJXCKGBDyusOKnTSVUodBhwDLE8cuiSxHf9lpZhjEmjgGaXUCqXURYljI7XW7yd+3gxUYiPsL5P+B1Wp4wv+4zkQfp/Px9nNuIxVSv1NKfUXpdRJ/SVUBl7ffaWP7UnAFq312ynH9ntsD0SlMCBQStUCjwPf0VrvBH4GfAJoAt7H2TZWCidqrY8FTgcuVkpNTX1TO3vbiop9VkqFgFnAY4lDlTy+aVTiePqhlPo+EAceThx6HxijtT4GuAx4RCk1pL/kSzBgvvsMvkL6oqYkY3sgKoWNwOiU1w2JYxWDUiqIoxAe1lr/DkBrvUVrbWmtbeBe+ngbmwut9cbE/z8A/g9Hti2uGSPx/w/6T0JPTgde01pvgcoe3wR+41mxv89KqX8GZgLnJRQZCVNMZ+LnFTh2+iP7TUhyfveVPLYB4J+A37rHSjW2B6JS+CtwhFJqbGK1+GVgUT/LlCRhJ7wfeENrfXvK8VQ78ReBVZnX9gdKqUFKqcHuzzgOxlU4Y/r1xGlfBxb2j4S+pK2yKnV8U/Abz0XA3EQU0vFAV4qZqd9QSn0BuAqYpbXek3L8IKWUmfj5cOAIYF3/SJmUye+7XwR8WSkVVkqNxZH11b6Wz4dTgTe11h3ugZKNbV960ivlH07ExlocTfr9/pYnQ7YTcUwDK4HWxL8ZwK+A1xPHFwGH9LesCXkPx4nQaANWu+MJ1AHPAW8DzwIf629ZU2QeBHQCQ1OOVcz44iir94EYjh37G37jiRN1dHfid/l1oLlC5G3Hsce7v8M/T5x7duL3pBV4DTizAmT1/e6B7yfG9i3g9EoY28Tx/wW+mXFuScZWylwIgiAISQ5E85EgCILggygFQRAEIYkoBUEQBCGJKAVBEAQhiSgFQRAEIYkoBUEoAYkKlZWW2yAIRSNKQRD6iEQWqiBUNKIUBKF0mEqpe5XTB+MZpVS1UuoFpdSPldNn4tv9LaAg5ENWLoJQOo4AvqK1vlAp9ShOhilASGvd3I9yCULByE5BEErHO1rr1sTPK3CankBK0TJBqHREKQhC6Yik/Gyxbyfe3Q+yCEKvEKUgCIIgJBGlIAiCICSRKqmCIAhCEtkpCIIgCElEKQiCIAhJRCkIgiAISUQpCIIgCElEKQiCIAhJRCkIgiAISUQpCIIgCEn+P4r1D+GRShPWAAAAAElFTkSuQmCC",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "workout_data_dd.plot.scatter(\"cadence\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"hr\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"cadence\", \"speed\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"speed\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"altitude\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"distance\", \"power\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using daal4py for Machine Learning tasks\n",
+ "\n",
+ "In the sections below, we will be using daal4py directly. After importing the model, we will arrange it in a separate independent and dependent dataframes, then use the daal4py's training and prediction classes to generate a workable model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import daal4py as d4p"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It is now the time to split the dataset into train and test sets. This is demonstrated below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3902, 9)\n",
+ "(3000, 9) (902, 9)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(workout_data_dd.shape)\n",
+ "train_set = workout_data_dd[0:3000]\n",
+ "test_set = workout_data_dd[3000:]\n",
+ "print(train_set.shape, test_set.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Reduce the dataset, create X. We drop the target, and other non-essential features.\n",
+ "reduced_dataset = train_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)\n",
+ "# Get the target, create Y\n",
+ "target = train_set.power.values.reshape((-1, 1))\n",
+ "# This is essentially doing np.array(dataset.power.values, ndmin=2).T\n",
+ "# as it needs to force a 2 dimensional array as we only have 1 target"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "X is 5 features by 3k rows, Y is 3k rows by 1 column"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3000, 5) (3000, 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(reduced_dataset.values.shape, target.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training the model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the Linear Regression Model, and train the model with the data. We utilize daal4py's linear_regression_training class to create the model, then call .compute() with the independent and dependent data as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d4p_lm = d4p.linear_regression_training(interceptFlag=True)\n",
+ "lm_trained = d4p_lm.compute(reduced_dataset.values, target)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model has this number of features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Model has this number of features: \", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prediction (inference) with the trained model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that the model is trained, we can test it with the test part of the dataset. We drop the same features to match that of the trained model, and put it into daal4py's linear_regression_prediction class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "subset = test_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can create the Prediction object and use the reduced dataset for prediction. The class's arguments use the independent data and the trained model from above as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lm_predictor_component = d4p.linear_regression_prediction()\n",
+ "result = lm_predictor_component.compute(subset.values, lm_trained.model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(result.prediction[0:300])\n",
+ "plt.plot(test_set.power.values[0:300])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The graph above shows the Orange (predicted) result over the Blue (original data). This data is notoriously sparse in features leading to a difficult to predict target!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Model properties\n",
+ "Another aspect of the model is the trained model's properties, which are explored below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Betas: [[ 1.51003501e+01 -1.25075548e-01 1.32249115e+00 1.64363922e-03\n",
+ " 8.53155955e-01 -1.09595022e+01]]\n",
+ "Number of betas: 6\n",
+ "Number of Features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Betas:\", lm_trained.model.Beta)\n",
+ "print(\"Number of betas:\", lm_trained.model.NumberOfBetas)\n",
+ "print(\"Number of Features:\", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Additional metrics\n",
+ "We can generate metrics on the independent data with daal4py's low_order_moments() class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1.90063975e+01, 3.75882355e+01, 4.98258371e+03, 2.41394741e+01,\n",
+ " 1.81623064e+00]])"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "metrics_processor = d4p.low_order_moments()\n",
+ "data = metrics_processor.compute(reduced_dataset.values)\n",
+ "data.standardDeviation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Migrating the trained model for inference on external systems\n",
+ "\n",
+ "Occasionally one may need to migrate the trained model to another system for inference only--this use case allows the training on a much more powerful machine with a larger dataset, and placing the trained model for inference-only on a smaller machine."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pickle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"wb\") as model_pi:\n",
+ " pickle.dump(lm_trained.model, model_pi)\n",
+ " model_pi.close"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The trained model file above can be moved to an inference-only or embedded system. This is useful if the training is extreamly heavy or computed-limited. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"rb\") as model_import:\n",
+ " lm_import = pickle.load(model_import)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The imported model from file is now usable again. We can check the betas from the model to ensure that the trained model is present."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1.51003501e+01, -1.25075548e-01, 1.32249115e+00,\n",
+ " 1.64363922e-03, 8.53155955e-01, -1.09595022e+01]])"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lm_import.Beta"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9 (tags/v3.10.9:1dd9be6, Dec 6 2022, 20:01:21) [MSC v.1934 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "8837a6bc722950b4562ef1f8ddb3cf1e2be71cad9580dda11136095ace1c488e"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/dbscan.ipynb b/2024.3/.doctrees/nbsphinx/samples/dbscan.ipynb
new file mode 100644
index 0000000000..d6e5c92653
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/dbscan.ipynb
@@ -0,0 +1,344 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.metrics import davies_bouldin_score\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6fd95eeb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "33da61da",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 6.37 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "params = {\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at Davies-Bouldin score of the DBSCAN algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class DBSCAN"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 469.21 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look Davies-Bouldin score of the DBSCAN algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Original Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Davies-Bouldin score of patched Scikit-learn and original Davies-Bouldin score of patched Scikit-learn: 0.8542652084275848 Davies-Bouldin score of unpatched Scikit-learn: 0.8542652084275848 Metrics ratio: 1.0 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 73.6 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Davies-Bouldin score of patched Scikit-learn and original \"\n",
+ " f\"Davies-Bouldin score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"Davies-Bouldin score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/kmeans.ipynb b/2024.3/.doctrees/nbsphinx/samples/kmeans.ipynb
new file mode 100644
index 0000000000..df09f8ded5
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/kmeans.ipynb
@@ -0,0 +1,362 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cdcb77d",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((236930, 14), (26326, 14), (236930,), (26326,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=123)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 7.36 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "params = {\n",
+ " \"n_clusters\": 128,\n",
+ " \"random_state\": 123,\n",
+ " \"copy_x\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn inertia: 13346.641333761074\n",
+ "Intel® extension for Scikit-learn number of iterations: 274\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_opt = model.inertia_\n",
+ "n_iter_opt = model.n_iter_\n",
+ "print(f\"Intel® extension for Scikit-learn inertia: {inertia_opt}\")\n",
+ "print(f\"Intel® extension for Scikit-learn number of iterations: {n_iter_opt}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KMeans"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 192.14 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn inertia: 13352.813785961785\n",
+ "Original Scikit-learn number of iterations: 212\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_original = model.inertia_\n",
+ "n_iter_original = model.n_iter_\n",
+ "print(f\"Original Scikit-learn inertia: {inertia_original}\")\n",
+ "print(f\"Original Scikit-learn number of iterations: {n_iter_original}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare inertia and number of iterations of patched Scikit-learn and original Inertia: Patched Scikit-learn: 13346.641333761074 Unpatched Scikit-learn: 13352.813785961785 Ratio: 0.9995377414603653 Number of iterations: Patched Scikit-learn: 274 Unpatched Scikit-learn: 212 Ratio: 1.29 Number of iterations is bigger but algorithm is much faster and inertia is lowerWith Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get speedup in 26.1 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare inertia and number of iterations of patched Scikit-learn and original \"\n",
+ " f\"Inertia: \"\n",
+ " f\"Patched Scikit-learn: {inertia_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {inertia_original} \"\n",
+ " f\"Ratio: {inertia_opt/inertia_original} \"\n",
+ " f\"Number of iterations: \"\n",
+ " f\"Patched Scikit-learn: {n_iter_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {n_iter_original} \"\n",
+ " f\"Ratio: {(n_iter_opt/n_iter_original):.2f} \"\n",
+ " f\"Number of iterations is bigger but algorithm is much faster and inertia is lower\"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/knn_mnist.ipynb b/2024.3/.doctrees/nbsphinx/samples/knn_mnist.ipynb
new file mode 100644
index 0000000000..b8604d70f0
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/knn_mnist.ipynb
@@ -0,0 +1,333 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn KNN for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Download the data "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"mnist_784\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6259f584",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((56000, 784), (14000, 784), (56000,), (14000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with Intel® Extension for Scikit-learn for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 1.45 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "params = {\"n_neighbors\": 40, \"weights\": \"distance\", \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_opt = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "8ca549ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KNeighborsClassifier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with original Scikit-learn library for MNSIT dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 36.15 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_original = timer() - start\n",
+ "f\"Original Scikit-learn time: {time_original:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "33da9fd1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 24.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(time_original/time_opt):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/lasso_regression.ipynb b/2024.3/.doctrees/nbsphinx/samples/lasso_regression.ipynb
new file mode 100644
index 0000000000..967d0d4e54
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/lasso_regression.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import requests\n",
+ "import warnings\n",
+ "import os\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db2d1c39",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e58a6e28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "532874ab",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.01,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.9676607251167297'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Lasso"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.83 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.9676599502563477'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "13c86289",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.9676607251167297 MSE metric of unpatched Scikit-learn: 0.9676599502563477 Metrics ratio: 1.0000008344650269 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.7 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/linear_regression.ipynb b/2024.3/.doctrees/nbsphinx/samples/linear_regression.ipynb
new file mode 100644
index 0000000000..508ee06d8c
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/linear_regression.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import requests\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad7ce109",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "801ea6cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03431aec",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.03 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "params = {\"n_jobs\": -1, \"copy_X\": False}\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.7716818451881409'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LinearRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.53 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.7716856598854065'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "91fb14e4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.7716818451881409 MSE metric of unpatched Scikit-learn: 0.7716856598854065 Metrics ratio: 0.9999950528144836 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 18.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb b/2024.3/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb
new file mode 100644
index 0000000000..43727804d7
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb
@@ -0,0 +1,329 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb52aca",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.datasets import fetch_openml\n",
+ "\n",
+ "x, y = fetch_openml(name=\"CIFAR-100\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc8ba7c8",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((54000, 3072), (6000, 3072), (54000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=43)\n",
+ "x_train.shape, x_test.shape, y_train.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with Intel® Extension for Scikit-learn for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.82 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "params = {\n",
+ " \"C\": 0.1,\n",
+ " \"solver\": \"lbfgs\",\n",
+ " \"multi_class\": \"multinomial\",\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Log Loss: 3.7073530800931587 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_opt = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Intel® extension for Scikit-learn Log Loss: {log_loss_opt} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LogisticRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with original Scikit-learn library for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 395.03 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d38dfb5",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Log Loss: 3.7140870590578428 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_original = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Original Scikit-learn Log Loss: {log_loss_original} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "b7d17e2f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Log Loss metric of patched Scikit-learn and original Log Loss metric of patched Scikit-learn: 3.7073530800931587 Log Loss metric of unpatched Scikit-learn: 3.7140870590578428 Metrics ratio: 0.9981869086917978 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 15.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Log Loss metric of patched Scikit-learn and original \"\n",
+ " f\"Log Loss metric of patched Scikit-learn: {log_loss_opt} \"\n",
+ " f\"Log Loss metric of unpatched Scikit-learn: {log_loss_original} \"\n",
+ " f\"Metrics ratio: {log_loss_opt/log_loss_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb b/2024.3/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb
new file mode 100644
index 0000000000..8c72c1b71d
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adf9ffe9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "a9b315cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"medical_charges_nominal\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49fbf604",
+ "metadata": {},
+ "source": [
+ "### Preprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fafea10b",
+ "metadata": {},
+ "source": [
+ "Encode categorical features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "f77c30f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cat_columns = x.select_dtypes([\"category\"]).columns\n",
+ "x[cat_columns] = x[cat_columns].apply(lambda x: x.cat.codes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd8d3b6d",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((48919, 11), (114146, 11), (48919,), (114146,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.3, random_state=42)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with Intel® Extension for Scikit-learn for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.69 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "params = {\n",
+ " \"nu\": 0.4,\n",
+ " \"C\": y_train.mean(),\n",
+ " \"degree\": 2,\n",
+ " \"kernel\": \"poly\",\n",
+ "}\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn R2 score: 0.8635974264586637'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = nusvr.score(x_test, y_test)\n",
+ "f\"Intel® extension for Scikit-learn R2 score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class NuSVR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with original Scikit-learn library for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 331.85 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23b8faa6",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn R2 score: 0.8636031741516902'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = nusvr.score(x_test, y_test)\n",
+ "f\"Original Scikit-learn R2 score: {score_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "3a704d51",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare R2 score of patched Scikit-learn and original R2 score of patched Scikit-learn: 0.8635974264586637 R2 score of unpatched Scikit-learn: 0.8636031741516902 Metrics ratio: 0.999993344520726 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare R2 score of patched Scikit-learn and original \"\n",
+ " f\"R2 score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"R2 score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb b/2024.3/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb
new file mode 100644
index 0000000000..276284ed9b
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb
@@ -0,0 +1,320 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Random Forest for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d0b6bb9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Yolanda\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b3a2483",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((280000, 100), (120000, 100), (280000,), (120000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with Intel® Extension for Scikit-learn for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "8fecbbb1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 42.56 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "params = {\"n_estimators\": 150, \"random_state\": 44, \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9279181",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d05bc57b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_opt = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class RandomForestRegressor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with original Scikit-learn library for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "76a8d5f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 123.34 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f162fe6b",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d5b5e45c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_original = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Original Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "e255e563",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 83.62232345666878 MSE metric of unpatched Scikit-learn: 83.80131297814816 Metrics ratio: 0.9978641203208111 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 2.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_original} \"\n",
+ " f\"Metrics ratio: {mse_opt/mse_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/ridge_regression.ipynb b/2024.3/.doctrees/nbsphinx/samples/ridge_regression.ipynb
new file mode 100644
index 0000000000..1c159a13ae
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/ridge_regression.ipynb
@@ -0,0 +1,390 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a1a9234",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f852cad8",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "27ebb377",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "147b3e82",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0014288520708046'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Ridge"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.70 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0014288520708057'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "1bde360d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0014288520708046 MSE metric of unpatched Scikit-learn: 1.0014288520708057 Metrics ratio: 0.9999999999999989 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 10.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/svc_adult.ipynb b/2024.3/.doctrees/nbsphinx/samples/svc_adult.ipynb
new file mode 100644
index 0000000000..9e49bcfecd
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/svc_adult.ipynb
@@ -0,0 +1,322 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn SVC for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2cdcbfa6",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"a9a\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a6df301",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with Intel® Extension for Scikit-learn for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 14.08 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "params = {\"C\": 100.0, \"kernel\": \"rbf\", \"gamma\": \"scale\"}\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class SVC."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with original Scikit-learn library for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 803.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0a7a747",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fc992182",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 57.0 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples/tsne.ipynb b/2024.3/.doctrees/nbsphinx/samples/tsne.ipynb
new file mode 100644
index 0000000000..99ad8fcefd
--- /dev/null
+++ b/2024.3/.doctrees/nbsphinx/samples/tsne.ipynb
@@ -0,0 +1,285 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn TSNE example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import make_blobs\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Generate the data \n",
+ "Generate isotropic Gaussian blobs for clustering.\n",
+ " \n",
+ "With the number of samples: 20k \n",
+ "Number of features: 100 \n",
+ "Number of blobs: 4 \n",
+ "Source: \n",
+ "https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = make_blobs(n_samples=20000, centers=4, n_features=100, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training TSNE algorithm with Intel® Extension for Scikit-learn for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn time: 12.63 s\n",
+ "Intel® Extension for scikit-learn. Divergence: 4.289110606110757\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_intelex = tsne.fit_transform(x)\n",
+ "time_opt = timer() - start\n",
+ "\n",
+ "print(f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\")\n",
+ "print(f\"Intel® Extension for scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ " ### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class TSNE."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training algorithm with original Scikit-learn library for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn time: 37.66 s\n",
+ "Original Scikit-learn. Divergence: 4.2955403327941895\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_original = tsne.fit_transform(x)\n",
+ "time_original = timer() - start\n",
+ "\n",
+ "print(f\"Original Scikit-learn time: {time_original:.2f} s\")\n",
+ "print(f\"Original Scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8358d7c2",
+ "metadata": {},
+ "source": [
+ "### Plot embeddings original scikit-learn and Intel® extension"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "43ab1a96",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colors = [int(m) for m in y]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "35147d24",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPWUlEQVR4nO3dd3gU5cIF8DObbDZ9Q0IKJYRQpNfQiyJEAiKCUqw0EQQiSBWQq6hXQSmioAKiBj4E6f0KCAgoEqnSlN5JSINkN4RkU/b9/uCylzUJJJDsu7tzfs+T52FnZ2fODkv2MPPOjCKEECAiIiJSAY3sAERERES2wuJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNUynbt2gVFUbBr164HzmsymWAymUo/lIPq378/KleuLGXdiYmJ6NmzJwICAqAoCj7//HMpOYrj0qVLUBQFCxcutEzr378/vL29H/jadu3aoV27do+0/pJYBlFJY/Ehp7dw4UIoioKDBw8W+7W3b9/G+++/X6TS8rBycnIwa9Ys1KpVC+7u7nB3d0etWrUwa9Ys5OTkFGtZlStXhqIoBf506tSp2NmWLl3qEF/wtjBq1Chs3boVEydOxOLFix9qezqy+Ph4vP/++zhy5IjsKESPxFV2ACJ7dvv2bXzwwQcAUCr/czUajejatStOnTqFQYMGISIiAoqi4PDhw5g2bRrWrl2LjRs3Qq/XF3mZDRs2xJgxY/JNL1++fLHzLV26FCdOnMDIkSOL/drSsGDBApjNZinr/uWXX9CtWzeMHTtWyvofRlhYGDIzM6HVaov92p9//tnqcXx8PD744ANUrlwZDRs2LKGERLbH4kMkUZ8+feDu7o4jR45Aq9VCURT4+fmhe/fuGDduHF5++WX06dMHGzZsKPIyK1SogFdffbUUU8vzMF/gJSUpKQl+fn4ltrysrCy4ublBoym9He+KosDd3f2hXuvm5lbCaWxDCIGsrCx4eHjIjkJ2ioe6SJXujnOIi4tD9+7d4e3tjcDAQIwdOxZ5eXkA7oyPCAwMBAB88MEHlkNG77//vmU5p06dQs+ePeHv7w93d3c0adKkyCVl06ZNOH/+PNauXYv58+cjMDAQZcuWhU6nQ2RkJEwmE1auXInLly/jP//5T4m996SkJAQGBqJdu3YQQlimnzt3Dl5eXnjhhRcA3NnD9Z///AeXL1+2vPd7x9eYTCZMnjwZ1apVg06nQ2hoKN5+++18Y5QURcGbb76JdevWoW7dutDpdKhTpw62bNliNV96ejpGjhyJypUrQ6fTISgoCE899RQOHz5smaegMT4ZGRkYM2YMQkNDodPpUKNGDcyYMcPqvRUnxz/dPVQqhMBXX31l2RZ3XbhwAb169YK/vz88PT3RokWLfH9fd8d5LVu2DP/6179QoUIFeHp6wmg0FrreZcuWISIiAj4+PvD19UW9evXwxRdfWM2TlpaGUaNGWbZZxYoV0bdvX6SkpAAoeIxPQY4cOWL5TNy6dQuA9ficXbt2oWnTpgCAAQMGWLbBg5ZbkKJ+bmJiYtC+fXsEBQVBp9Ohdu3amDt3br7lVa5cGc888wy2bt2KJk2awMPDA/Pnz7ds8xUrVuDjjz9GxYoV4e7ujg4dOuDcuXPFzk3Og3t8SLXy8vIQFRWF5s2bY8aMGdi+fTtmzpyJqlWrYujQoQgMDMTcuXMxdOhQPPfcc3j++ecBAPXr1wcA/PXXX2jdujUqVKiACRMmwMvLCytWrED37t2xevVqPPfcc/dd/3fffYcpU6bA09PTstyZM2fi5s2bmDBhAj7//HN89NFH+Pjjj/Hdd9+hS5cuRXpfOTk5li++e3l5ecHDwwNBQUGYO3cuevXqhTlz5mDEiBEwm83o378/fHx88PXXXwMAJk2aBIPBgGvXrmHWrFkAYBkUazab8eyzz2LPnj0YPHgwatWqhePHj2PWrFk4c+YM1q1bZ7XuPXv2YM2aNRg2bBh8fHwwe/Zs9OjRA1euXEFAQAAAYMiQIVi1ahXefPNN1K5dGzdu3MCePXtw8uRJNG7cuMD3KoTAs88+i507d2LgwIFo2LAhtm7dinHjxiEuLs6Suzg5/unxxx/H4sWL0adPHzz11FPo27ev5bnExES0atUKt2/fxogRIxAQEIBFixbh2WefxapVq/J9Bv7973/Dzc0NY8eOhclkKnSvyrZt2/DSSy+hQ4cO+PTTTwEAJ0+exO+//4633noLAHDr1i20bdsWJ0+exGuvvYbGjRsjJSUFGzZswLVr11C2bNkCl/1PBw4cQFRUFJo0aYL169cXuKekVq1a+PDDD/Hee+9h8ODBaNu2LQCgVatWRVrHXcX53MydOxd16tTBs88+C1dXV2zcuBHDhg2D2WxGdHS01XJPnz6Nl156CW+88QYGDRqEGjVqWJ775JNPoNFoMHbsWBgMBkybNg2vvPIK9u3bV6zs5EQEkZOLiYkRAMSBAwcs0/r16ycAiA8//NBq3kaNGomIiAjL4+TkZAFATJ48Od9yO3ToIOrVqyeysrIs08xms2jVqpWoXr26ZdrOnTsFALFz506r14eFhVleO3nyZNGqVSuRnJwszp49K5o0aSLGjRsnhBDCZDKJsLCwIr3XsLAwAaDAn6lTp1rN+9JLLwlPT09x5swZMX36dAFArFu3zmqeLl26FLjuxYsXC41GI3777Ter6fPmzRMAxO+//26ZBkC4ubmJc+fOWaYdPXpUABBz5syxTNPr9SI6Ovq+769fv35WedatWycAiI8++shqvp49ewpFUazWWdQchQGQL9/IkSMFAKvtkJ6eLsLDw0XlypVFXl6eEOJ/n4EqVaqI27dvP3Bdb731lvD19RW5ubmFzvPee+8JAGLNmjX5njObzUIIIS5evCgAiJiYGMtz/fr1E15eXkIIIfbs2SN8fX1Fly5drD7HQgjxxBNPiCeeeMLy+MCBA/mW9SD/XEZxPjcFbaeoqChRpUoVq2l3P/Nbtmyxmn53m9eqVUuYTCbL9C+++EIAEMePHy/y+yDnwkNdpGpDhgyxety2bVtcuHDhga+7efMmfvnlF/Tu3Rvp6elISUlBSkoKbty4gaioKJw9exZxcXEPXI5Op7P8ee/evQgMDET16tXh7u5uGVBc3LEWzZs3x7Zt2/L9vPTSS1bzffnll9Dr9ejZsyfeffdd9OnTB926dSvSOlauXIlatWqhZs2alveekpKC9u3bAwB27txpNX9kZCSqVq1qeVy/fn34+vpabWs/Pz/s27cP8fHxRX6vP/30E1xcXDBixAir6WPGjIEQAps3by52juL46aef0KxZM7Rp08YyzdvbG4MHD8alS5fw999/W83fr1+/Io098fPzQ0ZGBrZt21boPKtXr0aDBg0K3LN476G4wuzcuRNRUVHo0KED1qxZY/VZLC3F+dzcu50MBgNSUlLwxBNP4MKFCzAYDFbLDQ8PR1RUVIHrHDBggNW/obt7qx7275wcHw91kWq5u7tbxvDcVaZMGaSmpj7wtefOnYMQAu+++y7efffdAudJSkpChQoVCl2G2WyG2Wy2DG6tX78+/vWvf+Hdd99FtWrVLGdh3Z2vqMqWLYvIyMgHzufv74/Zs2ejV69eCA4OxuzZs4u8jrNnz+LkyZP5tt9dSUlJVo8rVaqUb55/butp06ahX79+CA0NRUREBJ5++mn07dsXVapUKTTH5cuXUb58efj4+FhNr1WrluX54uYojsuXL6N58+b5pt+7/rp161qmh4eHF2m5w4YNw4oVK9C5c2dUqFABHTt2RO/eva1OoT9//jx69OjxULmzsrLQpUsXREREYMWKFXB1ffivglu3blnGBQGAi4tLoZ+L4nxufv/9d0yePBmxsbG4ffu21XwGg8HqTMf7bdd//p2XKVMGAB7675wcH4sPqZaLi8tDv/ZuERk7dmyh/9OsVq3afZfx2GOPITY2Fq1btwZw5xdyr169ULNmTUREROCFF15Ap06dEBsbazVmoSRt3boVwJ0vgWvXrhX5rCWz2Yx69erhs88+K/D50NBQq8eFbWtxzwDk3r17o23btli7di1+/vlnTJ8+HZ9++inWrFmDzp07FynXgxQlR2kq6plGQUFBOHLkCLZu3YrNmzdj8+bNiImJQd++fbFo0aJHzqHT6fD0009j/fr12LJlC5555pmHXtaMGTMsl3wA7pxCf+nSpQLnLern5vz58+jQoQNq1qyJzz77DKGhoXBzc8NPP/2EWbNm5fuPwP22q+y/c7I/LD5E91HYIYO7eyG0Wm2R9q4U5OWXX8Z7772X73BGvXr18M4772D48OE4fvw4Pvjgg3yHqUrCli1b8O233+Ltt9/GkiVL0K9fP+zbt8/qf/+Fvf+qVavi6NGj6NChQ5EOqxRVuXLlMGzYMAwbNgxJSUlo3LgxPv7440KLT1hYGLZv34709HSrvT6nTp2yPF+awsLCcPr06XzTS2L9bm5u6Nq1K7p27Qqz2Yxhw4Zh/vz5lj2CVatWxYkTJx5q2YqiYMmSJejWrRt69eqFzZs3P/A6VYX9Pfft29fqUN/9SkhRPzcbN26EyWTChg0brPbY/PMQKtHD4Bgfovu4e8ZVWlqa1fSgoCC0a9cO8+fPx/Xr1/O9Ljk5+YHL7tOnD1JTUzF8+HBMmDDBajzK5MmTcfjwYUyYMAHJycno06fPo72Rf0hLS8Prr7+OZs2aYcqUKfj2229x+PBhTJkyxWo+Ly+vfOMpgDt7Z+Li4rBgwYJ8z2VmZiIjI6NYefLy8vKtJygoCOXLl7/vLTyefvpp5OXl4csvv7SaPmvWLCiKUmJ7iu63/v379yM2NtYyLSMjA9988w0qV66M2rVrP9Ryb9y4YfVYo9FYzia8uz169OiBo0ePYu3atfleX5S9GW5ublizZg2aNm2Krl27Yv/+/fed38vLC0D+fwtVqlRBZGSk5efuHsyCFPVzc3cvzb3vw2AwICYm5oHvi+hBuMeH6D48PDxQu3ZtLF++HI899hj8/f1Rt25d1K1bF1999RXatGmDevXqYdCgQahSpQoSExMRGxuLa9eu4ejRo/ddtlarxerVq/Hkk0/i4MGDGDVqFJo0aQJFUXDo0CF8/vnniIuLw86dO4t14b64uDj88MMP+aZ7e3uje/fuAIC33noLN27cwPbt2+Hi4oJOnTrh9ddfx0cffYRu3bqhQYMGAICIiAgsX74co0ePRtOmTeHt7Y2uXbuiT58+WLFiBYYMGYKdO3eidevWyMvLw6lTp7BixQrLNVWKKj09HRUrVkTPnj3RoEEDeHt7Y/v27Thw4ABmzpxZ6Ou6du2KJ598EpMmTcKlS5fQoEED/Pzzz1i/fj1GjhxpNZC5NEyYMAE//vgjOnfujBEjRsDf3x+LFi3CxYsXsXr16oe+OOHrr7+Omzdvon379qhYsSIuX76MOXPmoGHDhpbxQ+PGjcOqVavQq1cvvPbaa4iIiMDNmzexYcMGzJs3z/J3eD8eHh7YtGkT2rdvj86dO2P37t1WY5LuVbVqVfj5+WHevHnw8fGBl5cXmjdvXuRxSwCK/Lnp2LGjZY/XG2+8gVu3bmHBggUICgoq8D8aRMUi8YwyIpso7HT2u6f03mvy5Mnin/8s9u7dKyIiIoSbm1u+U9vPnz8v+vbtK0JCQoRWqxUVKlQQzzzzjFi1apVlnsJOZ78rISFBvPzyy0Kr1VpOPddqteLll18W169fL9Z7vd/p7HdPA1+/fr0AIGbOnGn1WqPRKMLCwkSDBg1Edna2EEKIW7duiZdffln4+flZLUMIIbKzs8Wnn34q6tSpI3Q6nShTpoyIiIgQH3zwgTAYDJb5UMBp4Hez9uvXTwhx55T9cePGiQYNGggfHx/h5eUlGjRoIL7++mur1/zzdHYh7pw+PmrUKFG+fHmh1WpF9erVxfTp0y2ndBcnx/0U9vrz58+Lnj17Cj8/P+Hu7i6aNWsmNm3aZDXP3c/AypUrH7geIYRYtWqV6NixowgKChJubm6iUqVK4o033sj3ebhx44Z48803RYUKFYSbm5uoWLGi6Nevn0hJSRFCPPh09rtSUlJE7dq1RUhIiDh79qwQIv+p6ELc+ezUrl1buLq6FunU9oKWUdTPzYYNG0T9+vWFu7u7qFy5svj000/F999/LwCIixcvWuYLCwsTXbp0ybfuwrZ5QduE1EURgiO8iOyBwWCwjA2pWbNmse7PRURERcPiQ0RERKrBwc1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBq8gOE9zGYz4uPj4ePjU6KX4SciIqLSI4RAeno6ypcv/8ALh7L43CM+Pj7fzRWJiIjIMVy9ehUVK1a87zwsPve4e5PDq1evwtfXV3IaIiIiKgqj0YjQ0FCrmxUXhsXnHncPb/n6+rL4EBEROZiiDFPh4GYiIiJSDRYfIiIiUg0WHyIiIlINFh8iIiJSDRYfIiIiUg2HKj5xcXF49dVXERAQAA8PD9SrVw8HDx60PC+EwHvvvYdy5crBw8MDkZGROHv2rMTEREREZE8cpvikpqaidevW0Gq12Lx5M/7++2/MnDkTZcqUscwzbdo0zJ49G/PmzcO+ffvg5eWFqKgoZGVlSUxORERE9kIRQgjZIYpiwoQJ+P333/Hbb78V+LwQAuXLl8eYMWMwduxYAIDBYEBwcDAWLlyIF1988YHrMBqN0Ov1MBgMvI4PERGRgyjO97fD7PHZsGEDmjRpgl69eiEoKAiNGjXCggULLM9fvHgRCQkJiIyMtEzT6/Vo3rw5YmNjC1ymyWSC0Wi0+iEiIiLn5TBXbr5w4QLmzp2L0aNH45133sGBAwcwYsQIuLm5oV+/fkhISAAABAcHW70uODjY8tw/TZ06FR988EGpZyf1uJVpwpx1e/DLkXMwZedC66rBbVMOTDl5AAB3N1f06RCBoc+2kpyUiEidHOZQl5ubG5o0aYK9e/dapo0YMQIHDhxAbGws9u7di9atWyM+Ph7lypWzzNO7d28oioLly5fnW6bJZILJZLI8vnuvDx7qUqdryWn4bvN+3Lx1G1XKBWBg52bQurhg+a4jiE8xoEJZPVrXDYfW1QXl/H2QeisT2Tl5SE2/jR1HzuFKYip2H7sAcxH+SVUrH4BnmtfGleQ0VAjQ46X2DeHuprXBuyQicj7FOdTlMHt8ypUrh9q1a1tNq1WrFlavXg0ACAkJAQAkJiZaFZ/ExEQ0bNiwwGXqdDrodLrSCUwOIzfXjMGfr8SR8/GWab8dv4hFPx/MN++sNQWPMSuuc/E38Pna/y3ryw170OvxBpjwYvsSWT4RERXMYcb4tG7dGqdPn7aadubMGYSFhQEAwsPDERISgh07dlieNxqN2LdvH1q2bGnTrORY/ll6ZBACWLH7KD5d9ovUHEREzs5his+oUaPwxx9/YMqUKTh37hyWLl2Kb775BtHR0QDu3JF15MiR+Oijj7BhwwYcP34cffv2Rfny5dG9e3e54clu/Xb8gvTSc68Vvx5FVnaO7BhERE7LYQ51NW3aFGvXrsXEiRPx4YcfIjw8HJ9//jleeeUVyzxvv/02MjIyMHjwYKSlpaFNmzbYsmUL3N3dJSYne3QlKRV9P/0RxtumB89sQ0IAc9buwbgXnpQdhYjIKTnM4GZb4HV8nFNGpglzN8Xi12MXIIRA4+oVsfGPv2XHuq9AX090aVEbFQP90LRGKEID/WRHIiKyW045uJnoYWw7dAYTvv0P7m33cTfsu/QAQLLxNhbeM7i6nL8v5o/sgYosQEREj4TFh5zWpYSbGP/tf2THKBHXbxrx7Hsx8NRp0fPx+hjRvQ00GocZokdEZDf4m5Oc1r8WbpYdocTdNuXg/7YdwnPvL4Qph4OgiYiKi8WHnFJOXh5OXk6SHaPUXE024IlRX2Px9oPgMD0ioqJj8SGns2znn2g94ks4ex3IzjNj1urf0H3yQpiyc2XHISJyCCw+5FR+2HEI01bsQq7ZLDuKzVxNTsPTkxbAlMPyQ0T0IBzcTA7vUsJNnItPQZDeC7NW/yo7jhSpt7LwwoeL4a/3RHAZb4zp1Q5lfb1kxyIisjssPuSwfjt+AR/+sA03jLdlR7ELV1LScCUlDQCw9eAZ1KwUhB/Gv8Szv4iI7sHfiOSQdh49h7e+Xs/Scx+nriThhY9+kB2DiMiusPiQwxFCYPLCrbJjOITz12/gzLVk2TGIiOwGiw85nP2nruBWVrbsGA5j5spdsiMQEdkNFh9yOMcvXpcdwaEcOHMNa/Yckx2DiMgusPiQwzHcypIdweF8tGQH9v51SXYMIiLpWHzIoQghsOGPv2THcEhvL9gkOwIRkXQsPuQwMk05mPDtf5CeyfE9D+O2KYe3tyAi1WPxIYeQYriFyPHzse3wWdlRHNqUH3ew/BCRqrH4kEN4bcYKZJp4N/JHtfq34/hs1W7ZMYiIpOGVm8nunYtLwbUUg+wYTmPJL3/i+KUEvPBEA3RuVkt2HCIim+IeH7J7P+0/KTuC0zl24TomxWzBk2PnIjE1XXYcIiKbYfEhu5dn5piU0mLIyMILHy2GWUV3sycidWPxIbv3VMRjsiM4NeNtE9bv/Vt2DCIim2DxIbtXo2IgfDzcZMdwaqt+Oyo7AhGRTXBwM9mt7JxcTPx+M3YfPQ8zT8EuVVnZubIjEBHZBIsP2aWcvDz0+PD/EMezuWwiNNBPdgQiIpvgoS6yS99v2c/SY0Mjn28rOwIRkU2w+JBdWrGLY05s5ZkWtVA5xF92DCIim+ChLrJLhgzegd0WBndpgSHPtJQdg4jIZrjHh+ySqws/mrYQzj09RKQy/HYhu9S0RqjsCKrwxdrfZEcgIrIpFh+yS2+/8CQURXYK55dwMx23Mk2yYxAR2QyLD9ml0EA/vN+no+wYqmDK4TV8iEg9WHzIblXktWVKnYtGA72Xh+wYREQ2w+JDdkvv5S47gtOrGx7MgeREpCr8jUd2KyyojOwITs/HXSc7AhGRTbH4kN3i/blKX66Z25iI1IXFh+zWlaRU2RGcXq3QQNkRiIhsisWH7NaQL1bLjuD02jWsJjsCEZFNsfiQXTpyLg43jLdlx3B6If4+siMQEdkUiw/ZpR1HzsqO4PQ83FwRqPeWHYOIyKZYfMguuWpcZEdwejUqBcmOQERkcyw+ZJeebVlbdgSnN5lXxiYiFWLxIbsUXi6A1/EpRfXCQ7h9iUiVWHzIbsWM6w0fD15grzR8NKCz7AhERFKw+JDd8vP2xLZP38DrTzdHWb0X3N1cZUdyCrXDghDK+6ARkUopQvDyuHcZjUbo9XoYDAb4+vrKjkMFeGr8fJ7m/ggUBdjw4WuoUFYvOwoRUYkpzvc39/iQQ/Fw08qO4NBa1Apj6SEiVWPxIYfSsGoF2REcWpPHKsqOQEQkFYsPOZS+T0XIjuCwFEVBjzb1ZccgIpKKxYccSrUKZTH0mZayYzikkc+3ha+Xu+wYRERSsfiQwxnUpQXa1guXHcOhlA/wRZ9I7i0jImLxIYf0736d4OrCj29RdYx4THYEIiK7wG8Ocki+Xu6Y/1ZPKIrsJPZPUcC9PURE/8XiQw6rUfUKqBsWIjuG3RvyTEuU8fGUHYOIyC7wUrjk0Lw9eUuLwrhoFIzu+QRebNdQdhQiIrvB4kMO7eX2jRD792XZMexORPWKmDHkGeg9PWRHISKyKyw+5NBa1wlHsJ83EtNuyY5iFxQFWDO5P8KCeed1IqKCOOwYn08++QSKomDkyJGWaVlZWYiOjkZAQAC8vb3Ro0cPJCYmygtJNrF00isI1HvJjmEXhAD+PHdNdgwiIrvlkMXnwIEDmD9/PurXt74K7ahRo7Bx40asXLkSu3fvRnx8PJ5//nlJKclWynh7YsvUQZg+6Bk0qFJOdhzp4lKMsiMQEdkthys+t27dwiuvvIIFCxagTJn/7c43GAz47rvv8Nlnn6F9+/aIiIhATEwM9u7diz/++ENiYrIFRVHQoXF1xIx7Efu/HIEaoYGyI0lTpZy/7AhERHbL4YpPdHQ0unTpgsjISKvphw4dQk5OjtX0mjVrolKlSoiNjbV1TJLI1cUFP77zKnZ8+obsKDandXVBp6Y1ZccgIrJbDjW4edmyZTh8+DAOHDiQ77mEhAS4ubnBz8/PanpwcDASEhIKXJ7JZILJZLI8Nhp5iMCZlPH1RI829bB6z3HZUWzmzW6tofCqjkREhXKYPT5Xr17FW2+9hSVLlsDdvWRutDh16lTo9XrLT2hoaIksl+zHpFci0fepCKe5vYW3hxu6taoDF431+9G6umDU8215hWYiogdQhBBCdoiiWLduHZ577jm4uLhYpuXl5UFRFGg0GmzduhWRkZFITU212usTFhaGkSNHYtSoUfmWWdAen9DQUBgMBvj6+pbq+yHbysszY/vhs0hIS4ebqwafrfoVeWaH+OgDuFN4hnRpia6t6sDHQ4e8PDM2/vE34m4YUCUkAFFNHoNG4xzljoiouIxGI/R6fZG+vx2m+KSnp+PyZesL1Q0YMAA1a9bE+PHjERoaisDAQPz444/o0aMHAOD06dOoWbMmYmNj0aJFiweuozgbjhxbctotDJixHPE37PfwpqIAIWV88dbzbdAxoobsOEREdqs4398OM8bHx8cHdevWtZrm5eWFgIAAy/SBAwdi9OjR8Pf3h6+vL4YPH46WLVsWqfSQugT6eWPTRwPx16UEfLx0B87EJcNsJ3uAmteshLlv9ZAdg4jIKTlM8SmKWbNmQaPRoEePHjCZTIiKisLXX38tOxbZsTqVQ7D0nVcAAGazGQCg0WgQn2LAjJW7sevYeZtlcdEo6NK8Nt7v29Fm6yQiUhuHOdRlCzzURf/03sIt2LTvZIkv11WjYOnEV+HhrsWhs9fg7aHDE/WqwMVJBmETEdmSUx7qIpLhw/6dUL9KOSz4aR+SDRkA7gw07tG2Hjo3qQl3Ny3Kl/XFwq0HELP1ADKzcy2vbVi1PGa+0RW5uWa8939bceH6Dbi5uqDX4/XxSmSE5cysCmX1Ut4bEZEacY/PPbjHh+4nN88MIQS0ri4FPm82C6Teug2NRgM/L3deT4eIyEa4x4eoFDzoWkAajYIAX94slYjInnFAAREREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYbDFJ+pU6eiadOm8PHxQVBQELp3747Tp09bzZOVlYXo6GgEBATA29sbPXr0QGJioqTEREREZG8cpvjs3r0b0dHR+OOPP7Bt2zbk5OSgY8eOyMjIsMwzatQobNy4EStXrsTu3bsRHx+P559/XmJqIiIisieKEELIDvEwkpOTERQUhN27d+Pxxx+HwWBAYGAgli5dip49ewIATp06hVq1aiE2NhYtWrR44DKNRiP0ej0MBgN8fX1L+y0QERFRCSjO97fD7PH5J4PBAADw9/cHABw6dAg5OTmIjIy0zFOzZk1UqlQJsbGxBS7DZDLBaDRa/RAREZHzcsjiYzabMXLkSLRu3Rp169YFACQkJMDNzQ1+fn5W8wYHByMhIaHA5UydOhV6vd7yExoaWtrRiYiISCKHLD7R0dE4ceIEli1b9kjLmThxIgwGg+Xn6tWrJZSQiIiI7JGr7ADF9eabb2LTpk349ddfUbFiRcv0kJAQZGdnIy0tzWqvT2JiIkJCQgpclk6ng06nK+3IREREZCccZo+PEAJvvvkm1q5di19++QXh4eFWz0dERECr1WLHjh2WaadPn8aVK1fQsmVLW8clIiIiO+Qwe3yio6OxdOlSrF+/Hj4+PpZxO3q9Hh4eHtDr9Rg4cCBGjx4Nf39/+Pr6Yvjw4WjZsmWRzugiIiIi5+cwp7MrilLg9JiYGPTv3x/AnQsYjhkzBj/++CNMJhOioqLw9ddfF3qo6594OjsREZHjKc73t8MUH1tg8SEiInI8qriODxEREVFxsfgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqFLv49OvXD7/++mtpZCEiIiIqVcUuPgaDAZGRkahevTqmTJmCuLi40shFREREVOKKXXzWrVuHuLg4DB06FMuXL0flypXRuXNnrFq1Cjk5OaWRkYiIiIooKcuA2OQz+PPmReSYc2XHsTuKEEI8ygIOHz6MmJgYfPvtt/D29sarr76KYcOGoXr16iWV0WaMRiP0ej0MBgN8fX1lxyEiIhXZdv0oPv1rA4y5mQAAvdYTo2s+jc4VGgMAMnKzMPPvTdh34yxcNS4YWrUjOlVsiLTsDNwwpSNXmDHxz6W4lnnTskwFCqJCGiDMqywuZCTB380L3UOboapPsJT3WFqK8/39SMXn+vXr+L//+z/ExMTg2rVr6NGjB+Li4rB7925MmzYNo0aNethFS8HiQ0REMgyMnYfjhisFPteoTGWEeQZiXdyBEltfhH84vmgyAG4a1xJbpkylWnxycnKwYcMGxMTE4Oeff0b9+vXx+uuv4+WXX7asbO3atXjttdeQmpr68O9CAhYfIiKylVxzHvKEGd+f24WYizttvv5q3sEYW7sr1lzdj0u3kuGr9UDHcg3QqXwDuLu42TzPoyjV4lO2bFmYzWa89NJLGDRoEBo2bJhvnrS0NDRq1AgXL14sVnDZWHyIiKi0bbx2EF+d2Yqb2RmyoxTIBRpEP9YRL4W3gYviGFe9KdXis3jxYvTq1Qvu7u6PFNIesfgQEVFpmnJiLdZdK7lDVqWpbWBNTGv8qkOUH5uN8XE2LD5ERFQSzGYzVl/dhwM3zkOrcUWP0GbQalwxcN882dGKxUvjhpfC26BRmXD467xRxTsIiqLIjpUPi89DYvEhIqJHtSvxL0w6sgw5Ik92lBKnQEGLstUxpeFL8HLVyY5jUZzvb/vff0VEROQgjqdextt/LnHK0gMAAgKxKWcQuePfSMh0rBOY7mLxISIiKiGf/r1BdgSbyBNmPLt7On5LOik7SrGx+BAREZWQM+nXZUewqTGHF+NXBys/LD5ERESPKE+Y8Vrs17JjSDHu8A84Y4yXHaPInOOSjURERJLkmvPQbfd0JJuMsqNIISDw6t4v4a/1wogandG5QiO7PPPrLu7xISIiegT/Pr5ataXnXjdzMvD+iVV460AM7PmEcRYfIiKih5SVm40t14/IjmFX/rh5Dh1/+QipJvu8MjWLDxER0UPIMedi+KEY2O++DXkMOZl46ffPYRZm2VHyYfEhIiJ6CEsu7sHR1MuyY9itm9kZ2BJ/RHaMfFh8iIiIiuFqxg1M+2s95p7dJjuK3Vt+OVZ2hHx4VhcREVER/ZZ0EuMO/wAzD3AVya2cLNkR8uEeHyIioiJIyTJizOHFLD3FcD0rFZm5JtkxrLD4EBERFcH8s9tlR3A4ucKMl/bMlh3DCosPERFREfyScEJ2BIcUn5WKYfu+tZtr+7D4EBERFcGtPPs6ZONIDqZeQO/fZsGQLf/aPiw+RERED5BrzoPg2J5Hcvl2Cp765WPsTvhbag4WHyIiovs4lnoZ7bZ/IDuG0xh35AekZMm7xQeLDxERUSHSsjPwxv4FyDbnyo7iVL44tVnaup2y+Hz11VeoXLky3N3d0bx5c+zfv192JCIickBfnt6CPDu87YKj25NyStq6na74LF++HKNHj8bkyZNx+PBhNGjQAFFRUUhKSpIdjYiIHMyvSfK+oJ1ZnllemXS64vPZZ59h0KBBGDBgAGrXro158+bB09MT33//vexoRETkYDJ5JlepqODpL23dTlV8srOzcejQIURGRlqmaTQaREZGIjY2//1CTCYTjEaj1Q8RERGVrrG1ukpbt1MVn5SUFOTl5SE4ONhqenBwMBISEvLNP3XqVOj1estPaGioraISEZGdyzbnwsRBzaXCw9VN2rqdqvgU18SJE2EwGCw/V69elR2JiIjshJmDmkvN1OPrpK3bqe7OXrZsWbi4uCAxMdFqemJiIkJCQvLNr9PpoNPpbBWPiIgcSEYOx/eUltO34pFrzoOrxsXm63aqPT5ubm6IiIjAjh07LNPMZjN27NiBli1bSkxGRESO5sPjq2RHcGobrh2Ssl6nKj4AMHr0aCxYsACLFi3CyZMnMXToUGRkZGDAgAGyoxERkQNIzjKi265piL1xVnYUp3Yi7YqU9TrVoS4AeOGFF5CcnIz33nsPCQkJaNiwIbZs2ZJvwDMREdE/Zeaa0Ou3z3A7L1t2FKf3n/g/0bVCBBoFhNt0vYqwl/vE2wGj0Qi9Xg+DwQBfX1/ZcYiIyMam/70BK6/8ITuGargqGuzo8N4jn+VVnO9vpzvURURE9LC2xh+VHUFVcoUZCy/ssuk6WXyIiIj+i4e4bO+XxL9suj4WHyIiov/ycNHKjqA6ueY8m66PxYeIiOi/nipXX3YE1anhW96m62PxISIi+q9XKreRHUF1RtToZNP1sfgQERH91/XMNNkRVOXZChEob+M7tbP4EBER/Vewu152BFV5o/pTNl8niw8REdF/hXkHwtfVQ3YMVWigD0Ogu+2vmcfiQ/kIYYbIOQZh+h0il3esJyJ1GfZYR9kRVEHrYvsblAJOeMsKKpg59wqQ8TWQlwy4VAS8h0PjUhZC5EFk/ABkrQVENqB4A7nxAJIsrxVuLaH4vgvFtZq8N0BEZCPPV2qO1OwMzD+3XXYUp3bKGC9lvSw+Tk6IPIjUQUD2HusnMn+E2bUpkHsEQM79F5K9HyKlB4RLFcB8HVC8AK+BUDxfgKLIaexERKVpYLX2eDGsFdrv+DcEeGen0mDr6/fcxUNdTsJszoM5LxnmvAyYTX/AnPUzzLnXIVKH5i89d+UewANLDwAgD0AmkPcXIG4C5qtA+vsQiXVhzipk2UREDs5L645BVTvIjuG0gj3kDCTnHh8HZ86NAwxjgJzDEtaeB6S9BrNrXUD/b2i0dSRkICIqPWHeZWVHcFoDq7aXsl4WHwdmzr0EpHRB0fbalKLcE8CN52CG7s5hMLcIKJ59oOhayM1FRPSI2gbVgpeLDhl5JtlRnEqEfxV0Kt9Qyrp5qMsBCfNNmNM+BFI6Q3rpsWK6cyjMtB0itS/MqSMhhFl2KCKih+buosWY2l1lx3AqLQKqY26z16Wtn3t8HIjZbAKSewHilOwoD/DfgYCmnyASt0C4NgU0OkBbF4pnbygutr0vCxHRo3imQmPoNK6YdHSZ7CgOTwMFMxq/KjkD2S1z7lWYjR/DnPYOzBkrgaTmDlB6/skM5O4Dsn8FMr6GSG4H8615skMRERXLU+XqQwNFdgyH1yGkHtxctFIzcI+PHTKbM4Gbr9wZO3NX1ip5gUrarc9gvr0K0LWH4tkdira27ERERA/k6arDrdws2TEcVh19Rfy7fm/ZMbjHxy7d6GZdepyR+QqQuRDiRneY00ZBiGzZiYiI7qtLhUayIzis8u5+iGk5DBqN/NohPwFZMWduA/IuyY5hW1n/gUgdJTsFEdF9DX+sE8poPWXHcDguUPB/rYbLjmHB4mNvMr6RnUCO7G0w394oOwURUaHcXLRY88RYNPALkx3FoTwZXAe+bvZz41cWH3uTd1F2AnmMY2A2xsBs5inwRGSfvFzdsaDFG5jfVN7p2I4mW8i5NUVhWHzsiNk4GxBG2THkuj0VSGpw5+KMRER2qlFAFTTwqyQ7hkOo6BkgO4IVFh87IEQOzMnPAre/lB3FTpiAlC68+CER2bX5zQajZdnqsmPYvYFVn5QdwQqLjx0QyU8BeY52fZ7SlgOR1Inlh4jslkajwRdNBkCn8MowhXk+tBl8tPYzvgdg8ZHOfGsxYI6XHcM+iUsQhn/JTkFEdF9l3X1lR7A7LtDglcptMKFOd9lR8mFNlUQIAWSuBm79W3YU+5a1CmaDK+AzCRqNTnYaIqJ8xtfuihGHFsmOYReeLd8EjQLC0DGkAbQu9lkxuMdHAiEEhPFfEMZ3ZEdxDJnLgKR6MN9eIzsJEVE+LQJroJZvBdkxpGsRUB3/qv88ulSIsNvSA7D4yGHaDmSulJ3C8RgnwJx9THYKIqJ8FrWKxlMh9VV5Ny9XRYPXqrTD7KYDZEcpEkUIIWSHsBdGoxF6vR4GgwG+vqVzzNacfQS4+SoA3qLhobg8Bk3gJtkpiIgKZBZmnDTEIz0nEzsSjmN93EHZkUqFh8YN3zYfDG83D4S4+0FR5Fa+4nx/2+++KCdkzj4K3HwBALvmQ8s7IzsBEVGhNIoGdfwqAgBaBFbH8bQruJCRJDlVyQr1DMA3zQYjwN1HdpSHwuJjS6mDwNJDRKQec5u9jqidU2THeGS1fSugaUA1PF2hIcK9g2XHeSQsPjZizlgCiDTZMZyCECYoCs/wIiL7V0bnjc8b98Oow4sc9r+9Ie56LGwVLTtGieHgZlu5NVt2AqchbvaRHYGIqMhaBdXAnqc+RO9KLRGo83GoAdCP+ZTDirajZccoURzcfI/SGtwszDchklqU2PIIQMAWaLRVZKcgIiq2xRd+xZwzW2THyOetx57GzqQTMGTfRll3Xwys+iSaBFSVHatIOLjZzgjD+7IjOB/ju0DAEtkpiIiKrU+Vx3HuVgI2xx+573wu0CAPpX/bnnCvIMxo3AehXgF4pUqbUl+fbCw+pcycGweY7K/ZO7ycwxAiB4qilZ2EiKjYPqjfG71CW2LOmc24nJECrcYFbQNr4qXKbeHu4ooAnTc0igYX05MQl3kT4V6BGH14MS4+5BliflpPNPALw21zNvzdvNAv/AlU9g6Cq8alhN+Z/eOhrnuUxqEuc+oowPSfElkW/YNbJDT+X8tOQURkM78lnsTMk5twM/sWtBoX5AkzbucVfl24UM8AfN3sdQS7622Y0vZ4qMtOCCEA01bZMZxX9naYc69A41pJdhIiIptoG1wLbYNrWR7fNKWj52+zcCs3K9+8gTpfLG71JjxdeRbsvXhWVykSt38AkCs7hnMzvC07ARGRNP46H2xt/w4GV4tEsE4Pb1cdKnj4Y1TNp7HxibdZegrAQ133KOlDXebEloC4UQLJqHBaaEL+kh2CiIgkKs73N/f4lCZhlJ1ABXJgvjlIdggiInIQLD6liWcc2Ub2bpizfpadgoiIHACLT2nSdZSdQD3Sv5CdgIiIHACLT2ny/UB2AvXIuyY7AREROQAWn9KU9afsBOqh8MoMRET0YCw+pcRszgaMr8uOoR5uzWQnICIiB8DiU1oME8Br+NiKAvi8IzsEERE5ABaf0sL7c9mOfiY0rqGyUxARkQNg8Sk13NtjG/7QeDwjOwQRETkIFh9ycDdlByAiIgfC4lNaNDz0Yiu86woRERUVi09p0X8qO4FKuEFRFNkhiIjIQbD4lBKNrgmAsrJjOD/3SNkJiIjIgbD4lCbv/rITODfFB/D9SHYKIiJyICw+pUjxfBmAm+wYzstnEjQab9kpiIjIgThE8bl06RIGDhyI8PBweHh4oGrVqpg8eTKys7Ot5jt27Bjatm0Ld3d3hIaGYtq0aZIS36FovAG/r6RmcGoZ38pOQEREDsYhbnB06tQpmM1mzJ8/H9WqVcOJEycwaNAgZGRkYMaMGQAAo9GIjh07IjIyEvPmzcPx48fx2muvwc/PD4MHD5aWXeP+BMxeI4CM2dIyOC3emJSIiIpJEQ56LvD06dMxd+5cXLhwAQAwd+5cTJo0CQkJCXBzu3N4acKECVi3bh1OnTpVpGUajUbo9XoYDAb4+vqWaF5zyiAgd3eJLpO8oAnhjWCJiNSuON/fDnGoqyAGgwH+/v6Wx7GxsXj88cctpQcAoqKicPr0aaSmpsqIaEXxnwHA/4HzUTHoWshOYDOmrGz8+MlazHpjPpZPX4dsU47sSEREDskhDnX907lz5zBnzhzLYS4ASEhIQHh4uNV8wcHBlufKlCmTbzkmkwkmk8ny2Gg0llJiQNHoIQK3AslNS20d6qIAPuNlh7CJL4d/hw1zt0KY/7dz9ruJS9Fz1DMYPL2vxGRERI5H6h6fCRMmQFGU+/788zBVXFwcOnXqhF69emHQoEGPtP6pU6dCr9dbfkJDS/dqyxoXfakuX1X0M6BxrSw7Ran7csR3WP/VFqvSAwDCLLBy5kYsGL8YSVdTsO3/duHwL8d4FWsiogeQOsYnOTkZN27cuO88VapUsRy+io+PR7t27dCiRQssXLgQGs3/elvfvn1hNBqxbt06y7SdO3eiffv2uHnzZpH3+ISGhpbKGJ+7zAmPlcpy1cMNKLsTGtdA2UFKnSkrG129X81Xeh7ksSZVMPzL15FhuI2yFQMQVqsiAODS31cRu+EgXF1d0P6Vtggol//fBBGRIyrOGB+ph7oCAwMRGFi0L7C4uDg8+eSTiIiIQExMjFXpAYCWLVti0qRJyMnJgVarBQBs27YNNWrUKLD0AIBOp4NOp3u0N1FsngBu23idTsRnrCpKjxACc978ttilBwDOHLyA4S3esTx2cdUAioK8nDzLtG/eXozweqH4Yu/HABTcSs2Aj7833D1t/e+BiMi2HOKsrri4OLRr1w5hYWFYtGgRXFxcLM+FhIQAuDPYuUaNGujYsSPGjx+PEydO4LXXXsOsWbOKfDp7aZ7VdZc5oTGAW6WybKeni4Ti9yUUxWHH5BfJsV//wuTnpuNWakapr0vjosCc979fATWbV8Prn7yCkPBg+Ab4wMPLvdQzEBE9quJ8fztE8Vm4cCEGDBhQ4HP3xj927Biio6Nx4MABlC1bFsOHD8f48UUfAGuT4pMYAYj0Ulm203KpCniPgOLeyWlvSLr5+x344cNVSLqSIjuKlcp1QzF6wRDUas5DtERkv5yu+NiKTYpPSlcg93SpLNsp+X4IjeeLslOUmNycXKyd/RN+XrQLpsxshNaogKyMLBzb/bfsaIVSFAWfbnsXjdrXkx2FiKhALD4PySbFJ2svkNa/VJbtjJTgo1AUD9kxSsTV03EY1mQ8sjJMD57ZzmjdXLHo3JcIrBggOwoRUT6quICho9K4twK0jWTHcBBeTlN68nLzEN10gkOWHgDIyc7FwDojcfkkbxNCRI6NxUcCxX8Z4N4N3PwP4P2G7ASP7M9fjuPDXjPxRsOxyLyVJTvOI8lMz8L7z03DlVPXkJpkkB2HiOih8FDXPWxxqOteQuRBmH4F0j8F8i6U+vocimsDKAErHHYwc0rcDUQ3m4Cb19NkRyk1lWpVwIivBqFBuzqyoxCRyvFQl4NQFBdo3J+EUnY94NZGdhw7oQO8x0JTdqXDlp6c7Bz0e2yEU5ceALhyMg5j27+P31bHyo5CRFRkLD52QFF0UMp8B2ibyY4ij/dEaELOQBNyHBrvol13yR4JIfDxS58jOzNbdhSbmfLyF8jNyZUdg4ioSFh87ISiKFD8FwMuajts4Af4b4LGu+DrNDmK7Ut/RVefV9HRpTd+X7tfdhybys3Jw6tVonFg6xHZUYiIHohjfO5h6zE+BTHnGf97B3c1/LX4QwneDUVx7NskfPfOEiz7ZJ3sGHahTLAeFaqXQ5/JvdG4A6/7Q0S2wTE+Dkzj4guU+RFO/1ej6+IUpefamXiWnnukJhpwYs8pjH/qQwxvMZGHwIjI7jj5t6tj0ugaQwn+G/B6A1DKyo5TwtyAwL3QlJnl8KXndvptRDebIDuG3Tq1/xw+fulz2TGIiKyw+NgpRdFA4zMGmuC9gC5SdpwSogCBv0Lj4vhl7sb1m3ih3GDcNmbKjmLXfl+7HxmG0r/ZKhFRUbH4OADF7yvAvQcc/q/LcwA0Lv6yUzyyqa9+gRcrvIGs2455FWZbEkJgj8oGexORfXPwb1J1UBQFGr+pQNBRwPffDnj4SwE8XobiM152kEc2b8wi/LJ0j+wYDiXxcrLsCEREFjyr6x72cFZXUZjNt4CUzoA5UXaU/JQQwH8FcHsBYE4CXMMAz8F3Bm07gShtb5jz+E+mOMoE6bH06jy4al1lRyEiJ8WzupycRuMNJfDXO3t/XKrd2QPkUh1QQm2cxOWeP7sD3uOgBO2GRhsCjf5daMrMgcZnrFOUnsyMTAxpPI6l5yGkJhkwrsOHMNwwyo5CRMQ9PvdylD0+hRFCQCRFAOJWwTO4dYOiHwuYkyCEB5A2AjCfe7iVeQ6FxnfUw4d1IDnZOXg1fJjT34KitLm5a7HgxGcoXyVEdhQicjLc46NSiqJACToEuHeH1d4YxRfwnQ2N/3QoLsFQtPWgcasGJfA/gOZ+X0LeAP55yrkb4D1BNaUHABZNXsHSUwKys3Iw5onJsmMQkcrxoLuTURQFit80ANOKNK8ouwswvAmYduB/V4tWALe2gN9caDRamHPOA7l/A66PQaOtUYrp7dNPC7bJjuA0UuJu4tSBc6jZtJrsKESkUiw+KqfRaIAyX985TJZ7CUAe4BIOjeZ/e4w02qqAtqq0jDJlm7KRfpPXoSlJs4ctwNcHPpUdg4hUioe6CMB/T5nXhkOjrWZVetTu075fyo7gdM4euoCU+JuyYxCRSrH4EBXCbDZjz5p9smM4paUfr5EdgYhUisWHqBCGlHSY88yyYzilSyeuyI5ARCrF4kNUCK0bh8CVFi+9p+wIRKRSLD5EhfD284Iry0+pcNW6IC8vT3YMIlIhFh+iQvy19xRys3Nlx3BKe9bux7cTlsiOQUQqxOJDVAh+MZeutV/8hLRkg+wYRKQyLD5EhTh14CFv50FFkpebh9gNB2XHICKVYfEhKkSuiYe5StuSj1cjIz1TdgwiUhEWH6IC8N69tpF4KRl9q0Yj25QjOwoRqQSLD1EBEi8ny46gGsaUdMwf+3+yYxCRSrD4EJF0Oxbvlh2BiFSCxYeoAIGhAVA0iuwYqnH7VpbsCESkEiw+RAVwcXFB6+7NZMdQDRdX3hiXiGyDxYeoEB7e7rIjqEaDJ2rLjkBEKsHiQ1SI3Sv3yo6gCopGQfTs12THICKVYPEhKsCVU3HIzuQp1qXN1c0VU36ahNAaFWRHISKV4B0YiQpw83qq7AhOTeOqweBpffDciKeh0fD/X0RkOyw+RAUIrx8mO4JTC6wYgB4jn5Edg4hUiP/VIiqAPsAH5auHyI7htF54u7vsCESkUiw+RIV4f/U42RGcVq0W1WVHICKVYvEhKkR43UooX417fUrDnzuOy45ARCrF4kN0H7x6c+kIqOAvOwIRqRSLD9F91GxaTXYEp9SudyvZEYhIpVh8iO5j8PQ+siM4HUWj8BR2IpKGv32I7sM/pAzqtK4hO4ZTEWYhOwIRqRiLD9EDfLxpouwITkVROG6KiORh8SF6AC+9F5p3aSw7htN4rEkV2RGISMVYfIiK4IN1b8O3rI/sGE5hzHfDZEcgIhVj8SEqAhcXF3Qb1kl2DMemAO8sfQvhdSvJTkJEKsbiQ1REnQa2lx3B4Xj6eiCoUll0H/E0fspciidfbCM7EhGpHG9SSlREQaFlEdW/HbYu3CU7isNYcyMGLi4usmMQEVlwjw9RMYz+dii6Du0oO4ZD0Oq0LD1EZHdYfIiKQaPRYMRXg7DmZgy0Ou4wvZ9yVYJkRyAiyofFh+gh+Ph5Y/n1BSw/9xHV/0nZEYiI8mHxIXpIPn7emLZ9suwYdsndS4ceo5+RHYOIKB8WH6JHULd1TejL+sqOYVc8vN3x9cFPOb6HiOwS99MTPaK83DzZEeyCi6sGQ2cNQNehHXkTUiKyWw7328lkMqFhw4ZQFAVHjhyxeu7YsWNo27Yt3N3dERoaimnTpskJSaripfeUHcEujP+/4egW3Ymlh4jsmsP9hnr77bdRvnz5fNONRiM6duyIsLAwHDp0CNOnT8f777+Pb775RkJKUpPOr3eQHUG650c9w4sTEpFDcKjis3nzZvz888+YMWNGvueWLFmC7OxsfP/996hTpw5efPFFjBgxAp999pmEpKQmvd9+Ft5lvGTHsDlFUVCnVQ0sOP4Zhs7sJzsOEVGROEzxSUxMxKBBg7B48WJ4euY/tBAbG4vHH38cbm5ulmlRUVE4ffo0UlNTC1ymyWSC0Wi0+iEqLq1Wi+9PfoGQcHVdt2Z27Mf4fM9HqFwnVHYUIqIic4jiI4RA//79MWTIEDRp0qTAeRISEhAcHGw17e7jhISEAl8zdepU6PV6y09oKH+B08MpE6TH4vNf4asDn8IvyPnP8hryWT/UbFZddgwiomKTWnwmTJgARVHu+3Pq1CnMmTMH6enpmDhxYomuf+LEiTAYDJafq1evlujySX0ei6iCFde/Re9xz8LT18My/d4/OyIvP0+UCfZDq25NsejcHPQYyWv0EJFjUoQQQtbKk5OTcePGjfvOU6VKFfTu3RsbN26EoiiW6Xl5eXBxccErr7yCRYsWoW/fvjAajVi3bp1lnp07d6J9+/a4efMmypQp88A8RqMRer0eBoMBvr7O/792Kn1msxnAnVtdrJi+HgvG/yA5UfGEhAfhy/1ToQ/gvwcisl/F+f6WWnyK6sqVK1bjb+Lj4xEVFYVVq1ahefPmqFixIubOnYtJkyYhMTERWq0WAPDOO+9gzZo1OHXqVJHWw+JDpe30wfNY8PZi/LX3NHKzc2XHKVBozfLo2L8dug6JgpcvT9UnIvvndMXnny5duoTw8HD8+eefaNiwIQDAYDCgRo0a6NixI8aPH48TJ07gtddew6xZszB48OAiLZfFh2zlliEDz5XpLzuGFRdXDf69YQKadmokOwoRUbEU5/vbaa7crNfr8fPPPyM6OhoREREoW7Ys3nvvvSKXHiJb8tZ7wdPHA7fTM2VHgYurC8bFDEP7l9taHU4mInJGDrnHp7Rwjw/Z0vf/+hE/TllT6PMaFwUxp77A9QtJOH/0Mr6buATmPHORl68owLurx2LuWzFIvlr4WLqPf5qIZp0aFys7EZE9cfpDXaWFxYds7Z2np+DAlj/zTVc0Ct5fOw6tuja1TMvNycWPn6zFnztOwMVFgyr1wxC78QCuX0jK9/omUQ3xxoy+qFwnFGazGR/0mIG96w9YzePupcP4xSPQpnuzkn9jREQ2xOLzkFh8SIbf1+3HosnLkXApCa5aF0Q81QBvzOiLshUCHvhaIQT+2nsaSVdSoHVzRYXq5VC2oj98/X3yzZt124TN326HISUdtVvWQLPOHMtDRM6BxechsfgQERE5nuJ8fzvElZuJiIiISgKLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYar7AD25O7dO4xGo+QkREREVFR3v7eLchcuFp97pKenAwBCQ0MlJyEiIqLiSk9Ph16vv+88vEnpPcxmM+Lj4+Hj4wNFUWTHsTAajQgNDcXVq1d589QSwO1Zsrg9Sxa3Z8ni9ixZ9ro9hRBIT09H+fLlodHcfxQP9/jcQ6PRoGLFirJjFMrX19euPmiOjtuzZHF7lixuz5LF7Vmy7HF7PmhPz10c3ExERESqweJDREREqsHi4wB0Oh0mT54MnU4nO4pT4PYsWdyeJYvbs2Rxe5YsZ9ieHNxMREREqsE9PkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD4OwmQyoWHDhlAUBUeOHLF67tixY2jbti3c3d0RGhqKadOmyQlp5y5duoSBAwciPDwcHh4eqFq1KiZPnozs7Gyr+bg9i+6rr75C5cqV4e7ujubNm2P//v2yIzmEqVOnomnTpvDx8UFQUBC6d++O06dPW82TlZWF6OhoBAQEwNvbGz169EBiYqKkxI7lk08+gaIoGDlypGUat2fxxMXF4dVXX0VAQAA8PDxQr149HDx40PK8EALvvfceypUrBw8PD0RGRuLs2bMSExcdi4+DePvtt1G+fPl8041GIzp27IiwsDAcOnQI06dPx/vvv49vvvlGQkr7durUKZjNZsyfPx9//fUXZs2ahXnz5uGdd96xzMPtWXTLly/H6NGjMXnyZBw+fBgNGjRAVFQUkpKSZEeze7t370Z0dDT++OMPbNu2DTk5OejYsSMyMjIs84waNQobN27EypUrsXv3bsTHx+P555+XmNoxHDhwAPPnz0f9+vWtpnN7Fl1qaipat24NrVaLzZs34++//8bMmTNRpkwZyzzTpk3D7NmzMW/ePOzbtw9eXl6IiopCVlaWxORFJMju/fTTT6JmzZrir7/+EgDEn3/+aXnu66+/FmXKlBEmk8kybfz48aJGjRoSkjqeadOmifDwcMtjbs+ia9asmYiOjrY8zsvLE+XLlxdTp06VmMoxJSUlCQBi9+7dQggh0tLShFarFStXrrTMc/LkSQFAxMbGyopp99LT00X16tXFtm3bxBNPPCHeeustIQS3Z3GNHz9etGnTptDnzWazCAkJEdOnT7dMS0tLEzqdTvz444+2iPhIuMfHziUmJmLQoEFYvHgxPD098z0fGxuLxx9/HG5ubpZpUVFROH36NFJTU20Z1SEZDAb4+/tbHnN7Fk12djYOHTqEyMhIyzSNRoPIyEjExsZKTOaYDAYDAFg+i4cOHUJOTo7V9q1ZsyYqVarE7Xsf0dHR6NKli9V2A7g9i2vDhg1o0qQJevXqhaCgIDRq1AgLFiywPH/x4kUkJCRYbU+9Xo/mzZs7xPZk8bFjQgj0798fQ4YMQZMmTQqcJyEhAcHBwVbT7j5OSEgo9YyO7Ny5c5gzZw7eeOMNyzRuz6JJSUlBXl5egduK26l4zGYzRo4cidatW6Nu3boA7nzW3Nzc4OfnZzUvt2/hli1bhsOHD2Pq1Kn5nuP2LJ4LFy5g7ty5qF69OrZu3YqhQ4dixIgRWLRoEYD//S501H//LD4STJgwAYqi3Pfn1KlTmDNnDtLT0zFx4kTZke1aUbfnveLi4tCpUyf06tULgwYNkpSc6M5eihMnTmDZsmWyozisq1ev4q233sKSJUvg7u4uO47DM5vNaNy4MaZMmYJGjRph8ODBGDRoEObNmyc7WolwlR1AjcaMGYP+/fvfd54qVargl19+QWxsbL57ojRp0gSvvPIKFi1ahJCQkHxnJtx9HBISUqK57VVRt+dd8fHxePLJJ9GqVat8g5a5PYumbNmycHFxKXBbcTsV3ZtvvolNmzbh119/RcWKFS3TQ0JCkJ2djbS0NKu9FNy+BTt06BCSkpLQuHFjy7S8vDz8+uuv+PLLL7F161Zuz2IoV64cateubTWtVq1aWL16NYD//S5MTExEuXLlLPMkJiaiYcOGNsv5sFh8JAgMDERgYOAD55s9ezY++ugjy+P4+HhERUVh+fLlaN68OQCgZcuWmDRpEnJycqDVagEA27ZtQ40aNaxG4Duzom5P4M6enieffBIRERGIiYmBRmO905Pbs2jc3NwQERGBHTt2oHv37gDu/C9xx44dePPNN+WGcwBCCAwfPhxr167Frl27EB4ebvV8REQEtFotduzYgR49egAATp8+jStXrqBly5YyItu1Dh064Pjx41bTBgwYgJo1a2L8+PEIDQ3l9iyG1q1b57u8wpkzZxAWFgYACA8PR0hICHbs2GEpOkajEfv27cPQoUNtHbf4ZI+upqK7ePFivrO60tLSRHBwsOjTp484ceKEWLZsmfD09BTz58+XF9ROXbt2TVSrVk106NBBXLt2TVy/ft3ycxe3Z9EtW7ZM6HQ6sXDhQvH333+LwYMHCz8/P5GQkCA7mt0bOnSo0Ov1YteuXVafw9u3b1vmGTJkiKhUqZL45ZdfxMGDB0XLli1Fy5YtJaZ2LPee1SUEt2dx7N+/X7i6uoqPP/5YnD17VixZskR4enqKH374wTLPJ598Ivz8/MT69evFsWPHRLdu3UR4eLjIzMyUmLxoWHwcSEHFRwghjh49Ktq0aSN0Op2oUKGC+OSTT+QEtHMxMTECQIE/9+L2LLo5c+aISpUqCTc3N9GsWTPxxx9/yI7kEAr7HMbExFjmyczMFMOGDRNlypQRnp6e4rnnnrMq6XR//yw+3J7Fs3HjRlG3bl2h0+lEzZo1xTfffGP1vNlsFu+++64IDg4WOp1OdOjQQZw+fVpS2uJRhBBCxp4mIiIiIlvjWV1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+ROTUkpOTERISgilTplim7d27F25ubtixY4fEZEQkA+/VRURO76effkL37t2xd+9e1KhRAw0bNkS3bt3w2WefyY5GRDbG4kNEqhAdHY3t27ejSZMmOH78OA4cOACdTic7FhHZGIsPEalCZmYm6tati6tXr+LQoUOoV6+e7EhEJAHH+BCRKpw/fx7x8fEwm824dOmS7DhEJAn3+BCR08vOzkazZs3QsGFD1KhRA59//jmOHz+OoKAg2dGIyMZYfIjI6Y0bNw6rVq3C0aNH4e3tjSeeeAJ6vR6bNm2SHY2IbIyHuojIqe3atQuff/45Fi9eDF9fX2g0GixevBi//fYb5s6dKzseEdkY9/gQERGRanCPDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqcb/AzJ0sogSJIg/AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for emb, title in zip(\n",
+ " [embedding_intelex, embedding_original],\n",
+ " [\"Intel® Extension for scikit-learn\", \"Original scikit-learn\"],\n",
+ "):\n",
+ " plt.scatter(emb[:, 0], emb[:, 1], c=colors)\n",
+ " plt.title(title)\n",
+ " plt.xlabel(\"x\")\n",
+ " plt.ylabel(\"y\")\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Speedup for this run: 3.0'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Speedup for this run: {(time_original/time_opt):.1f}\""
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png
new file mode 100644
index 0000000000..6c7d082563
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png
new file mode 100644
index 0000000000..cc9df20282
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png
new file mode 100644
index 0000000000..5e5d8b1d1a
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png
new file mode 100644
index 0000000000..e79ca5011f
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png
new file mode 100644
index 0000000000..b7c37519c2
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png
new file mode 100644
index 0000000000..87ce1f07e7
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png
new file mode 100644
index 0000000000..0a059e8d7f
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_tsne_15_0.png b/2024.3/.doctrees/nbsphinx/samples_tsne_15_0.png
new file mode 100644
index 0000000000..5a1138f6bc
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_tsne_15_0.png differ
diff --git a/2024.3/.doctrees/nbsphinx/samples_tsne_15_1.png b/2024.3/.doctrees/nbsphinx/samples_tsne_15_1.png
new file mode 100644
index 0000000000..49b9be9ae0
Binary files /dev/null and b/2024.3/.doctrees/nbsphinx/samples_tsne_15_1.png differ
diff --git a/2024.3/.doctrees/oneapi-gpu.doctree b/2024.3/.doctrees/oneapi-gpu.doctree
new file mode 100644
index 0000000000..fb09d760c3
Binary files /dev/null and b/2024.3/.doctrees/oneapi-gpu.doctree differ
diff --git a/2024.3/.doctrees/quick-start.doctree b/2024.3/.doctrees/quick-start.doctree
new file mode 100644
index 0000000000..f6d1208b06
Binary files /dev/null and b/2024.3/.doctrees/quick-start.doctree differ
diff --git a/2024.3/.doctrees/samples.doctree b/2024.3/.doctrees/samples.doctree
new file mode 100644
index 0000000000..bb331853dd
Binary files /dev/null and b/2024.3/.doctrees/samples.doctree differ
diff --git a/2024.3/.doctrees/samples/ElasticNet.doctree b/2024.3/.doctrees/samples/ElasticNet.doctree
new file mode 100644
index 0000000000..bc92181ca1
Binary files /dev/null and b/2024.3/.doctrees/samples/ElasticNet.doctree differ
diff --git a/2024.3/.doctrees/samples/daal4py_data_science.doctree b/2024.3/.doctrees/samples/daal4py_data_science.doctree
new file mode 100644
index 0000000000..f718d885a2
Binary files /dev/null and b/2024.3/.doctrees/samples/daal4py_data_science.doctree differ
diff --git a/2024.3/.doctrees/samples/dbscan.doctree b/2024.3/.doctrees/samples/dbscan.doctree
new file mode 100644
index 0000000000..64599e85f8
Binary files /dev/null and b/2024.3/.doctrees/samples/dbscan.doctree differ
diff --git a/2024.3/.doctrees/samples/kmeans.doctree b/2024.3/.doctrees/samples/kmeans.doctree
new file mode 100644
index 0000000000..72a91f679c
Binary files /dev/null and b/2024.3/.doctrees/samples/kmeans.doctree differ
diff --git a/2024.3/.doctrees/samples/knn_mnist.doctree b/2024.3/.doctrees/samples/knn_mnist.doctree
new file mode 100644
index 0000000000..4f73c944ae
Binary files /dev/null and b/2024.3/.doctrees/samples/knn_mnist.doctree differ
diff --git a/2024.3/.doctrees/samples/lasso_regression.doctree b/2024.3/.doctrees/samples/lasso_regression.doctree
new file mode 100644
index 0000000000..21ac8839cf
Binary files /dev/null and b/2024.3/.doctrees/samples/lasso_regression.doctree differ
diff --git a/2024.3/.doctrees/samples/linear_regression.doctree b/2024.3/.doctrees/samples/linear_regression.doctree
new file mode 100644
index 0000000000..8d69bc0286
Binary files /dev/null and b/2024.3/.doctrees/samples/linear_regression.doctree differ
diff --git a/2024.3/.doctrees/samples/logistictic_regression_cifar.doctree b/2024.3/.doctrees/samples/logistictic_regression_cifar.doctree
new file mode 100644
index 0000000000..3080b9dd57
Binary files /dev/null and b/2024.3/.doctrees/samples/logistictic_regression_cifar.doctree differ
diff --git a/2024.3/.doctrees/samples/nusvr_medical_charges.doctree b/2024.3/.doctrees/samples/nusvr_medical_charges.doctree
new file mode 100644
index 0000000000..f3fb8d6737
Binary files /dev/null and b/2024.3/.doctrees/samples/nusvr_medical_charges.doctree differ
diff --git a/2024.3/.doctrees/samples/random_forest_yolanda.doctree b/2024.3/.doctrees/samples/random_forest_yolanda.doctree
new file mode 100644
index 0000000000..908600b90b
Binary files /dev/null and b/2024.3/.doctrees/samples/random_forest_yolanda.doctree differ
diff --git a/2024.3/.doctrees/samples/ridge_regression.doctree b/2024.3/.doctrees/samples/ridge_regression.doctree
new file mode 100644
index 0000000000..07fe5f7f6f
Binary files /dev/null and b/2024.3/.doctrees/samples/ridge_regression.doctree differ
diff --git a/2024.3/.doctrees/samples/svc_adult.doctree b/2024.3/.doctrees/samples/svc_adult.doctree
new file mode 100644
index 0000000000..b10d8535f9
Binary files /dev/null and b/2024.3/.doctrees/samples/svc_adult.doctree differ
diff --git a/2024.3/.doctrees/samples/tsne.doctree b/2024.3/.doctrees/samples/tsne.doctree
new file mode 100644
index 0000000000..573b22463c
Binary files /dev/null and b/2024.3/.doctrees/samples/tsne.doctree differ
diff --git a/2024.3/.doctrees/support.doctree b/2024.3/.doctrees/support.doctree
new file mode 100644
index 0000000000..bafbc90007
Binary files /dev/null and b/2024.3/.doctrees/support.doctree differ
diff --git a/2024.3/.doctrees/tutorials.doctree b/2024.3/.doctrees/tutorials.doctree
new file mode 100644
index 0000000000..3940ae9bc7
Binary files /dev/null and b/2024.3/.doctrees/tutorials.doctree differ
diff --git a/2024.3/.doctrees/verbose.doctree b/2024.3/.doctrees/verbose.doctree
new file mode 100644
index 0000000000..ae981f67c4
Binary files /dev/null and b/2024.3/.doctrees/verbose.doctree differ
diff --git a/2024.3/.nojekyll b/2024.3/.nojekyll
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/2024.3/404.html b/2024.3/404.html
new file mode 100644
index 0000000000..1201f8c8f8
--- /dev/null
+++ b/2024.3/404.html
@@ -0,0 +1,395 @@
+
+
+
+
+
+
+ Page not found — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Page not found
+Unfortunately, we could not find the page you were looking for. Try:
+
+using search to browse documentation
+checking the table of contents on the left
+filing an issue or
+starting a discussion on GitHub
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/_images/samples_daal4py_data_science_24_0.png b/2024.3/_images/samples_daal4py_data_science_24_0.png
new file mode 100644
index 0000000000..6c7d082563
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_24_0.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_0.png b/2024.3/_images/samples_daal4py_data_science_7_0.png
new file mode 100644
index 0000000000..cc9df20282
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_0.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_1.png b/2024.3/_images/samples_daal4py_data_science_7_1.png
new file mode 100644
index 0000000000..5e5d8b1d1a
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_1.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_2.png b/2024.3/_images/samples_daal4py_data_science_7_2.png
new file mode 100644
index 0000000000..e79ca5011f
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_2.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_3.png b/2024.3/_images/samples_daal4py_data_science_7_3.png
new file mode 100644
index 0000000000..b7c37519c2
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_3.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_4.png b/2024.3/_images/samples_daal4py_data_science_7_4.png
new file mode 100644
index 0000000000..87ce1f07e7
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_4.png differ
diff --git a/2024.3/_images/samples_daal4py_data_science_7_5.png b/2024.3/_images/samples_daal4py_data_science_7_5.png
new file mode 100644
index 0000000000..0a059e8d7f
Binary files /dev/null and b/2024.3/_images/samples_daal4py_data_science_7_5.png differ
diff --git a/2024.3/_images/samples_tsne_15_0.png b/2024.3/_images/samples_tsne_15_0.png
new file mode 100644
index 0000000000..5a1138f6bc
Binary files /dev/null and b/2024.3/_images/samples_tsne_15_0.png differ
diff --git a/2024.3/_images/samples_tsne_15_1.png b/2024.3/_images/samples_tsne_15_1.png
new file mode 100644
index 0000000000..49b9be9ae0
Binary files /dev/null and b/2024.3/_images/samples_tsne_15_1.png differ
diff --git a/2024.3/_images/scikit-learn-acceleration.PNG b/2024.3/_images/scikit-learn-acceleration.PNG
new file mode 100644
index 0000000000..d045478f39
Binary files /dev/null and b/2024.3/_images/scikit-learn-acceleration.PNG differ
diff --git a/2024.3/_sources/404.rst.txt b/2024.3/_sources/404.rst.txt
new file mode 100644
index 0000000000..3060a3f9cc
--- /dev/null
+++ b/2024.3/_sources/404.rst.txt
@@ -0,0 +1,28 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+:orphan:
+:nosearch:
+
+Page not found
+==============
+
+Unfortunately, we could not find the page you were looking for. Try:
+
+- using :ref:`search ` to browse documentation
+- checking the table of contents on the left
+- filing an `issue `_ or
+ starting a `discussion `_ on GitHub
\ No newline at end of file
diff --git a/2024.3/_sources/algorithms.rst.txt b/2024.3/_sources/algorithms.rst.txt
new file mode 100644
index 0000000000..67f9e3b240
--- /dev/null
+++ b/2024.3/_sources/algorithms.rst.txt
@@ -0,0 +1,373 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _sklearn_algorithms:
+
+####################
+Supported Algorithms
+####################
+
+Applying |intelex| impacts the following scikit-learn algorithms:
+
+on CPU
+------
+
+Classification
+**************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVC`
+ - All parameters are supported
+ - No limitations
+ * - `NuSVC`
+ - All parameters are supported
+ - No limitations
+ * - `RandomForestClassifier`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'gini'`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsClassifier`
+ -
+ - For ``algorithm`` == `'kd_tree'`:
+
+ all parameters except ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - For ``algorithm`` == `'brute'`:
+
+ all parameters except ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Multi-output and sparse data are not supported
+ * - `LogisticRegression`
+ - All parameters are supported except:
+
+ - ``solver`` not in [`'lbfgs'`, `'newton-cg'`]
+ - ``class_weight`` != `None`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported
+
+Regression
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVR`
+ - All parameters are supported
+ - No limitations
+ * - `NuSVR`
+ - All parameters are supported
+ - No limitations
+ * - `RandomForestRegressor`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'mse'`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsRegressor`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - Multi-output and sparse data are not supported
+ * - `LinearRegression`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+ * - `Ridge`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``solver`` != `'auto'`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+ * - `ElasticNet`
+ - All parameters are supported except:
+
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported, `#observations` should be >= `#features`.
+ * - `Lasso`
+ - All parameters are supported except:
+
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported, `#observations` should be >= `#features`.
+
+Clustering
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `KMeans`
+ - All parameters are supported except:
+
+ - ``precompute_distances``
+ - ``sample_weight`` != `None`
+ - No limitations
+ * - `DBSCAN`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - ``algorithm`` not in [`'brute'`, `'auto'`]
+ - Only dense data is supported
+
+Dimensionality reduction
+************************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `PCA`
+ - All parameters are supported except:
+
+ - ``svd_solver`` != `'full'`
+ - Sparse data is not supported
+ * - `TSNE`
+ - All parameters are supported except:
+
+ - ``metric`` != 'euclidean' or `'minkowski'` with ``p`` != `2`
+
+ Refer to :ref:`TSNE acceleration details ` to learn more.
+ - Sparse data is not supported
+
+Nearest Neighbors
+*****************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `NearestNeighbors`
+ -
+ - For ``algorithm`` == 'kd_tree':
+
+ all parameters except ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - For ``algorithm`` == 'brute':
+
+ all parameters except ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Sparse data is not supported
+
+Other tasks
+***********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `train_test_split`
+ - All parameters are supported
+ - Only dense data is supported
+ * - `assert_all_finite`
+ - All parameters are supported
+ - Only dense data is supported
+ * - `pairwise_distance`
+ - All parameters are supported except:
+
+ - ``metric`` not in [`'cosine'`, `'correlation'`]
+ - Only dense data is supported
+ * - `roc_auc_score`
+ - All parameters are supported except:
+
+ - ``average`` != `None`
+ - ``sample_weight`` != `None`
+ - ``max_fpr`` != `None`
+ - ``multi_class`` != `None`
+ - No limitations
+
+on GPU
+------
+
+.. seealso:: :ref:`oneapi_gpu`
+
+Classification
+**************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVC`
+ - All parameters are supported except:
+
+ - ``kernel`` = `'sigmoid_poly'`
+ - ``class_weight`` != `None`
+ - Only binary dense data is supported
+ * - `RandomForestClassifier`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'gini'`
+ - ``oob_score`` = `True`
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsClassifier`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Only dense data is supported
+ * - `LogisticRegression`
+ - All parameters are supported except:
+
+ - ``solver`` != `'newton-cg'`
+ - ``class_weight`` != `None`
+ - ``sample_weight`` != `None`
+ - ``penalty`` != `'l2'`
+ - Only dense data is supported
+
+Regression
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `RandomForestRegressor`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'mse'`
+ - ``oob_score`` = `True`
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsRegressor`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - Only dense data is supported
+ * - `LinearRegression`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+
+Clustering
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `KMeans`
+ - All parameters are supported except:
+
+ - ``precompute_distances``
+ - ``sample_weight`` != `None`
+
+ ``Init`` = `'k-means++'` fallbacks to CPU.
+ - Sparse data is not supported
+ * - `DBSCAN`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'`
+ - ``algorithm`` not in [`'brute'`, `'auto'`]
+ - Only dense data is supported
+
+Dimensionality reduction
+************************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `PCA`
+ - All parameters are supported except:
+
+ - ``svd_solver`` != `'full'`
+ - Sparse data is not supported
+
+Nearest Neighbors
+*****************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `NearestNeighbors`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Only dense data is supported
+
+Scikit-learn tests
+------------------
+
+Monkey-patched scikit-learn classes and functions passes scikit-learn's own test
+suite, with few exceptions, specified in `deselected_tests.yaml
+`__.
+
+The results of the entire latest scikit-learn test suite with |intelex|: `CircleCI
+`_.
\ No newline at end of file
diff --git a/2024.3/_sources/blogs.rst.txt b/2024.3/_sources/blogs.rst.txt
new file mode 100644
index 0000000000..2d9b0024e5
--- /dev/null
+++ b/2024.3/_sources/blogs.rst.txt
@@ -0,0 +1,35 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _blogs:
+
+Follow us on Medium
+--------------------
+We publish blogs on Medium, so `follow us `_
+to learn tips and tricks for more efficient data analysis the help of |intelex|.
+Here are our latest blogs:
+
+- `Save Time and Money with Intel Extension for Scikit-learn `_,
+- `Superior Machine Learning Performance on the Latest Intel Xeon Scalable Processors `_,
+- `Leverage Intel Optimizations in Scikit-Learn `_,
+- `Intel Gives Scikit-Learn the Performance Boost Data Scientists Need `_,
+- `From Hours to Minutes: 600x Faster SVM `_,
+- `Improve the Performance of XGBoost and LightGBM Inference `_,
+- `Accelerate Kaggle Challenges Using Intel AI Analytics Toolkit `_,
+- `Accelerate Your scikit-learn Applications `_,
+- `Accelerate Linear Models for Machine Learning `_,
+- `Accelerate K-Means Clustering `_.
+- `Why Pay More for Machine Learning? `_.
diff --git a/2024.3/_sources/contribute.rst.txt b/2024.3/_sources/contribute.rst.txt
new file mode 100644
index 0000000000..28283bd9d8
--- /dev/null
+++ b/2024.3/_sources/contribute.rst.txt
@@ -0,0 +1,64 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+##################
+How to Contribute
+##################
+
+As an open source project, we welcome community contributions to Intel(R) Extension for Scikit-learn.
+This document explains how to participate in project conversations, log bugs and enhancement requests, and submit code patches.
+
+Licensing
+----------------------------------
+Intel(R) Extension for Scikit-learn uses the `Apache 2.0 License `_. By contributing to the project, you agree to the license and copyright terms and release your own contributions under these terms.
+
+Pull Requests
+----------------------------------
+No anonymous contributions are accepted. The name in the commit message Signed-off-by line and your email must match the change authorship information.
+
+Make sure your .gitconfig is set up correctly so you can use git commit -s for signing your patches:
+
+::
+
+ git config --global user.name "Kate Developer"
+ git config --global user.email kate.developer@company.com
+
+Before Contributing Changes
+********************************************
+
+Make sure you can build the product and run all the tests with your patch.
+For a larger feature, provide a relevant test.
+Document your code. Our project uses reStructuredText for documentation.
+For new file(s), specify the appropriate copyright year in the first line.
+Submit a pull request into the master branch.
+Continuous Integration (CI) testing is enabled for the repository. Your pull request must pass all checks before it can be merged. We will review your contribution and may provide feedback to guide you if any additional fixes or modifications are necessary. When reviewed and accepted, your pull request will be merged into our GitHub repository.
+
+Code Style
+-------------------
+
+We use `black `_ and `isort `_ formatters for Python* code.
+The line length is 90 characters; use default options otherwise. You can find the linter configuration in `.pyproject.toml `_.
+
+A GitHub* Action verifies if your changes comply with the output of the auto-formatting tools.
+
+Optionally, you can install pre-commit hooks that do the formatting for you. For this, run from the top level of the repository:
+
+::
+
+ pip install pre-commit
+ pre-commit install
+
+
diff --git a/2024.3/_sources/deprecation.rst.txt b/2024.3/_sources/deprecation.rst.txt
new file mode 100644
index 0000000000..5bc3f3fd19
--- /dev/null
+++ b/2024.3/_sources/deprecation.rst.txt
@@ -0,0 +1,30 @@
+.. ******************************************************************************
+.. * Copyright 2023 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+
+Deprecation Notice
+==================
+
+This page provides information about the deprecations of a specific |intelex| functionality.
+
+macOS* Support
+**************
+
+**Deprecation:** macOS* support is deprecated for |intelex|. The 2023.x releases are the last to provide it.
+
+**Reasons for deprecation:** No modern X86 macOS*-based systems are to be released.
+
+**Alternatives:** The 2023.x version on macOS*.
diff --git a/2024.3/_sources/distributed-mode.rst.txt b/2024.3/_sources/distributed-mode.rst.txt
new file mode 100644
index 0000000000..3b152b68a0
--- /dev/null
+++ b/2024.3/_sources/distributed-mode.rst.txt
@@ -0,0 +1,30 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _distributed:
+
+Distributed Mode
+================
+
+.. note::
+
+ |intelex| contains scikit-learn patching functionality that was originally available in
+ `daal4py `_ package.
+ We recommend you to use scikit-learn-intelex package instead of daal4py.
+ You can learn more about daal4py in `daal4py documentation `_.
+
+While daal4py is available in `distribued mode `_,
+|intelex| does not currently offer this functionality.
diff --git a/2024.3/_sources/guide/acceleration.rst.txt b/2024.3/_sources/guide/acceleration.rst.txt
new file mode 100644
index 0000000000..952ee73539
--- /dev/null
+++ b/2024.3/_sources/guide/acceleration.rst.txt
@@ -0,0 +1,86 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+########################
+Tuning Guide
+########################
+
+The performance of some algorithms changes based on the parameters that are used.
+This section denotes the details of such cases.
+
+Refer to :ref:`sklearn_algorithms` to see the full list of algorithms, parameters, and data formats supported in |intelex|.
+
+.. _acceleration_tsne:
+
+TSNE
+----
+
+TSNE algorithm consists of two components: KNN and Gradient Descent.
+The overall acceleration of TSNE depends on the acceleration of each of these algorithms.
+
+- The KNN part of the algorithm supports all parameters except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+- The Gradient Descent part of the algorithm supports all parameters except:
+
+ - ``n_components`` = `3`
+ - ``method`` = `'exact'`
+ - ``verbose`` != `0`
+
+To get better performance, use parameters supported by both components.
+
+.. _acceleration_rf:
+
+Random Forest
+-------------
+
+Random Forest models accelerated with |intelex| and using the `hist` splitting
+method discretize training data by creating a histogram with a configurable
+number of bins. The following keyword arguments can be used to influence the
+created histogram.
+
+.. list-table::
+ :widths: 10 10 10 30
+ :header-rows: 1
+ :align: left
+
+ * - Keyword argument
+ - Possible values
+ - Default value
+ - Description
+ * - ``maxBins``
+ - `[0, inf)`
+ - ``256``
+ - Number of bins in the histogram with the discretized training data. The
+ value ``0`` disables data discretization.
+ * - ``minBinSize``
+ - `[1, inf)`
+ - ``5``
+ - Minimum number of training data points in each bin after discretization.
+ * - ``binningStrategy``
+ - ``quantiles, averages``
+ - ``quantiles``
+ - Selects the algorithm used to calculate bin edges. ``quantiles``
+ results in bins with a similar amount of training data points. ``averages``
+ divides the range of values observed in the training data set into
+ equal-width bins of size `(max - min) / maxBins`.
+
+Note that using discretized training data can greatly accelerate model training
+times, especially for larger data sets. However, due to the reduced fidelity of
+the data, the resulting model can present worse performance metrics compared to
+a model trained on the original data. In such cases, the number of bins can be
+increased with the ``maxBins`` parameter, or binning can be disabled entirely by
+setting ``maxBins=0``.
diff --git a/2024.3/_sources/index.rst.txt b/2024.3/_sources/index.rst.txt
new file mode 100644
index 0000000000..62055385c8
--- /dev/null
+++ b/2024.3/_sources/index.rst.txt
@@ -0,0 +1,134 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |intelex_repo| replace:: |intelex| repository
+.. _intelex_repo: https://github.com/intel/scikit-learn-intelex
+
+.. _index:
+
+#########
+|intelex|
+#########
+
+Intel(R) Extension for Scikit-learn is a **free software AI accelerator** designed to deliver up to **100X** faster performance for your existing scikit-learn code.
+The software acceleration is achieved with vector instructions, AI hardware-specific memory optimizations, threading, and optimizations for all upcoming Intel(R) platforms at launch time.
+
+.. rubric:: Designed for Data Scientists and Framework Designers
+
+
+Use Intel(R) Extension for Scikit-learn, to:
+
+* Speed up training and inference by up to 100x with the equivalent mathematical accuracy
+* Benefit from performance improvements across different x86-compatible CPUs or Intel(R) GPUs
+* Integrate the extension into your existing Scikit-learn applications without code modifications
+* Enable and disable the extension with a couple of lines of code or at the command line
+
+Intel(R) Extension for Scikit-learn is also a part of `Intel(R) AI Tools `_.
+
+
+.. image:: _static/scikit-learn-acceleration.PNG
+ :width: 800
+
+
+These performance charts use benchmarks that you can find in the `scikit-learn bench repository `_.
+
+
+Supported Algorithms
+---------------------
+
+See all of the :ref:`sklearn_algorithms`.
+
+
+Intel(R) Optimizations
+----------------------------------
+
+Enable Intel(R) CPU Optimizations
+*********************************
+
+::
+
+ import numpy as np
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+Enable Intel(R) GPU optimizations
+*********************************
+::
+
+ import numpy as np
+ import dpctl
+ from sklearnex import patch_sklearn, config_context
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ with config_context(target_offload="gpu:0"):
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+
+
+.. toctree::
+ :caption: Get Started
+ :hidden:
+ :maxdepth: 3
+
+ quick-start.rst
+ samples.rst
+ kaggle.rst
+
+.. toctree::
+ :caption: Developer Guide
+ :hidden:
+ :maxdepth: 2
+
+ algorithms.rst
+ oneAPI and GPU support
+ distributed-mode.rst
+ verbose.rst
+ deprecation.rst
+
+
+.. toctree::
+ :caption: Performance
+ :hidden:
+ :maxdepth: 2
+
+ guide/acceleration.rst
+
+.. toctree::
+ :caption: Learn
+ :hidden:
+ :maxdepth: 2
+
+ Tutorials & Case Studies
+ Medium Blogs
+
+.. toctree::
+ :caption: More
+ :hidden:
+ :maxdepth: 2
+
+ Support
+ contribute.rst
+ license.rst
diff --git a/2024.3/_sources/kaggle.rst.txt b/2024.3/_sources/kaggle.rst.txt
new file mode 100644
index 0000000000..364ab723d1
--- /dev/null
+++ b/2024.3/_sources/kaggle.rst.txt
@@ -0,0 +1,49 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _kaggle:
+
+####################
+Kaggle Kernels
+####################
+
+See Kaggle notebooks created by |intelex| developers.
+
+Acceleration
+---------------------------------
+
+`Introduction to scikit-learn-intelex `_
+provides a summary of the speedup you can achieve with |intelex|.
+
+Machine Learning Workflows
+---------------------------------
+
+Browse this chapter to find Kaggle kernels that use scikit-learn-intelex for a specific type of a machine learning task.
+
+Kaggle kernels that use scikit-learn and |intelex|:
+******************************************************************
+
+.. toctree::
+
+ Classification Tasks
+ Regression Tasks
+
+Kaggle kernels that use AutoML with |intelex|:
+******************************************************************
+
+.. toctree::
+
+ AutoML Workflows
diff --git a/2024.3/_sources/kaggle/automl.rst.txt b/2024.3/_sources/kaggle/automl.rst.txt
new file mode 100644
index 0000000000..0156e5ec89
--- /dev/null
+++ b/2024.3/_sources/kaggle/automl.rst.txt
@@ -0,0 +1,66 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |automl_with_intelex_jun| replace:: AutoML MultiClass Classification (Gradient Boosting, Random Forest, kNN) using AutoGluon with |intelex|
+.. _automl_with_intelex_jun: https://www.kaggle.com/alex97andreev/tps-jun-autogluon-with-sklearnex
+
+.. |automl_with_intelex_tps_oct| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest) using AutoGluon with |intelex|
+.. _automl_with_intelex_tps_oct: https://www.kaggle.com/lordozvlad/fast-automl-with-intel-extension-for-scikit-learn/notebook
+
+.. |automl_with_intelex_tps_nov| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest, kNN) using EvalML and AutoGluon with |intelex|
+.. _automl_with_intelex_tps_nov: https://www.kaggle.com/lordozvlad/tps-nov-automl-with-intel-extension
+
+.. |automl_with_intelex_titanic| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest, kNN) using AutoGluon with |intelex|
+.. _automl_with_intelex_titanic: https://www.kaggle.com/lordozvlad/titanic-automl-with-intel-extension-for-sklearn/notebook
+
+.. |automl_with_intelex_tps_jan| replace:: AutoML Binary Classification (Random Forest, SVR, Blending) using PyCaret with |intelex|
+.. _automl_with_intelex_tps_jan: https://www.kaggle.com/code/lordozvlad/tps-jan-fast-pycaret-with-scikit-learn-intelex/notebook
+
+
+Kaggle Kernels that use AutoML and |intelex|
+--------------------------------------------
+
+The following Kaggle kernels show how to patch autoML frameworks with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 40 20
+
+ * - Kernel
+ - Goal
+ * - |automl_with_intelex_jun|_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ * - |automl_with_intelex_titanic|_
+
+ **Data:** Titanic datset
+ - Predict whether a passenger survivies
+ * - |automl_with_intelex_tps_oct|_
+
+ **Data:** [TPS Oct 2021] Synthetic molecular response data
+ - Predict the biological response of molecules given various chemical properties
+ * - |automl_with_intelex_tps_nov|_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+ - Identify spam emails via features extracted from the email
+ * - |automl_with_intelex_tps_jan|_
+
+ **Data:** [TPS Jan 2022] Fictional Sales data
+ - Predict the corresponding item sales for each date-country-store-item combination
\ No newline at end of file
diff --git a/2024.3/_sources/kaggle/classification.rst.txt b/2024.3/_sources/kaggle/classification.rst.txt
new file mode 100644
index 0000000000..5d7b94345f
--- /dev/null
+++ b/2024.3/_sources/kaggle/classification.rst.txt
@@ -0,0 +1,244 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+Kaggle Kernels for Classification Tasks
+***************************************
+
+The following Kaggle kernels show how to patch scikit-learn with |intelex| for various classification tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+Binary Classification
++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Logistic Regression for Binary Classification
+ `_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+
+ - Identify spam emails via features extracted from the email
+ -
+
+ - data preprocessing (normalization)
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Feature Importance in Random Forest for Binary Classification
+ `_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+
+ - Identify spam emails via features extracted from the email
+ -
+
+ - reducing DataFrame memory usage
+ - computing feature importance with ELI5 and the default scikit-learn permutation importance
+ - training using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - feature construction
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) with Feature Preprocessing for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - feature engineering
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+MultiClass Classification
++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Logistic Regression for MultiClass Classification with Quantile Transformer
+ `_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+
+ - data preprocessing with Quantile Transformer
+ - training and prediction using scikit-learn-intelex
+ - search for optimal paramters using Optuna
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for MultiClass Classification
+ `_
+
+ **Data:** [TPS May 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+
+ * - `Stacking Classifer with Logistic Regression, kNN, Random Forest, and Quantile Transformer
+ `_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+
+ - data preprocessing: one-hot encoding, dimensionality reduction with PCA, normalization
+ - creating a stacking classifier with logistic regression, kNN, and random forest,
+ and a pipeline of Quantile Transformer and another logistic regression as a final estimator
+ - searching for optimal parameters for the stacking classifier
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for MultiClass Classification
+ `_
+
+ **Data:** [TPS Dec 2021] Synthetic Forest Cover Type data
+ - Predict the forest cover type
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Feature Importance in Random Forest for MultiClass Classification
+ `_
+
+ **Data:** [TPS Dec 2021] Synthetic Forest Cover Type data
+
+ - Predict the forest cover type
+ -
+
+ - reducing DataFrame memory usage
+ - computing feature importance with ELI5
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `k-Nearest Neighbors (kNN) for MultiClass Classification
+ `_
+
+ **Data:** [TPS Feb 2022] Bacteria DNA
+ - Predict bacteria species based on repeated lossy measurements of DNA snippets
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Classification Tasks in Computer Vision
++++++++++++++++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Support Vector Classification (SVC) for MultiClass Classification (CV task)
+ `_
+
+ **Data:** Digit Recognizer (MNIST)
+ - Recognize hand-written digits
+ -
+
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `k-Nearest Neighbors (kNN) for MultiClass Classification (CV task)
+ `_
+
+ **Data:** Digit Recognizer (MNIST)
+ - Recognize hand-written digits
+ -
+
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Classification Tasks in Natural Language Processing
++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Support Vector Classification (SVC) for a Binary Classification (NLP task)
+ `_
+
+ **Data:** Natural Language Processing with Disaster Tweets
+ - Predict which tweets are about real disasters and which ones are not
+ -
+
+ - data preprocessing
+ - TF-IDF calculation
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `One-vs-Rest Support Vector Machine (SVM) with Text Data for MultiClass Classification
+ `_
+
+ **Data:** What's Cooking
+ - Use recipe ingredients to predict the cuisine
+ -
+
+ - feature extraction using TfidfVectorizer
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for Binary Classification with Sparse Data (NLP task)
+ `_
+
+ **Data:** Stack Overflow questions
+ - Predict the binary quality rating for Stack Overflow questions
+ -
+
+ - data preprocessing
+ - TF-IDF calculation
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
diff --git a/2024.3/_sources/kaggle/regression.rst.txt b/2024.3/_sources/kaggle/regression.rst.txt
new file mode 100644
index 0000000000..abdbebc15b
--- /dev/null
+++ b/2024.3/_sources/kaggle/regression.rst.txt
@@ -0,0 +1,156 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+Kaggle Kernels for Regression Tasks
+************************************
+
+The following Kaggle kernels show how to patch scikit-learn with |intelex| for various regression tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+Using a Single Regressor
+++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Baseline Nu Support Vector Regression (nuSVR) with RBF Kernel
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - data preprocessing
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ * - `Nu Support Vector Regression (nuSVR)
+ `__
+
+ **Data:** [TPS Aug 2021] Synthetic loan data
+ - Calculate loss associated with a loan defaults
+ -
+
+ - data preprocessing
+ - feature engineering
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Nu Support Vector Regression (nuSVR)
+ `__
+
+ **Data:** House Prices dataset
+ - Predict sale prices for a property based on its characteristics
+ -
+
+ - data preprocessing
+ - exploring outliers
+ - feature engineering
+ - filling missing values
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest Regression
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - checking correlation between features
+ - search for best paramters using GridSearchCV
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Random Forest Regression with Feature Engineering
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - data preprocessing
+ - feature engineering
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest Regression with Feature Importance Computation
+ `_
+
+ **Data:** [TPS Mar 2022] Spatio-temporal traffic data
+ - Forecast twelve-hours of traffic flow in a major U.S. metropolitan area
+ -
+
+ - feature engineering
+ - computing feature importance with ELI5
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Ridge Regression
+ `_
+
+
+ **Data:** [TPS Sep 2021] Synthetic insurance data
+ - Predict the probability of a customer making a claim upon an insurance policy
+ -
+
+ - data preprocessing
+ - filling missing values
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Stacking Regressors
++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Stacking Regressor with Random Fores, SVR, and LASSO
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - feature engineering
+ - creating a stacking regressor
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Stacking Regressor with ElasticNet, LASSO, and Ridge Regression for Time-series data
+ `_
+
+ **Data:** Predict Future Sales dataset
+ - Predict total sales for every product and store in the next month based on daily sales data
+ -
+
+ - data preprocessing
+ - creating a stacking regressor
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
diff --git a/2024.3/_sources/license.rst.txt b/2024.3/_sources/license.rst.txt
new file mode 100644
index 0000000000..df68abaea6
--- /dev/null
+++ b/2024.3/_sources/license.rst.txt
@@ -0,0 +1,23 @@
+.. ******************************************************************************
+.. * Copyright 2023 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _license:
+
+############################################
+License
+############################################
+
+License: https://github.com/intel/scikit-learn-intelex/blob/main/LICENSE
\ No newline at end of file
diff --git a/2024.3/_sources/oneapi-gpu.rst.txt b/2024.3/_sources/oneapi-gpu.rst.txt
new file mode 100644
index 0000000000..76a2a752f4
--- /dev/null
+++ b/2024.3/_sources/oneapi-gpu.rst.txt
@@ -0,0 +1,114 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _oneapi_gpu:
+
+##############################################################
+oneAPI and GPU support in |intelex|
+##############################################################
+
+|intelex| supports oneAPI concepts, which
+means that algorithms can be executed on different devices: CPUs and GPUs.
+This is done via integration with
+`dpctl `_ package that
+implements core oneAPI concepts like queues and devices.
+
+Prerequisites
+-------------
+
+For execution on GPU, DPC++ compiler runtime and driver are required. Refer to `DPC++ system
+requirements `_ for details.
+
+DPC++ compiler runtime can be installed either from PyPI or Anaconda:
+
+- Install from PyPI::
+
+ pip install dpcpp-cpp-rt
+
+- Install from Anaconda::
+
+ conda install dpcpp_cpp_rt -c intel
+
+Device offloading
+-----------------
+
+|intelex| offers two options for running an algorithm on a
+specific device with the help of dpctl:
+
+- Pass input data as `dpctl.tensor.usm_ndarray `_ to the algorithm.
+
+ The computation will run on the device where the input data is
+ located, and the result will be returned as :code:`usm_ndarray` to the same
+ device.
+
+ .. note::
+ All the input data for an algorithm must reside on the same device.
+
+ .. warning::
+ The :code:`usm_ndarray` can only be consumed by the base methods
+ like :code:`fit`, :code:`predict`, and :code:`transform`.
+ Note that only the algorithms in |intelex| support
+ :code:`usm_ndarray`. The algorithms from the stock version of scikit-learn
+ do not support this feature.
+- Use global configurations of |intelex|\*:
+
+ 1. The :code:`target_offload` option can be used to set the device primarily
+ used to perform computations. Accepted data types are :code:`str` and
+ :code:`dpctl.SyclQueue`. If you pass a string to :code:`target_offload`,
+ it should either be ``"auto"``, which means that the execution
+ context is deduced from the location of input data, or a string
+ with SYCL* filter selector. The default value is ``"auto"``.
+
+ 2. The :code:`allow_fallback_to_host` option
+ is a Boolean flag. If set to :code:`True`, the computation is allowed
+ to fallback to the host device when a particular estimator does not support
+ the selected device. The default value is :code:`False`.
+
+These options can be set using :code:`sklearnex.set_config()` function or
+:code:`sklearnex.config_context`. To obtain the current values of these options,
+call :code:`sklearnex.get_config()`.
+
+.. note::
+ Functions :code:`set_config`, :code:`get_config` and :code:`config_context`
+ are always patched after the :code:`sklearnex.patch_sklearn()` call.
+
+.. rubric:: Compatibility considerations
+
+For compatibility reasons, algorithms in |intelex| may be offloaded to the device using
+:code:`daal4py.oneapi.sycl_context`. However, it is recommended to use one of the options
+described above for device offloading instead of using :code:`sycl_context`.
+
+Example
+-------
+
+An example on how to patch your code with Intel CPU/GPU optimizations:
+
+.. code-block:: python
+
+ from sklearnex import patch_sklearn, config_context
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ with config_context(target_offload="gpu:0"):
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+
+.. note:: Current offloading behavior restricts fitting and inference of any models to be
+ in the same context or absence of context. For example, a model trained in the GPU context with
+ target_offload="gpu:0" throws an error if the inference is made outside the same GPU context.
diff --git a/2024.3/_sources/quick-start.rst.txt b/2024.3/_sources/quick-start.rst.txt
new file mode 100644
index 0000000000..4a486e0b5a
--- /dev/null
+++ b/2024.3/_sources/quick-start.rst.txt
@@ -0,0 +1,417 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |intelex_repo| replace:: |intelex| repository
+.. _intelex_repo: https://github.com/intel/scikit-learn-intelex
+
+####################
+Quick Start
+####################
+
+Get ready to elevate your scikit-learn code with |intelex| and experience the benefits of accelerated performance in just a few simple steps.
+
+Compatibility with Scikit-learn*
+---------------------------------
+
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn.
+
+Integrate |intelex|
+--------------------
+
+Patching
+**********************
+
+Once you install Intel*(R) Extension for Scikit-learn*, you replace algorithms that exist in the scikit-learn package with their optimized versions from the extension.
+This action is called ``patching``. This is not a permanent change so you can always undo the patching if necessary.
+
+To patch Intel® Extension for Scikit-learn, use one of these methods:
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Method
+ - Action
+ * - Use a flag in the command line
+ - Run this command:
+
+ ::
+
+ python -m sklearnex my_application.py
+ * - Modify your script
+ - Add the following lines:
+
+ ::
+
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+ * - Import an estimator from the ``sklearnex`` module
+ - Run this command:
+
+ ::
+
+ from sklearnex.neighbors import NearestNeighbors
+
+
+
+These patching methods are interchangeable.
+They support different enabling scenarios while producing the same result.
+
+
+**Example**
+
+This example shows how to patch Intel(R) extension for Scikit-Learn by modifing your script. To make sure that patching is registered by the scikit-learn estimators, always import scikit-learn after these lines.
+
+.. code-block:: python
+ :caption: Example: Drop-In Patching
+
+ import numpy as np
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+
+ # You need to re-import scikit-learn algorithms after the patch
+ from sklearn.cluster import KMeans
+
+ # The use of the original Scikit-learn is not changed
+ X = np.array([[1, 2], [1, 4], [1, 0],
+ [10, 2], [10, 4], [10, 0]])
+ kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
+ print(f"kmeans.labels_ = {kmeans.labels_}")
+
+
+Global Patching
+**********************
+
+You can also use global patching to patch all your scikit-learn applications without any additional actions.
+
+Before you begin, make sure that you have read and write permissions for Scikit-learn files.
+
+With global patching, you can:
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Task
+ - Action
+ - Note
+ * - Patch all supported algorithms
+ - Run this command:
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn
+
+ - If you run the global patching command several times with different parameters, then only the last configuration is applied.
+ * - Patch selected algorithms
+ - Use ``--algorithm`` or ``-a`` keys with a list of algorithms to patch. For example, to patch only ``SVC`` and ``RandomForestClassifier`` estimators, run
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier
+
+ -
+ * - Enable global patching via code
+ - Use the ``patch_sklearn`` function with the ``global_patch`` argument:
+
+ ::
+
+ from sklearnex import patch_sklearn
+ patch_sklearn(global_patch=True)
+ import sklearn
+
+ - After that, Scikit-learn patches is enabled in the current application and in all others that use the same environment.
+ * - Disable patching notifications
+ - Use ``--no-verbose`` or ``-nv`` keys:
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier -nv
+ -
+ * - Disable global patching
+ - Run this command:
+
+ ::
+
+ python -m sklearnex.glob unpatch_sklearn
+ -
+ * - Disable global patching via code
+ - Use the ``global_patch`` argument in the ``unpatch_sklearn`` function
+
+ ::
+
+ from sklearnex import unpatch_sklearn
+ unpatch_sklearn(global_patch=True)
+ -
+
+.. tip:: If you clone an environment with enabled global patching, it will already be applied in the new environment.
+
+Unpatching
+**********************
+
+To undo the patch (also called `unpatching`) is to return scikit-learn to original implementation and
+replace patched algorithms with the stock scikit-learn algorithms.
+
+To unpatch successfully, you must reimport the scikit-learn package::
+
+ sklearnex.unpatch_sklearn()
+ # Re-import scikit-learn algorithms after the unpatch
+ from sklearn.cluster import KMeans
+
+
+Installation
+--------------------
+
+.. contents:: :local:
+
+.. tip:: To prevent version conflicts, we recommend creating and activating a new environment for |intelex|.
+
+Install from PyPI
+**********************
+
+Recommended by default.
+
+To install |intelex|, run:
+
+::
+
+ pip install scikit-learn-intelex
+
+**Supported Configurations**
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ * - Windows* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+
+
+
+Install from Anaconda* Cloud
+********************************************
+
+To prevent version conflicts, we recommend installing `scikit-learn-intelex` into a new conda environment.
+
+.. tabs::
+
+ .. tab:: Conda-Forge channel
+
+ Recommended by default.
+
+ To install, run::
+
+ conda install scikit-learn-intelex -c conda-forge
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ * - Windows* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+
+
+ .. tab:: Intel channel
+
+ Recommended for the Intel® Distribution for Python users.
+
+ To install, run::
+
+ conda install scikit-learn-intelex -c intel
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ * - Windows* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+
+
+
+ .. tab:: Main channel
+
+ To install, run::
+
+ conda install scikit-learn-intelex
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ * - Windows* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+
+
+
+Build from Sources
+**********************
+
+See `Installation instructions `_ to build |intelex| from the sources.
+
+Install Intel*(R) AI Tools
+****************************
+
+Download the Intel AI Tools `here `_. The extension is already included.
+
+Release Notes
+-------------------
+
+See the `Release Notes `_ for each version of Intel® Extension for Scikit-learn*.
+
+System Requirements
+--------------------
+
+Hardware Requirements
+**********************
+
+.. tabs::
+
+ .. tab:: CPU
+
+ All processors with ``x86`` architecture with at least one of the following instruction sets:
+
+ - SSE2
+ - SSE4.2
+ - AVX2
+ - AVX512
+
+ .. note:: ARM* architecture is not supported.
+
+ .. tab:: GPU
+
+ - All Intel® integrated and discrete GPUs
+ - Intel® GPU drivers
+
+
+.. tip:: Intel(R) processors provide better performance than other CPUs. Read more about hardware comparison in our :ref:`blogs `.
+
+
+Software Requirements
+**********************
+
+.. tabs::
+
+ .. tab:: CPU
+
+ - Linux* OS: Ubuntu* 18.04 or newer
+ - Windows* OS 10 or newer
+ - Windows* Server 2019 or newer
+
+ .. tab:: GPU
+
+ - Linux* OS: Ubuntu* 18.04 or newer
+ - Windows* OS 10 or newer
+ - Windows* Server 2019 or newer
+
+ .. important::
+
+ If you use accelerators, refer to `oneAPI DPC++/C++ Compiler System Requirements `_.
+
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn:
+
+* 1.0.X
+* 1.1.X
+* 1.2.X
+* 1.3.X
+
+Memory Requirements
+**********************
+By default, algorithms in |intelex| run in the multi-thread mode. This mode uses all available threads.
+Optimized scikit-learn algorithms can consume more RAM than their corresponding unoptimized versions.
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Single-thread mode
+ - Multi-thread mode
+ * - SVM
+ - Both Scikit-learn and |intelex| consume approximately the same amount of RAM.
+ - In |intelex|, an algorithm with ``N`` threads consumes ``N`` times more RAM.
+
+In all |intelex| algorithms with GPU support, computations run on device memory.
+The device memory must be large enough to store a copy of the entire dataset.
+You may also require additional device memory for internal arrays that are used in computation.
+
+
+.. seealso::
+
+ :ref:`Samples`
diff --git a/2024.3/_sources/samples.rst.txt b/2024.3/_sources/samples.rst.txt
new file mode 100644
index 0000000000..e616e8f2d9
--- /dev/null
+++ b/2024.3/_sources/samples.rst.txt
@@ -0,0 +1,68 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _samples:
+
+#######
+Samples
+#######
+
+The following samples are also provided as Jupyter notebooks in |intelex| repository.
+If you want to run them locally, refer to `these instructions
+`_.
+
+.. rubric:: Classification Tasks
+
+.. toctree::
+ :maxdepth: 1
+
+ k-Nearest Neighbors (kNN) for MNIST dataset
+ Logistic Regression for Cifar dataset
+ Support Vector Classification (SVC) for Adult dataset
+
+.. rubric:: Regression Tasks
+
+.. toctree::
+ :maxdepth: 1
+
+ ElasticNet for Airlines DepDelay dataset
+ Lasso Regression for YearPredictionMSD dataset
+ Linear Regression for YearPredictionMSD dataset
+ Nu-Support Vector Regression (NuSVR) for Medical Charges dataset
+ Random Forest for Yolanda dataset
+ Rigde Regression for Airlines DepDelay dataset
+
+.. rubric:: Clustering Tasks
+
+.. toctree::
+ :maxdepth: 1
+
+ Kmeans for spoken arabic digit dataset
+ DBSCAN for spoken arabic digit dataset
+
+.. rubric:: Jupyter Notebook Samples
+
+.. toctree::
+ :maxdepth: 1
+
+ Intel® Extension for Scikit-Learn* Getting Started Sample
+ Intel® Extension for Scikit-Learn*: SVC for Adult dataset Performance Sample
+
+.. seealso::
+
+ There are also :ref:`Kaggle kernels ` that use |intelex| for a variety of machine learning scenarios.
+
+.. note:: Explore the complete list of oneAPI code samples in the `oneAPI Samples Catalog `_. These samples were designed to help you develop, offload, and optimize multiarchitecture applications targeting CPUs, GPUs, and FPGAs.
diff --git a/2024.3/_sources/samples/ElasticNet.ipynb.txt b/2024.3/_sources/samples/ElasticNet.ipynb.txt
new file mode 100644
index 0000000000..29e5dca851
--- /dev/null
+++ b/2024.3/_sources/samples/ElasticNet.ipynb.txt
@@ -0,0 +1,386 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34e460a7",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "00c2277b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06d309c0",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2ff35bc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38637349",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import StandardScaler\n",
+ "\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.28 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"l1_ratio\": 0.7,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0109113399224974'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class ElasticNet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 3.96 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0109113399545733'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a2edbb65",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0109113399224974 MSE metric of unpatched Scikit-learn: 1.0109113399545733 Metrics ratio: 0.9999999999682703 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 14.2 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/daal4py_data_science.ipynb.txt b/2024.3/_sources/samples/daal4py_data_science.ipynb.txt
new file mode 100644
index 0000000000..9336772cb3
--- /dev/null
+++ b/2024.3/_sources/samples/daal4py_data_science.ipynb.txt
@@ -0,0 +1,650 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Utilizing daal4py in Data Science Workflows\n",
+ "\n",
+ "The notebook below has been made to demonstrate daal4py in a data science context. It utilizes a Cycling Dataset for pyworkout-toolkit, and attempts to create a linear regression model from the 5 features collected for telemetry to predict the user's Power output in the absence of a power meter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'3.8.10 (default, May 19 2021, 18:05:58) \\n[GCC 7.3.0]'"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import glob\n",
+ "import sys\n",
+ "\n",
+ "%matplotlib inline\n",
+ "sys.version"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This example will be exploring workout data pulled from Strava, processed into a CSV for Pandas and daal4py usage. Below, we utilize pandas to read in the CSV file, and look at the head of dataframe with .head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " altitude \n",
+ " cadence \n",
+ " distance \n",
+ " hr \n",
+ " latitude \n",
+ " longitude \n",
+ " power \n",
+ " speed \n",
+ " time \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 185.800003 \n",
+ " 51 \n",
+ " 3.46 \n",
+ " 81 \n",
+ " 30.313309 \n",
+ " -97.732711 \n",
+ " 45 \n",
+ " 3.459 \n",
+ " 2016-10-20T22:01:26.000Z \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 185.800003 \n",
+ " 68 \n",
+ " 7.17 \n",
+ " 82 \n",
+ " 30.313277 \n",
+ " -97.732715 \n",
+ " 0 \n",
+ " 3.710 \n",
+ " 2016-10-20T22:01:27.000Z \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 186.399994 \n",
+ " 38 \n",
+ " 11.04 \n",
+ " 82 \n",
+ " 30.313243 \n",
+ " -97.732717 \n",
+ " 42 \n",
+ " 3.874 \n",
+ " 2016-10-20T22:01:28.000Z \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 186.800003 \n",
+ " 38 \n",
+ " 15.18 \n",
+ " 83 \n",
+ " 30.313212 \n",
+ " -97.732720 \n",
+ " 5 \n",
+ " 4.135 \n",
+ " 2016-10-20T22:01:29.000Z \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 186.600006 \n",
+ " 38 \n",
+ " 19.43 \n",
+ " 83 \n",
+ " 30.313172 \n",
+ " -97.732723 \n",
+ " 1 \n",
+ " 4.250 \n",
+ " 2016-10-20T22:01:30.000Z \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " altitude cadence distance hr latitude longitude power speed \\\n",
+ "0 185.800003 51 3.46 81 30.313309 -97.732711 45 3.459 \n",
+ "1 185.800003 68 7.17 82 30.313277 -97.732715 0 3.710 \n",
+ "2 186.399994 38 11.04 82 30.313243 -97.732717 42 3.874 \n",
+ "3 186.800003 38 15.18 83 30.313212 -97.732720 5 4.135 \n",
+ "4 186.600006 38 19.43 83 30.313172 -97.732723 1 4.250 \n",
+ "\n",
+ " time \n",
+ "0 2016-10-20T22:01:26.000Z \n",
+ "1 2016-10-20T22:01:27.000Z \n",
+ "2 2016-10-20T22:01:28.000Z \n",
+ "3 2016-10-20T22:01:29.000Z \n",
+ "4 2016-10-20T22:01:30.000Z "
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "workout_data_dd = pd.read_csv(\"data/cycling_dataset.csv\", index_col=0)\n",
+ "workout_data_dd.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data above has several key features that would be of great use here. \n",
+ "- Altitude can affect performance, so it might be a useful feature. \n",
+ "- Cadence is the revolutions per minute of the crank, and may have possible influence. \n",
+ "- Heart Rate is a measure of the body's workout strain, and would have a high possibly of influence.\n",
+ "- Distance may have a loose correlation as it is highly route dependent, but might be possible.\n",
+ "- Speed has possible correlations as it ties directly into power."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Explore and visualize some of the data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In general, we are trying to predict on the 'power' in Watts to see if we can generate a model that can predict one's power output without the usage of a cycling power meter. Below are some basic scatterplots as we explore the data. Scatterplots are great for looking for patterns and correlation in the data itself. Below, we can see that cadence and speed are positively correlated. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "workout_data_dd.plot.scatter(\"cadence\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"hr\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"cadence\", \"speed\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"speed\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"altitude\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"distance\", \"power\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using daal4py for Machine Learning tasks\n",
+ "\n",
+ "In the sections below, we will be using daal4py directly. After importing the model, we will arrange it in a separate independent and dependent dataframes, then use the daal4py's training and prediction classes to generate a workable model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import daal4py as d4p"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It is now the time to split the dataset into train and test sets. This is demonstrated below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3902, 9)\n",
+ "(3000, 9) (902, 9)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(workout_data_dd.shape)\n",
+ "train_set = workout_data_dd[0:3000]\n",
+ "test_set = workout_data_dd[3000:]\n",
+ "print(train_set.shape, test_set.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Reduce the dataset, create X. We drop the target, and other non-essential features.\n",
+ "reduced_dataset = train_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)\n",
+ "# Get the target, create Y\n",
+ "target = train_set.power.values.reshape((-1, 1))\n",
+ "# This is essentially doing np.array(dataset.power.values, ndmin=2).T\n",
+ "# as it needs to force a 2 dimensional array as we only have 1 target"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "X is 5 features by 3k rows, Y is 3k rows by 1 column"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3000, 5) (3000, 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(reduced_dataset.values.shape, target.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training the model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the Linear Regression Model, and train the model with the data. We utilize daal4py's linear_regression_training class to create the model, then call .compute() with the independent and dependent data as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d4p_lm = d4p.linear_regression_training(interceptFlag=True)\n",
+ "lm_trained = d4p_lm.compute(reduced_dataset.values, target)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model has this number of features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Model has this number of features: \", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prediction (inference) with the trained model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that the model is trained, we can test it with the test part of the dataset. We drop the same features to match that of the trained model, and put it into daal4py's linear_regression_prediction class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "subset = test_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can create the Prediction object and use the reduced dataset for prediction. The class's arguments use the independent data and the trained model from above as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lm_predictor_component = d4p.linear_regression_prediction()\n",
+ "result = lm_predictor_component.compute(subset.values, lm_trained.model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(result.prediction[0:300])\n",
+ "plt.plot(test_set.power.values[0:300])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The graph above shows the Orange (predicted) result over the Blue (original data). This data is notoriously sparse in features leading to a difficult to predict target!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Model properties\n",
+ "Another aspect of the model is the trained model's properties, which are explored below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Betas: [[ 1.51003501e+01 -1.25075548e-01 1.32249115e+00 1.64363922e-03\n",
+ " 8.53155955e-01 -1.09595022e+01]]\n",
+ "Number of betas: 6\n",
+ "Number of Features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Betas:\", lm_trained.model.Beta)\n",
+ "print(\"Number of betas:\", lm_trained.model.NumberOfBetas)\n",
+ "print(\"Number of Features:\", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Additional metrics\n",
+ "We can generate metrics on the independent data with daal4py's low_order_moments() class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1.90063975e+01, 3.75882355e+01, 4.98258371e+03, 2.41394741e+01,\n",
+ " 1.81623064e+00]])"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "metrics_processor = d4p.low_order_moments()\n",
+ "data = metrics_processor.compute(reduced_dataset.values)\n",
+ "data.standardDeviation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Migrating the trained model for inference on external systems\n",
+ "\n",
+ "Occasionally one may need to migrate the trained model to another system for inference only--this use case allows the training on a much more powerful machine with a larger dataset, and placing the trained model for inference-only on a smaller machine."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pickle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"wb\") as model_pi:\n",
+ " pickle.dump(lm_trained.model, model_pi)\n",
+ " model_pi.close"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The trained model file above can be moved to an inference-only or embedded system. This is useful if the training is extreamly heavy or computed-limited. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"rb\") as model_import:\n",
+ " lm_import = pickle.load(model_import)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The imported model from file is now usable again. We can check the betas from the model to ensure that the trained model is present."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1.51003501e+01, -1.25075548e-01, 1.32249115e+00,\n",
+ " 1.64363922e-03, 8.53155955e-01, -1.09595022e+01]])"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lm_import.Beta"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9 (tags/v3.10.9:1dd9be6, Dec 6 2022, 20:01:21) [MSC v.1934 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "8837a6bc722950b4562ef1f8ddb3cf1e2be71cad9580dda11136095ace1c488e"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2024.3/_sources/samples/dbscan.ipynb.txt b/2024.3/_sources/samples/dbscan.ipynb.txt
new file mode 100644
index 0000000000..d6e5c92653
--- /dev/null
+++ b/2024.3/_sources/samples/dbscan.ipynb.txt
@@ -0,0 +1,344 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.metrics import davies_bouldin_score\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6fd95eeb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "33da61da",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 6.37 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "params = {\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at Davies-Bouldin score of the DBSCAN algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class DBSCAN"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 469.21 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look Davies-Bouldin score of the DBSCAN algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Original Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Davies-Bouldin score of patched Scikit-learn and original Davies-Bouldin score of patched Scikit-learn: 0.8542652084275848 Davies-Bouldin score of unpatched Scikit-learn: 0.8542652084275848 Metrics ratio: 1.0 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 73.6 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Davies-Bouldin score of patched Scikit-learn and original \"\n",
+ " f\"Davies-Bouldin score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"Davies-Bouldin score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/kmeans.ipynb.txt b/2024.3/_sources/samples/kmeans.ipynb.txt
new file mode 100644
index 0000000000..df09f8ded5
--- /dev/null
+++ b/2024.3/_sources/samples/kmeans.ipynb.txt
@@ -0,0 +1,362 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cdcb77d",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((236930, 14), (26326, 14), (236930,), (26326,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=123)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 7.36 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "params = {\n",
+ " \"n_clusters\": 128,\n",
+ " \"random_state\": 123,\n",
+ " \"copy_x\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn inertia: 13346.641333761074\n",
+ "Intel® extension for Scikit-learn number of iterations: 274\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_opt = model.inertia_\n",
+ "n_iter_opt = model.n_iter_\n",
+ "print(f\"Intel® extension for Scikit-learn inertia: {inertia_opt}\")\n",
+ "print(f\"Intel® extension for Scikit-learn number of iterations: {n_iter_opt}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KMeans"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 192.14 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn inertia: 13352.813785961785\n",
+ "Original Scikit-learn number of iterations: 212\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_original = model.inertia_\n",
+ "n_iter_original = model.n_iter_\n",
+ "print(f\"Original Scikit-learn inertia: {inertia_original}\")\n",
+ "print(f\"Original Scikit-learn number of iterations: {n_iter_original}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare inertia and number of iterations of patched Scikit-learn and original Inertia: Patched Scikit-learn: 13346.641333761074 Unpatched Scikit-learn: 13352.813785961785 Ratio: 0.9995377414603653 Number of iterations: Patched Scikit-learn: 274 Unpatched Scikit-learn: 212 Ratio: 1.29 Number of iterations is bigger but algorithm is much faster and inertia is lowerWith Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get speedup in 26.1 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare inertia and number of iterations of patched Scikit-learn and original \"\n",
+ " f\"Inertia: \"\n",
+ " f\"Patched Scikit-learn: {inertia_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {inertia_original} \"\n",
+ " f\"Ratio: {inertia_opt/inertia_original} \"\n",
+ " f\"Number of iterations: \"\n",
+ " f\"Patched Scikit-learn: {n_iter_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {n_iter_original} \"\n",
+ " f\"Ratio: {(n_iter_opt/n_iter_original):.2f} \"\n",
+ " f\"Number of iterations is bigger but algorithm is much faster and inertia is lower\"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/knn_mnist.ipynb.txt b/2024.3/_sources/samples/knn_mnist.ipynb.txt
new file mode 100644
index 0000000000..b8604d70f0
--- /dev/null
+++ b/2024.3/_sources/samples/knn_mnist.ipynb.txt
@@ -0,0 +1,333 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn KNN for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Download the data "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"mnist_784\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6259f584",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((56000, 784), (14000, 784), (56000,), (14000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with Intel® Extension for Scikit-learn for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 1.45 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "params = {\"n_neighbors\": 40, \"weights\": \"distance\", \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_opt = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "8ca549ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KNeighborsClassifier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with original Scikit-learn library for MNSIT dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 36.15 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_original = timer() - start\n",
+ "f\"Original Scikit-learn time: {time_original:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "33da9fd1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 24.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(time_original/time_opt):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/lasso_regression.ipynb.txt b/2024.3/_sources/samples/lasso_regression.ipynb.txt
new file mode 100644
index 0000000000..967d0d4e54
--- /dev/null
+++ b/2024.3/_sources/samples/lasso_regression.ipynb.txt
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import requests\n",
+ "import warnings\n",
+ "import os\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db2d1c39",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e58a6e28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "532874ab",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.01,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.9676607251167297'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Lasso"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.83 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.9676599502563477'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "13c86289",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.9676607251167297 MSE metric of unpatched Scikit-learn: 0.9676599502563477 Metrics ratio: 1.0000008344650269 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.7 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/linear_regression.ipynb.txt b/2024.3/_sources/samples/linear_regression.ipynb.txt
new file mode 100644
index 0000000000..508ee06d8c
--- /dev/null
+++ b/2024.3/_sources/samples/linear_regression.ipynb.txt
@@ -0,0 +1,378 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import requests\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad7ce109",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "801ea6cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03431aec",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.03 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "params = {\"n_jobs\": -1, \"copy_X\": False}\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.7716818451881409'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LinearRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.53 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.7716856598854065'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "91fb14e4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.7716818451881409 MSE metric of unpatched Scikit-learn: 0.7716856598854065 Metrics ratio: 0.9999950528144836 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 18.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/logistictic_regression_cifar.ipynb.txt b/2024.3/_sources/samples/logistictic_regression_cifar.ipynb.txt
new file mode 100644
index 0000000000..43727804d7
--- /dev/null
+++ b/2024.3/_sources/samples/logistictic_regression_cifar.ipynb.txt
@@ -0,0 +1,329 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb52aca",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.datasets import fetch_openml\n",
+ "\n",
+ "x, y = fetch_openml(name=\"CIFAR-100\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc8ba7c8",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((54000, 3072), (6000, 3072), (54000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=43)\n",
+ "x_train.shape, x_test.shape, y_train.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with Intel® Extension for Scikit-learn for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.82 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "params = {\n",
+ " \"C\": 0.1,\n",
+ " \"solver\": \"lbfgs\",\n",
+ " \"multi_class\": \"multinomial\",\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Log Loss: 3.7073530800931587 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_opt = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Intel® extension for Scikit-learn Log Loss: {log_loss_opt} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LogisticRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with original Scikit-learn library for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 395.03 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d38dfb5",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Log Loss: 3.7140870590578428 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_original = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Original Scikit-learn Log Loss: {log_loss_original} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "b7d17e2f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Log Loss metric of patched Scikit-learn and original Log Loss metric of patched Scikit-learn: 3.7073530800931587 Log Loss metric of unpatched Scikit-learn: 3.7140870590578428 Metrics ratio: 0.9981869086917978 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 15.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Log Loss metric of patched Scikit-learn and original \"\n",
+ " f\"Log Loss metric of patched Scikit-learn: {log_loss_opt} \"\n",
+ " f\"Log Loss metric of unpatched Scikit-learn: {log_loss_original} \"\n",
+ " f\"Metrics ratio: {log_loss_opt/log_loss_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/nusvr_medical_charges.ipynb.txt b/2024.3/_sources/samples/nusvr_medical_charges.ipynb.txt
new file mode 100644
index 0000000000..8c72c1b71d
--- /dev/null
+++ b/2024.3/_sources/samples/nusvr_medical_charges.ipynb.txt
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adf9ffe9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "a9b315cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"medical_charges_nominal\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49fbf604",
+ "metadata": {},
+ "source": [
+ "### Preprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fafea10b",
+ "metadata": {},
+ "source": [
+ "Encode categorical features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "f77c30f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cat_columns = x.select_dtypes([\"category\"]).columns\n",
+ "x[cat_columns] = x[cat_columns].apply(lambda x: x.cat.codes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd8d3b6d",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((48919, 11), (114146, 11), (48919,), (114146,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.3, random_state=42)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with Intel® Extension for Scikit-learn for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.69 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "params = {\n",
+ " \"nu\": 0.4,\n",
+ " \"C\": y_train.mean(),\n",
+ " \"degree\": 2,\n",
+ " \"kernel\": \"poly\",\n",
+ "}\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn R2 score: 0.8635974264586637'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = nusvr.score(x_test, y_test)\n",
+ "f\"Intel® extension for Scikit-learn R2 score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class NuSVR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with original Scikit-learn library for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 331.85 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23b8faa6",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn R2 score: 0.8636031741516902'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = nusvr.score(x_test, y_test)\n",
+ "f\"Original Scikit-learn R2 score: {score_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "3a704d51",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare R2 score of patched Scikit-learn and original R2 score of patched Scikit-learn: 0.8635974264586637 R2 score of unpatched Scikit-learn: 0.8636031741516902 Metrics ratio: 0.999993344520726 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare R2 score of patched Scikit-learn and original \"\n",
+ " f\"R2 score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"R2 score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/random_forest_yolanda.ipynb.txt b/2024.3/_sources/samples/random_forest_yolanda.ipynb.txt
new file mode 100644
index 0000000000..276284ed9b
--- /dev/null
+++ b/2024.3/_sources/samples/random_forest_yolanda.ipynb.txt
@@ -0,0 +1,320 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Random Forest for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d0b6bb9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Yolanda\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b3a2483",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((280000, 100), (120000, 100), (280000,), (120000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with Intel® Extension for Scikit-learn for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "8fecbbb1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 42.56 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "params = {\"n_estimators\": 150, \"random_state\": 44, \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9279181",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d05bc57b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_opt = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class RandomForestRegressor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with original Scikit-learn library for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "76a8d5f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 123.34 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f162fe6b",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d5b5e45c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_original = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Original Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "e255e563",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 83.62232345666878 MSE metric of unpatched Scikit-learn: 83.80131297814816 Metrics ratio: 0.9978641203208111 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 2.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_original} \"\n",
+ " f\"Metrics ratio: {mse_opt/mse_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/ridge_regression.ipynb.txt b/2024.3/_sources/samples/ridge_regression.ipynb.txt
new file mode 100644
index 0000000000..1c159a13ae
--- /dev/null
+++ b/2024.3/_sources/samples/ridge_regression.ipynb.txt
@@ -0,0 +1,390 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a1a9234",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f852cad8",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "27ebb377",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "147b3e82",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0014288520708046'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Ridge"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.70 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0014288520708057'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "1bde360d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0014288520708046 MSE metric of unpatched Scikit-learn: 1.0014288520708057 Metrics ratio: 0.9999999999999989 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 10.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/svc_adult.ipynb.txt b/2024.3/_sources/samples/svc_adult.ipynb.txt
new file mode 100644
index 0000000000..9e49bcfecd
--- /dev/null
+++ b/2024.3/_sources/samples/svc_adult.ipynb.txt
@@ -0,0 +1,322 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn SVC for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2cdcbfa6",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"a9a\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a6df301",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with Intel® Extension for Scikit-learn for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 14.08 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "params = {\"C\": 100.0, \"kernel\": \"rbf\", \"gamma\": \"scale\"}\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class SVC."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with original Scikit-learn library for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 803.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0a7a747",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fc992182",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 57.0 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/samples/tsne.ipynb.txt b/2024.3/_sources/samples/tsne.ipynb.txt
new file mode 100644
index 0000000000..99ad8fcefd
--- /dev/null
+++ b/2024.3/_sources/samples/tsne.ipynb.txt
@@ -0,0 +1,285 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn TSNE example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import make_blobs\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Generate the data \n",
+ "Generate isotropic Gaussian blobs for clustering.\n",
+ " \n",
+ "With the number of samples: 20k \n",
+ "Number of features: 100 \n",
+ "Number of blobs: 4 \n",
+ "Source: \n",
+ "https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = make_blobs(n_samples=20000, centers=4, n_features=100, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training TSNE algorithm with Intel® Extension for Scikit-learn for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn time: 12.63 s\n",
+ "Intel® Extension for scikit-learn. Divergence: 4.289110606110757\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_intelex = tsne.fit_transform(x)\n",
+ "time_opt = timer() - start\n",
+ "\n",
+ "print(f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\")\n",
+ "print(f\"Intel® Extension for scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ " ### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class TSNE."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training algorithm with original Scikit-learn library for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn time: 37.66 s\n",
+ "Original Scikit-learn. Divergence: 4.2955403327941895\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_original = tsne.fit_transform(x)\n",
+ "time_original = timer() - start\n",
+ "\n",
+ "print(f\"Original Scikit-learn time: {time_original:.2f} s\")\n",
+ "print(f\"Original Scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8358d7c2",
+ "metadata": {},
+ "source": [
+ "### Plot embeddings original scikit-learn and Intel® extension"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "43ab1a96",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colors = [int(m) for m in y]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "35147d24",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPWUlEQVR4nO3dd3gU5cIF8DObbDZ9Q0IKJYRQpNfQiyJEAiKCUqw0EQQiSBWQq6hXQSmioAKiBj4E6f0KCAgoEqnSlN5JSINkN4RkU/b9/uCylzUJJJDsu7tzfs+T52FnZ2fODkv2MPPOjCKEECAiIiJSAY3sAERERES2wuJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNUynbt2gVFUbBr164HzmsymWAymUo/lIPq378/KleuLGXdiYmJ6NmzJwICAqAoCj7//HMpOYrj0qVLUBQFCxcutEzr378/vL29H/jadu3aoV27do+0/pJYBlFJY/Ehp7dw4UIoioKDBw8W+7W3b9/G+++/X6TS8rBycnIwa9Ys1KpVC+7u7nB3d0etWrUwa9Ys5OTkFGtZlStXhqIoBf506tSp2NmWLl3qEF/wtjBq1Chs3boVEydOxOLFix9qezqy+Ph4vP/++zhy5IjsKESPxFV2ACJ7dvv2bXzwwQcAUCr/czUajejatStOnTqFQYMGISIiAoqi4PDhw5g2bRrWrl2LjRs3Qq/XF3mZDRs2xJgxY/JNL1++fLHzLV26FCdOnMDIkSOL/drSsGDBApjNZinr/uWXX9CtWzeMHTtWyvofRlhYGDIzM6HVaov92p9//tnqcXx8PD744ANUrlwZDRs2LKGERLbH4kMkUZ8+feDu7o4jR45Aq9VCURT4+fmhe/fuGDduHF5++WX06dMHGzZsKPIyK1SogFdffbUUU8vzMF/gJSUpKQl+fn4ltrysrCy4ublBoym9He+KosDd3f2hXuvm5lbCaWxDCIGsrCx4eHjIjkJ2ioe6SJXujnOIi4tD9+7d4e3tjcDAQIwdOxZ5eXkA7oyPCAwMBAB88MEHlkNG77//vmU5p06dQs+ePeHv7w93d3c0adKkyCVl06ZNOH/+PNauXYv58+cjMDAQZcuWhU6nQ2RkJEwmE1auXInLly/jP//5T4m996SkJAQGBqJdu3YQQlimnzt3Dl5eXnjhhRcA3NnD9Z///AeXL1+2vPd7x9eYTCZMnjwZ1apVg06nQ2hoKN5+++18Y5QURcGbb76JdevWoW7dutDpdKhTpw62bNliNV96ejpGjhyJypUrQ6fTISgoCE899RQOHz5smaegMT4ZGRkYM2YMQkNDodPpUKNGDcyYMcPqvRUnxz/dPVQqhMBXX31l2RZ3XbhwAb169YK/vz88PT3RokWLfH9fd8d5LVu2DP/6179QoUIFeHp6wmg0FrreZcuWISIiAj4+PvD19UW9evXwxRdfWM2TlpaGUaNGWbZZxYoV0bdvX6SkpAAoeIxPQY4cOWL5TNy6dQuA9ficXbt2oWnTpgCAAQMGWLbBg5ZbkKJ+bmJiYtC+fXsEBQVBp9Ohdu3amDt3br7lVa5cGc888wy2bt2KJk2awMPDA/Pnz7ds8xUrVuDjjz9GxYoV4e7ujg4dOuDcuXPFzk3Og3t8SLXy8vIQFRWF5s2bY8aMGdi+fTtmzpyJqlWrYujQoQgMDMTcuXMxdOhQPPfcc3j++ecBAPXr1wcA/PXXX2jdujUqVKiACRMmwMvLCytWrED37t2xevVqPPfcc/dd/3fffYcpU6bA09PTstyZM2fi5s2bmDBhAj7//HN89NFH+Pjjj/Hdd9+hS5cuRXpfOTk5li++e3l5ecHDwwNBQUGYO3cuevXqhTlz5mDEiBEwm83o378/fHx88PXXXwMAJk2aBIPBgGvXrmHWrFkAYBkUazab8eyzz2LPnj0YPHgwatWqhePHj2PWrFk4c+YM1q1bZ7XuPXv2YM2aNRg2bBh8fHwwe/Zs9OjRA1euXEFAQAAAYMiQIVi1ahXefPNN1K5dGzdu3MCePXtw8uRJNG7cuMD3KoTAs88+i507d2LgwIFo2LAhtm7dinHjxiEuLs6Suzg5/unxxx/H4sWL0adPHzz11FPo27ev5bnExES0atUKt2/fxogRIxAQEIBFixbh2WefxapVq/J9Bv7973/Dzc0NY8eOhclkKnSvyrZt2/DSSy+hQ4cO+PTTTwEAJ0+exO+//4633noLAHDr1i20bdsWJ0+exGuvvYbGjRsjJSUFGzZswLVr11C2bNkCl/1PBw4cQFRUFJo0aYL169cXuKekVq1a+PDDD/Hee+9h8ODBaNu2LQCgVatWRVrHXcX53MydOxd16tTBs88+C1dXV2zcuBHDhg2D2WxGdHS01XJPnz6Nl156CW+88QYGDRqEGjVqWJ775JNPoNFoMHbsWBgMBkybNg2vvPIK9u3bV6zs5EQEkZOLiYkRAMSBAwcs0/r16ycAiA8//NBq3kaNGomIiAjL4+TkZAFATJ48Od9yO3ToIOrVqyeysrIs08xms2jVqpWoXr26ZdrOnTsFALFz506r14eFhVleO3nyZNGqVSuRnJwszp49K5o0aSLGjRsnhBDCZDKJsLCwIr3XsLAwAaDAn6lTp1rN+9JLLwlPT09x5swZMX36dAFArFu3zmqeLl26FLjuxYsXC41GI3777Ter6fPmzRMAxO+//26ZBkC4ubmJc+fOWaYdPXpUABBz5syxTNPr9SI6Ovq+769fv35WedatWycAiI8++shqvp49ewpFUazWWdQchQGQL9/IkSMFAKvtkJ6eLsLDw0XlypVFXl6eEOJ/n4EqVaqI27dvP3Bdb731lvD19RW5ubmFzvPee+8JAGLNmjX5njObzUIIIS5evCgAiJiYGMtz/fr1E15eXkIIIfbs2SN8fX1Fly5drD7HQgjxxBNPiCeeeMLy+MCBA/mW9SD/XEZxPjcFbaeoqChRpUoVq2l3P/Nbtmyxmn53m9eqVUuYTCbL9C+++EIAEMePHy/y+yDnwkNdpGpDhgyxety2bVtcuHDhga+7efMmfvnlF/Tu3Rvp6elISUlBSkoKbty4gaioKJw9exZxcXEPXI5Op7P8ee/evQgMDET16tXh7u5uGVBc3LEWzZs3x7Zt2/L9vPTSS1bzffnll9Dr9ejZsyfeffdd9OnTB926dSvSOlauXIlatWqhZs2alveekpKC9u3bAwB27txpNX9kZCSqVq1qeVy/fn34+vpabWs/Pz/s27cP8fHxRX6vP/30E1xcXDBixAir6WPGjIEQAps3by52juL46aef0KxZM7Rp08YyzdvbG4MHD8alS5fw999/W83fr1+/Io098fPzQ0ZGBrZt21boPKtXr0aDBg0K3LN476G4wuzcuRNRUVHo0KED1qxZY/VZLC3F+dzcu50MBgNSUlLwxBNP4MKFCzAYDFbLDQ8PR1RUVIHrHDBggNW/obt7qx7275wcHw91kWq5u7tbxvDcVaZMGaSmpj7wtefOnYMQAu+++y7efffdAudJSkpChQoVCl2G2WyG2Wy2DG6tX78+/vWvf+Hdd99FtWrVLGdh3Z2vqMqWLYvIyMgHzufv74/Zs2ejV69eCA4OxuzZs4u8jrNnz+LkyZP5tt9dSUlJVo8rVaqUb55/butp06ahX79+CA0NRUREBJ5++mn07dsXVapUKTTH5cuXUb58efj4+FhNr1WrluX54uYojsuXL6N58+b5pt+7/rp161qmh4eHF2m5w4YNw4oVK9C5c2dUqFABHTt2RO/eva1OoT9//jx69OjxULmzsrLQpUsXREREYMWKFXB1ffivglu3blnGBQGAi4tLoZ+L4nxufv/9d0yePBmxsbG4ffu21XwGg8HqTMf7bdd//p2XKVMGAB7675wcH4sPqZaLi8tDv/ZuERk7dmyh/9OsVq3afZfx2GOPITY2Fq1btwZw5xdyr169ULNmTUREROCFF15Ap06dEBsbazVmoSRt3boVwJ0vgWvXrhX5rCWz2Yx69erhs88+K/D50NBQq8eFbWtxzwDk3r17o23btli7di1+/vlnTJ8+HZ9++inWrFmDzp07FynXgxQlR2kq6plGQUFBOHLkCLZu3YrNmzdj8+bNiImJQd++fbFo0aJHzqHT6fD0009j/fr12LJlC5555pmHXtaMGTMsl3wA7pxCf+nSpQLnLern5vz58+jQoQNq1qyJzz77DKGhoXBzc8NPP/2EWbNm5fuPwP22q+y/c7I/LD5E91HYIYO7eyG0Wm2R9q4U5OWXX8Z7772X73BGvXr18M4772D48OE4fvw4Pvjgg3yHqUrCli1b8O233+Ltt9/GkiVL0K9fP+zbt8/qf/+Fvf+qVavi6NGj6NChQ5EOqxRVuXLlMGzYMAwbNgxJSUlo3LgxPv7440KLT1hYGLZv34709HSrvT6nTp2yPF+awsLCcPr06XzTS2L9bm5u6Nq1K7p27Qqz2Yxhw4Zh/vz5lj2CVatWxYkTJx5q2YqiYMmSJejWrRt69eqFzZs3P/A6VYX9Pfft29fqUN/9SkhRPzcbN26EyWTChg0brPbY/PMQKtHD4Bgfovu4e8ZVWlqa1fSgoCC0a9cO8+fPx/Xr1/O9Ljk5+YHL7tOnD1JTUzF8+HBMmDDBajzK5MmTcfjwYUyYMAHJycno06fPo72Rf0hLS8Prr7+OZs2aYcqUKfj2229x+PBhTJkyxWo+Ly+vfOMpgDt7Z+Li4rBgwYJ8z2VmZiIjI6NYefLy8vKtJygoCOXLl7/vLTyefvpp5OXl4csvv7SaPmvWLCiKUmJ7iu63/v379yM2NtYyLSMjA9988w0qV66M2rVrP9Ryb9y4YfVYo9FYzia8uz169OiBo0ePYu3atfleX5S9GW5ublizZg2aNm2Krl27Yv/+/fed38vLC0D+fwtVqlRBZGSk5efuHsyCFPVzc3cvzb3vw2AwICYm5oHvi+hBuMeH6D48PDxQu3ZtLF++HI899hj8/f1Rt25d1K1bF1999RXatGmDevXqYdCgQahSpQoSExMRGxuLa9eu4ejRo/ddtlarxerVq/Hkk0/i4MGDGDVqFJo0aQJFUXDo0CF8/vnniIuLw86dO4t14b64uDj88MMP+aZ7e3uje/fuAIC33noLN27cwPbt2+Hi4oJOnTrh9ddfx0cffYRu3bqhQYMGAICIiAgsX74co0ePRtOmTeHt7Y2uXbuiT58+WLFiBYYMGYKdO3eidevWyMvLw6lTp7BixQrLNVWKKj09HRUrVkTPnj3RoEEDeHt7Y/v27Thw4ABmzpxZ6Ou6du2KJ598EpMmTcKlS5fQoEED/Pzzz1i/fj1GjhxpNZC5NEyYMAE//vgjOnfujBEjRsDf3x+LFi3CxYsXsXr16oe+OOHrr7+Omzdvon379qhYsSIuX76MOXPmoGHDhpbxQ+PGjcOqVavQq1cvvPbaa4iIiMDNmzexYcMGzJs3z/J3eD8eHh7YtGkT2rdvj86dO2P37t1WY5LuVbVqVfj5+WHevHnw8fGBl5cXmjdvXuRxSwCK/Lnp2LGjZY/XG2+8gVu3bmHBggUICgoq8D8aRMUi8YwyIpso7HT2u6f03mvy5Mnin/8s9u7dKyIiIoSbm1u+U9vPnz8v+vbtK0JCQoRWqxUVKlQQzzzzjFi1apVlnsJOZ78rISFBvPzyy0Kr1VpOPddqteLll18W169fL9Z7vd/p7HdPA1+/fr0AIGbOnGn1WqPRKMLCwkSDBg1Edna2EEKIW7duiZdffln4+flZLUMIIbKzs8Wnn34q6tSpI3Q6nShTpoyIiIgQH3zwgTAYDJb5UMBp4Hez9uvXTwhx55T9cePGiQYNGggfHx/h5eUlGjRoIL7++mur1/zzdHYh7pw+PmrUKFG+fHmh1WpF9erVxfTp0y2ndBcnx/0U9vrz58+Lnj17Cj8/P+Hu7i6aNWsmNm3aZDXP3c/AypUrH7geIYRYtWqV6NixowgKChJubm6iUqVK4o033sj3ebhx44Z48803RYUKFYSbm5uoWLGi6Nevn0hJSRFCPPh09rtSUlJE7dq1RUhIiDh79qwQIv+p6ELc+ezUrl1buLq6FunU9oKWUdTPzYYNG0T9+vWFu7u7qFy5svj000/F999/LwCIixcvWuYLCwsTXbp0ybfuwrZ5QduE1EURgiO8iOyBwWCwjA2pWbNmse7PRURERcPiQ0RERKrBwc1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBq8gOE9zGYz4uPj4ePjU6KX4SciIqLSI4RAeno6ypcv/8ALh7L43CM+Pj7fzRWJiIjIMVy9ehUVK1a87zwsPve4e5PDq1evwtfXV3IaIiIiKgqj0YjQ0FCrmxUXhsXnHncPb/n6+rL4EBEROZiiDFPh4GYiIiJSDRYfIiIiUg0WHyIiIlINFh8iIiJSDRYfIiIiUg2HKj5xcXF49dVXERAQAA8PD9SrVw8HDx60PC+EwHvvvYdy5crBw8MDkZGROHv2rMTEREREZE8cpvikpqaidevW0Gq12Lx5M/7++2/MnDkTZcqUscwzbdo0zJ49G/PmzcO+ffvg5eWFqKgoZGVlSUxORERE9kIRQgjZIYpiwoQJ+P333/Hbb78V+LwQAuXLl8eYMWMwduxYAIDBYEBwcDAWLlyIF1988YHrMBqN0Ov1MBgMvI4PERGRgyjO97fD7PHZsGEDmjRpgl69eiEoKAiNGjXCggULLM9fvHgRCQkJiIyMtEzT6/Vo3rw5YmNjC1ymyWSC0Wi0+iEiIiLn5TBXbr5w4QLmzp2L0aNH45133sGBAwcwYsQIuLm5oV+/fkhISAAABAcHW70uODjY8tw/TZ06FR988EGpZyf1uJVpwpx1e/DLkXMwZedC66rBbVMOTDl5AAB3N1f06RCBoc+2kpyUiEidHOZQl5ubG5o0aYK9e/dapo0YMQIHDhxAbGws9u7di9atWyM+Ph7lypWzzNO7d28oioLly5fnW6bJZILJZLI8vnuvDx7qUqdryWn4bvN+3Lx1G1XKBWBg52bQurhg+a4jiE8xoEJZPVrXDYfW1QXl/H2QeisT2Tl5SE2/jR1HzuFKYip2H7sAcxH+SVUrH4BnmtfGleQ0VAjQ46X2DeHuprXBuyQicj7FOdTlMHt8ypUrh9q1a1tNq1WrFlavXg0ACAkJAQAkJiZaFZ/ExEQ0bNiwwGXqdDrodLrSCUwOIzfXjMGfr8SR8/GWab8dv4hFPx/MN++sNQWPMSuuc/E38Pna/y3ryw170OvxBpjwYvsSWT4RERXMYcb4tG7dGqdPn7aadubMGYSFhQEAwsPDERISgh07dlieNxqN2LdvH1q2bGnTrORY/ll6ZBACWLH7KD5d9ovUHEREzs5his+oUaPwxx9/YMqUKTh37hyWLl2Kb775BtHR0QDu3JF15MiR+Oijj7BhwwYcP34cffv2Rfny5dG9e3e54clu/Xb8gvTSc68Vvx5FVnaO7BhERE7LYQ51NW3aFGvXrsXEiRPx4YcfIjw8HJ9//jleeeUVyzxvv/02MjIyMHjwYKSlpaFNmzbYsmUL3N3dJSYne3QlKRV9P/0RxtumB89sQ0IAc9buwbgXnpQdhYjIKTnM4GZb4HV8nFNGpglzN8Xi12MXIIRA4+oVsfGPv2XHuq9AX090aVEbFQP90LRGKEID/WRHIiKyW045uJnoYWw7dAYTvv0P7m33cTfsu/QAQLLxNhbeM7i6nL8v5o/sgYosQEREj4TFh5zWpYSbGP/tf2THKBHXbxrx7Hsx8NRp0fPx+hjRvQ00GocZokdEZDf4m5Oc1r8WbpYdocTdNuXg/7YdwnPvL4Qph4OgiYiKi8WHnFJOXh5OXk6SHaPUXE024IlRX2Px9oPgMD0ioqJj8SGns2znn2g94ks4ex3IzjNj1urf0H3yQpiyc2XHISJyCCw+5FR+2HEI01bsQq7ZLDuKzVxNTsPTkxbAlMPyQ0T0IBzcTA7vUsJNnItPQZDeC7NW/yo7jhSpt7LwwoeL4a/3RHAZb4zp1Q5lfb1kxyIisjssPuSwfjt+AR/+sA03jLdlR7ELV1LScCUlDQCw9eAZ1KwUhB/Gv8Szv4iI7sHfiOSQdh49h7e+Xs/Scx+nriThhY9+kB2DiMiusPiQwxFCYPLCrbJjOITz12/gzLVk2TGIiOwGiw85nP2nruBWVrbsGA5j5spdsiMQEdkNFh9yOMcvXpcdwaEcOHMNa/Yckx2DiMgusPiQwzHcypIdweF8tGQH9v51SXYMIiLpWHzIoQghsOGPv2THcEhvL9gkOwIRkXQsPuQwMk05mPDtf5CeyfE9D+O2KYe3tyAi1WPxIYeQYriFyPHzse3wWdlRHNqUH3ew/BCRqrH4kEN4bcYKZJp4N/JHtfq34/hs1W7ZMYiIpOGVm8nunYtLwbUUg+wYTmPJL3/i+KUEvPBEA3RuVkt2HCIim+IeH7J7P+0/KTuC0zl24TomxWzBk2PnIjE1XXYcIiKbYfEhu5dn5piU0mLIyMILHy2GWUV3sycidWPxIbv3VMRjsiM4NeNtE9bv/Vt2DCIim2DxIbtXo2IgfDzcZMdwaqt+Oyo7AhGRTXBwM9mt7JxcTPx+M3YfPQ8zT8EuVVnZubIjEBHZBIsP2aWcvDz0+PD/EMezuWwiNNBPdgQiIpvgoS6yS99v2c/SY0Mjn28rOwIRkU2w+JBdWrGLY05s5ZkWtVA5xF92DCIim+ChLrJLhgzegd0WBndpgSHPtJQdg4jIZrjHh+ySqws/mrYQzj09RKQy/HYhu9S0RqjsCKrwxdrfZEcgIrIpFh+yS2+/8CQURXYK55dwMx23Mk2yYxAR2QyLD9ml0EA/vN+no+wYqmDK4TV8iEg9WHzIblXktWVKnYtGA72Xh+wYREQ2w+JDdkvv5S47gtOrGx7MgeREpCr8jUd2KyyojOwITs/HXSc7AhGRTbH4kN3i/blKX66Z25iI1IXFh+zWlaRU2RGcXq3QQNkRiIhsisWH7NaQL1bLjuD02jWsJjsCEZFNsfiQXTpyLg43jLdlx3B6If4+siMQEdkUiw/ZpR1HzsqO4PQ83FwRqPeWHYOIyKZYfMguuWpcZEdwejUqBcmOQERkcyw+ZJeebVlbdgSnN5lXxiYiFWLxIbsUXi6A1/EpRfXCQ7h9iUiVWHzIbsWM6w0fD15grzR8NKCz7AhERFKw+JDd8vP2xLZP38DrTzdHWb0X3N1cZUdyCrXDghDK+6ARkUopQvDyuHcZjUbo9XoYDAb4+vrKjkMFeGr8fJ7m/ggUBdjw4WuoUFYvOwoRUYkpzvc39/iQQ/Fw08qO4NBa1Apj6SEiVWPxIYfSsGoF2REcWpPHKsqOQEQkFYsPOZS+T0XIjuCwFEVBjzb1ZccgIpKKxYccSrUKZTH0mZayYzikkc+3ha+Xu+wYRERSsfiQwxnUpQXa1guXHcOhlA/wRZ9I7i0jImLxIYf0736d4OrCj29RdYx4THYEIiK7wG8Ocki+Xu6Y/1ZPKIrsJPZPUcC9PURE/8XiQw6rUfUKqBsWIjuG3RvyTEuU8fGUHYOIyC7wUrjk0Lw9eUuLwrhoFIzu+QRebNdQdhQiIrvB4kMO7eX2jRD792XZMexORPWKmDHkGeg9PWRHISKyKyw+5NBa1wlHsJ83EtNuyY5iFxQFWDO5P8KCeed1IqKCOOwYn08++QSKomDkyJGWaVlZWYiOjkZAQAC8vb3Ro0cPJCYmygtJNrF00isI1HvJjmEXhAD+PHdNdgwiIrvlkMXnwIEDmD9/PurXt74K7ahRo7Bx40asXLkSu3fvRnx8PJ5//nlJKclWynh7YsvUQZg+6Bk0qFJOdhzp4lKMsiMQEdkthys+t27dwiuvvIIFCxagTJn/7c43GAz47rvv8Nlnn6F9+/aIiIhATEwM9u7diz/++ENiYrIFRVHQoXF1xIx7Efu/HIEaoYGyI0lTpZy/7AhERHbL4YpPdHQ0unTpgsjISKvphw4dQk5OjtX0mjVrolKlSoiNjbV1TJLI1cUFP77zKnZ8+obsKDandXVBp6Y1ZccgIrJbDjW4edmyZTh8+DAOHDiQ77mEhAS4ubnBz8/PanpwcDASEhIKXJ7JZILJZLI8Nhp5iMCZlPH1RI829bB6z3HZUWzmzW6tofCqjkREhXKYPT5Xr17FW2+9hSVLlsDdvWRutDh16lTo9XrLT2hoaIksl+zHpFci0fepCKe5vYW3hxu6taoDF431+9G6umDU8215hWYiogdQhBBCdoiiWLduHZ577jm4uLhYpuXl5UFRFGg0GmzduhWRkZFITU212usTFhaGkSNHYtSoUfmWWdAen9DQUBgMBvj6+pbq+yHbysszY/vhs0hIS4ebqwafrfoVeWaH+OgDuFN4hnRpia6t6sDHQ4e8PDM2/vE34m4YUCUkAFFNHoNG4xzljoiouIxGI/R6fZG+vx2m+KSnp+PyZesL1Q0YMAA1a9bE+PHjERoaisDAQPz444/o0aMHAOD06dOoWbMmYmNj0aJFiweuozgbjhxbctotDJixHPE37PfwpqIAIWV88dbzbdAxoobsOEREdqs4398OM8bHx8cHdevWtZrm5eWFgIAAy/SBAwdi9OjR8Pf3h6+vL4YPH46WLVsWqfSQugT6eWPTRwPx16UEfLx0B87EJcNsJ3uAmteshLlv9ZAdg4jIKTlM8SmKWbNmQaPRoEePHjCZTIiKisLXX38tOxbZsTqVQ7D0nVcAAGazGQCg0WgQn2LAjJW7sevYeZtlcdEo6NK8Nt7v29Fm6yQiUhuHOdRlCzzURf/03sIt2LTvZIkv11WjYOnEV+HhrsWhs9fg7aHDE/WqwMVJBmETEdmSUx7qIpLhw/6dUL9KOSz4aR+SDRkA7gw07tG2Hjo3qQl3Ny3Kl/XFwq0HELP1ADKzcy2vbVi1PGa+0RW5uWa8939bceH6Dbi5uqDX4/XxSmSE5cysCmX1Ut4bEZEacY/PPbjHh+4nN88MIQS0ri4FPm82C6Teug2NRgM/L3deT4eIyEa4x4eoFDzoWkAajYIAX94slYjInnFAAREREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYbDFJ+pU6eiadOm8PHxQVBQELp3747Tp09bzZOVlYXo6GgEBATA29sbPXr0QGJioqTEREREZG8cpvjs3r0b0dHR+OOPP7Bt2zbk5OSgY8eOyMjIsMwzatQobNy4EStXrsTu3bsRHx+P559/XmJqIiIisieKEELIDvEwkpOTERQUhN27d+Pxxx+HwWBAYGAgli5dip49ewIATp06hVq1aiE2NhYtWrR44DKNRiP0ej0MBgN8fX1L+y0QERFRCSjO97fD7PH5J4PBAADw9/cHABw6dAg5OTmIjIy0zFOzZk1UqlQJsbGxBS7DZDLBaDRa/RAREZHzcsjiYzabMXLkSLRu3Rp169YFACQkJMDNzQ1+fn5W8wYHByMhIaHA5UydOhV6vd7yExoaWtrRiYiISCKHLD7R0dE4ceIEli1b9kjLmThxIgwGg+Xn6tWrJZSQiIiI7JGr7ADF9eabb2LTpk349ddfUbFiRcv0kJAQZGdnIy0tzWqvT2JiIkJCQgpclk6ng06nK+3IREREZCccZo+PEAJvvvkm1q5di19++QXh4eFWz0dERECr1WLHjh2WaadPn8aVK1fQsmVLW8clIiIiO+Qwe3yio6OxdOlSrF+/Hj4+PpZxO3q9Hh4eHtDr9Rg4cCBGjx4Nf39/+Pr6Yvjw4WjZsmWRzugiIiIi5+cwp7MrilLg9JiYGPTv3x/AnQsYjhkzBj/++CNMJhOioqLw9ddfF3qo6594OjsREZHjKc73t8MUH1tg8SEiInI8qriODxEREVFxsfgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqFLv49OvXD7/++mtpZCEiIiIqVcUuPgaDAZGRkahevTqmTJmCuLi40shFREREVOKKXXzWrVuHuLg4DB06FMuXL0flypXRuXNnrFq1Cjk5OaWRkYiIiIooKcuA2OQz+PPmReSYc2XHsTuKEEI8ygIOHz6MmJgYfPvtt/D29sarr76KYcOGoXr16iWV0WaMRiP0ej0MBgN8fX1lxyEiIhXZdv0oPv1rA4y5mQAAvdYTo2s+jc4VGgMAMnKzMPPvTdh34yxcNS4YWrUjOlVsiLTsDNwwpSNXmDHxz6W4lnnTskwFCqJCGiDMqywuZCTB380L3UOboapPsJT3WFqK8/39SMXn+vXr+L//+z/ExMTg2rVr6NGjB+Li4rB7925MmzYNo0aNethFS8HiQ0REMgyMnYfjhisFPteoTGWEeQZiXdyBEltfhH84vmgyAG4a1xJbpkylWnxycnKwYcMGxMTE4Oeff0b9+vXx+uuv4+WXX7asbO3atXjttdeQmpr68O9CAhYfIiKylVxzHvKEGd+f24WYizttvv5q3sEYW7sr1lzdj0u3kuGr9UDHcg3QqXwDuLu42TzPoyjV4lO2bFmYzWa89NJLGDRoEBo2bJhvnrS0NDRq1AgXL14sVnDZWHyIiKi0bbx2EF+d2Yqb2RmyoxTIBRpEP9YRL4W3gYviGFe9KdXis3jxYvTq1Qvu7u6PFNIesfgQEVFpmnJiLdZdK7lDVqWpbWBNTGv8qkOUH5uN8XE2LD5ERFQSzGYzVl/dhwM3zkOrcUWP0GbQalwxcN882dGKxUvjhpfC26BRmXD467xRxTsIiqLIjpUPi89DYvEhIqJHtSvxL0w6sgw5Ik92lBKnQEGLstUxpeFL8HLVyY5jUZzvb/vff0VEROQgjqdextt/LnHK0gMAAgKxKWcQuePfSMh0rBOY7mLxISIiKiGf/r1BdgSbyBNmPLt7On5LOik7SrGx+BAREZWQM+nXZUewqTGHF+NXBys/LD5ERESPKE+Y8Vrs17JjSDHu8A84Y4yXHaPInOOSjURERJLkmvPQbfd0JJuMsqNIISDw6t4v4a/1wogandG5QiO7PPPrLu7xISIiegT/Pr5ataXnXjdzMvD+iVV460AM7PmEcRYfIiKih5SVm40t14/IjmFX/rh5Dh1/+QipJvu8MjWLDxER0UPIMedi+KEY2O++DXkMOZl46ffPYRZm2VHyYfEhIiJ6CEsu7sHR1MuyY9itm9kZ2BJ/RHaMfFh8iIiIiuFqxg1M+2s95p7dJjuK3Vt+OVZ2hHx4VhcREVER/ZZ0EuMO/wAzD3AVya2cLNkR8uEeHyIioiJIyTJizOHFLD3FcD0rFZm5JtkxrLD4EBERFcH8s9tlR3A4ucKMl/bMlh3DCosPERFREfyScEJ2BIcUn5WKYfu+tZtr+7D4EBERFcGtPPs6ZONIDqZeQO/fZsGQLf/aPiw+RERED5BrzoPg2J5Hcvl2Cp765WPsTvhbag4WHyIiovs4lnoZ7bZ/IDuG0xh35AekZMm7xQeLDxERUSHSsjPwxv4FyDbnyo7iVL44tVnaup2y+Hz11VeoXLky3N3d0bx5c+zfv192JCIickBfnt6CPDu87YKj25NyStq6na74LF++HKNHj8bkyZNx+PBhNGjQAFFRUUhKSpIdjYiIHMyvSfK+oJ1ZnllemXS64vPZZ59h0KBBGDBgAGrXro158+bB09MT33//vexoRETkYDJ5JlepqODpL23dTlV8srOzcejQIURGRlqmaTQaREZGIjY2//1CTCYTjEaj1Q8RERGVrrG1ukpbt1MVn5SUFOTl5SE4ONhqenBwMBISEvLNP3XqVOj1estPaGioraISEZGdyzbnwsRBzaXCw9VN2rqdqvgU18SJE2EwGCw/V69elR2JiIjshJmDmkvN1OPrpK3bqe7OXrZsWbi4uCAxMdFqemJiIkJCQvLNr9PpoNPpbBWPiIgcSEYOx/eUltO34pFrzoOrxsXm63aqPT5ubm6IiIjAjh07LNPMZjN27NiBli1bSkxGRESO5sPjq2RHcGobrh2Ssl6nKj4AMHr0aCxYsACLFi3CyZMnMXToUGRkZGDAgAGyoxERkQNIzjKi265piL1xVnYUp3Yi7YqU9TrVoS4AeOGFF5CcnIz33nsPCQkJaNiwIbZs2ZJvwDMREdE/Zeaa0Ou3z3A7L1t2FKf3n/g/0bVCBBoFhNt0vYqwl/vE2wGj0Qi9Xg+DwQBfX1/ZcYiIyMam/70BK6/8ITuGargqGuzo8N4jn+VVnO9vpzvURURE9LC2xh+VHUFVcoUZCy/ssuk6WXyIiIj+i4e4bO+XxL9suj4WHyIiov/ycNHKjqA6ueY8m66PxYeIiOi/nipXX3YE1anhW96m62PxISIi+q9XKreRHUF1RtToZNP1sfgQERH91/XMNNkRVOXZChEob+M7tbP4EBER/Vewu152BFV5o/pTNl8niw8REdF/hXkHwtfVQ3YMVWigD0Ogu+2vmcfiQ/kIYYbIOQZh+h0il3esJyJ1GfZYR9kRVEHrYvsblAJOeMsKKpg59wqQ8TWQlwy4VAS8h0PjUhZC5EFk/ABkrQVENqB4A7nxAJIsrxVuLaH4vgvFtZq8N0BEZCPPV2qO1OwMzD+3XXYUp3bKGC9lvSw+Tk6IPIjUQUD2HusnMn+E2bUpkHsEQM79F5K9HyKlB4RLFcB8HVC8AK+BUDxfgKLIaexERKVpYLX2eDGsFdrv+DcEeGen0mDr6/fcxUNdTsJszoM5LxnmvAyYTX/AnPUzzLnXIVKH5i89d+UewANLDwAgD0AmkPcXIG4C5qtA+vsQiXVhzipk2UREDs5L645BVTvIjuG0gj3kDCTnHh8HZ86NAwxjgJzDEtaeB6S9BrNrXUD/b2i0dSRkICIqPWHeZWVHcFoDq7aXsl4WHwdmzr0EpHRB0fbalKLcE8CN52CG7s5hMLcIKJ59oOhayM1FRPSI2gbVgpeLDhl5JtlRnEqEfxV0Kt9Qyrp5qMsBCfNNmNM+BFI6Q3rpsWK6cyjMtB0itS/MqSMhhFl2KCKih+buosWY2l1lx3AqLQKqY26z16Wtn3t8HIjZbAKSewHilOwoD/DfgYCmnyASt0C4NgU0OkBbF4pnbygutr0vCxHRo3imQmPoNK6YdHSZ7CgOTwMFMxq/KjkD2S1z7lWYjR/DnPYOzBkrgaTmDlB6/skM5O4Dsn8FMr6GSG4H8615skMRERXLU+XqQwNFdgyH1yGkHtxctFIzcI+PHTKbM4Gbr9wZO3NX1ip5gUrarc9gvr0K0LWH4tkdira27ERERA/k6arDrdws2TEcVh19Rfy7fm/ZMbjHxy7d6GZdepyR+QqQuRDiRneY00ZBiGzZiYiI7qtLhUayIzis8u5+iGk5DBqN/NohPwFZMWduA/IuyY5hW1n/gUgdJTsFEdF9DX+sE8poPWXHcDguUPB/rYbLjmHB4mNvMr6RnUCO7G0w394oOwURUaHcXLRY88RYNPALkx3FoTwZXAe+bvZz41cWH3uTd1F2AnmMY2A2xsBs5inwRGSfvFzdsaDFG5jfVN7p2I4mW8i5NUVhWHzsiNk4GxBG2THkuj0VSGpw5+KMRER2qlFAFTTwqyQ7hkOo6BkgO4IVFh87IEQOzMnPAre/lB3FTpiAlC68+CER2bX5zQajZdnqsmPYvYFVn5QdwQqLjx0QyU8BeY52fZ7SlgOR1Inlh4jslkajwRdNBkCn8MowhXk+tBl8tPYzvgdg8ZHOfGsxYI6XHcM+iUsQhn/JTkFEdF9l3X1lR7A7LtDglcptMKFOd9lR8mFNlUQIAWSuBm79W3YU+5a1CmaDK+AzCRqNTnYaIqJ8xtfuihGHFsmOYReeLd8EjQLC0DGkAbQu9lkxuMdHAiEEhPFfEMZ3ZEdxDJnLgKR6MN9eIzsJEVE+LQJroJZvBdkxpGsRUB3/qv88ulSIsNvSA7D4yGHaDmSulJ3C8RgnwJx9THYKIqJ8FrWKxlMh9VV5Ny9XRYPXqrTD7KYDZEcpEkUIIWSHsBdGoxF6vR4GgwG+vqVzzNacfQS4+SoA3qLhobg8Bk3gJtkpiIgKZBZmnDTEIz0nEzsSjmN93EHZkUqFh8YN3zYfDG83D4S4+0FR5Fa+4nx/2+++KCdkzj4K3HwBALvmQ8s7IzsBEVGhNIoGdfwqAgBaBFbH8bQruJCRJDlVyQr1DMA3zQYjwN1HdpSHwuJjS6mDwNJDRKQec5u9jqidU2THeGS1fSugaUA1PF2hIcK9g2XHeSQsPjZizlgCiDTZMZyCECYoCs/wIiL7V0bnjc8b98Oow4sc9r+9Ie56LGwVLTtGieHgZlu5NVt2AqchbvaRHYGIqMhaBdXAnqc+RO9KLRGo83GoAdCP+ZTDirajZccoURzcfI/SGtwszDchklqU2PIIQMAWaLRVZKcgIiq2xRd+xZwzW2THyOetx57GzqQTMGTfRll3Xwys+iSaBFSVHatIOLjZzgjD+7IjOB/ju0DAEtkpiIiKrU+Vx3HuVgI2xx+573wu0CAPpX/bnnCvIMxo3AehXgF4pUqbUl+fbCw+pcycGweY7K/ZO7ycwxAiB4qilZ2EiKjYPqjfG71CW2LOmc24nJECrcYFbQNr4qXKbeHu4ooAnTc0igYX05MQl3kT4V6BGH14MS4+5BliflpPNPALw21zNvzdvNAv/AlU9g6Cq8alhN+Z/eOhrnuUxqEuc+oowPSfElkW/YNbJDT+X8tOQURkM78lnsTMk5twM/sWtBoX5AkzbucVfl24UM8AfN3sdQS7622Y0vZ4qMtOCCEA01bZMZxX9naYc69A41pJdhIiIptoG1wLbYNrWR7fNKWj52+zcCs3K9+8gTpfLG71JjxdeRbsvXhWVykSt38AkCs7hnMzvC07ARGRNP46H2xt/w4GV4tEsE4Pb1cdKnj4Y1TNp7HxibdZegrAQ133KOlDXebEloC4UQLJqHBaaEL+kh2CiIgkKs73N/f4lCZhlJ1ABXJgvjlIdggiInIQLD6liWcc2Ub2bpizfpadgoiIHACLT2nSdZSdQD3Sv5CdgIiIHACLT2ny/UB2AvXIuyY7AREROQAWn9KU9afsBOqh8MoMRET0YCw+pcRszgaMr8uOoR5uzWQnICIiB8DiU1oME8Br+NiKAvi8IzsEERE5ABaf0sL7c9mOfiY0rqGyUxARkQNg8Sk13NtjG/7QeDwjOwQRETkIFh9ycDdlByAiIgfC4lNaNDz0Yiu86woRERUVi09p0X8qO4FKuEFRFNkhiIjIQbD4lBKNrgmAsrJjOD/3SNkJiIjIgbD4lCbv/rITODfFB/D9SHYKIiJyICw+pUjxfBmAm+wYzstnEjQab9kpiIjIgThE8bl06RIGDhyI8PBweHh4oGrVqpg8eTKys7Ot5jt27Bjatm0Ld3d3hIaGYtq0aZIS36FovAG/r6RmcGoZ38pOQEREDsYhbnB06tQpmM1mzJ8/H9WqVcOJEycwaNAgZGRkYMaMGQAAo9GIjh07IjIyEvPmzcPx48fx2muvwc/PD4MHD5aWXeP+BMxeI4CM2dIyOC3emJSIiIpJEQ56LvD06dMxd+5cXLhwAQAwd+5cTJo0CQkJCXBzu3N4acKECVi3bh1OnTpVpGUajUbo9XoYDAb4+vqWaF5zyiAgd3eJLpO8oAnhjWCJiNSuON/fDnGoqyAGgwH+/v6Wx7GxsXj88cctpQcAoqKicPr0aaSmpsqIaEXxnwHA/4HzUTHoWshOYDOmrGz8+MlazHpjPpZPX4dsU47sSEREDskhDnX907lz5zBnzhzLYS4ASEhIQHh4uNV8wcHBlufKlCmTbzkmkwkmk8ny2Gg0llJiQNHoIQK3AslNS20d6qIAPuNlh7CJL4d/hw1zt0KY/7dz9ruJS9Fz1DMYPL2vxGRERI5H6h6fCRMmQFGU+/788zBVXFwcOnXqhF69emHQoEGPtP6pU6dCr9dbfkJDS/dqyxoXfakuX1X0M6BxrSw7Ran7csR3WP/VFqvSAwDCLLBy5kYsGL8YSVdTsO3/duHwL8d4FWsiogeQOsYnOTkZN27cuO88VapUsRy+io+PR7t27dCiRQssXLgQGs3/elvfvn1hNBqxbt06y7SdO3eiffv2uHnzZpH3+ISGhpbKGJ+7zAmPlcpy1cMNKLsTGtdA2UFKnSkrG129X81Xeh7ksSZVMPzL15FhuI2yFQMQVqsiAODS31cRu+EgXF1d0P6Vtggol//fBBGRIyrOGB+ph7oCAwMRGFi0L7C4uDg8+eSTiIiIQExMjFXpAYCWLVti0qRJyMnJgVarBQBs27YNNWrUKLD0AIBOp4NOp3u0N1FsngBu23idTsRnrCpKjxACc978ttilBwDOHLyA4S3esTx2cdUAioK8nDzLtG/eXozweqH4Yu/HABTcSs2Aj7833D1t/e+BiMi2HOKsrri4OLRr1w5hYWFYtGgRXFxcLM+FhIQAuDPYuUaNGujYsSPGjx+PEydO4LXXXsOsWbOKfDp7aZ7VdZc5oTGAW6WybKeni4Ti9yUUxWHH5BfJsV//wuTnpuNWakapr0vjosCc979fATWbV8Prn7yCkPBg+Ab4wMPLvdQzEBE9quJ8fztE8Vm4cCEGDBhQ4HP3xj927Biio6Nx4MABlC1bFsOHD8f48UUfAGuT4pMYAYj0Ulm203KpCniPgOLeyWlvSLr5+x344cNVSLqSIjuKlcp1QzF6wRDUas5DtERkv5yu+NiKTYpPSlcg93SpLNsp+X4IjeeLslOUmNycXKyd/RN+XrQLpsxshNaogKyMLBzb/bfsaIVSFAWfbnsXjdrXkx2FiKhALD4PySbFJ2svkNa/VJbtjJTgo1AUD9kxSsTV03EY1mQ8sjJMD57ZzmjdXLHo3JcIrBggOwoRUT6quICho9K4twK0jWTHcBBeTlN68nLzEN10gkOWHgDIyc7FwDojcfkkbxNCRI6NxUcCxX8Z4N4N3PwP4P2G7ASP7M9fjuPDXjPxRsOxyLyVJTvOI8lMz8L7z03DlVPXkJpkkB2HiOih8FDXPWxxqOteQuRBmH4F0j8F8i6U+vocimsDKAErHHYwc0rcDUQ3m4Cb19NkRyk1lWpVwIivBqFBuzqyoxCRyvFQl4NQFBdo3J+EUnY94NZGdhw7oQO8x0JTdqXDlp6c7Bz0e2yEU5ceALhyMg5j27+P31bHyo5CRFRkLD52QFF0UMp8B2ibyY4ij/dEaELOQBNyHBrvol13yR4JIfDxS58jOzNbdhSbmfLyF8jNyZUdg4ioSFh87ISiKFD8FwMuajts4Af4b4LGu+DrNDmK7Ut/RVefV9HRpTd+X7tfdhybys3Jw6tVonFg6xHZUYiIHohjfO5h6zE+BTHnGf97B3c1/LX4QwneDUVx7NskfPfOEiz7ZJ3sGHahTLAeFaqXQ5/JvdG4A6/7Q0S2wTE+Dkzj4guU+RFO/1ej6+IUpefamXiWnnukJhpwYs8pjH/qQwxvMZGHwIjI7jj5t6tj0ugaQwn+G/B6A1DKyo5TwtyAwL3QlJnl8KXndvptRDebIDuG3Tq1/xw+fulz2TGIiKyw+NgpRdFA4zMGmuC9gC5SdpwSogCBv0Lj4vhl7sb1m3ih3GDcNmbKjmLXfl+7HxmG0r/ZKhFRUbH4OADF7yvAvQcc/q/LcwA0Lv6yUzyyqa9+gRcrvIGs2455FWZbEkJgj8oGexORfXPwb1J1UBQFGr+pQNBRwPffDnj4SwE8XobiM152kEc2b8wi/LJ0j+wYDiXxcrLsCEREFjyr6x72cFZXUZjNt4CUzoA5UXaU/JQQwH8FcHsBYE4CXMMAz8F3Bm07gShtb5jz+E+mOMoE6bH06jy4al1lRyEiJ8WzupycRuMNJfDXO3t/XKrd2QPkUh1QQm2cxOWeP7sD3uOgBO2GRhsCjf5daMrMgcZnrFOUnsyMTAxpPI6l5yGkJhkwrsOHMNwwyo5CRMQ9PvdylD0+hRFCQCRFAOJWwTO4dYOiHwuYkyCEB5A2AjCfe7iVeQ6FxnfUw4d1IDnZOXg1fJjT34KitLm5a7HgxGcoXyVEdhQicjLc46NSiqJACToEuHeH1d4YxRfwnQ2N/3QoLsFQtPWgcasGJfA/gOZ+X0LeAP55yrkb4D1BNaUHABZNXsHSUwKys3Iw5onJsmMQkcrxoLuTURQFit80ANOKNK8ouwswvAmYduB/V4tWALe2gN9caDRamHPOA7l/A66PQaOtUYrp7dNPC7bJjuA0UuJu4tSBc6jZtJrsKESkUiw+KqfRaIAyX985TJZ7CUAe4BIOjeZ/e4w02qqAtqq0jDJlm7KRfpPXoSlJs4ctwNcHPpUdg4hUioe6CMB/T5nXhkOjrWZVetTu075fyo7gdM4euoCU+JuyYxCRSrH4EBXCbDZjz5p9smM4paUfr5EdgYhUisWHqBCGlHSY88yyYzilSyeuyI5ARCrF4kNUCK0bh8CVFi+9p+wIRKRSLD5EhfD284Iry0+pcNW6IC8vT3YMIlIhFh+iQvy19xRys3Nlx3BKe9bux7cTlsiOQUQqxOJDVAh+MZeutV/8hLRkg+wYRKQyLD5EhTh14CFv50FFkpebh9gNB2XHICKVYfEhKkSuiYe5StuSj1cjIz1TdgwiUhEWH6IC8N69tpF4KRl9q0Yj25QjOwoRqQSLD1EBEi8ny46gGsaUdMwf+3+yYxCRSrD4EJF0Oxbvlh2BiFSCxYeoAIGhAVA0iuwYqnH7VpbsCESkEiw+RAVwcXFB6+7NZMdQDRdX3hiXiGyDxYeoEB7e7rIjqEaDJ2rLjkBEKsHiQ1SI3Sv3yo6gCopGQfTs12THICKVYPEhKsCVU3HIzuQp1qXN1c0VU36ahNAaFWRHISKV4B0YiQpw83qq7AhOTeOqweBpffDciKeh0fD/X0RkOyw+RAUIrx8mO4JTC6wYgB4jn5Edg4hUiP/VIiqAPsAH5auHyI7htF54u7vsCESkUiw+RIV4f/U42RGcVq0W1WVHICKVYvEhKkR43UooX417fUrDnzuOy45ARCrF4kN0H7x6c+kIqOAvOwIRqRSLD9F91GxaTXYEp9SudyvZEYhIpVh8iO5j8PQ+siM4HUWj8BR2IpKGv32I7sM/pAzqtK4hO4ZTEWYhOwIRqRiLD9EDfLxpouwITkVROG6KiORh8SF6AC+9F5p3aSw7htN4rEkV2RGISMVYfIiK4IN1b8O3rI/sGE5hzHfDZEcgIhVj8SEqAhcXF3Qb1kl2DMemAO8sfQvhdSvJTkJEKsbiQ1REnQa2lx3B4Xj6eiCoUll0H/E0fspciidfbCM7EhGpHG9SSlREQaFlEdW/HbYu3CU7isNYcyMGLi4usmMQEVlwjw9RMYz+dii6Du0oO4ZD0Oq0LD1EZHdYfIiKQaPRYMRXg7DmZgy0Ou4wvZ9yVYJkRyAiyofFh+gh+Ph5Y/n1BSw/9xHV/0nZEYiI8mHxIXpIPn7emLZ9suwYdsndS4ceo5+RHYOIKB8WH6JHULd1TejL+sqOYVc8vN3x9cFPOb6HiOwS99MTPaK83DzZEeyCi6sGQ2cNQNehHXkTUiKyWw7328lkMqFhw4ZQFAVHjhyxeu7YsWNo27Yt3N3dERoaimnTpskJSaripfeUHcEujP+/4egW3Ymlh4jsmsP9hnr77bdRvnz5fNONRiM6duyIsLAwHDp0CNOnT8f777+Pb775RkJKUpPOr3eQHUG650c9w4sTEpFDcKjis3nzZvz888+YMWNGvueWLFmC7OxsfP/996hTpw5efPFFjBgxAp999pmEpKQmvd9+Ft5lvGTHsDlFUVCnVQ0sOP4Zhs7sJzsOEVGROEzxSUxMxKBBg7B48WJ4euY/tBAbG4vHH38cbm5ulmlRUVE4ffo0UlNTC1ymyWSC0Wi0+iEqLq1Wi+9PfoGQcHVdt2Z27Mf4fM9HqFwnVHYUIqIic4jiI4RA//79MWTIEDRp0qTAeRISEhAcHGw17e7jhISEAl8zdepU6PV6y09oKH+B08MpE6TH4vNf4asDn8IvyPnP8hryWT/UbFZddgwiomKTWnwmTJgARVHu+3Pq1CnMmTMH6enpmDhxYomuf+LEiTAYDJafq1evlujySX0ei6iCFde/Re9xz8LT18My/d4/OyIvP0+UCfZDq25NsejcHPQYyWv0EJFjUoQQQtbKk5OTcePGjfvOU6VKFfTu3RsbN26EoiiW6Xl5eXBxccErr7yCRYsWoW/fvjAajVi3bp1lnp07d6J9+/a4efMmypQp88A8RqMRer0eBoMBvr7O/792Kn1msxnAnVtdrJi+HgvG/yA5UfGEhAfhy/1ToQ/gvwcisl/F+f6WWnyK6sqVK1bjb+Lj4xEVFYVVq1ahefPmqFixIubOnYtJkyYhMTERWq0WAPDOO+9gzZo1OHXqVJHWw+JDpe30wfNY8PZi/LX3NHKzc2XHKVBozfLo2L8dug6JgpcvT9UnIvvndMXnny5duoTw8HD8+eefaNiwIQDAYDCgRo0a6NixI8aPH48TJ07gtddew6xZszB48OAiLZfFh2zlliEDz5XpLzuGFRdXDf69YQKadmokOwoRUbEU5/vbaa7crNfr8fPPPyM6OhoREREoW7Ys3nvvvSKXHiJb8tZ7wdPHA7fTM2VHgYurC8bFDEP7l9taHU4mInJGDrnHp7Rwjw/Z0vf/+hE/TllT6PMaFwUxp77A9QtJOH/0Mr6buATmPHORl68owLurx2LuWzFIvlr4WLqPf5qIZp0aFys7EZE9cfpDXaWFxYds7Z2np+DAlj/zTVc0Ct5fOw6tuja1TMvNycWPn6zFnztOwMVFgyr1wxC78QCuX0jK9/omUQ3xxoy+qFwnFGazGR/0mIG96w9YzePupcP4xSPQpnuzkn9jREQ2xOLzkFh8SIbf1+3HosnLkXApCa5aF0Q81QBvzOiLshUCHvhaIQT+2nsaSVdSoHVzRYXq5VC2oj98/X3yzZt124TN326HISUdtVvWQLPOHMtDRM6BxechsfgQERE5nuJ8fzvElZuJiIiISgKLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYar7AD25O7dO4xGo+QkREREVFR3v7eLchcuFp97pKenAwBCQ0MlJyEiIqLiSk9Ph16vv+88vEnpPcxmM+Lj4+Hj4wNFUWTHsTAajQgNDcXVq1d589QSwO1Zsrg9Sxa3Z8ni9ixZ9ro9hRBIT09H+fLlodHcfxQP9/jcQ6PRoGLFirJjFMrX19euPmiOjtuzZHF7lixuz5LF7Vmy7HF7PmhPz10c3ExERESqweJDREREqsHi4wB0Oh0mT54MnU4nO4pT4PYsWdyeJYvbs2Rxe5YsZ9ieHNxMREREqsE9PkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD4OwmQyoWHDhlAUBUeOHLF67tixY2jbti3c3d0RGhqKadOmyQlp5y5duoSBAwciPDwcHh4eqFq1KiZPnozs7Gyr+bg9i+6rr75C5cqV4e7ujubNm2P//v2yIzmEqVOnomnTpvDx8UFQUBC6d++O06dPW82TlZWF6OhoBAQEwNvbGz169EBiYqKkxI7lk08+gaIoGDlypGUat2fxxMXF4dVXX0VAQAA8PDxQr149HDx40PK8EALvvfceypUrBw8PD0RGRuLs2bMSExcdi4+DePvtt1G+fPl8041GIzp27IiwsDAcOnQI06dPx/vvv49vvvlGQkr7durUKZjNZsyfPx9//fUXZs2ahXnz5uGdd96xzMPtWXTLly/H6NGjMXnyZBw+fBgNGjRAVFQUkpKSZEeze7t370Z0dDT++OMPbNu2DTk5OejYsSMyMjIs84waNQobN27EypUrsXv3bsTHx+P555+XmNoxHDhwAPPnz0f9+vWtpnN7Fl1qaipat24NrVaLzZs34++//8bMmTNRpkwZyzzTpk3D7NmzMW/ePOzbtw9eXl6IiopCVlaWxORFJMju/fTTT6JmzZrir7/+EgDEn3/+aXnu66+/FmXKlBEmk8kybfz48aJGjRoSkjqeadOmifDwcMtjbs+ia9asmYiOjrY8zsvLE+XLlxdTp06VmMoxJSUlCQBi9+7dQggh0tLShFarFStXrrTMc/LkSQFAxMbGyopp99LT00X16tXFtm3bxBNPPCHeeustIQS3Z3GNHz9etGnTptDnzWazCAkJEdOnT7dMS0tLEzqdTvz444+2iPhIuMfHziUmJmLQoEFYvHgxPD098z0fGxuLxx9/HG5ubpZpUVFROH36NFJTU20Z1SEZDAb4+/tbHnN7Fk12djYOHTqEyMhIyzSNRoPIyEjExsZKTOaYDAYDAFg+i4cOHUJOTo7V9q1ZsyYqVarE7Xsf0dHR6NKli9V2A7g9i2vDhg1o0qQJevXqhaCgIDRq1AgLFiywPH/x4kUkJCRYbU+9Xo/mzZs7xPZk8bFjQgj0798fQ4YMQZMmTQqcJyEhAcHBwVbT7j5OSEgo9YyO7Ny5c5gzZw7eeOMNyzRuz6JJSUlBXl5egduK26l4zGYzRo4cidatW6Nu3boA7nzW3Nzc4OfnZzUvt2/hli1bhsOHD2Pq1Kn5nuP2LJ4LFy5g7ty5qF69OrZu3YqhQ4dixIgRWLRoEYD//S501H//LD4STJgwAYqi3Pfn1KlTmDNnDtLT0zFx4kTZke1aUbfnveLi4tCpUyf06tULgwYNkpSc6M5eihMnTmDZsmWyozisq1ev4q233sKSJUvg7u4uO47DM5vNaNy4MaZMmYJGjRph8ODBGDRoEObNmyc7WolwlR1AjcaMGYP+/fvfd54qVargl19+QWxsbL57ojRp0gSvvPIKFi1ahJCQkHxnJtx9HBISUqK57VVRt+dd8fHxePLJJ9GqVat8g5a5PYumbNmycHFxKXBbcTsV3ZtvvolNmzbh119/RcWKFS3TQ0JCkJ2djbS0NKu9FNy+BTt06BCSkpLQuHFjy7S8vDz8+uuv+PLLL7F161Zuz2IoV64cateubTWtVq1aWL16NYD//S5MTExEuXLlLPMkJiaiYcOGNsv5sFh8JAgMDERgYOAD55s9ezY++ugjy+P4+HhERUVh+fLlaN68OQCgZcuWmDRpEnJycqDVagEA27ZtQ40aNaxG4Duzom5P4M6enieffBIRERGIiYmBRmO905Pbs2jc3NwQERGBHTt2oHv37gDu/C9xx44dePPNN+WGcwBCCAwfPhxr167Frl27EB4ebvV8REQEtFotduzYgR49egAATp8+jStXrqBly5YyItu1Dh064Pjx41bTBgwYgJo1a2L8+PEIDQ3l9iyG1q1b57u8wpkzZxAWFgYACA8PR0hICHbs2GEpOkajEfv27cPQoUNtHbf4ZI+upqK7ePFivrO60tLSRHBwsOjTp484ceKEWLZsmfD09BTz58+XF9ROXbt2TVSrVk106NBBXLt2TVy/ft3ycxe3Z9EtW7ZM6HQ6sXDhQvH333+LwYMHCz8/P5GQkCA7mt0bOnSo0Ov1YteuXVafw9u3b1vmGTJkiKhUqZL45ZdfxMGDB0XLli1Fy5YtJaZ2LPee1SUEt2dx7N+/X7i6uoqPP/5YnD17VixZskR4enqKH374wTLPJ598Ivz8/MT69evFsWPHRLdu3UR4eLjIzMyUmLxoWHwcSEHFRwghjh49Ktq0aSN0Op2oUKGC+OSTT+QEtHMxMTECQIE/9+L2LLo5c+aISpUqCTc3N9GsWTPxxx9/yI7kEAr7HMbExFjmyczMFMOGDRNlypQRnp6e4rnnnrMq6XR//yw+3J7Fs3HjRlG3bl2h0+lEzZo1xTfffGP1vNlsFu+++64IDg4WOp1OdOjQQZw+fVpS2uJRhBBCxp4mIiIiIlvjWV1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+ROTUkpOTERISgilTplim7d27F25ubtixY4fEZEQkA+/VRURO76effkL37t2xd+9e1KhRAw0bNkS3bt3w2WefyY5GRDbG4kNEqhAdHY3t27ejSZMmOH78OA4cOACdTic7FhHZGIsPEalCZmYm6tati6tXr+LQoUOoV6+e7EhEJAHH+BCRKpw/fx7x8fEwm824dOmS7DhEJAn3+BCR08vOzkazZs3QsGFD1KhRA59//jmOHz+OoKAg2dGIyMZYfIjI6Y0bNw6rVq3C0aNH4e3tjSeeeAJ6vR6bNm2SHY2IbIyHuojIqe3atQuff/45Fi9eDF9fX2g0GixevBi//fYb5s6dKzseEdkY9/gQERGRanCPDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqcb/AzJ0sogSJIg/AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for emb, title in zip(\n",
+ " [embedding_intelex, embedding_original],\n",
+ " [\"Intel® Extension for scikit-learn\", \"Original scikit-learn\"],\n",
+ "):\n",
+ " plt.scatter(emb[:, 0], emb[:, 1], c=colors)\n",
+ " plt.title(title)\n",
+ " plt.xlabel(\"x\")\n",
+ " plt.ylabel(\"y\")\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Speedup for this run: 3.0'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Speedup for this run: {(time_original/time_opt):.1f}\""
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/_sources/support.rst.txt b/2024.3/_sources/support.rst.txt
new file mode 100644
index 0000000000..03a2dddadb
--- /dev/null
+++ b/2024.3/_sources/support.rst.txt
@@ -0,0 +1,34 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+######################################################
+Intel(R) Extension for Scikit-learn Support
+######################################################
+
+
+We are committed to providing support and assistance to help you make the most out of Intel(R) Extension for Scikit-learn.
+
+Use the following methods if you face any challenges.
+
+
+Issues
+----------------------------------
+
+If you have a problem, check out the `GitHub Issues `_ to see if the issue you want to address is already reported.
+
+You may find users that have encountered the same bug or have similar ideas for changes or updates.
+
+You can use issues to report a problem, make a feature request, or add comments on an existing issue.
diff --git a/2024.3/_sources/tutorials.rst.txt b/2024.3/_sources/tutorials.rst.txt
new file mode 100644
index 0000000000..ce778bb5ab
--- /dev/null
+++ b/2024.3/_sources/tutorials.rst.txt
@@ -0,0 +1,92 @@
+.. ******************************************************************************
+.. * Copyright 2024 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+
+################################################
+|intelex| Tutorials & Case Studies
+################################################
+
+Explore the tutorials & case studies to help you to harness the full potential of |intelex|.
+
+Tutorials
+----------------------------------
+
+.. grid:: 3
+
+ .. grid-item-card:: Introduction to scikit-learn* Essentials for Machine Learning
+ :link: https://www.intel.com/content/www/us/en/developer/videos/introduction-to-scikit-learn-essentials-for-ml.html
+ :padding: 1
+
+ An overview of scikit-learn essentials.
+
+ .. grid-item-card:: Advanced scikit-learn* Essentials for Machine Learning
+ :link: https://www.intel.com/content/www/us/en/developer/videos/advanced-scikit-learn-essentials-for-ml.html
+ :padding: 1
+
+ Special technique to perform scikit-learn computation on Intel GPUs.
+
+ .. grid-item-card:: Develop Efficient AI Solutions with Accelerated Machine Learning
+ :link: https://www.intel.com/content/www/us/en/developer/videos/accelerated-machine-learning-for-ai-solutions.html
+ :padding: 1
+
+ Techniques for maximizing Intel® Extension for Scikit-learn*.
+
+ .. grid-item-card:: Getting started with classical Machine Learning Frameworks using Google Colaboratory
+ :link: https://community.intel.com/t5/Blogs/Tech-Innovation/Artificial-Intelligence-AI/Getting-started-with-classical-Machine-Learning-Frameworks-using/post/1450139
+ :padding: 1
+
+ Simple Installation of Intel® Extension for Scikit-learn* on Google Colaboratory.
+
+ .. grid-item-card:: Accelerate Machine Learning Workloads: K-means and GPairs Algorithms
+ :link: https://www.intel.com/content/www/us/en/developer/videos/accelerate-ml-workloads-k-means-gpairs-algorithms.html
+ :padding: 1
+
+ An introduction to Intel® Extension for Scikit-learn*.
+
+ .. grid-item-card:: Benchmarking Intel® Extension for Scikit-learn*: How Much Faster Is It?
+ :link: https://www.intel.com/content/www/us/en/developer/articles/technical/benchmarking-intel-extension-for-scikit-learn.html
+ :padding: 1
+
+ Explore and compare the performance of the Intel Extension for Scikit-learn* vs. stock Scikit-learn*.
+
+ .. grid-item-card:: Drive Innovation & Performance into Your scikit-learn* Machine Learning Tasks
+ :link: https://www.intel.com/content/www/us/en/developer/videos/drive-innovation-performance-scikit-learn-ml-tasks.html
+ :padding: 1
+
+ An overview of scikit-learn essentials.
+
+Case Studies
+----------------------------------
+
+.. grid:: 3
+
+ .. grid-item-card:: Greener Machine Learning Computing with Intel® AI Acceleration
+ :link: https://www.intel.com/content/www/us/en/developer/articles/case-study/greener-machine-learning-with-intel-ai.html
+ :padding: 1
+
+ Lowering the Environmental Impact of AI Workloads by 7x using Intel® Extension for Scikit-learn*.
+
+ .. grid-item-card:: Supply Chain Optimization at Enterprise Scale
+ :link: https://www.intel.com/content/www/us/en/developer/articles/technical/supply-chain-optimization-at-enterprise-scale.html
+ :padding: 1
+
+ Leveraging Open-Source AI Technologies with Red Hat OpenShift* Data Science and Intel® Architecture.
+
+ .. grid-item-card:: HippoScreen Improves AI Performance by 2.4x with oneAPI Tools
+ :link: https://www.intel.com/content/www/us/en/developer/articles/case-study/hipposcreen-boosts-ai-performance-2-4x-with-oneapi.html
+ :padding: 1
+
+ The neurotechnology startup used |intelex| to the improve efficiency and build times of deep-learning models used in its Brain Waves AI system.
\ No newline at end of file
diff --git a/2024.3/_sources/verbose.rst.txt b/2024.3/_sources/verbose.rst.txt
new file mode 100644
index 0000000000..cf77cc0669
--- /dev/null
+++ b/2024.3/_sources/verbose.rst.txt
@@ -0,0 +1,54 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _verbose:
+
+############
+Verbose Mode
+############
+
+Use |intelex| in verbose mode to find out which implementation of the algorithm is currently used,
+|intelex| or original Scikit-learn.
+
+.. note:: Verbose mode is only available for :ref:`supported algorithms `.
+
+To enable verbose mode, set the ``SKLEARNEX_VERBOSE`` environment variable as shown below:
+
+- On Linux* OS ::
+
+ export SKLEARNEX_VERBOSE=INFO
+
+- On Windows* OS ::
+
+ set SKLEARNEX_VERBOSE=INFO
+
+Alternatively, get |intelex| logger and set its logging level in the Python code::
+
+ import logging
+ logger = logging.getLogger('sklearnex')
+ logger.setLevel(logging.INFO)
+
+During the calls that use Intel-optimized scikit-learn, you will receive additional print statements
+that indicate which implementation is being called.
+These print statements are only available for :ref:`supported algorithms `.
+
+For example, for DBSCAN you get one of these print statements depending on which implementation is used::
+
+ INFO:sklearnex: sklearn.cluster.DBSCAN.fit: running accelerated version on CPU
+
+::
+
+ INFO:sklearnex: sklearn.cluster.DBSCAN.fit: fallback to original Scikit-learn
diff --git a/2024.3/_sphinx_design_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css b/2024.3/_sphinx_design_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css
new file mode 100644
index 0000000000..eb19f698af
--- /dev/null
+++ b/2024.3/_sphinx_design_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css
@@ -0,0 +1 @@
+.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-hide-link-text{font-size:0}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #0071bc;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0060a0;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem}
diff --git a/2024.3/_sphinx_design_static/design-tabs.js b/2024.3/_sphinx_design_static/design-tabs.js
new file mode 100644
index 0000000000..36b38cf0d9
--- /dev/null
+++ b/2024.3/_sphinx_design_static/design-tabs.js
@@ -0,0 +1,27 @@
+var sd_labels_by_text = {};
+
+function ready() {
+ const li = document.getElementsByClassName("sd-tab-label");
+ for (const label of li) {
+ syncId = label.getAttribute("data-sync-id");
+ if (syncId) {
+ label.onclick = onLabelClick;
+ if (!sd_labels_by_text[syncId]) {
+ sd_labels_by_text[syncId] = [];
+ }
+ sd_labels_by_text[syncId].push(label);
+ }
+ }
+}
+
+function onLabelClick() {
+ // Activate other inputs with the same sync id.
+ syncId = this.getAttribute("data-sync-id");
+ for (label of sd_labels_by_text[syncId]) {
+ if (label === this) continue;
+ label.previousElementSibling.checked = true;
+ }
+ window.localStorage.setItem("sphinx-design-last-tab", syncId);
+}
+
+document.addEventListener("DOMContentLoaded", ready, false);
diff --git a/2024.3/_static/_sphinx_javascript_frameworks_compat.js b/2024.3/_static/_sphinx_javascript_frameworks_compat.js
new file mode 100644
index 0000000000..81415803ec
--- /dev/null
+++ b/2024.3/_static/_sphinx_javascript_frameworks_compat.js
@@ -0,0 +1,123 @@
+/* Compatability shim for jQuery and underscores.js.
+ *
+ * Copyright Sphinx contributors
+ * Released under the two clause BSD licence
+ */
+
+/**
+ * small helper function to urldecode strings
+ *
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL
+ */
+jQuery.urldecode = function(x) {
+ if (!x) {
+ return x
+ }
+ return decodeURIComponent(x.replace(/\+/g, ' '));
+};
+
+/**
+ * small helper function to urlencode strings
+ */
+jQuery.urlencode = encodeURIComponent;
+
+/**
+ * This function returns the parsed url parameters of the
+ * current request. Multiple values per key are supported,
+ * it will always return arrays of strings for the value parts.
+ */
+jQuery.getQueryParameters = function(s) {
+ if (typeof s === 'undefined')
+ s = document.location.search;
+ var parts = s.substr(s.indexOf('?') + 1).split('&');
+ var result = {};
+ for (var i = 0; i < parts.length; i++) {
+ var tmp = parts[i].split('=', 2);
+ var key = jQuery.urldecode(tmp[0]);
+ var value = jQuery.urldecode(tmp[1]);
+ if (key in result)
+ result[key].push(value);
+ else
+ result[key] = [value];
+ }
+ return result;
+};
+
+/**
+ * highlight a given string on a jquery object by wrapping it in
+ * span elements with the given class name.
+ */
+jQuery.fn.highlightText = function(text, className) {
+ function highlight(node, addItems) {
+ if (node.nodeType === 3) {
+ var val = node.nodeValue;
+ var pos = val.toLowerCase().indexOf(text);
+ if (pos >= 0 &&
+ !jQuery(node.parentNode).hasClass(className) &&
+ !jQuery(node.parentNode).hasClass("nohighlight")) {
+ var span;
+ var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg");
+ if (isInSVG) {
+ span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+ } else {
+ span = document.createElement("span");
+ span.className = className;
+ }
+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+ node.parentNode.insertBefore(span, node.parentNode.insertBefore(
+ document.createTextNode(val.substr(pos + text.length)),
+ node.nextSibling));
+ node.nodeValue = val.substr(0, pos);
+ if (isInSVG) {
+ var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect");
+ var bbox = node.parentElement.getBBox();
+ rect.x.baseVal.value = bbox.x;
+ rect.y.baseVal.value = bbox.y;
+ rect.width.baseVal.value = bbox.width;
+ rect.height.baseVal.value = bbox.height;
+ rect.setAttribute('class', className);
+ addItems.push({
+ "parent": node.parentNode,
+ "target": rect});
+ }
+ }
+ }
+ else if (!jQuery(node).is("button, select, textarea")) {
+ jQuery.each(node.childNodes, function() {
+ highlight(this, addItems);
+ });
+ }
+ }
+ var addItems = [];
+ var result = this.each(function() {
+ highlight(this, addItems);
+ });
+ for (var i = 0; i < addItems.length; ++i) {
+ jQuery(addItems[i].parent).before(addItems[i].target);
+ }
+ return result;
+};
+
+/*
+ * backward compatibility for jQuery.browser
+ * This will be supported until firefox bug is fixed.
+ */
+if (!jQuery.browser) {
+ jQuery.uaMatch = function(ua) {
+ ua = ua.toLowerCase();
+
+ var match = /(chrome)[ \/]([\w.]+)/.exec(ua) ||
+ /(webkit)[ \/]([\w.]+)/.exec(ua) ||
+ /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) ||
+ /(msie) ([\w.]+)/.exec(ua) ||
+ ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) ||
+ [];
+
+ return {
+ browser: match[ 1 ] || "",
+ version: match[ 2 ] || "0"
+ };
+ };
+ jQuery.browser = {};
+ jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true;
+}
diff --git a/2024.3/_static/basic.css b/2024.3/_static/basic.css
new file mode 100644
index 0000000000..7577acb1ad
--- /dev/null
+++ b/2024.3/_static/basic.css
@@ -0,0 +1,903 @@
+/*
+ * basic.css
+ * ~~~~~~~~~
+ *
+ * Sphinx stylesheet -- basic theme.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+
+/* -- main layout ----------------------------------------------------------- */
+
+div.clearer {
+ clear: both;
+}
+
+div.section::after {
+ display: block;
+ content: '';
+ clear: left;
+}
+
+/* -- relbar ---------------------------------------------------------------- */
+
+div.related {
+ width: 100%;
+ font-size: 90%;
+}
+
+div.related h3 {
+ display: none;
+}
+
+div.related ul {
+ margin: 0;
+ padding: 0 0 0 10px;
+ list-style: none;
+}
+
+div.related li {
+ display: inline;
+}
+
+div.related li.right {
+ float: right;
+ margin-right: 5px;
+}
+
+/* -- sidebar --------------------------------------------------------------- */
+
+div.sphinxsidebarwrapper {
+ padding: 10px 5px 0 10px;
+}
+
+div.sphinxsidebar {
+ float: left;
+ width: 230px;
+ margin-left: -100%;
+ font-size: 90%;
+ word-wrap: break-word;
+ overflow-wrap : break-word;
+}
+
+div.sphinxsidebar ul {
+ list-style: none;
+}
+
+div.sphinxsidebar ul ul,
+div.sphinxsidebar ul.want-points {
+ margin-left: 20px;
+ list-style: square;
+}
+
+div.sphinxsidebar ul ul {
+ margin-top: 0;
+ margin-bottom: 0;
+}
+
+div.sphinxsidebar form {
+ margin-top: 10px;
+}
+
+div.sphinxsidebar input {
+ border: 1px solid #98dbcc;
+ font-family: sans-serif;
+ font-size: 1em;
+}
+
+div.sphinxsidebar #searchbox form.search {
+ overflow: hidden;
+}
+
+div.sphinxsidebar #searchbox input[type="text"] {
+ float: left;
+ width: 80%;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+div.sphinxsidebar #searchbox input[type="submit"] {
+ float: left;
+ width: 20%;
+ border-left: none;
+ padding: 0.25em;
+ box-sizing: border-box;
+}
+
+
+img {
+ border: 0;
+ max-width: 100%;
+}
+
+/* -- search page ----------------------------------------------------------- */
+
+ul.search {
+ margin: 10px 0 0 20px;
+ padding: 0;
+}
+
+ul.search li {
+ padding: 5px 0 5px 20px;
+ background-image: url(file.png);
+ background-repeat: no-repeat;
+ background-position: 0 7px;
+}
+
+ul.search li a {
+ font-weight: bold;
+}
+
+ul.search li p.context {
+ color: #888;
+ margin: 2px 0 0 30px;
+ text-align: left;
+}
+
+ul.keywordmatches li.goodmatch a {
+ font-weight: bold;
+}
+
+/* -- index page ------------------------------------------------------------ */
+
+table.contentstable {
+ width: 90%;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table.contentstable p.biglink {
+ line-height: 150%;
+}
+
+a.biglink {
+ font-size: 1.3em;
+}
+
+span.linkdescr {
+ font-style: italic;
+ padding-top: 5px;
+ font-size: 90%;
+}
+
+/* -- general index --------------------------------------------------------- */
+
+table.indextable {
+ width: 100%;
+}
+
+table.indextable td {
+ text-align: left;
+ vertical-align: top;
+}
+
+table.indextable ul {
+ margin-top: 0;
+ margin-bottom: 0;
+ list-style-type: none;
+}
+
+table.indextable > tbody > tr > td > ul {
+ padding-left: 0em;
+}
+
+table.indextable tr.pcap {
+ height: 10px;
+}
+
+table.indextable tr.cap {
+ margin-top: 10px;
+ background-color: #f2f2f2;
+}
+
+img.toggler {
+ margin-right: 3px;
+ margin-top: 3px;
+ cursor: pointer;
+}
+
+div.modindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+div.genindex-jumpbox {
+ border-top: 1px solid #ddd;
+ border-bottom: 1px solid #ddd;
+ margin: 1em 0 1em 0;
+ padding: 0.4em;
+}
+
+/* -- domain module index --------------------------------------------------- */
+
+table.modindextable td {
+ padding: 2px;
+ border-collapse: collapse;
+}
+
+/* -- general body styles --------------------------------------------------- */
+
+div.body {
+ min-width: 360px;
+ max-width: 800px;
+}
+
+div.body p, div.body dd, div.body li, div.body blockquote {
+ -moz-hyphens: auto;
+ -ms-hyphens: auto;
+ -webkit-hyphens: auto;
+ hyphens: auto;
+}
+
+a.headerlink {
+ visibility: hidden;
+}
+
+h1:hover > a.headerlink,
+h2:hover > a.headerlink,
+h3:hover > a.headerlink,
+h4:hover > a.headerlink,
+h5:hover > a.headerlink,
+h6:hover > a.headerlink,
+dt:hover > a.headerlink,
+caption:hover > a.headerlink,
+p.caption:hover > a.headerlink,
+div.code-block-caption:hover > a.headerlink {
+ visibility: visible;
+}
+
+div.body p.caption {
+ text-align: inherit;
+}
+
+div.body td {
+ text-align: left;
+}
+
+.first {
+ margin-top: 0 !important;
+}
+
+p.rubric {
+ margin-top: 30px;
+ font-weight: bold;
+}
+
+img.align-left, figure.align-left, .figure.align-left, object.align-left {
+ clear: left;
+ float: left;
+ margin-right: 1em;
+}
+
+img.align-right, figure.align-right, .figure.align-right, object.align-right {
+ clear: right;
+ float: right;
+ margin-left: 1em;
+}
+
+img.align-center, figure.align-center, .figure.align-center, object.align-center {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+img.align-default, figure.align-default, .figure.align-default {
+ display: block;
+ margin-left: auto;
+ margin-right: auto;
+}
+
+.align-left {
+ text-align: left;
+}
+
+.align-center {
+ text-align: center;
+}
+
+.align-default {
+ text-align: center;
+}
+
+.align-right {
+ text-align: right;
+}
+
+/* -- sidebars -------------------------------------------------------------- */
+
+div.sidebar,
+aside.sidebar {
+ margin: 0 0 0.5em 1em;
+ border: 1px solid #ddb;
+ padding: 7px;
+ background-color: #ffe;
+ width: 40%;
+ float: right;
+ clear: right;
+ overflow-x: auto;
+}
+
+p.sidebar-title {
+ font-weight: bold;
+}
+
+nav.contents,
+aside.topic,
+div.admonition, div.topic, blockquote {
+ clear: left;
+}
+
+/* -- topics ---------------------------------------------------------------- */
+
+nav.contents,
+aside.topic,
+div.topic {
+ border: 1px solid #ccc;
+ padding: 7px;
+ margin: 10px 0 10px 0;
+}
+
+p.topic-title {
+ font-size: 1.1em;
+ font-weight: bold;
+ margin-top: 10px;
+}
+
+/* -- admonitions ----------------------------------------------------------- */
+
+div.admonition {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ padding: 7px;
+}
+
+div.admonition dt {
+ font-weight: bold;
+}
+
+p.admonition-title {
+ margin: 0px 10px 5px 0px;
+ font-weight: bold;
+}
+
+div.body p.centered {
+ text-align: center;
+ margin-top: 25px;
+}
+
+/* -- content of sidebars/topics/admonitions -------------------------------- */
+
+div.sidebar > :last-child,
+aside.sidebar > :last-child,
+nav.contents > :last-child,
+aside.topic > :last-child,
+div.topic > :last-child,
+div.admonition > :last-child {
+ margin-bottom: 0;
+}
+
+div.sidebar::after,
+aside.sidebar::after,
+nav.contents::after,
+aside.topic::after,
+div.topic::after,
+div.admonition::after,
+blockquote::after {
+ display: block;
+ content: '';
+ clear: both;
+}
+
+/* -- tables ---------------------------------------------------------------- */
+
+table.docutils {
+ margin-top: 10px;
+ margin-bottom: 10px;
+ border: 0;
+ border-collapse: collapse;
+}
+
+table.align-center {
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table.align-default {
+ margin-left: auto;
+ margin-right: auto;
+}
+
+table caption span.caption-number {
+ font-style: italic;
+}
+
+table caption span.caption-text {
+}
+
+table.docutils td, table.docutils th {
+ padding: 1px 8px 1px 5px;
+ border-top: 0;
+ border-left: 0;
+ border-right: 0;
+ border-bottom: 1px solid #aaa;
+}
+
+th {
+ text-align: left;
+ padding-right: 5px;
+}
+
+table.citation {
+ border-left: solid 1px gray;
+ margin-left: 1px;
+}
+
+table.citation td {
+ border-bottom: none;
+}
+
+th > :first-child,
+td > :first-child {
+ margin-top: 0px;
+}
+
+th > :last-child,
+td > :last-child {
+ margin-bottom: 0px;
+}
+
+/* -- figures --------------------------------------------------------------- */
+
+div.figure, figure {
+ margin: 0.5em;
+ padding: 0.5em;
+}
+
+div.figure p.caption, figcaption {
+ padding: 0.3em;
+}
+
+div.figure p.caption span.caption-number,
+figcaption span.caption-number {
+ font-style: italic;
+}
+
+div.figure p.caption span.caption-text,
+figcaption span.caption-text {
+}
+
+/* -- field list styles ----------------------------------------------------- */
+
+table.field-list td, table.field-list th {
+ border: 0 !important;
+}
+
+.field-list ul {
+ margin: 0;
+ padding-left: 1em;
+}
+
+.field-list p {
+ margin: 0;
+}
+
+.field-name {
+ -moz-hyphens: manual;
+ -ms-hyphens: manual;
+ -webkit-hyphens: manual;
+ hyphens: manual;
+}
+
+/* -- hlist styles ---------------------------------------------------------- */
+
+table.hlist {
+ margin: 1em 0;
+}
+
+table.hlist td {
+ vertical-align: top;
+}
+
+/* -- object description styles --------------------------------------------- */
+
+.sig {
+ font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace;
+}
+
+.sig-name, code.descname {
+ background-color: transparent;
+ font-weight: bold;
+}
+
+.sig-name {
+ font-size: 1.1em;
+}
+
+code.descname {
+ font-size: 1.2em;
+}
+
+.sig-prename, code.descclassname {
+ background-color: transparent;
+}
+
+.optional {
+ font-size: 1.3em;
+}
+
+.sig-paren {
+ font-size: larger;
+}
+
+.sig-param.n {
+ font-style: italic;
+}
+
+/* C++ specific styling */
+
+.sig-inline.c-texpr,
+.sig-inline.cpp-texpr {
+ font-family: unset;
+}
+
+.sig.c .k, .sig.c .kt,
+.sig.cpp .k, .sig.cpp .kt {
+ color: #0033B3;
+}
+
+.sig.c .m,
+.sig.cpp .m {
+ color: #1750EB;
+}
+
+.sig.c .s, .sig.c .sc,
+.sig.cpp .s, .sig.cpp .sc {
+ color: #067D17;
+}
+
+
+/* -- other body styles ----------------------------------------------------- */
+
+ol.arabic {
+ list-style: decimal;
+}
+
+ol.loweralpha {
+ list-style: lower-alpha;
+}
+
+ol.upperalpha {
+ list-style: upper-alpha;
+}
+
+ol.lowerroman {
+ list-style: lower-roman;
+}
+
+ol.upperroman {
+ list-style: upper-roman;
+}
+
+:not(li) > ol > li:first-child > :first-child,
+:not(li) > ul > li:first-child > :first-child {
+ margin-top: 0px;
+}
+
+:not(li) > ol > li:last-child > :last-child,
+:not(li) > ul > li:last-child > :last-child {
+ margin-bottom: 0px;
+}
+
+ol.simple ol p,
+ol.simple ul p,
+ul.simple ol p,
+ul.simple ul p {
+ margin-top: 0;
+}
+
+ol.simple > li:not(:first-child) > p,
+ul.simple > li:not(:first-child) > p {
+ margin-top: 0;
+}
+
+ol.simple p,
+ul.simple p {
+ margin-bottom: 0;
+}
+
+aside.footnote > span,
+div.citation > span {
+ float: left;
+}
+aside.footnote > span:last-of-type,
+div.citation > span:last-of-type {
+ padding-right: 0.5em;
+}
+aside.footnote > p {
+ margin-left: 2em;
+}
+div.citation > p {
+ margin-left: 4em;
+}
+aside.footnote > p:last-of-type,
+div.citation > p:last-of-type {
+ margin-bottom: 0em;
+}
+aside.footnote > p:last-of-type:after,
+div.citation > p:last-of-type:after {
+ content: "";
+ clear: both;
+}
+
+dl.field-list {
+ display: grid;
+ grid-template-columns: fit-content(30%) auto;
+}
+
+dl.field-list > dt {
+ font-weight: bold;
+ word-break: break-word;
+ padding-left: 0.5em;
+ padding-right: 5px;
+}
+
+dl.field-list > dd {
+ padding-left: 0.5em;
+ margin-top: 0em;
+ margin-left: 0em;
+ margin-bottom: 0em;
+}
+
+dl {
+ margin-bottom: 15px;
+}
+
+dd > :first-child {
+ margin-top: 0px;
+}
+
+dd ul, dd table {
+ margin-bottom: 10px;
+}
+
+dd {
+ margin-top: 3px;
+ margin-bottom: 10px;
+ margin-left: 30px;
+}
+
+dl > dd:last-child,
+dl > dd:last-child > :last-child {
+ margin-bottom: 0;
+}
+
+dt:target, span.highlighted {
+ background-color: #fbe54e;
+}
+
+rect.highlighted {
+ fill: #fbe54e;
+}
+
+dl.glossary dt {
+ font-weight: bold;
+ font-size: 1.1em;
+}
+
+.versionmodified {
+ font-style: italic;
+}
+
+.system-message {
+ background-color: #fda;
+ padding: 5px;
+ border: 3px solid red;
+}
+
+.footnote:target {
+ background-color: #ffa;
+}
+
+.line-block {
+ display: block;
+ margin-top: 1em;
+ margin-bottom: 1em;
+}
+
+.line-block .line-block {
+ margin-top: 0;
+ margin-bottom: 0;
+ margin-left: 1.5em;
+}
+
+.guilabel, .menuselection {
+ font-family: sans-serif;
+}
+
+.accelerator {
+ text-decoration: underline;
+}
+
+.classifier {
+ font-style: oblique;
+}
+
+.classifier:before {
+ font-style: normal;
+ margin: 0 0.5em;
+ content: ":";
+ display: inline-block;
+}
+
+abbr, acronym {
+ border-bottom: dotted 1px;
+ cursor: help;
+}
+
+/* -- code displays --------------------------------------------------------- */
+
+pre {
+ overflow: auto;
+ overflow-y: hidden; /* fixes display issues on Chrome browsers */
+}
+
+pre, div[class*="highlight-"] {
+ clear: both;
+}
+
+span.pre {
+ -moz-hyphens: none;
+ -ms-hyphens: none;
+ -webkit-hyphens: none;
+ hyphens: none;
+ white-space: nowrap;
+}
+
+div[class*="highlight-"] {
+ margin: 1em 0;
+}
+
+td.linenos pre {
+ border: 0;
+ background-color: transparent;
+ color: #aaa;
+}
+
+table.highlighttable {
+ display: block;
+}
+
+table.highlighttable tbody {
+ display: block;
+}
+
+table.highlighttable tr {
+ display: flex;
+}
+
+table.highlighttable td {
+ margin: 0;
+ padding: 0;
+}
+
+table.highlighttable td.linenos {
+ padding-right: 0.5em;
+}
+
+table.highlighttable td.code {
+ flex: 1;
+ overflow: hidden;
+}
+
+.highlight .hll {
+ display: block;
+}
+
+div.highlight pre,
+table.highlighttable pre {
+ margin: 0;
+}
+
+div.code-block-caption + div {
+ margin-top: 0;
+}
+
+div.code-block-caption {
+ margin-top: 1em;
+ padding: 2px 5px;
+ font-size: small;
+}
+
+div.code-block-caption code {
+ background-color: transparent;
+}
+
+table.highlighttable td.linenos,
+span.linenos,
+div.highlight span.gp { /* gp: Generic.Prompt */
+ user-select: none;
+ -webkit-user-select: text; /* Safari fallback only */
+ -webkit-user-select: none; /* Chrome/Safari */
+ -moz-user-select: none; /* Firefox */
+ -ms-user-select: none; /* IE10+ */
+}
+
+div.code-block-caption span.caption-number {
+ padding: 0.1em 0.3em;
+ font-style: italic;
+}
+
+div.code-block-caption span.caption-text {
+}
+
+div.literal-block-wrapper {
+ margin: 1em 0;
+}
+
+code.xref, a code {
+ background-color: transparent;
+ font-weight: bold;
+}
+
+h1 code, h2 code, h3 code, h4 code, h5 code, h6 code {
+ background-color: transparent;
+}
+
+.viewcode-link {
+ float: right;
+}
+
+.viewcode-back {
+ float: right;
+ font-family: sans-serif;
+}
+
+div.viewcode-block:target {
+ margin: -1px -10px;
+ padding: 0 10px;
+}
+
+/* -- math display ---------------------------------------------------------- */
+
+img.math {
+ vertical-align: middle;
+}
+
+div.body div.math p {
+ text-align: center;
+}
+
+span.eqno {
+ float: right;
+}
+
+span.eqno a.headerlink {
+ position: absolute;
+ z-index: 1;
+}
+
+div.math:hover a.headerlink {
+ visibility: visible;
+}
+
+/* -- printout stylesheet --------------------------------------------------- */
+
+@media print {
+ div.document,
+ div.documentwrapper,
+ div.bodywrapper {
+ margin: 0 !important;
+ width: 100%;
+ }
+
+ div.sphinxsidebar,
+ div.related,
+ div.footer,
+ #top-link {
+ display: none;
+ }
+}
\ No newline at end of file
diff --git a/2024.3/_static/check-solid.svg b/2024.3/_static/check-solid.svg
new file mode 100644
index 0000000000..92fad4b5c0
--- /dev/null
+++ b/2024.3/_static/check-solid.svg
@@ -0,0 +1,4 @@
+
+
+
+
diff --git a/2024.3/_static/clipboard.min.js b/2024.3/_static/clipboard.min.js
new file mode 100644
index 0000000000..54b3c46381
--- /dev/null
+++ b/2024.3/_static/clipboard.min.js
@@ -0,0 +1,7 @@
+/*!
+ * clipboard.js v2.0.8
+ * https://clipboardjs.com/
+ *
+ * Licensed MIT © Zeno Rocha
+ */
+!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1
+
+
+
+
diff --git a/2024.3/_static/copybutton.css b/2024.3/_static/copybutton.css
new file mode 100644
index 0000000000..f1916ec7d1
--- /dev/null
+++ b/2024.3/_static/copybutton.css
@@ -0,0 +1,94 @@
+/* Copy buttons */
+button.copybtn {
+ position: absolute;
+ display: flex;
+ top: .3em;
+ right: .3em;
+ width: 1.7em;
+ height: 1.7em;
+ opacity: 0;
+ transition: opacity 0.3s, border .3s, background-color .3s;
+ user-select: none;
+ padding: 0;
+ border: none;
+ outline: none;
+ border-radius: 0.4em;
+ /* The colors that GitHub uses */
+ border: #1b1f2426 1px solid;
+ background-color: #f6f8fa;
+ color: #57606a;
+}
+
+button.copybtn.success {
+ border-color: #22863a;
+ color: #22863a;
+}
+
+button.copybtn svg {
+ stroke: currentColor;
+ width: 1.5em;
+ height: 1.5em;
+ padding: 0.1em;
+}
+
+div.highlight {
+ position: relative;
+}
+
+/* Show the copybutton */
+.highlight:hover button.copybtn, button.copybtn.success {
+ opacity: 1;
+}
+
+.highlight button.copybtn:hover {
+ background-color: rgb(235, 235, 235);
+}
+
+.highlight button.copybtn:active {
+ background-color: rgb(187, 187, 187);
+}
+
+/**
+ * A minimal CSS-only tooltip copied from:
+ * https://codepen.io/mildrenben/pen/rVBrpK
+ *
+ * To use, write HTML like the following:
+ *
+ * Short
+ */
+ .o-tooltip--left {
+ position: relative;
+ }
+
+ .o-tooltip--left:after {
+ opacity: 0;
+ visibility: hidden;
+ position: absolute;
+ content: attr(data-tooltip);
+ padding: .2em;
+ font-size: .8em;
+ left: -.2em;
+ background: grey;
+ color: white;
+ white-space: nowrap;
+ z-index: 2;
+ border-radius: 2px;
+ transform: translateX(-102%) translateY(0);
+ transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1);
+}
+
+.o-tooltip--left:hover:after {
+ display: block;
+ opacity: 1;
+ visibility: visible;
+ transform: translateX(-100%) translateY(0);
+ transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1);
+ transition-delay: .5s;
+}
+
+/* By default the copy button shouldn't show up when printing a page */
+@media print {
+ button.copybtn {
+ display: none;
+ }
+}
diff --git a/2024.3/_static/copybutton.js b/2024.3/_static/copybutton.js
new file mode 100644
index 0000000000..2ea7ff3e21
--- /dev/null
+++ b/2024.3/_static/copybutton.js
@@ -0,0 +1,248 @@
+// Localization support
+const messages = {
+ 'en': {
+ 'copy': 'Copy',
+ 'copy_to_clipboard': 'Copy to clipboard',
+ 'copy_success': 'Copied!',
+ 'copy_failure': 'Failed to copy',
+ },
+ 'es' : {
+ 'copy': 'Copiar',
+ 'copy_to_clipboard': 'Copiar al portapapeles',
+ 'copy_success': '¡Copiado!',
+ 'copy_failure': 'Error al copiar',
+ },
+ 'de' : {
+ 'copy': 'Kopieren',
+ 'copy_to_clipboard': 'In die Zwischenablage kopieren',
+ 'copy_success': 'Kopiert!',
+ 'copy_failure': 'Fehler beim Kopieren',
+ },
+ 'fr' : {
+ 'copy': 'Copier',
+ 'copy_to_clipboard': 'Copier dans le presse-papier',
+ 'copy_success': 'Copié !',
+ 'copy_failure': 'Échec de la copie',
+ },
+ 'ru': {
+ 'copy': 'Скопировать',
+ 'copy_to_clipboard': 'Скопировать в буфер',
+ 'copy_success': 'Скопировано!',
+ 'copy_failure': 'Не удалось скопировать',
+ },
+ 'zh-CN': {
+ 'copy': '复制',
+ 'copy_to_clipboard': '复制到剪贴板',
+ 'copy_success': '复制成功!',
+ 'copy_failure': '复制失败',
+ },
+ 'it' : {
+ 'copy': 'Copiare',
+ 'copy_to_clipboard': 'Copiato negli appunti',
+ 'copy_success': 'Copiato!',
+ 'copy_failure': 'Errore durante la copia',
+ }
+}
+
+let locale = 'en'
+if( document.documentElement.lang !== undefined
+ && messages[document.documentElement.lang] !== undefined ) {
+ locale = document.documentElement.lang
+}
+
+let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT;
+if (doc_url_root == '#') {
+ doc_url_root = '';
+}
+
+/**
+ * SVG files for our copy buttons
+ */
+let iconCheck = `
+ ${messages[locale]['copy_success']}
+
+
+ `
+
+// If the user specified their own SVG use that, otherwise use the default
+let iconCopy = ``;
+if (!iconCopy) {
+ iconCopy = `
+ ${messages[locale]['copy_to_clipboard']}
+
+
+
+ `
+}
+
+/**
+ * Set up copy/paste for code blocks
+ */
+
+const runWhenDOMLoaded = cb => {
+ if (document.readyState != 'loading') {
+ cb()
+ } else if (document.addEventListener) {
+ document.addEventListener('DOMContentLoaded', cb)
+ } else {
+ document.attachEvent('onreadystatechange', function() {
+ if (document.readyState == 'complete') cb()
+ })
+ }
+}
+
+const codeCellId = index => `codecell${index}`
+
+// Clears selected text since ClipboardJS will select the text when copying
+const clearSelection = () => {
+ if (window.getSelection) {
+ window.getSelection().removeAllRanges()
+ } else if (document.selection) {
+ document.selection.empty()
+ }
+}
+
+// Changes tooltip text for a moment, then changes it back
+// We want the timeout of our `success` class to be a bit shorter than the
+// tooltip and icon change, so that we can hide the icon before changing back.
+var timeoutIcon = 2000;
+var timeoutSuccessClass = 1500;
+
+const temporarilyChangeTooltip = (el, oldText, newText) => {
+ el.setAttribute('data-tooltip', newText)
+ el.classList.add('success')
+ // Remove success a little bit sooner than we change the tooltip
+ // So that we can use CSS to hide the copybutton first
+ setTimeout(() => el.classList.remove('success'), timeoutSuccessClass)
+ setTimeout(() => el.setAttribute('data-tooltip', oldText), timeoutIcon)
+}
+
+// Changes the copy button icon for two seconds, then changes it back
+const temporarilyChangeIcon = (el) => {
+ el.innerHTML = iconCheck;
+ setTimeout(() => {el.innerHTML = iconCopy}, timeoutIcon)
+}
+
+const addCopyButtonToCodeCells = () => {
+ // If ClipboardJS hasn't loaded, wait a bit and try again. This
+ // happens because we load ClipboardJS asynchronously.
+ if (window.ClipboardJS === undefined) {
+ setTimeout(addCopyButtonToCodeCells, 250)
+ return
+ }
+
+ // Add copybuttons to all of our code cells
+ const COPYBUTTON_SELECTOR = 'div.highlight pre';
+ const codeCells = document.querySelectorAll(COPYBUTTON_SELECTOR)
+ codeCells.forEach((codeCell, index) => {
+ const id = codeCellId(index)
+ codeCell.setAttribute('id', id)
+
+ const clipboardButton = id =>
+ `
+ ${iconCopy}
+ `
+ codeCell.insertAdjacentHTML('afterend', clipboardButton(id))
+ })
+
+function escapeRegExp(string) {
+ return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+
+/**
+ * Removes excluded text from a Node.
+ *
+ * @param {Node} target Node to filter.
+ * @param {string} exclude CSS selector of nodes to exclude.
+ * @returns {DOMString} Text from `target` with text removed.
+ */
+function filterText(target, exclude) {
+ const clone = target.cloneNode(true); // clone as to not modify the live DOM
+ if (exclude) {
+ // remove excluded nodes
+ clone.querySelectorAll(exclude).forEach(node => node.remove());
+ }
+ return clone.innerText;
+}
+
+// Callback when a copy button is clicked. Will be passed the node that was clicked
+// should then grab the text and replace pieces of text that shouldn't be used in output
+function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") {
+ var regexp;
+ var match;
+
+ // Do we check for line continuation characters and "HERE-documents"?
+ var useLineCont = !!lineContinuationChar
+ var useHereDoc = !!hereDocDelim
+
+ // create regexp to capture prompt and remaining line
+ if (isRegexp) {
+ regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)')
+ } else {
+ regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)')
+ }
+
+ const outputLines = [];
+ var promptFound = false;
+ var gotLineCont = false;
+ var gotHereDoc = false;
+ const lineGotPrompt = [];
+ for (const line of textContent.split('\n')) {
+ match = line.match(regexp)
+ if (match || gotLineCont || gotHereDoc) {
+ promptFound = regexp.test(line)
+ lineGotPrompt.push(promptFound)
+ if (removePrompts && promptFound) {
+ outputLines.push(match[2])
+ } else {
+ outputLines.push(line)
+ }
+ gotLineCont = line.endsWith(lineContinuationChar) & useLineCont
+ if (line.includes(hereDocDelim) & useHereDoc)
+ gotHereDoc = !gotHereDoc
+ } else if (!onlyCopyPromptLines) {
+ outputLines.push(line)
+ } else if (copyEmptyLines && line.trim() === '') {
+ outputLines.push(line)
+ }
+ }
+
+ // If no lines with the prompt were found then just use original lines
+ if (lineGotPrompt.some(v => v === true)) {
+ textContent = outputLines.join('\n');
+ }
+
+ // Remove a trailing newline to avoid auto-running when pasting
+ if (textContent.endsWith("\n")) {
+ textContent = textContent.slice(0, -1)
+ }
+ return textContent
+}
+
+
+var copyTargetText = (trigger) => {
+ var target = document.querySelector(trigger.attributes['data-clipboard-target'].value);
+
+ // get filtered text
+ let exclude = '.linenos';
+
+ let text = filterText(target, exclude);
+ return formatCopyText(text, '', false, true, true, true, '', '')
+}
+
+ // Initialize with a callback so we can modify the text before copy
+ const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText})
+
+ // Update UI with error/success messages
+ clipboard.on('success', event => {
+ clearSelection()
+ temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success'])
+ temporarilyChangeIcon(event.trigger)
+ })
+
+ clipboard.on('error', event => {
+ temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure'])
+ })
+}
+
+runWhenDOMLoaded(addCopyButtonToCodeCells)
\ No newline at end of file
diff --git a/2024.3/_static/copybutton_funcs.js b/2024.3/_static/copybutton_funcs.js
new file mode 100644
index 0000000000..dbe1aaad79
--- /dev/null
+++ b/2024.3/_static/copybutton_funcs.js
@@ -0,0 +1,73 @@
+function escapeRegExp(string) {
+ return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+
+/**
+ * Removes excluded text from a Node.
+ *
+ * @param {Node} target Node to filter.
+ * @param {string} exclude CSS selector of nodes to exclude.
+ * @returns {DOMString} Text from `target` with text removed.
+ */
+export function filterText(target, exclude) {
+ const clone = target.cloneNode(true); // clone as to not modify the live DOM
+ if (exclude) {
+ // remove excluded nodes
+ clone.querySelectorAll(exclude).forEach(node => node.remove());
+ }
+ return clone.innerText;
+}
+
+// Callback when a copy button is clicked. Will be passed the node that was clicked
+// should then grab the text and replace pieces of text that shouldn't be used in output
+export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") {
+ var regexp;
+ var match;
+
+ // Do we check for line continuation characters and "HERE-documents"?
+ var useLineCont = !!lineContinuationChar
+ var useHereDoc = !!hereDocDelim
+
+ // create regexp to capture prompt and remaining line
+ if (isRegexp) {
+ regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)')
+ } else {
+ regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)')
+ }
+
+ const outputLines = [];
+ var promptFound = false;
+ var gotLineCont = false;
+ var gotHereDoc = false;
+ const lineGotPrompt = [];
+ for (const line of textContent.split('\n')) {
+ match = line.match(regexp)
+ if (match || gotLineCont || gotHereDoc) {
+ promptFound = regexp.test(line)
+ lineGotPrompt.push(promptFound)
+ if (removePrompts && promptFound) {
+ outputLines.push(match[2])
+ } else {
+ outputLines.push(line)
+ }
+ gotLineCont = line.endsWith(lineContinuationChar) & useLineCont
+ if (line.includes(hereDocDelim) & useHereDoc)
+ gotHereDoc = !gotHereDoc
+ } else if (!onlyCopyPromptLines) {
+ outputLines.push(line)
+ } else if (copyEmptyLines && line.trim() === '') {
+ outputLines.push(line)
+ }
+ }
+
+ // If no lines with the prompt were found then just use original lines
+ if (lineGotPrompt.some(v => v === true)) {
+ textContent = outputLines.join('\n');
+ }
+
+ // Remove a trailing newline to avoid auto-running when pasting
+ if (textContent.endsWith("\n")) {
+ textContent = textContent.slice(0, -1)
+ }
+ return textContent
+}
diff --git a/2024.3/_static/css/badge_only.css b/2024.3/_static/css/badge_only.css
new file mode 100644
index 0000000000..c718cee441
--- /dev/null
+++ b/2024.3/_static/css/badge_only.css
@@ -0,0 +1 @@
+.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}
\ No newline at end of file
diff --git a/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff b/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff
new file mode 100644
index 0000000000..6cb6000018
Binary files /dev/null and b/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff differ
diff --git a/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff2 b/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff2
new file mode 100644
index 0000000000..7059e23142
Binary files /dev/null and b/2024.3/_static/css/fonts/Roboto-Slab-Bold.woff2 differ
diff --git a/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff b/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff
new file mode 100644
index 0000000000..f815f63f99
Binary files /dev/null and b/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff differ
diff --git a/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff2 b/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff2
new file mode 100644
index 0000000000..f2c76e5bda
Binary files /dev/null and b/2024.3/_static/css/fonts/Roboto-Slab-Regular.woff2 differ
diff --git a/2024.3/_static/css/fonts/fontawesome-webfont.eot b/2024.3/_static/css/fonts/fontawesome-webfont.eot
new file mode 100644
index 0000000000..e9f60ca953
Binary files /dev/null and b/2024.3/_static/css/fonts/fontawesome-webfont.eot differ
diff --git a/2024.3/_static/css/fonts/fontawesome-webfont.svg b/2024.3/_static/css/fonts/fontawesome-webfont.svg
new file mode 100644
index 0000000000..855c845e53
--- /dev/null
+++ b/2024.3/_static/css/fonts/fontawesome-webfont.svg
@@ -0,0 +1,2671 @@
+
+
+
+
+Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016
+ By ,,,
+Copyright Dave Gandy 2016. All rights reserved.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/2024.3/_static/css/fonts/fontawesome-webfont.ttf b/2024.3/_static/css/fonts/fontawesome-webfont.ttf
new file mode 100644
index 0000000000..35acda2fa1
Binary files /dev/null and b/2024.3/_static/css/fonts/fontawesome-webfont.ttf differ
diff --git a/2024.3/_static/css/fonts/fontawesome-webfont.woff b/2024.3/_static/css/fonts/fontawesome-webfont.woff
new file mode 100644
index 0000000000..400014a4b0
Binary files /dev/null and b/2024.3/_static/css/fonts/fontawesome-webfont.woff differ
diff --git a/2024.3/_static/css/fonts/fontawesome-webfont.woff2 b/2024.3/_static/css/fonts/fontawesome-webfont.woff2
new file mode 100644
index 0000000000..4d13fc6040
Binary files /dev/null and b/2024.3/_static/css/fonts/fontawesome-webfont.woff2 differ
diff --git a/2024.3/_static/css/fonts/lato-bold-italic.woff b/2024.3/_static/css/fonts/lato-bold-italic.woff
new file mode 100644
index 0000000000..88ad05b9ff
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-bold-italic.woff differ
diff --git a/2024.3/_static/css/fonts/lato-bold-italic.woff2 b/2024.3/_static/css/fonts/lato-bold-italic.woff2
new file mode 100644
index 0000000000..c4e3d804b5
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-bold-italic.woff2 differ
diff --git a/2024.3/_static/css/fonts/lato-bold.woff b/2024.3/_static/css/fonts/lato-bold.woff
new file mode 100644
index 0000000000..c6dff51f06
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-bold.woff differ
diff --git a/2024.3/_static/css/fonts/lato-bold.woff2 b/2024.3/_static/css/fonts/lato-bold.woff2
new file mode 100644
index 0000000000..bb195043cf
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-bold.woff2 differ
diff --git a/2024.3/_static/css/fonts/lato-normal-italic.woff b/2024.3/_static/css/fonts/lato-normal-italic.woff
new file mode 100644
index 0000000000..76114bc033
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-normal-italic.woff differ
diff --git a/2024.3/_static/css/fonts/lato-normal-italic.woff2 b/2024.3/_static/css/fonts/lato-normal-italic.woff2
new file mode 100644
index 0000000000..3404f37e2e
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-normal-italic.woff2 differ
diff --git a/2024.3/_static/css/fonts/lato-normal.woff b/2024.3/_static/css/fonts/lato-normal.woff
new file mode 100644
index 0000000000..ae1307ff5f
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-normal.woff differ
diff --git a/2024.3/_static/css/fonts/lato-normal.woff2 b/2024.3/_static/css/fonts/lato-normal.woff2
new file mode 100644
index 0000000000..3bf9843328
Binary files /dev/null and b/2024.3/_static/css/fonts/lato-normal.woff2 differ
diff --git a/2024.3/_static/css/theme.css b/2024.3/_static/css/theme.css
new file mode 100644
index 0000000000..19a446a0e7
--- /dev/null
+++ b/2024.3/_static/css/theme.css
@@ -0,0 +1,4 @@
+html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*!
+ * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome
+ * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)
+ */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block}
\ No newline at end of file
diff --git a/2024.3/_static/custom.css b/2024.3/_static/custom.css
new file mode 100644
index 0000000000..9f70829e05
--- /dev/null
+++ b/2024.3/_static/custom.css
@@ -0,0 +1,131 @@
+/* override table width restrictions */
+@media screen and (min-width: 767px) {
+
+ .wy-table-responsive table td {
+ /* !important prevents the common CSS stylesheets from overriding
+ this as on RTD they are loaded after this stylesheet */
+
+ white-space: normal !important;
+ }
+}
+
+.code-block-caption {
+ color: #000;
+ font: italic 85%/1 arial,sans-serif;
+ padding: 1em 0;
+ text-align: center;
+}
+
+
+.collapsible {
+ margin-left: -10px;
+ background-color: #f1f1f1;
+ cursor: pointer;
+ padding: 18px 18px 18px 10px;
+ width: 100%;
+ border: none;
+ text-align: left;
+ outline: none;
+ font-weight: 700;
+ font-family: "Roboto Slab","ff-tisa-web-pro","Georgia",Arial,sans-serif;
+}
+
+code.sig-name.descname {
+ white-space: initial;
+}
+
+table.optimization-notice td {
+ white-space: initial;
+}
+
+table.optimization-notice td p:last-child {
+ text-align: right;
+}
+
+img.with-border {
+ border:1px solid #021a40;
+}
+
+div.column {
+ float: left;
+ width: 50%;
+ padding: 10px;
+ }
+
+/* Clear floats after the columns */
+.column:after {
+ content: "";
+ display: table;
+ clear: both;
+}
+
+.comparison:after {
+ content: "";
+ display: table;
+ clear: both;
+ }
+
+div.admonition-container {
+ width: 49%;
+ padding: 0 3px 0 0;
+}
+
+/* Clear floats after the columns */
+.admonition-container:after {
+ content: "";
+ display: table;
+ clear: both;
+}
+
+div.quotation {
+ background-color: #fffff1;
+ padding: 1em 0 0 1em;
+}
+
+.rst-content div[class^='highlight'] pre {
+ white-space: pre-wrap;
+}
+
+/* A workaround for https://github.com/readthedocs/sphinx_rtd_theme/issues/647
+ * Override display for function signatures so that there is spacing between
+ * types and arguments */
+ .rst-content dl:not(.docutils) dt {
+ display: table-cell !important;
+}
+.rst-content dl:not(.docutils) dd {
+ margin-top: 6px;
+}
+
+/*
+.rst-content tt.literal, .rst-content code.literal, .highlight {
+ background: #f0f0f0;
+}
+.rst-content tt.literal, .rst-content code.literal {
+ color: #000000;
+}*/
+
+
+.eqno {
+ margin-left: 5px;
+ float: right;
+}
+.math .headerlink {
+ display: none;
+ visibility: hidden;
+}
+.math:hover .headerlink {
+ display: inline-block;
+ visibility: visible;
+ margin-right: -0.7em;
+}
+
+a#wap_dns {display: none;}
+
+
+button#version-switcher-button {
+ background-color: #2980b9;
+}
+
+div#version-switcher-dropdown {
+ display: inline;
+}
\ No newline at end of file
diff --git a/2024.3/_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css b/2024.3/_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css
new file mode 100644
index 0000000000..eb19f698af
--- /dev/null
+++ b/2024.3/_static/design-style.1e8bd061cd6da7fc9cf755528e8ffc24.min.css
@@ -0,0 +1 @@
+.sd-bg-primary{background-color:var(--sd-color-primary) !important}.sd-bg-text-primary{color:var(--sd-color-primary-text) !important}button.sd-bg-primary:focus,button.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}a.sd-bg-primary:focus,a.sd-bg-primary:hover{background-color:var(--sd-color-primary-highlight) !important}.sd-bg-secondary{background-color:var(--sd-color-secondary) !important}.sd-bg-text-secondary{color:var(--sd-color-secondary-text) !important}button.sd-bg-secondary:focus,button.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}a.sd-bg-secondary:focus,a.sd-bg-secondary:hover{background-color:var(--sd-color-secondary-highlight) !important}.sd-bg-success{background-color:var(--sd-color-success) !important}.sd-bg-text-success{color:var(--sd-color-success-text) !important}button.sd-bg-success:focus,button.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}a.sd-bg-success:focus,a.sd-bg-success:hover{background-color:var(--sd-color-success-highlight) !important}.sd-bg-info{background-color:var(--sd-color-info) !important}.sd-bg-text-info{color:var(--sd-color-info-text) !important}button.sd-bg-info:focus,button.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}a.sd-bg-info:focus,a.sd-bg-info:hover{background-color:var(--sd-color-info-highlight) !important}.sd-bg-warning{background-color:var(--sd-color-warning) !important}.sd-bg-text-warning{color:var(--sd-color-warning-text) !important}button.sd-bg-warning:focus,button.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}a.sd-bg-warning:focus,a.sd-bg-warning:hover{background-color:var(--sd-color-warning-highlight) !important}.sd-bg-danger{background-color:var(--sd-color-danger) !important}.sd-bg-text-danger{color:var(--sd-color-danger-text) !important}button.sd-bg-danger:focus,button.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}a.sd-bg-danger:focus,a.sd-bg-danger:hover{background-color:var(--sd-color-danger-highlight) !important}.sd-bg-light{background-color:var(--sd-color-light) !important}.sd-bg-text-light{color:var(--sd-color-light-text) !important}button.sd-bg-light:focus,button.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}a.sd-bg-light:focus,a.sd-bg-light:hover{background-color:var(--sd-color-light-highlight) !important}.sd-bg-muted{background-color:var(--sd-color-muted) !important}.sd-bg-text-muted{color:var(--sd-color-muted-text) !important}button.sd-bg-muted:focus,button.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}a.sd-bg-muted:focus,a.sd-bg-muted:hover{background-color:var(--sd-color-muted-highlight) !important}.sd-bg-dark{background-color:var(--sd-color-dark) !important}.sd-bg-text-dark{color:var(--sd-color-dark-text) !important}button.sd-bg-dark:focus,button.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}a.sd-bg-dark:focus,a.sd-bg-dark:hover{background-color:var(--sd-color-dark-highlight) !important}.sd-bg-black{background-color:var(--sd-color-black) !important}.sd-bg-text-black{color:var(--sd-color-black-text) !important}button.sd-bg-black:focus,button.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}a.sd-bg-black:focus,a.sd-bg-black:hover{background-color:var(--sd-color-black-highlight) !important}.sd-bg-white{background-color:var(--sd-color-white) !important}.sd-bg-text-white{color:var(--sd-color-white-text) !important}button.sd-bg-white:focus,button.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}a.sd-bg-white:focus,a.sd-bg-white:hover{background-color:var(--sd-color-white-highlight) !important}.sd-text-primary,.sd-text-primary>p{color:var(--sd-color-primary) !important}a.sd-text-primary:focus,a.sd-text-primary:hover{color:var(--sd-color-primary-highlight) !important}.sd-text-secondary,.sd-text-secondary>p{color:var(--sd-color-secondary) !important}a.sd-text-secondary:focus,a.sd-text-secondary:hover{color:var(--sd-color-secondary-highlight) !important}.sd-text-success,.sd-text-success>p{color:var(--sd-color-success) !important}a.sd-text-success:focus,a.sd-text-success:hover{color:var(--sd-color-success-highlight) !important}.sd-text-info,.sd-text-info>p{color:var(--sd-color-info) !important}a.sd-text-info:focus,a.sd-text-info:hover{color:var(--sd-color-info-highlight) !important}.sd-text-warning,.sd-text-warning>p{color:var(--sd-color-warning) !important}a.sd-text-warning:focus,a.sd-text-warning:hover{color:var(--sd-color-warning-highlight) !important}.sd-text-danger,.sd-text-danger>p{color:var(--sd-color-danger) !important}a.sd-text-danger:focus,a.sd-text-danger:hover{color:var(--sd-color-danger-highlight) !important}.sd-text-light,.sd-text-light>p{color:var(--sd-color-light) !important}a.sd-text-light:focus,a.sd-text-light:hover{color:var(--sd-color-light-highlight) !important}.sd-text-muted,.sd-text-muted>p{color:var(--sd-color-muted) !important}a.sd-text-muted:focus,a.sd-text-muted:hover{color:var(--sd-color-muted-highlight) !important}.sd-text-dark,.sd-text-dark>p{color:var(--sd-color-dark) !important}a.sd-text-dark:focus,a.sd-text-dark:hover{color:var(--sd-color-dark-highlight) !important}.sd-text-black,.sd-text-black>p{color:var(--sd-color-black) !important}a.sd-text-black:focus,a.sd-text-black:hover{color:var(--sd-color-black-highlight) !important}.sd-text-white,.sd-text-white>p{color:var(--sd-color-white) !important}a.sd-text-white:focus,a.sd-text-white:hover{color:var(--sd-color-white-highlight) !important}.sd-outline-primary{border-color:var(--sd-color-primary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-primary:focus,a.sd-outline-primary:hover{border-color:var(--sd-color-primary-highlight) !important}.sd-outline-secondary{border-color:var(--sd-color-secondary) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-secondary:focus,a.sd-outline-secondary:hover{border-color:var(--sd-color-secondary-highlight) !important}.sd-outline-success{border-color:var(--sd-color-success) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-success:focus,a.sd-outline-success:hover{border-color:var(--sd-color-success-highlight) !important}.sd-outline-info{border-color:var(--sd-color-info) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-info:focus,a.sd-outline-info:hover{border-color:var(--sd-color-info-highlight) !important}.sd-outline-warning{border-color:var(--sd-color-warning) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-warning:focus,a.sd-outline-warning:hover{border-color:var(--sd-color-warning-highlight) !important}.sd-outline-danger{border-color:var(--sd-color-danger) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-danger:focus,a.sd-outline-danger:hover{border-color:var(--sd-color-danger-highlight) !important}.sd-outline-light{border-color:var(--sd-color-light) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-light:focus,a.sd-outline-light:hover{border-color:var(--sd-color-light-highlight) !important}.sd-outline-muted{border-color:var(--sd-color-muted) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-muted:focus,a.sd-outline-muted:hover{border-color:var(--sd-color-muted-highlight) !important}.sd-outline-dark{border-color:var(--sd-color-dark) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-dark:focus,a.sd-outline-dark:hover{border-color:var(--sd-color-dark-highlight) !important}.sd-outline-black{border-color:var(--sd-color-black) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-black:focus,a.sd-outline-black:hover{border-color:var(--sd-color-black-highlight) !important}.sd-outline-white{border-color:var(--sd-color-white) !important;border-style:solid !important;border-width:1px !important}a.sd-outline-white:focus,a.sd-outline-white:hover{border-color:var(--sd-color-white-highlight) !important}.sd-bg-transparent{background-color:transparent !important}.sd-outline-transparent{border-color:transparent !important}.sd-text-transparent{color:transparent !important}.sd-p-0{padding:0 !important}.sd-pt-0,.sd-py-0{padding-top:0 !important}.sd-pr-0,.sd-px-0{padding-right:0 !important}.sd-pb-0,.sd-py-0{padding-bottom:0 !important}.sd-pl-0,.sd-px-0{padding-left:0 !important}.sd-p-1{padding:.25rem !important}.sd-pt-1,.sd-py-1{padding-top:.25rem !important}.sd-pr-1,.sd-px-1{padding-right:.25rem !important}.sd-pb-1,.sd-py-1{padding-bottom:.25rem !important}.sd-pl-1,.sd-px-1{padding-left:.25rem !important}.sd-p-2{padding:.5rem !important}.sd-pt-2,.sd-py-2{padding-top:.5rem !important}.sd-pr-2,.sd-px-2{padding-right:.5rem !important}.sd-pb-2,.sd-py-2{padding-bottom:.5rem !important}.sd-pl-2,.sd-px-2{padding-left:.5rem !important}.sd-p-3{padding:1rem !important}.sd-pt-3,.sd-py-3{padding-top:1rem !important}.sd-pr-3,.sd-px-3{padding-right:1rem !important}.sd-pb-3,.sd-py-3{padding-bottom:1rem !important}.sd-pl-3,.sd-px-3{padding-left:1rem !important}.sd-p-4{padding:1.5rem !important}.sd-pt-4,.sd-py-4{padding-top:1.5rem !important}.sd-pr-4,.sd-px-4{padding-right:1.5rem !important}.sd-pb-4,.sd-py-4{padding-bottom:1.5rem !important}.sd-pl-4,.sd-px-4{padding-left:1.5rem !important}.sd-p-5{padding:3rem !important}.sd-pt-5,.sd-py-5{padding-top:3rem !important}.sd-pr-5,.sd-px-5{padding-right:3rem !important}.sd-pb-5,.sd-py-5{padding-bottom:3rem !important}.sd-pl-5,.sd-px-5{padding-left:3rem !important}.sd-m-auto{margin:auto !important}.sd-mt-auto,.sd-my-auto{margin-top:auto !important}.sd-mr-auto,.sd-mx-auto{margin-right:auto !important}.sd-mb-auto,.sd-my-auto{margin-bottom:auto !important}.sd-ml-auto,.sd-mx-auto{margin-left:auto !important}.sd-m-0{margin:0 !important}.sd-mt-0,.sd-my-0{margin-top:0 !important}.sd-mr-0,.sd-mx-0{margin-right:0 !important}.sd-mb-0,.sd-my-0{margin-bottom:0 !important}.sd-ml-0,.sd-mx-0{margin-left:0 !important}.sd-m-1{margin:.25rem !important}.sd-mt-1,.sd-my-1{margin-top:.25rem !important}.sd-mr-1,.sd-mx-1{margin-right:.25rem !important}.sd-mb-1,.sd-my-1{margin-bottom:.25rem !important}.sd-ml-1,.sd-mx-1{margin-left:.25rem !important}.sd-m-2{margin:.5rem !important}.sd-mt-2,.sd-my-2{margin-top:.5rem !important}.sd-mr-2,.sd-mx-2{margin-right:.5rem !important}.sd-mb-2,.sd-my-2{margin-bottom:.5rem !important}.sd-ml-2,.sd-mx-2{margin-left:.5rem !important}.sd-m-3{margin:1rem !important}.sd-mt-3,.sd-my-3{margin-top:1rem !important}.sd-mr-3,.sd-mx-3{margin-right:1rem !important}.sd-mb-3,.sd-my-3{margin-bottom:1rem !important}.sd-ml-3,.sd-mx-3{margin-left:1rem !important}.sd-m-4{margin:1.5rem !important}.sd-mt-4,.sd-my-4{margin-top:1.5rem !important}.sd-mr-4,.sd-mx-4{margin-right:1.5rem !important}.sd-mb-4,.sd-my-4{margin-bottom:1.5rem !important}.sd-ml-4,.sd-mx-4{margin-left:1.5rem !important}.sd-m-5{margin:3rem !important}.sd-mt-5,.sd-my-5{margin-top:3rem !important}.sd-mr-5,.sd-mx-5{margin-right:3rem !important}.sd-mb-5,.sd-my-5{margin-bottom:3rem !important}.sd-ml-5,.sd-mx-5{margin-left:3rem !important}.sd-w-25{width:25% !important}.sd-w-50{width:50% !important}.sd-w-75{width:75% !important}.sd-w-100{width:100% !important}.sd-w-auto{width:auto !important}.sd-h-25{height:25% !important}.sd-h-50{height:50% !important}.sd-h-75{height:75% !important}.sd-h-100{height:100% !important}.sd-h-auto{height:auto !important}.sd-d-none{display:none !important}.sd-d-inline{display:inline !important}.sd-d-inline-block{display:inline-block !important}.sd-d-block{display:block !important}.sd-d-grid{display:grid !important}.sd-d-flex-row{display:-ms-flexbox !important;display:flex !important;flex-direction:row !important}.sd-d-flex-column{display:-ms-flexbox !important;display:flex !important;flex-direction:column !important}.sd-d-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}@media(min-width: 576px){.sd-d-sm-none{display:none !important}.sd-d-sm-inline{display:inline !important}.sd-d-sm-inline-block{display:inline-block !important}.sd-d-sm-block{display:block !important}.sd-d-sm-grid{display:grid !important}.sd-d-sm-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-sm-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 768px){.sd-d-md-none{display:none !important}.sd-d-md-inline{display:inline !important}.sd-d-md-inline-block{display:inline-block !important}.sd-d-md-block{display:block !important}.sd-d-md-grid{display:grid !important}.sd-d-md-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-md-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 992px){.sd-d-lg-none{display:none !important}.sd-d-lg-inline{display:inline !important}.sd-d-lg-inline-block{display:inline-block !important}.sd-d-lg-block{display:block !important}.sd-d-lg-grid{display:grid !important}.sd-d-lg-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-lg-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}@media(min-width: 1200px){.sd-d-xl-none{display:none !important}.sd-d-xl-inline{display:inline !important}.sd-d-xl-inline-block{display:inline-block !important}.sd-d-xl-block{display:block !important}.sd-d-xl-grid{display:grid !important}.sd-d-xl-flex{display:-ms-flexbox !important;display:flex !important}.sd-d-xl-inline-flex{display:-ms-inline-flexbox !important;display:inline-flex !important}}.sd-align-major-start{justify-content:flex-start !important}.sd-align-major-end{justify-content:flex-end !important}.sd-align-major-center{justify-content:center !important}.sd-align-major-justify{justify-content:space-between !important}.sd-align-major-spaced{justify-content:space-evenly !important}.sd-align-minor-start{align-items:flex-start !important}.sd-align-minor-end{align-items:flex-end !important}.sd-align-minor-center{align-items:center !important}.sd-align-minor-stretch{align-items:stretch !important}.sd-text-justify{text-align:justify !important}.sd-text-left{text-align:left !important}.sd-text-right{text-align:right !important}.sd-text-center{text-align:center !important}.sd-font-weight-light{font-weight:300 !important}.sd-font-weight-lighter{font-weight:lighter !important}.sd-font-weight-normal{font-weight:400 !important}.sd-font-weight-bold{font-weight:700 !important}.sd-font-weight-bolder{font-weight:bolder !important}.sd-font-italic{font-style:italic !important}.sd-text-decoration-none{text-decoration:none !important}.sd-text-lowercase{text-transform:lowercase !important}.sd-text-uppercase{text-transform:uppercase !important}.sd-text-capitalize{text-transform:capitalize !important}.sd-text-wrap{white-space:normal !important}.sd-text-nowrap{white-space:nowrap !important}.sd-text-truncate{overflow:hidden;text-overflow:ellipsis;white-space:nowrap}.sd-fs-1,.sd-fs-1>p{font-size:calc(1.375rem + 1.5vw) !important;line-height:unset !important}.sd-fs-2,.sd-fs-2>p{font-size:calc(1.325rem + 0.9vw) !important;line-height:unset !important}.sd-fs-3,.sd-fs-3>p{font-size:calc(1.3rem + 0.6vw) !important;line-height:unset !important}.sd-fs-4,.sd-fs-4>p{font-size:calc(1.275rem + 0.3vw) !important;line-height:unset !important}.sd-fs-5,.sd-fs-5>p{font-size:1.25rem !important;line-height:unset !important}.sd-fs-6,.sd-fs-6>p{font-size:1rem !important;line-height:unset !important}.sd-border-0{border:0 solid !important}.sd-border-top-0{border-top:0 solid !important}.sd-border-bottom-0{border-bottom:0 solid !important}.sd-border-right-0{border-right:0 solid !important}.sd-border-left-0{border-left:0 solid !important}.sd-border-1{border:1px solid !important}.sd-border-top-1{border-top:1px solid !important}.sd-border-bottom-1{border-bottom:1px solid !important}.sd-border-right-1{border-right:1px solid !important}.sd-border-left-1{border-left:1px solid !important}.sd-border-2{border:2px solid !important}.sd-border-top-2{border-top:2px solid !important}.sd-border-bottom-2{border-bottom:2px solid !important}.sd-border-right-2{border-right:2px solid !important}.sd-border-left-2{border-left:2px solid !important}.sd-border-3{border:3px solid !important}.sd-border-top-3{border-top:3px solid !important}.sd-border-bottom-3{border-bottom:3px solid !important}.sd-border-right-3{border-right:3px solid !important}.sd-border-left-3{border-left:3px solid !important}.sd-border-4{border:4px solid !important}.sd-border-top-4{border-top:4px solid !important}.sd-border-bottom-4{border-bottom:4px solid !important}.sd-border-right-4{border-right:4px solid !important}.sd-border-left-4{border-left:4px solid !important}.sd-border-5{border:5px solid !important}.sd-border-top-5{border-top:5px solid !important}.sd-border-bottom-5{border-bottom:5px solid !important}.sd-border-right-5{border-right:5px solid !important}.sd-border-left-5{border-left:5px solid !important}.sd-rounded-0{border-radius:0 !important}.sd-rounded-1{border-radius:.2rem !important}.sd-rounded-2{border-radius:.3rem !important}.sd-rounded-3{border-radius:.5rem !important}.sd-rounded-pill{border-radius:50rem !important}.sd-rounded-circle{border-radius:50% !important}.shadow-none{box-shadow:none !important}.sd-shadow-sm{box-shadow:0 .125rem .25rem var(--sd-color-shadow) !important}.sd-shadow-md{box-shadow:0 .5rem 1rem var(--sd-color-shadow) !important}.sd-shadow-lg{box-shadow:0 1rem 3rem var(--sd-color-shadow) !important}@keyframes sd-slide-from-left{0%{transform:translateX(-100%)}100%{transform:translateX(0)}}@keyframes sd-slide-from-right{0%{transform:translateX(200%)}100%{transform:translateX(0)}}@keyframes sd-grow100{0%{transform:scale(0);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50{0%{transform:scale(0.5);opacity:.5}100%{transform:scale(1);opacity:1}}@keyframes sd-grow50-rot20{0%{transform:scale(0.5) rotateZ(-20deg);opacity:.5}75%{transform:scale(1) rotateZ(5deg);opacity:1}95%{transform:scale(1) rotateZ(-1deg);opacity:1}100%{transform:scale(1) rotateZ(0);opacity:1}}.sd-animate-slide-from-left{animation:1s ease-out 0s 1 normal none running sd-slide-from-left}.sd-animate-slide-from-right{animation:1s ease-out 0s 1 normal none running sd-slide-from-right}.sd-animate-grow100{animation:1s ease-out 0s 1 normal none running sd-grow100}.sd-animate-grow50{animation:1s ease-out 0s 1 normal none running sd-grow50}.sd-animate-grow50-rot20{animation:1s ease-out 0s 1 normal none running sd-grow50-rot20}.sd-badge{display:inline-block;padding:.35em .65em;font-size:.75em;font-weight:700;line-height:1;text-align:center;white-space:nowrap;vertical-align:baseline;border-radius:.25rem}.sd-badge:empty{display:none}a.sd-badge{text-decoration:none}.sd-btn .sd-badge{position:relative;top:-1px}.sd-btn{background-color:transparent;border:1px solid transparent;border-radius:.25rem;cursor:pointer;display:inline-block;font-weight:400;font-size:1rem;line-height:1.5;padding:.375rem .75rem;text-align:center;text-decoration:none;transition:color .15s ease-in-out,background-color .15s ease-in-out,border-color .15s ease-in-out,box-shadow .15s ease-in-out;vertical-align:middle;user-select:none;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none}.sd-btn:hover{text-decoration:none}@media(prefers-reduced-motion: reduce){.sd-btn{transition:none}}.sd-btn-primary,.sd-btn-outline-primary:hover,.sd-btn-outline-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-primary:hover,.sd-btn-primary:focus{color:var(--sd-color-primary-text) !important;background-color:var(--sd-color-primary-highlight) !important;border-color:var(--sd-color-primary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-primary{color:var(--sd-color-primary) !important;border-color:var(--sd-color-primary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary,.sd-btn-outline-secondary:hover,.sd-btn-outline-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-secondary:hover,.sd-btn-secondary:focus{color:var(--sd-color-secondary-text) !important;background-color:var(--sd-color-secondary-highlight) !important;border-color:var(--sd-color-secondary-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-secondary{color:var(--sd-color-secondary) !important;border-color:var(--sd-color-secondary) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success,.sd-btn-outline-success:hover,.sd-btn-outline-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-success:hover,.sd-btn-success:focus{color:var(--sd-color-success-text) !important;background-color:var(--sd-color-success-highlight) !important;border-color:var(--sd-color-success-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-success{color:var(--sd-color-success) !important;border-color:var(--sd-color-success) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info,.sd-btn-outline-info:hover,.sd-btn-outline-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-info:hover,.sd-btn-info:focus{color:var(--sd-color-info-text) !important;background-color:var(--sd-color-info-highlight) !important;border-color:var(--sd-color-info-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-info{color:var(--sd-color-info) !important;border-color:var(--sd-color-info) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning,.sd-btn-outline-warning:hover,.sd-btn-outline-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-warning:hover,.sd-btn-warning:focus{color:var(--sd-color-warning-text) !important;background-color:var(--sd-color-warning-highlight) !important;border-color:var(--sd-color-warning-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-warning{color:var(--sd-color-warning) !important;border-color:var(--sd-color-warning) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger,.sd-btn-outline-danger:hover,.sd-btn-outline-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-danger:hover,.sd-btn-danger:focus{color:var(--sd-color-danger-text) !important;background-color:var(--sd-color-danger-highlight) !important;border-color:var(--sd-color-danger-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-danger{color:var(--sd-color-danger) !important;border-color:var(--sd-color-danger) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light,.sd-btn-outline-light:hover,.sd-btn-outline-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-light:hover,.sd-btn-light:focus{color:var(--sd-color-light-text) !important;background-color:var(--sd-color-light-highlight) !important;border-color:var(--sd-color-light-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-light{color:var(--sd-color-light) !important;border-color:var(--sd-color-light) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted,.sd-btn-outline-muted:hover,.sd-btn-outline-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-muted:hover,.sd-btn-muted:focus{color:var(--sd-color-muted-text) !important;background-color:var(--sd-color-muted-highlight) !important;border-color:var(--sd-color-muted-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-muted{color:var(--sd-color-muted) !important;border-color:var(--sd-color-muted) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark,.sd-btn-outline-dark:hover,.sd-btn-outline-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-dark:hover,.sd-btn-dark:focus{color:var(--sd-color-dark-text) !important;background-color:var(--sd-color-dark-highlight) !important;border-color:var(--sd-color-dark-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-dark{color:var(--sd-color-dark) !important;border-color:var(--sd-color-dark) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black,.sd-btn-outline-black:hover,.sd-btn-outline-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-black:hover,.sd-btn-black:focus{color:var(--sd-color-black-text) !important;background-color:var(--sd-color-black-highlight) !important;border-color:var(--sd-color-black-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-black{color:var(--sd-color-black) !important;border-color:var(--sd-color-black) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white,.sd-btn-outline-white:hover,.sd-btn-outline-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-btn-white:hover,.sd-btn-white:focus{color:var(--sd-color-white-text) !important;background-color:var(--sd-color-white-highlight) !important;border-color:var(--sd-color-white-highlight) !important;border-width:1px !important;border-style:solid !important}.sd-btn-outline-white{color:var(--sd-color-white) !important;border-color:var(--sd-color-white) !important;border-width:1px !important;border-style:solid !important}.sd-stretched-link::after{position:absolute;top:0;right:0;bottom:0;left:0;z-index:1;content:""}.sd-hide-link-text{font-size:0}.sd-octicon,.sd-material-icon{display:inline-block;fill:currentColor;vertical-align:middle}.sd-avatar-xs{border-radius:50%;object-fit:cover;object-position:center;width:1rem;height:1rem}.sd-avatar-sm{border-radius:50%;object-fit:cover;object-position:center;width:3rem;height:3rem}.sd-avatar-md{border-radius:50%;object-fit:cover;object-position:center;width:5rem;height:5rem}.sd-avatar-lg{border-radius:50%;object-fit:cover;object-position:center;width:7rem;height:7rem}.sd-avatar-xl{border-radius:50%;object-fit:cover;object-position:center;width:10rem;height:10rem}.sd-avatar-inherit{border-radius:50%;object-fit:cover;object-position:center;width:inherit;height:inherit}.sd-avatar-initial{border-radius:50%;object-fit:cover;object-position:center;width:initial;height:initial}.sd-card{background-clip:border-box;background-color:var(--sd-color-card-background);border:1px solid var(--sd-color-card-border);border-radius:.25rem;color:var(--sd-color-card-text);display:-ms-flexbox;display:flex;-ms-flex-direction:column;flex-direction:column;min-width:0;position:relative;word-wrap:break-word}.sd-card>hr{margin-left:0;margin-right:0}.sd-card-hover:hover{border-color:var(--sd-color-card-border-hover);transform:scale(1.01)}.sd-card-body{-ms-flex:1 1 auto;flex:1 1 auto;padding:1rem 1rem}.sd-card-title{margin-bottom:.5rem}.sd-card-subtitle{margin-top:-0.25rem;margin-bottom:0}.sd-card-text:last-child{margin-bottom:0}.sd-card-link:hover{text-decoration:none}.sd-card-link+.card-link{margin-left:1rem}.sd-card-header{padding:.5rem 1rem;margin-bottom:0;background-color:var(--sd-color-card-header);border-bottom:1px solid var(--sd-color-card-border)}.sd-card-header:first-child{border-radius:calc(0.25rem - 1px) calc(0.25rem - 1px) 0 0}.sd-card-footer{padding:.5rem 1rem;background-color:var(--sd-color-card-footer);border-top:1px solid var(--sd-color-card-border)}.sd-card-footer:last-child{border-radius:0 0 calc(0.25rem - 1px) calc(0.25rem - 1px)}.sd-card-header-tabs{margin-right:-0.5rem;margin-bottom:-0.5rem;margin-left:-0.5rem;border-bottom:0}.sd-card-header-pills{margin-right:-0.5rem;margin-left:-0.5rem}.sd-card-img-overlay{position:absolute;top:0;right:0;bottom:0;left:0;padding:1rem;border-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom,.sd-card-img-top{width:100%}.sd-card-img,.sd-card-img-top{border-top-left-radius:calc(0.25rem - 1px);border-top-right-radius:calc(0.25rem - 1px)}.sd-card-img,.sd-card-img-bottom{border-bottom-left-radius:calc(0.25rem - 1px);border-bottom-right-radius:calc(0.25rem - 1px)}.sd-cards-carousel{width:100%;display:flex;flex-wrap:nowrap;-ms-flex-direction:row;flex-direction:row;overflow-x:hidden;scroll-snap-type:x mandatory}.sd-cards-carousel.sd-show-scrollbar{overflow-x:auto}.sd-cards-carousel:hover,.sd-cards-carousel:focus{overflow-x:auto}.sd-cards-carousel>.sd-card{flex-shrink:0;scroll-snap-align:start}.sd-cards-carousel>.sd-card:not(:last-child){margin-right:3px}.sd-card-cols-1>.sd-card{width:90%}.sd-card-cols-2>.sd-card{width:45%}.sd-card-cols-3>.sd-card{width:30%}.sd-card-cols-4>.sd-card{width:22.5%}.sd-card-cols-5>.sd-card{width:18%}.sd-card-cols-6>.sd-card{width:15%}.sd-card-cols-7>.sd-card{width:12.8571428571%}.sd-card-cols-8>.sd-card{width:11.25%}.sd-card-cols-9>.sd-card{width:10%}.sd-card-cols-10>.sd-card{width:9%}.sd-card-cols-11>.sd-card{width:8.1818181818%}.sd-card-cols-12>.sd-card{width:7.5%}.sd-container,.sd-container-fluid,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container-xl{margin-left:auto;margin-right:auto;padding-left:var(--sd-gutter-x, 0.75rem);padding-right:var(--sd-gutter-x, 0.75rem);width:100%}@media(min-width: 576px){.sd-container-sm,.sd-container{max-width:540px}}@media(min-width: 768px){.sd-container-md,.sd-container-sm,.sd-container{max-width:720px}}@media(min-width: 992px){.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:960px}}@media(min-width: 1200px){.sd-container-xl,.sd-container-lg,.sd-container-md,.sd-container-sm,.sd-container{max-width:1140px}}.sd-row{--sd-gutter-x: 1.5rem;--sd-gutter-y: 0;display:-ms-flexbox;display:flex;-ms-flex-wrap:wrap;flex-wrap:wrap;margin-top:calc(var(--sd-gutter-y) * -1);margin-right:calc(var(--sd-gutter-x) * -0.5);margin-left:calc(var(--sd-gutter-x) * -0.5)}.sd-row>*{box-sizing:border-box;flex-shrink:0;width:100%;max-width:100%;padding-right:calc(var(--sd-gutter-x) * 0.5);padding-left:calc(var(--sd-gutter-x) * 0.5);margin-top:var(--sd-gutter-y)}.sd-col{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-auto>*{flex:0 0 auto;width:auto}.sd-row-cols-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}@media(min-width: 576px){.sd-col-sm{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-sm-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-sm-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-sm-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-sm-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-sm-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-sm-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-sm-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-sm-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-sm-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-sm-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-sm-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-sm-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-sm-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 768px){.sd-col-md{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-md-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-md-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-md-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-md-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-md-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-md-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-md-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-md-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-md-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-md-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-md-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-md-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-md-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 992px){.sd-col-lg{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-lg-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-lg-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-lg-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-lg-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-lg-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-lg-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-lg-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-lg-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-lg-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-lg-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-lg-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-lg-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-lg-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}@media(min-width: 1200px){.sd-col-xl{flex:1 0 0%;-ms-flex:1 0 0%}.sd-row-cols-xl-auto{flex:1 0 auto;-ms-flex:1 0 auto;width:100%}.sd-row-cols-xl-1>*{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-row-cols-xl-2>*{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-row-cols-xl-3>*{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-row-cols-xl-4>*{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-row-cols-xl-5>*{flex:0 0 auto;-ms-flex:0 0 auto;width:20%}.sd-row-cols-xl-6>*{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-row-cols-xl-7>*{flex:0 0 auto;-ms-flex:0 0 auto;width:14.2857142857%}.sd-row-cols-xl-8>*{flex:0 0 auto;-ms-flex:0 0 auto;width:12.5%}.sd-row-cols-xl-9>*{flex:0 0 auto;-ms-flex:0 0 auto;width:11.1111111111%}.sd-row-cols-xl-10>*{flex:0 0 auto;-ms-flex:0 0 auto;width:10%}.sd-row-cols-xl-11>*{flex:0 0 auto;-ms-flex:0 0 auto;width:9.0909090909%}.sd-row-cols-xl-12>*{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}}.sd-col-auto{flex:0 0 auto;-ms-flex:0 0 auto;width:auto}.sd-col-1{flex:0 0 auto;-ms-flex:0 0 auto;width:8.3333333333%}.sd-col-2{flex:0 0 auto;-ms-flex:0 0 auto;width:16.6666666667%}.sd-col-3{flex:0 0 auto;-ms-flex:0 0 auto;width:25%}.sd-col-4{flex:0 0 auto;-ms-flex:0 0 auto;width:33.3333333333%}.sd-col-5{flex:0 0 auto;-ms-flex:0 0 auto;width:41.6666666667%}.sd-col-6{flex:0 0 auto;-ms-flex:0 0 auto;width:50%}.sd-col-7{flex:0 0 auto;-ms-flex:0 0 auto;width:58.3333333333%}.sd-col-8{flex:0 0 auto;-ms-flex:0 0 auto;width:66.6666666667%}.sd-col-9{flex:0 0 auto;-ms-flex:0 0 auto;width:75%}.sd-col-10{flex:0 0 auto;-ms-flex:0 0 auto;width:83.3333333333%}.sd-col-11{flex:0 0 auto;-ms-flex:0 0 auto;width:91.6666666667%}.sd-col-12{flex:0 0 auto;-ms-flex:0 0 auto;width:100%}.sd-g-0,.sd-gy-0{--sd-gutter-y: 0}.sd-g-0,.sd-gx-0{--sd-gutter-x: 0}.sd-g-1,.sd-gy-1{--sd-gutter-y: 0.25rem}.sd-g-1,.sd-gx-1{--sd-gutter-x: 0.25rem}.sd-g-2,.sd-gy-2{--sd-gutter-y: 0.5rem}.sd-g-2,.sd-gx-2{--sd-gutter-x: 0.5rem}.sd-g-3,.sd-gy-3{--sd-gutter-y: 1rem}.sd-g-3,.sd-gx-3{--sd-gutter-x: 1rem}.sd-g-4,.sd-gy-4{--sd-gutter-y: 1.5rem}.sd-g-4,.sd-gx-4{--sd-gutter-x: 1.5rem}.sd-g-5,.sd-gy-5{--sd-gutter-y: 3rem}.sd-g-5,.sd-gx-5{--sd-gutter-x: 3rem}@media(min-width: 576px){.sd-col-sm-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-sm-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-sm-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-sm-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-sm-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-sm-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-sm-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-sm-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-sm-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-sm-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-sm-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-sm-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-sm-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-sm-0,.sd-gy-sm-0{--sd-gutter-y: 0}.sd-g-sm-0,.sd-gx-sm-0{--sd-gutter-x: 0}.sd-g-sm-1,.sd-gy-sm-1{--sd-gutter-y: 0.25rem}.sd-g-sm-1,.sd-gx-sm-1{--sd-gutter-x: 0.25rem}.sd-g-sm-2,.sd-gy-sm-2{--sd-gutter-y: 0.5rem}.sd-g-sm-2,.sd-gx-sm-2{--sd-gutter-x: 0.5rem}.sd-g-sm-3,.sd-gy-sm-3{--sd-gutter-y: 1rem}.sd-g-sm-3,.sd-gx-sm-3{--sd-gutter-x: 1rem}.sd-g-sm-4,.sd-gy-sm-4{--sd-gutter-y: 1.5rem}.sd-g-sm-4,.sd-gx-sm-4{--sd-gutter-x: 1.5rem}.sd-g-sm-5,.sd-gy-sm-5{--sd-gutter-y: 3rem}.sd-g-sm-5,.sd-gx-sm-5{--sd-gutter-x: 3rem}}@media(min-width: 768px){.sd-col-md-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-md-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-md-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-md-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-md-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-md-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-md-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-md-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-md-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-md-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-md-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-md-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-md-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-md-0,.sd-gy-md-0{--sd-gutter-y: 0}.sd-g-md-0,.sd-gx-md-0{--sd-gutter-x: 0}.sd-g-md-1,.sd-gy-md-1{--sd-gutter-y: 0.25rem}.sd-g-md-1,.sd-gx-md-1{--sd-gutter-x: 0.25rem}.sd-g-md-2,.sd-gy-md-2{--sd-gutter-y: 0.5rem}.sd-g-md-2,.sd-gx-md-2{--sd-gutter-x: 0.5rem}.sd-g-md-3,.sd-gy-md-3{--sd-gutter-y: 1rem}.sd-g-md-3,.sd-gx-md-3{--sd-gutter-x: 1rem}.sd-g-md-4,.sd-gy-md-4{--sd-gutter-y: 1.5rem}.sd-g-md-4,.sd-gx-md-4{--sd-gutter-x: 1.5rem}.sd-g-md-5,.sd-gy-md-5{--sd-gutter-y: 3rem}.sd-g-md-5,.sd-gx-md-5{--sd-gutter-x: 3rem}}@media(min-width: 992px){.sd-col-lg-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-lg-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-lg-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-lg-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-lg-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-lg-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-lg-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-lg-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-lg-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-lg-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-lg-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-lg-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-lg-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-lg-0,.sd-gy-lg-0{--sd-gutter-y: 0}.sd-g-lg-0,.sd-gx-lg-0{--sd-gutter-x: 0}.sd-g-lg-1,.sd-gy-lg-1{--sd-gutter-y: 0.25rem}.sd-g-lg-1,.sd-gx-lg-1{--sd-gutter-x: 0.25rem}.sd-g-lg-2,.sd-gy-lg-2{--sd-gutter-y: 0.5rem}.sd-g-lg-2,.sd-gx-lg-2{--sd-gutter-x: 0.5rem}.sd-g-lg-3,.sd-gy-lg-3{--sd-gutter-y: 1rem}.sd-g-lg-3,.sd-gx-lg-3{--sd-gutter-x: 1rem}.sd-g-lg-4,.sd-gy-lg-4{--sd-gutter-y: 1.5rem}.sd-g-lg-4,.sd-gx-lg-4{--sd-gutter-x: 1.5rem}.sd-g-lg-5,.sd-gy-lg-5{--sd-gutter-y: 3rem}.sd-g-lg-5,.sd-gx-lg-5{--sd-gutter-x: 3rem}}@media(min-width: 1200px){.sd-col-xl-auto{-ms-flex:0 0 auto;flex:0 0 auto;width:auto}.sd-col-xl-1{-ms-flex:0 0 auto;flex:0 0 auto;width:8.3333333333%}.sd-col-xl-2{-ms-flex:0 0 auto;flex:0 0 auto;width:16.6666666667%}.sd-col-xl-3{-ms-flex:0 0 auto;flex:0 0 auto;width:25%}.sd-col-xl-4{-ms-flex:0 0 auto;flex:0 0 auto;width:33.3333333333%}.sd-col-xl-5{-ms-flex:0 0 auto;flex:0 0 auto;width:41.6666666667%}.sd-col-xl-6{-ms-flex:0 0 auto;flex:0 0 auto;width:50%}.sd-col-xl-7{-ms-flex:0 0 auto;flex:0 0 auto;width:58.3333333333%}.sd-col-xl-8{-ms-flex:0 0 auto;flex:0 0 auto;width:66.6666666667%}.sd-col-xl-9{-ms-flex:0 0 auto;flex:0 0 auto;width:75%}.sd-col-xl-10{-ms-flex:0 0 auto;flex:0 0 auto;width:83.3333333333%}.sd-col-xl-11{-ms-flex:0 0 auto;flex:0 0 auto;width:91.6666666667%}.sd-col-xl-12{-ms-flex:0 0 auto;flex:0 0 auto;width:100%}.sd-g-xl-0,.sd-gy-xl-0{--sd-gutter-y: 0}.sd-g-xl-0,.sd-gx-xl-0{--sd-gutter-x: 0}.sd-g-xl-1,.sd-gy-xl-1{--sd-gutter-y: 0.25rem}.sd-g-xl-1,.sd-gx-xl-1{--sd-gutter-x: 0.25rem}.sd-g-xl-2,.sd-gy-xl-2{--sd-gutter-y: 0.5rem}.sd-g-xl-2,.sd-gx-xl-2{--sd-gutter-x: 0.5rem}.sd-g-xl-3,.sd-gy-xl-3{--sd-gutter-y: 1rem}.sd-g-xl-3,.sd-gx-xl-3{--sd-gutter-x: 1rem}.sd-g-xl-4,.sd-gy-xl-4{--sd-gutter-y: 1.5rem}.sd-g-xl-4,.sd-gx-xl-4{--sd-gutter-x: 1.5rem}.sd-g-xl-5,.sd-gy-xl-5{--sd-gutter-y: 3rem}.sd-g-xl-5,.sd-gx-xl-5{--sd-gutter-x: 3rem}}.sd-flex-row-reverse{flex-direction:row-reverse !important}details.sd-dropdown{position:relative}details.sd-dropdown .sd-summary-title{font-weight:700;padding-right:3em !important;-moz-user-select:none;-ms-user-select:none;-webkit-user-select:none;user-select:none}details.sd-dropdown:hover{cursor:pointer}details.sd-dropdown .sd-summary-content{cursor:default}details.sd-dropdown summary{list-style:none;padding:1em}details.sd-dropdown summary .sd-octicon.no-title{vertical-align:middle}details.sd-dropdown[open] summary .sd-octicon.no-title{visibility:hidden}details.sd-dropdown summary::-webkit-details-marker{display:none}details.sd-dropdown summary:focus{outline:none}details.sd-dropdown .sd-summary-icon{margin-right:.5em}details.sd-dropdown .sd-summary-icon svg{opacity:.8}details.sd-dropdown summary:hover .sd-summary-up svg,details.sd-dropdown summary:hover .sd-summary-down svg{opacity:1;transform:scale(1.1)}details.sd-dropdown .sd-summary-up svg,details.sd-dropdown .sd-summary-down svg{display:block;opacity:.6}details.sd-dropdown .sd-summary-up,details.sd-dropdown .sd-summary-down{pointer-events:none;position:absolute;right:1em;top:1em}details.sd-dropdown[open]>.sd-summary-title .sd-summary-down{visibility:hidden}details.sd-dropdown:not([open])>.sd-summary-title .sd-summary-up{visibility:hidden}details.sd-dropdown:not([open]).sd-card{border:none}details.sd-dropdown:not([open])>.sd-card-header{border:1px solid var(--sd-color-card-border);border-radius:.25rem}details.sd-dropdown.sd-fade-in[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out;animation:sd-fade-in .5s ease-in-out}details.sd-dropdown.sd-fade-in-slide-down[open] summary~*{-moz-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;-webkit-animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out;animation:sd-fade-in .5s ease-in-out,sd-slide-down .5s ease-in-out}.sd-col>.sd-dropdown{width:100%}.sd-summary-content>.sd-tab-set:first-child{margin-top:0}@keyframes sd-fade-in{0%{opacity:0}100%{opacity:1}}@keyframes sd-slide-down{0%{transform:translate(0, -10px)}100%{transform:translate(0, 0)}}.sd-tab-set{border-radius:.125rem;display:flex;flex-wrap:wrap;margin:1em 0;position:relative}.sd-tab-set>input{opacity:0;position:absolute}.sd-tab-set>input:checked+label{border-color:var(--sd-color-tabs-underline-active);color:var(--sd-color-tabs-label-active)}.sd-tab-set>input:checked+label+.sd-tab-content{display:block}.sd-tab-set>input:not(:checked)+label:hover{color:var(--sd-color-tabs-label-hover);border-color:var(--sd-color-tabs-underline-hover)}.sd-tab-set>input:focus+label{outline-style:auto}.sd-tab-set>input:not(.focus-visible)+label{outline:none;-webkit-tap-highlight-color:transparent}.sd-tab-set>label{border-bottom:.125rem solid transparent;margin-bottom:0;color:var(--sd-color-tabs-label-inactive);border-color:var(--sd-color-tabs-underline-inactive);cursor:pointer;font-size:var(--sd-fontsize-tabs-label);font-weight:700;padding:1em 1.25em .5em;transition:color 250ms;width:auto;z-index:1}html .sd-tab-set>label:hover{color:var(--sd-color-tabs-label-active)}.sd-col>.sd-tab-set{width:100%}.sd-tab-content{box-shadow:0 -0.0625rem var(--sd-color-tabs-overline),0 .0625rem var(--sd-color-tabs-underline);display:none;order:99;padding-bottom:.75rem;padding-top:.75rem;width:100%}.sd-tab-content>:first-child{margin-top:0 !important}.sd-tab-content>:last-child{margin-bottom:0 !important}.sd-tab-content>.sd-tab-set{margin:0}.sd-sphinx-override,.sd-sphinx-override *{-moz-box-sizing:border-box;-webkit-box-sizing:border-box;box-sizing:border-box}.sd-sphinx-override p{margin-top:0}:root{--sd-color-primary: #0071bc;--sd-color-secondary: #6c757d;--sd-color-success: #28a745;--sd-color-info: #17a2b8;--sd-color-warning: #f0b37e;--sd-color-danger: #dc3545;--sd-color-light: #f8f9fa;--sd-color-muted: #6c757d;--sd-color-dark: #212529;--sd-color-black: black;--sd-color-white: white;--sd-color-primary-highlight: #0060a0;--sd-color-secondary-highlight: #5c636a;--sd-color-success-highlight: #228e3b;--sd-color-info-highlight: #148a9c;--sd-color-warning-highlight: #cc986b;--sd-color-danger-highlight: #bb2d3b;--sd-color-light-highlight: #d3d4d5;--sd-color-muted-highlight: #5c636a;--sd-color-dark-highlight: #1c1f23;--sd-color-black-highlight: black;--sd-color-white-highlight: #d9d9d9;--sd-color-primary-text: #fff;--sd-color-secondary-text: #fff;--sd-color-success-text: #fff;--sd-color-info-text: #fff;--sd-color-warning-text: #212529;--sd-color-danger-text: #fff;--sd-color-light-text: #212529;--sd-color-muted-text: #fff;--sd-color-dark-text: #fff;--sd-color-black-text: #fff;--sd-color-white-text: #212529;--sd-color-shadow: rgba(0, 0, 0, 0.15);--sd-color-card-border: rgba(0, 0, 0, 0.125);--sd-color-card-border-hover: hsla(231, 99%, 66%, 1);--sd-color-card-background: transparent;--sd-color-card-text: inherit;--sd-color-card-header: transparent;--sd-color-card-footer: transparent;--sd-color-tabs-label-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-hover: hsla(231, 99%, 66%, 1);--sd-color-tabs-label-inactive: hsl(0, 0%, 66%);--sd-color-tabs-underline-active: hsla(231, 99%, 66%, 1);--sd-color-tabs-underline-hover: rgba(178, 206, 245, 0.62);--sd-color-tabs-underline-inactive: transparent;--sd-color-tabs-overline: rgb(222, 222, 222);--sd-color-tabs-underline: rgb(222, 222, 222);--sd-fontsize-tabs-label: 1rem}
diff --git a/2024.3/_static/design-tabs.js b/2024.3/_static/design-tabs.js
new file mode 100644
index 0000000000..36b38cf0d9
--- /dev/null
+++ b/2024.3/_static/design-tabs.js
@@ -0,0 +1,27 @@
+var sd_labels_by_text = {};
+
+function ready() {
+ const li = document.getElementsByClassName("sd-tab-label");
+ for (const label of li) {
+ syncId = label.getAttribute("data-sync-id");
+ if (syncId) {
+ label.onclick = onLabelClick;
+ if (!sd_labels_by_text[syncId]) {
+ sd_labels_by_text[syncId] = [];
+ }
+ sd_labels_by_text[syncId].push(label);
+ }
+ }
+}
+
+function onLabelClick() {
+ // Activate other inputs with the same sync id.
+ syncId = this.getAttribute("data-sync-id");
+ for (label of sd_labels_by_text[syncId]) {
+ if (label === this) continue;
+ label.previousElementSibling.checked = true;
+ }
+ window.localStorage.setItem("sphinx-design-last-tab", syncId);
+}
+
+document.addEventListener("DOMContentLoaded", ready, false);
diff --git a/2024.3/_static/doctools.js b/2024.3/_static/doctools.js
new file mode 100644
index 0000000000..d06a71d751
--- /dev/null
+++ b/2024.3/_static/doctools.js
@@ -0,0 +1,156 @@
+/*
+ * doctools.js
+ * ~~~~~~~~~~~
+ *
+ * Base JavaScript utilities for all Sphinx HTML documentation.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+"use strict";
+
+const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([
+ "TEXTAREA",
+ "INPUT",
+ "SELECT",
+ "BUTTON",
+]);
+
+const _ready = (callback) => {
+ if (document.readyState !== "loading") {
+ callback();
+ } else {
+ document.addEventListener("DOMContentLoaded", callback);
+ }
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const Documentation = {
+ init: () => {
+ Documentation.initDomainIndexTable();
+ Documentation.initOnKeyListeners();
+ },
+
+ /**
+ * i18n support
+ */
+ TRANSLATIONS: {},
+ PLURAL_EXPR: (n) => (n === 1 ? 0 : 1),
+ LOCALE: "unknown",
+
+ // gettext and ngettext don't access this so that the functions
+ // can safely bound to a different name (_ = Documentation.gettext)
+ gettext: (string) => {
+ const translated = Documentation.TRANSLATIONS[string];
+ switch (typeof translated) {
+ case "undefined":
+ return string; // no translation
+ case "string":
+ return translated; // translation exists
+ default:
+ return translated[0]; // (singular, plural) translation tuple exists
+ }
+ },
+
+ ngettext: (singular, plural, n) => {
+ const translated = Documentation.TRANSLATIONS[singular];
+ if (typeof translated !== "undefined")
+ return translated[Documentation.PLURAL_EXPR(n)];
+ return n === 1 ? singular : plural;
+ },
+
+ addTranslations: (catalog) => {
+ Object.assign(Documentation.TRANSLATIONS, catalog.messages);
+ Documentation.PLURAL_EXPR = new Function(
+ "n",
+ `return (${catalog.plural_expr})`
+ );
+ Documentation.LOCALE = catalog.locale;
+ },
+
+ /**
+ * helper function to focus on search bar
+ */
+ focusSearchBar: () => {
+ document.querySelectorAll("input[name=q]")[0]?.focus();
+ },
+
+ /**
+ * Initialise the domain index toggle buttons
+ */
+ initDomainIndexTable: () => {
+ const toggler = (el) => {
+ const idNumber = el.id.substr(7);
+ const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`);
+ if (el.src.substr(-9) === "minus.png") {
+ el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`;
+ toggledRows.forEach((el) => (el.style.display = "none"));
+ } else {
+ el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`;
+ toggledRows.forEach((el) => (el.style.display = ""));
+ }
+ };
+
+ const togglerElements = document.querySelectorAll("img.toggler");
+ togglerElements.forEach((el) =>
+ el.addEventListener("click", (event) => toggler(event.currentTarget))
+ );
+ togglerElements.forEach((el) => (el.style.display = ""));
+ if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler);
+ },
+
+ initOnKeyListeners: () => {
+ // only install a listener if it is really needed
+ if (
+ !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS &&
+ !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS
+ )
+ return;
+
+ document.addEventListener("keydown", (event) => {
+ // bail for input elements
+ if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+ // bail with special keys
+ if (event.altKey || event.ctrlKey || event.metaKey) return;
+
+ if (!event.shiftKey) {
+ switch (event.key) {
+ case "ArrowLeft":
+ if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+ const prevLink = document.querySelector('link[rel="prev"]');
+ if (prevLink && prevLink.href) {
+ window.location.href = prevLink.href;
+ event.preventDefault();
+ }
+ break;
+ case "ArrowRight":
+ if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break;
+
+ const nextLink = document.querySelector('link[rel="next"]');
+ if (nextLink && nextLink.href) {
+ window.location.href = nextLink.href;
+ event.preventDefault();
+ }
+ break;
+ }
+ }
+
+ // some keyboard layouts may need Shift to get /
+ switch (event.key) {
+ case "/":
+ if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break;
+ Documentation.focusSearchBar();
+ event.preventDefault();
+ }
+ });
+ },
+};
+
+// quick alias for translations
+const _ = Documentation.gettext;
+
+_ready(Documentation.init);
diff --git a/2024.3/_static/documentation_options.js b/2024.3/_static/documentation_options.js
new file mode 100644
index 0000000000..8f648a2bc1
--- /dev/null
+++ b/2024.3/_static/documentation_options.js
@@ -0,0 +1,14 @@
+var DOCUMENTATION_OPTIONS = {
+ URL_ROOT: document.getElementById("documentation_options").getAttribute('data-url_root'),
+ VERSION: '2024.3',
+ LANGUAGE: 'en',
+ COLLAPSE_INDEX: false,
+ BUILDER: 'html',
+ FILE_SUFFIX: '.html',
+ LINK_SUFFIX: '.html',
+ HAS_SOURCE: true,
+ SOURCELINK_SUFFIX: '.txt',
+ NAVIGATION_WITH_KEYS: false,
+ SHOW_SEARCH_SUMMARY: true,
+ ENABLE_SEARCH_SHORTCUTS: true,
+};
\ No newline at end of file
diff --git a/2024.3/_static/favicons.png b/2024.3/_static/favicons.png
new file mode 100644
index 0000000000..f450376b19
Binary files /dev/null and b/2024.3/_static/favicons.png differ
diff --git a/2024.3/_static/file.png b/2024.3/_static/file.png
new file mode 100644
index 0000000000..a858a410e4
Binary files /dev/null and b/2024.3/_static/file.png differ
diff --git a/2024.3/_static/jquery.js b/2024.3/_static/jquery.js
new file mode 100644
index 0000000000..c4c6022f29
--- /dev/null
+++ b/2024.3/_static/jquery.js
@@ -0,0 +1,2 @@
+/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */
+!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML=" ",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML=" ";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML=" ",y.option=!!ce.lastChild;var ge={thead:[1,""],col:[2,""],tr:[2,""],td:[3,""],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML=" ",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document);
\ No newline at end of file
diff --git a/2024.3/_static/js/html5shiv.min.js b/2024.3/_static/js/html5shiv.min.js
new file mode 100644
index 0000000000..cd1c674f5e
--- /dev/null
+++ b/2024.3/_static/js/html5shiv.min.js
@@ -0,0 +1,4 @@
+/**
+* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed
+*/
+!function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML=" ",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document);
\ No newline at end of file
diff --git a/2024.3/_static/js/theme.js b/2024.3/_static/js/theme.js
new file mode 100644
index 0000000000..1fddb6ee4a
--- /dev/null
+++ b/2024.3/_static/js/theme.js
@@ -0,0 +1 @@
+!function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("
"),n("table.docutils.footnote").wrap(""),n("table.docutils.citation").wrap("
"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n(' '),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t0
+ var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1
+ var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1
+ var s_v = "^(" + C + ")?" + v; // vowel in stem
+
+ this.stemWord = function (w) {
+ var stem;
+ var suffix;
+ var firstch;
+ var origword = w;
+
+ if (w.length < 3)
+ return w;
+
+ var re;
+ var re2;
+ var re3;
+ var re4;
+
+ firstch = w.substr(0,1);
+ if (firstch == "y")
+ w = firstch.toUpperCase() + w.substr(1);
+
+ // Step 1a
+ re = /^(.+?)(ss|i)es$/;
+ re2 = /^(.+?)([^s])s$/;
+
+ if (re.test(w))
+ w = w.replace(re,"$1$2");
+ else if (re2.test(w))
+ w = w.replace(re2,"$1$2");
+
+ // Step 1b
+ re = /^(.+?)eed$/;
+ re2 = /^(.+?)(ed|ing)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ re = new RegExp(mgr0);
+ if (re.test(fp[1])) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1];
+ re2 = new RegExp(s_v);
+ if (re2.test(stem)) {
+ w = stem;
+ re2 = /(at|bl|iz)$/;
+ re3 = new RegExp("([^aeiouylsz])\\1$");
+ re4 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re2.test(w))
+ w = w + "e";
+ else if (re3.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+ else if (re4.test(w))
+ w = w + "e";
+ }
+ }
+
+ // Step 1c
+ re = /^(.+?)y$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(s_v);
+ if (re.test(stem))
+ w = stem + "i";
+ }
+
+ // Step 2
+ re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step2list[suffix];
+ }
+
+ // Step 3
+ re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ suffix = fp[2];
+ re = new RegExp(mgr0);
+ if (re.test(stem))
+ w = stem + step3list[suffix];
+ }
+
+ // Step 4
+ re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/;
+ re2 = /^(.+?)(s|t)(ion)$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ if (re.test(stem))
+ w = stem;
+ }
+ else if (re2.test(w)) {
+ var fp = re2.exec(w);
+ stem = fp[1] + fp[2];
+ re2 = new RegExp(mgr1);
+ if (re2.test(stem))
+ w = stem;
+ }
+
+ // Step 5
+ re = /^(.+?)e$/;
+ if (re.test(w)) {
+ var fp = re.exec(w);
+ stem = fp[1];
+ re = new RegExp(mgr1);
+ re2 = new RegExp(meq1);
+ re3 = new RegExp("^" + C + v + "[^aeiouwxy]$");
+ if (re.test(stem) || (re2.test(stem) && !(re3.test(stem))))
+ w = stem;
+ }
+ re = /ll$/;
+ re2 = new RegExp(mgr1);
+ if (re.test(w) && re2.test(w)) {
+ re = /.$/;
+ w = w.replace(re,"");
+ }
+
+ // and turn initial Y back to y
+ if (firstch == "y")
+ w = firstch.toLowerCase() + w.substr(1);
+ return w;
+ }
+}
+
diff --git a/2024.3/_static/minus.png b/2024.3/_static/minus.png
new file mode 100644
index 0000000000..d96755fdaf
Binary files /dev/null and b/2024.3/_static/minus.png differ
diff --git a/2024.3/_static/nbsphinx-broken-thumbnail.svg b/2024.3/_static/nbsphinx-broken-thumbnail.svg
new file mode 100644
index 0000000000..4919ca8829
--- /dev/null
+++ b/2024.3/_static/nbsphinx-broken-thumbnail.svg
@@ -0,0 +1,9 @@
+
+
+
+
diff --git a/2024.3/_static/nbsphinx-code-cells.css b/2024.3/_static/nbsphinx-code-cells.css
new file mode 100644
index 0000000000..a3fb27c30f
--- /dev/null
+++ b/2024.3/_static/nbsphinx-code-cells.css
@@ -0,0 +1,259 @@
+/* remove conflicting styling from Sphinx themes */
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt *,
+div.nbinput.container div.input_area pre,
+div.nboutput.container div.output_area pre,
+div.nbinput.container div.input_area .highlight,
+div.nboutput.container div.output_area .highlight {
+ border: none;
+ padding: 0;
+ margin: 0;
+ box-shadow: none;
+}
+
+div.nbinput.container > div[class*=highlight],
+div.nboutput.container > div[class*=highlight] {
+ margin: 0;
+}
+
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt * {
+ background: none;
+}
+
+div.nboutput.container div.output_area .highlight,
+div.nboutput.container div.output_area pre {
+ background: unset;
+}
+
+div.nboutput.container div.output_area div.highlight {
+ color: unset; /* override Pygments text color */
+}
+
+/* avoid gaps between output lines */
+div.nboutput.container div[class*=highlight] pre {
+ line-height: normal;
+}
+
+/* input/output containers */
+div.nbinput.container,
+div.nboutput.container {
+ display: -webkit-flex;
+ display: flex;
+ align-items: flex-start;
+ margin: 0;
+ width: 100%;
+}
+@media (max-width: 540px) {
+ div.nbinput.container,
+ div.nboutput.container {
+ flex-direction: column;
+ }
+}
+
+/* input container */
+div.nbinput.container {
+ padding-top: 5px;
+}
+
+/* last container */
+div.nblast.container {
+ padding-bottom: 5px;
+}
+
+/* input prompt */
+div.nbinput.container div.prompt pre,
+/* for sphinx_immaterial theme: */
+div.nbinput.container div.prompt pre > code {
+ color: #307FC1;
+}
+
+/* output prompt */
+div.nboutput.container div.prompt pre,
+/* for sphinx_immaterial theme: */
+div.nboutput.container div.prompt pre > code {
+ color: #BF5B3D;
+}
+
+/* all prompts */
+div.nbinput.container div.prompt,
+div.nboutput.container div.prompt {
+ width: 4.5ex;
+ padding-top: 5px;
+ position: relative;
+ user-select: none;
+}
+
+div.nbinput.container div.prompt > div,
+div.nboutput.container div.prompt > div {
+ position: absolute;
+ right: 0;
+ margin-right: 0.3ex;
+}
+
+@media (max-width: 540px) {
+ div.nbinput.container div.prompt,
+ div.nboutput.container div.prompt {
+ width: unset;
+ text-align: left;
+ padding: 0.4em;
+ }
+ div.nboutput.container div.prompt.empty {
+ padding: 0;
+ }
+
+ div.nbinput.container div.prompt > div,
+ div.nboutput.container div.prompt > div {
+ position: unset;
+ }
+}
+
+/* disable scrollbars and line breaks on prompts */
+div.nbinput.container div.prompt pre,
+div.nboutput.container div.prompt pre {
+ overflow: hidden;
+ white-space: pre;
+}
+
+/* input/output area */
+div.nbinput.container div.input_area,
+div.nboutput.container div.output_area {
+ -webkit-flex: 1;
+ flex: 1;
+ overflow: auto;
+}
+@media (max-width: 540px) {
+ div.nbinput.container div.input_area,
+ div.nboutput.container div.output_area {
+ width: 100%;
+ }
+}
+
+/* input area */
+div.nbinput.container div.input_area {
+ border: 1px solid #e0e0e0;
+ border-radius: 2px;
+ /*background: #f5f5f5;*/
+}
+
+/* override MathJax center alignment in output cells */
+div.nboutput.container div[class*=MathJax] {
+ text-align: left !important;
+}
+
+/* override sphinx.ext.imgmath center alignment in output cells */
+div.nboutput.container div.math p {
+ text-align: left;
+}
+
+/* standard error */
+div.nboutput.container div.output_area.stderr {
+ background: #fdd;
+}
+
+/* ANSI colors */
+.ansi-black-fg { color: #3E424D; }
+.ansi-black-bg { background-color: #3E424D; }
+.ansi-black-intense-fg { color: #282C36; }
+.ansi-black-intense-bg { background-color: #282C36; }
+.ansi-red-fg { color: #E75C58; }
+.ansi-red-bg { background-color: #E75C58; }
+.ansi-red-intense-fg { color: #B22B31; }
+.ansi-red-intense-bg { background-color: #B22B31; }
+.ansi-green-fg { color: #00A250; }
+.ansi-green-bg { background-color: #00A250; }
+.ansi-green-intense-fg { color: #007427; }
+.ansi-green-intense-bg { background-color: #007427; }
+.ansi-yellow-fg { color: #DDB62B; }
+.ansi-yellow-bg { background-color: #DDB62B; }
+.ansi-yellow-intense-fg { color: #B27D12; }
+.ansi-yellow-intense-bg { background-color: #B27D12; }
+.ansi-blue-fg { color: #208FFB; }
+.ansi-blue-bg { background-color: #208FFB; }
+.ansi-blue-intense-fg { color: #0065CA; }
+.ansi-blue-intense-bg { background-color: #0065CA; }
+.ansi-magenta-fg { color: #D160C4; }
+.ansi-magenta-bg { background-color: #D160C4; }
+.ansi-magenta-intense-fg { color: #A03196; }
+.ansi-magenta-intense-bg { background-color: #A03196; }
+.ansi-cyan-fg { color: #60C6C8; }
+.ansi-cyan-bg { background-color: #60C6C8; }
+.ansi-cyan-intense-fg { color: #258F8F; }
+.ansi-cyan-intense-bg { background-color: #258F8F; }
+.ansi-white-fg { color: #C5C1B4; }
+.ansi-white-bg { background-color: #C5C1B4; }
+.ansi-white-intense-fg { color: #A1A6B2; }
+.ansi-white-intense-bg { background-color: #A1A6B2; }
+
+.ansi-default-inverse-fg { color: #FFFFFF; }
+.ansi-default-inverse-bg { background-color: #000000; }
+
+.ansi-bold { font-weight: bold; }
+.ansi-underline { text-decoration: underline; }
+
+
+div.nbinput.container div.input_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight].math,
+div.nboutput.container div.output_area.rendered_html,
+div.nboutput.container div.output_area > div.output_javascript,
+div.nboutput.container div.output_area:not(.rendered_html) > img{
+ padding: 5px;
+ margin: 0;
+}
+
+/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
+div.nbinput.container div.input_area > div[class^='highlight'],
+div.nboutput.container div.output_area > div[class^='highlight']{
+ overflow-y: hidden;
+}
+
+/* hide copy button on prompts for 'sphinx_copybutton' extension ... */
+.prompt .copybtn,
+/* ... and 'sphinx_immaterial' theme */
+.prompt .md-clipboard.md-icon {
+ display: none;
+}
+
+/* Some additional styling taken form the Jupyter notebook CSS */
+.jp-RenderedHTMLCommon table,
+div.rendered_html table {
+ border: none;
+ border-collapse: collapse;
+ border-spacing: 0;
+ color: black;
+ font-size: 12px;
+ table-layout: fixed;
+}
+.jp-RenderedHTMLCommon thead,
+div.rendered_html thead {
+ border-bottom: 1px solid black;
+ vertical-align: bottom;
+}
+.jp-RenderedHTMLCommon tr,
+.jp-RenderedHTMLCommon th,
+.jp-RenderedHTMLCommon td,
+div.rendered_html tr,
+div.rendered_html th,
+div.rendered_html td {
+ text-align: right;
+ vertical-align: middle;
+ padding: 0.5em 0.5em;
+ line-height: normal;
+ white-space: normal;
+ max-width: none;
+ border: none;
+}
+.jp-RenderedHTMLCommon th,
+div.rendered_html th {
+ font-weight: bold;
+}
+.jp-RenderedHTMLCommon tbody tr:nth-child(odd),
+div.rendered_html tbody tr:nth-child(odd) {
+ background: #f5f5f5;
+}
+.jp-RenderedHTMLCommon tbody tr:hover,
+div.rendered_html tbody tr:hover {
+ background: rgba(66, 165, 245, 0.2);
+}
+
diff --git a/2024.3/_static/nbsphinx-gallery.css b/2024.3/_static/nbsphinx-gallery.css
new file mode 100644
index 0000000000..365c27a96b
--- /dev/null
+++ b/2024.3/_static/nbsphinx-gallery.css
@@ -0,0 +1,31 @@
+.nbsphinx-gallery {
+ display: grid;
+ grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+ gap: 5px;
+ margin-top: 1em;
+ margin-bottom: 1em;
+}
+
+.nbsphinx-gallery > a {
+ padding: 5px;
+ border: 1px dotted currentColor;
+ border-radius: 2px;
+ text-align: center;
+}
+
+.nbsphinx-gallery > a:hover {
+ border-style: solid;
+}
+
+.nbsphinx-gallery img {
+ max-width: 100%;
+ max-height: 100%;
+}
+
+.nbsphinx-gallery > a > div:first-child {
+ display: flex;
+ align-items: start;
+ justify-content: center;
+ height: 120px;
+ margin-bottom: 5px;
+}
diff --git a/2024.3/_static/nbsphinx-no-thumbnail.svg b/2024.3/_static/nbsphinx-no-thumbnail.svg
new file mode 100644
index 0000000000..9dca7588fa
--- /dev/null
+++ b/2024.3/_static/nbsphinx-no-thumbnail.svg
@@ -0,0 +1,9 @@
+
+
+
+
diff --git a/2024.3/_static/oneAPI-rgb-rev-100.png b/2024.3/_static/oneAPI-rgb-rev-100.png
new file mode 100644
index 0000000000..58d2d5c54e
Binary files /dev/null and b/2024.3/_static/oneAPI-rgb-rev-100.png differ
diff --git a/2024.3/_static/plus.png b/2024.3/_static/plus.png
new file mode 100644
index 0000000000..7107cec93a
Binary files /dev/null and b/2024.3/_static/plus.png differ
diff --git a/2024.3/_static/pygments.css b/2024.3/_static/pygments.css
new file mode 100644
index 0000000000..0d49244eda
--- /dev/null
+++ b/2024.3/_static/pygments.css
@@ -0,0 +1,75 @@
+pre { line-height: 125%; }
+td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
+td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
+.highlight .hll { background-color: #ffffcc }
+.highlight { background: #eeffcc; }
+.highlight .c { color: #408090; font-style: italic } /* Comment */
+.highlight .err { border: 1px solid #FF0000 } /* Error */
+.highlight .k { color: #007020; font-weight: bold } /* Keyword */
+.highlight .o { color: #666666 } /* Operator */
+.highlight .ch { color: #408090; font-style: italic } /* Comment.Hashbang */
+.highlight .cm { color: #408090; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #007020 } /* Comment.Preproc */
+.highlight .cpf { color: #408090; font-style: italic } /* Comment.PreprocFile */
+.highlight .c1 { color: #408090; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #408090; background-color: #fff0f0 } /* Comment.Special */
+.highlight .gd { color: #A00000 } /* Generic.Deleted */
+.highlight .ge { font-style: italic } /* Generic.Emph */
+.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */
+.highlight .gr { color: #FF0000 } /* Generic.Error */
+.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */
+.highlight .gi { color: #00A000 } /* Generic.Inserted */
+.highlight .go { color: #333333 } /* Generic.Output */
+.highlight .gp { color: #c65d09; font-weight: bold } /* Generic.Prompt */
+.highlight .gs { font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */
+.highlight .gt { color: #0044DD } /* Generic.Traceback */
+.highlight .kc { color: #007020; font-weight: bold } /* Keyword.Constant */
+.highlight .kd { color: #007020; font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { color: #007020; font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { color: #007020 } /* Keyword.Pseudo */
+.highlight .kr { color: #007020; font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #902000 } /* Keyword.Type */
+.highlight .m { color: #208050 } /* Literal.Number */
+.highlight .s { color: #4070a0 } /* Literal.String */
+.highlight .na { color: #4070a0 } /* Name.Attribute */
+.highlight .nb { color: #007020 } /* Name.Builtin */
+.highlight .nc { color: #0e84b5; font-weight: bold } /* Name.Class */
+.highlight .no { color: #60add5 } /* Name.Constant */
+.highlight .nd { color: #555555; font-weight: bold } /* Name.Decorator */
+.highlight .ni { color: #d55537; font-weight: bold } /* Name.Entity */
+.highlight .ne { color: #007020 } /* Name.Exception */
+.highlight .nf { color: #06287e } /* Name.Function */
+.highlight .nl { color: #002070; font-weight: bold } /* Name.Label */
+.highlight .nn { color: #0e84b5; font-weight: bold } /* Name.Namespace */
+.highlight .nt { color: #062873; font-weight: bold } /* Name.Tag */
+.highlight .nv { color: #bb60d5 } /* Name.Variable */
+.highlight .ow { color: #007020; font-weight: bold } /* Operator.Word */
+.highlight .w { color: #bbbbbb } /* Text.Whitespace */
+.highlight .mb { color: #208050 } /* Literal.Number.Bin */
+.highlight .mf { color: #208050 } /* Literal.Number.Float */
+.highlight .mh { color: #208050 } /* Literal.Number.Hex */
+.highlight .mi { color: #208050 } /* Literal.Number.Integer */
+.highlight .mo { color: #208050 } /* Literal.Number.Oct */
+.highlight .sa { color: #4070a0 } /* Literal.String.Affix */
+.highlight .sb { color: #4070a0 } /* Literal.String.Backtick */
+.highlight .sc { color: #4070a0 } /* Literal.String.Char */
+.highlight .dl { color: #4070a0 } /* Literal.String.Delimiter */
+.highlight .sd { color: #4070a0; font-style: italic } /* Literal.String.Doc */
+.highlight .s2 { color: #4070a0 } /* Literal.String.Double */
+.highlight .se { color: #4070a0; font-weight: bold } /* Literal.String.Escape */
+.highlight .sh { color: #4070a0 } /* Literal.String.Heredoc */
+.highlight .si { color: #70a0d0; font-style: italic } /* Literal.String.Interpol */
+.highlight .sx { color: #c65d09 } /* Literal.String.Other */
+.highlight .sr { color: #235388 } /* Literal.String.Regex */
+.highlight .s1 { color: #4070a0 } /* Literal.String.Single */
+.highlight .ss { color: #517918 } /* Literal.String.Symbol */
+.highlight .bp { color: #007020 } /* Name.Builtin.Pseudo */
+.highlight .fm { color: #06287e } /* Name.Function.Magic */
+.highlight .vc { color: #bb60d5 } /* Name.Variable.Class */
+.highlight .vg { color: #bb60d5 } /* Name.Variable.Global */
+.highlight .vi { color: #bb60d5 } /* Name.Variable.Instance */
+.highlight .vm { color: #bb60d5 } /* Name.Variable.Magic */
+.highlight .il { color: #208050 } /* Literal.Number.Integer.Long */
\ No newline at end of file
diff --git a/2024.3/_static/scikit-learn-acceleration-2021.2.3.PNG b/2024.3/_static/scikit-learn-acceleration-2021.2.3.PNG
new file mode 100644
index 0000000000..d52bc0bd8c
Binary files /dev/null and b/2024.3/_static/scikit-learn-acceleration-2021.2.3.PNG differ
diff --git a/2024.3/_static/scikit-learn-acceleration.PNG b/2024.3/_static/scikit-learn-acceleration.PNG
new file mode 100644
index 0000000000..d045478f39
Binary files /dev/null and b/2024.3/_static/scikit-learn-acceleration.PNG differ
diff --git a/2024.3/_static/searchtools.js b/2024.3/_static/searchtools.js
new file mode 100644
index 0000000000..97d56a74d8
--- /dev/null
+++ b/2024.3/_static/searchtools.js
@@ -0,0 +1,566 @@
+/*
+ * searchtools.js
+ * ~~~~~~~~~~~~~~~~
+ *
+ * Sphinx JavaScript utilities for the full-text search.
+ *
+ * :copyright: Copyright 2007-2023 by the Sphinx team, see AUTHORS.
+ * :license: BSD, see LICENSE for details.
+ *
+ */
+"use strict";
+
+/**
+ * Simple result scoring code.
+ */
+if (typeof Scorer === "undefined") {
+ var Scorer = {
+ // Implement the following function to further tweak the score for each result
+ // The function takes a result array [docname, title, anchor, descr, score, filename]
+ // and returns the new score.
+ /*
+ score: result => {
+ const [docname, title, anchor, descr, score, filename] = result
+ return score
+ },
+ */
+
+ // query matches the full name of an object
+ objNameMatch: 11,
+ // or matches in the last dotted part of the object name
+ objPartialMatch: 6,
+ // Additive scores depending on the priority of the object
+ objPrio: {
+ 0: 15, // used to be importantResults
+ 1: 5, // used to be objectResults
+ 2: -5, // used to be unimportantResults
+ },
+ // Used when the priority is not in the mapping.
+ objPrioDefault: 0,
+
+ // query found in title
+ title: 15,
+ partialTitle: 7,
+ // query found in terms
+ term: 5,
+ partialTerm: 2,
+ };
+}
+
+const _removeChildren = (element) => {
+ while (element && element.lastChild) element.removeChild(element.lastChild);
+};
+
+/**
+ * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping
+ */
+const _escapeRegExp = (string) =>
+ string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string
+
+const _displayItem = (item, searchTerms) => {
+ const docBuilder = DOCUMENTATION_OPTIONS.BUILDER;
+ const docUrlRoot = DOCUMENTATION_OPTIONS.URL_ROOT;
+ const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX;
+ const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX;
+ const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY;
+
+ const [docName, title, anchor, descr, score, _filename] = item;
+
+ let listItem = document.createElement("li");
+ let requestUrl;
+ let linkUrl;
+ if (docBuilder === "dirhtml") {
+ // dirhtml builder
+ let dirname = docName + "/";
+ if (dirname.match(/\/index\/$/))
+ dirname = dirname.substring(0, dirname.length - 6);
+ else if (dirname === "index/") dirname = "";
+ requestUrl = docUrlRoot + dirname;
+ linkUrl = requestUrl;
+ } else {
+ // normal html builders
+ requestUrl = docUrlRoot + docName + docFileSuffix;
+ linkUrl = docName + docLinkSuffix;
+ }
+ let linkEl = listItem.appendChild(document.createElement("a"));
+ linkEl.href = linkUrl + anchor;
+ linkEl.dataset.score = score;
+ linkEl.innerHTML = title;
+ if (descr)
+ listItem.appendChild(document.createElement("span")).innerHTML =
+ " (" + descr + ")";
+ else if (showSearchSummary)
+ fetch(requestUrl)
+ .then((responseData) => responseData.text())
+ .then((data) => {
+ if (data)
+ listItem.appendChild(
+ Search.makeSearchSummary(data, searchTerms)
+ );
+ });
+ Search.output.appendChild(listItem);
+};
+const _finishSearch = (resultCount) => {
+ Search.stopPulse();
+ Search.title.innerText = _("Search Results");
+ if (!resultCount)
+ Search.status.innerText = Documentation.gettext(
+ "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories."
+ );
+ else
+ Search.status.innerText = _(
+ `Search finished, found ${resultCount} page(s) matching the search query.`
+ );
+};
+const _displayNextItem = (
+ results,
+ resultCount,
+ searchTerms
+) => {
+ // results left, load the summary and display it
+ // this is intended to be dynamic (don't sub resultsCount)
+ if (results.length) {
+ _displayItem(results.pop(), searchTerms);
+ setTimeout(
+ () => _displayNextItem(results, resultCount, searchTerms),
+ 5
+ );
+ }
+ // search finished, update title and status message
+ else _finishSearch(resultCount);
+};
+
+/**
+ * Default splitQuery function. Can be overridden in ``sphinx.search`` with a
+ * custom function per language.
+ *
+ * The regular expression works by splitting the string on consecutive characters
+ * that are not Unicode letters, numbers, underscores, or emoji characters.
+ * This is the same as ``\W+`` in Python, preserving the surrogate pair area.
+ */
+if (typeof splitQuery === "undefined") {
+ var splitQuery = (query) => query
+ .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu)
+ .filter(term => term) // remove remaining empty strings
+}
+
+/**
+ * Search Module
+ */
+const Search = {
+ _index: null,
+ _queued_query: null,
+ _pulse_status: -1,
+
+ htmlToText: (htmlString) => {
+ const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html');
+ htmlElement.querySelectorAll(".headerlink").forEach((el) => { el.remove() });
+ const docContent = htmlElement.querySelector('[role="main"]');
+ if (docContent !== undefined) return docContent.textContent;
+ console.warn(
+ "Content block not found. Sphinx search tries to obtain it via '[role=main]'. Could you check your theme or template."
+ );
+ return "";
+ },
+
+ init: () => {
+ const query = new URLSearchParams(window.location.search).get("q");
+ document
+ .querySelectorAll('input[name="q"]')
+ .forEach((el) => (el.value = query));
+ if (query) Search.performSearch(query);
+ },
+
+ loadIndex: (url) =>
+ (document.body.appendChild(document.createElement("script")).src = url),
+
+ setIndex: (index) => {
+ Search._index = index;
+ if (Search._queued_query !== null) {
+ const query = Search._queued_query;
+ Search._queued_query = null;
+ Search.query(query);
+ }
+ },
+
+ hasIndex: () => Search._index !== null,
+
+ deferQuery: (query) => (Search._queued_query = query),
+
+ stopPulse: () => (Search._pulse_status = -1),
+
+ startPulse: () => {
+ if (Search._pulse_status >= 0) return;
+
+ const pulse = () => {
+ Search._pulse_status = (Search._pulse_status + 1) % 4;
+ Search.dots.innerText = ".".repeat(Search._pulse_status);
+ if (Search._pulse_status >= 0) window.setTimeout(pulse, 500);
+ };
+ pulse();
+ },
+
+ /**
+ * perform a search for something (or wait until index is loaded)
+ */
+ performSearch: (query) => {
+ // create the required interface elements
+ const searchText = document.createElement("h2");
+ searchText.textContent = _("Searching");
+ const searchSummary = document.createElement("p");
+ searchSummary.classList.add("search-summary");
+ searchSummary.innerText = "";
+ const searchList = document.createElement("ul");
+ searchList.classList.add("search");
+
+ const out = document.getElementById("search-results");
+ Search.title = out.appendChild(searchText);
+ Search.dots = Search.title.appendChild(document.createElement("span"));
+ Search.status = out.appendChild(searchSummary);
+ Search.output = out.appendChild(searchList);
+
+ const searchProgress = document.getElementById("search-progress");
+ // Some themes don't use the search progress node
+ if (searchProgress) {
+ searchProgress.innerText = _("Preparing search...");
+ }
+ Search.startPulse();
+
+ // index already loaded, the browser was quick!
+ if (Search.hasIndex()) Search.query(query);
+ else Search.deferQuery(query);
+ },
+
+ /**
+ * execute search (requires search index to be loaded)
+ */
+ query: (query) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+ const allTitles = Search._index.alltitles;
+ const indexEntries = Search._index.indexentries;
+
+ // stem the search terms and add them to the correct list
+ const stemmer = new Stemmer();
+ const searchTerms = new Set();
+ const excludedTerms = new Set();
+ const highlightTerms = new Set();
+ const objectTerms = new Set(splitQuery(query.toLowerCase().trim()));
+ splitQuery(query.trim()).forEach((queryTerm) => {
+ const queryTermLower = queryTerm.toLowerCase();
+
+ // maybe skip this "word"
+ // stopwords array is from language_data.js
+ if (
+ stopwords.indexOf(queryTermLower) !== -1 ||
+ queryTerm.match(/^\d+$/)
+ )
+ return;
+
+ // stem the word
+ let word = stemmer.stemWord(queryTermLower);
+ // select the correct list
+ if (word[0] === "-") excludedTerms.add(word.substr(1));
+ else {
+ searchTerms.add(word);
+ highlightTerms.add(queryTermLower);
+ }
+ });
+
+ if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js
+ localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" "))
+ }
+
+ // console.debug("SEARCH: searching for:");
+ // console.info("required: ", [...searchTerms]);
+ // console.info("excluded: ", [...excludedTerms]);
+
+ // array of [docname, title, anchor, descr, score, filename]
+ let results = [];
+ _removeChildren(document.getElementById("search-progress"));
+
+ const queryLower = query.toLowerCase();
+ for (const [title, foundTitles] of Object.entries(allTitles)) {
+ if (title.toLowerCase().includes(queryLower) && (queryLower.length >= title.length/2)) {
+ for (const [file, id] of foundTitles) {
+ let score = Math.round(100 * queryLower.length / title.length)
+ results.push([
+ docNames[file],
+ titles[file] !== title ? `${titles[file]} > ${title}` : title,
+ id !== null ? "#" + id : "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ }
+ }
+
+ // search for explicit entries in index directives
+ for (const [entry, foundEntries] of Object.entries(indexEntries)) {
+ if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) {
+ for (const [file, id] of foundEntries) {
+ let score = Math.round(100 * queryLower.length / entry.length)
+ results.push([
+ docNames[file],
+ titles[file],
+ id ? "#" + id : "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ }
+ }
+
+ // lookup as object
+ objectTerms.forEach((term) =>
+ results.push(...Search.performObjectSearch(term, objectTerms))
+ );
+
+ // lookup as search terms in fulltext
+ results.push(...Search.performTermsSearch(searchTerms, excludedTerms));
+
+ // let the scorer override scores with a custom scoring function
+ if (Scorer.score) results.forEach((item) => (item[4] = Scorer.score(item)));
+
+ // now sort the results by score (in opposite order of appearance, since the
+ // display function below uses pop() to retrieve items) and then
+ // alphabetically
+ results.sort((a, b) => {
+ const leftScore = a[4];
+ const rightScore = b[4];
+ if (leftScore === rightScore) {
+ // same score: sort alphabetically
+ const leftTitle = a[1].toLowerCase();
+ const rightTitle = b[1].toLowerCase();
+ if (leftTitle === rightTitle) return 0;
+ return leftTitle > rightTitle ? -1 : 1; // inverted is intentional
+ }
+ return leftScore > rightScore ? 1 : -1;
+ });
+
+ // remove duplicate search results
+ // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept
+ let seen = new Set();
+ results = results.reverse().reduce((acc, result) => {
+ let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(',');
+ if (!seen.has(resultStr)) {
+ acc.push(result);
+ seen.add(resultStr);
+ }
+ return acc;
+ }, []);
+
+ results = results.reverse();
+
+ // for debugging
+ //Search.lastresults = results.slice(); // a copy
+ // console.info("search results:", Search.lastresults);
+
+ // print the results
+ _displayNextItem(results, results.length, searchTerms);
+ },
+
+ /**
+ * search for object names
+ */
+ performObjectSearch: (object, objectTerms) => {
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const objects = Search._index.objects;
+ const objNames = Search._index.objnames;
+ const titles = Search._index.titles;
+
+ const results = [];
+
+ const objectSearchCallback = (prefix, match) => {
+ const name = match[4]
+ const fullname = (prefix ? prefix + "." : "") + name;
+ const fullnameLower = fullname.toLowerCase();
+ if (fullnameLower.indexOf(object) < 0) return;
+
+ let score = 0;
+ const parts = fullnameLower.split(".");
+
+ // check for different match types: exact matches of full name or
+ // "last name" (i.e. last dotted part)
+ if (fullnameLower === object || parts.slice(-1)[0] === object)
+ score += Scorer.objNameMatch;
+ else if (parts.slice(-1)[0].indexOf(object) > -1)
+ score += Scorer.objPartialMatch; // matches in last name
+
+ const objName = objNames[match[1]][2];
+ const title = titles[match[0]];
+
+ // If more than one term searched for, we require other words to be
+ // found in the name/title/description
+ const otherTerms = new Set(objectTerms);
+ otherTerms.delete(object);
+ if (otherTerms.size > 0) {
+ const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase();
+ if (
+ [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0)
+ )
+ return;
+ }
+
+ let anchor = match[3];
+ if (anchor === "") anchor = fullname;
+ else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname;
+
+ const descr = objName + _(", in ") + title;
+
+ // add custom score for some objects according to scorer
+ if (Scorer.objPrio.hasOwnProperty(match[2]))
+ score += Scorer.objPrio[match[2]];
+ else score += Scorer.objPrioDefault;
+
+ results.push([
+ docNames[match[0]],
+ fullname,
+ "#" + anchor,
+ descr,
+ score,
+ filenames[match[0]],
+ ]);
+ };
+ Object.keys(objects).forEach((prefix) =>
+ objects[prefix].forEach((array) =>
+ objectSearchCallback(prefix, array)
+ )
+ );
+ return results;
+ },
+
+ /**
+ * search for full-text terms in the index
+ */
+ performTermsSearch: (searchTerms, excludedTerms) => {
+ // prepare search
+ const terms = Search._index.terms;
+ const titleTerms = Search._index.titleterms;
+ const filenames = Search._index.filenames;
+ const docNames = Search._index.docnames;
+ const titles = Search._index.titles;
+
+ const scoreMap = new Map();
+ const fileMap = new Map();
+
+ // perform the search on the required terms
+ searchTerms.forEach((word) => {
+ const files = [];
+ const arr = [
+ { files: terms[word], score: Scorer.term },
+ { files: titleTerms[word], score: Scorer.title },
+ ];
+ // add support for partial matches
+ if (word.length > 2) {
+ const escapedWord = _escapeRegExp(word);
+ Object.keys(terms).forEach((term) => {
+ if (term.match(escapedWord) && !terms[word])
+ arr.push({ files: terms[term], score: Scorer.partialTerm });
+ });
+ Object.keys(titleTerms).forEach((term) => {
+ if (term.match(escapedWord) && !titleTerms[word])
+ arr.push({ files: titleTerms[word], score: Scorer.partialTitle });
+ });
+ }
+
+ // no match but word was a required one
+ if (arr.every((record) => record.files === undefined)) return;
+
+ // found search word in contents
+ arr.forEach((record) => {
+ if (record.files === undefined) return;
+
+ let recordFiles = record.files;
+ if (recordFiles.length === undefined) recordFiles = [recordFiles];
+ files.push(...recordFiles);
+
+ // set score for the word in each file
+ recordFiles.forEach((file) => {
+ if (!scoreMap.has(file)) scoreMap.set(file, {});
+ scoreMap.get(file)[word] = record.score;
+ });
+ });
+
+ // create the mapping
+ files.forEach((file) => {
+ if (fileMap.has(file) && fileMap.get(file).indexOf(word) === -1)
+ fileMap.get(file).push(word);
+ else fileMap.set(file, [word]);
+ });
+ });
+
+ // now check if the files don't contain excluded terms
+ const results = [];
+ for (const [file, wordList] of fileMap) {
+ // check if all requirements are matched
+
+ // as search terms with length < 3 are discarded
+ const filteredTermCount = [...searchTerms].filter(
+ (term) => term.length > 2
+ ).length;
+ if (
+ wordList.length !== searchTerms.size &&
+ wordList.length !== filteredTermCount
+ )
+ continue;
+
+ // ensure that none of the excluded terms is in the search result
+ if (
+ [...excludedTerms].some(
+ (term) =>
+ terms[term] === file ||
+ titleTerms[term] === file ||
+ (terms[term] || []).includes(file) ||
+ (titleTerms[term] || []).includes(file)
+ )
+ )
+ break;
+
+ // select one (max) score for the file.
+ const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w]));
+ // add result to the result list
+ results.push([
+ docNames[file],
+ titles[file],
+ "",
+ null,
+ score,
+ filenames[file],
+ ]);
+ }
+ return results;
+ },
+
+ /**
+ * helper function to return a node containing the
+ * search summary for a given text. keywords is a list
+ * of stemmed words.
+ */
+ makeSearchSummary: (htmlText, keywords) => {
+ const text = Search.htmlToText(htmlText);
+ if (text === "") return null;
+
+ const textLower = text.toLowerCase();
+ const actualStartPosition = [...keywords]
+ .map((k) => textLower.indexOf(k.toLowerCase()))
+ .filter((i) => i > -1)
+ .slice(-1)[0];
+ const startWithContext = Math.max(actualStartPosition - 120, 0);
+
+ const top = startWithContext === 0 ? "" : "...";
+ const tail = startWithContext + 240 < text.length ? "..." : "";
+
+ let summary = document.createElement("p");
+ summary.classList.add("context");
+ summary.textContent = top + text.substr(startWithContext, 240).trim() + tail;
+
+ return summary;
+ },
+};
+
+_ready(Search.init);
diff --git a/2024.3/_static/sphinx_highlight.js b/2024.3/_static/sphinx_highlight.js
new file mode 100644
index 0000000000..aae669d7ea
--- /dev/null
+++ b/2024.3/_static/sphinx_highlight.js
@@ -0,0 +1,144 @@
+/* Highlighting utilities for Sphinx HTML documentation. */
+"use strict";
+
+const SPHINX_HIGHLIGHT_ENABLED = true
+
+/**
+ * highlight a given string on a node by wrapping it in
+ * span elements with the given class name.
+ */
+const _highlight = (node, addItems, text, className) => {
+ if (node.nodeType === Node.TEXT_NODE) {
+ const val = node.nodeValue;
+ const parent = node.parentNode;
+ const pos = val.toLowerCase().indexOf(text);
+ if (
+ pos >= 0 &&
+ !parent.classList.contains(className) &&
+ !parent.classList.contains("nohighlight")
+ ) {
+ let span;
+
+ const closestNode = parent.closest("body, svg, foreignObject");
+ const isInSVG = closestNode && closestNode.matches("svg");
+ if (isInSVG) {
+ span = document.createElementNS("http://www.w3.org/2000/svg", "tspan");
+ } else {
+ span = document.createElement("span");
+ span.classList.add(className);
+ }
+
+ span.appendChild(document.createTextNode(val.substr(pos, text.length)));
+ parent.insertBefore(
+ span,
+ parent.insertBefore(
+ document.createTextNode(val.substr(pos + text.length)),
+ node.nextSibling
+ )
+ );
+ node.nodeValue = val.substr(0, pos);
+
+ if (isInSVG) {
+ const rect = document.createElementNS(
+ "http://www.w3.org/2000/svg",
+ "rect"
+ );
+ const bbox = parent.getBBox();
+ rect.x.baseVal.value = bbox.x;
+ rect.y.baseVal.value = bbox.y;
+ rect.width.baseVal.value = bbox.width;
+ rect.height.baseVal.value = bbox.height;
+ rect.setAttribute("class", className);
+ addItems.push({ parent: parent, target: rect });
+ }
+ }
+ } else if (node.matches && !node.matches("button, select, textarea")) {
+ node.childNodes.forEach((el) => _highlight(el, addItems, text, className));
+ }
+};
+const _highlightText = (thisNode, text, className) => {
+ let addItems = [];
+ _highlight(thisNode, addItems, text, className);
+ addItems.forEach((obj) =>
+ obj.parent.insertAdjacentElement("beforebegin", obj.target)
+ );
+};
+
+/**
+ * Small JavaScript module for the documentation.
+ */
+const SphinxHighlight = {
+
+ /**
+ * highlight the search words provided in localstorage in the text
+ */
+ highlightSearchWords: () => {
+ if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight
+
+ // get and clear terms from localstorage
+ const url = new URL(window.location);
+ const highlight =
+ localStorage.getItem("sphinx_highlight_terms")
+ || url.searchParams.get("highlight")
+ || "";
+ localStorage.removeItem("sphinx_highlight_terms")
+ url.searchParams.delete("highlight");
+ window.history.replaceState({}, "", url);
+
+ // get individual terms from highlight string
+ const terms = highlight.toLowerCase().split(/\s+/).filter(x => x);
+ if (terms.length === 0) return; // nothing to do
+
+ // There should never be more than one element matching "div.body"
+ const divBody = document.querySelectorAll("div.body");
+ const body = divBody.length ? divBody[0] : document.querySelector("body");
+ window.setTimeout(() => {
+ terms.forEach((term) => _highlightText(body, term, "highlighted"));
+ }, 10);
+
+ const searchBox = document.getElementById("searchbox");
+ if (searchBox === null) return;
+ searchBox.appendChild(
+ document
+ .createRange()
+ .createContextualFragment(
+ '' +
+ '' +
+ _("Hide Search Matches") +
+ "
"
+ )
+ );
+ },
+
+ /**
+ * helper function to hide the search marks again
+ */
+ hideSearchWords: () => {
+ document
+ .querySelectorAll("#searchbox .highlight-link")
+ .forEach((el) => el.remove());
+ document
+ .querySelectorAll("span.highlighted")
+ .forEach((el) => el.classList.remove("highlighted"));
+ localStorage.removeItem("sphinx_highlight_terms")
+ },
+
+ initEscapeListener: () => {
+ // only install a listener if it is really needed
+ if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return;
+
+ document.addEventListener("keydown", (event) => {
+ // bail for input elements
+ if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return;
+ // bail with special keys
+ if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return;
+ if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) {
+ SphinxHighlight.hideSearchWords();
+ event.preventDefault();
+ }
+ });
+ },
+};
+
+_ready(SphinxHighlight.highlightSearchWords);
+_ready(SphinxHighlight.initEscapeListener);
diff --git a/2024.3/_static/tabs.css b/2024.3/_static/tabs.css
new file mode 100644
index 0000000000..957ba60d69
--- /dev/null
+++ b/2024.3/_static/tabs.css
@@ -0,0 +1,89 @@
+.sphinx-tabs {
+ margin-bottom: 1rem;
+}
+
+[role="tablist"] {
+ border-bottom: 1px solid #a0b3bf;
+}
+
+.sphinx-tabs-tab {
+ position: relative;
+ font-family: Lato,'Helvetica Neue',Arial,Helvetica,sans-serif;
+ color: #1D5C87;
+ line-height: 24px;
+ margin: 0;
+ font-size: 16px;
+ font-weight: 400;
+ background-color: rgba(255, 255, 255, 0);
+ border-radius: 5px 5px 0 0;
+ border: 0;
+ padding: 1rem 1.5rem;
+ margin-bottom: 0;
+}
+
+.sphinx-tabs-tab[aria-selected="true"] {
+ font-weight: 700;
+ border: 1px solid #a0b3bf;
+ border-bottom: 1px solid white;
+ margin: -1px;
+ background-color: white;
+}
+
+.sphinx-tabs-tab:focus {
+ z-index: 1;
+ outline-offset: 1px;
+}
+
+.sphinx-tabs-panel {
+ position: relative;
+ padding: 1rem;
+ border: 1px solid #a0b3bf;
+ margin: 0px -1px -1px -1px;
+ border-radius: 0 0 5px 5px;
+ border-top: 0;
+ background: white;
+}
+
+.sphinx-tabs-panel.code-tab {
+ padding: 0.4rem;
+}
+
+.sphinx-tab img {
+ margin-bottom: 24 px;
+}
+
+/* Dark theme preference styling */
+
+@media (prefers-color-scheme: dark) {
+ body[data-theme="auto"] .sphinx-tabs-panel {
+ color: white;
+ background-color: rgb(50, 50, 50);
+ }
+
+ body[data-theme="auto"] .sphinx-tabs-tab {
+ color: white;
+ background-color: rgba(255, 255, 255, 0.05);
+ }
+
+ body[data-theme="auto"] .sphinx-tabs-tab[aria-selected="true"] {
+ border-bottom: 1px solid rgb(50, 50, 50);
+ background-color: rgb(50, 50, 50);
+ }
+}
+
+/* Explicit dark theme styling */
+
+body[data-theme="dark"] .sphinx-tabs-panel {
+ color: white;
+ background-color: rgb(50, 50, 50);
+}
+
+body[data-theme="dark"] .sphinx-tabs-tab {
+ color: white;
+ background-color: rgba(255, 255, 255, 0.05);
+}
+
+body[data-theme="dark"] .sphinx-tabs-tab[aria-selected="true"] {
+ border-bottom: 2px solid rgb(50, 50, 50);
+ background-color: rgb(50, 50, 50);
+}
diff --git a/2024.3/_static/tabs.js b/2024.3/_static/tabs.js
new file mode 100644
index 0000000000..48dc303c8c
--- /dev/null
+++ b/2024.3/_static/tabs.js
@@ -0,0 +1,145 @@
+try {
+ var session = window.sessionStorage || {};
+} catch (e) {
+ var session = {};
+}
+
+window.addEventListener("DOMContentLoaded", () => {
+ const allTabs = document.querySelectorAll('.sphinx-tabs-tab');
+ const tabLists = document.querySelectorAll('[role="tablist"]');
+
+ allTabs.forEach(tab => {
+ tab.addEventListener("click", changeTabs);
+ });
+
+ tabLists.forEach(tabList => {
+ tabList.addEventListener("keydown", keyTabs);
+ });
+
+ // Restore group tab selection from session
+ const lastSelected = session.getItem('sphinx-tabs-last-selected');
+ if (lastSelected != null) selectNamedTabs(lastSelected);
+});
+
+/**
+ * Key focus left and right between sibling elements using arrows
+ * @param {Node} e the element in focus when key was pressed
+ */
+function keyTabs(e) {
+ const tab = e.target;
+ let nextTab = null;
+ if (e.keyCode === 39 || e.keyCode === 37) {
+ tab.setAttribute("tabindex", -1);
+ // Move right
+ if (e.keyCode === 39) {
+ nextTab = tab.nextElementSibling;
+ if (nextTab === null) {
+ nextTab = tab.parentNode.firstElementChild;
+ }
+ // Move left
+ } else if (e.keyCode === 37) {
+ nextTab = tab.previousElementSibling;
+ if (nextTab === null) {
+ nextTab = tab.parentNode.lastElementChild;
+ }
+ }
+ }
+
+ if (nextTab !== null) {
+ nextTab.setAttribute("tabindex", 0);
+ nextTab.focus();
+ }
+}
+
+/**
+ * Select or deselect clicked tab. If a group tab
+ * is selected, also select tab in other tabLists.
+ * @param {Node} e the element that was clicked
+ */
+function changeTabs(e) {
+ // Use this instead of the element that was clicked, in case it's a child
+ const notSelected = this.getAttribute("aria-selected") === "false";
+ const positionBefore = this.parentNode.getBoundingClientRect().top;
+ const notClosable = !this.parentNode.classList.contains("closeable");
+
+ deselectTabList(this);
+
+ if (notSelected || notClosable) {
+ selectTab(this);
+ const name = this.getAttribute("name");
+ selectNamedTabs(name, this.id);
+
+ if (this.classList.contains("group-tab")) {
+ // Persist during session
+ session.setItem('sphinx-tabs-last-selected', name);
+ }
+ }
+
+ const positionAfter = this.parentNode.getBoundingClientRect().top;
+ const positionDelta = positionAfter - positionBefore;
+ // Scroll to offset content resizing
+ window.scrollTo(0, window.scrollY + positionDelta);
+}
+
+/**
+ * Select tab and show associated panel.
+ * @param {Node} tab tab to select
+ */
+function selectTab(tab) {
+ tab.setAttribute("aria-selected", true);
+
+ // Show the associated panel
+ document
+ .getElementById(tab.getAttribute("aria-controls"))
+ .removeAttribute("hidden");
+}
+
+/**
+ * Hide the panels associated with all tabs within the
+ * tablist containing this tab.
+ * @param {Node} tab a tab within the tablist to deselect
+ */
+function deselectTabList(tab) {
+ const parent = tab.parentNode;
+ const grandparent = parent.parentNode;
+
+ Array.from(parent.children)
+ .forEach(t => t.setAttribute("aria-selected", false));
+
+ Array.from(grandparent.children)
+ .slice(1) // Skip tablist
+ .forEach(panel => panel.setAttribute("hidden", true));
+}
+
+/**
+ * Select grouped tabs with the same name, but no the tab
+ * with the given id.
+ * @param {Node} name name of grouped tab to be selected
+ * @param {Node} clickedId id of clicked tab
+ */
+function selectNamedTabs(name, clickedId=null) {
+ const groupedTabs = document.querySelectorAll(`.sphinx-tabs-tab[name="${name}"]`);
+ const tabLists = Array.from(groupedTabs).map(tab => tab.parentNode);
+
+ tabLists
+ .forEach(tabList => {
+ // Don't want to change the tabList containing the clicked tab
+ const clickedTab = tabList.querySelector(`[id="${clickedId}"]`);
+ if (clickedTab === null ) {
+ // Select first tab with matching name
+ const tab = tabList.querySelector(`.sphinx-tabs-tab[name="${name}"]`);
+ deselectTabList(tab);
+ selectTab(tab);
+ }
+ })
+}
+
+if (typeof exports === 'undefined') {
+ exports = {};
+}
+
+exports.keyTabs = keyTabs;
+exports.changeTabs = changeTabs;
+exports.selectTab = selectTab;
+exports.deselectTabList = deselectTabList;
+exports.selectNamedTabs = selectNamedTabs;
diff --git a/2024.3/_static/version_switcher.js b/2024.3/_static/version_switcher.js
new file mode 100644
index 0000000000..a2543fdb9c
--- /dev/null
+++ b/2024.3/_static/version_switcher.js
@@ -0,0 +1,36 @@
+fetch("https://aepanchi.github.io/scikit-learn-intelex/versions.json").then(response => response.text()).then(respText=>
+ load_versions(respText));
+
+
+function load_versions(json){
+ var button = document.getElementById('version-switcher-button')
+ var container = document.getElementById('version-switcher-dropdown')
+ var loc = window.location.href;
+ var s = document.createElement('select');
+ s.style = "border-radius:5px;"
+ const versions = JSON.parse(json);
+ for (entry of versions){
+ var o = document.createElement('option');
+ var optionText = '';
+ if ('name' in entry){
+ optionText = entry.name;
+ }else{
+ optionText = entry.version;
+ }
+ o.value = entry.url;
+ if (current_version == entry.version){
+ o.selected = true;
+ optionText = optionText;
+ }
+ o.innerHTML = optionText;
+ s.append(o);
+ }
+ s.addEventListener("change", (event)=> {
+ var current_url = new URL(window.location.href);
+ var path = current_url.pathname;
+ //strip version from path
+ var page_path = path.substring(project_name.length+current_version.length+3);
+ window.location.href = s.value + page_path;
+ });
+ container.append(s);
+}
\ No newline at end of file
diff --git a/2024.3/algorithms.html b/2024.3/algorithms.html
new file mode 100644
index 0000000000..703d7b701e
--- /dev/null
+++ b/2024.3/algorithms.html
@@ -0,0 +1,893 @@
+
+
+
+
+
+
+ Supported Algorithms — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Supported Algorithms
+Applying Intel® Extension for Scikit-learn* impacts the following scikit-learn algorithms:
+
+on CPU
+
+Classification
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+SVC
+All parameters are supported
+No limitations
+
+NuSVC
+All parameters are supported
+No limitations
+
+RandomForestClassifier
+All parameters are supported except:
+
+warm_start
= True
+cpp_alpha
!= 0
+criterion
!= ‘gini’
+
+
+Multi-output and sparse data are not supported
+
+KNeighborsClassifier
+
+For algorithm
== ‘kd_tree’ :
+all parameters except metric
!= ‘euclidean’ or ‘minkowski’ with p
!= 2
+
+For algorithm
== ‘brute’ :
+all parameters except metric
not in [‘euclidean’ , ‘manhattan’ , ‘minkowski’ , ‘chebyshev’ , ‘cosine’ ]
+
+
+
+Multi-output and sparse data are not supported
+
+LogisticRegression
+All parameters are supported except:
+
+
+Only dense data is supported
+
+
+
+
+
+Regression
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+SVR
+All parameters are supported
+No limitations
+
+NuSVR
+All parameters are supported
+No limitations
+
+RandomForestRegressor
+All parameters are supported except:
+
+warm_start
= True
+cpp_alpha
!= 0
+criterion
!= ‘mse’
+
+
+Multi-output and sparse data are not supported
+
+KNeighborsRegressor
+All parameters are supported except:
+
+
+Multi-output and sparse data are not supported
+
+LinearRegression
+All parameters are supported except:
+
+normalize
!= False
+sample_weight
!= None
+
+
+Only dense data is supported, #observations should be >= #features .
+
+Ridge
+All parameters are supported except:
+
+normalize
!= False
+solver
!= ‘auto’
+sample_weight
!= None
+
+
+Only dense data is supported, #observations should be >= #features .
+
+ElasticNet
+All parameters are supported except:
+
+
+Multi-output and sparse data are not supported, #observations should be >= #features .
+
+Lasso
+All parameters are supported except:
+
+
+Multi-output and sparse data are not supported, #observations should be >= #features .
+
+
+
+
+
+Clustering
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+KMeans
+All parameters are supported except:
+
+precompute_distances
+sample_weight
!= None
+
+
+No limitations
+
+DBSCAN
+All parameters are supported except:
+
+
+Only dense data is supported
+
+
+
+
+
+Dimensionality reduction
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+PCA
+All parameters are supported except:
+
+
+Sparse data is not supported
+
+TSNE
+All parameters are supported except:
+
+Refer to TSNE acceleration details to learn more.
+
+Sparse data is not supported
+
+
+
+
+
+Nearest Neighbors
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+NearestNeighbors
+
+For algorithm
== ‘kd_tree’:
+all parameters except metric
!= ‘euclidean’ or ‘minkowski’ with p
!= 2
+
+For algorithm
== ‘brute’:
+all parameters except metric
not in [‘euclidean’ , ‘manhattan’ , ‘minkowski’ , ‘chebyshev’ , ‘cosine’ ]
+
+
+
+Sparse data is not supported
+
+
+
+
+
+Other tasks
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+train_test_split
+All parameters are supported
+Only dense data is supported
+
+assert_all_finite
+All parameters are supported
+Only dense data is supported
+
+pairwise_distance
+All parameters are supported except:
+
+
+Only dense data is supported
+
+roc_auc_score
+All parameters are supported except:
+
+average
!= None
+sample_weight
!= None
+max_fpr
!= None
+multi_class
!= None
+
+
+No limitations
+
+
+
+
+
+
+on GPU
+
+
+Classification
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+SVC
+All parameters are supported except:
+
+kernel
= ‘sigmoid_poly’
+class_weight
!= None
+
+
+Only binary dense data is supported
+
+RandomForestClassifier
+All parameters are supported except:
+
+warm_start
= True
+cpp_alpha
!= 0
+criterion
!= ‘gini’
+oob_score
= True
+sample_weight
!= None
+
+
+Multi-output and sparse data are not supported
+
+KNeighborsClassifier
+All parameters are supported except:
+
+algorithm
!= ‘brute’
+weights
= ‘callable’
+metric
not in [‘euclidean’ , ‘manhattan’ , ‘minkowski’ , ‘chebyshev’ , ‘cosine’ ]
+
+
+Only dense data is supported
+
+LogisticRegression
+All parameters are supported except:
+
+solver
!= ‘newton-cg’
+class_weight
!= None
+sample_weight
!= None
+penalty
!= ‘l2’
+
+
+Only dense data is supported
+
+
+
+
+
+Regression
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+RandomForestRegressor
+All parameters are supported except:
+
+warm_start
= True
+cpp_alpha
!= 0
+criterion
!= ‘mse’
+oob_score
= True
+sample_weight
!= None
+
+
+Multi-output and sparse data are not supported
+
+KNeighborsRegressor
+All parameters are supported except:
+
+
+Only dense data is supported
+
+LinearRegression
+All parameters are supported except:
+
+normalize
!= False
+sample_weight
!= None
+
+
+Only dense data is supported, #observations should be >= #features .
+
+
+
+
+
+Clustering
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+KMeans
+All parameters are supported except:
+
+precompute_distances
+sample_weight
!= None
+
+Init
= ‘k-means++’ fallbacks to CPU.
+
+Sparse data is not supported
+
+DBSCAN
+All parameters are supported except:
+
+
+Only dense data is supported
+
+
+
+
+
+Dimensionality reduction
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+PCA
+All parameters are supported except:
+
+
+Sparse data is not supported
+
+
+
+
+
+Nearest Neighbors
+
+
+
+
+
+
+
+Algorithm
+Parameters
+Data formats
+
+
+
+NearestNeighbors
+All parameters are supported except:
+
+algorithm
!= ‘brute’
+weights
= ‘callable’
+metric
not in [‘euclidean’ , ‘manhattan’ , ‘minkowski’ , ‘chebyshev’ , ‘cosine’ ]
+
+
+Only dense data is supported
+
+
+
+
+
+
+Scikit-learn tests
+Monkey-patched scikit-learn classes and functions passes scikit-learn’s own test
+suite, with few exceptions, specified in deselected_tests.yaml .
+The results of the entire latest scikit-learn test suite with Intel® Extension for Scikit-learn*: CircleCI .
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/blogs.html b/2024.3/blogs.html
new file mode 100644
index 0000000000..1396627a91
--- /dev/null
+++ b/2024.3/blogs.html
@@ -0,0 +1,409 @@
+
+
+
+
+
+
+ Follow us on Medium — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Follow us on Medium
+We publish blogs on Medium, so follow us
+to learn tips and tricks for more efficient data analysis the help of Intel® Extension for Scikit-learn*.
+Here are our latest blogs:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/contribute.html b/2024.3/contribute.html
new file mode 100644
index 0000000000..0ea78c5e47
--- /dev/null
+++ b/2024.3/contribute.html
@@ -0,0 +1,428 @@
+
+
+
+
+
+
+ How to Contribute — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+How to Contribute
+As an open source project, we welcome community contributions to Intel(R) Extension for Scikit-learn.
+This document explains how to participate in project conversations, log bugs and enhancement requests, and submit code patches.
+
+Licensing
+Intel(R) Extension for Scikit-learn uses the Apache 2.0 License . By contributing to the project, you agree to the license and copyright terms and release your own contributions under these terms.
+
+
+Pull Requests
+No anonymous contributions are accepted. The name in the commit message Signed-off-by line and your email must match the change authorship information.
+Make sure your .gitconfig is set up correctly so you can use git commit -s for signing your patches:
+git config -- global user . name "Kate Developer"
+git config -- global user . email kate . developer @company . com
+
+
+
+Before Contributing Changes
+Make sure you can build the product and run all the tests with your patch.
+For a larger feature, provide a relevant test.
+Document your code. Our project uses reStructuredText for documentation.
+For new file(s), specify the appropriate copyright year in the first line.
+Submit a pull request into the master branch.
+Continuous Integration (CI) testing is enabled for the repository. Your pull request must pass all checks before it can be merged. We will review your contribution and may provide feedback to guide you if any additional fixes or modifications are necessary. When reviewed and accepted, your pull request will be merged into our GitHub repository.
+
+
+
+Code Style
+We use black and isort formatters for Python* code.
+The line length is 90 characters; use default options otherwise. You can find the linter configuration in .pyproject.toml .
+A GitHub* Action verifies if your changes comply with the output of the auto-formatting tools.
+Optionally, you can install pre-commit hooks that do the formatting for you. For this, run from the top level of the repository:
+pip install pre - commit
+pre - commit install
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/deprecation.html b/2024.3/deprecation.html
new file mode 100644
index 0000000000..b185591054
--- /dev/null
+++ b/2024.3/deprecation.html
@@ -0,0 +1,400 @@
+
+
+
+
+
+
+ Deprecation Notice — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Deprecation Notice
+This page provides information about the deprecations of a specific Intel® Extension for Scikit-learn* functionality.
+
+macOS* Support
+Deprecation: macOS* support is deprecated for Intel® Extension for Scikit-learn*. The 2023.x releases are the last to provide it.
+Reasons for deprecation: No modern X86 macOS*-based systems are to be released.
+Alternatives: The 2023.x version on macOS*.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/distributed-mode.html b/2024.3/distributed-mode.html
new file mode 100644
index 0000000000..a65a7d4ebc
--- /dev/null
+++ b/2024.3/distributed-mode.html
@@ -0,0 +1,402 @@
+
+
+
+
+
+
+ Distributed Mode — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Distributed Mode
+
+
Note
+
Intel® Extension for Scikit-learn* contains scikit-learn patching functionality that was originally available in
+daal4py package.
+We recommend you to use scikit-learn-intelex package instead of daal4py.
+You can learn more about daal4py in daal4py documentation .
+
+While daal4py is available in distribued mode ,
+Intel® Extension for Scikit-learn* does not currently offer this functionality.
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/genindex.html b/2024.3/genindex.html
new file mode 100644
index 0000000000..0b228803d4
--- /dev/null
+++ b/2024.3/genindex.html
@@ -0,0 +1,390 @@
+
+
+
+
+
+ Index — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/guide/acceleration.html b/2024.3/guide/acceleration.html
new file mode 100644
index 0000000000..d48935d00e
--- /dev/null
+++ b/2024.3/guide/acceleration.html
@@ -0,0 +1,465 @@
+
+
+
+
+
+
+ Tuning Guide — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Tuning Guide
+The performance of some algorithms changes based on the parameters that are used.
+This section denotes the details of such cases.
+Refer to Supported Algorithms to see the full list of algorithms, parameters, and data formats supported in Intel® Extension for Scikit-learn*.
+
+TSNE
+TSNE algorithm consists of two components: KNN and Gradient Descent.
+The overall acceleration of TSNE depends on the acceleration of each of these algorithms.
+
+To get better performance, use parameters supported by both components.
+
+
+Random Forest
+Random Forest models accelerated with Intel® Extension for Scikit-learn* and using the hist splitting
+method discretize training data by creating a histogram with a configurable
+number of bins. The following keyword arguments can be used to influence the
+created histogram.
+
+
+
+
+
+
+
+
+Keyword argument
+Possible values
+Default value
+Description
+
+
+
+maxBins
+[0, inf)
+256
+Number of bins in the histogram with the discretized training data. The
+value 0
disables data discretization.
+
+minBinSize
+[1, inf)
+5
+Minimum number of training data points in each bin after discretization.
+
+binningStrategy
+quantiles, averages
+quantiles
+Selects the algorithm used to calculate bin edges. quantiles
+results in bins with a similar amount of training data points. averages
+divides the range of values observed in the training data set into
+equal-width bins of size (max - min) / maxBins .
+
+
+
+Note that using discretized training data can greatly accelerate model training
+times, especially for larger data sets. However, due to the reduced fidelity of
+the data, the resulting model can present worse performance metrics compared to
+a model trained on the original data. In such cases, the number of bins can be
+increased with the maxBins
parameter, or binning can be disabled entirely by
+setting maxBins=0
.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/index.html b/2024.3/index.html
new file mode 100644
index 0000000000..022438a22a
--- /dev/null
+++ b/2024.3/index.html
@@ -0,0 +1,451 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn* — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn*
+Intel(R) Extension for Scikit-learn is a free software AI accelerator designed to deliver up to 100X faster performance for your existing scikit-learn code.
+The software acceleration is achieved with vector instructions, AI hardware-specific memory optimizations, threading, and optimizations for all upcoming Intel(R) platforms at launch time.
+Designed for Data Scientists and Framework Designers
+Use Intel(R) Extension for Scikit-learn, to:
+
+Speed up training and inference by up to 100x with the equivalent mathematical accuracy
+Benefit from performance improvements across different x86-compatible CPUs or Intel(R) GPUs
+Integrate the extension into your existing Scikit-learn applications without code modifications
+Enable and disable the extension with a couple of lines of code or at the command line
+
+Intel(R) Extension for Scikit-learn is also a part of Intel(R) AI Tools .
+
+These performance charts use benchmarks that you can find in the scikit-learn bench repository .
+
+
+Intel(R) Optimizations
+
+Enable Intel(R) CPU Optimizations
+import numpy as np
+from sklearnex import patch_sklearn
+patch_sklearn ()
+
+from sklearn.cluster import DBSCAN
+
+X = np . array ([[ 1. , 2. ], [ 2. , 2. ], [ 2. , 3. ],
+ [ 8. , 7. ], [ 8. , 8. ], [ 25. , 80. ]], dtype = np . float32 )
+clustering = DBSCAN ( eps = 3 , min_samples = 2 ) . fit ( X )
+
+
+
+
+Enable Intel(R) GPU optimizations
+import numpy as np
+import dpctl
+from sklearnex import patch_sklearn , config_context
+patch_sklearn ()
+
+from sklearn.cluster import DBSCAN
+
+X = np . array ([[ 1. , 2. ], [ 2. , 2. ], [ 2. , 3. ],
+ [ 8. , 7. ], [ 8. , 8. ], [ 25. , 80. ]], dtype = np . float32 )
+with config_context ( target_offload = "gpu:0" ):
+ clustering = DBSCAN ( eps = 3 , min_samples = 2 ) . fit ( X )
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/kaggle.html b/2024.3/kaggle.html
new file mode 100644
index 0000000000..d3846a4fb2
--- /dev/null
+++ b/2024.3/kaggle.html
@@ -0,0 +1,430 @@
+
+
+
+
+
+
+ Kaggle Kernels — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Kaggle Kernels
+See Kaggle notebooks created by Intel® Extension for Scikit-learn* developers.
+
+
+Machine Learning Workflows
+Browse this chapter to find Kaggle kernels that use scikit-learn-intelex for a specific type of a machine learning task.
+
+Kaggle kernels that use scikit-learn and Intel® Extension for Scikit-learn*:
+
+
+
+Kaggle kernels that use AutoML with Intel® Extension for Scikit-learn*:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/kaggle/automl.html b/2024.3/kaggle/automl.html
new file mode 100644
index 0000000000..dd5251cfbc
--- /dev/null
+++ b/2024.3/kaggle/automl.html
@@ -0,0 +1,434 @@
+
+
+
+
+
+
+ Kaggle Kernels that use AutoML and Intel® Extension for Scikit-learn* — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Kaggle Kernels that use AutoML and Intel® Extension for Scikit-learn*
+The following Kaggle kernels show how to patch autoML frameworks with Intel® Extension for Scikit-learn*.
+TPS stands for Tabular Playground Series, which is a series of beginner-friendly Kaggle competitions.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/kaggle/classification.html b/2024.3/kaggle/classification.html
new file mode 100644
index 0000000000..f58bfaf91f
--- /dev/null
+++ b/2024.3/kaggle/classification.html
@@ -0,0 +1,657 @@
+
+
+
+
+
+
+ Kaggle Kernels for Classification Tasks — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Kaggle Kernels for Classification Tasks
+The following Kaggle kernels show how to patch scikit-learn with Intel® Extension for Scikit-learn* for various classification tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with Intel® Extension for Scikit-learn*.
+TPS stands for Tabular Playground Series, which is a series of beginner-friendly Kaggle competitions.
+
+Binary Classification
+
+
+
+MultiClass Classification
+
+
+
+Classification Tasks in Computer Vision
+
+
+
+Classification Tasks in Natural Language Processing
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/kaggle/regression.html b/2024.3/kaggle/regression.html
new file mode 100644
index 0000000000..b4cc623231
--- /dev/null
+++ b/2024.3/kaggle/regression.html
@@ -0,0 +1,547 @@
+
+
+
+
+
+
+ Kaggle Kernels for Regression Tasks — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Kaggle Kernels for Regression Tasks
+The following Kaggle kernels show how to patch scikit-learn with Intel® Extension for Scikit-learn* for various regression tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with Intel® Extension for Scikit-learn*.
+TPS stands for Tabular Playground Series, which is a series of beginner-friendly Kaggle competitions.
+
+Using a Single Regressor
+
+
+
+
+
+
+
+Kernel
+Goal
+Content
+
+
+
+Baseline Nu Support Vector Regression (nuSVR) with RBF Kernel
+Data: [TPS Jul 2021] Synthetic pollution data
+
+Predict air pollution measurements over time based on weather and input values from multiple sensors
+
+
+
+Nu Support Vector Regression (nuSVR)
+Data: [TPS Aug 2021] Synthetic loan data
+
+Calculate loss associated with a loan defaults
+
+
+
+Nu Support Vector Regression (nuSVR)
+Data: House Prices dataset
+
+Predict sale prices for a property based on its characteristics
+
+data preprocessing
+exploring outliers
+feature engineering
+filling missing values
+search for optimal parameters using Optuna
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+Random Forest Regression
+Data: [TPS Jul 2021] Synthetic pollution data
+
+Predict air pollution measurements over time based on weather and input values from multiple sensors
+
+checking correlation between features
+search for best paramters using GridSearchCV
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+Random Forest Regression with Feature Engineering
+Data: [TPS Jul 2021] Synthetic pollution data
+
+Predict air pollution measurements over time based on weather and input values from multiple sensors
+
+data preprocessing
+feature engineering
+search for optimal parameters using Optuna
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+Random Forest Regression with Feature Importance Computation
+Data: [TPS Mar 2022] Spatio-temporal traffic data
+
+Forecast twelve-hours of traffic flow in a major U.S. metropolitan area
+
+feature engineering
+computing feature importance with ELI5
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+Ridge Regression
+Data: [TPS Sep 2021] Synthetic insurance data
+
+Predict the probability of a customer making a claim upon an insurance policy
+
+data preprocessing
+filling missing values
+search for optimal parameters using Optuna
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+
+
+
+
+Stacking Regressors
+
+
+
+
+
+
+
+Kernel
+Goal
+Content
+
+
+
+Stacking Regressor with Random Fores, SVR, and LASSO
+Data: [TPS Jul 2021] Synthetic pollution data
+
+Predict air pollution measurements over time based on weather and input values from multiple sensors
+
+feature engineering
+creating a stacking regressor
+search for optimal parameters using Optuna
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+Stacking Regressor with ElasticNet, LASSO, and Ridge Regression for Time-series data
+Data: Predict Future Sales dataset
+
+Predict total sales for every product and store in the next month based on daily sales data
+
+data preprocessing
+creating a stacking regressor
+search for optimal parameters using Optuna
+training and prediction using scikit-learn-intelex
+performance comparison to scikit-learn
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/license.html b/2024.3/license.html
new file mode 100644
index 0000000000..4463d2c76c
--- /dev/null
+++ b/2024.3/license.html
@@ -0,0 +1,392 @@
+
+
+
+
+
+
+ License — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/objects.inv b/2024.3/objects.inv
new file mode 100644
index 0000000000..260ff0f3a8
Binary files /dev/null and b/2024.3/objects.inv differ
diff --git a/2024.3/oneapi-gpu.html b/2024.3/oneapi-gpu.html
new file mode 100644
index 0000000000..8c85f68c51
--- /dev/null
+++ b/2024.3/oneapi-gpu.html
@@ -0,0 +1,487 @@
+
+
+
+
+
+
+ oneAPI and GPU support in Intel® Extension for Scikit-learn* — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+ oneAPI and GPU support in Intel® Extension for Scikit-learn*
+
+ View page source
+
+
+
+
+
+
+
+
+oneAPI and GPU support in Intel® Extension for Scikit-learn*
+Intel® Extension for Scikit-learn* supports oneAPI concepts, which
+means that algorithms can be executed on different devices: CPUs and GPUs.
+This is done via integration with
+dpctl package that
+implements core oneAPI concepts like queues and devices.
+
+Prerequisites
+For execution on GPU, DPC++ compiler runtime and driver are required. Refer to DPC++ system
+requirements for details.
+DPC++ compiler runtime can be installed either from PyPI or Anaconda:
+
+Install from PyPI:
+pip install dpcpp - cpp - rt
+
+
+
+Install from Anaconda:
+conda install dpcpp_cpp_rt - c intel
+
+
+
+
+
+
+Device offloading
+Intel® Extension for Scikit-learn* offers two options for running an algorithm on a
+specific device with the help of dpctl:
+
+Pass input data as dpctl.tensor.usm_ndarray to the algorithm.
+The computation will run on the device where the input data is
+located, and the result will be returned as usm_ndarray
to the same
+device.
+
+
Note
+
All the input data for an algorithm must reside on the same device.
+
+
+
Warning
+
The usm_ndarray
can only be consumed by the base methods
+like fit
, predict
, and transform
.
+Note that only the algorithms in Intel® Extension for Scikit-learn* support
+usm_ndarray
. The algorithms from the stock version of scikit-learn
+do not support this feature.
+
+
+Use global configurations of Intel® Extension for Scikit-learn**:
+
+The target_offload
option can be used to set the device primarily
+used to perform computations. Accepted data types are str
and
+dpctl.SyclQueue
. If you pass a string to target_offload
,
+it should either be "auto"
, which means that the execution
+context is deduced from the location of input data, or a string
+with SYCL* filter selector. The default value is "auto"
.
+The allow_fallback_to_host
option
+is a Boolean flag. If set to True
, the computation is allowed
+to fallback to the host device when a particular estimator does not support
+the selected device. The default value is False
.
+
+
+
+These options can be set using sklearnex.set_config()
function or
+sklearnex.config_context
. To obtain the current values of these options,
+call sklearnex.get_config()
.
+
+
Note
+
Functions set_config
, get_config
and config_context
+are always patched after the sklearnex.patch_sklearn()
call.
+
+Compatibility considerations
+For compatibility reasons, algorithms in Intel® Extension for Scikit-learn* may be offloaded to the device using
+daal4py.oneapi.sycl_context
. However, it is recommended to use one of the options
+described above for device offloading instead of using sycl_context
.
+
+
+Example
+An example on how to patch your code with Intel CPU/GPU optimizations:
+from sklearnex import patch_sklearn , config_context
+patch_sklearn ()
+
+from sklearn.cluster import DBSCAN
+
+X = np . array ([[ 1. , 2. ], [ 2. , 2. ], [ 2. , 3. ],
+ [ 8. , 7. ], [ 8. , 8. ], [ 25. , 80. ]], dtype = np . float32 )
+with config_context ( target_offload = "gpu:0" ):
+ clustering = DBSCAN ( eps = 3 , min_samples = 2 ) . fit ( X )
+
+
+
+
Note
+
Current offloading behavior restricts fitting and inference of any models to be
+in the same context or absence of context. For example, a model trained in the GPU context with
+target_offload=”gpu:0” throws an error if the inference is made outside the same GPU context.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/quick-start.html b/2024.3/quick-start.html
new file mode 100644
index 0000000000..2ef11712ad
--- /dev/null
+++ b/2024.3/quick-start.html
@@ -0,0 +1,790 @@
+
+
+
+
+
+
+ Quick Start — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Quick Start
+Get ready to elevate your scikit-learn code with Intel® Extension for Scikit-learn* and experience the benefits of accelerated performance in just a few simple steps.
+
+Compatibility with Scikit-learn*
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn.
+
+
+Integrate Intel® Extension for Scikit-learn*
+
+Patching
+Once you install Intel*(R) Extension for Scikit-learn*, you replace algorithms that exist in the scikit-learn package with their optimized versions from the extension.
+This action is called patching
. This is not a permanent change so you can always undo the patching if necessary.
+To patch Intel® Extension for Scikit-learn, use one of these methods:
+
+
+Method
+Action
+
+
+
+Use a flag in the command line
+Run this command:
+python - m sklearnex my_application . py
+
+
+
+
+Modify your script
+Add the following lines:
+from sklearnex import patch_sklearn
+patch_sklearn ()
+
+
+
+
+Import an estimator from the sklearnex
module
+Run this command:
+from sklearnex.neighbors import NearestNeighbors
+
+
+
+
+
+
+These patching methods are interchangeable.
+They support different enabling scenarios while producing the same result.
+Example
+This example shows how to patch Intel(R) extension for Scikit-Learn by modifing your script. To make sure that patching is registered by the scikit-learn estimators, always import scikit-learn after these lines.
+
+
Example: Drop-In Patching
+
import numpy as np
+ from sklearnex import patch_sklearn
+ patch_sklearn ()
+
+ # You need to re-import scikit-learn algorithms after the patch
+ from sklearn.cluster import KMeans
+
+ # The use of the original Scikit-learn is not changed
+ X = np . array ([[ 1 , 2 ], [ 1 , 4 ], [ 1 , 0 ],
+ [ 10 , 2 ], [ 10 , 4 ], [ 10 , 0 ]])
+ kmeans = KMeans ( n_clusters = 2 , random_state = 0 ) . fit ( X )
+ print ( f "kmeans.labels_ = { kmeans . labels_ } " )
+
+
+
+
+
+Global Patching
+You can also use global patching to patch all your scikit-learn applications without any additional actions.
+Before you begin, make sure that you have read and write permissions for Scikit-learn files.
+With global patching, you can:
+
+
+Task
+Action
+Note
+
+
+
+Patch all supported algorithms
+Run this command:
+python - m sklearnex . glob patch_sklearn
+
+
+
+If you run the global patching command several times with different parameters, then only the last configuration is applied.
+
+Patch selected algorithms
+Use --algorithm
or -a
keys with a list of algorithms to patch. For example, to patch only SVC
and RandomForestClassifier
estimators, run
+python - m sklearnex . glob patch_sklearn - a svc random_forest_classifier
+
+
+
+
+
+Enable global patching via code
+Use the patch_sklearn
function with the global_patch
argument:
+from sklearnex import patch_sklearn
+patch_sklearn ( global_patch = True )
+import sklearn
+
+
+
+After that, Scikit-learn patches is enabled in the current application and in all others that use the same environment.
+
+Disable patching notifications
+Use --no-verbose
or -nv
keys:
+python - m sklearnex . glob patch_sklearn - a svc random_forest_classifier - nv
+
+
+
+
+
+Disable global patching
+Run this command:
+python - m sklearnex . glob unpatch_sklearn
+
+
+
+
+
+Disable global patching via code
+Use the global_patch
argument in the unpatch_sklearn
function
+from sklearnex import unpatch_sklearn
+unpatch_sklearn ( global_patch = True )
+
+
+
+
+
+
+
+
+
Tip
+
If you clone an environment with enabled global patching, it will already be applied in the new environment.
+
+
+
+Unpatching
+To undo the patch (also called unpatching ) is to return scikit-learn to original implementation and
+replace patched algorithms with the stock scikit-learn algorithms.
+To unpatch successfully, you must reimport the scikit-learn package:
+sklearnex . unpatch_sklearn ()
+# Re-import scikit-learn algorithms after the unpatch
+from sklearn.cluster import KMeans
+
+
+
+
+
+Installation
+
+
+
+
+
Tip
+
To prevent version conflicts, we recommend creating and activating a new environment for Intel® Extension for Scikit-learn*.
+
+
+
+Recommended by default.
+To install Intel® Extension for Scikit-learn*, run:
+pip install scikit - learn - intelex
+
+
+Supported Configurations
+
+
+OS / Python version
+Python 3.8
+Python 3.9
+Python 3.10
+Python 3.11
+Python 3.12
+
+
+
+Linux* OS
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+
+Windows* OS
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+
+
+
+
+
+
+To prevent version conflicts, we recommend installing scikit-learn-intelex into a new conda environment.
+
+
Conda-Forge channel Intel channel Main channel
Recommended by default.
+
To install, run:
+
conda install scikit - learn - intelex - c conda - forge
+
+
+
+Supported Configurations
+
+OS / Python version
+Python 3.8
+Python 3.9
+Python 3.10
+Python 3.11
+Python 3.12
+
+
+
+Linux* OS
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+
+Windows* OS
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+
+
+
+
Recommended for the Intel® Distribution for Python users.
+
To install, run:
+
conda install scikit - learn - intelex - c intel
+
+
+
+Supported Configurations
+
+OS / Python version
+Python 3.8
+Python 3.9
+Python 3.10
+Python 3.11
+Python 3.12
+
+
+
+Linux* OS
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+
+Windows* OS
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+[CPU, GPU]
+
+
+
+
To install, run:
+
conda install scikit - learn - intelex
+
+
+
+Supported Configurations
+
+OS / Python version
+Python 3.8
+Python 3.9
+Python 3.10
+Python 3.11
+Python 3.12
+
+
+
+Linux* OS
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+
+Windows* OS
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+[CPU]
+
+
+
+
+
+
+
+
+
+Release Notes
+See the Release Notes for each version of Intel® Extension for Scikit-learn*.
+
+
+System Requirements
+
+Hardware Requirements
+
+
CPU GPU
All processors with x86
architecture with at least one of the following instruction sets:
+
+
+SSE2
+SSE4.2
+AVX2
+AVX512
+
+
+
+
Note
+
ARM* architecture is not supported.
+
+
+
+
Tip
+
Intel(R) processors provide better performance than other CPUs. Read more about hardware comparison in our blogs .
+
+
+
+Software Requirements
+
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn:
+
+1.0.X
+1.1.X
+1.2.X
+1.3.X
+
+
+
+Memory Requirements
+By default, algorithms in Intel® Extension for Scikit-learn* run in the multi-thread mode. This mode uses all available threads.
+Optimized scikit-learn algorithms can consume more RAM than their corresponding unoptimized versions.
+
+
+Algorithm
+Single-thread mode
+Multi-thread mode
+
+
+
+SVM
+Both Scikit-learn and Intel® Extension for Scikit-learn* consume approximately the same amount of RAM.
+In Intel® Extension for Scikit-learn*, an algorithm with N
threads consumes N
times more RAM.
+
+
+
+In all Intel® Extension for Scikit-learn* algorithms with GPU support, computations run on device memory.
+The device memory must be large enough to store a copy of the entire dataset.
+You may also require additional device memory for internal arrays that are used in computation.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples.html b/2024.3/samples.html
new file mode 100644
index 0000000000..59dd7d47fc
--- /dev/null
+++ b/2024.3/samples.html
@@ -0,0 +1,436 @@
+
+
+
+
+
+
+ Samples — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Samples
+The following samples are also provided as Jupyter notebooks in Intel® Extension for Scikit-learn* repository.
+If you want to run them locally, refer to these instructions .
+Classification Tasks
+
+Regression Tasks
+
+Clustering Tasks
+
+Jupyter Notebook Samples
+
+
+
See also
+
There are also Kaggle kernels that use Intel® Extension for Scikit-learn* for a variety of machine learning scenarios.
+
+
+
Note
+
Explore the complete list of oneAPI code samples in the oneAPI Samples Catalog . These samples were designed to help you develop, offload, and optimize multiarchitecture applications targeting CPUs, GPUs, and FPGAs.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/ElasticNet.html b/2024.3/samples/ElasticNet.html
new file mode 100644
index 0000000000..73887e50c4
--- /dev/null
+++ b/2024.3/samples/ElasticNet.html
@@ -0,0 +1,638 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset
+
+
+
+Preprocessing
+Let’s encode categorical features with LabelEncoder
+
+Split the data into train and test sets
+
+
+
+
+
+((9000000, 9), (1000000, 9), (9000000,), (1000000,))
+
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the ElasticNet algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 0.28 s'
+
+
+Predict and get a result of the ElasticNet algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Patched Scikit-learn MSE: 1.0109113399224974'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class ElasticNet
+
+Training of the ElasticNet algorithm with original Scikit-learn library for Airlines DepDelay dataset
+
+
+
+
+
+'Original Scikit-learn time: 3.96 s'
+
+
+Predict and get a result of the ElasticNet algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn MSE: 1.0109113399545733'
+
+
+
+
+
+
+
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0109113399224974
MSE metric of unpatched Scikit-learn: 1.0109113399545733
Metrics ratio: 0.9999999999682703
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 14.2 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/ElasticNet.ipynb b/2024.3/samples/ElasticNet.ipynb
new file mode 100644
index 0000000000..29e5dca851
--- /dev/null
+++ b/2024.3/samples/ElasticNet.ipynb
@@ -0,0 +1,386 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34e460a7",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "00c2277b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06d309c0",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2ff35bc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38637349",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import StandardScaler\n",
+ "\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.28 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"l1_ratio\": 0.7,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0109113399224974'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class ElasticNet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 3.96 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0109113399545733'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a2edbb65",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0109113399224974 MSE metric of unpatched Scikit-learn: 1.0109113399545733 Metrics ratio: 0.9999999999682703 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 14.2 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/daal4py_data_science.html b/2024.3/samples/daal4py_data_science.html
new file mode 100644
index 0000000000..12d10e46cf
--- /dev/null
+++ b/2024.3/samples/daal4py_data_science.html
@@ -0,0 +1,827 @@
+
+
+
+
+
+
+ Utilizing daal4py in Data Science Workflows — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Utilizing daal4py in Data Science Workflows
+The notebook below has been made to demonstrate daal4py in a data science context. It utilizes a Cycling Dataset for pyworkout-toolkit, and attempts to create a linear regression model from the 5 features collected for telemetry to predict the user’s Power output in the absence of a power meter.
+
+
+
+
+
+'3.8.10 (default, May 19 2021, 18:05:58) \n[GCC 7.3.0]'
+
+
+This example will be exploring workout data pulled from Strava, processed into a CSV for Pandas and daal4py usage. Below, we utilize pandas to read in the CSV file, and look at the head of dataframe with .head()
+
+
+
+
+
+
+
+
+
+
+ altitude
+ cadence
+ distance
+ hr
+ latitude
+ longitude
+ power
+ speed
+ time
+
+
+
+
+ 0
+ 185.800003
+ 51
+ 3.46
+ 81
+ 30.313309
+ -97.732711
+ 45
+ 3.459
+ 2016-10-20T22:01:26.000Z
+
+
+ 1
+ 185.800003
+ 68
+ 7.17
+ 82
+ 30.313277
+ -97.732715
+ 0
+ 3.710
+ 2016-10-20T22:01:27.000Z
+
+
+ 2
+ 186.399994
+ 38
+ 11.04
+ 82
+ 30.313243
+ -97.732717
+ 42
+ 3.874
+ 2016-10-20T22:01:28.000Z
+
+
+ 3
+ 186.800003
+ 38
+ 15.18
+ 83
+ 30.313212
+ -97.732720
+ 5
+ 4.135
+ 2016-10-20T22:01:29.000Z
+
+
+ 4
+ 186.600006
+ 38
+ 19.43
+ 83
+ 30.313172
+ -97.732723
+ 1
+ 4.250
+ 2016-10-20T22:01:30.000Z
+
+
+
+
+
+
+
The data above has several key features that would be of great use here.
+
- Altitude can affect performance, so it might be a useful feature.
+
- Cadence is the revolutions per minute of the crank, and may have possible influence.
+
- Heart Rate is a measure of the body’s workout strain, and would have a high possibly of influence. - Distance may have a loose correlation as it is highly route dependent, but might be possible. - Speed has possible correlations as it ties directly into power.
+
+
+Explore and visualize some of the data
+In general, we are trying to predict on the ‘power’ in Watts to see if we can generate a model that can predict one’s power output without the usage of a cycling power meter. Below are some basic scatterplots as we explore the data. Scatterplots are great for looking for patterns and correlation in the data itself. Below, we can see that cadence and speed are positively correlated.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Using daal4py for Machine Learning tasks
+In the sections below, we will be using daal4py directly. After importing the model, we will arrange it in a separate independent and dependent dataframes, then use the daal4py’s training and prediction classes to generate a workable model.
+
+It is now the time to split the dataset into train and test sets. This is demonstrated below.
+
+
+
+
+
+
+(3902, 9)
+(3000, 9) (902, 9)
+
+
+
+X is 5 features by 3k rows, Y is 3k rows by 1 column
+
+
+
+
+Training the model
+Create the Linear Regression Model, and train the model with the data. We utilize daal4py’s linear_regression_training class to create the model, then call .compute() with the independent and dependent data as the parameters.
+
+
+
+
+
+
+
+Model has this number of features: 5
+
+
+
+
+Prediction (inference) with the trained model
+Now that the model is trained, we can test it with the test part of the dataset. We drop the same features to match that of the trained model, and put it into daal4py’s linear_regression_prediction class.
+
+Now we can create the Prediction object and use the reduced dataset for prediction. The class’s arguments use the independent data and the trained model from above as the parameters.
+
+
+
+
+
+
+
+
+
+The graph above shows the Orange (predicted) result over the Blue (original data). This data is notoriously sparse in features leading to a difficult to predict target!
+
+
+Model properties
+Another aspect of the model is the trained model’s properties, which are explored below.
+
+
+
+
+
+
+Betas: [[ 1.51003501e+01 -1.25075548e-01 1.32249115e+00 1.64363922e-03
+ 8.53155955e-01 -1.09595022e+01]]
+Number of betas: 6
+Number of Features: 5
+
+
+
+
+Additional metrics
+We can generate metrics on the independent data with daal4py’s low_order_moments() class.
+
+
+
+
+
+array([[1.90063975e+01, 3.75882355e+01, 4.98258371e+03, 2.41394741e+01,
+ 1.81623064e+00]])
+
+
+
+
+Migrating the trained model for inference on external systems
+Occasionally one may need to migrate the trained model to another system for inference only–this use case allows the training on a much more powerful machine with a larger dataset, and placing the trained model for inference-only on a smaller machine.
+
+
+The trained model file above can be moved to an inference-only or embedded system. This is useful if the training is extreamly heavy or computed-limited.
+
+The imported model from file is now usable again. We can check the betas from the model to ensure that the trained model is present.
+
+
+
+
+
+array([[ 1.51003501e+01, -1.25075548e-01, 1.32249115e+00,
+ 1.64363922e-03, 8.53155955e-01, -1.09595022e+01]])
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/daal4py_data_science.ipynb b/2024.3/samples/daal4py_data_science.ipynb
new file mode 100644
index 0000000000..9336772cb3
--- /dev/null
+++ b/2024.3/samples/daal4py_data_science.ipynb
@@ -0,0 +1,650 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Utilizing daal4py in Data Science Workflows\n",
+ "\n",
+ "The notebook below has been made to demonstrate daal4py in a data science context. It utilizes a Cycling Dataset for pyworkout-toolkit, and attempts to create a linear regression model from the 5 features collected for telemetry to predict the user's Power output in the absence of a power meter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'3.8.10 (default, May 19 2021, 18:05:58) \\n[GCC 7.3.0]'"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import glob\n",
+ "import sys\n",
+ "\n",
+ "%matplotlib inline\n",
+ "sys.version"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This example will be exploring workout data pulled from Strava, processed into a CSV for Pandas and daal4py usage. Below, we utilize pandas to read in the CSV file, and look at the head of dataframe with .head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " altitude \n",
+ " cadence \n",
+ " distance \n",
+ " hr \n",
+ " latitude \n",
+ " longitude \n",
+ " power \n",
+ " speed \n",
+ " time \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 185.800003 \n",
+ " 51 \n",
+ " 3.46 \n",
+ " 81 \n",
+ " 30.313309 \n",
+ " -97.732711 \n",
+ " 45 \n",
+ " 3.459 \n",
+ " 2016-10-20T22:01:26.000Z \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 185.800003 \n",
+ " 68 \n",
+ " 7.17 \n",
+ " 82 \n",
+ " 30.313277 \n",
+ " -97.732715 \n",
+ " 0 \n",
+ " 3.710 \n",
+ " 2016-10-20T22:01:27.000Z \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 186.399994 \n",
+ " 38 \n",
+ " 11.04 \n",
+ " 82 \n",
+ " 30.313243 \n",
+ " -97.732717 \n",
+ " 42 \n",
+ " 3.874 \n",
+ " 2016-10-20T22:01:28.000Z \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 186.800003 \n",
+ " 38 \n",
+ " 15.18 \n",
+ " 83 \n",
+ " 30.313212 \n",
+ " -97.732720 \n",
+ " 5 \n",
+ " 4.135 \n",
+ " 2016-10-20T22:01:29.000Z \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 186.600006 \n",
+ " 38 \n",
+ " 19.43 \n",
+ " 83 \n",
+ " 30.313172 \n",
+ " -97.732723 \n",
+ " 1 \n",
+ " 4.250 \n",
+ " 2016-10-20T22:01:30.000Z \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " altitude cadence distance hr latitude longitude power speed \\\n",
+ "0 185.800003 51 3.46 81 30.313309 -97.732711 45 3.459 \n",
+ "1 185.800003 68 7.17 82 30.313277 -97.732715 0 3.710 \n",
+ "2 186.399994 38 11.04 82 30.313243 -97.732717 42 3.874 \n",
+ "3 186.800003 38 15.18 83 30.313212 -97.732720 5 4.135 \n",
+ "4 186.600006 38 19.43 83 30.313172 -97.732723 1 4.250 \n",
+ "\n",
+ " time \n",
+ "0 2016-10-20T22:01:26.000Z \n",
+ "1 2016-10-20T22:01:27.000Z \n",
+ "2 2016-10-20T22:01:28.000Z \n",
+ "3 2016-10-20T22:01:29.000Z \n",
+ "4 2016-10-20T22:01:30.000Z "
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "workout_data_dd = pd.read_csv(\"data/cycling_dataset.csv\", index_col=0)\n",
+ "workout_data_dd.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data above has several key features that would be of great use here. \n",
+ "- Altitude can affect performance, so it might be a useful feature. \n",
+ "- Cadence is the revolutions per minute of the crank, and may have possible influence. \n",
+ "- Heart Rate is a measure of the body's workout strain, and would have a high possibly of influence.\n",
+ "- Distance may have a loose correlation as it is highly route dependent, but might be possible.\n",
+ "- Speed has possible correlations as it ties directly into power."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Explore and visualize some of the data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In general, we are trying to predict on the 'power' in Watts to see if we can generate a model that can predict one's power output without the usage of a cycling power meter. Below are some basic scatterplots as we explore the data. Scatterplots are great for looking for patterns and correlation in the data itself. Below, we can see that cadence and speed are positively correlated. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "workout_data_dd.plot.scatter(\"cadence\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"hr\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"cadence\", \"speed\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"speed\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"altitude\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"distance\", \"power\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using daal4py for Machine Learning tasks\n",
+ "\n",
+ "In the sections below, we will be using daal4py directly. After importing the model, we will arrange it in a separate independent and dependent dataframes, then use the daal4py's training and prediction classes to generate a workable model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import daal4py as d4p"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It is now the time to split the dataset into train and test sets. This is demonstrated below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3902, 9)\n",
+ "(3000, 9) (902, 9)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(workout_data_dd.shape)\n",
+ "train_set = workout_data_dd[0:3000]\n",
+ "test_set = workout_data_dd[3000:]\n",
+ "print(train_set.shape, test_set.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Reduce the dataset, create X. We drop the target, and other non-essential features.\n",
+ "reduced_dataset = train_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)\n",
+ "# Get the target, create Y\n",
+ "target = train_set.power.values.reshape((-1, 1))\n",
+ "# This is essentially doing np.array(dataset.power.values, ndmin=2).T\n",
+ "# as it needs to force a 2 dimensional array as we only have 1 target"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "X is 5 features by 3k rows, Y is 3k rows by 1 column"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3000, 5) (3000, 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(reduced_dataset.values.shape, target.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training the model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the Linear Regression Model, and train the model with the data. We utilize daal4py's linear_regression_training class to create the model, then call .compute() with the independent and dependent data as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d4p_lm = d4p.linear_regression_training(interceptFlag=True)\n",
+ "lm_trained = d4p_lm.compute(reduced_dataset.values, target)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model has this number of features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Model has this number of features: \", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prediction (inference) with the trained model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that the model is trained, we can test it with the test part of the dataset. We drop the same features to match that of the trained model, and put it into daal4py's linear_regression_prediction class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "subset = test_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can create the Prediction object and use the reduced dataset for prediction. The class's arguments use the independent data and the trained model from above as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lm_predictor_component = d4p.linear_regression_prediction()\n",
+ "result = lm_predictor_component.compute(subset.values, lm_trained.model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(result.prediction[0:300])\n",
+ "plt.plot(test_set.power.values[0:300])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The graph above shows the Orange (predicted) result over the Blue (original data). This data is notoriously sparse in features leading to a difficult to predict target!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Model properties\n",
+ "Another aspect of the model is the trained model's properties, which are explored below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Betas: [[ 1.51003501e+01 -1.25075548e-01 1.32249115e+00 1.64363922e-03\n",
+ " 8.53155955e-01 -1.09595022e+01]]\n",
+ "Number of betas: 6\n",
+ "Number of Features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Betas:\", lm_trained.model.Beta)\n",
+ "print(\"Number of betas:\", lm_trained.model.NumberOfBetas)\n",
+ "print(\"Number of Features:\", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Additional metrics\n",
+ "We can generate metrics on the independent data with daal4py's low_order_moments() class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1.90063975e+01, 3.75882355e+01, 4.98258371e+03, 2.41394741e+01,\n",
+ " 1.81623064e+00]])"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "metrics_processor = d4p.low_order_moments()\n",
+ "data = metrics_processor.compute(reduced_dataset.values)\n",
+ "data.standardDeviation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Migrating the trained model for inference on external systems\n",
+ "\n",
+ "Occasionally one may need to migrate the trained model to another system for inference only--this use case allows the training on a much more powerful machine with a larger dataset, and placing the trained model for inference-only on a smaller machine."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pickle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"wb\") as model_pi:\n",
+ " pickle.dump(lm_trained.model, model_pi)\n",
+ " model_pi.close"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The trained model file above can be moved to an inference-only or embedded system. This is useful if the training is extreamly heavy or computed-limited. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"rb\") as model_import:\n",
+ " lm_import = pickle.load(model_import)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The imported model from file is now usable again. We can check the betas from the model to ensure that the trained model is present."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1.51003501e+01, -1.25075548e-01, 1.32249115e+00,\n",
+ " 1.64363922e-03, 8.53155955e-01, -1.09595022e+01]])"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lm_import.Beta"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9 (tags/v3.10.9:1dd9be6, Dec 6 2022, 20:01:21) [MSC v.1934 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "8837a6bc722950b4562ef1f8ddb3cf1e2be71cad9580dda11136095ace1c488e"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2024.3/samples/dbscan.html b/2024.3/samples/dbscan.html
new file mode 100644
index 0000000000..41b9d0ea59
--- /dev/null
+++ b/2024.3/samples/dbscan.html
@@ -0,0 +1,607 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset
+
+
+
+Preprocessing
+Split the data into train and test sets
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the DBSCAN algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 6.37 s'
+
+
+Let’s take a look at Davies-Bouldin score of the DBSCAN algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Intel® extension for Scikit-learn Davies-Bouldin score: 0.8542652084275848'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class DBSCAN
+
+Training of the DBSCAN algorithm with original Scikit-learn library for spoken arabic digit dataset
+
+
+
+
+
+'Original Scikit-learn time: 469.21 s'
+
+
+Let’s take a look Davies-Bouldin score of the DBSCAN algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn Davies-Bouldin score: 0.8542652084275848'
+
+
+
+
+
+
+
Compare Davies-Bouldin score of patched Scikit-learn and original Davies-Bouldin score of patched Scikit-learn: 0.8542652084275848
Davies-Bouldin score of unpatched Scikit-learn: 0.8542652084275848
Metrics ratio: 1.0
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 73.6 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/dbscan.ipynb b/2024.3/samples/dbscan.ipynb
new file mode 100644
index 0000000000..d6e5c92653
--- /dev/null
+++ b/2024.3/samples/dbscan.ipynb
@@ -0,0 +1,344 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.metrics import davies_bouldin_score\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6fd95eeb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "33da61da",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 6.37 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "params = {\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at Davies-Bouldin score of the DBSCAN algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class DBSCAN"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 469.21 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look Davies-Bouldin score of the DBSCAN algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Original Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Davies-Bouldin score of patched Scikit-learn and original Davies-Bouldin score of patched Scikit-learn: 0.8542652084275848 Davies-Bouldin score of unpatched Scikit-learn: 0.8542652084275848 Metrics ratio: 1.0 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 73.6 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Davies-Bouldin score of patched Scikit-learn and original \"\n",
+ " f\"Davies-Bouldin score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"Davies-Bouldin score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/kmeans.html b/2024.3/samples/kmeans.html
new file mode 100644
index 0000000000..eb779854df
--- /dev/null
+++ b/2024.3/samples/kmeans.html
@@ -0,0 +1,627 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset
+
+
+
+Preprocessing
+Split the data into train and test sets
+
+
+
+
+
+((236930, 14), (26326, 14), (236930,), (26326,))
+
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the KMeans algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 7.36 s'
+
+
+Let’s take a look at inertia and number of iterations of the KMeans algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+
+Intel® extension for Scikit-learn inertia: 13346.641333761074
+Intel® extension for Scikit-learn number of iterations: 274
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class KMeans
+
+Training of the KMeans algorithm with original Scikit-learn library for spoken arabic digit dataset
+
+
+
+
+
+'Original Scikit-learn time: 192.14 s'
+
+
+Let’s take a look at inertia and number of iterations of the KMeans algorithm with original Scikit-learn
+
+
+
+
+
+
+Original Scikit-learn inertia: 13352.813785961785
+Original Scikit-learn number of iterations: 212
+
+
+
+
+
+
+
Compare inertia and number of iterations of patched Scikit-learn and original Inertia: Patched Scikit-learn: 13346.641333761074
Unpatched Scikit-learn: 13352.813785961785
Ratio: 0.9995377414603653
Number of iterations: Patched Scikit-learn: 274
Unpatched Scikit-learn: 212
Ratio: 1.29
Number of iterations is bigger but algorithm is much faster and inertia is lower
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get speedup in 26.1 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/kmeans.ipynb b/2024.3/samples/kmeans.ipynb
new file mode 100644
index 0000000000..df09f8ded5
--- /dev/null
+++ b/2024.3/samples/kmeans.ipynb
@@ -0,0 +1,362 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cdcb77d",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((236930, 14), (26326, 14), (236930,), (26326,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=123)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 7.36 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "params = {\n",
+ " \"n_clusters\": 128,\n",
+ " \"random_state\": 123,\n",
+ " \"copy_x\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn inertia: 13346.641333761074\n",
+ "Intel® extension for Scikit-learn number of iterations: 274\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_opt = model.inertia_\n",
+ "n_iter_opt = model.n_iter_\n",
+ "print(f\"Intel® extension for Scikit-learn inertia: {inertia_opt}\")\n",
+ "print(f\"Intel® extension for Scikit-learn number of iterations: {n_iter_opt}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KMeans"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 192.14 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn inertia: 13352.813785961785\n",
+ "Original Scikit-learn number of iterations: 212\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_original = model.inertia_\n",
+ "n_iter_original = model.n_iter_\n",
+ "print(f\"Original Scikit-learn inertia: {inertia_original}\")\n",
+ "print(f\"Original Scikit-learn number of iterations: {n_iter_original}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare inertia and number of iterations of patched Scikit-learn and original Inertia: Patched Scikit-learn: 13346.641333761074 Unpatched Scikit-learn: 13352.813785961785 Ratio: 0.9995377414603653 Number of iterations: Patched Scikit-learn: 274 Unpatched Scikit-learn: 212 Ratio: 1.29 Number of iterations is bigger but algorithm is much faster and inertia is lowerWith Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get speedup in 26.1 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare inertia and number of iterations of patched Scikit-learn and original \"\n",
+ " f\"Inertia: \"\n",
+ " f\"Patched Scikit-learn: {inertia_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {inertia_original} \"\n",
+ " f\"Ratio: {inertia_opt/inertia_original} \"\n",
+ " f\"Number of iterations: \"\n",
+ " f\"Patched Scikit-learn: {n_iter_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {n_iter_original} \"\n",
+ " f\"Ratio: {(n_iter_opt/n_iter_original):.2f} \"\n",
+ " f\"Number of iterations is bigger but algorithm is much faster and inertia is lower\"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/knn_mnist.html b/2024.3/samples/knn_mnist.html
new file mode 100644
index 0000000000..e08ec763c2
--- /dev/null
+++ b/2024.3/samples/knn_mnist.html
@@ -0,0 +1,620 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn KNN for MNIST dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn KNN for MNIST dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+
+
+((56000, 784), (14000, 784), (56000,), (14000,))
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training and predict KNN algorithm with Intel® Extension for Scikit-learn for MNIST dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 1.45 s'
+
+
+
+
+
+
+
+
+Classification report for Intel® extension for Scikit-learn KNN:
+ precision recall f1-score support
+
+ 0 0.97 0.99 0.98 1365
+ 1 0.93 0.99 0.96 1637
+ 2 0.99 0.94 0.96 1401
+ 3 0.96 0.95 0.96 1455
+ 4 0.98 0.96 0.97 1380
+ 5 0.95 0.95 0.95 1219
+ 6 0.96 0.99 0.97 1317
+ 7 0.94 0.95 0.95 1420
+ 8 0.99 0.90 0.94 1379
+ 9 0.92 0.94 0.93 1427
+
+ accuracy 0.96 14000
+ macro avg 0.96 0.96 0.96 14000
+weighted avg 0.96 0.96 0.96 14000
+
+
+
+
+The first column of the classification report above is the class labels.
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class KNeighborsClassifier.
+
+Training and predict KNN algorithm with original Scikit-learn library for MNSIT dataset
+
+
+
+
+
+'Original Scikit-learn time: 36.15 s'
+
+
+
+
+
+
+
+
+Classification report for original Scikit-learn KNN:
+ precision recall f1-score support
+
+ 0 0.97 0.99 0.98 1365
+ 1 0.93 0.99 0.96 1637
+ 2 0.99 0.94 0.96 1401
+ 3 0.96 0.95 0.96 1455
+ 4 0.98 0.96 0.97 1380
+ 5 0.95 0.95 0.95 1219
+ 6 0.96 0.99 0.97 1317
+ 7 0.94 0.95 0.95 1420
+ 8 0.99 0.90 0.94 1379
+ 9 0.92 0.94 0.93 1427
+
+ accuracy 0.96 14000
+ macro avg 0.96 0.96 0.96 14000
+weighted avg 0.96 0.96 0.96 14000
+
+
+
+
+
+
+
+
+
With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 24.9 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/knn_mnist.ipynb b/2024.3/samples/knn_mnist.ipynb
new file mode 100644
index 0000000000..b8604d70f0
--- /dev/null
+++ b/2024.3/samples/knn_mnist.ipynb
@@ -0,0 +1,333 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn KNN for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Download the data "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"mnist_784\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6259f584",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((56000, 784), (14000, 784), (56000,), (14000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with Intel® Extension for Scikit-learn for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 1.45 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "params = {\"n_neighbors\": 40, \"weights\": \"distance\", \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_opt = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "8ca549ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KNeighborsClassifier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with original Scikit-learn library for MNSIT dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 36.15 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_original = timer() - start\n",
+ "f\"Original Scikit-learn time: {time_original:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "33da9fd1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 24.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(time_original/time_opt):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/lasso_regression.html b/2024.3/samples/lasso_regression.html
new file mode 100644
index 0000000000..2c1de54b69
--- /dev/null
+++ b/2024.3/samples/lasso_regression.html
@@ -0,0 +1,644 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+ Samples
+ Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset
+
+ View page source
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+
+
+((463810, 90), (51535, 90), (463810,), (51535,))
+
+
+
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the Lasso algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 0.06 s'
+
+
+Predict and get a result of the Lasso algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Patched Scikit-learn MSE: 0.9676607251167297'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class Lasso
+
+Training of the Lasso algorithm with original Scikit-learn library for YearPredictionMSD dataset
+
+
+
+
+
+'Original Scikit-learn time: 0.83 s'
+
+
+Predict and get a result of the Lasso algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn MSE: 0.9676599502563477'
+
+
+
+
+
+
+
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.9676607251167297
MSE metric of unpatched Scikit-learn: 0.9676599502563477
Metrics ratio: 1.0000008344650269
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.7 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/lasso_regression.ipynb b/2024.3/samples/lasso_regression.ipynb
new file mode 100644
index 0000000000..967d0d4e54
--- /dev/null
+++ b/2024.3/samples/lasso_regression.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import requests\n",
+ "import warnings\n",
+ "import os\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db2d1c39",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e58a6e28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "532874ab",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.01,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.9676607251167297'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Lasso"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.83 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.9676599502563477'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "13c86289",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.9676607251167297 MSE metric of unpatched Scikit-learn: 0.9676599502563477 Metrics ratio: 1.0000008344650269 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.7 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/linear_regression.html b/2024.3/samples/linear_regression.html
new file mode 100644
index 0000000000..8d3367659a
--- /dev/null
+++ b/2024.3/samples/linear_regression.html
@@ -0,0 +1,639 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+ Samples
+ Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset
+
+ View page source
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+
+
+((463810, 90), (51535, 90), (463810,), (51535,))
+
+
+
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the Linear Regression algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 0.03 s'
+
+
+Predict and get a result of the Linear Regression algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Patched Scikit-learn MSE: 0.7716818451881409'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class LinearRegression
+
+Training of the Linear Regression algorithm with original Scikit-learn library for YearPredictionMSD dataset
+
+
+
+
+
+'Original Scikit-learn time: 0.53 s'
+
+
+Predict and get a result of the Linear Regression algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn MSE: 0.7716856598854065'
+
+
+
+
+
+
+
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.7716818451881409
MSE metric of unpatched Scikit-learn: 0.7716856598854065
Metrics ratio: 0.9999950528144836
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 18.4 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/linear_regression.ipynb b/2024.3/samples/linear_regression.ipynb
new file mode 100644
index 0000000000..508ee06d8c
--- /dev/null
+++ b/2024.3/samples/linear_regression.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import requests\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad7ce109",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "801ea6cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03431aec",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.03 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "params = {\"n_jobs\": -1, \"copy_X\": False}\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.7716818451881409'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LinearRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.53 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.7716856598854065'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "91fb14e4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.7716818451881409 MSE metric of unpatched Scikit-learn: 0.7716856598854065 Metrics ratio: 0.9999950528144836 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 18.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/logistictic_regression_cifar.html b/2024.3/samples/logistictic_regression_cifar.html
new file mode 100644
index 0000000000..f2c6f3d294
--- /dev/null
+++ b/2024.3/samples/logistictic_regression_cifar.html
@@ -0,0 +1,599 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+
+
+((54000, 3072), (6000, 3072), (54000,))
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the Logistic Regression algorithm with Intel® Extension for Scikit-learn for CIFAR dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 24.82 s'
+
+
+Predict probability and get a result of the Logistic Regression algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Intel® extension for Scikit-learn Log Loss: 3.7073530800931587 s'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class LogisticRegression
+
+Training of the Logistic Regression algorithm with original Scikit-learn library for CIFAR dataset
+
+
+
+
+
+'Original Scikit-learn time: 395.03 s'
+
+
+Predict probability and get a result of the Logistic Regression algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn Log Loss: 3.7140870590578428 s'
+
+
+
+
+
+
+
Compare Log Loss metric of patched Scikit-learn and original Log Loss metric of patched Scikit-learn: 3.7073530800931587
Log Loss metric of unpatched Scikit-learn: 3.7140870590578428
Metrics ratio: 0.9981869086917978
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 15.9 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/logistictic_regression_cifar.ipynb b/2024.3/samples/logistictic_regression_cifar.ipynb
new file mode 100644
index 0000000000..43727804d7
--- /dev/null
+++ b/2024.3/samples/logistictic_regression_cifar.ipynb
@@ -0,0 +1,329 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb52aca",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.datasets import fetch_openml\n",
+ "\n",
+ "x, y = fetch_openml(name=\"CIFAR-100\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc8ba7c8",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((54000, 3072), (6000, 3072), (54000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=43)\n",
+ "x_train.shape, x_test.shape, y_train.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with Intel® Extension for Scikit-learn for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.82 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "params = {\n",
+ " \"C\": 0.1,\n",
+ " \"solver\": \"lbfgs\",\n",
+ " \"multi_class\": \"multinomial\",\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Log Loss: 3.7073530800931587 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_opt = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Intel® extension for Scikit-learn Log Loss: {log_loss_opt} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LogisticRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with original Scikit-learn library for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 395.03 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d38dfb5",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Log Loss: 3.7140870590578428 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_original = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Original Scikit-learn Log Loss: {log_loss_original} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "b7d17e2f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Log Loss metric of patched Scikit-learn and original Log Loss metric of patched Scikit-learn: 3.7073530800931587 Log Loss metric of unpatched Scikit-learn: 3.7140870590578428 Metrics ratio: 0.9981869086917978 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 15.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Log Loss metric of patched Scikit-learn and original \"\n",
+ " f\"Log Loss metric of patched Scikit-learn: {log_loss_opt} \"\n",
+ " f\"Log Loss metric of unpatched Scikit-learn: {log_loss_original} \"\n",
+ " f\"Metrics ratio: {log_loss_opt/log_loss_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/nusvr_medical_charges.html b/2024.3/samples/nusvr_medical_charges.html
new file mode 100644
index 0000000000..ee0d442761
--- /dev/null
+++ b/2024.3/samples/nusvr_medical_charges.html
@@ -0,0 +1,608 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset
+
+
+
+Preprocessing
+Encode categorical features
+
+Split the data into train and test sets
+
+
+
+
+
+((48919, 11), (114146, 11), (48919,), (114146,))
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the NuSVR algorithm with Intel® Extension for Scikit-learn for Medical Charges dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 24.69 s'
+
+
+Predict and get a result of the NuSVR algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Intel® extension for Scikit-learn R2 score: 0.8635974264586637'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class NuSVR
+
+Training of the NuSVR algorithm with original Scikit-learn library for Medical Charges dataset
+
+
+
+
+
+'Original Scikit-learn time: 331.85 s'
+
+
+Predict and get a result of the NuSVR algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn R2 score: 0.8636031741516902'
+
+
+
+
+
+
+
Compare R2 score of patched Scikit-learn and original R2 score of patched Scikit-learn: 0.8635974264586637
R2 score of unpatched Scikit-learn: 0.8636031741516902
Metrics ratio: 0.999993344520726
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.4 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/nusvr_medical_charges.ipynb b/2024.3/samples/nusvr_medical_charges.ipynb
new file mode 100644
index 0000000000..8c72c1b71d
--- /dev/null
+++ b/2024.3/samples/nusvr_medical_charges.ipynb
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adf9ffe9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "a9b315cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"medical_charges_nominal\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49fbf604",
+ "metadata": {},
+ "source": [
+ "### Preprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fafea10b",
+ "metadata": {},
+ "source": [
+ "Encode categorical features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "f77c30f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cat_columns = x.select_dtypes([\"category\"]).columns\n",
+ "x[cat_columns] = x[cat_columns].apply(lambda x: x.cat.codes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd8d3b6d",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((48919, 11), (114146, 11), (48919,), (114146,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.3, random_state=42)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with Intel® Extension for Scikit-learn for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.69 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "params = {\n",
+ " \"nu\": 0.4,\n",
+ " \"C\": y_train.mean(),\n",
+ " \"degree\": 2,\n",
+ " \"kernel\": \"poly\",\n",
+ "}\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn R2 score: 0.8635974264586637'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = nusvr.score(x_test, y_test)\n",
+ "f\"Intel® extension for Scikit-learn R2 score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class NuSVR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with original Scikit-learn library for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 331.85 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23b8faa6",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn R2 score: 0.8636031741516902'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = nusvr.score(x_test, y_test)\n",
+ "f\"Original Scikit-learn R2 score: {score_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "3a704d51",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare R2 score of patched Scikit-learn and original R2 score of patched Scikit-learn: 0.8635974264586637 R2 score of unpatched Scikit-learn: 0.8636031741516902 Metrics ratio: 0.999993344520726 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare R2 score of patched Scikit-learn and original \"\n",
+ " f\"R2 score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"R2 score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/random_forest_yolanda.html b/2024.3/samples/random_forest_yolanda.html
new file mode 100644
index 0000000000..e6efff23a4
--- /dev/null
+++ b/2024.3/samples/random_forest_yolanda.html
@@ -0,0 +1,590 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Random Forest for Yolanda dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Random Forest for Yolanda dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+
+
+((280000, 100), (120000, 100), (280000,), (120000,))
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training Random Forest algorithm with Intel® Extension for Scikit-learn for Yolanda dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 42.56 s'
+
+
+Predict and get a result of the Random Forest algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Intel® extension for Scikit-learn Mean Squared Error: 83.62232345666878'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class RandomForestRegressor.
+
+Training Random Forest algorithm with original Scikit-learn library for Yolanda dataset
+
+
+
+
+
+'Original Scikit-learn time: 123.34 s'
+
+
+Predict and get a result of the Random Forest algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn Mean Squared Error: 83.62232345666878'
+
+
+
+
+
+
+
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 83.62232345666878
MSE metric of unpatched Scikit-learn: 83.80131297814816
Metrics ratio: 0.9978641203208111
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 2.9 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/random_forest_yolanda.ipynb b/2024.3/samples/random_forest_yolanda.ipynb
new file mode 100644
index 0000000000..276284ed9b
--- /dev/null
+++ b/2024.3/samples/random_forest_yolanda.ipynb
@@ -0,0 +1,320 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Random Forest for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d0b6bb9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Yolanda\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b3a2483",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((280000, 100), (120000, 100), (280000,), (120000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with Intel® Extension for Scikit-learn for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "8fecbbb1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 42.56 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "params = {\"n_estimators\": 150, \"random_state\": 44, \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9279181",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d05bc57b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_opt = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class RandomForestRegressor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with original Scikit-learn library for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "76a8d5f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 123.34 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f162fe6b",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d5b5e45c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_original = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Original Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "e255e563",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 83.62232345666878 MSE metric of unpatched Scikit-learn: 83.80131297814816 Metrics ratio: 0.9978641203208111 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 2.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_original} \"\n",
+ " f\"Metrics ratio: {mse_opt/mse_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/ridge_regression.html b/2024.3/samples/ridge_regression.html
new file mode 100644
index 0000000000..987fcf7349
--- /dev/null
+++ b/2024.3/samples/ridge_regression.html
@@ -0,0 +1,642 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+ Samples
+ Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset
+
+ View page source
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset
+
+
+
+Preprocessing
+Let’s encode categorical features with LabelEncoder
+
+Split the data into train and test sets
+
+
+
+
+
+((9000000, 9), (1000000, 9), (9000000,), (1000000,))
+
+
+Normalize the data
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the Ridge Regression algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 0.06 s'
+
+
+Predict and get a result of the Ridge Regression algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+'Patched Scikit-learn MSE: 1.0014288520708046'
+
+
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class Ridge
+
+Training of the Ridge Regression algorithm with original Scikit-learn library for Airlines DepDelay dataset
+
+
+
+
+
+'Original Scikit-learn time: 0.70 s'
+
+
+Predict and get a result of the Ridge Regression algorithm with original Scikit-learn
+
+
+
+
+
+'Original Scikit-learn MSE: 1.0014288520708057'
+
+
+
+
+
+
+
Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0014288520708046
MSE metric of unpatched Scikit-learn: 1.0014288520708057
Metrics ratio: 0.9999999999999989
With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 10.9 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/ridge_regression.ipynb b/2024.3/samples/ridge_regression.ipynb
new file mode 100644
index 0000000000..1c159a13ae
--- /dev/null
+++ b/2024.3/samples/ridge_regression.ipynb
@@ -0,0 +1,390 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a1a9234",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f852cad8",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "27ebb377",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "147b3e82",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0014288520708046'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Ridge"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.70 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0014288520708057'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "1bde360d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0014288520708046 MSE metric of unpatched Scikit-learn: 1.0014288520708057 Metrics ratio: 0.9999999999999989 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 10.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/svc_adult.html b/2024.3/samples/svc_adult.html
new file mode 100644
index 0000000000..19b1231aba
--- /dev/null
+++ b/2024.3/samples/svc_adult.html
@@ -0,0 +1,595 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn SVC for Adult dataset — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn SVC for Adult dataset
+
+
+Download the data
+
+Split the data into train and test sets
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training of the SVC algorithm with Intel® Extension for Scikit-learn for Adult dataset
+
+
+
+
+
+'Intel® extension for Scikit-learn time: 14.08 s'
+
+
+Predict and get a result of the SVC algorithm with Intel® Extension for Scikit-learn
+
+
+
+
+
+
+Classification report for Intel® extension for Scikit-learn SVC:
+ precision recall f1-score support
+
+ -1.0 0.87 0.90 0.88 7414
+ 1.0 0.64 0.58 0.61 2355
+
+ accuracy 0.82 9769
+ macro avg 0.76 0.74 0.75 9769
+weighted avg 0.82 0.82 0.82 9769
+
+
+
+
+The first column of the classification report above is the class labels.
+
+
+Train the same algorithm with original Scikit-learn
+In order to cancel optimizations, we use unpatch_sklearn and reimport the class SVC.
+
+Training of the SVC algorithm with original Scikit-learn library for Adult dataset
+
+
+
+
+
+'Original Scikit-learn time: 803.06 s'
+
+
+Predict and get a result of the SVC algorithm with original Scikit-learn
+
+
+
+
+
+
+Classification report for original Scikit-learn SVC:
+ precision recall f1-score support
+
+ -1.0 0.87 0.90 0.88 7414
+ 1.0 0.64 0.58 0.61 2355
+
+ accuracy 0.82 9769
+ macro avg 0.76 0.74 0.75 9769
+weighted avg 0.82 0.82 0.82 9769
+
+
+
+
+
+
+
+
+
With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 57.0 times.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/svc_adult.ipynb b/2024.3/samples/svc_adult.ipynb
new file mode 100644
index 0000000000..9e49bcfecd
--- /dev/null
+++ b/2024.3/samples/svc_adult.ipynb
@@ -0,0 +1,322 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn SVC for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2cdcbfa6",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"a9a\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a6df301",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with Intel® Extension for Scikit-learn for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 14.08 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "params = {\"C\": 100.0, \"kernel\": \"rbf\", \"gamma\": \"scale\"}\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class SVC."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with original Scikit-learn library for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 803.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0a7a747",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fc992182",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 57.0 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/samples/tsne.html b/2024.3/samples/tsne.html
new file mode 100644
index 0000000000..df1506332b
--- /dev/null
+++ b/2024.3/samples/tsne.html
@@ -0,0 +1,569 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn TSNE example — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn TSNE example
+
+
+Generate the data
+
+
Generate isotropic Gaussian blobs for clustering. With the number of samples: 20k Number of features: 100 Number of blobs: 4 Source:
+
+
+
+
+
+Patch original Scikit-learn with Intel® Extension for Scikit-learn
+Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)
+
+
+Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the list of supported algorithms and parameters for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, submit an issue on GitHub .
+Training TSNE algorithm with Intel® Extension for Scikit-learn for generated dataset
+
+
+
+
+
+
+Intel® extension for Scikit-learn time: 12.63 s
+Intel® Extension for scikit-learn. Divergence: 4.289110606110757
+
+
+### Train the same algorithm with original Scikit-learn In order to cancel optimizations, we use unpatch_sklearn and reimport the class TSNE.
+
+Training algorithm with original Scikit-learn library for generated dataset
+
+
+
+
+
+
+Original Scikit-learn time: 37.66 s
+Original Scikit-learn. Divergence: 4.2955403327941895
+
+
+
+
+Plot embeddings original scikit-learn and Intel® extension
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+'Speedup for this run: 3.0'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/samples/tsne.ipynb b/2024.3/samples/tsne.ipynb
new file mode 100644
index 0000000000..99ad8fcefd
--- /dev/null
+++ b/2024.3/samples/tsne.ipynb
@@ -0,0 +1,285 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn TSNE example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import make_blobs\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Generate the data \n",
+ "Generate isotropic Gaussian blobs for clustering.\n",
+ " \n",
+ "With the number of samples: 20k \n",
+ "Number of features: 100 \n",
+ "Number of blobs: 4 \n",
+ "Source: \n",
+ "https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = make_blobs(n_samples=20000, centers=4, n_features=100, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training TSNE algorithm with Intel® Extension for Scikit-learn for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn time: 12.63 s\n",
+ "Intel® Extension for scikit-learn. Divergence: 4.289110606110757\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_intelex = tsne.fit_transform(x)\n",
+ "time_opt = timer() - start\n",
+ "\n",
+ "print(f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\")\n",
+ "print(f\"Intel® Extension for scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ " ### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class TSNE."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training algorithm with original Scikit-learn library for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn time: 37.66 s\n",
+ "Original Scikit-learn. Divergence: 4.2955403327941895\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_original = tsne.fit_transform(x)\n",
+ "time_original = timer() - start\n",
+ "\n",
+ "print(f\"Original Scikit-learn time: {time_original:.2f} s\")\n",
+ "print(f\"Original Scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8358d7c2",
+ "metadata": {},
+ "source": [
+ "### Plot embeddings original scikit-learn and Intel® extension"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "43ab1a96",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colors = [int(m) for m in y]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "35147d24",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABPWUlEQVR4nO3dd3gU5cIF8DObbDZ9Q0IKJYRQpNfQiyJEAiKCUqw0EQQiSBWQq6hXQSmioAKiBj4E6f0KCAgoEqnSlN5JSINkN4RkU/b9/uCylzUJJJDsu7tzfs+T52FnZ2fODkv2MPPOjCKEECAiIiJSAY3sAERERES2wuJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNERESqweJDREREqsHiQ0RERKrB4kNUynbt2gVFUbBr164HzmsymWAymUo/lIPq378/KleuLGXdiYmJ6NmzJwICAqAoCj7//HMpOYrj0qVLUBQFCxcutEzr378/vL29H/jadu3aoV27do+0/pJYBlFJY/Ehp7dw4UIoioKDBw8W+7W3b9/G+++/X6TS8rBycnIwa9Ys1KpVC+7u7nB3d0etWrUwa9Ys5OTkFGtZlStXhqIoBf506tSp2NmWLl3qEF/wtjBq1Chs3boVEydOxOLFix9qezqy+Ph4vP/++zhy5IjsKESPxFV2ACJ7dvv2bXzwwQcAUCr/czUajejatStOnTqFQYMGISIiAoqi4PDhw5g2bRrWrl2LjRs3Qq/XF3mZDRs2xJgxY/JNL1++fLHzLV26FCdOnMDIkSOL/drSsGDBApjNZinr/uWXX9CtWzeMHTtWyvofRlhYGDIzM6HVaov92p9//tnqcXx8PD744ANUrlwZDRs2LKGERLbH4kMkUZ8+feDu7o4jR45Aq9VCURT4+fmhe/fuGDduHF5++WX06dMHGzZsKPIyK1SogFdffbUUU8vzMF/gJSUpKQl+fn4ltrysrCy4ublBoym9He+KosDd3f2hXuvm5lbCaWxDCIGsrCx4eHjIjkJ2ioe6SJXujnOIi4tD9+7d4e3tjcDAQIwdOxZ5eXkA7oyPCAwMBAB88MEHlkNG77//vmU5p06dQs+ePeHv7w93d3c0adKkyCVl06ZNOH/+PNauXYv58+cjMDAQZcuWhU6nQ2RkJEwmE1auXInLly/jP//5T4m996SkJAQGBqJdu3YQQlimnzt3Dl5eXnjhhRcA3NnD9Z///AeXL1+2vPd7x9eYTCZMnjwZ1apVg06nQ2hoKN5+++18Y5QURcGbb76JdevWoW7dutDpdKhTpw62bNliNV96ejpGjhyJypUrQ6fTISgoCE899RQOHz5smaegMT4ZGRkYM2YMQkNDodPpUKNGDcyYMcPqvRUnxz/dPVQqhMBXX31l2RZ3XbhwAb169YK/vz88PT3RokWLfH9fd8d5LVu2DP/6179QoUIFeHp6wmg0FrreZcuWISIiAj4+PvD19UW9evXwxRdfWM2TlpaGUaNGWbZZxYoV0bdvX6SkpAAoeIxPQY4cOWL5TNy6dQuA9ficXbt2oWnTpgCAAQMGWLbBg5ZbkKJ+bmJiYtC+fXsEBQVBp9Ohdu3amDt3br7lVa5cGc888wy2bt2KJk2awMPDA/Pnz7ds8xUrVuDjjz9GxYoV4e7ujg4dOuDcuXPFzk3Og3t8SLXy8vIQFRWF5s2bY8aMGdi+fTtmzpyJqlWrYujQoQgMDMTcuXMxdOhQPPfcc3j++ecBAPXr1wcA/PXXX2jdujUqVKiACRMmwMvLCytWrED37t2xevVqPPfcc/dd/3fffYcpU6bA09PTstyZM2fi5s2bmDBhAj7//HN89NFH+Pjjj/Hdd9+hS5cuRXpfOTk5li++e3l5ecHDwwNBQUGYO3cuevXqhTlz5mDEiBEwm83o378/fHx88PXXXwMAJk2aBIPBgGvXrmHWrFkAYBkUazab8eyzz2LPnj0YPHgwatWqhePHj2PWrFk4c+YM1q1bZ7XuPXv2YM2aNRg2bBh8fHwwe/Zs9OjRA1euXEFAQAAAYMiQIVi1ahXefPNN1K5dGzdu3MCePXtw8uRJNG7cuMD3KoTAs88+i507d2LgwIFo2LAhtm7dinHjxiEuLs6Suzg5/unxxx/H4sWL0adPHzz11FPo27ev5bnExES0atUKt2/fxogRIxAQEIBFixbh2WefxapVq/J9Bv7973/Dzc0NY8eOhclkKnSvyrZt2/DSSy+hQ4cO+PTTTwEAJ0+exO+//4633noLAHDr1i20bdsWJ0+exGuvvYbGjRsjJSUFGzZswLVr11C2bNkCl/1PBw4cQFRUFJo0aYL169cXuKekVq1a+PDDD/Hee+9h8ODBaNu2LQCgVatWRVrHXcX53MydOxd16tTBs88+C1dXV2zcuBHDhg2D2WxGdHS01XJPnz6Nl156CW+88QYGDRqEGjVqWJ775JNPoNFoMHbsWBgMBkybNg2vvPIK9u3bV6zs5EQEkZOLiYkRAMSBAwcs0/r16ycAiA8//NBq3kaNGomIiAjL4+TkZAFATJ48Od9yO3ToIOrVqyeysrIs08xms2jVqpWoXr26ZdrOnTsFALFz506r14eFhVleO3nyZNGqVSuRnJwszp49K5o0aSLGjRsnhBDCZDKJsLCwIr3XsLAwAaDAn6lTp1rN+9JLLwlPT09x5swZMX36dAFArFu3zmqeLl26FLjuxYsXC41GI3777Ter6fPmzRMAxO+//26ZBkC4ubmJc+fOWaYdPXpUABBz5syxTNPr9SI6Ovq+769fv35WedatWycAiI8++shqvp49ewpFUazWWdQchQGQL9/IkSMFAKvtkJ6eLsLDw0XlypVFXl6eEOJ/n4EqVaqI27dvP3Bdb731lvD19RW5ubmFzvPee+8JAGLNmjX5njObzUIIIS5evCgAiJiYGMtz/fr1E15eXkIIIfbs2SN8fX1Fly5drD7HQgjxxBNPiCeeeMLy+MCBA/mW9SD/XEZxPjcFbaeoqChRpUoVq2l3P/Nbtmyxmn53m9eqVUuYTCbL9C+++EIAEMePHy/y+yDnwkNdpGpDhgyxety2bVtcuHDhga+7efMmfvnlF/Tu3Rvp6elISUlBSkoKbty4gaioKJw9exZxcXEPXI5Op7P8ee/evQgMDET16tXh7u5uGVBc3LEWzZs3x7Zt2/L9vPTSS1bzffnll9Dr9ejZsyfeffdd9OnTB926dSvSOlauXIlatWqhZs2alveekpKC9u3bAwB27txpNX9kZCSqVq1qeVy/fn34+vpabWs/Pz/s27cP8fHxRX6vP/30E1xcXDBixAir6WPGjIEQAps3by52juL46aef0KxZM7Rp08YyzdvbG4MHD8alS5fw999/W83fr1+/Io098fPzQ0ZGBrZt21boPKtXr0aDBg0K3LN476G4wuzcuRNRUVHo0KED1qxZY/VZLC3F+dzcu50MBgNSUlLwxBNP4MKFCzAYDFbLDQ8PR1RUVIHrHDBggNW/obt7qx7275wcHw91kWq5u7tbxvDcVaZMGaSmpj7wtefOnYMQAu+++y7efffdAudJSkpChQoVCl2G2WyG2Wy2DG6tX78+/vWvf+Hdd99FtWrVLGdh3Z2vqMqWLYvIyMgHzufv74/Zs2ejV69eCA4OxuzZs4u8jrNnz+LkyZP5tt9dSUlJVo8rVaqUb55/butp06ahX79+CA0NRUREBJ5++mn07dsXVapUKTTH5cuXUb58efj4+FhNr1WrluX54uYojsuXL6N58+b5pt+7/rp161qmh4eHF2m5w4YNw4oVK9C5c2dUqFABHTt2RO/eva1OoT9//jx69OjxULmzsrLQpUsXREREYMWKFXB1ffivglu3blnGBQGAi4tLoZ+L4nxufv/9d0yePBmxsbG4ffu21XwGg8HqTMf7bdd//p2XKVMGAB7675wcH4sPqZaLi8tDv/ZuERk7dmyh/9OsVq3afZfx2GOPITY2Fq1btwZw5xdyr169ULNmTUREROCFF15Ap06dEBsbazVmoSRt3boVwJ0vgWvXrhX5rCWz2Yx69erhs88+K/D50NBQq8eFbWtxzwDk3r17o23btli7di1+/vlnTJ8+HZ9++inWrFmDzp07FynXgxQlR2kq6plGQUFBOHLkCLZu3YrNmzdj8+bNiImJQd++fbFo0aJHzqHT6fD0009j/fr12LJlC5555pmHXtaMGTMsl3wA7pxCf+nSpQLnLern5vz58+jQoQNq1qyJzz77DKGhoXBzc8NPP/2EWbNm5fuPwP22q+y/c7I/LD5E91HYIYO7eyG0Wm2R9q4U5OWXX8Z7772X73BGvXr18M4772D48OE4fvw4Pvjgg3yHqUrCli1b8O233+Ltt9/GkiVL0K9fP+zbt8/qf/+Fvf+qVavi6NGj6NChQ5EOqxRVuXLlMGzYMAwbNgxJSUlo3LgxPv7440KLT1hYGLZv34709HSrvT6nTp2yPF+awsLCcPr06XzTS2L9bm5u6Nq1K7p27Qqz2Yxhw4Zh/vz5lj2CVatWxYkTJx5q2YqiYMmSJejWrRt69eqFzZs3P/A6VYX9Pfft29fqUN/9SkhRPzcbN26EyWTChg0brPbY/PMQKtHD4Bgfovu4e8ZVWlqa1fSgoCC0a9cO8+fPx/Xr1/O9Ljk5+YHL7tOnD1JTUzF8+HBMmDDBajzK5MmTcfjwYUyYMAHJycno06fPo72Rf0hLS8Prr7+OZs2aYcqUKfj2229x+PBhTJkyxWo+Ly+vfOMpgDt7Z+Li4rBgwYJ8z2VmZiIjI6NYefLy8vKtJygoCOXLl7/vLTyefvpp5OXl4csvv7SaPmvWLCiKUmJ7iu63/v379yM2NtYyLSMjA9988w0qV66M2rVrP9Ryb9y4YfVYo9FYzia8uz169OiBo0ePYu3atfleX5S9GW5ublizZg2aNm2Krl27Yv/+/fed38vLC0D+fwtVqlRBZGSk5efuHsyCFPVzc3cvzb3vw2AwICYm5oHvi+hBuMeH6D48PDxQu3ZtLF++HI899hj8/f1Rt25d1K1bF1999RXatGmDevXqYdCgQahSpQoSExMRGxuLa9eu4ejRo/ddtlarxerVq/Hkk0/i4MGDGDVqFJo0aQJFUXDo0CF8/vnniIuLw86dO4t14b64uDj88MMP+aZ7e3uje/fuAIC33noLN27cwPbt2+Hi4oJOnTrh9ddfx0cffYRu3bqhQYMGAICIiAgsX74co0ePRtOmTeHt7Y2uXbuiT58+WLFiBYYMGYKdO3eidevWyMvLw6lTp7BixQrLNVWKKj09HRUrVkTPnj3RoEEDeHt7Y/v27Thw4ABmzpxZ6Ou6du2KJ598EpMmTcKlS5fQoEED/Pzzz1i/fj1GjhxpNZC5NEyYMAE//vgjOnfujBEjRsDf3x+LFi3CxYsXsXr16oe+OOHrr7+Omzdvon379qhYsSIuX76MOXPmoGHDhpbxQ+PGjcOqVavQq1cvvPbaa4iIiMDNmzexYcMGzJs3z/J3eD8eHh7YtGkT2rdvj86dO2P37t1WY5LuVbVqVfj5+WHevHnw8fGBl5cXmjdvXuRxSwCK/Lnp2LGjZY/XG2+8gVu3bmHBggUICgoq8D8aRMUi8YwyIpso7HT2u6f03mvy5Mnin/8s9u7dKyIiIoSbm1u+U9vPnz8v+vbtK0JCQoRWqxUVKlQQzzzzjFi1apVlnsJOZ78rISFBvPzyy0Kr1VpOPddqteLll18W169fL9Z7vd/p7HdPA1+/fr0AIGbOnGn1WqPRKMLCwkSDBg1Edna2EEKIW7duiZdffln4+flZLUMIIbKzs8Wnn34q6tSpI3Q6nShTpoyIiIgQH3zwgTAYDJb5UMBp4Hez9uvXTwhx55T9cePGiQYNGggfHx/h5eUlGjRoIL7++mur1/zzdHYh7pw+PmrUKFG+fHmh1WpF9erVxfTp0y2ndBcnx/0U9vrz58+Lnj17Cj8/P+Hu7i6aNWsmNm3aZDXP3c/AypUrH7geIYRYtWqV6NixowgKChJubm6iUqVK4o033sj3ebhx44Z48803RYUKFYSbm5uoWLGi6Nevn0hJSRFCPPh09rtSUlJE7dq1RUhIiDh79qwQIv+p6ELc+ezUrl1buLq6FunU9oKWUdTPzYYNG0T9+vWFu7u7qFy5svj000/F999/LwCIixcvWuYLCwsTXbp0ybfuwrZ5QduE1EURgiO8iOyBwWCwjA2pWbNmse7PRURERcPiQ0RERKrBwc1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBq8gOE9zGYz4uPj4ePjU6KX4SciIqLSI4RAeno6ypcv/8ALh7L43CM+Pj7fzRWJiIjIMVy9ehUVK1a87zwsPve4e5PDq1evwtfXV3IaIiIiKgqj0YjQ0FCrmxUXhsXnHncPb/n6+rL4EBEROZiiDFPh4GYiIiJSDRYfIiIiUg0WHyIiIlINFh8iIiJSDRYfIiIiUg2HKj5xcXF49dVXERAQAA8PD9SrVw8HDx60PC+EwHvvvYdy5crBw8MDkZGROHv2rMTEREREZE8cpvikpqaidevW0Gq12Lx5M/7++2/MnDkTZcqUscwzbdo0zJ49G/PmzcO+ffvg5eWFqKgoZGVlSUxORERE9kIRQgjZIYpiwoQJ+P333/Hbb78V+LwQAuXLl8eYMWMwduxYAIDBYEBwcDAWLlyIF1988YHrMBqN0Ov1MBgMvI4PERGRgyjO97fD7PHZsGEDmjRpgl69eiEoKAiNGjXCggULLM9fvHgRCQkJiIyMtEzT6/Vo3rw5YmNjC1ymyWSC0Wi0+iEiIiLn5TBXbr5w4QLmzp2L0aNH45133sGBAwcwYsQIuLm5oV+/fkhISAAABAcHW70uODjY8tw/TZ06FR988EGpZyf1uJVpwpx1e/DLkXMwZedC66rBbVMOTDl5AAB3N1f06RCBoc+2kpyUiEidHOZQl5ubG5o0aYK9e/dapo0YMQIHDhxAbGws9u7di9atWyM+Ph7lypWzzNO7d28oioLly5fnW6bJZILJZLI8vnuvDx7qUqdryWn4bvN+3Lx1G1XKBWBg52bQurhg+a4jiE8xoEJZPVrXDYfW1QXl/H2QeisT2Tl5SE2/jR1HzuFKYip2H7sAcxH+SVUrH4BnmtfGleQ0VAjQ46X2DeHuprXBuyQicj7FOdTlMHt8ypUrh9q1a1tNq1WrFlavXg0ACAkJAQAkJiZaFZ/ExEQ0bNiwwGXqdDrodLrSCUwOIzfXjMGfr8SR8/GWab8dv4hFPx/MN++sNQWPMSuuc/E38Pna/y3ryw170OvxBpjwYvsSWT4RERXMYcb4tG7dGqdPn7aadubMGYSFhQEAwsPDERISgh07dlieNxqN2LdvH1q2bGnTrORY/ll6ZBACWLH7KD5d9ovUHEREzs5his+oUaPwxx9/YMqUKTh37hyWLl2Kb775BtHR0QDu3JF15MiR+Oijj7BhwwYcP34cffv2Rfny5dG9e3e54clu/Xb8gvTSc68Vvx5FVnaO7BhERE7LYQ51NW3aFGvXrsXEiRPx4YcfIjw8HJ9//jleeeUVyzxvv/02MjIyMHjwYKSlpaFNmzbYsmUL3N3dJSYne3QlKRV9P/0RxtumB89sQ0IAc9buwbgXnpQdhYjIKTnM4GZb4HV8nFNGpglzN8Xi12MXIIRA4+oVsfGPv2XHuq9AX090aVEbFQP90LRGKEID/WRHIiKyW045uJnoYWw7dAYTvv0P7m33cTfsu/QAQLLxNhbeM7i6nL8v5o/sgYosQEREj4TFh5zWpYSbGP/tf2THKBHXbxrx7Hsx8NRp0fPx+hjRvQ00GocZokdEZDf4m5Oc1r8WbpYdocTdNuXg/7YdwnPvL4Qph4OgiYiKi8WHnFJOXh5OXk6SHaPUXE024IlRX2Px9oPgMD0ioqJj8SGns2znn2g94ks4ex3IzjNj1urf0H3yQpiyc2XHISJyCCw+5FR+2HEI01bsQq7ZLDuKzVxNTsPTkxbAlMPyQ0T0IBzcTA7vUsJNnItPQZDeC7NW/yo7jhSpt7LwwoeL4a/3RHAZb4zp1Q5lfb1kxyIisjssPuSwfjt+AR/+sA03jLdlR7ELV1LScCUlDQCw9eAZ1KwUhB/Gv8Szv4iI7sHfiOSQdh49h7e+Xs/Scx+nriThhY9+kB2DiMiusPiQwxFCYPLCrbJjOITz12/gzLVk2TGIiOwGiw85nP2nruBWVrbsGA5j5spdsiMQEdkNFh9yOMcvXpcdwaEcOHMNa/Yckx2DiMgusPiQwzHcypIdweF8tGQH9v51SXYMIiLpWHzIoQghsOGPv2THcEhvL9gkOwIRkXQsPuQwMk05mPDtf5CeyfE9D+O2KYe3tyAi1WPxIYeQYriFyPHzse3wWdlRHNqUH3ew/BCRqrH4kEN4bcYKZJp4N/JHtfq34/hs1W7ZMYiIpOGVm8nunYtLwbUUg+wYTmPJL3/i+KUEvPBEA3RuVkt2HCIim+IeH7J7P+0/KTuC0zl24TomxWzBk2PnIjE1XXYcIiKbYfEhu5dn5piU0mLIyMILHy2GWUV3sycidWPxIbv3VMRjsiM4NeNtE9bv/Vt2DCIim2DxIbtXo2IgfDzcZMdwaqt+Oyo7AhGRTXBwM9mt7JxcTPx+M3YfPQ8zT8EuVVnZubIjEBHZBIsP2aWcvDz0+PD/EMezuWwiNNBPdgQiIpvgoS6yS99v2c/SY0Mjn28rOwIRkU2w+JBdWrGLY05s5ZkWtVA5xF92DCIim+ChLrJLhgzegd0WBndpgSHPtJQdg4jIZrjHh+ySqws/mrYQzj09RKQy/HYhu9S0RqjsCKrwxdrfZEcgIrIpFh+yS2+/8CQURXYK55dwMx23Mk2yYxAR2QyLD9ml0EA/vN+no+wYqmDK4TV8iEg9WHzIblXktWVKnYtGA72Xh+wYREQ2w+JDdkvv5S47gtOrGx7MgeREpCr8jUd2KyyojOwITs/HXSc7AhGRTbH4kN3i/blKX66Z25iI1IXFh+zWlaRU2RGcXq3QQNkRiIhsisWH7NaQL1bLjuD02jWsJjsCEZFNsfiQXTpyLg43jLdlx3B6If4+siMQEdkUiw/ZpR1HzsqO4PQ83FwRqPeWHYOIyKZYfMguuWpcZEdwejUqBcmOQERkcyw+ZJeebVlbdgSnN5lXxiYiFWLxIbsUXi6A1/EpRfXCQ7h9iUiVWHzIbsWM6w0fD15grzR8NKCz7AhERFKw+JDd8vP2xLZP38DrTzdHWb0X3N1cZUdyCrXDghDK+6ARkUopQvDyuHcZjUbo9XoYDAb4+vrKjkMFeGr8fJ7m/ggUBdjw4WuoUFYvOwoRUYkpzvc39/iQQ/Fw08qO4NBa1Apj6SEiVWPxIYfSsGoF2REcWpPHKsqOQEQkFYsPOZS+T0XIjuCwFEVBjzb1ZccgIpKKxYccSrUKZTH0mZayYzikkc+3ha+Xu+wYRERSsfiQwxnUpQXa1guXHcOhlA/wRZ9I7i0jImLxIYf0736d4OrCj29RdYx4THYEIiK7wG8Ocki+Xu6Y/1ZPKIrsJPZPUcC9PURE/8XiQw6rUfUKqBsWIjuG3RvyTEuU8fGUHYOIyC7wUrjk0Lw9eUuLwrhoFIzu+QRebNdQdhQiIrvB4kMO7eX2jRD792XZMexORPWKmDHkGeg9PWRHISKyKyw+5NBa1wlHsJ83EtNuyY5iFxQFWDO5P8KCeed1IqKCOOwYn08++QSKomDkyJGWaVlZWYiOjkZAQAC8vb3Ro0cPJCYmygtJNrF00isI1HvJjmEXhAD+PHdNdgwiIrvlkMXnwIEDmD9/PurXt74K7ahRo7Bx40asXLkSu3fvRnx8PJ5//nlJKclWynh7YsvUQZg+6Bk0qFJOdhzp4lKMsiMQEdkthys+t27dwiuvvIIFCxagTJn/7c43GAz47rvv8Nlnn6F9+/aIiIhATEwM9u7diz/++ENiYrIFRVHQoXF1xIx7Efu/HIEaoYGyI0lTpZy/7AhERHbL4YpPdHQ0unTpgsjISKvphw4dQk5OjtX0mjVrolKlSoiNjbV1TJLI1cUFP77zKnZ8+obsKDandXVBp6Y1ZccgIrJbDjW4edmyZTh8+DAOHDiQ77mEhAS4ubnBz8/PanpwcDASEhIKXJ7JZILJZLI8Nhp5iMCZlPH1RI829bB6z3HZUWzmzW6tofCqjkREhXKYPT5Xr17FW2+9hSVLlsDdvWRutDh16lTo9XrLT2hoaIksl+zHpFci0fepCKe5vYW3hxu6taoDF431+9G6umDU8215hWYiogdQhBBCdoiiWLduHZ577jm4uLhYpuXl5UFRFGg0GmzduhWRkZFITU212usTFhaGkSNHYtSoUfmWWdAen9DQUBgMBvj6+pbq+yHbysszY/vhs0hIS4ebqwafrfoVeWaH+OgDuFN4hnRpia6t6sDHQ4e8PDM2/vE34m4YUCUkAFFNHoNG4xzljoiouIxGI/R6fZG+vx2m+KSnp+PyZesL1Q0YMAA1a9bE+PHjERoaisDAQPz444/o0aMHAOD06dOoWbMmYmNj0aJFiweuozgbjhxbctotDJixHPE37PfwpqIAIWV88dbzbdAxoobsOEREdqs4398OM8bHx8cHdevWtZrm5eWFgIAAy/SBAwdi9OjR8Pf3h6+vL4YPH46WLVsWqfSQugT6eWPTRwPx16UEfLx0B87EJcNsJ3uAmteshLlv9ZAdg4jIKTlM8SmKWbNmQaPRoEePHjCZTIiKisLXX38tOxbZsTqVQ7D0nVcAAGazGQCg0WgQn2LAjJW7sevYeZtlcdEo6NK8Nt7v29Fm6yQiUhuHOdRlCzzURf/03sIt2LTvZIkv11WjYOnEV+HhrsWhs9fg7aHDE/WqwMVJBmETEdmSUx7qIpLhw/6dUL9KOSz4aR+SDRkA7gw07tG2Hjo3qQl3Ny3Kl/XFwq0HELP1ADKzcy2vbVi1PGa+0RW5uWa8939bceH6Dbi5uqDX4/XxSmSE5cysCmX1Ut4bEZEacY/PPbjHh+4nN88MIQS0ri4FPm82C6Teug2NRgM/L3deT4eIyEa4x4eoFDzoWkAajYIAX94slYjInnFAAREREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYbDFJ+pU6eiadOm8PHxQVBQELp3747Tp09bzZOVlYXo6GgEBATA29sbPXr0QGJioqTEREREZG8cpvjs3r0b0dHR+OOPP7Bt2zbk5OSgY8eOyMjIsMwzatQobNy4EStXrsTu3bsRHx+P559/XmJqIiIisieKEELIDvEwkpOTERQUhN27d+Pxxx+HwWBAYGAgli5dip49ewIATp06hVq1aiE2NhYtWrR44DKNRiP0ej0MBgN8fX1L+y0QERFRCSjO97fD7PH5J4PBAADw9/cHABw6dAg5OTmIjIy0zFOzZk1UqlQJsbGxBS7DZDLBaDRa/RAREZHzcsjiYzabMXLkSLRu3Rp169YFACQkJMDNzQ1+fn5W8wYHByMhIaHA5UydOhV6vd7yExoaWtrRiYiISCKHLD7R0dE4ceIEli1b9kjLmThxIgwGg+Xn6tWrJZSQiIiI7JGr7ADF9eabb2LTpk349ddfUbFiRcv0kJAQZGdnIy0tzWqvT2JiIkJCQgpclk6ng06nK+3IREREZCccZo+PEAJvvvkm1q5di19++QXh4eFWz0dERECr1WLHjh2WaadPn8aVK1fQsmVLW8clIiIiO+Qwe3yio6OxdOlSrF+/Hj4+PpZxO3q9Hh4eHtDr9Rg4cCBGjx4Nf39/+Pr6Yvjw4WjZsmWRzugiIiIi5+cwp7MrilLg9JiYGPTv3x/AnQsYjhkzBj/++CNMJhOioqLw9ddfF3qo6594OjsREZHjKc73t8MUH1tg8SEiInI8qriODxEREVFxsfgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqsPgQERGRarD4EBERkWqw+BAREZFqFLv49OvXD7/++mtpZCEiIiIqVcUuPgaDAZGRkahevTqmTJmCuLi40shFREREVOKKXXzWrVuHuLg4DB06FMuXL0flypXRuXNnrFq1Cjk5OaWRkYiIiIooKcuA2OQz+PPmReSYc2XHsTuKEEI8ygIOHz6MmJgYfPvtt/D29sarr76KYcOGoXr16iWV0WaMRiP0ej0MBgN8fX1lxyEiIhXZdv0oPv1rA4y5mQAAvdYTo2s+jc4VGgMAMnKzMPPvTdh34yxcNS4YWrUjOlVsiLTsDNwwpSNXmDHxz6W4lnnTskwFCqJCGiDMqywuZCTB380L3UOboapPsJT3WFqK8/39SMXn+vXr+L//+z/ExMTg2rVr6NGjB+Li4rB7925MmzYNo0aNethFS8HiQ0REMgyMnYfjhisFPteoTGWEeQZiXdyBEltfhH84vmgyAG4a1xJbpkylWnxycnKwYcMGxMTE4Oeff0b9+vXx+uuv4+WXX7asbO3atXjttdeQmpr68O9CAhYfIiKylVxzHvKEGd+f24WYizttvv5q3sEYW7sr1lzdj0u3kuGr9UDHcg3QqXwDuLu42TzPoyjV4lO2bFmYzWa89NJLGDRoEBo2bJhvnrS0NDRq1AgXL14sVnDZWHyIiKi0bbx2EF+d2Yqb2RmyoxTIBRpEP9YRL4W3gYviGFe9KdXis3jxYvTq1Qvu7u6PFNIesfgQEVFpmnJiLdZdK7lDVqWpbWBNTGv8qkOUH5uN8XE2LD5ERFQSzGYzVl/dhwM3zkOrcUWP0GbQalwxcN882dGKxUvjhpfC26BRmXD467xRxTsIiqLIjpUPi89DYvEhIqJHtSvxL0w6sgw5Ik92lBKnQEGLstUxpeFL8HLVyY5jUZzvb/vff0VEROQgjqdextt/LnHK0gMAAgKxKWcQuePfSMh0rBOY7mLxISIiKiGf/r1BdgSbyBNmPLt7On5LOik7SrGx+BAREZWQM+nXZUewqTGHF+NXBys/LD5ERESPKE+Y8Vrs17JjSDHu8A84Y4yXHaPInOOSjURERJLkmvPQbfd0JJuMsqNIISDw6t4v4a/1wogandG5QiO7PPPrLu7xISIiegT/Pr5ataXnXjdzMvD+iVV460AM7PmEcRYfIiKih5SVm40t14/IjmFX/rh5Dh1/+QipJvu8MjWLDxER0UPIMedi+KEY2O++DXkMOZl46ffPYRZm2VHyYfEhIiJ6CEsu7sHR1MuyY9itm9kZ2BJ/RHaMfFh8iIiIiuFqxg1M+2s95p7dJjuK3Vt+OVZ2hHx4VhcREVER/ZZ0EuMO/wAzD3AVya2cLNkR8uEeHyIioiJIyTJizOHFLD3FcD0rFZm5JtkxrLD4EBERFcH8s9tlR3A4ucKMl/bMlh3DCosPERFREfyScEJ2BIcUn5WKYfu+tZtr+7D4EBERFcGtPPs6ZONIDqZeQO/fZsGQLf/aPiw+RERED5BrzoPg2J5Hcvl2Cp765WPsTvhbag4WHyIiovs4lnoZ7bZ/IDuG0xh35AekZMm7xQeLDxERUSHSsjPwxv4FyDbnyo7iVL44tVnaup2y+Hz11VeoXLky3N3d0bx5c+zfv192JCIickBfnt6CPDu87YKj25NyStq6na74LF++HKNHj8bkyZNx+PBhNGjQAFFRUUhKSpIdjYiIHMyvSfK+oJ1ZnllemXS64vPZZ59h0KBBGDBgAGrXro158+bB09MT33//vexoRETkYDJ5JlepqODpL23dTlV8srOzcejQIURGRlqmaTQaREZGIjY2//1CTCYTjEaj1Q8RERGVrrG1ukpbt1MVn5SUFOTl5SE4ONhqenBwMBISEvLNP3XqVOj1estPaGioraISEZGdyzbnwsRBzaXCw9VN2rqdqvgU18SJE2EwGCw/V69elR2JiIjshJmDmkvN1OPrpK3bqe7OXrZsWbi4uCAxMdFqemJiIkJCQvLNr9PpoNPpbBWPiIgcSEYOx/eUltO34pFrzoOrxsXm63aqPT5ubm6IiIjAjh07LNPMZjN27NiBli1bSkxGRESO5sPjq2RHcGobrh2Ssl6nKj4AMHr0aCxYsACLFi3CyZMnMXToUGRkZGDAgAGyoxERkQNIzjKi265piL1xVnYUp3Yi7YqU9TrVoS4AeOGFF5CcnIz33nsPCQkJaNiwIbZs2ZJvwDMREdE/Zeaa0Ou3z3A7L1t2FKf3n/g/0bVCBBoFhNt0vYqwl/vE2wGj0Qi9Xg+DwQBfX1/ZcYiIyMam/70BK6/8ITuGargqGuzo8N4jn+VVnO9vpzvURURE9LC2xh+VHUFVcoUZCy/ssuk6WXyIiIj+i4e4bO+XxL9suj4WHyIiov/ycNHKjqA6ueY8m66PxYeIiOi/nipXX3YE1anhW96m62PxISIi+q9XKreRHUF1RtToZNP1sfgQERH91/XMNNkRVOXZChEob+M7tbP4EBER/Vewu152BFV5o/pTNl8niw8REdF/hXkHwtfVQ3YMVWigD0Ogu+2vmcfiQ/kIYYbIOQZh+h0il3esJyJ1GfZYR9kRVEHrYvsblAJOeMsKKpg59wqQ8TWQlwy4VAS8h0PjUhZC5EFk/ABkrQVENqB4A7nxAJIsrxVuLaH4vgvFtZq8N0BEZCPPV2qO1OwMzD+3XXYUp3bKGC9lvSw+Tk6IPIjUQUD2HusnMn+E2bUpkHsEQM79F5K9HyKlB4RLFcB8HVC8AK+BUDxfgKLIaexERKVpYLX2eDGsFdrv+DcEeGen0mDr6/fcxUNdTsJszoM5LxnmvAyYTX/AnPUzzLnXIVKH5i89d+UewANLDwAgD0AmkPcXIG4C5qtA+vsQiXVhzipk2UREDs5L645BVTvIjuG0gj3kDCTnHh8HZ86NAwxjgJzDEtaeB6S9BrNrXUD/b2i0dSRkICIqPWHeZWVHcFoDq7aXsl4WHwdmzr0EpHRB0fbalKLcE8CN52CG7s5hMLcIKJ59oOhayM1FRPSI2gbVgpeLDhl5JtlRnEqEfxV0Kt9Qyrp5qMsBCfNNmNM+BFI6Q3rpsWK6cyjMtB0itS/MqSMhhFl2KCKih+buosWY2l1lx3AqLQKqY26z16Wtn3t8HIjZbAKSewHilOwoD/DfgYCmnyASt0C4NgU0OkBbF4pnbygutr0vCxHRo3imQmPoNK6YdHSZ7CgOTwMFMxq/KjkD2S1z7lWYjR/DnPYOzBkrgaTmDlB6/skM5O4Dsn8FMr6GSG4H8615skMRERXLU+XqQwNFdgyH1yGkHtxctFIzcI+PHTKbM4Gbr9wZO3NX1ip5gUrarc9gvr0K0LWH4tkdira27ERERA/k6arDrdws2TEcVh19Rfy7fm/ZMbjHxy7d6GZdepyR+QqQuRDiRneY00ZBiGzZiYiI7qtLhUayIzis8u5+iGk5DBqN/NohPwFZMWduA/IuyY5hW1n/gUgdJTsFEdF9DX+sE8poPWXHcDguUPB/rYbLjmHB4mNvMr6RnUCO7G0w394oOwURUaHcXLRY88RYNPALkx3FoTwZXAe+bvZz41cWH3uTd1F2AnmMY2A2xsBs5inwRGSfvFzdsaDFG5jfVN7p2I4mW8i5NUVhWHzsiNk4GxBG2THkuj0VSGpw5+KMRER2qlFAFTTwqyQ7hkOo6BkgO4IVFh87IEQOzMnPAre/lB3FTpiAlC68+CER2bX5zQajZdnqsmPYvYFVn5QdwQqLjx0QyU8BeY52fZ7SlgOR1Inlh4jslkajwRdNBkCn8MowhXk+tBl8tPYzvgdg8ZHOfGsxYI6XHcM+iUsQhn/JTkFEdF9l3X1lR7A7LtDglcptMKFOd9lR8mFNlUQIAWSuBm79W3YU+5a1CmaDK+AzCRqNTnYaIqJ8xtfuihGHFsmOYReeLd8EjQLC0DGkAbQu9lkxuMdHAiEEhPFfEMZ3ZEdxDJnLgKR6MN9eIzsJEVE+LQJroJZvBdkxpGsRUB3/qv88ulSIsNvSA7D4yGHaDmSulJ3C8RgnwJx9THYKIqJ8FrWKxlMh9VV5Ny9XRYPXqrTD7KYDZEcpEkUIIWSHsBdGoxF6vR4GgwG+vqVzzNacfQS4+SoA3qLhobg8Bk3gJtkpiIgKZBZmnDTEIz0nEzsSjmN93EHZkUqFh8YN3zYfDG83D4S4+0FR5Fa+4nx/2+++KCdkzj4K3HwBALvmQ8s7IzsBEVGhNIoGdfwqAgBaBFbH8bQruJCRJDlVyQr1DMA3zQYjwN1HdpSHwuJjS6mDwNJDRKQec5u9jqidU2THeGS1fSugaUA1PF2hIcK9g2XHeSQsPjZizlgCiDTZMZyCECYoCs/wIiL7V0bnjc8b98Oow4sc9r+9Ie56LGwVLTtGieHgZlu5NVt2AqchbvaRHYGIqMhaBdXAnqc+RO9KLRGo83GoAdCP+ZTDirajZccoURzcfI/SGtwszDchklqU2PIIQMAWaLRVZKcgIiq2xRd+xZwzW2THyOetx57GzqQTMGTfRll3Xwys+iSaBFSVHatIOLjZzgjD+7IjOB/ju0DAEtkpiIiKrU+Vx3HuVgI2xx+573wu0CAPpX/bnnCvIMxo3AehXgF4pUqbUl+fbCw+pcycGweY7K/ZO7ycwxAiB4qilZ2EiKjYPqjfG71CW2LOmc24nJECrcYFbQNr4qXKbeHu4ooAnTc0igYX05MQl3kT4V6BGH14MS4+5BliflpPNPALw21zNvzdvNAv/AlU9g6Cq8alhN+Z/eOhrnuUxqEuc+oowPSfElkW/YNbJDT+X8tOQURkM78lnsTMk5twM/sWtBoX5AkzbucVfl24UM8AfN3sdQS7622Y0vZ4qMtOCCEA01bZMZxX9naYc69A41pJdhIiIptoG1wLbYNrWR7fNKWj52+zcCs3K9+8gTpfLG71JjxdeRbsvXhWVykSt38AkCs7hnMzvC07ARGRNP46H2xt/w4GV4tEsE4Pb1cdKnj4Y1TNp7HxibdZegrAQ133KOlDXebEloC4UQLJqHBaaEL+kh2CiIgkKs73N/f4lCZhlJ1ABXJgvjlIdggiInIQLD6liWcc2Ub2bpizfpadgoiIHACLT2nSdZSdQD3Sv5CdgIiIHACLT2ny/UB2AvXIuyY7AREROQAWn9KU9afsBOqh8MoMRET0YCw+pcRszgaMr8uOoR5uzWQnICIiB8DiU1oME8Br+NiKAvi8IzsEERE5ABaf0sL7c9mOfiY0rqGyUxARkQNg8Sk13NtjG/7QeDwjOwQRETkIFh9ycDdlByAiIgfC4lNaNDz0Yiu86woRERUVi09p0X8qO4FKuEFRFNkhiIjIQbD4lBKNrgmAsrJjOD/3SNkJiIjIgbD4lCbv/rITODfFB/D9SHYKIiJyICw+pUjxfBmAm+wYzstnEjQab9kpiIjIgThE8bl06RIGDhyI8PBweHh4oGrVqpg8eTKys7Ot5jt27Bjatm0Ld3d3hIaGYtq0aZIS36FovAG/r6RmcGoZ38pOQEREDsYhbnB06tQpmM1mzJ8/H9WqVcOJEycwaNAgZGRkYMaMGQAAo9GIjh07IjIyEvPmzcPx48fx2muvwc/PD4MHD5aWXeP+BMxeI4CM2dIyOC3emJSIiIpJEQ56LvD06dMxd+5cXLhwAQAwd+5cTJo0CQkJCXBzu3N4acKECVi3bh1OnTpVpGUajUbo9XoYDAb4+vqWaF5zyiAgd3eJLpO8oAnhjWCJiNSuON/fDnGoqyAGgwH+/v6Wx7GxsXj88cctpQcAoqKicPr0aaSmpsqIaEXxnwHA/4HzUTHoWshOYDOmrGz8+MlazHpjPpZPX4dsU47sSEREDskhDnX907lz5zBnzhzLYS4ASEhIQHh4uNV8wcHBlufKlCmTbzkmkwkmk8ny2Gg0llJiQNHoIQK3AslNS20d6qIAPuNlh7CJL4d/hw1zt0KY/7dz9ruJS9Fz1DMYPL2vxGRERI5H6h6fCRMmQFGU+/788zBVXFwcOnXqhF69emHQoEGPtP6pU6dCr9dbfkJDS/dqyxoXfakuX1X0M6BxrSw7Ran7csR3WP/VFqvSAwDCLLBy5kYsGL8YSVdTsO3/duHwL8d4FWsiogeQOsYnOTkZN27cuO88VapUsRy+io+PR7t27dCiRQssXLgQGs3/elvfvn1hNBqxbt06y7SdO3eiffv2uHnzZpH3+ISGhpbKGJ+7zAmPlcpy1cMNKLsTGtdA2UFKnSkrG129X81Xeh7ksSZVMPzL15FhuI2yFQMQVqsiAODS31cRu+EgXF1d0P6Vtggol//fBBGRIyrOGB+ph7oCAwMRGFi0L7C4uDg8+eSTiIiIQExMjFXpAYCWLVti0qRJyMnJgVarBQBs27YNNWrUKLD0AIBOp4NOp3u0N1FsngBu23idTsRnrCpKjxACc978ttilBwDOHLyA4S3esTx2cdUAioK8nDzLtG/eXozweqH4Yu/HABTcSs2Aj7833D1t/e+BiMi2HOKsrri4OLRr1w5hYWFYtGgRXFxcLM+FhIQAuDPYuUaNGujYsSPGjx+PEydO4LXXXsOsWbOKfDp7aZ7VdZc5oTGAW6WybKeni4Ti9yUUxWHH5BfJsV//wuTnpuNWakapr0vjosCc979fATWbV8Prn7yCkPBg+Ab4wMPLvdQzEBE9quJ8fztE8Vm4cCEGDBhQ4HP3xj927Biio6Nx4MABlC1bFsOHD8f48UUfAGuT4pMYAYj0Ulm203KpCniPgOLeyWlvSLr5+x344cNVSLqSIjuKlcp1QzF6wRDUas5DtERkv5yu+NiKTYpPSlcg93SpLNsp+X4IjeeLslOUmNycXKyd/RN+XrQLpsxshNaogKyMLBzb/bfsaIVSFAWfbnsXjdrXkx2FiKhALD4PySbFJ2svkNa/VJbtjJTgo1AUD9kxSsTV03EY1mQ8sjJMD57ZzmjdXLHo3JcIrBggOwoRUT6quICho9K4twK0jWTHcBBeTlN68nLzEN10gkOWHgDIyc7FwDojcfkkbxNCRI6NxUcCxX8Z4N4N3PwP4P2G7ASP7M9fjuPDXjPxRsOxyLyVJTvOI8lMz8L7z03DlVPXkJpkkB2HiOih8FDXPWxxqOteQuRBmH4F0j8F8i6U+vocimsDKAErHHYwc0rcDUQ3m4Cb19NkRyk1lWpVwIivBqFBuzqyoxCRyvFQl4NQFBdo3J+EUnY94NZGdhw7oQO8x0JTdqXDlp6c7Bz0e2yEU5ceALhyMg5j27+P31bHyo5CRFRkLD52QFF0UMp8B2ibyY4ij/dEaELOQBNyHBrvol13yR4JIfDxS58jOzNbdhSbmfLyF8jNyZUdg4ioSFh87ISiKFD8FwMuajts4Af4b4LGu+DrNDmK7Ut/RVefV9HRpTd+X7tfdhybys3Jw6tVonFg6xHZUYiIHohjfO5h6zE+BTHnGf97B3c1/LX4QwneDUVx7NskfPfOEiz7ZJ3sGHahTLAeFaqXQ5/JvdG4A6/7Q0S2wTE+Dkzj4guU+RFO/1ej6+IUpefamXiWnnukJhpwYs8pjH/qQwxvMZGHwIjI7jj5t6tj0ugaQwn+G/B6A1DKyo5TwtyAwL3QlJnl8KXndvptRDebIDuG3Tq1/xw+fulz2TGIiKyw+NgpRdFA4zMGmuC9gC5SdpwSogCBv0Lj4vhl7sb1m3ih3GDcNmbKjmLXfl+7HxmG0r/ZKhFRUbH4OADF7yvAvQcc/q/LcwA0Lv6yUzyyqa9+gRcrvIGs2455FWZbEkJgj8oGexORfXPwb1J1UBQFGr+pQNBRwPffDnj4SwE8XobiM152kEc2b8wi/LJ0j+wYDiXxcrLsCEREFjyr6x72cFZXUZjNt4CUzoA5UXaU/JQQwH8FcHsBYE4CXMMAz8F3Bm07gShtb5jz+E+mOMoE6bH06jy4al1lRyEiJ8WzupycRuMNJfDXO3t/XKrd2QPkUh1QQm2cxOWeP7sD3uOgBO2GRhsCjf5daMrMgcZnrFOUnsyMTAxpPI6l5yGkJhkwrsOHMNwwyo5CRMQ9PvdylD0+hRFCQCRFAOJWwTO4dYOiHwuYkyCEB5A2AjCfe7iVeQ6FxnfUw4d1IDnZOXg1fJjT34KitLm5a7HgxGcoXyVEdhQicjLc46NSiqJACToEuHeH1d4YxRfwnQ2N/3QoLsFQtPWgcasGJfA/gOZ+X0LeAP55yrkb4D1BNaUHABZNXsHSUwKys3Iw5onJsmMQkcrxoLuTURQFit80ANOKNK8ouwswvAmYduB/V4tWALe2gN9caDRamHPOA7l/A66PQaOtUYrp7dNPC7bJjuA0UuJu4tSBc6jZtJrsKESkUiw+KqfRaIAyX985TJZ7CUAe4BIOjeZ/e4w02qqAtqq0jDJlm7KRfpPXoSlJs4ctwNcHPpUdg4hUioe6CMB/T5nXhkOjrWZVetTu075fyo7gdM4euoCU+JuyYxCRSrH4EBXCbDZjz5p9smM4paUfr5EdgYhUisWHqBCGlHSY88yyYzilSyeuyI5ARCrF4kNUCK0bh8CVFi+9p+wIRKRSLD5EhfD284Iry0+pcNW6IC8vT3YMIlIhFh+iQvy19xRys3Nlx3BKe9bux7cTlsiOQUQqxOJDVAh+MZeutV/8hLRkg+wYRKQyLD5EhTh14CFv50FFkpebh9gNB2XHICKVYfEhKkSuiYe5StuSj1cjIz1TdgwiUhEWH6IC8N69tpF4KRl9q0Yj25QjOwoRqQSLD1EBEi8ny46gGsaUdMwf+3+yYxCRSrD4EJF0Oxbvlh2BiFSCxYeoAIGhAVA0iuwYqnH7VpbsCESkEiw+RAVwcXFB6+7NZMdQDRdX3hiXiGyDxYeoEB7e7rIjqEaDJ2rLjkBEKsHiQ1SI3Sv3yo6gCopGQfTs12THICKVYPEhKsCVU3HIzuQp1qXN1c0VU36ahNAaFWRHISKV4B0YiQpw83qq7AhOTeOqweBpffDciKeh0fD/X0RkOyw+RAUIrx8mO4JTC6wYgB4jn5Edg4hUiP/VIiqAPsAH5auHyI7htF54u7vsCESkUiw+RIV4f/U42RGcVq0W1WVHICKVYvEhKkR43UooX417fUrDnzuOy45ARCrF4kN0H7x6c+kIqOAvOwIRqRSLD9F91GxaTXYEp9SudyvZEYhIpVh8iO5j8PQ+siM4HUWj8BR2IpKGv32I7sM/pAzqtK4hO4ZTEWYhOwIRqRiLD9EDfLxpouwITkVROG6KiORh8SF6AC+9F5p3aSw7htN4rEkV2RGISMVYfIiK4IN1b8O3rI/sGE5hzHfDZEcgIhVj8SEqAhcXF3Qb1kl2DMemAO8sfQvhdSvJTkJEKsbiQ1REnQa2lx3B4Xj6eiCoUll0H/E0fspciidfbCM7EhGpHG9SSlREQaFlEdW/HbYu3CU7isNYcyMGLi4usmMQEVlwjw9RMYz+dii6Du0oO4ZD0Oq0LD1EZHdYfIiKQaPRYMRXg7DmZgy0Ou4wvZ9yVYJkRyAiyofFh+gh+Ph5Y/n1BSw/9xHV/0nZEYiI8mHxIXpIPn7emLZ9suwYdsndS4ceo5+RHYOIKB8WH6JHULd1TejL+sqOYVc8vN3x9cFPOb6HiOwS99MTPaK83DzZEeyCi6sGQ2cNQNehHXkTUiKyWw7328lkMqFhw4ZQFAVHjhyxeu7YsWNo27Yt3N3dERoaimnTpskJSaripfeUHcEujP+/4egW3Ymlh4jsmsP9hnr77bdRvnz5fNONRiM6duyIsLAwHDp0CNOnT8f777+Pb775RkJKUpPOr3eQHUG650c9w4sTEpFDcKjis3nzZvz888+YMWNGvueWLFmC7OxsfP/996hTpw5efPFFjBgxAp999pmEpKQmvd9+Ft5lvGTHsDlFUVCnVQ0sOP4Zhs7sJzsOEVGROEzxSUxMxKBBg7B48WJ4euY/tBAbG4vHH38cbm5ulmlRUVE4ffo0UlNTC1ymyWSC0Wi0+iEqLq1Wi+9PfoGQcHVdt2Z27Mf4fM9HqFwnVHYUIqIic4jiI4RA//79MWTIEDRp0qTAeRISEhAcHGw17e7jhISEAl8zdepU6PV6y09oKH+B08MpE6TH4vNf4asDn8IvyPnP8hryWT/UbFZddgwiomKTWnwmTJgARVHu+3Pq1CnMmTMH6enpmDhxYomuf+LEiTAYDJafq1evlujySX0ei6iCFde/Re9xz8LT18My/d4/OyIvP0+UCfZDq25NsejcHPQYyWv0EJFjUoQQQtbKk5OTcePGjfvOU6VKFfTu3RsbN26EoiiW6Xl5eXBxccErr7yCRYsWoW/fvjAajVi3bp1lnp07d6J9+/a4efMmypQp88A8RqMRer0eBoMBvr7O/792Kn1msxnAnVtdrJi+HgvG/yA5UfGEhAfhy/1ToQ/gvwcisl/F+f6WWnyK6sqVK1bjb+Lj4xEVFYVVq1ahefPmqFixIubOnYtJkyYhMTERWq0WAPDOO+9gzZo1OHXqVJHWw+JDpe30wfNY8PZi/LX3NHKzc2XHKVBozfLo2L8dug6JgpcvT9UnIvvndMXnny5duoTw8HD8+eefaNiwIQDAYDCgRo0a6NixI8aPH48TJ07gtddew6xZszB48OAiLZfFh2zlliEDz5XpLzuGFRdXDf69YQKadmokOwoRUbEU5/vbaa7crNfr8fPPPyM6OhoREREoW7Ys3nvvvSKXHiJb8tZ7wdPHA7fTM2VHgYurC8bFDEP7l9taHU4mInJGDrnHp7Rwjw/Z0vf/+hE/TllT6PMaFwUxp77A9QtJOH/0Mr6buATmPHORl68owLurx2LuWzFIvlr4WLqPf5qIZp0aFys7EZE9cfpDXaWFxYds7Z2np+DAlj/zTVc0Ct5fOw6tuja1TMvNycWPn6zFnztOwMVFgyr1wxC78QCuX0jK9/omUQ3xxoy+qFwnFGazGR/0mIG96w9YzePupcP4xSPQpnuzkn9jREQ2xOLzkFh8SIbf1+3HosnLkXApCa5aF0Q81QBvzOiLshUCHvhaIQT+2nsaSVdSoHVzRYXq5VC2oj98/X3yzZt124TN326HISUdtVvWQLPOHMtDRM6BxechsfgQERE5nuJ8fzvElZuJiIiISgKLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqYar7AD25O7dO4xGo+QkREREVFR3v7eLchcuFp97pKenAwBCQ0MlJyEiIqLiSk9Ph16vv+88vEnpPcxmM+Lj4+Hj4wNFUWTHsTAajQgNDcXVq1d589QSwO1Zsrg9Sxa3Z8ni9ixZ9ro9hRBIT09H+fLlodHcfxQP9/jcQ6PRoGLFirJjFMrX19euPmiOjtuzZHF7lixuz5LF7Vmy7HF7PmhPz10c3ExERESqweJDREREqsHi4wB0Oh0mT54MnU4nO4pT4PYsWdyeJYvbs2Rxe5YsZ9ieHNxMREREqsE9PkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD4OwmQyoWHDhlAUBUeOHLF67tixY2jbti3c3d0RGhqKadOmyQlp5y5duoSBAwciPDwcHh4eqFq1KiZPnozs7Gyr+bg9i+6rr75C5cqV4e7ujubNm2P//v2yIzmEqVOnomnTpvDx8UFQUBC6d++O06dPW82TlZWF6OhoBAQEwNvbGz169EBiYqKkxI7lk08+gaIoGDlypGUat2fxxMXF4dVXX0VAQAA8PDxQr149HDx40PK8EALvvfceypUrBw8PD0RGRuLs2bMSExcdi4+DePvtt1G+fPl8041GIzp27IiwsDAcOnQI06dPx/vvv49vvvlGQkr7durUKZjNZsyfPx9//fUXZs2ahXnz5uGdd96xzMPtWXTLly/H6NGjMXnyZBw+fBgNGjRAVFQUkpKSZEeze7t370Z0dDT++OMPbNu2DTk5OejYsSMyMjIs84waNQobN27EypUrsXv3bsTHx+P555+XmNoxHDhwAPPnz0f9+vWtpnN7Fl1qaipat24NrVaLzZs34++//8bMmTNRpkwZyzzTpk3D7NmzMW/ePOzbtw9eXl6IiopCVlaWxORFJMju/fTTT6JmzZrir7/+EgDEn3/+aXnu66+/FmXKlBEmk8kybfz48aJGjRoSkjqeadOmifDwcMtjbs+ia9asmYiOjrY8zsvLE+XLlxdTp06VmMoxJSUlCQBi9+7dQggh0tLShFarFStXrrTMc/LkSQFAxMbGyopp99LT00X16tXFtm3bxBNPPCHeeustIQS3Z3GNHz9etGnTptDnzWazCAkJEdOnT7dMS0tLEzqdTvz444+2iPhIuMfHziUmJmLQoEFYvHgxPD098z0fGxuLxx9/HG5ubpZpUVFROH36NFJTU20Z1SEZDAb4+/tbHnN7Fk12djYOHTqEyMhIyzSNRoPIyEjExsZKTOaYDAYDAFg+i4cOHUJOTo7V9q1ZsyYqVarE7Xsf0dHR6NKli9V2A7g9i2vDhg1o0qQJevXqhaCgIDRq1AgLFiywPH/x4kUkJCRYbU+9Xo/mzZs7xPZk8bFjQgj0798fQ4YMQZMmTQqcJyEhAcHBwVbT7j5OSEgo9YyO7Ny5c5gzZw7eeOMNyzRuz6JJSUlBXl5egduK26l4zGYzRo4cidatW6Nu3boA7nzW3Nzc4OfnZzUvt2/hli1bhsOHD2Pq1Kn5nuP2LJ4LFy5g7ty5qF69OrZu3YqhQ4dixIgRWLRoEYD//S501H//LD4STJgwAYqi3Pfn1KlTmDNnDtLT0zFx4kTZke1aUbfnveLi4tCpUyf06tULgwYNkpSc6M5eihMnTmDZsmWyozisq1ev4q233sKSJUvg7u4uO47DM5vNaNy4MaZMmYJGjRph8ODBGDRoEObNmyc7WolwlR1AjcaMGYP+/fvfd54qVargl19+QWxsbL57ojRp0gSvvPIKFi1ahJCQkHxnJtx9HBISUqK57VVRt+dd8fHxePLJJ9GqVat8g5a5PYumbNmycHFxKXBbcTsV3ZtvvolNmzbh119/RcWKFS3TQ0JCkJ2djbS0NKu9FNy+BTt06BCSkpLQuHFjy7S8vDz8+uuv+PLLL7F161Zuz2IoV64cateubTWtVq1aWL16NYD//S5MTExEuXLlLPMkJiaiYcOGNsv5sFh8JAgMDERgYOAD55s9ezY++ugjy+P4+HhERUVh+fLlaN68OQCgZcuWmDRpEnJycqDVagEA27ZtQ40aNaxG4Duzom5P4M6enieffBIRERGIiYmBRmO905Pbs2jc3NwQERGBHTt2oHv37gDu/C9xx44dePPNN+WGcwBCCAwfPhxr167Frl27EB4ebvV8REQEtFotduzYgR49egAATp8+jStXrqBly5YyItu1Dh064Pjx41bTBgwYgJo1a2L8+PEIDQ3l9iyG1q1b57u8wpkzZxAWFgYACA8PR0hICHbs2GEpOkajEfv27cPQoUNtHbf4ZI+upqK7ePFivrO60tLSRHBwsOjTp484ceKEWLZsmfD09BTz58+XF9ROXbt2TVSrVk106NBBXLt2TVy/ft3ycxe3Z9EtW7ZM6HQ6sXDhQvH333+LwYMHCz8/P5GQkCA7mt0bOnSo0Ov1YteuXVafw9u3b1vmGTJkiKhUqZL45ZdfxMGDB0XLli1Fy5YtJaZ2LPee1SUEt2dx7N+/X7i6uoqPP/5YnD17VixZskR4enqKH374wTLPJ598Ivz8/MT69evFsWPHRLdu3UR4eLjIzMyUmLxoWHwcSEHFRwghjh49Ktq0aSN0Op2oUKGC+OSTT+QEtHMxMTECQIE/9+L2LLo5c+aISpUqCTc3N9GsWTPxxx9/yI7kEAr7HMbExFjmyczMFMOGDRNlypQRnp6e4rnnnrMq6XR//yw+3J7Fs3HjRlG3bl2h0+lEzZo1xTfffGP1vNlsFu+++64IDg4WOp1OdOjQQZw+fVpS2uJRhBBCxp4mIiIiIlvjWV1ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+REREpBosPkRERKQaLD5ERESkGiw+ROTUkpOTERISgilTplim7d27F25ubtixY4fEZEQkA+/VRURO76effkL37t2xd+9e1KhRAw0bNkS3bt3w2WefyY5GRDbG4kNEqhAdHY3t27ejSZMmOH78OA4cOACdTic7FhHZGIsPEalCZmYm6tati6tXr+LQoUOoV6+e7EhEJAHH+BCRKpw/fx7x8fEwm824dOmS7DhEJAn3+BCR08vOzkazZs3QsGFD1KhRA59//jmOHz+OoKAg2dGIyMZYfIjI6Y0bNw6rVq3C0aNH4e3tjSeeeAJ6vR6bNm2SHY2IbIyHuojIqe3atQuff/45Fi9eDF9fX2g0GixevBi//fYb5s6dKzseEdkY9/gQERGRanCPDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqQaLDxEREakGiw8RERGpBosPERERqcb/AzJ0sogSJIg/AAAAAElFTkSuQmCC\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAHHCAYAAAC/R1LgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABTuklEQVR4nO3dd3QUZeM98Du72d30TS9AAqFFQpUoEEogEoi8gHQLgoAIgqAivCgI0iwgqIhIVUEsKNJtlIgQ9KVJ6L3XkARI2dRNsju/P/iyPwMJpO0+W+7nnD3HnZnM3IwhezPzzIwky7IMIiIiIgegEB2AiIiIyFJYfIiIiMhhsPgQERGRw2DxISIiIofB4kNEREQOg8WHiIiIHAaLDxERETkMFh8iIiJyGCw+RERE5DBYfIgc3LRp0yBJUoW+9uuvv4YkSbh06VLVhvqXS5cuQZIkfP3112bbxr+V9D3VqlUL3bp1e+jXSpKEadOmVWr7VbEOIiodiw+RjTp+/DgGDBiA6tWrQ6PRoFq1anj++edx/Phx0dHo/+zatQvTpk1DRkaG6ChE9H9YfIhs0Lp169C8eXNs27YNQ4YMwcKFCzF06FBs374dzZs3x/r168u8rsmTJyMvL69COQYOHIi8vDzUrFmzQl9vjSrzPeXl5WHy5Mmm97t27cL06dNZfIisiJPoAERUPufPn8fAgQNRu3Zt7Ny5E/7+/qZ5r7/+Otq1a4eBAwfiyJEjqF27dqnrycnJgZubG5ycnODkVLFfBUqlEkqlskJfa60q8z05OztXcRrLKCoqgtFohFqtFh2FyOx4xIfIxsyZMwe5ublYunRpsdIDAH5+fliyZAlycnIwe/Zs0/S743hOnDiB/v37w9vbG23bti0279/y8vLw2muvwc/PDx4eHnjqqadw/fr1+8afPGg8zN9//40WLVrA2dkZtWvXxjfffFNsG2lpafjvf/+Lxo0bw93dHZ6enujSpQsOHz5cof1SWFiI6dOno169enB2doavry/atm2L+Pj4YsudOnUKTz/9NPz9/eHi4oLw8HBMmjTpgd9TSVasWAEnJyeMHz/eNO3f+2fatGmmeWFhYZAkqcLjoa5fv44XX3wRgYGB0Gg0aNiwIZYtW1ZsmYKCAkyZMgWRkZHQarVwc3NDu3btsH379mLL3R0z9dFHH+HTTz9FnTp1oNFocOLECdPPwrlz5zB48GB4eXlBq9ViyJAhyM3NLXduImvEIz5ENuaXX35BrVq10K5duxLnR0dHo1atWvjtt9/um9evXz/Uq1cPH3zwAWRZLnUbgwcPxk8//YSBAweiVatWSEhIQNeuXcuc8dy5c+jbty+GDh2KQYMGYdmyZRg8eDAiIyPRsGFDAMCFCxewYcMG9OvXD2FhYUhJScGSJUvQvn17nDhxAtWqVSvz9oA7RWPmzJl46aWX0KJFC+h0Ouzfvx8HDhxAp06dAABHjhxBu3btoFKpMHz4cNSqVQvnz5/HL7/8gvfff7/M21q6dClGjBiBt99+G++9916Jy/Tu3RtnzpzBDz/8gLlz58LPzw8A7iurD5OSkoJWrVpBkiSMHj0a/v7+2LRpE4YOHQqdTocxY8YAAHQ6Hb788ks899xzGDZsGLKysvDVV18hLi4O+/btQ7NmzYqtd/ny5cjPz8fw4cOh0Wjg4+Njmvf0008jLCwMM2fOxIEDB/Dll18iICAAH374YbmyE1klmYhsRkZGhgxA7tGjxwOXe+qpp2QAsk6nk2VZlqdOnSoDkJ977rn7lr07767ExEQZgDxmzJhiyw0ePFgGIE+dOtU0bfny5TIA+eLFi6ZpNWvWlAHIO3fuNE1LTU2VNRqNPG7cONO0/Px82WAwFNvGxYsXZY1GI8+YMaPYNADy8uXLH/g9N23aVO7atesDl4mOjpY9PDzky5cvF5tuNBof+j3dXfe8efNkSZLkd999977137t/5syZc9+6HubedQwdOlQODg6Wb926VWy5Z599VtZqtXJubq4sy7JcVFQk6/X6Ysukp6fLgYGB8osvvmiadnd/enp6yqmpqcWWv/uz8O/lZVmWe/XqJfv6+pb5eyCyZjzVRWRDsrKyAAAeHh4PXO7ufJ1OV2z6iBEjHrqNzZs3AwBeeeWVYtNfffXVMueMiIgodkTK398f4eHhuHDhgmmaRqOBQnHnV5DBYMDt27fh7u6O8PBwHDhwoMzbusvLywvHjx/H2bNnS5x/8+ZN7Ny5Ey+++CJCQ0OLzSvr5fyzZ8/G66+/jg8//LDYIGZzkWUZa9euRffu3SHLMm7dumV6xcXFITMz07SvlEqlaYyO0WhEWloaioqK8Nhjj5W4P/v06VPq0ad7f07atWuH27dv3/fzRGSLeKqLyIbcLTR3C1BpSitIYWFhD93G5cuXoVAo7lu2bt26Zc55b7EAAG9vb6Snp5veG41GzJs3DwsXLsTFixdhMBhM83x9fcu8rbtmzJiBHj16oH79+mjUqBGefPJJDBw4EE2aNAEAU+lq1KhRudcNAAkJCfjtt9/w1ltvFRvXUxFpaWkoKCgwvXdxcYFWq71vuZs3byIjIwNLly7F0qVLS1xXamqq6b9XrFiBjz/+GKdOnUJhYaFpekn/3x/0s3Dv/z9vb28AQHp6Ojw9PUv9OiJbwCM+RDZEq9UiODgYR44ceeByR44cQfXq1e/7kHJxcTFnPJPSroqS/zWu6IMPPsDYsWMRHR2N7777Dlu2bEF8fDwaNmwIo9FY7m1GR0fj/PnzWLZsGRo1aoQvv/wSzZs3x5dfflnh7+PfGjZsiPDwcHz77be4ePFipdbVu3dvBAcHm16vv/56icvd3Q8DBgxAfHx8ia82bdoAAL777jsMHjwYderUwVdffYXNmzcjPj4eTzzxRIn780E/C2X5/0dkq3jEh8jGdOvWDV988QX+/vtv05VZ//bXX3/h0qVLePnllyu0/po1a8JoNOLixYuoV6+eafq5c+cqnLkka9asQUxMDL766qti0zMyMkwDgcvLx8cHQ4YMwZAhQ5CdnY3o6GhMmzYNL730kunS/mPHjlVo3X5+flizZg3atm2Ljh074u+//37oAOzSTqF9/PHHxY5+lbYef39/eHh4wGAwIDY29oHbWrNmDWrXro1169YV2+7UqVMf+HVEjoZHfIhszPjx4+Hi4oKXX34Zt2/fLjYvLS0NI0aMgKura4VPx8TFxQEAFi5cWGz6/PnzKxa4FEql8r4jCKtXr8b169crtL5794W7uzvq1q0LvV4P4E6JiI6OxrJly3DlypViy5b1SEaNGjXwxx9/IC8vD506dbpvm/dyc3MDgPtuYBgZGYnY2FjTKyIiosSvVyqV6NOnD9auXVtiYbt582axZe/9Xvbu3Yvdu3eX6XsjchQ84kNkY+rVq4cVK1bg+eefR+PGjTF06FCEhYXh0qVL+Oqrr3Dr1i388MMPqFOnToXWHxkZiT59+uDTTz/F7du3TZeznzlzBkDZBwI/TLdu3TBjxgwMGTIErVu3xtGjR/H9998/8KaLDxIREYEOHTogMjISPj4+2L9/P9asWYPRo0eblvnss8/Qtm1bNG/eHMOHDzftt99++w2HDh0q03bq1q2LrVu3okOHDoiLi8Off/5Z6riXyMhIAMCkSZPw7LPPQqVSoXv37qZCVBazZs3C9u3b0bJlSwwbNgwRERFIS0vDgQMH8McffyAtLQ3Anf25bt069OrVC127dsXFixexePFiREREIDs7u8zbI7J3LD5ENqhfv3545JFHMHPmTFPZ8fX1RUxMDN5+++0KD+C965tvvkFQUBB++OEHrF+/HrGxsVi1ahXCw8Or7O7Eb7/9NnJycrBy5UqsWrUKzZs3x2+//YYJEyZUaH2vvfYafv75Z2zduhV6vR41a9bEe++9V+zIV9OmTbFnzx688847WLRoEfLz81GzZk08/fTT5dpW48aNsWnTJsTGxqJ79+7YvHlziWNmHn/8cbz77rtYvHgxNm/ebDqFWJ7iExgYiH379mHGjBlYt24dFi5cCF9fXzRs2LDYfXUGDx6M5ORkLFmyBFu2bEFERAS+++47rF69Gjt27CjX90dkzySZo9WIqAwOHTqERx99FN999x2ef/550XGIiCqEY3yI6D4lPbT0008/hUKhQHR0tIBERERVg6e6iOg+s2fPRmJiImJiYuDk5IRNmzZh06ZNGD58OEJCQkTHIyKqMJ7qIqL7xMfHY/r06Thx4gSys7MRGhqKgQMHYtKkSRV+kjsRkTVg8SEiIiKHwTE+RERE5DBYfIiIiMhh8GT9PYxGI5KSkuDh4VFlN2ojIiIi85JlGVlZWahWrRoUitKP67D43CMpKYlXrRAREdmoq1evokaNGqXOZ/G5h4eHB4A7O66029ATERGRddHpdAgJCTF9jpeGxeced09veXp6svgQERHZmIcNU+HgZiIiInIYLD5ERETkMFh8iIiIyGGw+BAREZHDYPEhIiIih8HiQ0RERA6DxYeIiIgcBosPEREROQwWHyIiInIYvHMzEdmc3/acwCfrdiI9Kw8AoFEp0bdtE7zSow1cNCrB6YjImrH4EJFNGbt4I3YcvlBsmr7QgO+3H8Sm/aewbupgeLo5m+bl6Qvx+76T+G3vSdy4rYO3hwv6tG2C3u0aP/TW9kRkfyRZlmXRIayJTqeDVqtFZmYmn9VFZGXW/X0E732/7YHLRNQMxKs92iA9Ow9OSiXmb/gLV29m3recs9oJX7/5LOpX90d6Vi4+3/g/nLl2Cy4aJzzTvhmeeLQuixGRDSnr5zeLzz1YfIjEy8rNx7VbmXBRq1Az0BuSJGHH4fP479JfYDRW3a8shSShZ5tGWPf30fvm+Xi4YuXb/eGvdceWxNNYue0gsvP0CPLxxKin2qBhrcAqy0FElcfiU0EsPkSWdzMzGxdvpCFXX4ivNu3F8csppnmuGhWa162Gv49ftngurasGapUTbmbm3DevdUQtzB/dk0eFiKxEWT+/beaqrkWLFqFJkybw9PSEp6cnoqKisGnTJtP8/Px8jBo1Cr6+vnB3d0efPn2QkpLygDUSkWgHz15H3ISliJvwBUbMW4uxi38uVnoAIFdfKKT0AEBmrr7E0gMAu05cwozv4i2ciIgqy2aKT40aNTBr1iwkJiZi//79eOKJJ9CjRw8cP34cAPDGG2/gl19+werVq5GQkICkpCT07t1bcGoix6bLycfBc9dx7FIyCosMAACD0YidRy9g5KdrMPSTn0otFrbg190nkKcvqNLTb0RkXjZ9qsvHxwdz5sxB37594e/vj5UrV6Jv374AgFOnTqFBgwbYvXs3WrVqVeZ18lQXUeVl5ebjw5924Pe9J03T1ColurdsgH9OX8OVmxniwpmBJAHRjWtjcOfH0bRONdFxiBxSWT+/bfJydoPBgNWrVyMnJwdRUVFITExEYWEhYmNjTcs88sgjCA0NfWjx0ev10Ov1pvc6nc6s2YnsXW5+AXpNXYG07Nxi0wsKDVj79zFBqcxLloGEIxeQcOQCWoSHYPzTHVCnmp/oWERUAps51QUAR48ehbu7OzQaDUaMGIH169cjIiICycnJUKvV8PLyKrZ8YGAgkpOTH7jOmTNnQqvVml4hISFm/A6I7N/EZb/fV3ocyb7TV9Hv3W/RffJX0BcUio5DRPewqeITHh6OQ4cOYe/evRg5ciQGDRqEEydOVGqdEydORGZmpul19erVKkpL5HgMBiP+OnpRdAyrcP22DnETv8CJy8k4fCEJupx80ZGICDZ2qkutVqNu3boAgMjISPzzzz+YN28ennnmGRQUFCAjI6PYUZ+UlBQEBQU9cJ0ajQYajcacsYkcxoKf/yc6glXR5eoxYNYPAABJkhDTtA4mPx8LL3cXwcmIHJdNHfG5l9FohF6vR2RkJFQqFbZt+/93dD19+jSuXLmCqKgogQmJHMuW/WdER7Basizjz0Pn8PS73yIrT//wLyAis7CZIz4TJ05Ely5dEBoaiqysLKxcuRI7duzAli1boNVqMXToUIwdOxY+Pj7w9PTEq6++iqioqHJd0UVEFWcwGpGczosDHuaWLgefrt2JdwZ0Eh2FyCHZTPFJTU3FCy+8gBs3bkCr1aJJkybYsmULOnW688tj7ty5UCgU6NOnD/R6PeLi4rBw4ULBqYns15XUdGw/dA430rIQGuCFmgHesN2bY1jW+v8dg5NSgVFPtSn2QFUiMj+bvo+POfA+PkQPlptfgMlfb8aOw+dFR7F5zmon/DzjRfhp3URHIbJ5dvfICiIST5ZljF3yC0tPFckvKMLAWSthMBpFRyFyGCw+RFRmB89dx75TV0THsCspGdloP3YhvvsjETwAT2R+LD5EVGZb9p8WHcEu5eoL8cnanfh4TYJp2u3MHCSl6WDk0SCiKmUzg5uJSLxM3oTPrFb+eRBFBiN+3XMCufo7d31WKiREN66ND4Z2gUalEpyQyPbxiA8Rlcnmf05hz8nLomPYvZ8SDptKDwAYjDK2Hz6P7pOXQV9YJDAZkX1g8SGih/py0168vWwTdLm88Z4ot3S5mPnDn6JjENk8Fh8ieqBLyWlY+PMu0TEIHGNFVBVYfIjogT5Zs1N0BPo/PNVFVHksPkRUqtz8Qvx9nE9bJyL7weJDRKVa8htPcVmT0AAv0RGIbB6LDxGVKCdfj9/3nRIdg/7l9V7tREcgsnm8jw8RFSPLMt784lf8efAceB9h6/FK9yjENKsrOgaRzWPxIaJiRs9fj928X49VaVo7GC/9p5XoGER2gae6iMjkUvJtlh4rdPjCDew/c1V0DCK7wOJDRCafrf9bdAQqxawfefNCoqrA4kNEAO4MZt5/5proGFSK67d0oiMQ2QWO8SFycFdSMzDhy99w6mqq6Cj0AEqlJDoCkV1g8SFyYJeT09HvvW9QZDCKjkIP0aZBLdERiOwCT3URObBxS35m6bERw7ryqi6iqsDiQ+Sgbmfl4kJymugYVAYqpQKerhrRMYjsAosPkYM6eTlZdAQqo0KDEV3e/hIb/ndUdBQim8fiQ+SgvNxcREegcpABzPjuD5y6kiI6CpFNY/EhclANawVBo1KKjkHl9NkG3muJqDJYfIgclCRJeP6J5qJjUDkl8l5LRJXC4kPkwLq2bCA6ApWTQeajY4kqg8WHyIHN/mmH6AhUTgFe7qIjENk0Fh8iB3YlNV10BCqn5LQsLN+8T3QMIpvF4kPkwNyc1aIjUAXM3/g/xB84IzoGkU1i8SFyYCO6RYmOQBU0b91fkDneh6jcWHyIHNgTj9aDhwvvCGyLkm7rcCONT2wnKi8WHyIH9/O7Q6BU8Mnftig3v1B0BCKbw+JD5OC0bi68i7MNUiokBPt6io5BZHNYfIgIRo4VsTmdIutzcDpRBbD4EBHq1/AXHYHKwcvdBf/t20F0DCKbxOJDRBjapYXoCFRGMc3qYO3UQfDxdBUdhcgmsfgQESLr1cBTrSJEx6AymDOsO7zdOSaLqKJYfIgIkiRh6gud0btNI9FR6AGUCgkKXoFHVCksPkQE4E75adc4THQMeoAW4aGiIxDZPBYfIjLZdeKy6AhUCieFApOe7yg6BpHNcxIdgIisR35BkegIVAI/T1csfK03qvlqRUchsnksPkRkUjPQS3QEusdXb/TDo/VriI5BZDd4qouITGKbh4uOQPe4zudxEVUpFh8iMgkN8MJ/WjQQHYP+5VJKmugIRHbFZorPzJkz8fjjj8PDwwMBAQHo2bMnTp8+XWyZ/Px8jBo1Cr6+vnB3d0efPn2QkpIiKDGRbZoyIJblx4oE+/B5XERVyWaKT0JCAkaNGoU9e/YgPj4ehYWF6Ny5M3JyckzLvPHGG/jll1+wevVqJCQkICkpCb179xaYmsj2qFVOeG/IkwgL8hEdxeEpJAldHn9EdAwiuyLJsm0+nfDmzZsICAhAQkICoqOjkZmZCX9/f6xcuRJ9+/YFAJw6dQoNGjTA7t270apVqzKtV6fTQavVIjMzE56e/EuLHNeqHYfw4artomM4tAEdm2Ns3/aiYxDZhLJ+ftvMEZ97ZWZmAgB8fO78VZqYmIjCwkLExsaalnnkkUcQGhqK3bt3l7oevV4PnU5X7EVEQK82jaBRKUXHcFitI2rijT7RomMQ2R2bLD5GoxFjxoxBmzZt0KjRnVvsJycnQ61Ww8vLq9iygYGBSE5OLnVdM2fOhFarNb1CQkLMGZ3IZqhVTlj6Rj/RMRxW3+imkCQ+noKoqtlk8Rk1ahSOHTuGH3/8sdLrmjhxIjIzM02vq1evVkFCIvtQr7q/6AgOSalQIJL37iEyC5u7geHo0aPx66+/YufOnahR4///YggKCkJBQQEyMjKKHfVJSUlBUFBQqevTaDTQaDTmjExkszb/c0p0BIfUq20jeLjw9xKROdjMER9ZljF69GisX78ef/75J8LCij9MMTIyEiqVCtu2bTNNO336NK5cuYKoqChLxyWyCyev8HYQlta8bnW8+XSM6BhEdstmjviMGjUKK1euxMaNG+Hh4WEat6PVauHi4gKtVouhQ4di7Nix8PHxgaenJ1599VVERUWV+YouIirOw8VZdASH4emqwaT+segUWV90FCK7ZjNHfBYtWoTMzEx06NABwcHBpteqVatMy8ydOxfdunVDnz59EB0djaCgIKxbt05gaiLb9uTjfISFpfRq05ilh8gCbOaIT1luN+Ts7IwFCxZgwYIFFkhEZP/qVvdD49rBOHrhhugodi/E30t0BCKHYDNHfIhIjIWv9kZt3sXZrJQKCZ0i64mOQeQQWHyI6IHcnNVYPeUFLH2jL+rX8Iez2gnOaifUq+6HBqEBouPZhVe6t4aHK8dTEVmCzT6ywlz4yAqistMXFqH92IUoKDKIjmKTVE4KjOkVjeeeeFR0FCKbZ/ePrCAi8TQqJywZ00d0DJukUSmxfc5Ilh4iC2PxIaJKaVqnOiJq8pRXeaiUCnw5th9cndWioxA5HBYfIqq0t5/rCAWfK/VAGpUSnq4aPN2+KX59byga1goWHYnIIdnM5exEZL0iagZh4Wu9Mf6LX5GVqxcdx+pM6t8Rfdo1ER2DiMAjPkRURVo8Eopts0fgsXA+XPPfOjevx9JDZEVYfIioyjgpFZjwzBOiY1gFCUCgtwcmD+gkOgoR/QuLDxFVqdrBvmjVoKboGMLVqeaLL8f2gzufsk5kVTjGh4iq3LxXeuDNL39FwuELxaYrFRKclEroC4sEJTMvb3cXdGvZANFN6qB5veqQOOCbyOqw+BBRlVM5KTF3RA/czMjGhl3HcFuXg0dCAtGhaR08MX6x6HhVpnVETUx7oTP0hQYE+XhAqeBBdCJrx+JDRGbj7+WOYf9pZXp/4nKywDRVr/8TzeGndRcdg4jKgX+eEJHFeHu4io5QZQK93NG6YS3RMYionFh8iMhign08oVEpH7pcvWq+FkhTcX5aN6x8e4DoGERUASw+RGRRI7pFPXC+k0KB7yY+DzdnlYUSPVzLR0JRr7ofmtWphtnDumLLzGHw9nARHYuIKoBjfIjIogZ1fhw30rLwU8Lh++apnZRYNXkAVE5KfDLiKYz4dC3kUtajUTmZ/eowSQLeHfwk/tOigVm3Q0SWI8myXNrvFYdU1sfaE1HlZObk4f3vt+Hk1RSonZwwoGNz9GrbuNgyRy/ewPRvtuJCcpppWmiAFyb3j8Vj4SHIzivAp2sTsOvkZdzW5aKwyFCpTN7uLnBzVkOSgMfqh+D1Xu3g6eZcqXUSkWWU9fObxeceLD5E1udWZg5u63Lg4+EKf6+Sr6I6ffUmnvvgu1LXIUnAw37bffvWc2hYK6gyUYlIkLJ+fnOMDxFZPT+tG8JDAkotPQAQHuKPD1/qWuJT4lVKBRa91gdTBnRCabcUfPu5jiw9RA6AR3zuwSM+RLYtT1+Irzbvw96Tl6GQJHRoWgcDOkVCpbxzNdltXS4+W/8XEs9eAwA0q1MNb/SJhq+nm8jYRFRJPNVVQSw+REREtoenuoiIiIjuweJDREREDoPFh4iIiBwGiw8RERE5DBYfIiIichgsPkREROQwWHyIiIjIYbD4EBERkcNg8SEiIiKHweJDREREDoPFh4iIiBwGiw8RERE5DBYfIiIichgsPkREROQwWHyIiIjIYbD4EBERkcNg8SEiIiKHweJDREREDoPFh4iIiBwGiw8RERE5DBYfIiIichg2VXx27tyJ7t27o1q1apAkCRs2bCg2X5ZlTJkyBcHBwXBxcUFsbCzOnj0rJiwRERFZHZsqPjk5OWjatCkWLFhQ4vzZs2fjs88+w+LFi7F37164ubkhLi4O+fn5Fk5KRERE1shJdIDy6NKlC7p06VLiPFmW8emnn2Ly5Mno0aMHAOCbb75BYGAgNmzYgGeffdaSUYmIiMgK2dQRnwe5ePEikpOTERsba5qm1WrRsmVL7N69u9Sv0+v10Ol0xV5ERERkn+ym+CQnJwMAAgMDi00PDAw0zSvJzJkzodVqTa+QkBCz5iQiIiJx7Kb4VNTEiRORmZlpel29elV0JCIiIjITuyk+QUFBAICUlJRi01NSUkzzSqLRaODp6VnsRURERPbJbopPWFgYgoKCsG3bNtM0nU6HvXv3IioqSmAyIiIishY2dVVXdnY2zp07Z3p/8eJFHDp0CD4+PggNDcWYMWPw3nvvoV69eggLC8M777yDatWqoWfPnuJCExERkdWwqeKzf/9+xMTEmN6PHTsWADBo0CB8/fXXePPNN5GTk4Phw4cjIyMDbdu2xebNm+Hs7CwqMhERUYUVGQ34+kICVl3ehTxDAdyUGrxQOxruSmcc011FDRdf9K/VBiqlTX2cCyXJsiyLDmFNdDodtFotMjMzOd6HiIiEydDn4KmE2cg3Fj502ZiAhviw+fMWSGW9yvr5zYpIRERkRrIs46Zeh0KjAYHOWjgplCUu98eNo1h8Nh7Xcm/f+ToAMsp2bGJ76nG8+s9yzH98CADAKBux6fpB7L19Hm5OGvQJbYm6HsUv9MkvKsDskz8j/sZR6I2FkCChvkcwxjXoimY+YRX/hq0cj/jcg0d8iIioqqy9vAfzz2xGrqEAAOCsUOGZmlGI9KmDBWc2IykvHSqFEq4KNa7lp1d6e79Gv4UD6Rcw/dhaGGRjsXk1XH2wImoUPFQuyCnKR8+Ej5BZmFviet5p1Afda0RWOo8llfXzm8XnHiw+RERUFV7Y9TlO6ZJExyjGW+2GzTFv45V/vkJi2oVSl5MgISF2Kpyd1BZMVzll/fy2m8vZiYiIrMWcYxusrvQAQHpBDt488O0DSw9w5xTbknN/WCiVZXGMDxERUQXpDYXYmXoS13LT4KFyRoeACFzITsHqa/tERytVws1TZVruQNpFMycRg8WHiIioHPINBTiXlYL9t8/jmwsJyDboTfNmn/hZYLKqJYkOYCYsPkRERGVQaCzCkrN/YM2VPabByvbspC4Jy85tx5A6HSBJ9lODWHyIiIhKkFGQg0Vn4nFSdx1qSYlcgx7ns1PLfIm5rZMhY/G5eCgkCYPrdBAdp8qw+FCZXD19HV+9vRJXT12Hs6sGXYd3QtyLMVAqS74fBRGRLVt+fjsWnY0XHcMqLDq7FU/XbAVXJ/t4CgIvZ78HL2e/3yfDFmPTV9vum+7u5YbFB2cjsGaAgFREROaxOekQphz5SXQMq+IsOaFvzSgMrtMBnioX0XFKxPv4VBCLT3ErZ67D8kk/lDrf1dMFtZvWwtnE85BloH5kbQya/gyaxTSyYEoioqrTbfsspOp1omNYrbcinkKf0FYoMhpwW58FjVIFL7Wb6FgsPhXF4gNkpWdj/We/43/r9+HisSuQjeX/EXn2rZ4YOrP4c2MunbiKJeNW4MTuM5CNMmpG1MBLHw5A0/YNqyo6EVGl5BTmI2bbDNExrF59jyCcy0qB8f/GO9V09cPrj/wHbQMeEZaJxaeCHK34ZKVnY8eP/0PypZvw9PWAd6AWH7+0CEaD8eFf/BDdR3ZGaIMaeLRjYxzcdhQLXltW4nLdRnTC6wuHlzgv7UYarp65gaBa/jylRkRmJcsyBuz6HGezboiOYrMmRPRA79CWQrbN4lNB9lx8cjJzEP/NThz568SdCbKM/234p0pKTmW9OPM5XDx8BVnpOQhrHIom7SMwf/SXSL18y7SMd5AXRs17Ee37RQlMSkT2RJZlnNYlIU2fjTNZN7Dw7FbRkWxeC9+6aKStgQFh0XBXWW5ANItPBdlT8SkqKsKaj3/Br0vicft6GooKDaIjVYkxS15G12GxomMQkY3bknQYs49vRJYhX3QUuyQBGFa3I16q29Ei22PxqSB7KD45ulzMGbIA/1tvvbdMrwylSonf81ZCoeCj5oioYn65uh/vHl8nOoZDGN+gO/rVNP+Rej6k1EHdSkpD/5ARdlt6AMBQaMDPC7eIjkFENqrIaMAHJzaIjuEwFp3ZCms6xsIbGNoBWZZxcu9ZnE08j2+m/4TcrDzRkczu9L5zoiMQkY3acuMwDLL4sY2OItugx9msG6jvWU10FAAsPjbv0PajeO/ZT5F507HuOeHm5So6AhHZqO03jouO4HBu5GaglnsA1ArxtUN8AqqwI3+dwPjYGXCQx8YUI0kSUi7fRGBNf9FRiMiG3MzXYV86jxhb2vhD3wEAarn5462IHoj0rS0sC8f42KhVczZiXPupDll6AODnhVswsPYo/DRno+goRGQj9IZCvLB7AfINhaKjOKxLOTcx8p8vEX/jiLAMPOJjI9KS07Hx881IvnQTackZOPTnUdGRhLp776Ev3voOAaF+6PBMG8GJiMjabb5xGLf1WaJjEIBpR1ajQ2AEVAJOffFy9ntY2+XshiIDZg74DAk/7RIdxWopVUpoXNXQ+nriqVFPotdrXfjUeCK6z4D/zccZ3pXZatx95ldV4eXsduL9/p+y9DyEodCA3Mw83LiQgiXjVqB/6Ejk6HJFxyIiK6IrzENyXoboGPQvB9MvCdkui48VS76Uir/W7BEdw+ak3UjHuA5TRccgIisgyzI+P70Znba9C12R/d/qw5ZoFCoh22XxsVL5uXrMfH6e6Bg26/yhS7hw9JLoGEQk2KKz8fjm4k5HvQ7EqvUT9DBTFh8rdGLPaTzlORAndp8RHcWmjXpsAo7+dVJ0DCISJLswH99eSBAdg0oQ4uqLR7Q1hGybxcfKpCWnY0ybdyAb+fdJZRUVGjAuZiqunr4uOgoRCfBX6kkYeKzHKj1V/TFh22bxsTKTu8+yqmea2DrZKOPVVm9zsDORA7pdkC06ApViwdkt2HL9kJBt8z4+AuXn6rH310TcuJSK29fTcOzvUzh38KLoWHYnJzMXS8d/izeWvCw6ChFZ0N+pPNVtzaYfW4PO1ZpCkiSLbpfFR5AN8zfhiwnfoiCPdxC1hN+/+AOXjl/F02/2QOvuj1n8HxoRWdY3FxJwQNDl0lQ2RbIR8TeOonO1JhbdLk91CbBh/iYseH0ZS4+Fndh1GtN6zsZzIS8j6Xyy6DhEZCayLOOr89tFx6Ay2HrjsMW3yeJjIUVFRUi9egu3UzKwbNJK0XEc2u2k9DvjfjJzREchIjO4kZeBPEOB6BhUBs5Ky9/Lh6e6zCwtJQMfPDcXRxJOctCyFdHdzsKWr3eg9+tdRUchoirG0mM7+oZY/l4+POJjRmnJ6Xihzigc3nGCpccKxX/D+3sQ2SONgAdfUsWsvPw/i38+sviY0bRec6DP5V8e1irjlk50BCIyg9+TDoqOQGW0I/UEdt+y7M16WXzMJC9Xj5N7z4qOQQ+Qm5nLI3FEduimnn/U2JKfLu+26PZYfMzk0tHLoiPQQ+Tq8nB4x3HRMYioitV2DxQdgcrhfHaKRbfH4mMm7l5uoiNQGezauE90BCKqYr1CHhcdgcrBw8nZottj8TGTkPDqcHaz7P9MKr9fFsfjwhEenSOyJwqJH2225Kkaln1uF386zKjv2G6iI9BDFBUU4ZXH3sTtG2mioxBRFVGCd2a3FRIkdK3W3KLbZPExo0HTn8ET/duKjkEPYSgy4qMXF4mOQURVYNm57WgfP110DCojGTKu51n2D0/e7MDMfKv5iI5AZXAg/jCMRiMUCv4tQGSr5p36Hd9f+lt0DCqnW/osi27PLn/LL1iwALVq1YKzszNatmyJffvEDGDduXYPVn/0s5BtU/kYjTKSzvH5XUS2Kqcwn6XHRvk7e1p0e3ZXfFatWoWxY8di6tSpOHDgAJo2bYq4uDikpqZaPAufyWVbDEUG0RGIqIK+OL9NdASqACcoUN8j2KLbtLvi88knn2DYsGEYMmQIIiIisHjxYri6umLZsmUWzWE0GnH9zA2LbpMqTu2iRnCdINExiKiCLmRb/o9bqgISIEmWHYxe7uIzaNAg7Ny50xxZKq2goACJiYmIjY01TVMoFIiNjcXu3Za9MyTvCGxbqtcLgkrNIW9EtspLxXun2SKjgM/KchefzMxMxMbGol69evjggw9w/fp1c+SqkFu3bsFgMCAwsPhdOwMDA5GcXPL4Db1eD51OV+xVFc4mXqiS9ZBlXDxyBd/OWC06BhFV0KDa7UVHoAqQYQPFZ8OGDbh+/TpGjhyJVatWoVatWujSpQvWrFmDwsJCc2Q0q5kzZ0Kr1ZpeISEhVbLenxduqZL1kOWs+nAjCvS29zNMREAdj0A08KwuOgaVkwzggi08ssLf3x9jx47F4cOHsXfvXtStWxcDBw5EtWrV8MYbb+DsWTEP5/Tz84NSqURKSvGdmJKSgqCgksdvTJw4EZmZmabX1atXqyTLuYOXqmQ9ZDkF+QX4a80e0TGIqIK+aDkctdz8RcegcrqVb0OXs9+4cQPx8fGIj4+HUqnEf/7zHxw9ehQRERGYO3duVWUsM7VajcjISGzb9v9H9xuNRmzbtg1RUVElfo1Go4Gnp2exV1Vw9XSpkvWQZS0e9zWP+hDZKLVShZ/avYFX6nUSHYXKwVfjbtHtlbv4FBYWYu3atejWrRtq1qyJ1atXY8yYMUhKSsKKFSvwxx9/4KeffsKMGTPMkfehxo4diy+++AIrVqzAyZMnMXLkSOTk5GDIkCEWzRE7INqi26OqkZGqw99redSHyJa1D4gQHYHKKMw9ALXdAx++YBUq92UswcHBMBqNeO6557Bv3z40a9bsvmViYmLg5eVVBfHK75lnnsHNmzcxZcoUJCcno1mzZti8efN9A57NreOAdlg8bgX0uXqLbpcqR1JI2PXzP3iifzvRUYiogmq5B8BdqUG2gb9/rd24Bt2s/3L2uXPnIikpCQsWLCix9ACAl5cXLl68WNlsFTZ69GhcvnwZer0ee/fuRcuWLS2ewcXNGZNWvm7x7VLlyEYZ+twC0TGIqBIkScKo+nGiY9BDjKgbixa+dS2+3XIXn4EDB8LZ2dkcWexO1FOPwztYKzoGlYNCqUDtJjVFxyCiSupTsxUe86ktOgaVQgEJQ+rECNo2mVVgaIDoCFQesowuL3UUnYKIqsDHzV9AuIUfh0BlU8vV1+KnuO5i8TGjvJx8nNor5tJ+qpjR84ciqBbLKpE9cHFS85SXlQp08Ra2bd6j34z2/JIoOgKVUWiD6hg5dwge69xUdBQiqkJTj/CO7NaoY3BjYdvmER8zup2UJjoClVHqlVtQKPnPgcienMi4hvTCHNEx6B4qSYnOwU2EbZ+/6c2o/mMcWGcr8nP0eKvTDBzZeUJ0FCKqIofTL4mOQCVo6VcXzkq1sO2z+JhRk+iGPIpgYz4cOF90BCKqIp5qV9ERqASxQeKO9gAsPmbXqN0joiNQOaRevcVTlER2IiawIcRcN0Sl0Sic0DGokdAMLD5mdOqfsziacFJ0DCqna2eSREcgoirg6qRBXDAvWLAm0QENoFGqhGZg8TGjj4YshCzLomNQOfmH8unORPZiapN+eNynjugY9H+erPao6Ai8nN1c8nLycfnENdExqJzcvdxQrbZln+tGROajlBRY0GIoTmZew9Kz25Ccn4Hz2SmiYzkkNycN2gWIH/7BIz5mkp6SIToCVcAr84aIjkBEZtBAWwNzHxuEH9q+jhBXH9FxHI4ECZ80f0F0DAAsPmaj9fUQHYHK6aUPn0enge1FxyAiM5vYsJfoCA4lQlsD37YejUd9wkRHAcBTXWbjpnVDtTqBSDrPQ6rWzEmlRPdX4jB8zkA4OfGfA5EjeMy3Dp6qHomfr/Pu+uaigIQvW41AA211KCXrOsZiXWnszJjFw0VHoIeo+2gYXpk7hKWHyMFMbtwHs5r1h1rBf/tVzUPlgmWtRqCRV4jVlR6AxcesHu3YBFNWj4PaWeyle1S6nq/9R3QEIhLkiaBGeL/ps6Jj2AUXpRrNvGpiTrPn8ccTkxHhFSI6UqlYdc2sXZ9WaNOrBf747i8c3XkCLh7OOHfwIo7u5P19RFNpnNC+X5ToGEQkUBv/cPirPXCzIEt0FJvVwqcuPm/xougYZcbiYwEKhQKdX2iPzi/cGTh7fPdpjGkzWXAqWnxgDpxU/CdA5MicFEosbfUyBu9agMyiPNFxbFJmUa7oCOXCU10CHIg/IjqCw+s2ohNCG9QQHYOIrEB1Vx/8GjMB7zTqgzA3f7gp1XzURTn4qtxFRygX/rkrwOblf4qO4NDihsTgtQXDRMcgIiuiUarQvUYkuteIBACsuJCABWe2CE5lG3qFthAdoVx4xEeArLRs0REcltbfE//96hVIEv+eI6LS9ajxOLQqPt39YZwVKqu4G3N5sPgIEFQrQHQEh9Xh6daiIxCRDfBSu+KLlsMR5KwVHcVqSZAw77HBUFjhJesPYltp7US3lzuLjuCwer7WRXQEIrIRtdwDsKH9eLzTqA9cFWrRcYRxggJxQU2h+NfIpzZ+9fFdG+u5G3N5SDIfH16MTqeDVqtFZmYmPD09zbINfZ4eb0RPwdnEC2ZZP5WsXmRtLPznQ9ExiMgGybKM/WkXcDDtIgAg0qc2Jh38AWlFOYKTmZe/xhMr27wGrdoVhcYiZBbmwd1JA2el9RXBsn5+s/jcwxLFBwBys/KwaOxybFm2Hfw/YH6unq5YcmgOTzMSUZU5n5WC/v+bB3v9Fb6x3X8R7GY7D3Rl8akgSxWfu7IzcnBo+zEc3nEcu37+B6mXb5l9m44mbnAHvPhBf/gEeYuOQkR25rwuGUP3LkGuQS86SpXqWq05pjbpKzpGubD4VJCli8+/HU44jv/GTLPoNu3d+79NRIsuzUXHICI7llukx+zjG/H7jUOio1SJx33q4PPHX7S5q1/L+vnN+/hYkSbREWjY9hEc//uU6Ch2wc3LlaWHiMzO1UmDaU2fxtmsZJzNThYdp8y8VW541CcM13JvI6dIj0AXLV6p1wlNvGuJjmZWLD5WRJIkzNo8GTMHzMOuDf+IjmPzlE5K0RGIyIEsbfUynvlrLlL1uvvmeavcoFIoS5xnSSGuvni1fhxqugcgxNUXTgrH+z3J4mNlnF01mL7uTdy4kII9vyYi+XIq1s/7HbKRZyTLyzuA998gIstxc9Lg5w5vYsO1f/DDpV3ILMyB1skVz9Zqg94hd+5uvOXGYXx/6W/oCnPhpXJDNRdvHMu4ihR9plkyPRHYEM/Wao30glw01IYgwNmyQzisEcf43EPkGJ/SFBUWoYvzc7DbSwfMZPzXo9D5hQ6iYxARPdSGq/9g0dmtSC/4/5fH13UPxBOBjfBH8lFcyEl94Nd7OLkg618PWVVAQp/QlhjXoJvN3WCwojjGx444qZxQo14wrp25ITqKzahRPxixA6JFxyAiKpOeIY+jW/XmOJR+CVlF+aju4oP6nsEAgBdqR6NXwke4WZBV4teOrNsJA2tHY8+ts7iWexvuTs5oF9AAWjUfuVESx6iBdqBmwxDREaxK9XrBWHr4IwTW8i8+QwKad2yMxYc+gkLBH28ish1OCiUe862DmMCGptIDAGqlChvaj8fToa3grFCZpoe5+ePT5i9gSN0YOCmUaBvwCJ6t1QbdakSy9DwAT3XdwxpPdQHA3t8PYHK3maJjWAVJkvDxjulo3K4BAODyiav4Z/MhaFw16PBsa3h4uQtOSERElsZTXXbm8SebIbJTEyTGHxEdRShJIWHid6+bSg8A1IwIQc0IHhEjIqKH47kAG6FQKDB9w5vo+nInKJSO+7/tP8M6IubZNqJjEBGRjeIRHxuicdFgzKLhGPLuszj29ykYigyoVi8IS//7DQ5uOyY6nkU4OfFHloiIKo6fIjZI6+eJNj1bmN7Pjp+Ki8euYP/mQzi59wz+WrtXYDrziu4bJToCERHZMBYfOxHWKBRhjUIBAH98m4A5QxbAaGM3PVSqlDAUGkqd7+XviSbtIyyYiIiI7I3jDhaxY7ED2+OXnO/R/+3eaNQmHGpn1UO/JiDUzwLJStfx+Xb44ujHUGlK7uJOKiXm/DnNsqGIiMjusPjYKbVGhSHvPYe5f72Hd3+Z8NDlJ/04Bg3bPPLQ5ZSqij3XxSvAE4PffQa/56/EW9+8ipoNQxAUFoBW3SOx8upiTPj2NYTUr47vLy1Cuz6toHJWARKg0jihdY/H8e3FhajFexkREVEl8T4+97DW+/hU1nfvrcGKKatKnDdy7iD0fr0bbl67jWGNxyInM7fE5TSuaszfMxNKJyWGNx33wNNS9xr6QX88O6FXhbITERE9TFk/v1l87mGvxQcALp+8hi8nfI9jf50EJKBph4YY9dmL8K/ua1rm9o10LPnvCiT8tAtGw50fDVetC555sweem9AbkiQBAAwGA3au3o0VU1fh+tnkh2571Y0v4BPoZZbvi4iIiMWnguy5+JRHYUEhdLez4erpAhc35wcuOy5mKo4knCh1/uNPNsMHv0+q6ohEREQmZf38tpkxPu+//z5at24NV1dXeHl5lbjMlStX0LVrV7i6uiIgIADjx49HUVGRZYPaCZVaBd9g74eWHgD4MH4K6kXWLnHeIy3rYfqGN6s6HhERUYXYzOXsBQUF6NevH6KiovDVV1/dN99gMKBr164ICgrCrl27cOPGDbzwwgtQqVT44IMPBCR2HE5OSiz850Mc33UK305fg/SUDPhW88aAyX0R0TpcdDwiIiITmzvV9fXXX2PMmDHIyMgoNn3Tpk3o1q0bkpKSEBgYCABYvHgx3nrrLdy8eRNqtbpM6+epLiIiIttjd6e6Hmb37t1o3LixqfQAQFxcHHQ6HY4fP17q1+n1euh0umIvIiIisk92U3ySk5OLlR4ApvfJyaVfdTRz5kxotVrTKySE94ohIiKyV0KLz4QJEyBJ0gNfp06dMmuGiRMnIjMz0/S6evWqWbdHRERE4ggd3Dxu3DgMHjz4gcvUrl3y1UL3CgoKwr59+4pNS0lJMc0rjUajgUajKdM2iIiIyLYJLT7+/v7w9/evknVFRUXh/fffR2pqKgICAgAA8fHx8PT0REQEH2xJRERENnQ5+5UrV5CWloYrV67AYDDg0KFDAIC6devC3d0dnTt3RkREBAYOHIjZs2cjOTkZkydPxqhRo3hEh4iIiADY0OXsgwcPxooVK+6bvn37dnTo0AEAcPnyZYwcORI7duyAm5sbBg0ahFmzZsHJqez9jpezExER2R4+sqKCWHyIiIhsj8Pdx4eIiIjoYVh8iIiIyGGw+BAREZHDYPEhIiIih8HiQ0RERA6DxYeIiIgcBosPEREROQwWHyIiInIYLD5ERETkMFh8iIiIyGGw+BAREZHDYPEhIiIih8HiQ0RERA6DxYeIiIgcBosPEREROQwWHyIiInIYLD5ERETkMFh8iIiIyGGw+BAREZHDYPEhIiIih8HiQ0RERA7DSXQAIiJLMxYcBLI/B4y3AIU/4D4GCnUj0bGIyAJYfIjIYRiNRUDaM0DR0X9NPQmk7YRRFQl4fw+FggfCiewZiw8ROY6MF+8pPf9SmAhkjIDR+UlAvxWQZUDdCpJrL0gKLwCAbMwFDNcASQMoQyFJkuWyE1GVYPEhIrthLDwJFB4A4AZoYu+UnPw/AUkFaGKAgj0PXkHBjjsv0/vtkLPnQHZ7Bcj9DpDT/rWwErLrcCg836j6b4SIzIbFh4hsnrHwJJD+MmBMLn2h3C8ruPYiIOezEqYbgNxFMBYeheTzBQADJEldwW0QkaWw+BCRTTMWXQBu9wZgEBOg8G/IKQ0AADLUgKoJ4DEJCnVDMXmI6IE4io+IrJ4x9xcYb3aBMSUSxtTWMGZOhdGouzMzfSSElZ77FACF+4G0XjCmDYVseMARKCISQpJlWRYdwprodDpotVpkZmbC09NTdBwih2Y0GoG0fqUMSFbizt9uhRZOVU7qJwCvj6FQuJkmyUUXgaJLgMIdUD0KSeLBd6LKKuvnN/+1EZH1yni59KuwYID1HOl5gII/gdTHIXuMh6wMB3QTio9Fkjwgu4+Dwq2/uIxEDoTFh4isjtGQBdzqDciXRUepIkWQs2aWPEvOArKmwShnQ+E+3LKxiBwQx/gQkVWRZRm43d2OSk8ZZX8M2Zj28OWIqFJYfIhIKFk2wpj1OYzJTWFMrg85JRwwJomOJYAMOfMD0SGI7B5PdRGRMEZjDnCz4z03BnRg+p8hZ4dDch8mOgmR3WLxISKLk41pkDOnAfrNoqNYHTl7DuTCg4AyEJKmA6BuB0niwXmiqsLiQ0QWJRvTIN/sdGdQL5VM/wcAQM79HlAEQfb5AQqn6oJDEdkH/hlBRBYlp49h6SkPYzJwKwbG7G9FJyGyCyw+RGQxsjEbKHzIg0KpZNnvwpg+RnQKIpvH4kNEFmEsOAn5Zg/RMWyb/ncY834VnYLIprH4EJHZGbPmA2k9APmq6Ci2L3ue6ARENo3Fh4jMyqg/DuTMFx3Dfhguw5jzzZ3ThkRUbiw+RGReGSNFJ7A/We9BTn0cxtx1opMQ2Rxezk5EVU4uOgcYkgCFDyAnP/wLqAIMgG4CjAofKJw7iA5DZDNs4ojPpUuXMHToUISFhcHFxQV16tTB1KlTUVBQUGy5I0eOoF27dnB2dkZISAhmz54tKDGRY5ILDsKY+iTkW/+BnP4S5Nu9RUeyf7p3RScgsik2ccTn1KlTMBqNWLJkCerWrYtjx45h2LBhyMnJwUcffQQA0Ol06Ny5M2JjY7F48WIcPXoUL774Iry8vDB8OJ94TGRucsEhyGnPApBFR3EsxqswJte/89+SD+A2FJLbS5AkSWwuIislybJsk7+l5syZg0WLFuHChQsAgEWLFmHSpElITk6GWq0GAEyYMAEbNmzAqVOnyrxenU4HrVaLzMxMeHp6miU7kT0yprYFjKmiYxAAqKIg+XzN8kMOpayf3zZxqqskmZmZ8PHxMb3fvXs3oqOjTaUHAOLi4nD69Gmkp6eXuh69Xg+dTlfsRUTlYyw4w9JjTQp3Q875RnQKIqtkk8Xn3LlzmD9/Pl5++WXTtOTkZAQGBhZb7u775OTSB1fOnDkTWq3W9AoJCTFPaCI7ZTTmA+kDRcege+V8IToBkVUSWnwmTJgASZIe+Lr3NNX169fx5JNPol+/fhg2bFilM0ycOBGZmZmm19WrvMEaUbmkDwPk0o+qkiDyTdEJiKyS0MHN48aNw+DBgx+4TO3atU3/nZSUhJiYGLRu3RpLly4ttlxQUBBSUlKKTbv7PigoqNT1azQaaDSaciYnIgAwGtKBwr2iY1CJOL6HqCRCi4+/vz/8/f3LtOz169cRExODyMhILF++HApF8YNVUVFRmDRpEgoLC6FSqQAA8fHxCA8Ph7e3d5VnJyIA+u2iE1BplDxtT1QSmxjjc/36dXTo0AGhoaH46KOPcPPmTSQnJxcbu9O/f3+o1WoMHToUx48fx6pVqzBv3jyMHTtWYHIie1ckOgCVRhEmOgGRVbKJ+/jEx8fj3LlzOHfuHGrUqFFs3t2r8bVaLbZu3YpRo0YhMjISfn5+mDJlCu/hQ2ROqlaiE1BpCnfAmLcFCpc40UmIrIrN3sfHXHgfH6KykWUZcu43QNYH4E0LrZj/PiiUXqJTEJmd3d/Hh4jEkrPnAVnvg6XHyummiU5AZFVYfIio3GRDKpCzSHQMKgv9TtEJiKwKiw8RlZucuxo80mMrOACd6N9YfIio/IrOiE5AZaWsLjoBkVVh8SGi8lPw3lg2w2OS6AREVoXFh4jKz3WA6ARURpKGtxwg+jcWHyIqN4WqLqCoIzoGlYGcEgnjrR4w5v8pOgqRVWDxIaKKcR0kOgGVSR5QdBLIGAFj2svgrdvI0bH4EFG5GfP+ALKniY5B5VWwHXL2AtEpiIRi8SGicjEWngEyRwEwio5CFZG7jEd9yKGx+BBR+WTNAu/hY8PkbMCYKjoFkTAsPkRUPgV7RCegSmNxJcfF4kNE5WQQHYAqRQMoAkSHIBKGxYeIykcq/anHZANcekCS+KufHBd/+omofFz7i05AFaUMg+Q5XXQKIqFYfIioXCT30YAiWHQMKi+XAZD8NkGSlKKTEAnF4kNE5SJJKsBvKyC5iY5C5SC5j+ApLiKw+BBRBSgUGsB1oOgYVA6yzCM9RACLDxFVlLKG6ARUHrd7ik5AZBVYfIioYgr2ik5A5SGnwKhPEJ2CSDgWHyKqIN4Ez+bkLBedgEg4Fh8iqhhNe9EJqLyM2aITEAnH4kNEFSI5dwHgLDoGlYdTbdEJiIRj8SGiCpEkNeCzQnQMKg/3/4pOQCQciw8RVZhC/SjgPk10DCoLl2ehcOIzuohYfIioUiTXnuCvEmsmAW6vQqGdIToIkVXgbysiqhRJ4Qo4dxYdg0olA85dRYcgshosPkRUaZL2YwAq0TGoNNmfiU5AZDVYfIio0iRJBSi8Rceg0hhTRScgshosPkRURfgsKKulDBadgMhqsPgQUaUZDTcB4w3RMag07mNEJyCyGiw+RFR52QtEJ6DSaDpA4RQiOgWR1WDxIaLKM1wTnYDuIwHO3aDwXio6CJFVcRIdgIjsgJI3xrMOasB1AKDwB1yfg0LhKjoQkdVh8SGiynMbDeStEZ2C3AZD4cHHUhA9CE91EVGlKZyqAeoOomM4NkUtSG4vi05BZPVYfIioSkjeiwFNrOgYjkkTB8lvDSSFh+gkRFaPp7qIqEpIkgKS90IYDelA7nLAcBNQ1QeKrgN534iOZ8c8IXl9BkmSRAchsgksPkRUpRRKb8BjrOm9bMyFnPcjgAJxoeyZdjJLD1E58FQXEZmVpHAFYBQdwz65vQKFS0/RKYhsCo/4EJEFqAAUiQ5hJzSApj3g/joUqnqiwxDZHBYfIjI/5xgg/3fRKeyAE6TAREiSWnQQIpvFU11EZHaS++sAOA6l0rQzWXqIKslmis9TTz2F0NBQODs7Izg4GAMHDkRSUlKxZY4cOYJ27drB2dkZISEhmD17tqC0RPRvklMY4LUUPMhcCW4joXDpIToFkc2zmeITExODn376CadPn8batWtx/vx59O3b1zRfp9Ohc+fOqFmzJhITEzFnzhxMmzYNS5fyOTVE1kDh3B5SwD+A2yjRUWyIAnDuDsnnRyg83hAdhsguSLIsy6JDVMTPP/+Mnj17Qq/XQ6VSYdGiRZg0aRKSk5OhVt85FDxhwgRs2LABp06dKvN6dTodtFotMjMz4enpaa74RA7NmDkdyPtedAzr5/U5FM6dRacgsgll/fy2mSM+/5aWlobvv/8erVu3hkqlAgDs3r0b0dHRptIDAHFxcTh9+jTS09NLXZder4dOpyv2IiLzkjynABqetnkgTS+WHiIzsKni89Zbb8HNzQ2+vr64cuUKNm7caJqXnJyMwMDAYsvffZ+cnFzqOmfOnAmtVmt6hYSEmCc8EZlIkgSF9xxI/rsA52cBp8aAopboWFZEA8nrfdEhiOyS0OIzYcIESJL0wNe/T1ONHz8eBw8exNatW6FUKvHCCy+gsmfqJk6ciMzMTNPr6tWrlf22iKiMJKUfFF4zoPBbC0XAVkDdTnQkK+AC+G6GJHEgOJE5CP2XNW7cOAwePPiBy9SuXdv0335+fvDz80P9+vXRoEEDhISEYM+ePYiKikJQUBBSUlKKfe3d90FBQaWuX6PRQKPRVPybIKIqo/D5CsbcDUD2XMCYgjuXwPsCSBUbzKwkQPIGJE/AfTgklz58BAWRGQktPv7+/vD396/Q1xqNd26Br9frAQBRUVGYNGkSCgsLTeN+4uPjER4eDm9v76oJTERmp3DtCbj2LDbNWJAIpL8EyDlCMpmPE+D7GxSqMNFBiByGTYzx2bt3Lz7//HMcOnQIly9fxp9//onnnnsOderUQVRUFACgf//+UKvVGDp0KI4fP45Vq1Zh3rx5GDt27EPWTkTWTqGOhBRwAPCYITpKOWkAt5cByeee6RKg7gz4J7D0EFmYTZxEdnV1xbp16zB16lTk5OQgODgYTz75JCZPnmw6TaXVarF161aMGjUKkZGR8PPzw5QpUzB8+HDB6YmoKkiSBMntWRgNKUDuAtFxHkIBaDpA8pwBSRkAeIyDLBcBMECSeGqdSCSbvY+PufA+PkTWT877GXLWPMBo5osRlA0Aw8kyLOgO+G2EJOsAyRVQ1uI4HSILs+v7+BCRY5NcnoLk/8edy+G9vzXDBgIA7edQ+G8ENE8+fHm/eCicQiCpGkJyCmPpIbJiNnGqi4joXpIkAUo/SEo/GJ0eA4r2V36lnjOgcH22+Ha85kG+9R/AcL6Ur5kFhZNv5bdNRBbBIz5EZPMkn0WAonYpc1WA73ZA0/Uha3GF5NLn/nVLEiS/3wGPd/9vkLICgBOgagn4/g6Fa+9KpiciS+IRHyKyeZJCC/j/Cjn/TyB7GWC8DEjugNsrkFx7QpIkyF6fQE5LBgoTS1iDBvD9EZKkKnn9kgTJ7RnA7RnzfiNEZHYsPkRkFyTJCZJLZ8Cl5OdbSZIEyfcHGPP/BLLnA4YkQHIGXLpDchsBSeFu4cREJAKLDxE5FIXzE4DzE6JjEJEgHONDREREDoPFh4iIiBwGiw8RERE5DBYfIiIichgsPkREROQwWHyIiIjIYbD4EBERkcNg8SEiIiKHweJDREREDoPFh4iIiBwGH1lxD1mWAQA6nU5wEiIiIiqru5/bdz/HS8Pic4+srCwAQEhIiOAkREREVF5ZWVnQarWlzpfkh1UjB2M0GpGUlAQPDw9IkiQ6DoA7LTYkJARXr16Fp6en6DhWhfumdNw3peO+KRn3S+m4b0pnLftGlmVkZWWhWrVqUChKH8nDIz73UCgUqFGjhugYJfL09OQ/uFJw35SO+6Z03Dcl434pHfdN6axh3zzoSM9dHNxMREREDoPFh4iIiBwGi48N0Gg0mDp1KjQajegoVof7pnTcN6XjvikZ90vpuG9KZ2v7hoObiYiIyGHwiA8RERE5DBYfIiIichgsPkREROQwWHyIiIjIYbD4WLmnnnoKoaGhcHZ2RnBwMAYOHIikpKRiyxw5cgTt2rWDs7MzQkJCMHv2bEFpLefSpUsYOnQowsLC4OLigjp16mDq1KkoKCgotpwj7hsAeP/999G6dWu4urrCy8urxGWuXLmCrl27wtXVFQEBARg/fjyKioosG1SABQsWoFatWnB2dkbLli2xb98+0ZEsbufOnejevTuqVasGSZKwYcOGYvNlWcaUKVMQHBwMFxcXxMbG4uzZs2LCWtDMmTPx+OOPw8PDAwEBAejZsydOnz5dbJn8/HyMGjUKvr6+cHd3R58+fZCSkiIoseUsWrQITZo0Md2kMCoqCps2bTLNt6X9wuJj5WJiYvDTTz/h9OnTWLt2Lc6fP4++ffua5ut0OnTu3Bk1a9ZEYmIi5syZg2nTpmHp0qUCU5vfqVOnYDQasWTJEhw/fhxz587F4sWL8fbbb5uWcdR9AwAFBQXo168fRo4cWeJ8g8GArl27oqCgALt27cKKFSvw9ddfY8qUKRZOalmrVq3C2LFjMXXqVBw4cABNmzZFXFwcUlNTRUezqJycHDRt2hQLFiwocf7s2bPx2WefYfHixdi7dy/c3NwQFxeH/Px8Cye1rISEBIwaNQp79uxBfHw8CgsL0blzZ+Tk5JiWeeONN/DLL79g9erVSEhIQFJSEnr37i0wtWXUqFEDs2bNQmJiIvbv348nnngCPXr0wPHjxwHY2H6RyaZs3LhRliRJLigokGVZlhcuXCh7e3vLer3etMxbb70lh4eHi4oozOzZs+WwsDDTe+4bWV6+fLms1Wrvm/7777/LCoVCTk5ONk1btGiR7OnpWWx/2ZsWLVrIo0aNMr03GAxytWrV5JkzZwpMJRYAef369ab3RqNRDgoKkufMmWOalpGRIWs0GvmHH34QkFCc1NRUGYCckJAgy/Kd/aBSqeTVq1ebljl58qQMQN69e7eomMJ4e3vLX375pc3tFx7xsSFpaWn4/vvv0bp1a6hUKgDA7t27ER0dDbVabVouLi4Op0+fRnp6uqioQmRmZsLHx8f0nvumdLt370bjxo0RGBhomhYXFwedTmf6C87eFBQUIDExEbGxsaZpCoUCsbGx2L17t8Bk1uXixYtITk4utp+0Wi1atmzpcPspMzMTAEy/VxITE1FYWFhs3zzyyCMIDQ11qH1jMBjw448/IicnB1FRUTa3X1h8bMBbb70FNzc3+Pr64sqVK9i4caNpXnJycrEPLwCm98nJyRbNKdK5c+cwf/58vPzyy6Zp3Delc8R9c+vWLRgMhhK/b3v9nivi7r5w9P1kNBoxZswYtGnTBo0aNQJwZ9+o1er7xs05yr45evQo3N3dodFoMGLECKxfvx4RERE2t19YfASYMGECJEl64OvUqVOm5cePH4+DBw9i69atUCqVeOGFFyDb6Q23y7tvAOD69et48skn0a9fPwwbNkxQcvOryL4hoooZNWoUjh07hh9//FF0FKsRHh6OQ4cOYe/evRg5ciQGDRqEEydOiI5Vbk6iAziicePGYfDgwQ9cpnbt2qb/9vPzg5+fH+rXr48GDRogJCQEe/bsQVRUFIKCgu4bOX/3fVBQUJVnN7fy7pukpCTExMSgdevW9w1advR98yBBQUH3Xc1ky/umLPz8/KBUKkv8mbDX77ki7u6LlJQUBAcHm6anpKSgWbNmglJZ1ujRo/Hrr79i586dqFGjhml6UFAQCgoKkJGRUezohqP8DKnVatStWxcAEBkZiX/++Qfz5s3DM888Y1P7hcVHAH9/f/j7+1foa41GIwBAr9cDAKKiojBp0iQUFhaaxv3Ex8cjPDwc3t7eVRPYgsqzb65fv46YmBhERkZi+fLlUCiKH8B05H3zMFFRUXj//feRmpqKgIAAAHf2jaenJyIiIqpkG9ZGrVYjMjIS27ZtQ8+ePQHc+fe0bds2jB49Wmw4KxIWFoagoCBs27bNVHR0Op3pr3x7JssyXn31Vaxfvx47duxAWFhYsfmRkZFQqVTYtm0b+vTpAwA4ffo0rly5gqioKBGRhTIajdDr9ba3X0SPrqbS7dmzR54/f7588OBB+dKlS/K2bdvk1q1by3Xq1JHz8/NlWb5zlUFgYKA8cOBA+dixY/KPP/4ou7q6ykuWLBGc3ryuXbsm161bV+7YsaN87do1+caNG6bXXY66b2RZli9fviwfPHhQnj59uuzu7i4fPHhQPnjwoJyVlSXLsiwXFRXJjRo1kjt37iwfOnRI3rx5s+zv7y9PnDhRcHLz+vHHH2WNRiN//fXX8okTJ+Thw4fLXl5exa5ucwRZWVmmnwkA8ieffCIfPHhQvnz5sizLsjxr1izZy8tL3rhxo3zkyBG5R48eclhYmJyXlyc4uXmNHDlS1mq18o4dO4r9TsnNzTUtM2LECDk0NFT+888/5f3798tRUVFyVFSUwNSWMWHCBDkhIUG+ePGifOTIEXnChAmyJEny1q1bZVm2rf3C4mPFjhw5IsfExMg+Pj6yRqORa9WqJY8YMUK+du1aseUOHz4st23bVtZoNHL16tXlWbNmCUpsOcuXL5cBlPj6N0fcN7Isy4MGDSpx32zfvt20zKVLl+QuXbrILi4usp+fnzxu3Di5sLBQXGgLmT9/vhwaGiqr1Wq5RYsW8p49e0RHsrjt27eX+PMxaNAgWZbvXNL+zjvvyIGBgbJGo5E7duwonz59WmxoCyjtd8ry5ctNy+Tl5cmvvPKK7O3tLbu6usq9evUq9geXvXrxxRflmjVrymq1Wvb395c7duxoKj2ybFv7RZJlOx0lS0RERHQPXtVFREREDoPFh4iIiBwGiw8RERE5DBYfIiIichgsPkREROQwWHyIiIjIYbD4EBERkcNg8SEiIiKHweJDREREDoPFh4iIiBwGiw8R2bWbN28iKCgIH3zwgWnarl27oFarsW3bNoHJiEgEPquLiOze77//jp49e2LXrl0IDw9Hs2bN0KNHD3zyySeioxGRhbH4EJFDGDVqFP744w889thjOHr0KP755x9oNBrRsYjIwlh8iMgh5OXloVGjRrh69SoSExPRuHFj0ZGISACO8SEih3D+/HkkJSXBaDTi0qVLouMQkSA84kNEdq+goAAtWrRAs2bNEB4ejk8//RRHjx5FQECA6GhEZGEsPkRk98aPH481a9bg8OHDcHd3R/v27aHVavHrr7+KjkZEFsZTXURk13bs2IFPP/0U3377LTw9PaFQKPDtt9/ir7/+wqJFi0THIyIL4xEfIiIichg84kNEREQOg8WHiIiIHAaLDxERETkMFh8iIiJyGCw+RERE5DBYfIiIiMhhsPgQERGRw2DxISIiIofB4kNEREQOg8WHiIiIHAaLDxERETkMFh8iIiJyGP8PfD2NvY2bmiMAAAAASUVORK5CYII=\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for emb, title in zip(\n",
+ " [embedding_intelex, embedding_original],\n",
+ " [\"Intel® Extension for scikit-learn\", \"Original scikit-learn\"],\n",
+ "):\n",
+ " plt.scatter(emb[:, 0], emb[:, 1], c=colors)\n",
+ " plt.title(title)\n",
+ " plt.xlabel(\"x\")\n",
+ " plt.ylabel(\"y\")\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Speedup for this run: 3.0'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Speedup for this run: {(time_original/time_opt):.1f}\""
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.3/search.html b/2024.3/search.html
new file mode 100644
index 0000000000..6ed8776251
--- /dev/null
+++ b/2024.3/search.html
@@ -0,0 +1,405 @@
+
+
+
+
+
+ Search — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/searchindex.js b/2024.3/searchindex.js
new file mode 100644
index 0000000000..5f923234c2
--- /dev/null
+++ b/2024.3/searchindex.js
@@ -0,0 +1 @@
+Search.setIndex({"docnames": ["404", "algorithms", "blogs", "contribute", "deprecation", "distributed-mode", "guide/acceleration", "index", "kaggle", "kaggle/automl", "kaggle/classification", "kaggle/regression", "license", "oneapi-gpu", "quick-start", "samples", "samples/ElasticNet", "samples/daal4py_data_science", "samples/dbscan", "samples/kmeans", "samples/knn_mnist", "samples/lasso_regression", "samples/linear_regression", "samples/logistictic_regression_cifar", "samples/nusvr_medical_charges", "samples/random_forest_yolanda", "samples/ridge_regression", "samples/svc_adult", "samples/tsne", "support", "tutorials", "verbose"], "filenames": ["404.rst", "algorithms.rst", "blogs.rst", "contribute.rst", "deprecation.rst", "distributed-mode.rst", "guide/acceleration.rst", "index.rst", "kaggle.rst", "kaggle/automl.rst", "kaggle/classification.rst", "kaggle/regression.rst", "license.rst", "oneapi-gpu.rst", "quick-start.rst", "samples.rst", "samples/ElasticNet.ipynb", "samples/daal4py_data_science.ipynb", "samples/dbscan.ipynb", "samples/kmeans.ipynb", "samples/knn_mnist.ipynb", "samples/lasso_regression.ipynb", "samples/linear_regression.ipynb", "samples/logistictic_regression_cifar.ipynb", "samples/nusvr_medical_charges.ipynb", "samples/random_forest_yolanda.ipynb", "samples/ridge_regression.ipynb", "samples/svc_adult.ipynb", "samples/tsne.ipynb", "support.rst", "tutorials.rst", "verbose.rst"], "titles": ["", "Supported Algorithms", "Follow us on Medium", "How to Contribute", "Deprecation Notice", "Distributed Mode", "Tuning Guide", "Intel\u00ae Extension for Scikit-learn*", "Kaggle Kernels", "Kaggle Kernels that use AutoML and Intel\u00ae Extension for Scikit-learn*", "Kaggle Kernels for Classification Tasks", "Kaggle Kernels for Regression Tasks", "License", "oneAPI and GPU support in Intel\u00ae Extension for Scikit-learn*", "Quick Start", "Samples", "Intel\u00ae Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset", "Utilizing daal4py in Data Science Workflows", "Intel\u00ae Extension for Scikit-learn DBSCAN for spoken arabic digit dataset", "Intel\u00ae Extension for Scikit-learn Kmeans for spoken arabic digit dataset", "Intel\u00ae Extension for Scikit-learn KNN for MNIST dataset", "Intel\u00ae Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset", "Intel\u00ae Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset", "Intel\u00ae Extension for Scikit-learn Logistic Regression for Cifar dataset", "Intel\u00ae Extension for Scikit-learn NuSVR for Medical Charges dataset", "Intel\u00ae Extension for Scikit-learn Random Forest for Yolanda dataset", "Intel\u00ae Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset", "Intel\u00ae Extension for Scikit-learn SVC for Adult dataset", "Intel\u00ae Extension for Scikit-learn TSNE example", "Intel(R) Extension for Scikit-learn Support", "Intel\u00ae Extension for Scikit-learn* Tutorials & Case Studies", "Verbose Mode"], "terms": {"intel": [1, 2, 3, 4, 5, 6, 10, 11, 12, 15, 31], "extens": [1, 2, 3, 4, 5, 6, 10, 11, 12, 15, 31], "appli": [1, 14, 24], "impact": [1, 30], "follow": [1, 6, 9, 10, 11, 14, 15, 29], "paramet": [1, 6, 10, 11, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "data": [1, 2, 6, 7, 9, 10, 11, 13, 30], "format": [1, 3, 6], "svc": [1, 10, 14, 15], "all": [1, 3, 6, 7, 13, 14], "ar": [1, 2, 3, 4, 6, 10, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31], "No": [1, 3, 4], "limit": [1, 17], "nusvc": 1, "randomforestclassifi": [1, 14], "except": [1, 6], "warm_start": 1, "true": [1, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "cpp_alpha": 1, "0": [1, 3, 6, 7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "criterion": 1, "gini": 1, "multi": [1, 14], "output": [1, 3, 17], "spars": [1, 10, 17], "kneighborsclassifi": [1, 20], "For": [1, 3, 13, 14, 31], "kd_tree": 1, "metric": [1, 6, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28], "euclidean": [1, 6], "minkowski": [1, 6], "p": [1, 6], "2": [1, 3, 6, 7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "brute": 1, "manhattan": 1, "chebyshev": 1, "cosin": 1, "logisticregress": [1, 23], "solver": [1, 23], "lbfg": [1, 23], "newton": 1, "cg": 1, "class_weight": 1, "none": [1, 21, 22], "sample_weight": 1, "onli": [1, 13, 14, 17, 31], "dens": 1, "i": [1, 3, 4, 5, 7, 9, 10, 11, 13, 14, 17, 19, 20, 27, 29, 30, 31], "svr": [1, 9, 11], "nusvr": [1, 11, 15], "randomforestregressor": [1, 25], "mse": [1, 16, 21, 22, 25, 26], "kneighborsregressor": 1, "linearregress": [1, 22], "normal": [1, 10, 16, 18, 19, 26], "fals": [1, 13, 16, 19, 21, 22, 26], "observ": [1, 6], "should": [1, 13], "featur": [1, 3, 9, 10, 11, 13, 16, 17, 24, 26, 28, 29], "ridg": [1, 11], "auto": [1, 3, 13], "elasticnet": [1, 11, 15], "lasso": [1, 11, 15], "kmean": [1, 14, 15], "precompute_dist": 1, "dbscan": [1, 7, 13, 15, 31], "pca": [1, 10], "svd_solver": 1, "full": [1, 6, 30], "tsne": 1, "refer": [1, 6, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "acceler": [1, 2, 6, 7, 14, 30, 31], "detail": [1, 6, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "more": [1, 2, 5, 14, 17], "nearestneighbor": [1, 14], "train_test_split": [1, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "assert_all_finit": 1, "pairwise_dist": 1, "correl": [1, 11, 17], "roc_auc_scor": 1, "averag": [1, 6], "max_fpr": 1, "multi_class": [1, 23], "oneapi": [1, 14, 15, 30], "kernel": [1, 15, 24, 27], "sigmoid_poli": 1, "binari": [1, 8, 9], "oob_scor": 1, "weight": [1, 20, 27], "callabl": 1, "penalti": 1, "l2": 1, "init": 1, "k": [1, 2, 10, 15, 30], "mean": [1, 2, 13, 24, 25, 30], "fallback": [1, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "monkei": 1, "patch": [1, 3, 5, 9, 10, 11, 13], "class": [1, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "function": [1, 4, 5, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "pass": [1, 3, 13], "": [1, 3, 10, 11, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "own": [1, 3], "suit": 1, "few": [1, 14], "specifi": [1, 3], "deselected_test": 1, "yaml": 1, "The": [1, 3, 4, 6, 7, 9, 10, 11, 13, 14, 15, 17, 20, 27, 30], "result": [1, 6, 13, 14, 16, 17, 21, 22, 23, 24, 25, 26, 27], "entir": [1, 6, 14], "latest": [1, 2], "circleci": 1, "scikit": [2, 3, 4, 5, 6, 10, 11, 12, 15, 31], "learn": [2, 3, 4, 5, 6, 10, 11, 12, 15, 31], "we": [2, 3, 5, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29], "publish": 2, "blog": [2, 14], "so": [2, 3, 14, 17], "tip": 2, "trick": 2, "effici": [2, 30], "analysi": 2, "help": [2, 13, 15, 29, 30], "here": [2, 14, 17], "our": [2, 3, 14], "save": 2, "time": [2, 6, 7, 11, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "monei": 2, "superior": 2, "machin": [2, 10, 15, 21, 22, 30], "perform": [2, 6, 7, 10, 11, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "xeon": 2, "scalabl": 2, "processor": [2, 14], "leverag": [2, 30], "optim": [2, 10, 11, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31], "give": 2, "boost": [2, 9], "scientist": [2, 7], "need": [2, 14, 17], "from": [2, 3, 7, 9, 10, 11, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "hour": [2, 11], "minut": [2, 17], "600x": 2, "faster": [2, 7, 19, 30], "svm": [2, 10, 14, 24, 27], "improv": [2, 7, 30], "xgboost": 2, "lightgbm": 2, "infer": [2, 7, 13], "kaggl": [2, 15], "challeng": [2, 29], "us": [2, 3, 5, 6, 7, 10, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], "ai": [2, 7, 30], "analyt": 2, "toolkit": [2, 17], "your": [2, 3, 7, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "applic": [2, 7, 14, 15], "linear": [2, 15, 17], "model": [2, 6, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 30], "cluster": [2, 7, 13, 14, 15, 18, 19, 28, 31], "why": 2, "pai": 2, "As": 3, "an": [3, 9, 10, 11, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], "open": [3, 17, 21, 22, 30], "sourc": [3, 28, 30], "project": 3, "welcom": 3, "commun": 3, "r": [3, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "thi": [3, 4, 5, 6, 8, 13, 14, 17, 28], "document": [3, 5], "explain": 3, "particip": 3, "convers": 3, "log": [3, 23, 31], "bug": [3, 29], "enhanc": 3, "submit": [3, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "apach": 3, "By": [3, 14], "you": [3, 5, 7, 8, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31], "agre": 3, "copyright": 3, "term": 3, "releas": [3, 4], "under": 3, "anonym": 3, "accept": [3, 13], "name": [3, 16, 18, 19, 20, 23, 24, 25, 26, 27], "commit": [3, 29], "messag": 3, "sign": 3, "off": 3, "line": [3, 7, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "email": [3, 9, 10], "must": [3, 13, 14], "match": [3, 17], "authorship": 3, "inform": [3, 4], "make": [3, 11, 14, 29], "sure": [3, 14], "gitconfig": 3, "set": [3, 6, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 31], "up": [3, 7], "correctli": 3, "can": [3, 5, 6, 7, 8, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29], "git": 3, "config": 3, "global": [3, 13], "user": [3, 14, 17, 29], "kate": 3, "develop": [3, 8, 15, 30], "compani": 3, "com": [3, 12, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "build": [3, 30], "product": [3, 9, 10, 11], "run": [3, 13, 14, 15, 28, 31], "test": [3, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "larger": [3, 6, 17], "provid": [3, 4, 8, 14, 15, 29], "relev": 3, "restructuredtext": 3, "new": [3, 14], "file": [3, 14, 17, 21, 22], "appropri": 3, "year": [3, 21, 22], "first": [3, 20, 27], "master": 3, "branch": 3, "continu": 3, "integr": [3, 7, 13], "ci": 3, "enabl": [3, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "repositori": [3, 7, 14, 15], "check": [3, 11, 17, 29], "merg": 3, "review": 3, "mai": [3, 10, 13, 14, 17, 29], "feedback": 3, "guid": 3, "ani": [3, 13, 14, 29], "addit": [3, 14, 31], "fix": 3, "modif": [3, 7, 14], "necessari": [3, 14], "when": [3, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "github": [3, 12, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29], "black": 3, "isort": 3, "formatt": 3, "python": [3, 14, 31], "length": 3, "90": [3, 20, 21, 22, 27], "charact": 3, "default": [3, 6, 10, 11, 13, 14, 17], "option": [3, 13], "otherwis": 3, "find": [3, 7, 8, 29, 31], "linter": 3, "configur": [3, 6, 13], "pyproject": 3, "toml": 3, "A": 3, "action": [3, 14], "verifi": 3, "compli": 3, "tool": [3, 7, 30], "instal": [3, 13, 30], "pre": 3, "hook": 3, "do": [3, 13, 17], "top": 3, "level": [3, 31], "pip": [3, 13, 14], "page": 4, "about": [4, 5, 10, 14], "specif": [4, 7, 8, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "2023": 4, "x": [4, 7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "last": [4, 14], "reason": [4, 13], "modern": 4, "x86": [4, 7, 14], "base": [4, 6, 10, 11, 13], "system": [4, 13, 30], "altern": [4, 31], "version": [4, 13, 14, 17, 31], "contain": [5, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "wa": 5, "origin": [5, 6, 14, 17, 31], "avail": [5, 14, 31], "daal4pi": [5, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "packag": [5, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "recommend": [5, 13, 14], "intelex": [5, 8, 10, 11, 12, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "instead": [5, 13], "while": [5, 14], "distribu": 5, "doe": [5, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "current": [5, 13, 14, 31], "offer": [5, 13], "some": 6, "algorithm": [6, 13, 14, 28, 30, 31], "chang": [6, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 29], "section": [6, 17], "denot": 6, "case": [6, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "support": [6, 10, 11, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "see": [6, 7, 8, 14, 17, 29], "list": [6, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "consist": 6, "two": [6, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "compon": 6, "knn": [6, 9, 10, 15], "gradient": [6, 9], "descent": 6, "overal": 6, "depend": [6, 17, 31], "each": [6, 9, 14], "part": [6, 7, 17], "n_compon": [6, 28], "3": [6, 7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "method": [6, 13, 14, 29], "exact": 6, "verbos": [6, 14], "To": [6, 13, 14, 31], "get": [6, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 30, 31], "better": [6, 14], "both": [6, 14], "hist": 6, "split": [6, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "discret": [6, 14], "train": [6, 7, 10, 11, 13, 28], "creat": [6, 8, 10, 11, 14, 17], "histogram": 6, "number": [6, 17, 19, 28], "bin": 6, "keyword": 6, "argument": [6, 14, 17], "influenc": [6, 17], "possibl": [6, 17], "valu": [6, 11, 13, 17], "descript": 6, "maxbin": 6, "inf": 6, "256": 6, "disabl": [6, 7, 14], "minbins": 6, "1": [6, 7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "5": [6, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "minimum": 6, "point": 6, "after": [6, 13, 14, 17], "binningstrategi": 6, "quantil": [6, 10], "select": [6, 13, 14], "calcul": [6, 10, 11], "edg": 6, "similar": [6, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27, 29], "amount": [6, 14], "divid": 6, "rang": 6, "equal": 6, "width": 6, "size": 6, "max": 6, "min": 6, "note": [6, 13], "greatli": 6, "especi": 6, "howev": [6, 13], "due": 6, "reduc": [6, 10, 17], "fidel": 6, "present": [6, 17], "wors": 6, "compar": [6, 16, 18, 19, 21, 22, 23, 24, 25, 26, 30], "In": [6, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "increas": 6, "free": 7, "softwar": 7, "design": [7, 15], "deliv": 7, "100x": 7, "exist": [7, 14, 29], "code": [7, 13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "achiev": [7, 8], "vector": [7, 10, 11, 15], "instruct": [7, 14, 15], "hardwar": 7, "memori": [7, 10], "thread": [7, 14], "upcom": 7, "platform": 7, "launch": 7, "framework": [7, 9, 30], "speed": [7, 17], "equival": 7, "mathemat": 7, "accuraci": [7, 20, 27], "benefit": [7, 14], "across": 7, "differ": [7, 13, 14], "compat": [7, 13], "without": [7, 14, 17], "coupl": [7, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "command": [7, 14], "also": [7, 14, 15], "These": [7, 10, 11, 13, 14, 15, 31], "chart": 7, "benchmark": [7, 30], "bench": 7, "import": [7, 10, 11, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "numpi": [7, 14, 21, 22], "np": [7, 13, 14, 17, 21, 22], "sklearnex": [7, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "patch_sklearn": [7, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "sklearn": [7, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 31], "arrai": [7, 13, 14, 17], "8": [7, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "7": [7, 13, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "25": [7, 13], "80": [7, 13], "dtype": [7, 13, 21, 22], "float32": [7, 13, 21, 22], "ep": [7, 13], "min_sampl": [7, 13], "fit": [7, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 31], "dpctl": [7, 13], "config_context": [7, 13], "target_offload": [7, 13], "notebook": [8, 15, 17], "introduct": [8, 30], "summari": 8, "speedup": [8, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "brows": 8, "chapter": 8, "type": [8, 10, 13], "task": [8, 14, 15, 30], "classif": [8, 9, 15, 20, 27], "multiclass": [8, 9], "comput": [8, 11, 13, 14, 17, 30], "vision": 8, "natur": 8, "languag": 8, "process": [8, 17], "regress": [8, 10, 15, 17], "singl": [8, 14], "regressor": 8, "stack": [8, 10], "random": [9, 10, 11, 15], "forest": [9, 10, 11, 15], "autogluon": 9, "evalml": 9, "blend": 9, "pycaret": 9, "show": [9, 10, 11, 14, 17, 28], "how": [9, 10, 11, 13, 14, 30], "tp": [9, 10, 11], "stand": [9, 10, 11], "tabular": [9, 10, 11], "playground": [9, 10, 11], "seri": [9, 10, 11], "which": [9, 10, 11, 13, 17, 31], "beginn": [9, 10, 11], "friendli": [9, 10, 11], "competit": [9, 10, 11], "goal": [9, 10, 11], "jun": [9, 10], "2021": [9, 10, 11, 17], "synthet": [9, 10, 11], "ecommerc": [9, 10], "predict": [9, 10, 11, 13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "categori": [9, 10, 24], "titan": [9, 10], "datset": 9, "whether": [9, 10], "passeng": [9, 10], "survivi": [9, 10], "oct": 9, "molecular": 9, "respons": [9, 21, 22], "biolog": 9, "molecul": 9, "given": 9, "variou": [9, 10, 11], "chemic": 9, "properti": [9, 11], "nov": [9, 10], "spam": [9, 10], "identifi": [9, 10], "via": [9, 10, 13, 14], "extract": [9, 10], "jan": 9, "2022": [9, 10, 11], "fiction": 9, "sale": [9, 11], "correspond": [9, 14], "item": 9, "date": 9, "countri": 9, "store": [9, 11, 14], "combin": 9, "usual": [10, 11, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "includ": [10, 11, 14], "comparison": [10, 11, 14], "between": [10, 11], "stock": [10, 11, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "content": [10, 11], "logist": [10, 15], "preprocess": [10, 11, 21, 22], "search": [10, 11], "optuna": [10, 11], "datafram": [10, 17], "usag": [10, 17], "eli5": [10, 11], "permut": 10, "apr": 10, "dataset": [10, 11, 14, 15, 17, 28], "construct": 10, "engin": [10, 11], "transform": [10, 13, 16, 18, 19, 21, 22, 26], "paramt": [10, 11], "one": [10, 13, 14, 17, 31], "hot": 10, "encod": [10, 16, 24, 26], "dimension": [10, 17], "reduct": 10, "classifi": [10, 23, 27], "pipelin": 10, "anoth": [10, 17], "final": 10, "estim": [10, 13, 14], "dec": 10, "cover": [10, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "nearest": [10, 15], "neighbor": [10, 14, 15, 20], "feb": 10, "bacteria": 10, "dna": 10, "speci": 10, "repeat": 10, "lossi": 10, "measur": [10, 11, 17], "snippet": 10, "cv": 10, "digit": [10, 15], "recogn": 10, "mnist": [10, 15], "hand": 10, "written": 10, "nlp": 10, "disast": 10, "tweet": 10, "real": 10, "ones": 10, "tf": 10, "idf": 10, "One": 10, "v": [10, 30], "rest": 10, "text": 10, "what": 10, "cook": 10, "recip": 10, "ingredi": 10, "cuisin": 10, "tfidfvector": 10, "overflow": 10, "question": 10, "qualiti": [10, 16, 18, 20, 21, 22, 23, 24, 25, 26, 27], "rate": [10, 17], "baselin": 11, "nu": [11, 15, 24], "rbf": [11, 27], "jul": 11, "pollut": 11, "air": 11, "over": [11, 17], "weather": 11, "input": [11, 13], "multipl": 11, "sensor": 11, "aug": 11, "loan": 11, "loss": [11, 23], "associ": 11, "hous": 11, "price": 11, "its": [11, 30, 31], "characterist": 11, "explor": [11, 15, 30], "outlier": 11, "fill": 11, "miss": 11, "best": 11, "gridsearchcv": 11, "mar": 11, "spatio": 11, "tempor": 11, "traffic": 11, "forecast": 11, "twelv": 11, "flow": 11, "major": 11, "u": 11, "metropolitan": 11, "area": 11, "sep": 11, "insur": 11, "probabl": [11, 23], "custom": 11, "claim": 11, "upon": 11, "polici": 11, "fore": 11, "futur": 11, "total": 11, "everi": 11, "next": 11, "month": 11, "daili": 11, "http": [12, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "blob": [12, 28], "main": [12, 14], "concept": 13, "execut": [13, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "cpu": [13, 14, 15, 31], "done": 13, "implement": [13, 14, 31], "core": 13, "like": 13, "queue": 13, "dpc": [13, 14], "compil": [13, 14], "runtim": 13, "driver": [13, 14], "requir": 13, "either": 13, "pypi": 13, "anaconda": 13, "dpcpp": 13, "cpp": 13, "rt": 13, "conda": [13, 14], "dpcpp_cpp_rt": 13, "c": [13, 14, 23, 24, 27, 28], "tensor": 13, "usm_ndarrai": 13, "where": 13, "locat": 13, "return": [13, 14], "same": [13, 14, 17, 28, 29], "resid": 13, "consum": [13, 14], "primarili": 13, "str": 13, "syclqueu": 13, "If": [13, 14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29], "string": 13, "context": [13, 17], "deduc": 13, "sycl": 13, "filter": 13, "selector": 13, "allow_fallback_to_host": 13, "boolean": 13, "flag": [13, 14], "allow": [13, 17], "host": 13, "particular": 13, "set_config": 13, "obtain": 13, "call": [13, 14, 17, 31], "get_config": 13, "alwai": [13, 14], "consider": 13, "sycl_context": 13, "describ": 13, "abov": [13, 17, 20, 27], "behavior": 13, "restrict": 13, "absenc": [13, 17], "throw": 13, "error": [13, 25], "made": [13, 17], "outsid": 13, "readi": 14, "elev": 14, "experi": 14, "just": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "simpl": [14, 30], "step": 14, "four": 14, "onc": 14, "replac": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "perman": 14, "undo": 14, "m": [14, 28], "my_appl": 14, "py": 14, "modifi": 14, "script": 14, "add": [14, 29], "modul": [14, 28], "interchang": 14, "thei": 14, "scenario": [14, 15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "produc": 14, "exampl": [14, 17, 31], "regist": 14, "drop": [14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "re": 14, "4": [14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "10": [14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "n_cluster": [14, 19], "random_st": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "print": [14, 17, 19, 20, 27, 28, 31], "f": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "labels_": 14, "befor": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "begin": 14, "have": [14, 17, 29], "read": [14, 17], "write": [14, 21, 22], "permiss": 14, "With": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "glob": [14, 17], "sever": [14, 17], "kei": [14, 17], "random_forest_classifi": 14, "global_patch": 14, "other": [14, 17], "environ": [14, 31], "notif": 14, "nv": 14, "unpatch_sklearn": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "clone": 14, "alreadi": [14, 29], "successfulli": 14, "reimport": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "prevent": 14, "conflict": 14, "activ": 14, "o": [14, 21, 22, 31], "9": [14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "11": [14, 16, 17, 18, 19, 21, 22, 24, 26], "12": [14, 16, 17, 18, 19, 21, 22, 26, 28], "linux": [14, 31], "gpu": [14, 15, 30], "window": [14, 31], "forg": 14, "channel": 14, "distribut": 14, "download": 14, "architectur": [14, 30], "least": 14, "sse2": 14, "sse4": 14, "avx2": 14, "avx512": 14, "arm": 14, "than": 14, "ubuntu": 14, "18": [14, 17, 22], "04": [14, 17], "newer": 14, "server": 14, "2019": 14, "mode": 14, "ram": 14, "unoptim": 14, "approxim": 14, "n": [14, 17, 20, 27], "devic": 14, "larg": 14, "enough": 14, "copi": 14, "intern": 14, "sampl": [14, 28], "jupyt": 15, "want": [15, 29], "them": 15, "local": 15, "cifar": 15, "adult": 15, "airlin": 15, "depdelai": 15, "yearpredictionmsd": 15, "medic": 15, "charg": 15, "yolanda": 15, "rigd": 15, "spoken": 15, "arab": 15, "start": [15, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30], "There": 15, "varieti": 15, "complet": 15, "catalog": 15, "were": 15, "offload": 15, "multiarchitectur": 15, "target": [15, 17], "fpga": 15, "timeit": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "default_tim": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "timer": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "model_select": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "warn": [16, 18, 19, 21, 22, 23, 24, 26, 28], "fetch_openml": [16, 18, 19, 20, 23, 24, 25, 26, 27], "labelencod": [16, 26], "ipython": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "displai": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "html": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "filterwarn": [16, 18, 19, 21, 22, 23, 24, 26, 28], "ignor": [16, 18, 19, 21, 22, 23, 24, 26, 28], "y": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "airlines_depdelay_10m": [16, 26], "return_x_i": [16, 18, 19, 20, 23, 24, 25, 26, 27], "let": [16, 18, 19, 26], "categor": [16, 24, 26], "col": [16, 26], "uniquecarri": [16, 26], "dest": [16, 26], "le": [16, 26], "x_train": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "x_test": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "y_train": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "y_test": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "test_siz": [16, 18, 19, 20, 21, 22, 23, 25, 26, 27], "shape": [16, 17, 19, 20, 21, 22, 23, 24, 25, 26], "9000000": [16, 26], "1000000": [16, 26], "standardscal": [16, 21, 22, 26], "scaler_i": [16, 21, 22, 26], "6": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "to_numpi": [16, 21, 22, 26], "reshap": [16, 17, 21, 22, 26], "ravel": [16, 21, 22, 26], "previous": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "known": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "take": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "advantag": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "ad": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "affect": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "unsupport": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "issu": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "linear_model": [16, 21, 22, 23, 26], "param": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "alpha": [16, 21, 26], "fit_intercept": [16, 21, 26], "l1_ratio": 16, "copy_x": [16, 19, 21, 22, 26], "train_patch": [16, 18, 19, 21, 22, 23, 24, 25, 26, 27], "2f": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "39": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "28": [16, 17], "y_predict": [16, 21, 22, 23, 26], "mse_metric_opt": [16, 21, 22, 26], "mean_squared_error": [16, 21, 22, 25, 26], "0109113399224974": 16, "order": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "cancel": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "librari": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "train_unpatch": [16, 18, 19, 21, 22, 23, 24, 25, 26, 27], "96": [16, 20], "mse_metric_origin": [16, 21, 22, 26], "0109113399545733": 16, "13": [16, 17, 21, 24, 26], "h3": [16, 18, 19, 21, 22, 23, 24, 25, 26], "br": [16, 18, 19, 21, 22, 23, 24, 25, 26], "unpatch": [16, 18, 19, 21, 22, 23, 24, 25, 26], "ratio": [16, 18, 19, 21, 22, 23, 24, 25, 26], "ul": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "li": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "minim": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "fast": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "strong": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "1f": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "originalms": [16, 21, 22, 25, 26], "9999999999682703": 16, "qualityget": [16, 18, 20, 21, 22, 23, 24, 25, 26, 27], "14": [16, 17, 19, 27], "below": [17, 31], "ha": 17, "been": 17, "demonstr": 17, "It": [17, 30], "cycl": 17, "pyworkout": 17, "attempt": 17, "collect": 17, "telemetri": 17, "power": 17, "meter": 17, "panda": [17, 21, 22], "pd": [17, 21, 22], "matplotlib": [17, 28], "pyplot": [17, 28], "plt": [17, 28], "sy": 17, "inlin": [17, 28], "19": 17, "05": 17, "58": [17, 27], "gcc": 17, "workout": 17, "pull": 17, "strava": 17, "csv": 17, "look": [17, 18, 19], "head": 17, "workout_data_dd": 17, "read_csv": [17, 21, 22], "cycling_dataset": 17, "index_col": 17, "altitud": 17, "cadenc": 17, "distanc": [17, 20], "hr": 17, "latitud": 17, "longitud": 17, "185": 17, "800003": 17, "51": 17, "46": 17, "81": 17, "30": 17, "313309": 17, "97": [17, 20], "732711": 17, "45": [17, 20], "459": 17, "2016": 17, "20t22": 17, "01": [17, 21], "26": [17, 19], "000z": 17, "68": 17, "17": 17, "82": [17, 23, 27], "313277": 17, "732715": 17, "710": 17, "27": 17, "186": 17, "399994": 17, "38": 17, "313243": 17, "732717": 17, "42": [17, 24, 25, 27, 28], "874": 17, "15": [17, 20, 23], "83": [17, 21, 25], "313212": 17, "732720": 17, "135": 17, "29": [17, 19], "600006": 17, "43": [17, 23], "313172": 17, "732723": 17, "250": 17, "would": 17, "great": 17, "might": 17, "revolut": 17, "per": 17, "crank": 17, "heart": 17, "bodi": 17, "strain": 17, "high": 17, "possibli": 17, "loos": 17, "highli": 17, "rout": 17, "ti": 17, "directli": 17, "gener": 17, "try": 17, "watt": 17, "basic": 17, "scatterplot": 17, "pattern": 17, "itself": 17, "posit": 17, "plot": 17, "scatter": [17, 28], "arrang": 17, "separ": 17, "independ": 17, "workabl": 17, "d4p": 17, "now": 17, "train_set": 17, "3000": 17, "test_set": 17, "3902": 17, "902": 17, "non": 17, "essenti": [17, 30], "reduced_dataset": 17, "axi": 17, "ndmin": 17, "t": 17, "forc": 17, "3k": 17, "row": 17, "column": [17, 20, 24, 27], "linear_regression_train": 17, "d4p_lm": 17, "interceptflag": 17, "lm_train": 17, "numberoffeatur": 17, "put": 17, "linear_regression_predict": 17, "subset": 17, "object": 17, "lm_predictor_compon": 17, "300": 17, "graph": 17, "orang": 17, "blue": 17, "notori": 17, "lead": 17, "difficult": 17, "aspect": 17, "beta": 17, "numberofbeta": 17, "51003501e": 17, "25075548e": 17, "32249115e": 17, "00": 17, "64363922e": 17, "03": [17, 22, 23], "53155955e": 17, "09595022e": 17, "low_order_mo": 17, "metrics_processor": 17, "standarddevi": 17, "90063975e": 17, "75882355e": 17, "98258371e": 17, "41394741e": 17, "81623064e": 17, "occasion": 17, "much": [17, 19, 30], "place": 17, "smaller": 17, "pickl": 17, "16": 17, "trained_model2": 17, "wb": [17, 21, 22], "model_pi": 17, "dump": 17, "close": 17, "move": 17, "embed": 17, "extreamli": 17, "heavi": 17, "rb": 17, "model_import": 17, "lm_import": 17, "load": 17, "usabl": 17, "again": 17, "ensur": 17, "davies_bouldin_scor": 18, "minmaxscal": [18, 19, 21, 22, 26], "scaler_x": [18, 19, 21, 22, 26], "n_job": [18, 20, 22, 23, 25], "y_pred": [18, 25], "fit_predict": 18, "37": [18, 28], "davi": 18, "bouldin": 18, "score": [18, 20, 24, 27], "score_opt": [18, 24], "8542652084275848": 18, "469": 18, "21": 18, "score_origin": [18, 24], "originaldavi": 18, "73": 18, "123": [19, 25], "236930": 19, "26326": 19, "128": 19, "36": [19, 20], "inertia": 19, "iter": 19, "inertia_opt": 19, "inertia_": 19, "n_iter_opt": 19, "n_iter_": 19, "13346": 19, "641333761074": 19, "274": 19, "192": 19, "inertia_origin": 19, "n_iter_origin": 19, "13352": 19, "813785961785": 19, "212": 19, "bigger": 19, "lower": [19, 30], "originalinertia": 19, "9995377414603653": 19, "lowerwith": 19, "mnist_784": 20, "72": [20, 25], "56000": 20, "784": 20, "14000": 20, "n_neighbor": 20, "40": 20, "time_opt": [20, 28], "report": [20, 27, 29], "classification_report": [20, 27], "precis": [20, 27], "recal": [20, 27], "f1": [20, 27], "99": 20, "98": 20, "1365": 20, "93": 20, "1637": 20, "94": 20, "1401": 20, "95": 20, "1455": 20, "1380": 20, "1219": 20, "1317": 20, "1420": 20, "1379": 20, "92": 20, "1427": 20, "macro": [20, 27], "avg": [20, 27], "label": [20, 27], "mnsit": 20, "time_origin": [20, 28], "h2": [20, 27], "24": [20, 23, 24], "request": [21, 22, 29], "dataset_dir": [21, 22], "dataset_nam": [21, 22], "year_prediction_msd": [21, 22], "url": [21, 22], "archiv": [21, 22], "ic": [21, 22], "uci": [21, 22], "edu": [21, 22], "ml": [21, 22], "databas": [21, 22], "00203": [21, 22], "txt": [21, 22], "zip": [21, 22, 28], "makedir": [21, 22], "exist_ok": [21, 22], "local_url": [21, 22], "path": [21, 22], "join": [21, 22], "basenam": [21, 22], "isfil": [21, 22], "stream": [21, 22], "iter_cont": [21, 22], "8192": [21, 22], "header": [21, 22], "iloc": [21, 22], "463810": [21, 22], "51535": [21, 22], "06": [21, 26, 27], "9676607251167297": 21, "9676599502563477": 21, "0000008344650269": 21, "7716818451881409": 22, "53": 22, "7716856598854065": 22, "9999950528144836": 22, "100": [23, 25, 27, 28], "54000": 23, "3072": 23, "6000": 23, "multinomi": 23, "predict_proba": 23, "log_loss_opt": 23, "log_loss": 23, "7073530800931587": 23, "395": 23, "log_loss_origin": 23, "7140870590578428": 23, "originallog": 23, "9981869086917978": 23, "medical_charges_nomin": 24, "cat_column": 24, "select_dtyp": 24, "lambda": 24, "cat": 24, "train_siz": 24, "48919": 24, "114146": 24, "degre": 24, "poli": 24, "69": 24, "r2": 24, "8635974264586637": 24, "331": 24, "85": 24, "8636031741516902": 24, "originalr2": 24, "999993344520726": 24, "280000": 25, "120000": 25, "ensembl": 25, "n_estim": 25, "150": 25, "44": 25, "rf": 25, "56": 25, "mse_opt": 25, "squar": 25, "62232345666878": 25, "34": 25, "mse_origin": 25, "80131297814816": 25, "9978641203208111": 25, "0014288520708046": 26, "70": 26, "0014288520708057": 26, "9999999999999989": 26, "a9a": 27, "gamma": 27, "scale": [27, 30], "08": 27, "87": 27, "88": 27, "7414": 27, "64": 27, "61": 27, "2355": 27, "9769": 27, "76": 27, "74": 27, "75": 27, "803": 27, "57": 27, "make_blob": 28, "isotrop": 28, "gaussian": 28, "20k": 28, "org": 28, "stabl": 28, "n_sampl": 28, "20000": 28, "center": 28, "n_featur": 28, "manifold": 28, "embedding_intelex": 28, "fit_transform": 28, "diverg": 28, "kl_divergence_": 28, "63": 28, "289110606110757": 28, "embedding_origin": 28, "66": 28, "2955403327941895": 28, "color": 28, "int": 28, "emb": 28, "titl": 28, "xlabel": 28, "ylabel": 28, "assist": 29, "most": 29, "out": [29, 31], "face": 29, "problem": 29, "address": 29, "encount": 29, "idea": 29, "updat": 29, "comment": 29, "har": 30, "potenti": 30, "overview": 30, "advanc": 30, "special": 30, "techniqu": 30, "solut": 30, "maxim": 30, "classic": 30, "googl": 30, "colaboratori": 30, "workload": 30, "gpair": 30, "drive": 30, "innov": 30, "greener": 30, "environment": 30, "7x": 30, "suppli": 30, "chain": 30, "enterpris": 30, "technologi": 30, "red": 30, "hat": 30, "openshift": 30, "scienc": 30, "hipposcreen": 30, "4x": 30, "neurotechnologi": 30, "startup": 30, "deep": 30, "brain": 30, "wave": 30, "sklearnex_verbos": 31, "variabl": 31, "shown": 31, "On": 31, "export": 31, "info": 31, "logger": 31, "getlogg": 31, "setlevel": 31, "dure": 31, "receiv": 31, "statement": 31, "indic": 31, "being": 31}, "objects": {}, "objtypes": {}, "objnames": {}, "titleterms": {"support": [1, 4, 7, 13, 14, 29], "algorithm": [1, 7, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "cpu": [1, 7], "classif": [1, 10], "regress": [1, 11, 21, 22, 23, 26], "cluster": 1, "dimension": 1, "reduct": 1, "nearest": 1, "neighbor": 1, "other": 1, "task": [1, 10, 11, 17], "gpu": [1, 7, 13], "scikit": [1, 7, 8, 9, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], "learn": [1, 7, 8, 9, 13, 14, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], "test": 1, "follow": 2, "u": 2, "medium": 2, "how": 3, "contribut": 3, "licens": [3, 12], "pull": 3, "request": 3, "befor": 3, "chang": 3, "code": 3, "style": 3, "deprec": 4, "notic": 4, "maco": 4, "distribut": 5, "mode": [5, 31], "tune": 6, "guid": 6, "tsne": [6, 28], "random": [6, 25], "forest": [6, 25], "intel": [7, 8, 9, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], "extens": [7, 8, 9, 13, 14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], "r": [7, 14, 29], "optim": 7, "enabl": 7, "kaggl": [8, 9, 10, 11], "kernel": [8, 9, 10, 11], "acceler": 8, "machin": [8, 17], "workflow": [8, 17], "us": [8, 9, 11, 17], "automl": [8, 9], "binari": 10, "multiclass": 10, "comput": 10, "vision": 10, "natur": 10, "languag": 10, "process": 10, "singl": 11, "regressor": 11, "stack": 11, "oneapi": 13, "prerequisit": 13, "devic": 13, "offload": 13, "exampl": [13, 28], "quick": 14, "start": 14, "compat": 14, "integr": 14, "patch": [14, 16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "global": 14, "unpatch": 14, "instal": 14, "from": 14, "pypi": 14, "anaconda": 14, "cloud": 14, "configur": 14, "build": 14, "sourc": 14, "ai": 14, "tool": 14, "releas": 14, "note": 14, "system": [14, 17], "requir": 14, "hardwar": 14, "softwar": 14, "memori": 14, "sampl": 15, "elasticnet": 16, "airlin": [16, 26], "depdelai": [16, 26], "dataset": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "download": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "data": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "preprocess": [16, 18, 19, 24, 26], "origin": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28], "train": [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "same": [16, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27], "util": 17, "daal4pi": 17, "scienc": 17, "explor": 17, "visual": 17, "some": 17, "model": 17, "predict": 17, "infer": 17, "properti": 17, "addit": 17, "metric": 17, "migrat": 17, "extern": 17, "dbscan": 18, "spoken": [18, 19], "arab": [18, 19], "digit": [18, 19], "kmean": 19, "knn": 20, "mnist": 20, "lasso": 21, "yearpredictionmsd": [21, 22], "normal": [21, 22], "linear": 22, "logist": 23, "cifar": 23, "nusvr": 24, "medic": 24, "charg": 24, "yolanda": 25, "ridg": 26, "svc": 27, "adult": 27, "gener": 28, "plot": 28, "embed": 28, "issu": 29, "tutori": 30, "case": 30, "studi": 30, "verbos": 31}, "envversion": {"sphinx.domains.c": 2, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 8, "sphinx.domains.index": 1, "sphinx.domains.javascript": 2, "sphinx.domains.math": 2, "sphinx.domains.python": 3, "sphinx.domains.rst": 2, "sphinx.domains.std": 2, "sphinx.ext.todo": 2, "sphinx.ext.viewcode": 1, "nbsphinx": 4, "sphinx": 57}, "alltitles": {"Supported Algorithms": [[1, "supported-algorithms"], [7, "supported-algorithms"]], "on CPU": [[1, "on-cpu"]], "Classification": [[1, "classification"], [1, "id1"]], "Regression": [[1, "regression"], [1, "id2"]], "Clustering": [[1, "clustering"], [1, "id3"]], "Dimensionality reduction": [[1, "dimensionality-reduction"], [1, "id4"]], "Nearest Neighbors": [[1, "nearest-neighbors"], [1, "id5"]], "Other tasks": [[1, "other-tasks"]], "on GPU": [[1, "on-gpu"]], "Scikit-learn tests": [[1, "scikit-learn-tests"]], "Follow us on Medium": [[2, "follow-us-on-medium"]], "How to Contribute": [[3, "how-to-contribute"]], "Licensing": [[3, "licensing"]], "Pull Requests": [[3, "pull-requests"]], "Before Contributing Changes": [[3, "before-contributing-changes"]], "Code Style": [[3, "code-style"]], "Deprecation Notice": [[4, "deprecation-notice"]], "macOS* Support": [[4, "macos-support"]], "Distributed Mode": [[5, "distributed-mode"]], "Tuning Guide": [[6, "tuning-guide"]], "TSNE": [[6, "tsne"]], "Random Forest": [[6, "random-forest"]], "Intel\u00ae Extension for Scikit-learn*": [[7, "intelex"]], "Intel(R) Optimizations": [[7, "intel-r-optimizations"]], "Enable Intel(R) CPU Optimizations": [[7, "enable-intel-r-cpu-optimizations"]], "Enable Intel(R) GPU optimizations": [[7, "enable-intel-r-gpu-optimizations"]], "Kaggle Kernels": [[8, "kaggle-kernels"]], "Acceleration": [[8, "acceleration"]], "Machine Learning Workflows": [[8, "machine-learning-workflows"]], "Kaggle kernels that use scikit-learn and Intel\u00ae Extension for Scikit-learn*:": [[8, "kaggle-kernels-that-use-scikit-learn-and-intelex"]], "Kaggle kernels that use AutoML with Intel\u00ae Extension for Scikit-learn*:": [[8, "kaggle-kernels-that-use-automl-with-intelex"]], "Kaggle Kernels that use AutoML and Intel\u00ae Extension for Scikit-learn*": [[9, "kaggle-kernels-that-use-automl-and-intelex"]], "Kaggle Kernels for Classification Tasks": [[10, "kaggle-kernels-for-classification-tasks"]], "Binary Classification": [[10, "binary-classification"]], "MultiClass Classification": [[10, "multiclass-classification"]], "Classification Tasks in Computer Vision": [[10, "classification-tasks-in-computer-vision"]], "Classification Tasks in Natural Language Processing": [[10, "classification-tasks-in-natural-language-processing"]], "Kaggle Kernels for Regression Tasks": [[11, "kaggle-kernels-for-regression-tasks"]], "Using a Single Regressor": [[11, "using-a-single-regressor"]], "Stacking Regressors": [[11, "stacking-regressors"]], "License": [[12, "license"]], "oneAPI and GPU support in Intel\u00ae Extension for Scikit-learn*": [[13, "oneapi-and-gpu-support-in-intelex"]], "Prerequisites": [[13, "prerequisites"]], "Device offloading": [[13, "device-offloading"]], "Example": [[13, "example"]], "Quick Start": [[14, "quick-start"]], "Compatibility with Scikit-learn*": [[14, "compatibility-with-scikit-learn"]], "Integrate Intel\u00ae Extension for Scikit-learn*": [[14, "integrate-intelex"]], "Patching": [[14, "patching"]], "Global Patching": [[14, "global-patching"]], "Unpatching": [[14, "unpatching"]], "Installation": [[14, "installation"]], "Install from PyPI": [[14, "install-from-pypi"]], "Install from Anaconda* Cloud": [[14, "install-from-anaconda-cloud"]], "Supported Configurations": [[14, "id3"], [14, "id4"], [14, "id5"]], "Build from Sources": [[14, "build-from-sources"]], "Install Intel*(R) AI Tools": [[14, "install-intel-r-ai-tools"]], "Release Notes": [[14, "release-notes"]], "System Requirements": [[14, "system-requirements"]], "Hardware Requirements": [[14, "hardware-requirements"]], "Software Requirements": [[14, "software-requirements"]], "Memory Requirements": [[14, "memory-requirements"]], "Samples": [[15, "samples"]], "Intel\u00ae Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset": [[16, "Intel\u00ae-Extension-for-Scikit-learn-ElasticNet-for-Airlines-DepDelay-dataset"]], "Download the data": [[16, "Download-the-data"], [18, "Download-the-data"], [19, "Download-the-data"], [20, "Download-the-data"], [21, "Download-the-data"], [22, "Download-the-data"], [23, "Download-the-data"], [24, "Download-the-data"], [25, "Download-the-data"], [26, "Download-the-data"], [27, "Download-the-data"]], "Preprocessing": [[16, "Preprocessing"], [18, "Preprocessing"], [19, "Preprocessing"], [24, "Preprocessing"], [26, "Preprocessing"]], "Patch original Scikit-learn with Intel\u00ae Extension for Scikit-learn": [[16, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [18, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [19, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [20, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [21, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [22, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [23, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [24, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [25, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [26, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [27, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"], [28, "Patch-original-Scikit-learn-with-Intel\u00ae-Extension-for-Scikit-learn"]], "Train the same algorithm with original Scikit-learn": [[16, "Train-the-same-algorithm-with-original-Scikit-learn"], [18, "Train-the-same-algorithm-with-original-Scikit-learn"], [19, "Train-the-same-algorithm-with-original-Scikit-learn"], [20, "Train-the-same-algorithm-with-original-Scikit-learn"], [21, "Train-the-same-algorithm-with-original-Scikit-learn"], [22, "Train-the-same-algorithm-with-original-Scikit-learn"], [23, "Train-the-same-algorithm-with-original-Scikit-learn"], [24, "Train-the-same-algorithm-with-original-Scikit-learn"], [25, "Train-the-same-algorithm-with-original-Scikit-learn"], [26, "Train-the-same-algorithm-with-original-Scikit-learn"], [27, "Train-the-same-algorithm-with-original-Scikit-learn"]], "Utilizing daal4py in Data Science Workflows": [[17, "Utilizing-daal4py-in-Data-Science-Workflows"]], "Explore and visualize some of the data": [[17, "Explore-and-visualize-some-of-the-data"]], "Using daal4py for Machine Learning tasks": [[17, "Using-daal4py-for-Machine-Learning-tasks"]], "Training the model": [[17, "Training-the-model"]], "Prediction (inference) with the trained model": [[17, "Prediction-(inference)-with-the-trained-model"]], "Model properties": [[17, "Model-properties"]], "Additional metrics": [[17, "Additional-metrics"]], "Migrating the trained model for inference on external systems": [[17, "Migrating-the-trained-model-for-inference-on-external-systems"]], "Intel\u00ae Extension for Scikit-learn DBSCAN for spoken arabic digit dataset": [[18, "Intel\u00ae-Extension-for-Scikit-learn-DBSCAN-for-spoken-arabic-digit-dataset"]], "Intel\u00ae Extension for Scikit-learn Kmeans for spoken arabic digit dataset": [[19, "Intel\u00ae-Extension-for-Scikit-learn-Kmeans-for-spoken-arabic-digit-dataset"]], "Intel\u00ae Extension for Scikit-learn KNN for MNIST dataset": [[20, "Intel\u00ae-Extension-for-Scikit-learn-KNN-for-MNIST-dataset"]], "Intel\u00ae Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset": [[21, "Intel\u00ae-Extension-for-Scikit-learn-Lasso-Regression-for-YearPredictionMSD-dataset"]], "Normalize the data": [[21, "Normalize-the-data"], [22, "Normalize-the-data"]], "Intel\u00ae Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset": [[22, "Intel\u00ae-Extension-for-Scikit-learn-Linear-Regression-for-YearPredictionMSD-dataset"]], "Intel\u00ae Extension for Scikit-learn Logistic Regression for Cifar dataset": [[23, "Intel\u00ae-Extension-for-Scikit-learn-Logistic-Regression-for-Cifar-dataset"]], "Intel\u00ae Extension for Scikit-learn NuSVR for Medical Charges dataset": [[24, "Intel\u00ae-Extension-for-Scikit-learn-NuSVR-for-Medical-Charges-dataset"]], "Intel\u00ae Extension for Scikit-learn Random Forest for Yolanda dataset": [[25, "Intel\u00ae-Extension-for-Scikit-learn-Random-Forest-for-Yolanda-dataset"]], "Intel\u00ae Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset": [[26, "Intel\u00ae-Extension-for-Scikit-learn-Ridge-Regression-for-Airlines-DepDelay-dataset"]], "Intel\u00ae Extension for Scikit-learn SVC for Adult dataset": [[27, "Intel\u00ae-Extension-for-Scikit-learn-SVC-for-Adult-dataset"]], "Intel\u00ae Extension for Scikit-learn TSNE example": [[28, "Intel\u00ae-Extension-for-Scikit-learn-TSNE-example"]], "Generate the data": [[28, "Generate-the-data"]], "Plot embeddings original scikit-learn and Intel\u00ae extension": [[28, "Plot-embeddings-original-scikit-learn-and-Intel\u00ae-extension"]], "Intel(R) Extension for Scikit-learn Support": [[29, "intel-r-extension-for-scikit-learn-support"]], "Issues": [[29, "issues"]], "Intel\u00ae Extension for Scikit-learn* Tutorials & Case Studies": [[30, "intelex-tutorials-case-studies"]], "Tutorials": [[30, "tutorials"]], "Case Studies": [[30, "case-studies"]], "Verbose Mode": [[31, "verbose-mode"]]}, "indexentries": {}})
\ No newline at end of file
diff --git a/2024.3/support.html b/2024.3/support.html
new file mode 100644
index 0000000000..7d4ad745fc
--- /dev/null
+++ b/2024.3/support.html
@@ -0,0 +1,401 @@
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn Support — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Intel(R) Extension for Scikit-learn Support
+We are committed to providing support and assistance to help you make the most out of Intel(R) Extension for Scikit-learn.
+Use the following methods if you face any challenges.
+
+Issues
+If you have a problem, check out the GitHub Issues to see if the issue you want to address is already reported.
+You may find users that have encountered the same bug or have similar ideas for changes or updates.
+You can use issues to report a problem, make a feature request, or add comments on an existing issue.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/tutorials.html b/2024.3/tutorials.html
new file mode 100644
index 0000000000..7463c9f6ec
--- /dev/null
+++ b/2024.3/tutorials.html
@@ -0,0 +1,498 @@
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn* Tutorials & Case Studies — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+ Intel® Extension for Scikit-learn* Tutorials & Case Studies
+
+ View page source
+
+
+
+
+
+
+
+
+Intel® Extension for Scikit-learn* Tutorials & Case Studies
+Explore the tutorials & case studies to help you to harness the full potential of Intel® Extension for Scikit-learn*.
+
+Tutorials
+
+
+
+
+
+
+Introduction to scikit-learn* Essentials for Machine Learning
+
An overview of scikit-learn essentials.
+
+
+
+
+
+
+
+Advanced scikit-learn* Essentials for Machine Learning
+
Special technique to perform scikit-learn computation on Intel GPUs.
+
+
+
+
+
+
+
+Develop Efficient AI Solutions with Accelerated Machine Learning
+
Techniques for maximizing Intel® Extension for Scikit-learn*.
+
+
+
+
+
+
+
+Getting started with classical Machine Learning Frameworks using Google Colaboratory
+
Simple Installation of Intel® Extension for Scikit-learn* on Google Colaboratory.
+
+
+
+
+
+
+
+Accelerate Machine Learning Workloads: K-means and GPairs Algorithms
+
An introduction to Intel® Extension for Scikit-learn*.
+
+
+
+
+
+
+
+Benchmarking Intel® Extension for Scikit-learn*: How Much Faster Is It?
+
Explore and compare the performance of the Intel Extension for Scikit-learn* vs. stock Scikit-learn*.
+
+
+
+
+
+
+
+Drive Innovation & Performance into Your scikit-learn* Machine Learning Tasks
+
An overview of scikit-learn essentials.
+
+
+
+
+
+
+
+Case Studies
+
+
+
+
+
+
+Greener Machine Learning Computing with Intel® AI Acceleration
+
Lowering the Environmental Impact of AI Workloads by 7x using Intel® Extension for Scikit-learn*.
+
+
+
+
+
+
+
+Supply Chain Optimization at Enterprise Scale
+
Leveraging Open-Source AI Technologies with Red Hat OpenShift* Data Science and Intel® Architecture.
+
+
+
+
+
+
+
+HippoScreen Improves AI Performance by 2.4x with oneAPI Tools
+
The neurotechnology startup used Intel® Extension for Scikit-learn* to the improve efficiency and build times of deep-learning models used in its Brain Waves AI system.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.3/verbose.html b/2024.3/verbose.html
new file mode 100644
index 0000000000..c35384f794
--- /dev/null
+++ b/2024.3/verbose.html
@@ -0,0 +1,428 @@
+
+
+
+
+
+
+ Verbose Mode — Intel(R) Extension for Scikit-learn* 2024.3 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Verbose Mode
+Use Intel® Extension for Scikit-learn* in verbose mode to find out which implementation of the algorithm is currently used,
+Intel® Extension for Scikit-learn* or original Scikit-learn.
+
+To enable verbose mode, set the SKLEARNEX_VERBOSE
environment variable as shown below:
+
+On Linux* OS
+export SKLEARNEX_VERBOSE = INFO
+
+
+
+On Windows* OS
+set SKLEARNEX_VERBOSE = INFO
+
+
+
+
+Alternatively, get Intel® Extension for Scikit-learn* logger and set its logging level in the Python code:
+import logging
+logger = logging . getLogger ( 'sklearnex' )
+logger . setLevel ( logging . INFO )
+
+
+During the calls that use Intel-optimized scikit-learn, you will receive additional print statements
+that indicate which implementation is being called.
+These print statements are only available for supported algorithms .
+For example, for DBSCAN you get one of these print statements depending on which implementation is used:
+INFO : sklearnex : sklearn . cluster . DBSCAN . fit : running accelerated version on CPU
+
+
+INFO : sklearnex : sklearn . cluster . DBSCAN . fit : fallback to original Scikit - learn
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.6/.buildinfo b/2024.6/.buildinfo
new file mode 100644
index 0000000000..a5c62ffc6d
--- /dev/null
+++ b/2024.6/.buildinfo
@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: 1597415444d57aac71d8e2ad9465fd7d
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/2024.6/.doctrees/404.doctree b/2024.6/.doctrees/404.doctree
new file mode 100644
index 0000000000..e9f6567a29
Binary files /dev/null and b/2024.6/.doctrees/404.doctree differ
diff --git a/2024.6/.doctrees/algorithms.doctree b/2024.6/.doctrees/algorithms.doctree
new file mode 100644
index 0000000000..94b95d8ec4
Binary files /dev/null and b/2024.6/.doctrees/algorithms.doctree differ
diff --git a/2024.6/.doctrees/blogs.doctree b/2024.6/.doctrees/blogs.doctree
new file mode 100644
index 0000000000..9186bb0341
Binary files /dev/null and b/2024.6/.doctrees/blogs.doctree differ
diff --git a/2024.6/.doctrees/contribute.doctree b/2024.6/.doctrees/contribute.doctree
new file mode 100644
index 0000000000..dcf0f8c44f
Binary files /dev/null and b/2024.6/.doctrees/contribute.doctree differ
diff --git a/2024.6/.doctrees/deprecation.doctree b/2024.6/.doctrees/deprecation.doctree
new file mode 100644
index 0000000000..eea5dd6825
Binary files /dev/null and b/2024.6/.doctrees/deprecation.doctree differ
diff --git a/2024.6/.doctrees/distributed-mode.doctree b/2024.6/.doctrees/distributed-mode.doctree
new file mode 100644
index 0000000000..eaba0df49d
Binary files /dev/null and b/2024.6/.doctrees/distributed-mode.doctree differ
diff --git a/2024.6/.doctrees/environment.pickle b/2024.6/.doctrees/environment.pickle
new file mode 100644
index 0000000000..1a40c6186a
Binary files /dev/null and b/2024.6/.doctrees/environment.pickle differ
diff --git a/2024.6/.doctrees/guide/acceleration.doctree b/2024.6/.doctrees/guide/acceleration.doctree
new file mode 100644
index 0000000000..2138c3585f
Binary files /dev/null and b/2024.6/.doctrees/guide/acceleration.doctree differ
diff --git a/2024.6/.doctrees/index.doctree b/2024.6/.doctrees/index.doctree
new file mode 100644
index 0000000000..4eebbaa35e
Binary files /dev/null and b/2024.6/.doctrees/index.doctree differ
diff --git a/2024.6/.doctrees/kaggle.doctree b/2024.6/.doctrees/kaggle.doctree
new file mode 100644
index 0000000000..97a6163cfe
Binary files /dev/null and b/2024.6/.doctrees/kaggle.doctree differ
diff --git a/2024.6/.doctrees/kaggle/automl.doctree b/2024.6/.doctrees/kaggle/automl.doctree
new file mode 100644
index 0000000000..cdc7adb6ae
Binary files /dev/null and b/2024.6/.doctrees/kaggle/automl.doctree differ
diff --git a/2024.6/.doctrees/kaggle/classification.doctree b/2024.6/.doctrees/kaggle/classification.doctree
new file mode 100644
index 0000000000..023f54255a
Binary files /dev/null and b/2024.6/.doctrees/kaggle/classification.doctree differ
diff --git a/2024.6/.doctrees/kaggle/regression.doctree b/2024.6/.doctrees/kaggle/regression.doctree
new file mode 100644
index 0000000000..fcd437cd85
Binary files /dev/null and b/2024.6/.doctrees/kaggle/regression.doctree differ
diff --git a/2024.6/.doctrees/license.doctree b/2024.6/.doctrees/license.doctree
new file mode 100644
index 0000000000..a110db12da
Binary files /dev/null and b/2024.6/.doctrees/license.doctree differ
diff --git a/2024.6/.doctrees/nbsphinx/samples/ElasticNet.ipynb b/2024.6/.doctrees/nbsphinx/samples/ElasticNet.ipynb
new file mode 100644
index 0000000000..29e5dca851
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/ElasticNet.ipynb
@@ -0,0 +1,386 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn ElasticNet for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "34e460a7",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "00c2277b",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "06d309c0",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "2ff35bc2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "38637349",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import StandardScaler\n",
+ "\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.28 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"l1_ratio\": 0.7,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0109113399224974'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class ElasticNet"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the ElasticNet algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 3.96 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import ElasticNet\n",
+ "\n",
+ "start = timer()\n",
+ "model = ElasticNet(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the ElasticNet algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0109113399545733'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "a2edbb65",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0109113399224974 MSE metric of unpatched Scikit-learn: 1.0109113399545733 Metrics ratio: 0.9999999999682703 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 14.2 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb b/2024.6/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb
new file mode 100644
index 0000000000..9336772cb3
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb
@@ -0,0 +1,650 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Utilizing daal4py in Data Science Workflows\n",
+ "\n",
+ "The notebook below has been made to demonstrate daal4py in a data science context. It utilizes a Cycling Dataset for pyworkout-toolkit, and attempts to create a linear regression model from the 5 features collected for telemetry to predict the user's Power output in the absence of a power meter."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'3.8.10 (default, May 19 2021, 18:05:58) \\n[GCC 7.3.0]'"
+ ]
+ },
+ "execution_count": 1,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "import pandas as pd\n",
+ "import matplotlib.pyplot as plt\n",
+ "import glob\n",
+ "import sys\n",
+ "\n",
+ "%matplotlib inline\n",
+ "sys.version"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "This example will be exploring workout data pulled from Strava, processed into a CSV for Pandas and daal4py usage. Below, we utilize pandas to read in the CSV file, and look at the head of dataframe with .head()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "\n",
+ "\n",
+ "
\n",
+ " \n",
+ " \n",
+ " \n",
+ " altitude \n",
+ " cadence \n",
+ " distance \n",
+ " hr \n",
+ " latitude \n",
+ " longitude \n",
+ " power \n",
+ " speed \n",
+ " time \n",
+ " \n",
+ " \n",
+ " \n",
+ " \n",
+ " 0 \n",
+ " 185.800003 \n",
+ " 51 \n",
+ " 3.46 \n",
+ " 81 \n",
+ " 30.313309 \n",
+ " -97.732711 \n",
+ " 45 \n",
+ " 3.459 \n",
+ " 2016-10-20T22:01:26.000Z \n",
+ " \n",
+ " \n",
+ " 1 \n",
+ " 185.800003 \n",
+ " 68 \n",
+ " 7.17 \n",
+ " 82 \n",
+ " 30.313277 \n",
+ " -97.732715 \n",
+ " 0 \n",
+ " 3.710 \n",
+ " 2016-10-20T22:01:27.000Z \n",
+ " \n",
+ " \n",
+ " 2 \n",
+ " 186.399994 \n",
+ " 38 \n",
+ " 11.04 \n",
+ " 82 \n",
+ " 30.313243 \n",
+ " -97.732717 \n",
+ " 42 \n",
+ " 3.874 \n",
+ " 2016-10-20T22:01:28.000Z \n",
+ " \n",
+ " \n",
+ " 3 \n",
+ " 186.800003 \n",
+ " 38 \n",
+ " 15.18 \n",
+ " 83 \n",
+ " 30.313212 \n",
+ " -97.732720 \n",
+ " 5 \n",
+ " 4.135 \n",
+ " 2016-10-20T22:01:29.000Z \n",
+ " \n",
+ " \n",
+ " 4 \n",
+ " 186.600006 \n",
+ " 38 \n",
+ " 19.43 \n",
+ " 83 \n",
+ " 30.313172 \n",
+ " -97.732723 \n",
+ " 1 \n",
+ " 4.250 \n",
+ " 2016-10-20T22:01:30.000Z \n",
+ " \n",
+ " \n",
+ "
\n",
+ "
"
+ ],
+ "text/plain": [
+ " altitude cadence distance hr latitude longitude power speed \\\n",
+ "0 185.800003 51 3.46 81 30.313309 -97.732711 45 3.459 \n",
+ "1 185.800003 68 7.17 82 30.313277 -97.732715 0 3.710 \n",
+ "2 186.399994 38 11.04 82 30.313243 -97.732717 42 3.874 \n",
+ "3 186.800003 38 15.18 83 30.313212 -97.732720 5 4.135 \n",
+ "4 186.600006 38 19.43 83 30.313172 -97.732723 1 4.250 \n",
+ "\n",
+ " time \n",
+ "0 2016-10-20T22:01:26.000Z \n",
+ "1 2016-10-20T22:01:27.000Z \n",
+ "2 2016-10-20T22:01:28.000Z \n",
+ "3 2016-10-20T22:01:29.000Z \n",
+ "4 2016-10-20T22:01:30.000Z "
+ ]
+ },
+ "execution_count": 2,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "workout_data_dd = pd.read_csv(\"data/cycling_dataset.csv\", index_col=0)\n",
+ "workout_data_dd.head()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The data above has several key features that would be of great use here. \n",
+ "- Altitude can affect performance, so it might be a useful feature. \n",
+ "- Cadence is the revolutions per minute of the crank, and may have possible influence. \n",
+ "- Heart Rate is a measure of the body's workout strain, and would have a high possibly of influence.\n",
+ "- Distance may have a loose correlation as it is highly route dependent, but might be possible.\n",
+ "- Speed has possible correlations as it ties directly into power."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Explore and visualize some of the data"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "In general, we are trying to predict on the 'power' in Watts to see if we can generate a model that can predict one's power output without the usage of a cycling power meter. Below are some basic scatterplots as we explore the data. Scatterplots are great for looking for patterns and correlation in the data itself. Below, we can see that cadence and speed are positively correlated. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABqVklEQVR4nO2deXwV5b3/P9+ZsyQkECDIEsIiRtQEgQoVEaSKtHVhaX8itqL23mq97RXbuiC2vS7A7aJoN7X2UmuvtNgKeCuI1lYFRRDQoAkmiBD2sBNDICGcZeb5/TFnJnNmnjlnzpZzkjzv10vJmTMz55mZZ57v83xXYoxBIBAIBAIAkLLdAIFAIBDkDkIoCAQCgcBACAWBQCAQGAihIBAIBAIDIRQEAoFAYODJdgNSoU+fPmzo0KHZboZAIBB0KLZs2XKCMXYO77sOLRSGDh2KysrKbDdDIBAIOhREtM/pO6E+EggEAoGBEAoCgUAgMBBCQSAQCAQGQigIBAKBwEAIBYFAIBAYCKGQJRqaA6g+cBINzYFsN0UgEAgMOrRLakdlZdVBzHt5K7yShJCq4vEbRmL66IHZbpZAIBCIlUJ709AcwLyXt+JsSMXpQBhnQyoeeHmrWDEIBIKcQAiFdqa+sRVeKfq2eyUJ9Y2tWWqRQCAQtCGEQjtT2isfIVWN2hZSVZT2ys9SiwQCgaANIRTameJCPx6/YSTyvBK6+z3I80p4/IaRKC70Z7tpAoFAIAzN2WD66IGYUNYH9Y2tKO2VLwSCQCDIGYRQyBLFhX4hDAQCQc4h1EcCgUAgMBBCQSAQCAQGQigIBAKBwEAIBYFAIBAYCKEgEAgEAgMhFAQCgUBgkFGhQET3EFEtEdUQ0V+JKI+IziWizURUR0QvEZEvsq8/8rku8v3QTLZNIBAIBHYyJhSIaCCA7wMYyxgbAUAG8A0AjwH4FWOsDEAjgNsjh9wOoDGy/VeR/QQCgUDQjmRafeQBkE9EHgDdABwGMBnAisj3LwD4WuTvGZHPiHx/NRFRhtsnEAgEAhMZEwqMsYMAngCwH5owaAKwBcBJxlg4sls9AL2QwEAAByLHhiP7F1vPS0R3ElElEVUeP348U80XCASCLkkm1Ue9oM3+zwVQAqAAwDWpnpcxtpgxNpYxNvacc85J9XQCgUAgMJFJ9dEUAHsYY8cZYyEA/wdgAoCeEXUSAJQCOBj5+yCAQQAQ+b4IQEMG2ycQCAQCC5kUCvsBXEZE3SK2gasBbAOwFsDMyD7fArAy8veqyGdEvl/DGGMZbJ9AIBAILGTSprAZmsH4IwCfRH5rMYB5AO4lojpoNoM/Rg75I4DiyPZ7ATyYqbYJBAKBgA915Mn42LFjWWVlZbabIRAIBB0KItrCGBvL+05ENAsEAoHAQAgFgUAgEBgIoSAQCAQCAyEUBAKBQGAghIJAIBAIDIRQEAgEAoGBEAoCgUAgMBBCQSAQCAQGQigIBAKBwEAIBYFAIBAYCKEgEAgEAgMhFAQCgUBgIISCQCAQCAyEUGhHGpoDqD5wEg3NgWw3RSAQCLh44u8iSAcrqw5i3stb4ZUkhFQVj98wEtNHD4x/oEAgELQjYqXQDjQ0BzDv5a04G1JxOhDG2ZCKB17eKlYMAoEg5xBCoR2ob2yFV4q+1V5JQn1ja5ZaJBAIBHyEUGgHSnvlI6SqUdtCqorSXvlZapFAIBDwEUKhHSgu9OPxG0Yizyuhu9+DPK+Ex28YieJCf7abJhAIBFEIQ3M7MX30QEwo64P6xlaU9srvsAKhoTnQ4a9BIBA4I4RCO1Jc6O/QA6nwoBIIOj9CfSRwhfCgEgi6BkIoCFzRnh5UIshPIMgeQn0kcEVpr3wElcx7UAkVlUCQXcRKQeCK9XUnoJjcar0ypd2DSqioBILsI4SCIC76YB02LRQkAiaU9Unr74ggP4Eg+wihIIgLb7D2yXLaB2sR5CcQZB8hFARxiTdYJ2sYth4ngvwEguwjDM2CuOiD9QMWA3BxoT9pw7DTcZ0lyE8g6KgQYyzbbUiasWPHssrKymw3o8tgjWZuaA5gwmNrcDbUtorI80rYMG9yzME82eMEAkF6IKItjLGxvO+E+kjgmuJCP0YN6mkM3MkahoVBWSDIXYRQECRNsoZhYVAWCHIXIRQESZOsYVgYlAWC3EXYFAQpk2zmVJFxVSDIDrFsCsL7KMN0hYEv2eyvHT1rrEDQGRFCIYPEc9fsCgJDEBvRBwS5hhAKGcKcx+csNKPq/curUT6gB8r6dReJ3zh0tQFS9AFBLpJRQzMR9SSiFUS0nYg+JaLxRNSbiN4kop2Rf3tF9iUi+i0R1RHRViK6JJNtyzQ8t8ugwnDdU+uxdNM+kfjNwsqqg5jw2Brc8txmTHhsDVZVHcx2kzKKSP4nyFUy7X30GwBvMMYuBDAKwKcAHgTwNmPsfABvRz4DwLUAzo/8dyeAZzPcNi7pyuXPc7sEgGBYxfxXa+GRKGp7V/bT74oDZH1jq+gDgpwkY0KBiIoATALwRwBgjAUZYycBzADwQmS3FwB8LfL3DABLmMYmAD2JaECm2scjnbNV3e3SK9u/88oSgkq011dX9tPvisFsNQeb0BxQorZ15T4gyB0yuVI4F8BxAH8ioo+J6DkiKgDQjzF2OLLPEQD9In8PBHDAdHx9ZFsURHQnEVUSUeXx48fT1thMzFYZAALZtiuM4ZFp5R3ST99pJZXKCqurBbM1NAew8LVttu0PTS3vEH1A0LnJpKHZA+ASAHczxjYT0W/QpioCADDGGBElFCjBGFsMYDGgxSmkq7H6bFU3CgNts9VkXlRdyFhXBH6PZBgUr6no36EMq06G0VQNprES7nVGeH2twCdjRElRFlslEGhkUijUA6hnjG2OfF4BTSgcJaIBjLHDEfXQscj3BwEMMh1fGtnWLqR7tsp78bt5Zfz+1jGYNPwcAB3LT5/nTfXAy1tRPqAHd/uEsj4JXVtXyo7K62sKY512ZSToWGRMfcQYOwLgABFdENl0NYBtAFYB+FZk27cArIz8vQrAbREvpMsANJnUTBkn3akXeC++CoaKkh7paG6746T3rzpwMm32AGvCvc6KSPMhyGUyHadwN4ClROQDsBvAv0MTRMuI6HYA+wDMiuz7OoDrANQBOBPZt11J52y1s6lEnFZSowf17FL2gHTh1Ne6WqyGIPcQuY8yTLpf8mwOGquqDtqE3PTRAx23CxJDBLMJ2otYuY+EUOhA5MKg4SSUxAw3NUThIUF7IhLidQKcDL2JGnST/W3zgO8kDEYN6pnRdnRm0u39JhAkixAKHYRsDRqxVidLN+3D/NXb4JMJYZUJdUcKdLVYDUHuIorsdBCyMWjECuhbumkffvJKDYJhFc0BpUukpkgHsYL87rqyDH6P8EgSZBexUuggZMObyWl1UnvoFOa/WmvbX5bItnIRtoY23AT/AQx3ThqGm8cN7vL3S5AdhFDoQLR3gJfT6gRgkfxNltw9SnQAlhvDeFcRGokE/z3zTh1uHjc4m80VdGGE+qiD0Z4BXuYgqwKfDJ9MeOj6clSUFEHheK09Mq08yt8+Xi6prpQuuz2C/wSCdCCEQgZJVxrubDJ99EA8dH05QiqDzyNh4WvbsKHuhE1Y/PRrIzB73BDjuHiZT7taumwR/CfoKAj1UYbIhZiCdKBn9AyGVQTD2ra5K6rxh9vGYvWciWgJKlzVTzzDOM9eIZPdJtFZcLIJlfXr3qki3wUdHyEUEsSNDjybMQXphjd4B8IM3/3LR1CZ5obKi0+IZxjnCY2WoIKaQ00dPt7BqY842YS6UjJAQe4jhEICuJ39d6ZAJKcKcmeCmpE5lrCLNdgVF/rx0PXl+MkrNVHHLFy9DddU9O9w90knXh9xyozbkTLmCjo3wqbgkkR04J0pEMlsbO7GKSMXzygayzA+YmARCv3R5+zIRlZeH5m7ohrrdhzrtLYSQedDCAWXJFIysrOlRp5Q1geLbx2Dx2eOhN8TfQ9SEXalvfIRVjtPWVJeH9FVbVbvqs7ghCDonAj1kUsSnf0nqydOxm8/k77+VnXITV8sxbLK+rQYRbtCenGgTdU2d0U1JpT1wfq6E53CCSGTxOrTXSW2JVuILKkWYnW4TKeITtRjqaE5gKWb9+OZtXXwyelvk1PmTt3rqMAnO3ofJfIbtYdOAWCoKCnq8C+53kckEM6EFNv33/vSMPzp/b0iG2oMYr0HncWrL9uILKkuidfhMuklkqjH0sqqg3hgRTUCYU2oB8LaMfpsNB1tczKYtwQV7G1oSfrl1AXv5t0NeOJfn8ErS1BYdEI9fZ90CJ72oqE5gCHFBVg9ZyIONZ3FHS98aKvR/dz6PTYVnEyEtduP4aoL++b8NWaaWJHfh5rO4oEVWxEId3yvvlxGCIUIbgflTHmJJOKxpLdVFwhmAmGGFzfvx91Xn59ymwp8MgJKtDokEFYQCiuu7hVv1aULXqYyBCIDpp4uQz+Hrl7R98nzaoNoLs8KeROKuyefjyff3BG1n0+WbIKiJajg0Vdr8V8ra3L6GtsD3nvAVIbrnloPD5Ex+dHpqF59uYwwNEdIxJCcCRKxWfDaaua3a3ai7ujplNqzsuogpj69HhRRL+qTW0ki3PzcZtv+1nvFS2FhFrwBxS7QZCLUHjpl2+dsSM3piGcnz7RrR/S3rQoUxvDItHIjGlxHZJrV4L0HAYUhGFa56riO7JiQqwihECHbbqSJeCw5GTR1Qoo2s0o2lxBv8NYnaGdDKoIKi9KJA9H3ymmQrD3UBKY627BCSiTZnoPAy1V3VacJRUtQwaKZ9mc6e9wQbJg3GfOnV3Qql9x0YH0PfDIZK0Uz3Xxyh/fqy1WE+ihCLnjCuLVZmNsqE6ElaJ9BBcNq0vpW3hLeil8mMCL4Zfu9clKFnWoNc1cIOo9Mq0BFSZGjwMvVWWGsCcWoQT25z7S40I+rLuyL/1pZwz2uK2N+Dwp8MqY+vT7qe7+H8PtbLukUjgm5SFyhQEQygMcYY/e3Q3uySi6kG3CyWVj18+a21hxqwvxVtTZddbL61ngrEQAgifCaQ+4jp0GyR742W7auMjwyYf70CiOhni7weDaFXBwE4k0oYkUxZ3sikquY7xnvHk0a3jfLLey8uHJJJaJNjLHL2qE9CZEJl9T2xK2/tRs3vLqjp3HdU+sRDCfn6mhti9X9dtZYe3xCLIMoz313Qlkfm4urzyPh9bsnoqxfd257Opr3kX4PAbieXAi/+/iIe5ReYrmkuhUKzwIYCGA5gBZ9O2Ps/9LVyGToyELBrb+1U6wAb7BPNo7CqS16DMGp1hB65HtRUpSX0ADNe5EzHeuRKRIZlLqKLz3vnojBu2OQjjiFPAANACabtjEAWRUKHZVEYhIScVW16mJbggoamgMxX85YbVlfdwL3L69GKKKWkglYMGOE6yymPLVJLqjo4mEd2BIZ5N08284wcFrvyUPXl6OhJZj2QMpkV1+C5HElFBhj/57phnQlEhnoefr5oKKgqTXIHfCLC/0JpVFwrsPchAdWbDUEAgAoDFpWU0JUQZ1EyeWMoObBLqgo+PaEc/H8hr2uA6biPdvOsIrgCT5ztls9liDVwDLzvWoNhUFEyPPIHfa+dRRcuaQS0XAiepuIaiKfRxLRf2W2aZ2XRNxfrS56HglQGXDX0o+5JSydMnU6+b4712EmyBJxj3nolZpO6UtvvXeBMMOz7+52DJjiEevZdpZqc/HiZHRSca+13quwqrlau+nTgtRwG6fwBwA/AhACAMbYVgDfyFSjOgMNzQGs23GcmzY50Syq00cPxIZ5k/HM7EsgS1LUy2EdVGoPNUGxxALoUc5O3HVlGfye6LZUlPSwnUdHZcDGXQ1ub0WHwe1gF8ttNNazzXaAZLpw450GpOZeG+9ZBMIMv/zXDiEYMoBbm0I3xtgHRFEzx3AG2tMpWFl1EPctqzICvrwy4fuTz8fN4wYnXW2ruNCPonwvfLIUNXO1qibmLq8CJ/ATT63ZGfX7ejv15TnAcOekYVH7PDzVXgRH50QneBmtHk4FPjnmYNfNJxvV5mI9L6dnm+0AyXThJk7G70ktsMyN4Fn6wX6s+Kgei2YKVVI6cSsUThDRedCMyyCimQAOZ6xVHZiG5gAeWFENs8YhpDA8+eYOPL12JxbNHGV0YF23rufWjycc3KgmOO8nAMBjsVnw9MLPvFOHm8cNNo4ZMbAI3bwyN73AxLI+ru6HlVzxWLHmYNJjIWaNLcVLHx6w5ZWKFzBlvQae3aQzxSVY42QWrt5m2GHmXHW+0Y/c9Gsz5vtovldngmHw4h4DKQRpCvi4FQp3AVgM4EIiOghgD4DZGWtVB6a+sRUySQDsA2kgzGwdOBHDY6xBpfrAyZhRyAqLnpG6MXaX9sqHwuznk4nQq8Dn+p7o2DxWppajoTn9HivxMAtEHf3vZZX1eO3uK/CPmiN42tIup4CpRJ5hLntfJSqcdcE3alBPXFPRP2mPLR3eMRvmTTZWc9c/td5m3wGSC9LsDB5gmcKt99FuAFOIqACAxBhLLdtaJ8ZpINUxd+BE02UDiakmdDwSsGjmKFdRx2bBUVzox5yr7Jk+u/nkpF5Cm8fK39PvseKGWGk89JxFd1+tzXbjDRxun6G1boRbt972IlWvKPPKKJl+7XTMhnmTjXvlpM4MKomp4DqDB1gmcet9tIuIlgK4FcDgePt3ZYoL/Vg0cxQ8DnfWPPAma3jUZ2fWlN5mA6ffQ/jel4ZhybcvxeYfT7F1erfG7pvHDU5LCc728FhxSywBejYcNrKX8u6zFTfPcGXVQYz72Vu47fkPcNvzH+Kyn7+ddLLCTJBur6hE+3VDcwBrtx+Dx+LtZj2GV9MbAOZcVZaQeqozeIBlErfqo3IA4wBcAWAREV0AYCtj7OsZa1mWSMeyUp/N1x46hY27TuD5DXvgk2WbDtnNbD2R9iSqmnCzvybkUteDt4fHilvMajhzXQcACCnAV3+zDgumj8Dsy+LHYsR7hk42prkrckcPnkjcjBsSMajrs3aewdp6DK+mt1cCrh3R33XbnASTqMnQhluhoEBzR1UAqACORf7rVKRrWakP5BUlPTBp+Dm444ph3IE3nuExmfYkGhjmZv906MGjPFYkQksg/R4riWAW3NYKaYraFqRn1ZVbsT7DoKLgrivLjO+dbEyyRDkzEKXbK8qtQZ1n2wGAAr8MRbV7efGEuSxLmPr0etfvaoFPtv3e2ZAaVduiq+M299EZAJ8A+CWAtxhjOeGkns7cR4nkGIpFMgO5k0dOOtqTa+jXunTTXizb0qZCuX5Efyz42oh2v7bqAyfxzcWbuB5WMgEeWeIawa3PzKle9oSyPrj8F29zvJkkvP9g7jzLTOSkild/u/rASdzy3GacDrR5txf4ZMyfXhGzNCkv+aNPBp771hfjeoc1tQbxnRcqo1aHfpmw7LuX55ydJ5OkI/fRNwFMBPCfAO4govcBrGOMvZ2mNmaddCyhEzGw8VwYre2xFqRhKsuZ2WWyGInxtkZ7NL/92TEsyEJ7YjkGKAxQwqrNCM5LIzKhrA9+904dApb9N8ybjEUzR+FeS9zKopm55YqaCa8o830yu6rGUp8qjMWtVd0SVOCXpSihEFSAb//vh5CI8Mi0iijVnzV1ifVpk0QdLlYkk7j1PloJYCURXQjgWgA/BPAAgE5zJ9OxhHYrWNysJrT6yJbIZIVldZlbd/Q0qg6cxOhBPW2prhNh464GWMfhbNXa1R0D7nmpiusHb0bLCXWKK/gX3zrG8dmbVVVOs+ZcwK3q0Y2dizdB0mJ16oxgs2TiNhqaA2hqDSIQtsfOajKCReXn4rXDI2krNR+nQJTApVAgopcBjAKwC8B7AG4DYC/Uyz9WBlAJ4CBjbCoRnQvgbwCKAWwBcCtjLEhEfgBLAIyBlpH1JsbY3sQuJ3nSEVjErS8bVqIGcreriZagYitIk+eVuNGjmaahOYCHXvkEr9ccNbbdNn4wFsy4OOFzPfzKJ1iyyZ5yI5uRvfqg/dx7u/HH9Xvg9UgIKypUhqiEgNqzZdzBH6CYk4riQj8mDT+nPS4no7hVjzq5/VqDzRJZoZh/O54An//qNsMeZG1HvteDZ2ZfgqJ8r4hT4OBWffRzAB8zxpIZkX4A4FMAPSKfHwPwK8bY34jo9wBuB/Bs5N9GxlgZEX0jst9NSfxe0sTqoG5mRzxDmCRRlCHM7WrCaYBs74FzZdVBPLBiqy1oaMnG/bjtsqEJrRjqjp7mCgSfnP2qasWFfsy79qIop4ANdSdskwReudCQqqKipEeniVZ2IhH1aCxvM2t/d7NC4f12LLwyGc/R6Xl1pmeTTtwKhWoAdxHRpMjndwH8njEWinUQEZUCuB7ATwHcS1rypMkAbo7s8gKAR6EJhRmRvwFgBYCniYiYG0t4GuF10EQjVkuK8vDN57SFlD7T118et2qqXEiJoL+IvChSQNMZJyIUqg6c5G7/8XUX5UzwkPn5O00SnJ5LLkcrp4NE7G56/527otpmZA8qSpTLrpv7xfttvU44gdl+Q1GZcc5ZY0qjJiOzxpZ2umeTTtwKhWcBeAH8LvL51si2O+Ic92totgd95CgGcJIxpisE66FVdEPk3wMAwBgLE1FTZP8T5hMS0Z0A7gSAwYMzH0eXaHSmlpSuOkrtALS9PKMG9XQ92Gd7kIkV+QsAfQoTS3Ux2sG7Y0RJUcI5ctoL3iQh1nNJ1CU40yQTd+N0TKJ2N/0+vbh5P3791g5D5aMyYEPdCTDA9WSL99vmOuGbdzfgiTd3wCsTFJXhoevLUd/YisaWIJZtqY86blllPX5w9fCcek65hFuh8EXG2CjT5zVEVB3rACKaCuAYY2wLEV2ZZPtsMMYWQ8vDhLFjx2Z8FZHI7KgtKZ29WeZQ/EQG+2wOMrFUABIB489LLCleWb/uRq1nnSvKinHL8x90uJQDuTb480hX/iFzAsdEV6/FhX7cPG4wnl5bByWy4tSC96oBkOviRU6/ra9URw3qiRvGlBoBowtWb4tkFFYgWSKlJRBqD53qFDaeTOA6eI2IzmOM7QIAIhoGXsa3aCYAmE5E10Er59kDwG8A9CQiT2S1UApAd1Y/CGAQgHoi8gAogmZwziqJzI5izawVVcWGuhNG7eNsqxgStZEAmipMJk0gfP/q4Qn/5sqqg1hVfQjdvBKCioq7rizD/7y3O6EcOQJ3pDP/kPmYZFav9Y2ttpTvMkmApYZTPA+0eL+9vu4EHjCpq4zfs0zSzoQU3P7Ch3jU4roq0HArFOYCWEtEuyOfhwKIWaKTMfYjaIV5EFkp3M8Ym01EywHMhOaB9C0AKyOHrIp83hj5fk172xN4JDI7ijWzDqvaC3b6bBgLX9uW1Zlxslk9C3wyVnxUjz+u34Pfv7sLz7xT57r9vOjVZ9/dBZ+HnyMnl4RCLgjxREkmnYPbVXGiqyR+PIIK66tyNqzEdaQw/7a1frNm/3I3ZIQUlpbSsp0Rt0JhA4D/AXA1gJMA/glt8E6GeQD+RkT/DeBjAH+MbP8jgD8TUR2Az5FDld3czo7MAkQiwpmgPbXB/FdrEVSY8eLdv2Irygf0QK8CX8oDT7L+4/FmkPqLuHTTPvz+XW1eEFIUV8fqcAccWbKp2nKt6ExHzaiZTDqHTBUB4k2sHrq+HI+sis54qqoMjS1BV/1/6aZ9mP9qLbyyBIUx3HVlWUz7lxO662pHEfbtgVuhsATAKQALI59vBvBnADe6OZgx9g6AdyJ/7wZwKWefs27P117Eizrm0Rao1ITvLKmMmrmEFBYZCNuERTCs4qu/XgdJSq0oeSr+425m5w3NAcxfvc22XSZ3OXycolcfmVZuFGjJNTfOZARorqBF/ZItnUOsOJdMerxZJ1ZaTihCGKacUwy47qn1eCJOJbWlm/YZKbT1d+nptTth00e5QHddzfXn2Z64FQojGGPlps9ricg+QnQiUpkhaoFKfbFo5qjo2dFUbQC0ojBAURhCiuaUlejAk6r/uJvZoKYXJgQtgaQhl7nsnQac6aMHxk06ly3SnT20PSntlQ+SKEqf7iadQyY93swTq8aWoC1iH9AmSbH6v9PkxCNJ+O6XzsMz79TBK0kIhMNQGUVlVZXJZl4wXFcFbbgVCh8R0WWMsU0AQETjoEUpd0rSNUPkvWDd/R7cv2JrVN4WK3o6BbcRl8n4jyc6G+SlLQaAR6ZVuL4nTgNOrnryuEmLnYvCDEht1t8ez+NQE9/mAcQWvE6Tk6Ci4uZxg6MKI/GCD08Hwpj/6jZ4JCCsaK6rufbsso1boTAGwPtEpEeADAbwGRF9AoAxxkZmpHVZQC/4IRO/4EeiHcj6gk0o64ObvzgI/7txn+MxraEwvrOk0nWJymT9x61ZPt2miJYlQkjRVD+JGulyVQDwiDWwdgRbQ7bjXGLjrOqJ1XedJieqygzvvrieUgyYv3obfB4JC1/bhu55npx7dtnEbersmG8+Y8x5hMsg6UydDbSpjDwSodmS7z8daaudUkYAmm4zzyNrWRwtOXfc/HYqqY9ttZOvL8eg3vkAyJYOIJdnx5mClya7M6Y1zxROqeHH/ewtWF8Fv0cyEuY5sarqIOZy3iM3z0A8O42UU2dna9BvTxwLfvhkKMxe8CPZ8/MEQoFfxrOzx6Ao34um1iDuWvqxYV8A3K1Skp0Vcmsnm+rgygQsmNFWhawjzfTThfWaO7Ktob1xWlEVF/rxy1mjMXdFNWSSEFYV3D15eFRqbSemjx6Int18+O6ft0TVwXDzDOI9u6446bHiVn3U6eF1lgK/jPnTYhf8SOX8OorKjBl5Q3MgabdAtwO2uePHS2WhMAh/bguZct3sbMSzzaWi3qoo6QEVibszx3p2HUEl2B7Er6TeReC6TKrxC36kcn4A8MkUVb5R12PneSV093uQ501vicqVVQcx4bE1uOW5zZjw2BrUHGxyVTv5kZW1naK4eUNzANUHTqZ0LZl+RomSjmvKBPqEw4w+K9cpLvRj1KCeSdnqknkGTscBMATY6UAYZ0OaF1Su3dP2wJVNIVdJt00hEyUJnc4fVFRMLOuDdTuPwStJCKssqmJUJpaxTvpU3VWWVzzdzNPf/AKmjipJS1uyQTpmgtYo2myrGjQ7laaCUZiKRTNH5czs1qm/rY4ksUvHfUv2PbEexysN2t3vwV/uGNcpy3SmoxxnlyDT3hrm82/a3YCf/2M7AM3XH4hW02RCd++kTx1RUoQN8yajvrEVNYea8NArNeA4eOCHL30MlbGcGXQSIR1uxrmmXmhoDuA+o8ynJszvXVaVM8F1PO+tWWNKMfXp9Wm7h8m+J9bjhEqwDaE+spDscjaR85f2yscT//qM+/38V7dlbMkaq+Pr131NRX/c92V+sjs9f1NHXFK7UWXEwixUckW9UHvolM17J6wiUvYzN5g+eiA2zJuMv9wxDqvnTMSyLfU5dQ91ck0lmE3ESiELPPTKJ7Z6CzqZDLvXO/79y6tAkMAQHdCkz4TlGNkCUvWyyZZ3R6ozwdz0OHJS/eaWSliflVcfOJkz95DXD3M7rqP9EEKhnak7ejqq1rGVTIfdV+79HJrZQHsxK/d9bqTz5rnkWkllSZ1N9UuqeX1iCZVUBV2yx1eUFMErU9QEwysTKkqKEm5DOklXkZ5MEa9mRFcVBjpCKGQY6wvyz9rD3P08EsEjU0aXrLwayXqt5ZagAo9kXyJIBHgkwO/xpJQgLReSy6UyE3QSKuvrTqQk6FLNsfXkjaMwd4UWZa6oDItmZlfloVUebFuJPnHj6JSK9KSbXOiHuY4QChnE+sLPGluKFzfbC9cDwD1Tzsc3Lo0fuJMKTjWSqw6cxFUX9uVWjMv3ynj2lktQlO9LaUmdm+qXxLAKFQCGd00yA0w6BqhcUnk0NAfww79VRZRX2vX84G/Rhu9st7cz9MNMI4RChuC98Es28gUCAHy1HXK6Dy3u5ri9uNCPR6aV4yd/j85xrzCGipKilNuWC6qDdKivzOqFVHXk6RqgckXlsXFXg82awSLbza7M2WxvLvTDXEd4H8UglaAgnreLE3leKWZ8QLrwemSbEVkmbTugucL+9Gsj4JMJBT45rR4Y2fbuyIT3UDw7Q7y+k44BSv+duqOnsx7AdqL5bELbs0G2+2FHQKwUHEh1VhmrNKfT/pmmtFc+JImgmNREkiXH/uzLhuCaEZmpb5BN1UEm1Aap2hlS1bHrfZSpDAGFIc+rTUKyFT8xsewcAJ86bE8P6fBey7YKK9cRQoFDOnS9xYV+zBpbGlNl5PdIIEK7zlSsEey8iPZYy/tUX8psqQ54QvpMMIwTp1ObxaZqZ0hHIkMd/e9sGU7L+nXHbeMHR/X528YPRlm/7mk5fzq913JF5ZaLCKHAIR2zyobmAJZV1jt+n+ch/PfXRqQtt5Ib6htbke/1RIXy53s9rq9r6aZ9Wh56Wato5ealzJWsk/qsfO6KaqNEqsKA25dswRVlxfjzHZeldO5U7AzJDFCxEhlm03C6YMbFuO2yoag6cBKjB/VMm0DIda+hXOnn6aDLCwXew0yHrjde9lEGaleBACR/XQ3NATz19k6jMJBe9SreS9necQnxXkwGRKnOdN6ra0DlngaMPbc45TaU9spHayi6LNjZsGK7x6kOIrHUk9k2nJb16542YaCTy15DuZb+JFW6tFAwF9UJmiqJ8XS9D11fbqREcNMJS3vlI6jwX1qvTFH+5E4DRLpnH8nosFdWHcT9y6u5EdiyxI++rjt6GuvrTuDn/9iOQDh6Zlc+oEekFKO9gE8qxHsx9Zlm2CHYd93OE2kRCm/UHLGnnrDcu3R5Qc0aUxoVd+KVCbKU2ViXbJGrXkO5voJJhi4rFHg62Z/8vQZgmrHVrOutOdiEha9tswmPWBQX+jHnqjI8+eaOqO15HglP3DgKg3p3Q0NzIMooGVRUzLmqDNeO6I/Xa47gmbV1rktyumX66IEoH9DD1fK+oTmAB1ZsdUzJEVLs0dcPv/KJLUBOJ6youOY37xnlFD0S8MtZo23XlagwdPNixlu5TTq/T9zfcdOOR1+ttW1n0PIRTRp+TtoGkYbmAJZtiVZPEoDVcyamfZaeC+RC4BuPXF7BJEuXFQr1ja1QeYXoV9WiKN+LHvkeVJQUobRXPm5avNFReMTi5nGD8fTanYYOGwDCqor7llfDJ2tCQFFVhFUYnerJN3dECRK9Upt14Eh2FZHILLX2UFOMSrrAI9Oii57zIqbNaJfCoj7PXVEddV3JzKLrG1tt0djWFzOWuuWKsuK0rBL0dvCFKDP2SccgwjuP3yOn3bU5l3Tlueg1lKsrmFToskJh8+4GbgRvWGWY89ePAWjL8e9PPp+b/mH+q7W4ZoRzwJn+Mj08tQILX9sWWQlo9ZcDYZVbljMW5oEjWfWD0yy1fEAPW357PU9/wEHf8uNrL7StlpwipmMhU3QpRLftM1NzsMlWU9v6YlpnmmdDYVx9YT/cccW5aREIgDZAqBxvLnM+onQNIomeJ5nBPRd15bnmNZSrK5hU6JJCoaE5gMf+uT3ufiGF4ak1OwHOfNkrO8/urC/TQ1PLMaKkiFt/2S3moKhk1Q+82SVTGa57aj38JjXVhLI+kXrSHDsCAXdOGoYbxpTavhudRDGSQMQI29AcwNrtx2wCWG+fVyKEFDWqEBGgPcuFr22znfehqeW2+5HpmWZxoR+LZo7CvUaNAy2n1ZM3jjJ+K12DSCLnSWZw74y68ngkIzgbmgMYUlyQ1sJB2aZLCoXaQ01wsAFzuX3iUDz77u6obQrjZzPlvUwLV2/DhnmTuZ4pbvB72qIuU0mtwPv9gMIAMARNaqrFt44F46jW9PH6L5v240/v77UNLjw/9XhIEuGNmiNYsHobJAJaLVlajfZFPlvrRW/cdQLWyXmBT8YIh0yhmZ5pTh89EKfPhvHoqhrIkgTGSWOdLuHk5jzJDu6dUVcei2QEJ++YzlClrYumuYilKY8mqDD0KvA5pn+wpjOob2y1DahMZahvbOV6pjiR55Xg9xDu+/JwvP/gZKODpqp+IIp97V5JwqnWUGQwjkZlmm9/rDQRC2ZcjLfumYRHp5XDJ8fvXj6PhIdX1SAQVqMEQoHfnpJDRy9E9PArn2DOX6tsqjgngd0e6CuXkAqcDasIhBn3PhUXpqeYU7zz8NKtMKblI4oFr58FwgoKfHJK7c1FkkmBkotFl9JFl1wplBTlJbT/E//agY0PTralf+DNFMoH9LANqAGFIRRWMH+1Xc1hxScT5k+vgFeWuN5Bqagf6htbkeeRY6qvQqqKHvle5HmluLUVnGaOZf26oyWowO+RbG65eopn4/fCKnfVdtOYgXjBYcXhlQkbdzVwjdpeyV2EeKYMqNmaYceqYWBbHYZVzPnrx/hgbwMWzLiYez5zP9PTaEgSYerT641ZdKx7mEsG6ngk88w680qqSwqFlqBiG/R8MuG28UPxpw17YJ0k69XQ9BlZQ3MA63YcxwMrttr88BffOtZ27jyvhL0NZ1ytT1TG8Oir22K6oiarftBiJ6INsh4JkCUp6vcqSnq4Op/TCqWhOYCm1pBdIBBg1vV4ZcLtE8+1qeYA4Pn3nVVQwZCCP22wHwOAW1vaSiYNqLxBuDUUzujKJd71aKtD+43Ra2k4ubBOHz0QJUV5+OZzmwFEp9E4fTZsOFBYfzMXDdSxSGb13Rm9jnS6pFAo7ZUfNVsFNDVR3x5+m34a0IKP9Ietd3gJZFNbaMt0/qg0tLibK48jFjmvkyuqTjK68TdqjkTNyvU4AZ6AefyGkbjnpSqbgASAbl4JKvgzcvOAELReL0WvEiSCKxWTlZAKbNnfxP1OYcD9y6tRPqAHd7Dj6djnrtiKnt18aQumsw7C8VR2qRDPZlDf2ArZ0U1W8xhzEgpawRx74KIsEea/Wougwmy/CaDDGajNqyKZNIeGh663OyrEOiYYVvDvlw9Na7uytdrqojYF2IQCAPziH9u5oU3XX9wftYeaULmnAXOXV+NsSMWZkN0fPKCoKCnKN1LzFvhk+GTCQ9eXw+uR4bcoyT2S/QFY26VHDafK0k378JNXaozAMe3ckvGymldB1QdOonxAD8gOqb9bQ5pHFS/ozKxntd5h67V5JAnPvFOX8rVZCSoM1/32PayqOmj7jmfzCYRVfPfPWzDhsTXcYxJBV9GZyfPIMZ9hulO0y0RYu/0YGpoDKPDJMdWATh5j+rPkuW2HFAavRZjLkvabtYeabO3R1Sq5zPTRA3HPlOEIKiq8soSFr22L2xemjx6Ih64vx9mQgpAKPPvublz287dT7kOAJpAnPLYGtzy3OS39MhG6pFCoPdTEVTM4qR7+7+NDuO35DzHzfzZxXxIdRVEx9en1AICHri9HSGXwebQOVnOoCWRxt5RIcoivbaMloKDmIH9W7HYwaWgOYD4n0hZA1Mtq7ojX/fY9OE1wGYCHXqmx/W4iNSQAIKSo8CSwfyIEFb6Bt8Anc43oZ0JKxmss8HD78js9a97vtQQVPPpqLSY8tgZPr9np2NZZYwc6rhLqG1shO3SAmy8tjZpcAFo/fWRVLb6zpBJnw7FjRnKRpZv24ef/2I6QwtASjN0XzDUsFqyujVpNhxSGuSuS70Nm1XS2jNhdUn10qjVxt1A3KAxQQirmrqgGQAiGVSN53MLV2/DQ9eVYsLoWBIKiqrj50kFGkrlYLFi9zRYol4jeVo+0tQq0QFg1vEl4aggnVRigCdCNu05g6qi233RbQ8IvE0gi437EwyORbRByg3mGqi/DdQO4kypPJn4+J7ck4gjAu+f3L6+yqVp4z9qs8uOlaNeD+V6pPuzYVkVlaGgOoLEliKoDJzG0uBu8HhmlvfK1Z+ngt7108wEwxuCVCT6PhJbIb+nR1FpNb8lwKsj1YC6nSRMvt5ce1CmThJCqgDiWQqecYPGIp5puLyN2lxQKlXtju+OlDCNInLQLDS1BqAzGy/bnTfvANwFGY+1kWk4iLdrYjd62tFc+d1D1yYSWoGIEjllnhl6JEIoxGK/dfixKKADA5Av64vWaI8ZniewrMEaE1yI5errnebi2C79Hwo+uvRCDeuXje0s/cmxDLEKqipqDTbhp8UZjQJ0+ckBM205LUEHNoaaU/M3jOQLouuKm1qAtWC+oAA+/UoNnbhlj7GsVHPcuqzKcA/RUKcnw8keH8PJHh6K2eSQtqd6imSPxyLQKLS7Egm5j8HuAuV+5AIv++VlUeg2ZCCpjkJmb3p1ektHD1ze2witLNicMa26vhuYA7jMCE/V97denqIm7RPNysUW1pR1XW11OKDQ0B/DiBwfSci6vpBk9rQQUta3PRAgqCp5ZWxdltIuhiYrC2smWbt5vizaONZMoLvRzX3BJImPQ9Ehky5sjSYCP7CsMnVeqDuHHEYOcU1oMibTob/NA7Jfbyo9OHz0QPbt58R9//gitJjuNRyKcOhvGd5d+FHXPvDLhrivPQ3NAwZKN+xwz0fo9hIemlmPh6m1RA+qyLfF1swtXb8M1KdbMbmwJYufR0yjwyY6z/jPBMLcPvFZzBPccPY2yft25ro9hVcuhlWiqFDeEVYawynDf8mps+tHVqD95Bs++w/f08skyhp1TAMXinaGr50KRQba9DM3Jej2V9sq3XQNgz+1Ve+gUN87IPPGxZkB2Cy9/FwB088lQWfuutrqcTaG+sRU+T3ou+yvl/ZHnlYwyiDx8MiHPK2HOVedD5jx0K7xz3fTF0qhVwjNr7cbZoGLP2W9m9mVD8NOvj4DPI6HArwXg3TtlOOZHBk1z7iA9QG/RzFF44sZRjh5CSiQIqs09l5dLCrbByzrrqSgpskX+tgQV/OatHTbPF0VhePbd3XjpwwNQmQqvTIYBXwv4kyIBf1djRElRQjYOnVQNow+/8gmm/God7l+xFVN+tQ7/ubQSDc0BmyE+1qTg+Q17ACRe1jVdhBSG2kNNuGPiMPgd3peQqqKipCiq5rFPJtv+mTQ01x09jRWVB1C5pyGhYDKzjUZX+ZmdQ376tRGcTMj8ByYRkO+R4JWBR6dVJOV+y8vfBQDfunwINsyb3K4uvV1upVDaKz9tM6x/fXoUf71jHLweGR/sacBPX7fnU1IZ8OK3L8WZkGp30eTAmCZIzLPzZZX1+MHVww0XQ579b85V58edScweNwTXVPQ30oHrboVmZNKyu940dhDK+nXH0k37oDLndt+zrApeyVlHb8UnS7a8RMWFfkwfOcA2i+cNmiqiEwr6PcAfbhuLkiLNXlDga8sUmuyAyiuK4xZeptjXPzmKtz89jjlXlcVM323m5Y8O4r6vXGCzUQQVBSGFuYrHSJXdx1tQUVKERTO13we0WAXdJvT4DSMBICr3z+bdDfjZP6Lfg0ypPqxp2q0R8E6rZ6cVRbzYn4qSIq46VF+5AVqizHHn9kavAp9rNVZDcwALHAJb/7RhL+6YOCzm8ekmY0KBiAYBWAKgHzQRu5gx9hsi6g3gJQBDAewFMIsx1kiaM/dvAFwH4AyAf2OMJadMjgOv+lYyhBSGm5/bjCduHAWvQ04GBoZvPrcJfo/sylg65cK+WLfzBIKmqGNz53ZyMbx2RP+459b1rQU+GQtf28ZVCykM+MN7e/CnDXvw/y4pjVlSFNDuQUhxn65ZJk09093vMWY/Dc0BvPxxci53PllGUb4PZf26c1/2x28YGZWgzo2WW1EYNu5qwPjzihNesq+vO8HdHgir+O3bOyC5XLn45LbZdc9uPjwxUxuAK/c2unJOSAdP/Osz/OKN7Xj8hpHYMG+y0Xf0xG/r605gwmNrohI//vKtHbbz8JIT6iTri88TvtbuzBNG8eI64rVBlghqjPEjqDB89dfrIEmkZQ9wocbS1MEOBbmyECWdyZVCGMB9jLGPiKg7gC1E9CaAfwPwNmPsF0T0IIAHAcwDcC2A8yP/jQPwbOTftLJ0834X8zT3BBWGe5ZVYXHEMGhFNy+4HTjf2n4M1mHL3Llbggr8MkW5VfrlaHsA70Uze01oBrXYqqywipgCgQD4PGRTGXXzyQgrKsIK497n1rAeMFaNnt28qCgpcp2gUCbNDmJWKcXKHjt3xVa8dvdESKZgMjfTARXAnL9+DK+sZThNZOneJ8bLG1IBKcaqy0wgrGDT7gYs+uf2uPmy/B4JjDH4PbKjnQJwtoE5oaszHnh5q5HQUe9XgD1Ibf6r2+C1qEhjJSdMJfLZKU275vkkOwagpZKewk2aGCDihagwY79YNhVNHezsNpwNd96MCQXG2GEAhyN/nyaiTwEMBDADwJWR3V4A8A40oTADwBLGGAOwiYh6EtGAyHnSgpM+PlUUFbjzz1u4S8tE8ckS7pw0DM+8U2eoC+66ssz4vrRXvhbvYHrzSSJbxLXVfdGN10QiMMAmEDwS8PtbLgFAuGvpRzgdcH55AmGG7/7lI6iM4RtjB8X8LZ9M+PF1F2HaqBJsqDuB+5dXgSCBoc3ds/rASW5Q2uw/2mNLZHJn5A8pDPcvT8xIOv68Ylt+JzPx+odX1oQeEfDzf8RP7w5oz+L171+BlqCCA5+3YM5fq2z7yHDv2GA7lghPvb0TSz/YD58sQWEMd11pV4V5ZULIIsHCMVKhpBL5/HlLkLv9rivL8Oy63UZ8UPc8T5SgSSU9hRbjkviUMpbQqW9shU+WEQhHvyseieCRs1NatV0MzUQ0FMAXAGwG0M800B+Bpl4CNIFhdguqj2yznutOIqokosrjx48n1A495D8TKCw5gWBtzdmwgpvHDcaGeZPxnUnDABAWr9ttBDaZjWLd/R7keSWjfnTd0dNcY9vGXSdcZ2dNlYqSIlSU9HClyz8TCRJa+kFsdUhQYZgYSaHwj5ojCCqah1dQAf68cS9WVx9EKKxwg9KOnrIPHokMjkFFxUMrP3G9f3GhHwtmVGj1khPsah7T/k7FjXg8Mq0cZf26Y9SgnuiR7+XuoyD5CUtLUMH/btwXFdj11JodNs+vkMJw/1cvgNnOrDJgA0elxgt0lIhQe4gfqGmmoTnAVVNNOr8Yv1+3G8Gw5jjBMzbz3h83A+/KqoOY+vR6UMRLKZFHG0voaOpg++RJURlWz5mYlZxRGTc0E1EhgJcB/JAxdsqcB4Yxxogooa7KGFsMYDEAjB07NqFjeTmPso21NeYi7797p46bB4lXP1oz9irc+IgTzfxZVbrJ93qMxIHWovKxiKdZ88qElz+qx+J1u20D+of7TuLDfVUguA9yc7tS0Hn9k6Ooi7iIxmNl1UEsXB1JaAgVc750Hp6NDFQ6TivKMENS0/lxQ3sbf1eUFHHtJulYxZoJKgBZFITEGJ745/ao39EifNtUhbHKo54JKvjOkkosmhlbZedUb3vz7kbbTN4rSag9dApF+V5DnTqhrA+emDkKJ5rPYmLZOXHrlNceOmUkv9SRIjeZ13V1NafZphCr+BFv8cEA/GXTPnz9ktJ2z32UUaFARF5oAmEpY+z/IpuP6mohIhoA4Fhk+0EAZj1CaWRb2tAqY43ED1+qahfvjWRg0CKFz4bUmHWH9U6i1482XhDLoBJSVXy0v7E9mh6l37cWlY9FvDUFY+BmUo3aB3Ad9ZyMGiVW4jgdXgDS/7y3G49M0+IldJXel4b3wT9rj8U4U2Jc+5t1eHLWaEwfPRCNLUGuYlBliQvDeFhPxVupAW2qQkVVMeeq83HzuMHGjH2uZbDV60/EUiPxsv1qv2/vSa2hML6zpNLIAjxrTCle/GC/sXL2ytsd7UaxIoxj3ceX7rwM555TGGXX04ULwIzSrLGC1QDgfzfuw4qP6hGORIW316ohk95HBOCPAD5ljP3S9NUqAN8C8IvIvytN2+cQ0d+gGZib0mlP0Jk+eiCOnjrLdR/NFXQ3zzOh2LpP3ozJ+uJ/pbwvVsVIdZAufCb9J686XLJ4ZUqbt1gqDC3uFncfJyPmiJIiw3tn0+4G17YCAPjel4Zh/Hl9cLDxDH70d3t0MaAZj/WB1MkASwC+OqIfXv/kqOvfTidnIo4QT765A0+vrcOimSMjgYs+/MeSSsMBAYhv+F1fdyLupK6bT4aiqraa6NbVq56ryCqE4kUYO+GXCV5LQsSlm/bh4ZU1xnup1353846Yjf3tlWk2kyuFCQBuBfAJEVVFtv0YmjBYRkS3A9gHYFbku9ehuaPWQXNJ/fdMNeyC/u7qBWSLkAJu3plZY6OD2A58fgYBS/Ix6/j5+idH0B7855XnxawOlygE4KlvfgE98r24c0klzqbBKGJVq/hkzSAcT+Z4JNhedB686zYHFTa1hvDYG+4Fgt9DuOOKYcYzf/vTYxHvNDv6QOokvBiAf2RJIFgJhFVjkDvw+ZkogQDE1sHrg7VTKnBAu2+awwNc1USXCDYh5KSiyvdKtpKxZsiUJcApal2v/Z5ISnUJ9jZmiowZmhlj6xljxBgbyRgbHfnvdcZYA2PsasbY+YyxKYyxzyP7M8bYXYyx8xhjFzPGKjPVtkQrr7Un3hj9ZFllPRqaA1hZdRDjfvYW5vz1Y8OzJs8rwScTrMGniVlskuc3b9ehco+WU0pXDfgStbSaYADe33UCJUV5UHlFLpI8p5mgyyAwIrjyTtGv22po/c3bOzDhsTW4c0ll3N+TiQwD6KKZo6IGgcdmjnQ0XgcVBW/UHMbNkYI4PJK9i7z0C6miqgy1h05h4Wv2oK1YtQx4kdEeieCVEXXfJg3vi4qSIleTk9aQihqTgdupSJTfQ5h3zQUo8PGHTb9Hc/pY+Nq2uFHrHlnCNy+N7XVn5kxIxdLN7ROf0uXSXACIStiWa8RyOtGMZk2Yu7zK5k0UUlQ8fsPF9u0MmDFqQPobaoEBmPk/m/BwxFOHgV+zIhFe/OAAvvrrdTFnhani5syXDO7leoY2oaxPVB2KkMKwZON+ze7jKqKd4ZnZX+CmNtA8m0bAKwHeyMLFJxMk0n7n2Xd3x0ztnixubTVfGMSPR+ARVBhOtYZsSRgL/DJGDHQ+Dy94M6wyqCpwy2WDo+6bLqT9nvhCbUGk7reeyvyupZoNxCtHC+lpowZyB/rvXTkM7z84GYN650fiYmITUlRXKkkzyyrr8fa2zI9dXU4oZCpWIV3Eev2Cior3dzUgyHF5UFTg/pc/sUVW53kl3DBmEJ7+5hcw85KS9DaWw5KN+1G5pwH3OlRtSxSFtXeeTTsf7mm05dBxqm+g+Z0n/1ppwx05eqssWF0LjywBIMwYNUALEkzSHTqd+GRCoS8xbfQrH9fbkjDGyzCqB29aUSLOCG/URg+a00cPxJM3juYeY0Yirc6K2aU7rGrbf/7/RmDxrWMMnT4vT9K8ay7C+roT+M6SSsN+EouwwhyD+mJx+5ItxsQrU3S53EeZjFXINN+eMBTPrd/j+H2YMwqHwipuf+FDeCRCIEGjWbK8UXs0rV4u2Uav0W2ODneKxNU8Y1K9z/abF522Wft+ZRIOBJpKj9LQxmiCCsN7u/gp6b2krVitvLXdHmcUrwwmL3jTzPxXozPcGtl743RI7XaQ3Y7AgHuXb4U/klpb957SHQfM3kXzXuYnheTBoKmErqnoizcS9ESLV1s7VbrcSiEXYxXcIBO0oLA4ndsq7hSmqRZaQ2pa03vEwsVqvUPBwNDUGuRmOuUFSN1wSfKugx4JhsuiTt3R03j2nV1pCUC8dkR/PHHjSPji283TBk8g8IinOgLMKiH+0OWVtQA4vTKa24H6/q8M5wZdBhSGYFh71oEww5Nv7sDlv1iDDXUnjBK2QOJVBwFgzadHsIYjGHUG9nQWjk5eZumgy60U9FiF+zgFyXMZzVMh/mib7Su6oF8Bfv+e82oml5k1thTNZ8M2mxMDaV4sqoq7riyzpdNgKkN9YyvW153AvEgh90Qwe0URETbUnTBWHtZMoKmysvowPjt8CmoWCuDEw21xGj1487n3dtviV4JhNRKXIHODOXl4JWDcsGJT7EQ1JBCCqlYu1hqjYPaeihWMF4//3Rj7uR475Vx+06m2djrocisFQOtUm350NZ7+5hfQUTRJYZXhlXYs3p0oJUV+/PG2MfjsaEvK50rlkaQyA15ZdRD/rLUb8kIKM1YFT6+ts6kiAgpDKKwYKwirnjwe5rOFTLWleZlA08H2Yy1JlTfNNPFUR2aKC/2Yd+1FUTVC9MSAgbD2vIIKcxVnEFJhePYwaGrY1rAKhVMLRMdaI8KaPsMjaauWAp8MrwRMufCchAdbr4NtigD0KvAleDb3dLmVgk5xoR898j1ZN9Alwlufpi8KNt0cagpwc9wkAgG498vDcfO4wfj569uwwlIq0g0MBJnixx7wUJT4x8kSQZYQlZrAKxP2NpxJW8CeXn5159HT3O89Etotl1U6yPNICKsqCLGztA7qnZg3DhBdI6SpNYTvvPAhwiYxKxMgyxI8RDgTchbWyyrrMWtMKR5YUe0uWSInlsJak+GNmiOYv3ob/F4Z79WdAEmIH75vIqwyI0GiGb+H8ML7ezF9VElG7ApdcqXQRgdZJnQQ9n5+JqXjGYDxw3prKYq9yc1X5n7lAvxwynB4SMsMmghubISKymy5akIKw9DibmmrkNYaKRYUdjAG3zlpWEoxIO1NWFXh90gu0nYnN0PT64ys3X7UtopTGPDi7Zfi97eOcbRD6KzbeQIy2ffxyYQbLimB3xM/iV5xod+o773wtW1Gcr5A2N5vYuH3SHhkWgVXk3E2zPDbNXWY8qt1GfFE6rIrBUAz3KY7H0xXZkgSMz0rNy3eDFlCUv72EgFPvvkZwi5m/MkgE3D1hX1tNgc9tcG9U4bbqo4lg8qAr/56Hfxeu1gjAH27t28q5VQJq0A4GHtE9MpkM7C7JZbdJc8rweuRMencYiyaORLf/1uV43kIgMKpdxFUGF6tPoxHplVgxMAiVwnqnCKi3fLkjSMxddRAdM/zRBWJspIJT6QuvVIoLvRjwddGZLsZnYZ4VdrcoDCWdACWlucmMwIB0NQ6b31qTxWhMM1A2juNel6FgevvzgA8/sZnnWoi44sUM0omhUM8uwtjbcbr8gGx09s8++5uPDytwpYVANAEw6Ov1rrOWMozPCe2uNN2nj56IDb/eAqWfPtS3DKOHwHtVO0vWbq0UACAESVFKGhP/7xOTKIG1o6GR5a4MS56Fo5MeoSYORNS0+JWfc2IvmloTWp4CHjuW19MOgNoPNdMc+3y372zK+a+YUXFocYzuGfK+fj25UNs34cU5qreA8Cv2/DDKcNR6Hc31ty3vBqrIo4lxYV+TBp+DoYWFzi2O510afUREIlbSFNunWyQqmNhrCphHQWvBEiSBEVV02KAlaDdU+td0ewJ9h/I88pGHYnbxg/GkjiuhrnCm7XH0M0rxzTAZhqPR0JFSfIJKmMJYp9MuHncYABa8N+q6tjeeyqAZ96JnaL9ICf3khNWwzMAPPNOdDYFJ/U1z+119Va+44WTh1SydOmVgl7L+N4pw7PdFINrK/rF38nE8v+4DEu+fSkenXZR3FB+Kz6PhAUz+MasjsTscUPw/oOT8ctZo5HnlVLu1Cr4gnbG6BIwxkux0KaiWDDjYrx1zyTM/cpwW8qRREklXYYbFMavQZBu8r1OCeRSLzdZ1q87bhs/2LZdIuAJk0qqvrEVfheZbuPhVAbUCd3wrNdASWT1YHZ7rTt6GlX1p7j7xTOgJ0qXXSmYUxUEFBUecud9kkkIwD9q3ac3njW2FF6PjIpzClFR0gO/eOOzhKzmj0wrx+xxQ1CU58Wcv36cRItzg6Uf7MfdV5+P6aMHonxAD1QdOIkdR0/hT+/vAyG+0dpNQXu/h/D3jw9yV5VW//raw6fw1No6qCmuwGaNLcXx5rNpLchjox1WibwCPxIBS28fh7HnFqd8/gUzLsZtlw3FP2uPoCUYRvmAHhh/XnTtgXRpBIY4qHDcYl09NLYE8ZRDLjaz22ssNZknzZOHLikUeEXDM82EYcWo3N8Yc6nnpst6ZcKNY0oxtLgAv3xrB/7xyREj/87jN4zEAxFBx8vjruORgPnTR2D2OE1vemH/zORQaS9CCsNz7+1Gvs+DZ9bWGSqxr3+hBK98fAgFPgnBsKZa4t0SN5MBlWkpmq0+43leKSo1Q7LFWXj8ZbOmhhpR0h01h/gxC6mSacWR3yNhzlVlWLxuN04H2uoaqAz4xh82af3wMrv+PlHK+nWP6YGjz9IfeHkrJMBWwMotTWdDSbbQzhs1R7DwtW1G3WddcOZFVlbmVVQsNdmIFNRvPLqkUOBWyOIEiaQDmbRZUVV9bIHgxjXWJxNe//4V6FXgw4TH1kQJtQde3ooN8yZHJep6o/YI/uvvNVEDoUciyBKhe17bo28JKsjzSmkZyNJNvldGWFHizuR55TqXVWo6ZH2loNsKrMhEkGXAI0lcY7lMwB1XnIs/ctJ3mL1bgNRdEXlkSiBkmm5eGb+/dQwqSnrYdOmA5qr6k1dqAIIxQUkWXRUcyztIn6Wv3X4Mj75aa1Q1S4SFq6MT7sVrk2aYJlSU9EBxod/QUMhE9gyxTHvH77qyzChZqlPWrzuuu9heOc9tAahE6JI2BZ67mETISPZUhWmqiRaTnzZPBxhPIHhlTUda1q87N/mWuYShrsOcPW4IKv9rCn7+9RFGoZSwygwjlp7EzSnfjNPduO7ifvB7JHSLpA6+7uJ+XDc+K4nqPiUAC2dU4IdpsvkU+D344pCetu35Xhl/uG0s5k+vsOl3vRJBkgh/2bgfDIiyv3gk2ArhpKPqHI/Lz+sddx+fTCnbMZyYenH/hI9RwYzB8PEbRsLn8PznR2oZJIteA+GW5zZjwmNrDK8dHsWFflx1Yd+k03xY01vEatNlP38btz3/IW57/gOM+9lbWLp5X9xUKEGFcQUoACyccbHtHQqriCoQlA66pFDgGXwWzRyFBTMqUj63m5cyrKiO1Zu8DoLpV5HC7AB/4NH1j9Y8/8WFfpSXFCHfax3s2jq3+X7oxmqfLMHnkWy+1X6PhIUzLsb7D07Gd790HogI7+1oAGOImQjue18ahkUzRyZUxcsjA1dd2BdDEixG4kRrKIyf/z97hs2QqqKipIg7WIRUZuQ+CikMXlnC098cjSXfvhSbfzyFWwjn8RtGpj1T7ILpIwwDttO5ieCqwEuiyASMLO2Z8HEPTW2ztUwfPRCv3z2RO3nQU5Mng5ustVYSKb5jJVapUHObHlgRXTI0rAKPrqp1lSzRSfAUF/rx8NRy2/aFq1MTqla6pFAAtE66Yd5k/OWOcUa1ptnjhuCWcXZPBrd080n4/uTzDWHj5wyqAGKH/JN9hu6RgPHn9TE+84Ta4zeMxPq6E9wZkxshMqGsD1bPmQgW6bRBRSt2LkkEv8dcfWqkye+7DoFwW9lBJ0OeRwLuuGIYJpT1ScjT6ZFpI1Bc6Mf48xI7zgm9Ju6cq8q4KQus99XnkWweXT5ZwqDeBZg0/JyYaorNP5mCwS4yfrrh+hH90avAZxiw5YhhUW+aXyZjYpOo4LUiQUsqaB68FQb88q0dmDU2sViCorxo7XRZv+6YP90eLOo2OyqPWKvmWEwfPRDvP3g17vvy8Ki+MGKAs11CV+24aRPvEcgScWuvWzkbVhzvx4iBRZzVrLvVi1u6pE1BRx8IdFZWHcRfP0jex1xRGW4eNxg3jxscpdf/yd9rovZToeVvf+wf27lFvXVvGC2/DcPdk+3qE54PNM/OYK4W9YClMIye6lnfdteVZVoxEZPtI6QwfO9LwyJCiaGkKB/VB06iqTXoSncuE/DLWaNRXOhH9YGT8HtkBOMUUgfacuvruuL/mDSMazdwwiNpKxdzLhxZIlz32/fglSWoqopbJgzFHVcMi+oD5vta4JMx9en1Ubo9NzNFQOtb6+ZNxtvbjuD+5VVobE1Mf/1v44cgqDCs2LIf63aewOW/WGOLw1AY8IPJZZh8Ub8oXfquY834zZrEqwveOm4wZo4dhKbWIO5a+nGUYdgrSZg9bihmjRmEb/xhU1Q7nOxx9y7bCpUhajU1+7IhAGkqI6+sOQSk4pYaa8ITj+JCP+6++nzjfS3wyVhfdxw1r37K3V9RgcXrduOZd+qiCitZqTnYhFbOrI8xhkemVWDha9uMd+7eKcPx2BvR4wCL4SVV2ivfdq/dXq9burRQMKMvQ1OxNZujJ/V/Z48bAjBg/qu18MoSFMYwa0wpnvzXDsff0vuTliVRcuyIZh9s3iBttjO4ESJPr93J9cNfvG43nt+wF0TA2ZCqzZ7JnTfj7ROHxlR7OaGoDJt3N+DGN3fAJ2szLLfZQX0y4cU7xuGW5z+IGtB1Q3pQ0QboZ9/djdLe3WxGTvNkgSdMExnAri7vj6sv6o8VHyWW9vzFD/aDCAgqiClEf/dOHW67fKjRpobmAH73buzIXSf+vHk/LizpgWsq+jsOtPWNrcj3eqIEhs8jQVUVW38OKvYALCA6s6nbtBFOOE14EjlncaHfmCDFWmUpjBnXzbsuQLv/C1/bZjuWoNmfpo8eiGtGtF17fWMruvmi72e+1xNV6c/M+roTUQGUXjn1WA8rXVoomD0WUvUa8XskI3rSyuzLhhgdQZ99uolC1HL5qMa+1o5ojrUIKoptkLbOIMyDXfWBk7brJaKoVYKOwgDFtF2ffbtRUix+by9Otobw+MzRthc4qKjcKGS/R8JXy/sZyeWCkfdFz1Fvnin5ZdKCzRhDvtdjDApjzy2O+q2AogKqCmteNmv5RitWYRrv5eN5wVw7InGh4JGliKtU7BVGSAVe3KzFaQDA0s37U/Ki0+9HrIHWKjDCCsOdk4bhD+/ttj1LPQ249b5ZV+mJYr7P5viU0YN6JpwcLhk3YvOEy0x9YytXsHhkYEKZpgK2XrvblY7eTvM9lqjtvOmiywoFa53dh6aWJ+Q1opW6bUsREVZUvFFzxNHnWu8IvMHY9W+aXjBerIVH0gZUnxx7xtTQHEBTa9CYMesk6pLqduhZVnkQd15xHsr6dbcNshvqTpiEhFYD1++RuNlG/V4Zz84eE/llQklRHlqCbfpX62BsVQVd99v3bK3WjZyNLUHHQcXtAMar3cwAPLCi2uWdakNRGRgnYyePp9fWGROSZ9buTPi3zOj3w0kYWgX72bACRVXxl037IUsSGFOjVgwtAQU1B5uMdNLpwHqfZ40txbLKem7NbDckMyF0Gri1Gt32N8Mny47C0e1Kh9dOp/OmQpcUCrwBdeHqbXjo+nIsWL3N1Sx+8a1j8J8vfmTkSFeYO59rJxWK30O4+qK+Nj9kM+YXrL6x1VYWUibCH24bi6J8r+Os1vxCaQFZ2nI1oKggxrgFzj0SuXLh80mwzcR1qg6cNAZb8yCrDz61h05Bt1log7edkNLm4sjDKb+9vv2RaRXaMzKhqAxLN+3Fsi1tM/nbxg/GghkXu/J91+H1qfuXV4FIilkjeMzgImzZ3+ZSKBPg9WjG70+PnMKzcXLxAJrxWzc0amUo49tsnAiFmZEg0kkYtj2zJnxnSSUCCgz1h1cmKJY+tPC1bbhmhDvf/njw7rOea4pnS3ODG7WmTIAkEfI8csyBu7jQj0emldvsiApzNqa7XY2mYj9JhC4pFLjBa5KEQb3zMXZIL2zY1RDzeL9MaDwT0uq3Wpb38dQR5pmBLBFCYRW3TzwXd1wxDADw9qfHYwol/QUr8MncspAlRXmOy2feC+X3SLjvK8MxoqQHbn5uE/c4J4FgTaYnyRLunDAYi9/ba9s3VkSm2eAdUNS2tKMWHpnmvlwjD56Rk1cDYcnG/eiV78Oz7+4y7EDxZp+8PhVUAK8cW5jWHj6NH0wuwzPv1MEnE8KM8NDUckwfPRA9d/hcCQXzwJBqjARjDFOfXo/HbxgZc6AqLvSjKN9nE0IeSQJBjZotO6laksHNrD7R37PO1s+ElKh+fd3F/bBwxsXG78ebJPDsiPH0/m5Wo8WFfswaUxqVKnzW2NK0rhKALioUeBL3bFjBHS98CDfZn0kijB7Uk+tepi+/Yz2o6aMH4vTZsNFp/vT+Xlw0oAemjx6IRTMjAoMT8Qi0qZAA2KKQ87z8iFwd3gsVCKt4/I3PoILhi0OKsWF3bIEYBWNR6qqHri9HQ0sQksUIfdv4wQkJKh4/vu7ClKNeAbuR89VqfuZJ3XtHV7HFm31qagP7vY+n35clwrPv7tIK0ahablY9araipEdM43qBX47y3mloDuCuK8vw1Jodrvoxj5DKEFIZ7l1WBVmKVkVahaJ2zdGNa+VkXE3nbNbNrD6Z3+PlJOKpE90OwGY7YqrGdJ2G5gCWbYmuWbKssh4/uHp4WgVDl4xTsPqj6wW/471IBT7Z8Gsv69cdj0yzB7u58bnWPRSCCkNLUIkKuNHjJ+ZPr+AGuIUU7fxOvxHrt51eqDMhrQ0f7vs8ZrutKAxQVRV3ThoWUb3V4pdv7rAZvC/o55ybhednnueV4IsUPffJhJ9+bQTunHReQm2LhTnqu0+hu8I4MvEDrPQ4D0DzPrOS55XgkCQUAIyAODPmme4vZ42G36PVhTYza+xAvHjHZUaMjR7Vu3jdbjBQ3AyrHgkxYz/CKowYFKeAMKsnjBPpnM3yYnRuGz/YFrOTzO+Z+0VZv+6YOXZQShXNzOdLB8nGZCRKl1wpANEzg6bWEO5a+lGUW5iVPK+E+dMrcNWFfdvcTS8bgpZAGIv+9Znm+x5jmWj1dOKhDwR6KP6D/2d/4cwqlERd8aKSghHZKnsRtECp1yzlJmMRUoFfv7UDEidZnM6jr9ZgUO98o9yiefbEm20CwOvfv8IwIqfLS0WfTZs/64Fx8UwmZ4L2gCKes4LVO0pRGX510xfwwMtbbffbJxMemVaOhaujXRjNM13ds+a6374HxWQkX1V9GPOuucjR6cDJDUAmwg+nnG8YpmsPNeFUawj3LquOmU3WPPjohnurJ4wTbmazidhveDr4H1w9PO2z8nSeLx0Im0I7oA/ADc2BuEvSsKJGCQRAGxR++dYO+GTNvXL2pYPRs5sXDc0B237mwePeKcNtnj5nQ6qtApwWgWvSzcqEayractAk6i5pPmbjrgZbuuyAwnDPl4dj5KCeeOyN7a6zKisMNuOimZACfPcvHyEYVkAUbaxjANfvOh01Z3leKi99WG/YQhbN1FQiv75pNO5fXg0igqqqYLAb1hmAxpZgVDyAdSBe8Oo2W7psxhgu7N8dqsVO4vNIeP3uiSjr1x3d/Z6Ywr0lqMArS1HqKfNqgqcW9MsERqQFIyoqrr+4PyZf2A/jzyuOOvek4X2xdNO+uIWWgorm5HDT4o1xbT9W4un4eV5b8byHrDr4VF1cU21Pe5COmAw3dGmhoGO92bFWDDo83+b/3bgP/7txH7yRmrPTRw/kDh5P/OszW8U0iaLLWdY3tmqDpylwKc9jdz9L5mUoLvRjUO9uXJvEoaazXBVQqrTNkplxTXNXbAXAMuJ3HctLRee+5dWYUNbHJlyf/NdnePGDA7Zzmj2oeAOxLBFkiq5klu/1oCWocF9m/Vzx/OxrDjbZbEXmGSJvBkkS4Xff/AKq65swqrQIrSEF+xpaALCoWgNLN+2zeWTxUBnwyKoahFUk7E4dazbLe06Jeg8li3k1AESvgLLRHjckMxFMFCEUIphdI+94odKm0vBbBuTaQ6cgOYRvhRSGuSu2Gg+PN3hYl+oqA06cPovqAycNm0E6lopOy2Dn87CMZIvlIUsEMII5QMsjSVi7/ZhtVZYobrxU9Jq7k4b3jRKu355wLlcomD2oeM9HUe1FPPVnNmpQT8eXOdbM1ClC1lzYhzeDHDukF25fsoV73RIBv75pNCaU9cH81fZz8+CpBv0eyZX7diybgpMnYLp9762Y73lrKGysYHXXbDOZaI/1vaw7etp18F06V0U8hFAwobnZeeHzkM3oHFLaBuSVVQfxwIqtsesjRLyEeIOHk4vnnX/egm6+tqhcw3WVtDQP5oHAjc4z1mDjtBStKClqt5rNvEG0Jajg0Vdr8ZNXPsGcq8635ZV3i9uUGqdaw4Yg1n+nV4HPtpKjyHYdp/sHwHhmQUXBv18+NOoY67XEmynzBs0Cv4xBvfOj2m2eQYbCCmb+D9+9GNAmIPcvr8Zz3xoLn0xGxHgy/Nv4IXjxAy1wjed5BMS2KbSXntyMkw0m5JBOJN3tsb6XY4f0wvq6Nq8/PU4mW3RJ76NYlPbK5w7aj0yrMOwPD6yojjtD0r2QeN4Sc79yAf8Yhihvj/IBPfDvlw9FSFHh80hY+No2rKo66Cp/vJuUwrxMscWFfsy5Kn4mSCfiZQ43f62oKm764iDkeaUoe0pzQEEgzPDkmztw+S9i58fX4aUMt3qYWZtG0FRIs5/bhPG/WIOlm/cB0Gavhf7o+VKh32NzEODdv+mjB+Kh68sRCKsIKVp+pXE/e8vxGuJ5lPAGzWBYxXeWVNqev+7tsrfhTNz7pdmr+EGJfo+WGdeaBt4rU1T21EBYNVZU/zZhiGMq6lgeMrz3IxN6cjO8e25G937LRHt476VZIACamrPuaPYKK4mVggVbcJnCjFrGgJZbJlaEKqC9POYU0zw9YPWBkzG9fJjKcO1v3zOW7bqRce6KrVBVFSGTbnfuiq3o2c0XFe3rdlnOm73ePG4wnl67M+o6ZdIGizMh52vX02y0OIU1I3r2HVa1WeTqORNRdeAktxqWXhAolk7XaUXES6kxd0U1ZJIQVhUwUCS3lHaen/y9BmDANSOcE8JZsd6/huYAFqzeFjXYhlVg7opq7jXEmylbVyR6vqiAAiNozHp/YgUK6qiqioqSHra+fv+Xh2PcsGJbChLdu2rBq7VR16arWZ97bw8enVaBBatrbe9HvJl2e+jJzbhZRabL+82K25QaZvtVeyOEgoWG5gB6dvPhkanlCIQVTCw7x3g4Dc0BPONQZBvQdLX3fXk4vlqh5b83L++tg8flZX1iCgVeugkA3BVKIKziu3/eAhVtkbfcGabinKfdTHGhHzeNHRQVOXnDmFKsqj6EWBmPvnPFMPzp/b1xz2/GGymBedWFffFfK/kGz1g63XjqF/N9j3ZDDuI/l36EkCXgbP6rtbhmRH/MGlsaZZi26sWd1Hf1ja1cm4xM/Gtw41ESz33aen/K+nU38gE58f2IOseaH8o8EE4o64PFt46BXk6yvrHVMY1GSGEY1Dsf7z94NV7cvB9Pr62Lm4PLeh/ay5Cr3/O5KzRhGAgpthQWmRqQ3ao13Qj2TCGEgomVVQdx70tVUQm9vPJ2w5NIeymcjWsqA559dxd+/fZOW9ZOs0tb3dHTeHiVfQA08hCFtU6aSII63ePFWkPh3mVVhnePyoANdSeijJi8gY0XObmq+hAeur4cC1/bBlkitFhm9H6PhDuuGIaLBvRo06mHFYBi174OhBUU+GTTi1ptm2m2hsKOwow385KIDAOyEyVF/MRlXllC7aEm24D60ocHDL14LFtNaa98rk1GYc6zZTcz5eJCPxpbgvh4/+c4YzECtIYUmzvzhLI+WF5ZzxXhXolw7Yg21+biQr+ttsasMaV4qfIAZJKgMBWLZo7ChLI+cQY0QnFhdI2CRGfa7RUfwPT/M4JHJjw8tQIjBhZl/HeLC/02G8KAHj4cPhU0PsfKANAeUKyCDrnO2LFjWWVlZVLHNjQHsHHXCZxoDmJiWR/0KvDhiz99i+uKSQQsnFaOCwf0wDf+sDnh+q5emfCrWaMx/rxirK87gbnL+YFC/3XdhfDIEsKKisf++VlSKZAL/DLmT9OC7ADg8l+siRJieV4JG+ZNxvq6E3ggokrRX3p9YFtdfQj3LY+2m/g9Em6fOBTlA3oA0Abd5zfsgU+WEVRUfHvCUIw/r9gWoBatslHx5Yv64c1Pj4AxQkhlyPNKYEyrhnbzuMFobAnimt+8F3WPvTLhj9/6IjcZXkNzwKgLYcYnA0/cODpKGOsOArJECCsqJg0/B299eizqOL+H8IfbvsgNZrzvy8Nx87jBtt/T76netlVVB3Hf8mrj+ckE/HDKcMNo/spHB/D3qkP4wqCeuHX8UFeD0MOvfBK1crPi95DxDOuOnsa1v10HB7svPJLWp++YOAw3XFKKtZ8dw89e3x4z661MwAc/mRJ5nnYnCwLws6+PwMBe3YznpA/wBT4Zh5rOAmCoKClKOV4hVcFRd/Q0rvvte1HvoPUZZko4Ve5p4DoB/Pf0chxrDmLS+X0w9tziuOdJtX1EtIUxNpb7XS4JBSK6BsBvAMgAnmOM/SLW/skKhZVVB3HPS1VRAmBSWTHWWQw+HZ3xw3rj4wMnowYwvwwU5XlxrCVk2/+uK4dhzafH8OnR5pR+97Jze+PcPt3w8f5G7DzaEqciQBsE4IL+hdh+xPn3S4r8mHBeHwztU4CwouJAYysOnTyDTXsauQL9ksE9cNmwPhjUqxt+/PcaV+m+Lx5QgE8Ot9i2SwRcU9EXb9Qci9IIE4AL+xdCAsPw/t1xTvd8VO79HEebWnEqEMbpgCnVMSeTrAeALAMBBRjY04+vjS5BWAH2fd6CfoV5+PxMEK9+4j7KPJMM7pmHfJ+Mz47Z748bJAK+P7kMV13YD3uOn8YbtUfRq5sXo0p74pFXo+0ReV4Jq+dMREtQMVRbm3c3YNG/PgOYFt/Su5sHxYV+VJT0QHlJEQ6fbMXx0wEU5nnQu8CLnt38kW1n0ad7Hhpbgnil+rC9XQC+eG5PHG46i2HFhVi384TxjMef2wuzLxuCfK+MtZ8dh08mnN+vuyEAgegofaco+pqDTXh4ZY1jcS0C4JEJc79yAQ43teLIqbP4ank/9C70Q08V/4d1dVi99TBaQgx5HgKIkgqu6xBCgYhkADsAfBlAPYAPAXyTMeboSJ2MUGhoDmD8z9+OGdIvEAiyT55XgqoyQ5UqE1KqjJgJJNL+01XF1toO+mePRDYninRhXeW4IZZQyCWbwqUA6hhjuwGAiP4GYAYAd9E1LqlvbHVdHEYgEGQPY4UbkQS5JhAAzU6nsrZ6EtbaDtYo+ozAWFqD63IpTmEgAHMYaX1kWxREdCcRVRJR5fHjxxP+ESdDoEAgyA26eWX4PJJWC1wQl2A4fmbmRMgloeAKxthixthYxtjYc845J+Hjiwv9+P7k5IOzBAJB5vDJEn5/6xi8fvdEUDulW+nozB43KK3G8FwSCgcBDDJ9Lo1sSzs//PIFGHdur6htV5QVoyhPdjhCIBBkGlkiPHHjSEwarsUG6ZHOeZGCFJ5cGq0iSKS1y6m2g/lzJnKK9e3uxcKvj0zrOXPJ0OyBZmi+Gpow+BDAzYyxWqdjUnFJBTT3sHU7T0S5gf3l/T1YunkfggrDmaCCkKLg1JkwQkzzDlAB9M6XMah3N+z5vAVgQMtZFQo0l6mibjKuvrA/KgYWYURJD+w81oylm/Zh1/HTkCRCgdeDIX264WDjWRw6FXBsW5FfRmtIgcoixiwAZyMq1kIf8OA15dh+5BT+/vFBeCSgfGAvjBxYhA11x7Gn4Qz69vBjxqiBKOtbCADoke9DSVEePtz7ORa/uwsHTraiu1/CmCHFyPfKKMyTUdqrACdbAli25QBaAloBdl7vIACFfgl5HhknW0LQ/ZiuKe+LgjwvfJFl/8f7G7H7eAuYCvi8QGsIyPcBeV4vBhTl4Z4pw1GU78UL7+9BS1DFxSXdsa/xLHr4Pdh2+BQONJ6Bqqo4E1JxXp8CnNPDj0ONrRgxsGeU95FXBlpDDIdOngFjDIoKNJ0N4dSZEIb1LcCYIb1RPqAHwoqKN2qPIqQoaD6roCjfi6J8L2oPN6GpNYQzAQW9C3wo71+I9bsa0NiqGQZlAOf26Yb+PfNQPqAIx0+fxdb6JjQHwiAC+vXIg1eW0BoIGd5H1QdO4vMzQYTCDPleQq9ufhTmeVDWrxBeAlZtPYwjTa04G9Y8whicvY8UAHuPn0b1oZPole/DpPPPwb9qj6KhJYQ8L+CVZYRVFc1BBinSR2MhASjKlxFWGBipMNfOKfBrJwiHgb5FfgTCKloCIYQVLTJ7YM88lPXvjmMnz6I5GMapsyF4iHAmrMAnEU61KghDM1bm+yUU+D2QoB1bXODF+PP64LqLB8DrkaO8jyaUnWNL6w0gyq1V90I61NSKt2uPYt2u41AUzdDq1vuopGc+Dp9sxfYjp3DyTAijBvXElIv64UDjGWysa8CnR0/hqxf1w9FTAby78zh65ntwedk5mFDWJ2XvI72i2z9rj+BMMISLBvTEhf27o3Lv53ij5giaAyHcctkQjBjYE0s373P0Pnrr02PonufBD6cMx9cuGYRk6BDeRwBARNcB+DW09/B5xthPY+2fqlAQCASCrkhH8T4CY+x1AK9nux0CgUDQVclBLZ1AIBAIsoUQCgKBQCAwEEJBIBAIBAZCKAgEAoHAIKe8jxKFiI4D2Gfa1AfAiSw1J9uIa++6dOXrF9eeHEMYY9zo3w4tFKwQUaWTm1VnR1x717x2oGtfv7j29F+7UB8JBAKBwEAIBYFAIBAYdDahsDjbDcgi4tq7Ll35+sW1p5lOZVMQCAQCQWp0tpWCQCAQCFJACAWBQCAQGHQooUBEzxPRMSKqMW1bRETbiWgrEf2diHqavvsREdUR0WdE9NWsNDpN8K7d9N19RMSIqE/kMxHRbyPXvpWILmn/FqcPp2snorsjz76WiB43be/Uz52IRhPRJiKqilQhvDSyvbM990FEtJaItkWe8Q8i23sT0ZtEtDPyb6/I9q5y/Zkd8xhjHeY/AJMAXAKgxrTtKwA8kb8fA/BY5O9yANUA/ADOBbALgJzta0jntUe2DwLwT2hBfH0i264D8A9opQ8uA7A52+3PwHO/CsBbAPyRz327ynMH8C8A15qe9Tud9LkPAHBJ5O/u0OqtlAN4HMCDke0Pmt75rnL9GR3zOtRKgTG2DsDnlm3/YoyFIx83QavYBgAzAPyNMRZgjO0BUAfg0nZrbJrhXXuEXwF4ANH1cGYAWMI0NgHoSUQD2qGZGcHh2r8H4BeMsUBkn2OR7V3huTMAPSJ/FwE4FPm7sz33w4yxjyJ/nwbwKbS67TMAvBDZ7QUAX4v83SWuP9NjXocSCi74NrSZAqB1ngOm7+oj2zoNRDQDwEHGWLXlq05/7QCGA7iCiDYT0btE9MXI9q5w7T8EsIiIDgB4AsCPIts77bUT0VAAXwCwGUA/xtjhyFdHAPSL/N1Vrt9M2se8TiMUiOgnAMIAlma7Le0BEXUD8GMAD2e7LVnCA6A3NDXBXADLiKirVHr/HoB7GGODANwD4I9Zbk9GIaJCAC8D+CFj7JT5O6bpTTq1X73T9WdqzOsUQoGI/g3AVACzI50E0Oo8mwuYlka2dRbOg6Y3rCaivdCu7yMi6o/Of+2ANgv6v4iq4ANopYn7oGtc+7cA/F/k7+VoUxF0umsnIi+0AXEpY0y/5qO6Wijyr6467CrXn9Exr8MLBSK6BppOfTpj7Izpq1UAvkFEfiI6F8D5AD7IRhszAWPsE8ZYX8bYUMbYUGiD5CWMsSPQrv22iDfGZQCaTMvtzsIr0IzNIKLhAHzQMkZ26uce4RCAL0X+ngxgZ+TvTvXcIyu/PwL4lDH2S9NXq6AJRkT+XWna3umvP+NjXrYt7Ala4/8K4DCAELRB8HZoxpQDAKoi//3etP9PoFngP0PEW6Oj/se7dsv3e9HmfUQAnolc+ycAxma7/Rl47j4AfwFQA+AjAJO7ynMHMBHAFmieJpsBjOmkz30iNNXQVtP7fR2AYgBvQxOGbwHo3cWuP6NjnkhzIRAIBAKDDq8+EggEAkH6EEJBIBAIBAZCKAgEAoHAQAgFgUAgEBgIoSAQCAQCAyEUBAIXENFeIupDRD2J6D9N20uIaEXk79FEdF0S536UiO5PZ3sFgmQRQkEgSIyeAAyhwBg7xBibGfk4GpofuUDQYRFCQSCwQESvENGWSA77Oy1f/wLAeZFaBouIaCgR1RCRD8ACADdFvrvJugKI7Dc08vdPiGgHEa0HcIFpn/OI6I3I779HRBdm/ooFgjY82W6AQJCDfJsx9jkR5QP4kIheNn33IIARjLHRgJG9EoyxIBE9DC2Kdk7ku0d5JyeiMQC+AW1l4YEWkb0l8vViAN9ljO0konEAfgctlYVA0C4IoSAQ2Pk+EX098vcgaDlk0skVAP7OInlriGhV5N9CAJcDWG5K+OpP828LBDERQkEgMEFEVwKYAmA8Y+wMEb0DIC/J04URraKNdx4JwEl9FSIQZANhUxAIoikC0BgRCBdCq9dg5jS00og8rN/thVZKE5F6wedGtq8D8DUiyiei7gCmAQDTcuXvIaIbI8cQEY1K/ZIEAvcIoSAQRPMGAA8RfQrNqLzJ/CVjrAHAhojReJHl2LUAynVDM7Q8+L2JqBbAHGg1dsG0EosvQcty+g8AH5rOMRvA7URUDaAWWolFgaDdEFlSBQKBQGAgVgoCgUAgMBBCQSAQCAQGQigIBAKBwEAIBYFAIBAYCKEgEAgEAgMhFAQCgUBgIISCQCAQCAz+Px4KsMQ1eIQbAAAAAElFTkSuQmCC",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "workout_data_dd.plot.scatter(\"cadence\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"hr\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"cadence\", \"speed\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"speed\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"altitude\", \"power\")\n",
+ "plt.show()\n",
+ "workout_data_dd.plot.scatter(\"distance\", \"power\")\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Using daal4py for Machine Learning tasks\n",
+ "\n",
+ "In the sections below, we will be using daal4py directly. After importing the model, we will arrange it in a separate independent and dependent dataframes, then use the daal4py's training and prediction classes to generate a workable model."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import daal4py as d4p"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "It is now the time to split the dataset into train and test sets. This is demonstrated below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3902, 9)\n",
+ "(3000, 9) (902, 9)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(workout_data_dd.shape)\n",
+ "train_set = workout_data_dd[0:3000]\n",
+ "test_set = workout_data_dd[3000:]\n",
+ "print(train_set.shape, test_set.shape)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Reduce the dataset, create X. We drop the target, and other non-essential features.\n",
+ "reduced_dataset = train_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)\n",
+ "# Get the target, create Y\n",
+ "target = train_set.power.values.reshape((-1, 1))\n",
+ "# This is essentially doing np.array(dataset.power.values, ndmin=2).T\n",
+ "# as it needs to force a 2 dimensional array as we only have 1 target"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "X is 5 features by 3k rows, Y is 3k rows by 1 column"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "(3000, 5) (3000, 1)\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(reduced_dataset.values.shape, target.shape)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Training the model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Create the Linear Regression Model, and train the model with the data. We utilize daal4py's linear_regression_training class to create the model, then call .compute() with the independent and dependent data as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "d4p_lm = d4p.linear_regression_training(interceptFlag=True)\n",
+ "lm_trained = d4p_lm.compute(reduced_dataset.values, target)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Model has this number of features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Model has this number of features: \", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Prediction (inference) with the trained model"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now that the model is trained, we can test it with the test part of the dataset. We drop the same features to match that of the trained model, and put it into daal4py's linear_regression_prediction class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "subset = test_set.drop([\"time\", \"power\", \"latitude\", \"longitude\"], axis=1)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Now we can create the Prediction object and use the reduced dataset for prediction. The class's arguments use the independent data and the trained model from above as the parameters."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "lm_predictor_component = d4p.linear_regression_prediction()\n",
+ "result = lm_predictor_component.compute(subset.values, lm_trained.model)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.plot(result.prediction[0:300])\n",
+ "plt.plot(test_set.power.values[0:300])\n",
+ "plt.show()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The graph above shows the Orange (predicted) result over the Blue (original data). This data is notoriously sparse in features leading to a difficult to predict target!"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Model properties\n",
+ "Another aspect of the model is the trained model's properties, which are explored below."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Betas: [[ 1.51003501e+01 -1.25075548e-01 1.32249115e+00 1.64363922e-03\n",
+ " 8.53155955e-01 -1.09595022e+01]]\n",
+ "Number of betas: 6\n",
+ "Number of Features: 5\n"
+ ]
+ }
+ ],
+ "source": [
+ "print(\"Betas:\", lm_trained.model.Beta)\n",
+ "print(\"Number of betas:\", lm_trained.model.NumberOfBetas)\n",
+ "print(\"Number of Features:\", lm_trained.model.NumberOfFeatures)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Additional metrics\n",
+ "We can generate metrics on the independent data with daal4py's low_order_moments() class."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[1.90063975e+01, 3.75882355e+01, 4.98258371e+03, 2.41394741e+01,\n",
+ " 1.81623064e+00]])"
+ ]
+ },
+ "execution_count": 14,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "metrics_processor = d4p.low_order_moments()\n",
+ "data = metrics_processor.compute(reduced_dataset.values)\n",
+ "data.standardDeviation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "## Migrating the trained model for inference on external systems\n",
+ "\n",
+ "Occasionally one may need to migrate the trained model to another system for inference only--this use case allows the training on a much more powerful machine with a larger dataset, and placing the trained model for inference-only on a smaller machine."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "import pickle"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 16,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"wb\") as model_pi:\n",
+ " pickle.dump(lm_trained.model, model_pi)\n",
+ " model_pi.close"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The trained model file above can be moved to an inference-only or embedded system. This is useful if the training is extreamly heavy or computed-limited. "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 17,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "with open(\"trained_model2.pickle\", \"rb\") as model_import:\n",
+ " lm_import = pickle.load(model_import)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "The imported model from file is now usable again. We can check the betas from the model to ensure that the trained model is present."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 18,
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "array([[ 1.51003501e+01, -1.25075548e-01, 1.32249115e+00,\n",
+ " 1.64363922e-03, 8.53155955e-01, -1.09595022e+01]])"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "lm_import.Beta"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.10.9 (tags/v3.10.9:1dd9be6, Dec 6 2022, 20:01:21) [MSC v.1934 64 bit (AMD64)]"
+ },
+ "vscode": {
+ "interpreter": {
+ "hash": "8837a6bc722950b4562ef1f8ddb3cf1e2be71cad9580dda11136095ace1c488e"
+ }
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/dbscan.ipynb b/2024.6/.doctrees/nbsphinx/samples/dbscan.ipynb
new file mode 100644
index 0000000000..d6e5c92653
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/dbscan.ipynb
@@ -0,0 +1,344 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn DBSCAN for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.metrics import davies_bouldin_score\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "6fd95eeb",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "33da61da",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 6.37 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "params = {\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at Davies-Bouldin score of the DBSCAN algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class DBSCAN"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the DBSCAN algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 469.21 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import DBSCAN\n",
+ "\n",
+ "start = timer()\n",
+ "y_pred = DBSCAN(**params).fit_predict(x_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look Davies-Bouldin score of the DBSCAN algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Davies-Bouldin score: 0.8542652084275848'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = davies_bouldin_score(x_train, y_pred)\n",
+ "f\"Original Scikit-learn Davies-Bouldin score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Davies-Bouldin score of patched Scikit-learn and original Davies-Bouldin score of patched Scikit-learn: 0.8542652084275848 Davies-Bouldin score of unpatched Scikit-learn: 0.8542652084275848 Metrics ratio: 1.0 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 73.6 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Davies-Bouldin score of patched Scikit-learn and original \"\n",
+ " f\"Davies-Bouldin score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"Davies-Bouldin score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/kmeans.ipynb b/2024.6/.doctrees/nbsphinx/samples/kmeans.ipynb
new file mode 100644
index 0000000000..df09f8ded5
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/kmeans.ipynb
@@ -0,0 +1,362 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Kmeans for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "be391256",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"spoken-arabic-digit\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0cdcb77d",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((236930, 14), (26326, 14), (236930,), (26326,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=123)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "02a779e9",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with Intel® Extension for Scikit-learn for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "1ffc93c7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 7.36 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "params = {\n",
+ " \"n_clusters\": 128,\n",
+ " \"random_state\": 123,\n",
+ " \"copy_x\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn inertia: 13346.641333761074\n",
+ "Intel® extension for Scikit-learn number of iterations: 274\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_opt = model.inertia_\n",
+ "n_iter_opt = model.n_iter_\n",
+ "print(f\"Intel® extension for Scikit-learn inertia: {inertia_opt}\")\n",
+ "print(f\"Intel® extension for Scikit-learn number of iterations: {n_iter_opt}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KMeans"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the KMeans algorithm with original Scikit-learn library for spoken arabic digit dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 192.14 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.cluster import KMeans\n",
+ "\n",
+ "start = timer()\n",
+ "model = KMeans(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Let's take a look at inertia and number of iterations of the KMeans algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn inertia: 13352.813785961785\n",
+ "Original Scikit-learn number of iterations: 212\n"
+ ]
+ }
+ ],
+ "source": [
+ "inertia_original = model.inertia_\n",
+ "n_iter_original = model.n_iter_\n",
+ "print(f\"Original Scikit-learn inertia: {inertia_original}\")\n",
+ "print(f\"Original Scikit-learn number of iterations: {n_iter_original}\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "3639eef9",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare inertia and number of iterations of patched Scikit-learn and original Inertia: Patched Scikit-learn: 13346.641333761074 Unpatched Scikit-learn: 13352.813785961785 Ratio: 0.9995377414603653 Number of iterations: Patched Scikit-learn: 274 Unpatched Scikit-learn: 212 Ratio: 1.29 Number of iterations is bigger but algorithm is much faster and inertia is lowerWith Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get speedup in 26.1 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare inertia and number of iterations of patched Scikit-learn and original \"\n",
+ " f\"Inertia: \"\n",
+ " f\"Patched Scikit-learn: {inertia_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {inertia_original} \"\n",
+ " f\"Ratio: {inertia_opt/inertia_original} \"\n",
+ " f\"Number of iterations: \"\n",
+ " f\"Patched Scikit-learn: {n_iter_opt} \"\n",
+ " f\"Unpatched Scikit-learn: {n_iter_original} \"\n",
+ " f\"Ratio: {(n_iter_opt/n_iter_original):.2f} \"\n",
+ " f\"Number of iterations is bigger but algorithm is much faster and inertia is lower\"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/knn_mnist.ipynb b/2024.6/.doctrees/nbsphinx/samples/knn_mnist.ipynb
new file mode 100644
index 0000000000..b8604d70f0
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/knn_mnist.ipynb
@@ -0,0 +1,333 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn KNN for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Download the data "
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"mnist_784\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6259f584",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((56000, 784), (14000, 784), (56000,), (14000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with Intel® Extension for Scikit-learn for MNIST dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 1.45 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "params = {\"n_neighbors\": 40, \"weights\": \"distance\", \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_opt = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "8ca549ae",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class KNeighborsClassifier."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training and predict KNN algorithm with original Scikit-learn library for MNSIT dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 36.15 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.neighbors import KNeighborsClassifier\n",
+ "\n",
+ "\n",
+ "start = timer()\n",
+ "knn = KNeighborsClassifier(**params).fit(x_train, y_train)\n",
+ "predicted = knn.predict(x_test)\n",
+ "time_original = timer() - start\n",
+ "f\"Original Scikit-learn time: {time_original:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "33da9fd1",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn KNN:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " 0 0.97 0.99 0.98 1365\n",
+ " 1 0.93 0.99 0.96 1637\n",
+ " 2 0.99 0.94 0.96 1401\n",
+ " 3 0.96 0.95 0.96 1455\n",
+ " 4 0.98 0.96 0.97 1380\n",
+ " 5 0.95 0.95 0.95 1219\n",
+ " 6 0.96 0.99 0.97 1317\n",
+ " 7 0.94 0.95 0.95 1420\n",
+ " 8 0.99 0.90 0.94 1379\n",
+ " 9 0.92 0.94 0.93 1427\n",
+ "\n",
+ " accuracy 0.96 14000\n",
+ " macro avg 0.96 0.96 0.96 14000\n",
+ "weighted avg 0.96 0.96 0.96 14000\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn KNN:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 24.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(time_original/time_opt):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/lasso_regression.ipynb b/2024.6/.doctrees/nbsphinx/samples/lasso_regression.ipynb
new file mode 100644
index 0000000000..967d0d4e54
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/lasso_regression.ipynb
@@ -0,0 +1,383 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Lasso Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import requests\n",
+ "import warnings\n",
+ "import os\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "db2d1c39",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "e58a6e28",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "532874ab",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.01,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.9676607251167297'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Lasso"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Lasso algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.83 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Lasso\n",
+ "\n",
+ "start = timer()\n",
+ "model = Lasso(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Lasso algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.9676599502563477'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "13c86289",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.9676607251167297 MSE metric of unpatched Scikit-learn: 0.9676599502563477 Metrics ratio: 1.0000008344650269 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.7 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/linear_regression.ipynb b/2024.6/.doctrees/nbsphinx/samples/linear_regression.ipynb
new file mode 100644
index 0000000000..508ee06d8c
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/linear_regression.ipynb
@@ -0,0 +1,378 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Linear Regression for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import pandas as pd\n",
+ "import numpy as np\n",
+ "import os\n",
+ "import requests\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "ad7ce109",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "801ea6cd",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "dataset_dir = \"data\"\n",
+ "dataset_name = \"year_prediction_msd\"\n",
+ "url = \"https://archive.ics.uci.edu/ml/machine-learning-databases/00203/YearPredictionMSD.txt.zip\"\n",
+ "\n",
+ "os.makedirs(dataset_dir, exist_ok=True)\n",
+ "local_url = os.path.join(dataset_dir, os.path.basename(url))\n",
+ "\n",
+ "if not os.path.isfile(local_url):\n",
+ " response = requests.get(url, stream=True)\n",
+ " with open(local_url, \"wb+\") as file:\n",
+ " for data in response.iter_content(8192):\n",
+ " file.write(data)\n",
+ "\n",
+ "year = pd.read_csv(local_url, header=None)\n",
+ "x = year.iloc[:, 1:].to_numpy(dtype=np.float32)\n",
+ "y = year.iloc[:, 0].to_numpy(dtype=np.float32)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "03431aec",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((463810, 90), (51535, 90), (463810,), (51535,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "### Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train.reshape(-1, 1))\n",
+ "y_train = scaler_y.transform(y_train.reshape(-1, 1)).ravel()\n",
+ "y_test = scaler_y.transform(y_test.reshape(-1, 1)).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with Intel® Extension for Scikit-learn for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.03 s'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "params = {\"n_jobs\": -1, \"copy_X\": False}\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 0.7716818451881409'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LinearRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Linear Regression algorithm with original Scikit-learn library for YearPredictionMSD dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.53 s'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LinearRegression\n",
+ "\n",
+ "start = timer()\n",
+ "model = LinearRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Linear Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 0.7716856598854065'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "91fb14e4",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 0.7716818451881409 MSE metric of unpatched Scikit-learn: 0.7716856598854065 Metrics ratio: 0.9999950528144836 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 18.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb b/2024.6/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb
new file mode 100644
index 0000000000..43727804d7
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb
@@ -0,0 +1,329 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Logistic Regression for Cifar dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fbb52aca",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.datasets import fetch_openml\n",
+ "\n",
+ "x, y = fetch_openml(name=\"CIFAR-100\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bc8ba7c8",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((54000, 3072), (6000, 3072), (54000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=43)\n",
+ "x_train.shape, x_test.shape, y_train.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with Intel® Extension for Scikit-learn for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.82 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "params = {\n",
+ " \"C\": 0.1,\n",
+ " \"solver\": \"lbfgs\",\n",
+ " \"multi_class\": \"multinomial\",\n",
+ " \"n_jobs\": -1,\n",
+ "}\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Log Loss: 3.7073530800931587 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_opt = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Intel® extension for Scikit-learn Log Loss: {log_loss_opt} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class LogisticRegression"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the Logistic Regression algorithm with original Scikit-learn library for CIFAR dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 395.03 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import LogisticRegression\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = LogisticRegression(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2d38dfb5",
+ "metadata": {},
+ "source": [
+ "Predict probability and get a result of the Logistic Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Log Loss: 3.7140870590578428 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = classifier.predict_proba(x_test)\n",
+ "log_loss_original = metrics.log_loss(y_test, y_predict)\n",
+ "f\"Original Scikit-learn Log Loss: {log_loss_original} s\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "b7d17e2f",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare Log Loss metric of patched Scikit-learn and original Log Loss metric of patched Scikit-learn: 3.7073530800931587 Log Loss metric of unpatched Scikit-learn: 3.7140870590578428 Metrics ratio: 0.9981869086917978 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 15.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare Log Loss metric of patched Scikit-learn and original \"\n",
+ " f\"Log Loss metric of patched Scikit-learn: {log_loss_opt} \"\n",
+ " f\"Log Loss metric of unpatched Scikit-learn: {log_loss_original} \"\n",
+ " f\"Metrics ratio: {log_loss_opt/log_loss_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb b/2024.6/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb
new file mode 100644
index 0000000000..8c72c1b71d
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb
@@ -0,0 +1,354 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn NuSVR for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "from IPython.display import HTML\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "adf9ffe9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "a9b315cc",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"medical_charges_nominal\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "49fbf604",
+ "metadata": {},
+ "source": [
+ "### Preprocessing"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fafea10b",
+ "metadata": {},
+ "source": [
+ "Encode categorical features"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "f77c30f2",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "cat_columns = x.select_dtypes([\"category\"]).columns\n",
+ "x[cat_columns] = x[cat_columns].apply(lambda x: x.cat.codes)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cd8d3b6d",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((48919, 11), (114146, 11), (48919,), (114146,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, train_size=0.3, random_state=42)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with Intel® Extension for Scikit-learn for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 24.69 s'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "params = {\n",
+ " \"nu\": 0.4,\n",
+ " \"C\": y_train.mean(),\n",
+ " \"degree\": 2,\n",
+ " \"kernel\": \"poly\",\n",
+ "}\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn R2 score: 0.8635974264586637'"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_opt = nusvr.score(x_test, y_test)\n",
+ "f\"Intel® extension for Scikit-learn R2 score: {score_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class NuSVR"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the NuSVR algorithm with original Scikit-learn library for Medical Charges dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 331.85 s'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import NuSVR\n",
+ "\n",
+ "start = timer()\n",
+ "nusvr = NuSVR(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "23b8faa6",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the NuSVR algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn R2 score: 0.8636031741516902'"
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "score_original = nusvr.score(x_test, y_test)\n",
+ "f\"Original Scikit-learn R2 score: {score_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "3a704d51",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare R2 score of patched Scikit-learn and original R2 score of patched Scikit-learn: 0.8635974264586637 R2 score of unpatched Scikit-learn: 0.8636031741516902 Metrics ratio: 0.999993344520726 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 13.4 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare R2 score of patched Scikit-learn and original \"\n",
+ " f\"R2 score of patched Scikit-learn: {score_opt} \"\n",
+ " f\"R2 score of unpatched Scikit-learn: {score_original} \"\n",
+ " f\"Metrics ratio: {score_opt/score_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb b/2024.6/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb
new file mode 100644
index 0000000000..276284ed9b
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb
@@ -0,0 +1,320 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Random Forest for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from IPython.display import HTML\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "7d0b6bb9",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Yolanda\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "5b3a2483",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((280000, 100), (120000, 100), (280000,), (120000,))"
+ ]
+ },
+ "execution_count": 3,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=72)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with Intel® Extension for Scikit-learn for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "8fecbbb1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 42.56 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "params = {\"n_estimators\": 150, \"random_state\": 44, \"n_jobs\": -1}\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d9279181",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "d05bc57b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 6,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_opt = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Intel® extension for Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class RandomForestRegressor."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training Random Forest algorithm with original Scikit-learn library for Yolanda dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "76a8d5f1",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 123.34 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.ensemble import RandomForestRegressor\n",
+ "\n",
+ "start = timer()\n",
+ "rf = RandomForestRegressor(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f162fe6b",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Random Forest algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d5b5e45c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn Mean Squared Error: 83.62232345666878'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_pred = rf.predict(x_test)\n",
+ "mse_original = metrics.mean_squared_error(y_test, y_pred)\n",
+ "f\"Original Scikit-learn Mean Squared Error: {mse_opt}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "e255e563",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 83.62232345666878 MSE metric of unpatched Scikit-learn: 83.80131297814816 Metrics ratio: 0.9978641203208111 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 2.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_original} \"\n",
+ " f\"Metrics ratio: {mse_opt/mse_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/ridge_regression.ipynb b/2024.6/.doctrees/nbsphinx/samples/ridge_regression.ipynb
new file mode 100644
index 0000000000..1c159a13ae
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/ridge_regression.ipynb
@@ -0,0 +1,390 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "3768ec43",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn Ridge Regression for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "b1b922d1",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.model_selection import train_test_split\n",
+ "import warnings\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.preprocessing import LabelEncoder\n",
+ "from IPython.display import HTML\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2a1a9234",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "7e73dc65",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"Airlines_DepDelay_10M\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f852cad8",
+ "metadata": {},
+ "source": [
+ "### Preprocessing\n",
+ "Let's encode categorical features with LabelEncoder"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "27ebb377",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "for col in [\"UniqueCarrier\", \"Origin\", \"Dest\"]:\n",
+ " le = LabelEncoder().fit(x[col])\n",
+ " x[col] = le.transform(x[col])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "147b3e82",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "0d332789",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "((9000000, 9), (1000000, 9), (9000000,), (1000000,))"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.1, random_state=0)\n",
+ "x_train.shape, x_test.shape, y_train.shape, y_test.shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "246f819f",
+ "metadata": {},
+ "source": [
+ "Normalize the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "454a341c",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
+ "\n",
+ "scaler_x = MinMaxScaler()\n",
+ "scaler_y = StandardScaler()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "df400504",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "y_train = y_train.to_numpy().reshape(-1, 1)\n",
+ "y_test = y_test.to_numpy().reshape(-1, 1)\n",
+ "\n",
+ "scaler_x.fit(x_train)\n",
+ "x_train = scaler_x.transform(x_train)\n",
+ "x_test = scaler_x.transform(x_test)\n",
+ "\n",
+ "scaler_y.fit(y_train)\n",
+ "y_train = scaler_y.transform(y_train).ravel()\n",
+ "y_test = scaler_y.transform(y_test).ravel()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe1d4fac",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "ef6938df",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "20c5ab48",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f80273e7",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with Intel® Extension for Scikit-learn for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "a4dd1c7e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 0.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "params = {\n",
+ " \"alpha\": 0.3,\n",
+ " \"fit_intercept\": False,\n",
+ " \"random_state\": 0,\n",
+ " \"copy_X\": False,\n",
+ "}\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f10b51fc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "d4295a26",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Patched Scikit-learn MSE: 1.0014288520708046'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_opt = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Patched Scikit-learn MSE: {mse_metric_opt}\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "cbe6db0d",
+ "metadata": {},
+ "source": [
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class Ridge"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "6f64ba97",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f242c6da",
+ "metadata": {},
+ "source": [
+ "Training of the Ridge Regression algorithm with original Scikit-learn library for Airlines DepDelay dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 11,
+ "id": "67243849",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 0.70 s'"
+ ]
+ },
+ "execution_count": 11,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.linear_model import Ridge\n",
+ "\n",
+ "start = timer()\n",
+ "model = Ridge(random_state=0).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c85a125c",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the Ridge Regression algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 12,
+ "id": "cd9e726c",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn MSE: 1.0014288520708057'"
+ ]
+ },
+ "execution_count": 12,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "y_predict = model.predict(x_test)\n",
+ "mse_metric_original = metrics.mean_squared_error(y_test, y_predict)\n",
+ "f\"Original Scikit-learn MSE: {mse_metric_original}\""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 13,
+ "id": "1bde360d",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "Compare MSE metric of patched Scikit-learn and original MSE metric of patched Scikit-learn: 1.0014288520708046 MSE metric of unpatched Scikit-learn: 1.0014288520708057 Metrics ratio: 0.9999999999999989 With Scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 10.9 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 13,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"Compare MSE metric of patched Scikit-learn and original \"\n",
+ " f\"MSE metric of patched Scikit-learn: {mse_metric_opt} \"\n",
+ " f\"MSE metric of unpatched Scikit-learn: {mse_metric_original} \"\n",
+ " f\"Metrics ratio: {mse_metric_opt/mse_metric_original} \"\n",
+ " f\"With Scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/svc_adult.ipynb b/2024.6/.doctrees/nbsphinx/samples/svc_adult.ipynb
new file mode 100644
index 0000000000..9e49bcfecd
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/svc_adult.ipynb
@@ -0,0 +1,322 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn SVC for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from IPython.display import HTML\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import fetch_openml\n",
+ "from sklearn.model_selection import train_test_split"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "2cdcbfa6",
+ "metadata": {},
+ "source": [
+ "### Download the data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = fetch_openml(name=\"a9a\", return_X_y=True)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "3a6df301",
+ "metadata": {},
+ "source": [
+ "Split the data into train and test sets"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "96e14dd7",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=42)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with Intel® Extension for Scikit-learn for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Intel® extension for Scikit-learn time: 14.08 s'"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "params = {\"C\": 100.0, \"kernel\": \"rbf\", \"gamma\": \"scale\"}\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_patched = timer() - start\n",
+ "f\"Intel® extension for Scikit-learn time: {train_patched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "d01cdabc",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with Intel® Extension for Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "9ead2a44",
+ "metadata": {
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for Intel® extension for Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for Intel® extension for Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ "*The first column of the classification report above is the class labels.* \n",
+ " \n",
+ "### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class SVC."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training of the SVC algorithm with original Scikit-learn library for Adult dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Original Scikit-learn time: 803.06 s'"
+ ]
+ },
+ "execution_count": 8,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from sklearn.svm import SVC\n",
+ "\n",
+ "start = timer()\n",
+ "classifier = SVC(**params).fit(x_train, y_train)\n",
+ "train_unpatched = timer() - start\n",
+ "f\"Original Scikit-learn time: {train_unpatched:.2f} s\""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "c0a7a747",
+ "metadata": {},
+ "source": [
+ "Predict and get a result of the SVC algorithm with original Scikit-learn"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "7644999d",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Classification report for original Scikit-learn SVC:\n",
+ " precision recall f1-score support\n",
+ "\n",
+ " -1.0 0.87 0.90 0.88 7414\n",
+ " 1.0 0.64 0.58 0.61 2355\n",
+ "\n",
+ " accuracy 0.82 9769\n",
+ " macro avg 0.76 0.74 0.75 9769\n",
+ "weighted avg 0.82 0.82 0.82 9769\n",
+ "\n",
+ "\n"
+ ]
+ }
+ ],
+ "source": [
+ "predicted = classifier.predict(x_test)\n",
+ "report = metrics.classification_report(y_test, predicted)\n",
+ "print(f\"Classification report for original Scikit-learn SVC:\\n{report}\\n\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "id": "fc992182",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "With scikit-learn-intelex patching you can: Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); Fast execution training and prediction of Scikit-learn models; Get the similar quality Get speedup in 57.0 times. "
+ ],
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 10,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "HTML(\n",
+ " f\"With scikit-learn-intelex patching you can: \"\n",
+ " f\"\"\n",
+ " f\"Use your Scikit-learn code for training and prediction with minimal changes (a couple of lines of code); \"\n",
+ " f\"Fast execution training and prediction of Scikit-learn models; \"\n",
+ " f\"Get the similar quality \"\n",
+ " f\"Get speedup in {(train_unpatched/train_patched):.1f} times. \"\n",
+ " f\" \"\n",
+ ")"
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.8.12"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples/tsne.ipynb b/2024.6/.doctrees/nbsphinx/samples/tsne.ipynb
new file mode 100644
index 0000000000..99ad8fcefd
--- /dev/null
+++ b/2024.6/.doctrees/nbsphinx/samples/tsne.ipynb
@@ -0,0 +1,285 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "f5c4abc0",
+ "metadata": {},
+ "source": [
+ "# Intel® Extension for Scikit-learn TSNE example"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "id": "23512089",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from timeit import default_timer as timer\n",
+ "from sklearn import metrics\n",
+ "from sklearn.datasets import make_blobs\n",
+ "import matplotlib.pyplot as plt\n",
+ "\n",
+ "%matplotlib inline\n",
+ "\n",
+ "import warnings\n",
+ "\n",
+ "warnings.filterwarnings(\"ignore\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "b6e359f6",
+ "metadata": {},
+ "source": [
+ "### Generate the data \n",
+ "Generate isotropic Gaussian blobs for clustering.\n",
+ " \n",
+ "With the number of samples: 20k \n",
+ "Number of features: 100 \n",
+ "Number of blobs: 4 \n",
+ "Source: \n",
+ "https://scikit-learn.org/stable/modules/generated/sklearn.datasets.make_blobs.html\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "id": "27b99b44",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "x, y = make_blobs(n_samples=20000, centers=4, n_features=100, random_state=0)"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "0341cac9",
+ "metadata": {},
+ "source": [
+ "### Patch original Scikit-learn with Intel® Extension for Scikit-learn\n",
+ "Intel® Extension for Scikit-learn (previously known as daal4py) contains drop-in replacement functionality for the stock Scikit-learn package. You can take advantage of the performance optimizations of Intel® Extension for Scikit-learn by adding just two lines of code before the usual Scikit-learn imports:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "id": "244c5bc9",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Intel(R) Extension for Scikit-learn* enabled (https://github.com/intel/scikit-learn-intelex)\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearnex import patch_sklearn\n",
+ "\n",
+ "patch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "6bb14ac8",
+ "metadata": {},
+ "source": [
+ "Intel® Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://intel.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/intel/scikit-learn-intelex/issues)."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "693b4e26",
+ "metadata": {},
+ "source": [
+ "Training TSNE algorithm with Intel® Extension for Scikit-learn for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "id": "e9b8f06b",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Intel® extension for Scikit-learn time: 12.63 s\n",
+ "Intel® Extension for scikit-learn. Divergence: 4.289110606110757\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_intelex = tsne.fit_transform(x)\n",
+ "time_opt = timer() - start\n",
+ "\n",
+ "print(f\"Intel® extension for Scikit-learn time: {time_opt:.2f} s\")\n",
+ "print(f\"Intel® Extension for scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "bd8e7b0b",
+ "metadata": {},
+ "source": [
+ " ### Train the same algorithm with original Scikit-learn\n",
+ "In order to cancel optimizations, we use *unpatch_sklearn* and reimport the class TSNE."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "id": "5bb884d5",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "from sklearnex import unpatch_sklearn\n",
+ "\n",
+ "unpatch_sklearn()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8cfa0dba",
+ "metadata": {},
+ "source": [
+ "Training algorithm with original Scikit-learn library for generated dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "id": "ae421d8e",
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Original Scikit-learn time: 37.66 s\n",
+ "Original Scikit-learn. Divergence: 4.2955403327941895\n"
+ ]
+ }
+ ],
+ "source": [
+ "from sklearn.manifold import TSNE\n",
+ "\n",
+ "params = {\"n_components\": 2, \"random_state\": 42}\n",
+ "start = timer()\n",
+ "tsne = TSNE(**params)\n",
+ "embedding_original = tsne.fit_transform(x)\n",
+ "time_original = timer() - start\n",
+ "\n",
+ "print(f\"Original Scikit-learn time: {time_original:.2f} s\")\n",
+ "print(f\"Original Scikit-learn. Divergence: {tsne.kl_divergence_}\")"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "8358d7c2",
+ "metadata": {},
+ "source": [
+ "### Plot embeddings original scikit-learn and Intel® extension"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 7,
+ "id": "43ab1a96",
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "colors = [int(m) for m in y]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 8,
+ "id": "35147d24",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "for emb, title in zip(\n",
+ " [embedding_intelex, embedding_original],\n",
+ " [\"Intel® Extension for scikit-learn\", \"Original scikit-learn\"],\n",
+ "):\n",
+ " plt.scatter(emb[:, 0], emb[:, 1], c=colors)\n",
+ " plt.title(title)\n",
+ " plt.xlabel(\"x\")\n",
+ " plt.ylabel(\"y\")\n",
+ " plt.show()"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "id": "ffd79e96",
+ "metadata": {},
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "'Speedup for this run: 3.0'"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "f\"Speedup for this run: {(time_original/time_opt):.1f}\""
+ ]
+ }
+ ],
+ "metadata": {
+ "kernelspec": {
+ "display_name": "Python 3 (ipykernel)",
+ "language": "python",
+ "name": "python3"
+ },
+ "language_info": {
+ "codemirror_mode": {
+ "name": "ipython",
+ "version": 3
+ },
+ "file_extension": ".py",
+ "mimetype": "text/x-python",
+ "name": "python",
+ "nbconvert_exporter": "python",
+ "pygments_lexer": "ipython3",
+ "version": "3.9.15"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png
new file mode 100644
index 0000000000..6c7d082563
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png
new file mode 100644
index 0000000000..cc9df20282
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png
new file mode 100644
index 0000000000..5e5d8b1d1a
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png
new file mode 100644
index 0000000000..e79ca5011f
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png
new file mode 100644
index 0000000000..b7c37519c2
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png
new file mode 100644
index 0000000000..87ce1f07e7
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png
new file mode 100644
index 0000000000..0a059e8d7f
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_tsne_15_0.png b/2024.6/.doctrees/nbsphinx/samples_tsne_15_0.png
new file mode 100644
index 0000000000..5a1138f6bc
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_tsne_15_0.png differ
diff --git a/2024.6/.doctrees/nbsphinx/samples_tsne_15_1.png b/2024.6/.doctrees/nbsphinx/samples_tsne_15_1.png
new file mode 100644
index 0000000000..49b9be9ae0
Binary files /dev/null and b/2024.6/.doctrees/nbsphinx/samples_tsne_15_1.png differ
diff --git a/2024.6/.doctrees/oneapi-gpu.doctree b/2024.6/.doctrees/oneapi-gpu.doctree
new file mode 100644
index 0000000000..fb09d760c3
Binary files /dev/null and b/2024.6/.doctrees/oneapi-gpu.doctree differ
diff --git a/2024.6/.doctrees/quick-start.doctree b/2024.6/.doctrees/quick-start.doctree
new file mode 100644
index 0000000000..f6d1208b06
Binary files /dev/null and b/2024.6/.doctrees/quick-start.doctree differ
diff --git a/2024.6/.doctrees/samples.doctree b/2024.6/.doctrees/samples.doctree
new file mode 100644
index 0000000000..bb331853dd
Binary files /dev/null and b/2024.6/.doctrees/samples.doctree differ
diff --git a/2024.6/.doctrees/samples/ElasticNet.doctree b/2024.6/.doctrees/samples/ElasticNet.doctree
new file mode 100644
index 0000000000..bc92181ca1
Binary files /dev/null and b/2024.6/.doctrees/samples/ElasticNet.doctree differ
diff --git a/2024.6/.doctrees/samples/daal4py_data_science.doctree b/2024.6/.doctrees/samples/daal4py_data_science.doctree
new file mode 100644
index 0000000000..f718d885a2
Binary files /dev/null and b/2024.6/.doctrees/samples/daal4py_data_science.doctree differ
diff --git a/2024.6/.doctrees/samples/dbscan.doctree b/2024.6/.doctrees/samples/dbscan.doctree
new file mode 100644
index 0000000000..64599e85f8
Binary files /dev/null and b/2024.6/.doctrees/samples/dbscan.doctree differ
diff --git a/2024.6/.doctrees/samples/kmeans.doctree b/2024.6/.doctrees/samples/kmeans.doctree
new file mode 100644
index 0000000000..72a91f679c
Binary files /dev/null and b/2024.6/.doctrees/samples/kmeans.doctree differ
diff --git a/2024.6/.doctrees/samples/knn_mnist.doctree b/2024.6/.doctrees/samples/knn_mnist.doctree
new file mode 100644
index 0000000000..4f73c944ae
Binary files /dev/null and b/2024.6/.doctrees/samples/knn_mnist.doctree differ
diff --git a/2024.6/.doctrees/samples/lasso_regression.doctree b/2024.6/.doctrees/samples/lasso_regression.doctree
new file mode 100644
index 0000000000..21ac8839cf
Binary files /dev/null and b/2024.6/.doctrees/samples/lasso_regression.doctree differ
diff --git a/2024.6/.doctrees/samples/linear_regression.doctree b/2024.6/.doctrees/samples/linear_regression.doctree
new file mode 100644
index 0000000000..8d69bc0286
Binary files /dev/null and b/2024.6/.doctrees/samples/linear_regression.doctree differ
diff --git a/2024.6/.doctrees/samples/logistictic_regression_cifar.doctree b/2024.6/.doctrees/samples/logistictic_regression_cifar.doctree
new file mode 100644
index 0000000000..3080b9dd57
Binary files /dev/null and b/2024.6/.doctrees/samples/logistictic_regression_cifar.doctree differ
diff --git a/2024.6/.doctrees/samples/nusvr_medical_charges.doctree b/2024.6/.doctrees/samples/nusvr_medical_charges.doctree
new file mode 100644
index 0000000000..f3fb8d6737
Binary files /dev/null and b/2024.6/.doctrees/samples/nusvr_medical_charges.doctree differ
diff --git a/2024.6/.doctrees/samples/random_forest_yolanda.doctree b/2024.6/.doctrees/samples/random_forest_yolanda.doctree
new file mode 100644
index 0000000000..908600b90b
Binary files /dev/null and b/2024.6/.doctrees/samples/random_forest_yolanda.doctree differ
diff --git a/2024.6/.doctrees/samples/ridge_regression.doctree b/2024.6/.doctrees/samples/ridge_regression.doctree
new file mode 100644
index 0000000000..07fe5f7f6f
Binary files /dev/null and b/2024.6/.doctrees/samples/ridge_regression.doctree differ
diff --git a/2024.6/.doctrees/samples/svc_adult.doctree b/2024.6/.doctrees/samples/svc_adult.doctree
new file mode 100644
index 0000000000..b10d8535f9
Binary files /dev/null and b/2024.6/.doctrees/samples/svc_adult.doctree differ
diff --git a/2024.6/.doctrees/samples/tsne.doctree b/2024.6/.doctrees/samples/tsne.doctree
new file mode 100644
index 0000000000..573b22463c
Binary files /dev/null and b/2024.6/.doctrees/samples/tsne.doctree differ
diff --git a/2024.6/.doctrees/support.doctree b/2024.6/.doctrees/support.doctree
new file mode 100644
index 0000000000..bafbc90007
Binary files /dev/null and b/2024.6/.doctrees/support.doctree differ
diff --git a/2024.6/.doctrees/tutorials.doctree b/2024.6/.doctrees/tutorials.doctree
new file mode 100644
index 0000000000..3940ae9bc7
Binary files /dev/null and b/2024.6/.doctrees/tutorials.doctree differ
diff --git a/2024.6/.doctrees/verbose.doctree b/2024.6/.doctrees/verbose.doctree
new file mode 100644
index 0000000000..ae981f67c4
Binary files /dev/null and b/2024.6/.doctrees/verbose.doctree differ
diff --git a/2024.6/.nojekyll b/2024.6/.nojekyll
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/2024.6/404.html b/2024.6/404.html
new file mode 100644
index 0000000000..ab5db15ac5
--- /dev/null
+++ b/2024.6/404.html
@@ -0,0 +1,395 @@
+
+
+
+
+
+
+ Page not found — Intel(R) Extension for Scikit-learn* 2024.6 documentation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Intel(R) Extension for Scikit-learn*
+
+
+
+
+
+
+
+
+
+Page not found
+Unfortunately, we could not find the page you were looking for. Try:
+
+using search to browse documentation
+checking the table of contents on the left
+filing an issue or
+starting a discussion on GitHub
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+
\ No newline at end of file
diff --git a/2024.6/_images/samples_daal4py_data_science_24_0.png b/2024.6/_images/samples_daal4py_data_science_24_0.png
new file mode 100644
index 0000000000..6c7d082563
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_24_0.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_0.png b/2024.6/_images/samples_daal4py_data_science_7_0.png
new file mode 100644
index 0000000000..cc9df20282
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_0.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_1.png b/2024.6/_images/samples_daal4py_data_science_7_1.png
new file mode 100644
index 0000000000..5e5d8b1d1a
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_1.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_2.png b/2024.6/_images/samples_daal4py_data_science_7_2.png
new file mode 100644
index 0000000000..e79ca5011f
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_2.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_3.png b/2024.6/_images/samples_daal4py_data_science_7_3.png
new file mode 100644
index 0000000000..b7c37519c2
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_3.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_4.png b/2024.6/_images/samples_daal4py_data_science_7_4.png
new file mode 100644
index 0000000000..87ce1f07e7
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_4.png differ
diff --git a/2024.6/_images/samples_daal4py_data_science_7_5.png b/2024.6/_images/samples_daal4py_data_science_7_5.png
new file mode 100644
index 0000000000..0a059e8d7f
Binary files /dev/null and b/2024.6/_images/samples_daal4py_data_science_7_5.png differ
diff --git a/2024.6/_images/samples_tsne_15_0.png b/2024.6/_images/samples_tsne_15_0.png
new file mode 100644
index 0000000000..5a1138f6bc
Binary files /dev/null and b/2024.6/_images/samples_tsne_15_0.png differ
diff --git a/2024.6/_images/samples_tsne_15_1.png b/2024.6/_images/samples_tsne_15_1.png
new file mode 100644
index 0000000000..49b9be9ae0
Binary files /dev/null and b/2024.6/_images/samples_tsne_15_1.png differ
diff --git a/2024.6/_images/scikit-learn-acceleration.PNG b/2024.6/_images/scikit-learn-acceleration.PNG
new file mode 100644
index 0000000000..d045478f39
Binary files /dev/null and b/2024.6/_images/scikit-learn-acceleration.PNG differ
diff --git a/2024.6/_sources/404.rst.txt b/2024.6/_sources/404.rst.txt
new file mode 100644
index 0000000000..3060a3f9cc
--- /dev/null
+++ b/2024.6/_sources/404.rst.txt
@@ -0,0 +1,28 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+:orphan:
+:nosearch:
+
+Page not found
+==============
+
+Unfortunately, we could not find the page you were looking for. Try:
+
+- using :ref:`search ` to browse documentation
+- checking the table of contents on the left
+- filing an `issue `_ or
+ starting a `discussion `_ on GitHub
\ No newline at end of file
diff --git a/2024.6/_sources/algorithms.rst.txt b/2024.6/_sources/algorithms.rst.txt
new file mode 100644
index 0000000000..49c93f378f
--- /dev/null
+++ b/2024.6/_sources/algorithms.rst.txt
@@ -0,0 +1,373 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _sklearn_algorithms:
+
+####################
+Supported Algorithms
+####################
+
+Applying |intelex| impacts the following scikit-learn algorithms:
+
+on CPU
+------
+
+Classification
+**************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVC`
+ - All parameters are supported
+ - No limitations
+ * - `NuSVC`
+ - All parameters are supported
+ - No limitations
+ * - `RandomForestClassifier`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'gini'`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsClassifier`
+ -
+ - For ``algorithm`` == `'kd_tree'`:
+
+ all parameters except ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - For ``algorithm`` == `'brute'`:
+
+ all parameters except ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Multi-output and sparse data are not supported
+ * - `LogisticRegression`
+ - All parameters are supported except:
+
+ - ``solver`` not in [`'lbfgs'`, `'newton-cg'`]
+ - ``class_weight`` != `None`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported
+
+Regression
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVR`
+ - All parameters are supported
+ - No limitations
+ * - `NuSVR`
+ - All parameters are supported
+ - No limitations
+ * - `RandomForestRegressor`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'mse'`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsRegressor`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - Multi-output and sparse data are not supported
+ * - `LinearRegression`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+ * - `Ridge`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``solver`` != `'auto'`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+ * - `ElasticNet`
+ - All parameters are supported except:
+
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported, `#observations` should be >= `#features`.
+ * - `Lasso`
+ - All parameters are supported except:
+
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported, `#observations` should be >= `#features`.
+
+Clustering
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `KMeans`
+ - All parameters are supported except:
+
+ - ``precompute_distances``
+ - ``sample_weight`` != `None`
+ - No limitations
+ * - `DBSCAN`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - ``algorithm`` not in [`'brute'`, `'auto'`]
+ - Only dense data is supported
+
+Dimensionality reduction
+************************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `PCA`
+ - All parameters are supported except:
+
+ - ``svd_solver`` not in [`'full'`, `'covariance_eigh'`]
+ - Sparse data is not supported
+ * - `TSNE`
+ - All parameters are supported except:
+
+ - ``metric`` != 'euclidean' or `'minkowski'` with ``p`` != `2`
+
+ Refer to :ref:`TSNE acceleration details ` to learn more.
+ - Sparse data is not supported
+
+Nearest Neighbors
+*****************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `NearestNeighbors`
+ -
+ - For ``algorithm`` == 'kd_tree':
+
+ all parameters except ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - For ``algorithm`` == 'brute':
+
+ all parameters except ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Sparse data is not supported
+
+Other tasks
+***********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `train_test_split`
+ - All parameters are supported
+ - Only dense data is supported
+ * - `assert_all_finite`
+ - All parameters are supported
+ - Only dense data is supported
+ * - `pairwise_distance`
+ - All parameters are supported except:
+
+ - ``metric`` not in [`'cosine'`, `'correlation'`]
+ - Only dense data is supported
+ * - `roc_auc_score`
+ - All parameters are supported except:
+
+ - ``average`` != `None`
+ - ``sample_weight`` != `None`
+ - ``max_fpr`` != `None`
+ - ``multi_class`` != `None`
+ - No limitations
+
+on GPU
+------
+
+.. seealso:: :ref:`oneapi_gpu`
+
+Classification
+**************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `SVC`
+ - All parameters are supported except:
+
+ - ``kernel`` = `'sigmoid_poly'`
+ - ``class_weight`` != `None`
+ - Only binary dense data is supported
+ * - `RandomForestClassifier`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'gini'`
+ - ``oob_score`` = `True`
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsClassifier`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Only dense data is supported
+ * - `LogisticRegression`
+ - All parameters are supported except:
+
+ - ``solver`` != `'newton-cg'`
+ - ``class_weight`` != `None`
+ - ``sample_weight`` != `None`
+ - ``penalty`` != `'l2'`
+ - Only dense data is supported
+
+Regression
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `RandomForestRegressor`
+ - All parameters are supported except:
+
+ - ``warm_start`` = `True`
+ - ``cpp_alpha`` != `0`
+ - ``criterion`` != `'mse'`
+ - ``oob_score`` = `True`
+ - ``sample_weight`` != `None`
+ - Multi-output and sparse data are not supported
+ * - `KNeighborsRegressor`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+ - Only dense data is supported
+ * - `LinearRegression`
+ - All parameters are supported except:
+
+ - ``normalize`` != `False`
+ - ``sample_weight`` != `None`
+ - Only dense data is supported, `#observations` should be >= `#features`.
+
+Clustering
+**********
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `KMeans`
+ - All parameters are supported except:
+
+ - ``precompute_distances``
+ - ``sample_weight`` != `None`
+
+ ``Init`` = `'k-means++'` fallbacks to CPU.
+ - Sparse data is not supported
+ * - `DBSCAN`
+ - All parameters are supported except:
+
+ - ``metric`` != `'euclidean'`
+ - ``algorithm`` not in [`'brute'`, `'auto'`]
+ - Only dense data is supported
+
+Dimensionality reduction
+************************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `PCA`
+ - All parameters are supported except:
+
+ - ``svd_solver`` not in [`'full'`, `'covariance_eigh'`]
+ - Sparse data is not supported
+
+Nearest Neighbors
+*****************
+
+.. list-table::
+ :widths: 10 30 20
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Parameters
+ - Data formats
+ * - `NearestNeighbors`
+ - All parameters are supported except:
+
+ - ``algorithm`` != `'brute'`
+ - ``weights`` = `'callable'`
+ - ``metric`` not in [`'euclidean'`, `'manhattan'`, `'minkowski'`, `'chebyshev'`, `'cosine'`]
+ - Only dense data is supported
+
+Scikit-learn tests
+------------------
+
+Monkey-patched scikit-learn classes and functions passes scikit-learn's own test
+suite, with few exceptions, specified in `deselected_tests.yaml
+`__.
+
+The results of the entire latest scikit-learn test suite with |intelex|: `CircleCI
+`_.
\ No newline at end of file
diff --git a/2024.6/_sources/blogs.rst.txt b/2024.6/_sources/blogs.rst.txt
new file mode 100644
index 0000000000..2d9b0024e5
--- /dev/null
+++ b/2024.6/_sources/blogs.rst.txt
@@ -0,0 +1,35 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _blogs:
+
+Follow us on Medium
+--------------------
+We publish blogs on Medium, so `follow us `_
+to learn tips and tricks for more efficient data analysis the help of |intelex|.
+Here are our latest blogs:
+
+- `Save Time and Money with Intel Extension for Scikit-learn `_,
+- `Superior Machine Learning Performance on the Latest Intel Xeon Scalable Processors `_,
+- `Leverage Intel Optimizations in Scikit-Learn `_,
+- `Intel Gives Scikit-Learn the Performance Boost Data Scientists Need `_,
+- `From Hours to Minutes: 600x Faster SVM `_,
+- `Improve the Performance of XGBoost and LightGBM Inference `_,
+- `Accelerate Kaggle Challenges Using Intel AI Analytics Toolkit `_,
+- `Accelerate Your scikit-learn Applications `_,
+- `Accelerate Linear Models for Machine Learning `_,
+- `Accelerate K-Means Clustering `_.
+- `Why Pay More for Machine Learning? `_.
diff --git a/2024.6/_sources/contribute.rst.txt b/2024.6/_sources/contribute.rst.txt
new file mode 100644
index 0000000000..28283bd9d8
--- /dev/null
+++ b/2024.6/_sources/contribute.rst.txt
@@ -0,0 +1,64 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+##################
+How to Contribute
+##################
+
+As an open source project, we welcome community contributions to Intel(R) Extension for Scikit-learn.
+This document explains how to participate in project conversations, log bugs and enhancement requests, and submit code patches.
+
+Licensing
+----------------------------------
+Intel(R) Extension for Scikit-learn uses the `Apache 2.0 License `_. By contributing to the project, you agree to the license and copyright terms and release your own contributions under these terms.
+
+Pull Requests
+----------------------------------
+No anonymous contributions are accepted. The name in the commit message Signed-off-by line and your email must match the change authorship information.
+
+Make sure your .gitconfig is set up correctly so you can use git commit -s for signing your patches:
+
+::
+
+ git config --global user.name "Kate Developer"
+ git config --global user.email kate.developer@company.com
+
+Before Contributing Changes
+********************************************
+
+Make sure you can build the product and run all the tests with your patch.
+For a larger feature, provide a relevant test.
+Document your code. Our project uses reStructuredText for documentation.
+For new file(s), specify the appropriate copyright year in the first line.
+Submit a pull request into the master branch.
+Continuous Integration (CI) testing is enabled for the repository. Your pull request must pass all checks before it can be merged. We will review your contribution and may provide feedback to guide you if any additional fixes or modifications are necessary. When reviewed and accepted, your pull request will be merged into our GitHub repository.
+
+Code Style
+-------------------
+
+We use `black `_ and `isort `_ formatters for Python* code.
+The line length is 90 characters; use default options otherwise. You can find the linter configuration in `.pyproject.toml `_.
+
+A GitHub* Action verifies if your changes comply with the output of the auto-formatting tools.
+
+Optionally, you can install pre-commit hooks that do the formatting for you. For this, run from the top level of the repository:
+
+::
+
+ pip install pre-commit
+ pre-commit install
+
+
diff --git a/2024.6/_sources/deprecation.rst.txt b/2024.6/_sources/deprecation.rst.txt
new file mode 100644
index 0000000000..5bc3f3fd19
--- /dev/null
+++ b/2024.6/_sources/deprecation.rst.txt
@@ -0,0 +1,30 @@
+.. ******************************************************************************
+.. * Copyright 2023 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+
+Deprecation Notice
+==================
+
+This page provides information about the deprecations of a specific |intelex| functionality.
+
+macOS* Support
+**************
+
+**Deprecation:** macOS* support is deprecated for |intelex|. The 2023.x releases are the last to provide it.
+
+**Reasons for deprecation:** No modern X86 macOS*-based systems are to be released.
+
+**Alternatives:** The 2023.x version on macOS*.
diff --git a/2024.6/_sources/distributed-mode.rst.txt b/2024.6/_sources/distributed-mode.rst.txt
new file mode 100644
index 0000000000..3b152b68a0
--- /dev/null
+++ b/2024.6/_sources/distributed-mode.rst.txt
@@ -0,0 +1,30 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _distributed:
+
+Distributed Mode
+================
+
+.. note::
+
+ |intelex| contains scikit-learn patching functionality that was originally available in
+ `daal4py `_ package.
+ We recommend you to use scikit-learn-intelex package instead of daal4py.
+ You can learn more about daal4py in `daal4py documentation `_.
+
+While daal4py is available in `distribued mode `_,
+|intelex| does not currently offer this functionality.
diff --git a/2024.6/_sources/guide/acceleration.rst.txt b/2024.6/_sources/guide/acceleration.rst.txt
new file mode 100644
index 0000000000..952ee73539
--- /dev/null
+++ b/2024.6/_sources/guide/acceleration.rst.txt
@@ -0,0 +1,86 @@
+.. ******************************************************************************
+.. * Copyright 2022 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+########################
+Tuning Guide
+########################
+
+The performance of some algorithms changes based on the parameters that are used.
+This section denotes the details of such cases.
+
+Refer to :ref:`sklearn_algorithms` to see the full list of algorithms, parameters, and data formats supported in |intelex|.
+
+.. _acceleration_tsne:
+
+TSNE
+----
+
+TSNE algorithm consists of two components: KNN and Gradient Descent.
+The overall acceleration of TSNE depends on the acceleration of each of these algorithms.
+
+- The KNN part of the algorithm supports all parameters except:
+
+ - ``metric`` != `'euclidean'` or `'minkowski'` with ``p`` != `2`
+- The Gradient Descent part of the algorithm supports all parameters except:
+
+ - ``n_components`` = `3`
+ - ``method`` = `'exact'`
+ - ``verbose`` != `0`
+
+To get better performance, use parameters supported by both components.
+
+.. _acceleration_rf:
+
+Random Forest
+-------------
+
+Random Forest models accelerated with |intelex| and using the `hist` splitting
+method discretize training data by creating a histogram with a configurable
+number of bins. The following keyword arguments can be used to influence the
+created histogram.
+
+.. list-table::
+ :widths: 10 10 10 30
+ :header-rows: 1
+ :align: left
+
+ * - Keyword argument
+ - Possible values
+ - Default value
+ - Description
+ * - ``maxBins``
+ - `[0, inf)`
+ - ``256``
+ - Number of bins in the histogram with the discretized training data. The
+ value ``0`` disables data discretization.
+ * - ``minBinSize``
+ - `[1, inf)`
+ - ``5``
+ - Minimum number of training data points in each bin after discretization.
+ * - ``binningStrategy``
+ - ``quantiles, averages``
+ - ``quantiles``
+ - Selects the algorithm used to calculate bin edges. ``quantiles``
+ results in bins with a similar amount of training data points. ``averages``
+ divides the range of values observed in the training data set into
+ equal-width bins of size `(max - min) / maxBins`.
+
+Note that using discretized training data can greatly accelerate model training
+times, especially for larger data sets. However, due to the reduced fidelity of
+the data, the resulting model can present worse performance metrics compared to
+a model trained on the original data. In such cases, the number of bins can be
+increased with the ``maxBins`` parameter, or binning can be disabled entirely by
+setting ``maxBins=0``.
diff --git a/2024.6/_sources/index.rst.txt b/2024.6/_sources/index.rst.txt
new file mode 100644
index 0000000000..62055385c8
--- /dev/null
+++ b/2024.6/_sources/index.rst.txt
@@ -0,0 +1,134 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |intelex_repo| replace:: |intelex| repository
+.. _intelex_repo: https://github.com/intel/scikit-learn-intelex
+
+.. _index:
+
+#########
+|intelex|
+#########
+
+Intel(R) Extension for Scikit-learn is a **free software AI accelerator** designed to deliver up to **100X** faster performance for your existing scikit-learn code.
+The software acceleration is achieved with vector instructions, AI hardware-specific memory optimizations, threading, and optimizations for all upcoming Intel(R) platforms at launch time.
+
+.. rubric:: Designed for Data Scientists and Framework Designers
+
+
+Use Intel(R) Extension for Scikit-learn, to:
+
+* Speed up training and inference by up to 100x with the equivalent mathematical accuracy
+* Benefit from performance improvements across different x86-compatible CPUs or Intel(R) GPUs
+* Integrate the extension into your existing Scikit-learn applications without code modifications
+* Enable and disable the extension with a couple of lines of code or at the command line
+
+Intel(R) Extension for Scikit-learn is also a part of `Intel(R) AI Tools `_.
+
+
+.. image:: _static/scikit-learn-acceleration.PNG
+ :width: 800
+
+
+These performance charts use benchmarks that you can find in the `scikit-learn bench repository `_.
+
+
+Supported Algorithms
+---------------------
+
+See all of the :ref:`sklearn_algorithms`.
+
+
+Intel(R) Optimizations
+----------------------------------
+
+Enable Intel(R) CPU Optimizations
+*********************************
+
+::
+
+ import numpy as np
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+Enable Intel(R) GPU optimizations
+*********************************
+::
+
+ import numpy as np
+ import dpctl
+ from sklearnex import patch_sklearn, config_context
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ with config_context(target_offload="gpu:0"):
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+
+
+.. toctree::
+ :caption: Get Started
+ :hidden:
+ :maxdepth: 3
+
+ quick-start.rst
+ samples.rst
+ kaggle.rst
+
+.. toctree::
+ :caption: Developer Guide
+ :hidden:
+ :maxdepth: 2
+
+ algorithms.rst
+ oneAPI and GPU support
+ distributed-mode.rst
+ verbose.rst
+ deprecation.rst
+
+
+.. toctree::
+ :caption: Performance
+ :hidden:
+ :maxdepth: 2
+
+ guide/acceleration.rst
+
+.. toctree::
+ :caption: Learn
+ :hidden:
+ :maxdepth: 2
+
+ Tutorials & Case Studies
+ Medium Blogs
+
+.. toctree::
+ :caption: More
+ :hidden:
+ :maxdepth: 2
+
+ Support
+ contribute.rst
+ license.rst
diff --git a/2024.6/_sources/kaggle.rst.txt b/2024.6/_sources/kaggle.rst.txt
new file mode 100644
index 0000000000..364ab723d1
--- /dev/null
+++ b/2024.6/_sources/kaggle.rst.txt
@@ -0,0 +1,49 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _kaggle:
+
+####################
+Kaggle Kernels
+####################
+
+See Kaggle notebooks created by |intelex| developers.
+
+Acceleration
+---------------------------------
+
+`Introduction to scikit-learn-intelex `_
+provides a summary of the speedup you can achieve with |intelex|.
+
+Machine Learning Workflows
+---------------------------------
+
+Browse this chapter to find Kaggle kernels that use scikit-learn-intelex for a specific type of a machine learning task.
+
+Kaggle kernels that use scikit-learn and |intelex|:
+******************************************************************
+
+.. toctree::
+
+ Classification Tasks
+ Regression Tasks
+
+Kaggle kernels that use AutoML with |intelex|:
+******************************************************************
+
+.. toctree::
+
+ AutoML Workflows
diff --git a/2024.6/_sources/kaggle/automl.rst.txt b/2024.6/_sources/kaggle/automl.rst.txt
new file mode 100644
index 0000000000..0156e5ec89
--- /dev/null
+++ b/2024.6/_sources/kaggle/automl.rst.txt
@@ -0,0 +1,66 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |automl_with_intelex_jun| replace:: AutoML MultiClass Classification (Gradient Boosting, Random Forest, kNN) using AutoGluon with |intelex|
+.. _automl_with_intelex_jun: https://www.kaggle.com/alex97andreev/tps-jun-autogluon-with-sklearnex
+
+.. |automl_with_intelex_tps_oct| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest) using AutoGluon with |intelex|
+.. _automl_with_intelex_tps_oct: https://www.kaggle.com/lordozvlad/fast-automl-with-intel-extension-for-scikit-learn/notebook
+
+.. |automl_with_intelex_tps_nov| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest, kNN) using EvalML and AutoGluon with |intelex|
+.. _automl_with_intelex_tps_nov: https://www.kaggle.com/lordozvlad/tps-nov-automl-with-intel-extension
+
+.. |automl_with_intelex_titanic| replace:: AutoML Binary Classification (Gradient Boosting, Random Forest, kNN) using AutoGluon with |intelex|
+.. _automl_with_intelex_titanic: https://www.kaggle.com/lordozvlad/titanic-automl-with-intel-extension-for-sklearn/notebook
+
+.. |automl_with_intelex_tps_jan| replace:: AutoML Binary Classification (Random Forest, SVR, Blending) using PyCaret with |intelex|
+.. _automl_with_intelex_tps_jan: https://www.kaggle.com/code/lordozvlad/tps-jan-fast-pycaret-with-scikit-learn-intelex/notebook
+
+
+Kaggle Kernels that use AutoML and |intelex|
+--------------------------------------------
+
+The following Kaggle kernels show how to patch autoML frameworks with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 40 20
+
+ * - Kernel
+ - Goal
+ * - |automl_with_intelex_jun|_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ * - |automl_with_intelex_titanic|_
+
+ **Data:** Titanic datset
+ - Predict whether a passenger survivies
+ * - |automl_with_intelex_tps_oct|_
+
+ **Data:** [TPS Oct 2021] Synthetic molecular response data
+ - Predict the biological response of molecules given various chemical properties
+ * - |automl_with_intelex_tps_nov|_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+ - Identify spam emails via features extracted from the email
+ * - |automl_with_intelex_tps_jan|_
+
+ **Data:** [TPS Jan 2022] Fictional Sales data
+ - Predict the corresponding item sales for each date-country-store-item combination
\ No newline at end of file
diff --git a/2024.6/_sources/kaggle/classification.rst.txt b/2024.6/_sources/kaggle/classification.rst.txt
new file mode 100644
index 0000000000..5d7b94345f
--- /dev/null
+++ b/2024.6/_sources/kaggle/classification.rst.txt
@@ -0,0 +1,244 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+Kaggle Kernels for Classification Tasks
+***************************************
+
+The following Kaggle kernels show how to patch scikit-learn with |intelex| for various classification tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+Binary Classification
++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Logistic Regression for Binary Classification
+ `_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+
+ - Identify spam emails via features extracted from the email
+ -
+
+ - data preprocessing (normalization)
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Feature Importance in Random Forest for Binary Classification
+ `_
+
+ **Data:** [TPS Nov 2021] Synthetic spam emails data
+
+ - Identify spam emails via features extracted from the email
+ -
+
+ - reducing DataFrame memory usage
+ - computing feature importance with ELI5 and the default scikit-learn permutation importance
+ - training using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - feature construction
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) with Feature Preprocessing for Binary Classification
+ `_
+
+ **Data:** [TPS Apr 2021] Synthetic data based on Titanic dataset
+ - Predict whether a passenger survivies
+ -
+
+ - data preprocessing
+ - feature engineering
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+MultiClass Classification
++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Logistic Regression for MultiClass Classification with Quantile Transformer
+ `_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+
+ - data preprocessing with Quantile Transformer
+ - training and prediction using scikit-learn-intelex
+ - search for optimal paramters using Optuna
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for MultiClass Classification
+ `_
+
+ **Data:** [TPS May 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+
+ * - `Stacking Classifer with Logistic Regression, kNN, Random Forest, and Quantile Transformer
+ `_
+
+ **Data:** [TPS Jun 2021] Synthetic eCommerce data
+ - Predict the category of an eCommerce product
+ -
+
+ - data preprocessing: one-hot encoding, dimensionality reduction with PCA, normalization
+ - creating a stacking classifier with logistic regression, kNN, and random forest,
+ and a pipeline of Quantile Transformer and another logistic regression as a final estimator
+ - searching for optimal parameters for the stacking classifier
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for MultiClass Classification
+ `_
+
+ **Data:** [TPS Dec 2021] Synthetic Forest Cover Type data
+ - Predict the forest cover type
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Feature Importance in Random Forest for MultiClass Classification
+ `_
+
+ **Data:** [TPS Dec 2021] Synthetic Forest Cover Type data
+
+ - Predict the forest cover type
+ -
+
+ - reducing DataFrame memory usage
+ - computing feature importance with ELI5
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `k-Nearest Neighbors (kNN) for MultiClass Classification
+ `_
+
+ **Data:** [TPS Feb 2022] Bacteria DNA
+ - Predict bacteria species based on repeated lossy measurements of DNA snippets
+ -
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Classification Tasks in Computer Vision
++++++++++++++++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Support Vector Classification (SVC) for MultiClass Classification (CV task)
+ `_
+
+ **Data:** Digit Recognizer (MNIST)
+ - Recognize hand-written digits
+ -
+
+ - data preprocessing
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `k-Nearest Neighbors (kNN) for MultiClass Classification (CV task)
+ `_
+
+ **Data:** Digit Recognizer (MNIST)
+ - Recognize hand-written digits
+ -
+
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Classification Tasks in Natural Language Processing
++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Support Vector Classification (SVC) for a Binary Classification (NLP task)
+ `_
+
+ **Data:** Natural Language Processing with Disaster Tweets
+ - Predict which tweets are about real disasters and which ones are not
+ -
+
+ - data preprocessing
+ - TF-IDF calculation
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `One-vs-Rest Support Vector Machine (SVM) with Text Data for MultiClass Classification
+ `_
+
+ **Data:** What's Cooking
+ - Use recipe ingredients to predict the cuisine
+ -
+
+ - feature extraction using TfidfVectorizer
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Support Vector Classification (SVC) for Binary Classification with Sparse Data (NLP task)
+ `_
+
+ **Data:** Stack Overflow questions
+ - Predict the binary quality rating for Stack Overflow questions
+ -
+
+ - data preprocessing
+ - TF-IDF calculation
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
diff --git a/2024.6/_sources/kaggle/regression.rst.txt b/2024.6/_sources/kaggle/regression.rst.txt
new file mode 100644
index 0000000000..abdbebc15b
--- /dev/null
+++ b/2024.6/_sources/kaggle/regression.rst.txt
@@ -0,0 +1,156 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+Kaggle Kernels for Regression Tasks
+************************************
+
+The following Kaggle kernels show how to patch scikit-learn with |intelex| for various regression tasks.
+These kernels usually include a performance comparison between stock scikit-learn and scikit-learn patched with |intelex|.
+
+.. include:: /kaggle/note-about-tps.rst
+
+Using a Single Regressor
+++++++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Baseline Nu Support Vector Regression (nuSVR) with RBF Kernel
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - data preprocessing
+ - search for optimal paramters using Optuna
+ - training and prediction using scikit-learn-intelex
+ * - `Nu Support Vector Regression (nuSVR)
+ `__
+
+ **Data:** [TPS Aug 2021] Synthetic loan data
+ - Calculate loss associated with a loan defaults
+ -
+
+ - data preprocessing
+ - feature engineering
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Nu Support Vector Regression (nuSVR)
+ `__
+
+ **Data:** House Prices dataset
+ - Predict sale prices for a property based on its characteristics
+ -
+
+ - data preprocessing
+ - exploring outliers
+ - feature engineering
+ - filling missing values
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest Regression
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - checking correlation between features
+ - search for best paramters using GridSearchCV
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Random Forest Regression with Feature Engineering
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - data preprocessing
+ - feature engineering
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Random Forest Regression with Feature Importance Computation
+ `_
+
+ **Data:** [TPS Mar 2022] Spatio-temporal traffic data
+ - Forecast twelve-hours of traffic flow in a major U.S. metropolitan area
+ -
+
+ - feature engineering
+ - computing feature importance with ELI5
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+ * - `Ridge Regression
+ `_
+
+
+ **Data:** [TPS Sep 2021] Synthetic insurance data
+ - Predict the probability of a customer making a claim upon an insurance policy
+ -
+
+ - data preprocessing
+ - filling missing values
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+Stacking Regressors
++++++++++++++++++++
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+ :widths: 30 20 30
+
+ * - Kernel
+ - Goal
+ - Content
+ * - `Stacking Regressor with Random Fores, SVR, and LASSO
+ `_
+
+ **Data:** [TPS Jul 2021] Synthetic pollution data
+ - Predict air pollution measurements over time based on weather and input values from multiple sensors
+ -
+
+ - feature engineering
+ - creating a stacking regressor
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
+
+ * - `Stacking Regressor with ElasticNet, LASSO, and Ridge Regression for Time-series data
+ `_
+
+ **Data:** Predict Future Sales dataset
+ - Predict total sales for every product and store in the next month based on daily sales data
+ -
+
+ - data preprocessing
+ - creating a stacking regressor
+ - search for optimal parameters using Optuna
+ - training and prediction using scikit-learn-intelex
+ - performance comparison to scikit-learn
diff --git a/2024.6/_sources/license.rst.txt b/2024.6/_sources/license.rst.txt
new file mode 100644
index 0000000000..df68abaea6
--- /dev/null
+++ b/2024.6/_sources/license.rst.txt
@@ -0,0 +1,23 @@
+.. ******************************************************************************
+.. * Copyright 2023 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _license:
+
+############################################
+License
+############################################
+
+License: https://github.com/intel/scikit-learn-intelex/blob/main/LICENSE
\ No newline at end of file
diff --git a/2024.6/_sources/oneapi-gpu.rst.txt b/2024.6/_sources/oneapi-gpu.rst.txt
new file mode 100644
index 0000000000..76a2a752f4
--- /dev/null
+++ b/2024.6/_sources/oneapi-gpu.rst.txt
@@ -0,0 +1,114 @@
+.. ******************************************************************************
+.. * Copyright 2020 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _oneapi_gpu:
+
+##############################################################
+oneAPI and GPU support in |intelex|
+##############################################################
+
+|intelex| supports oneAPI concepts, which
+means that algorithms can be executed on different devices: CPUs and GPUs.
+This is done via integration with
+`dpctl `_ package that
+implements core oneAPI concepts like queues and devices.
+
+Prerequisites
+-------------
+
+For execution on GPU, DPC++ compiler runtime and driver are required. Refer to `DPC++ system
+requirements `_ for details.
+
+DPC++ compiler runtime can be installed either from PyPI or Anaconda:
+
+- Install from PyPI::
+
+ pip install dpcpp-cpp-rt
+
+- Install from Anaconda::
+
+ conda install dpcpp_cpp_rt -c intel
+
+Device offloading
+-----------------
+
+|intelex| offers two options for running an algorithm on a
+specific device with the help of dpctl:
+
+- Pass input data as `dpctl.tensor.usm_ndarray `_ to the algorithm.
+
+ The computation will run on the device where the input data is
+ located, and the result will be returned as :code:`usm_ndarray` to the same
+ device.
+
+ .. note::
+ All the input data for an algorithm must reside on the same device.
+
+ .. warning::
+ The :code:`usm_ndarray` can only be consumed by the base methods
+ like :code:`fit`, :code:`predict`, and :code:`transform`.
+ Note that only the algorithms in |intelex| support
+ :code:`usm_ndarray`. The algorithms from the stock version of scikit-learn
+ do not support this feature.
+- Use global configurations of |intelex|\*:
+
+ 1. The :code:`target_offload` option can be used to set the device primarily
+ used to perform computations. Accepted data types are :code:`str` and
+ :code:`dpctl.SyclQueue`. If you pass a string to :code:`target_offload`,
+ it should either be ``"auto"``, which means that the execution
+ context is deduced from the location of input data, or a string
+ with SYCL* filter selector. The default value is ``"auto"``.
+
+ 2. The :code:`allow_fallback_to_host` option
+ is a Boolean flag. If set to :code:`True`, the computation is allowed
+ to fallback to the host device when a particular estimator does not support
+ the selected device. The default value is :code:`False`.
+
+These options can be set using :code:`sklearnex.set_config()` function or
+:code:`sklearnex.config_context`. To obtain the current values of these options,
+call :code:`sklearnex.get_config()`.
+
+.. note::
+ Functions :code:`set_config`, :code:`get_config` and :code:`config_context`
+ are always patched after the :code:`sklearnex.patch_sklearn()` call.
+
+.. rubric:: Compatibility considerations
+
+For compatibility reasons, algorithms in |intelex| may be offloaded to the device using
+:code:`daal4py.oneapi.sycl_context`. However, it is recommended to use one of the options
+described above for device offloading instead of using :code:`sycl_context`.
+
+Example
+-------
+
+An example on how to patch your code with Intel CPU/GPU optimizations:
+
+.. code-block:: python
+
+ from sklearnex import patch_sklearn, config_context
+ patch_sklearn()
+
+ from sklearn.cluster import DBSCAN
+
+ X = np.array([[1., 2.], [2., 2.], [2., 3.],
+ [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
+ with config_context(target_offload="gpu:0"):
+ clustering = DBSCAN(eps=3, min_samples=2).fit(X)
+
+
+.. note:: Current offloading behavior restricts fitting and inference of any models to be
+ in the same context or absence of context. For example, a model trained in the GPU context with
+ target_offload="gpu:0" throws an error if the inference is made outside the same GPU context.
diff --git a/2024.6/_sources/quick-start.rst.txt b/2024.6/_sources/quick-start.rst.txt
new file mode 100644
index 0000000000..4a486e0b5a
--- /dev/null
+++ b/2024.6/_sources/quick-start.rst.txt
@@ -0,0 +1,417 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. |intelex_repo| replace:: |intelex| repository
+.. _intelex_repo: https://github.com/intel/scikit-learn-intelex
+
+####################
+Quick Start
+####################
+
+Get ready to elevate your scikit-learn code with |intelex| and experience the benefits of accelerated performance in just a few simple steps.
+
+Compatibility with Scikit-learn*
+---------------------------------
+
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn.
+
+Integrate |intelex|
+--------------------
+
+Patching
+**********************
+
+Once you install Intel*(R) Extension for Scikit-learn*, you replace algorithms that exist in the scikit-learn package with their optimized versions from the extension.
+This action is called ``patching``. This is not a permanent change so you can always undo the patching if necessary.
+
+To patch Intel® Extension for Scikit-learn, use one of these methods:
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Method
+ - Action
+ * - Use a flag in the command line
+ - Run this command:
+
+ ::
+
+ python -m sklearnex my_application.py
+ * - Modify your script
+ - Add the following lines:
+
+ ::
+
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+ * - Import an estimator from the ``sklearnex`` module
+ - Run this command:
+
+ ::
+
+ from sklearnex.neighbors import NearestNeighbors
+
+
+
+These patching methods are interchangeable.
+They support different enabling scenarios while producing the same result.
+
+
+**Example**
+
+This example shows how to patch Intel(R) extension for Scikit-Learn by modifing your script. To make sure that patching is registered by the scikit-learn estimators, always import scikit-learn after these lines.
+
+.. code-block:: python
+ :caption: Example: Drop-In Patching
+
+ import numpy as np
+ from sklearnex import patch_sklearn
+ patch_sklearn()
+
+ # You need to re-import scikit-learn algorithms after the patch
+ from sklearn.cluster import KMeans
+
+ # The use of the original Scikit-learn is not changed
+ X = np.array([[1, 2], [1, 4], [1, 0],
+ [10, 2], [10, 4], [10, 0]])
+ kmeans = KMeans(n_clusters=2, random_state=0).fit(X)
+ print(f"kmeans.labels_ = {kmeans.labels_}")
+
+
+Global Patching
+**********************
+
+You can also use global patching to patch all your scikit-learn applications without any additional actions.
+
+Before you begin, make sure that you have read and write permissions for Scikit-learn files.
+
+With global patching, you can:
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Task
+ - Action
+ - Note
+ * - Patch all supported algorithms
+ - Run this command:
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn
+
+ - If you run the global patching command several times with different parameters, then only the last configuration is applied.
+ * - Patch selected algorithms
+ - Use ``--algorithm`` or ``-a`` keys with a list of algorithms to patch. For example, to patch only ``SVC`` and ``RandomForestClassifier`` estimators, run
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier
+
+ -
+ * - Enable global patching via code
+ - Use the ``patch_sklearn`` function with the ``global_patch`` argument:
+
+ ::
+
+ from sklearnex import patch_sklearn
+ patch_sklearn(global_patch=True)
+ import sklearn
+
+ - After that, Scikit-learn patches is enabled in the current application and in all others that use the same environment.
+ * - Disable patching notifications
+ - Use ``--no-verbose`` or ``-nv`` keys:
+
+ ::
+
+ python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier -nv
+ -
+ * - Disable global patching
+ - Run this command:
+
+ ::
+
+ python -m sklearnex.glob unpatch_sklearn
+ -
+ * - Disable global patching via code
+ - Use the ``global_patch`` argument in the ``unpatch_sklearn`` function
+
+ ::
+
+ from sklearnex import unpatch_sklearn
+ unpatch_sklearn(global_patch=True)
+ -
+
+.. tip:: If you clone an environment with enabled global patching, it will already be applied in the new environment.
+
+Unpatching
+**********************
+
+To undo the patch (also called `unpatching`) is to return scikit-learn to original implementation and
+replace patched algorithms with the stock scikit-learn algorithms.
+
+To unpatch successfully, you must reimport the scikit-learn package::
+
+ sklearnex.unpatch_sklearn()
+ # Re-import scikit-learn algorithms after the unpatch
+ from sklearn.cluster import KMeans
+
+
+Installation
+--------------------
+
+.. contents:: :local:
+
+.. tip:: To prevent version conflicts, we recommend creating and activating a new environment for |intelex|.
+
+Install from PyPI
+**********************
+
+Recommended by default.
+
+To install |intelex|, run:
+
+::
+
+ pip install scikit-learn-intelex
+
+**Supported Configurations**
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ * - Windows* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+
+
+
+Install from Anaconda* Cloud
+********************************************
+
+To prevent version conflicts, we recommend installing `scikit-learn-intelex` into a new conda environment.
+
+.. tabs::
+
+ .. tab:: Conda-Forge channel
+
+ Recommended by default.
+
+ To install, run::
+
+ conda install scikit-learn-intelex -c conda-forge
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ * - Windows* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+
+
+ .. tab:: Intel channel
+
+ Recommended for the Intel® Distribution for Python users.
+
+ To install, run::
+
+ conda install scikit-learn-intelex -c intel
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ * - Windows* OS
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+ - [CPU, GPU]
+
+
+
+ .. tab:: Main channel
+
+ To install, run::
+
+ conda install scikit-learn-intelex
+
+ .. list-table:: **Supported Configurations**
+ :header-rows: 1
+ :align: left
+
+ * - OS / Python version
+ - Python 3.8
+ - Python 3.9
+ - Python 3.10
+ - Python 3.11
+ - Python 3.12
+ * - Linux* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ * - Windows* OS
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+ - [CPU]
+
+
+
+Build from Sources
+**********************
+
+See `Installation instructions `_ to build |intelex| from the sources.
+
+Install Intel*(R) AI Tools
+****************************
+
+Download the Intel AI Tools `here `_. The extension is already included.
+
+Release Notes
+-------------------
+
+See the `Release Notes `_ for each version of Intel® Extension for Scikit-learn*.
+
+System Requirements
+--------------------
+
+Hardware Requirements
+**********************
+
+.. tabs::
+
+ .. tab:: CPU
+
+ All processors with ``x86`` architecture with at least one of the following instruction sets:
+
+ - SSE2
+ - SSE4.2
+ - AVX2
+ - AVX512
+
+ .. note:: ARM* architecture is not supported.
+
+ .. tab:: GPU
+
+ - All Intel® integrated and discrete GPUs
+ - Intel® GPU drivers
+
+
+.. tip:: Intel(R) processors provide better performance than other CPUs. Read more about hardware comparison in our :ref:`blogs `.
+
+
+Software Requirements
+**********************
+
+.. tabs::
+
+ .. tab:: CPU
+
+ - Linux* OS: Ubuntu* 18.04 or newer
+ - Windows* OS 10 or newer
+ - Windows* Server 2019 or newer
+
+ .. tab:: GPU
+
+ - Linux* OS: Ubuntu* 18.04 or newer
+ - Windows* OS 10 or newer
+ - Windows* Server 2019 or newer
+
+ .. important::
+
+ If you use accelerators, refer to `oneAPI DPC++/C++ Compiler System Requirements `_.
+
+Intel(R) Extension for Scikit-learn is compatible with the last four versions of scikit-learn:
+
+* 1.0.X
+* 1.1.X
+* 1.2.X
+* 1.3.X
+
+Memory Requirements
+**********************
+By default, algorithms in |intelex| run in the multi-thread mode. This mode uses all available threads.
+Optimized scikit-learn algorithms can consume more RAM than their corresponding unoptimized versions.
+
+.. list-table::
+ :header-rows: 1
+ :align: left
+
+ * - Algorithm
+ - Single-thread mode
+ - Multi-thread mode
+ * - SVM
+ - Both Scikit-learn and |intelex| consume approximately the same amount of RAM.
+ - In |intelex|, an algorithm with ``N`` threads consumes ``N`` times more RAM.
+
+In all |intelex| algorithms with GPU support, computations run on device memory.
+The device memory must be large enough to store a copy of the entire dataset.
+You may also require additional device memory for internal arrays that are used in computation.
+
+
+.. seealso::
+
+ :ref:`Samples`
diff --git a/2024.6/_sources/samples.rst.txt b/2024.6/_sources/samples.rst.txt
new file mode 100644
index 0000000000..e616e8f2d9
--- /dev/null
+++ b/2024.6/_sources/samples.rst.txt
@@ -0,0 +1,68 @@
+.. ******************************************************************************
+.. * Copyright 2021 Intel Corporation
+.. *
+.. * Licensed under the Apache License, Version 2.0 (the "License");
+.. * you may not use this file except in compliance with the License.
+.. * You may obtain a copy of the License at
+.. *
+.. * http://www.apache.org/licenses/LICENSE-2.0
+.. *
+.. * Unless required by applicable law or agreed to in writing, software
+.. * distributed under the License is distributed on an "AS IS" BASIS,
+.. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+.. * See the License for the specific language governing permissions and
+.. * limitations under the License.
+.. *******************************************************************************/
+
+.. _samples:
+
+#######
+Samples
+#######
+
+The following samples are also provided as Jupyter notebooks in |intelex| repository.
+If you want to run them locally, refer to `these instructions
+`_.
+
+.. rubric:: Classification Tasks
+
+.. toctree::
+ :maxdepth: 1
+
+ k-Nearest Neighbors (kNN) for MNIST dataset
+ Logistic Regression for Cifar dataset
+ Support Vector Classification (SVC) for Adult dataset
+
+.. rubric:: Regression Tasks
+
+.. toctree::
+ :maxdepth: 1
+
+ ElasticNet for Airlines DepDelay dataset
+ Lasso Regression for YearPredictionMSD dataset
+ Linear Regression for YearPredictionMSD dataset
+ Nu-Support Vector Regression (NuSVR) for Medical Charges dataset
+ Random Forest for Yolanda dataset
+ Rigde Regression for Airlines DepDelay dataset