diff --git a/2023.2/.buildinfo b/2023.2/.buildinfo
new file mode 100644
index 0000000000..a41243969f
--- /dev/null
+++ b/2023.2/.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: 6800a6ffac59c178770a0c0cc83712a8
+tags: 645f666f9bcd5a90fca523b33c5a78b7
diff --git a/2023.2/.doctrees/404.doctree b/2023.2/.doctrees/404.doctree
new file mode 100644
index 0000000000..4b1df81808
Binary files /dev/null and b/2023.2/.doctrees/404.doctree differ
diff --git a/2023.2/.doctrees/acceleration.doctree b/2023.2/.doctrees/acceleration.doctree
new file mode 100644
index 0000000000..163213c792
Binary files /dev/null and b/2023.2/.doctrees/acceleration.doctree differ
diff --git a/2023.2/.doctrees/algorithms.doctree b/2023.2/.doctrees/algorithms.doctree
new file mode 100644
index 0000000000..eefc4d9661
Binary files /dev/null and b/2023.2/.doctrees/algorithms.doctree differ
diff --git a/2023.2/.doctrees/blogs.doctree b/2023.2/.doctrees/blogs.doctree
new file mode 100644
index 0000000000..dd4eaf8039
Binary files /dev/null and b/2023.2/.doctrees/blogs.doctree differ
diff --git a/2023.2/.doctrees/contribute.doctree b/2023.2/.doctrees/contribute.doctree
new file mode 100644
index 0000000000..dce1438af1
Binary files /dev/null and b/2023.2/.doctrees/contribute.doctree differ
diff --git a/2023.2/.doctrees/distributed-mode.doctree b/2023.2/.doctrees/distributed-mode.doctree
new file mode 100644
index 0000000000..4191be22a4
Binary files /dev/null and b/2023.2/.doctrees/distributed-mode.doctree differ
diff --git a/2023.2/.doctrees/environment.pickle b/2023.2/.doctrees/environment.pickle
new file mode 100644
index 0000000000..83430f7389
Binary files /dev/null and b/2023.2/.doctrees/environment.pickle differ
diff --git a/2023.2/.doctrees/global-patching.doctree b/2023.2/.doctrees/global-patching.doctree
new file mode 100644
index 0000000000..8ca7293348
Binary files /dev/null and b/2023.2/.doctrees/global-patching.doctree differ
diff --git a/2023.2/.doctrees/guide/acceleration.doctree b/2023.2/.doctrees/guide/acceleration.doctree
new file mode 100644
index 0000000000..33e3f9d478
Binary files /dev/null and b/2023.2/.doctrees/guide/acceleration.doctree differ
diff --git a/2023.2/.doctrees/index.doctree b/2023.2/.doctrees/index.doctree
new file mode 100644
index 0000000000..fe88497b70
Binary files /dev/null and b/2023.2/.doctrees/index.doctree differ
diff --git a/2023.2/.doctrees/installation.doctree b/2023.2/.doctrees/installation.doctree
new file mode 100644
index 0000000000..e51e9002ad
Binary files /dev/null and b/2023.2/.doctrees/installation.doctree differ
diff --git a/2023.2/.doctrees/kaggle.doctree b/2023.2/.doctrees/kaggle.doctree
new file mode 100644
index 0000000000..b14befb14e
Binary files /dev/null and b/2023.2/.doctrees/kaggle.doctree differ
diff --git a/2023.2/.doctrees/kaggle/automl.doctree b/2023.2/.doctrees/kaggle/automl.doctree
new file mode 100644
index 0000000000..8a3b3fcd5d
Binary files /dev/null and b/2023.2/.doctrees/kaggle/automl.doctree differ
diff --git a/2023.2/.doctrees/kaggle/classification.doctree b/2023.2/.doctrees/kaggle/classification.doctree
new file mode 100644
index 0000000000..7146fd3b80
Binary files /dev/null and b/2023.2/.doctrees/kaggle/classification.doctree differ
diff --git a/2023.2/.doctrees/kaggle/regression.doctree b/2023.2/.doctrees/kaggle/regression.doctree
new file mode 100644
index 0000000000..7d0912d121
Binary files /dev/null and b/2023.2/.doctrees/kaggle/regression.doctree differ
diff --git a/2023.2/.doctrees/memory-requirements.doctree b/2023.2/.doctrees/memory-requirements.doctree
new file mode 100644
index 0000000000..e802368688
Binary files /dev/null and b/2023.2/.doctrees/memory-requirements.doctree differ
diff --git a/2023.2/.doctrees/nbsphinx/samples/ElasticNet.ipynb b/2023.2/.doctrees/nbsphinx/samples/ElasticNet.ipynb
new file mode 100644
index 0000000000..29e5dca851
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb b/2023.2/.doctrees/nbsphinx/samples/daal4py_data_science.ipynb
new file mode 100644
index 0000000000..9336772cb3
--- /dev/null
+++ b/2023.2/.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": "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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/2023.2/.doctrees/nbsphinx/samples/dbscan.ipynb b/2023.2/.doctrees/nbsphinx/samples/dbscan.ipynb
new file mode 100644
index 0000000000..d6e5c92653
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/kmeans.ipynb b/2023.2/.doctrees/nbsphinx/samples/kmeans.ipynb
new file mode 100644
index 0000000000..df09f8ded5
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/knn_mnist.ipynb b/2023.2/.doctrees/nbsphinx/samples/knn_mnist.ipynb
new file mode 100644
index 0000000000..b8604d70f0
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/lasso_regression.ipynb b/2023.2/.doctrees/nbsphinx/samples/lasso_regression.ipynb
new file mode 100644
index 0000000000..967d0d4e54
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/linear_regression.ipynb b/2023.2/.doctrees/nbsphinx/samples/linear_regression.ipynb
new file mode 100644
index 0000000000..508ee06d8c
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb b/2023.2/.doctrees/nbsphinx/samples/logistictic_regression_cifar.ipynb
new file mode 100644
index 0000000000..43727804d7
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb b/2023.2/.doctrees/nbsphinx/samples/nusvr_medical_charges.ipynb
new file mode 100644
index 0000000000..8c72c1b71d
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb b/2023.2/.doctrees/nbsphinx/samples/random_forest_yolanda.ipynb
new file mode 100644
index 0000000000..276284ed9b
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/ridge_regression.ipynb b/2023.2/.doctrees/nbsphinx/samples/ridge_regression.ipynb
new file mode 100644
index 0000000000..1c159a13ae
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/svc_adult.ipynb b/2023.2/.doctrees/nbsphinx/samples/svc_adult.ipynb
new file mode 100644
index 0000000000..9e49bcfecd
--- /dev/null
+++ b/2023.2/.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/2023.2/.doctrees/nbsphinx/samples/tsne.ipynb b/2023.2/.doctrees/nbsphinx/samples/tsne.ipynb
new file mode 100644
index 0000000000..99ad8fcefd
--- /dev/null
+++ b/2023.2/.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": "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/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png
new file mode 100644
index 0000000000..6c7d082563
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_24_0.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png
new file mode 100644
index 0000000000..cc9df20282
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_0.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png
new file mode 100644
index 0000000000..5e5d8b1d1a
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_1.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png
new file mode 100644
index 0000000000..e79ca5011f
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_2.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png
new file mode 100644
index 0000000000..b7c37519c2
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_3.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png
new file mode 100644
index 0000000000..87ce1f07e7
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_4.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png
new file mode 100644
index 0000000000..0a059e8d7f
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_daal4py_data_science_7_5.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_tsne_15_0.png b/2023.2/.doctrees/nbsphinx/samples_tsne_15_0.png
new file mode 100644
index 0000000000..5a1138f6bc
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_tsne_15_0.png differ
diff --git a/2023.2/.doctrees/nbsphinx/samples_tsne_15_1.png b/2023.2/.doctrees/nbsphinx/samples_tsne_15_1.png
new file mode 100644
index 0000000000..49b9be9ae0
Binary files /dev/null and b/2023.2/.doctrees/nbsphinx/samples_tsne_15_1.png differ
diff --git a/2023.2/.doctrees/oneapi-gpu.doctree b/2023.2/.doctrees/oneapi-gpu.doctree
new file mode 100644
index 0000000000..4bd48cfe68
Binary files /dev/null and b/2023.2/.doctrees/oneapi-gpu.doctree differ
diff --git a/2023.2/.doctrees/quick-start.doctree b/2023.2/.doctrees/quick-start.doctree
new file mode 100644
index 0000000000..5b9576b904
Binary files /dev/null and b/2023.2/.doctrees/quick-start.doctree differ
diff --git a/2023.2/.doctrees/samples.doctree b/2023.2/.doctrees/samples.doctree
new file mode 100644
index 0000000000..43b6ad5c7f
Binary files /dev/null and b/2023.2/.doctrees/samples.doctree differ
diff --git a/2023.2/.doctrees/samples/ElasticNet.doctree b/2023.2/.doctrees/samples/ElasticNet.doctree
new file mode 100644
index 0000000000..35d385a0a1
Binary files /dev/null and b/2023.2/.doctrees/samples/ElasticNet.doctree differ
diff --git a/2023.2/.doctrees/samples/daal4py_data_science.doctree b/2023.2/.doctrees/samples/daal4py_data_science.doctree
new file mode 100644
index 0000000000..09a4c48947
Binary files /dev/null and b/2023.2/.doctrees/samples/daal4py_data_science.doctree differ
diff --git a/2023.2/.doctrees/samples/dbscan.doctree b/2023.2/.doctrees/samples/dbscan.doctree
new file mode 100644
index 0000000000..e28baa2e14
Binary files /dev/null and b/2023.2/.doctrees/samples/dbscan.doctree differ
diff --git a/2023.2/.doctrees/samples/kmeans.doctree b/2023.2/.doctrees/samples/kmeans.doctree
new file mode 100644
index 0000000000..3e537dc53c
Binary files /dev/null and b/2023.2/.doctrees/samples/kmeans.doctree differ
diff --git a/2023.2/.doctrees/samples/knn_mnist.doctree b/2023.2/.doctrees/samples/knn_mnist.doctree
new file mode 100644
index 0000000000..ab5294ead3
Binary files /dev/null and b/2023.2/.doctrees/samples/knn_mnist.doctree differ
diff --git a/2023.2/.doctrees/samples/lasso_regression.doctree b/2023.2/.doctrees/samples/lasso_regression.doctree
new file mode 100644
index 0000000000..a964237c2d
Binary files /dev/null and b/2023.2/.doctrees/samples/lasso_regression.doctree differ
diff --git a/2023.2/.doctrees/samples/linear_regression.doctree b/2023.2/.doctrees/samples/linear_regression.doctree
new file mode 100644
index 0000000000..e97b9174a5
Binary files /dev/null and b/2023.2/.doctrees/samples/linear_regression.doctree differ
diff --git a/2023.2/.doctrees/samples/logistictic_regression_cifar.doctree b/2023.2/.doctrees/samples/logistictic_regression_cifar.doctree
new file mode 100644
index 0000000000..bd8477f82e
Binary files /dev/null and b/2023.2/.doctrees/samples/logistictic_regression_cifar.doctree differ
diff --git a/2023.2/.doctrees/samples/nusvr_medical_charges.doctree b/2023.2/.doctrees/samples/nusvr_medical_charges.doctree
new file mode 100644
index 0000000000..4cacb1651a
Binary files /dev/null and b/2023.2/.doctrees/samples/nusvr_medical_charges.doctree differ
diff --git a/2023.2/.doctrees/samples/random_forest_yolanda.doctree b/2023.2/.doctrees/samples/random_forest_yolanda.doctree
new file mode 100644
index 0000000000..ddb199ccd4
Binary files /dev/null and b/2023.2/.doctrees/samples/random_forest_yolanda.doctree differ
diff --git a/2023.2/.doctrees/samples/ridge_regression.doctree b/2023.2/.doctrees/samples/ridge_regression.doctree
new file mode 100644
index 0000000000..a69fe0f98a
Binary files /dev/null and b/2023.2/.doctrees/samples/ridge_regression.doctree differ
diff --git a/2023.2/.doctrees/samples/svc_adult.doctree b/2023.2/.doctrees/samples/svc_adult.doctree
new file mode 100644
index 0000000000..3a1179726a
Binary files /dev/null and b/2023.2/.doctrees/samples/svc_adult.doctree differ
diff --git a/2023.2/.doctrees/samples/tsne.doctree b/2023.2/.doctrees/samples/tsne.doctree
new file mode 100644
index 0000000000..0593fc9945
Binary files /dev/null and b/2023.2/.doctrees/samples/tsne.doctree differ
diff --git a/2023.2/.doctrees/support.doctree b/2023.2/.doctrees/support.doctree
new file mode 100644
index 0000000000..7423be5d2e
Binary files /dev/null and b/2023.2/.doctrees/support.doctree differ
diff --git a/2023.2/.doctrees/system-requirements.doctree b/2023.2/.doctrees/system-requirements.doctree
new file mode 100644
index 0000000000..35f77751c6
Binary files /dev/null and b/2023.2/.doctrees/system-requirements.doctree differ
diff --git a/2023.2/.doctrees/verbose.doctree b/2023.2/.doctrees/verbose.doctree
new file mode 100644
index 0000000000..0de9443fc5
Binary files /dev/null and b/2023.2/.doctrees/verbose.doctree differ
diff --git a/2023.2/.doctrees/what-is-patching.doctree b/2023.2/.doctrees/what-is-patching.doctree
new file mode 100644
index 0000000000..3614b0516a
Binary files /dev/null and b/2023.2/.doctrees/what-is-patching.doctree differ
diff --git a/2023.2/.nojekyll b/2023.2/.nojekyll
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/2023.2/404.html b/2023.2/404.html
index 8395fa5de2..f1296f725f 100644
--- a/2023.2/404.html
+++ b/2023.2/404.html
@@ -1,28 +1,32 @@
+
+
-
+
Page not found — Intel(R) Extension for Scikit-learn* 2023.2 documentation
-
-
-
-
-
-
+
+
+
+
+
-
-
-
-
+
+
+
+
+
+
+
+
+
+ Choose version
+
+
+
+
+
+
+ About
-Features
-
-Releases
-
-Installation Guide
-
-Examples
+Get Started
-Performance
+Developer Guide
-Blogs & Publications
-
-How to contribute
+Community
-License
-
+
@@ -151,19 +160,7 @@ Page not found