{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to PyALAF\n",
    "PyALAF is developed to solve a large range of Active Learning problems by making use of so called acquisition functions. \n",
    "This enables to choose from a broad range of settings for running the Active Learning. PyALAF enables pool based learning as well as population based learning. It also allows to find several suggested data points in one iteration. \n",
    "By the choice of the acquisition function one can control whether the model function that approximates the true data is optimized only close to the maximum in order to find that maximum or whether the full model function is optimized. \n",
    "PyALAF is compatible with most of sklearns regression models and also can use linear regression models."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The usage of PyALAF is very simple. First, we need to import some libraries."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Disabled warnings\n",
      "Disabled warnings\n",
      "Disabled warnings\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from PyALAF.models import inv_sphere\n",
    "from PyALAF.multi_optimize import run_continuous_batch_learning_multi\n",
    "from PyALAF.aggregation_fn import identity_aggregation_fn as identity\n",
    "\n",
    "from sklearn.gaussian_process import GaussianProcessRegressor as GPR\n",
    "from sklearn.gaussian_process.kernels import RBF, WhiteKernel\n",
    "\n",
    "random_state=41"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we create some test data by first setting some parameters. For this basic example, we use only 1D data with a grid spacing of 100 data points in any dimension in the intervall [-2,2]. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape of the test pool:  (100, 1)\n"
     ]
    }
   ],
   "source": [
    "#Parameters for grid\n",
    "grid_size = 100     #Number of data points per dimension\n",
    "dimensions = 1      #Number of dimensions\n",
    "lim = [[-2,],[2,]]  #Bounds for each dimension. First lower bounds, than upper bounds\n",
    "\n",
    "#Create a grid for arbitrary number of dimensions\n",
    "x = []\n",
    "[x.append(np.linspace(lim[0][i],lim[1][i], grid_size )) for i in range(dimensions)]\n",
    "pool = np.meshgrid(*x)\n",
    "pool = np.array(pool).T\n",
    "test_pool = pool.reshape(grid_size**dimensions, dimensions)\n",
    "print('Shape of the test pool: ', test_pool.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we define a data_model. The data model represents the true underlying data in this case. We sample data from this model, where we can also decide that this data is noisy. Therefore, we set the noise parameter."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Data model\n",
    "data_model = inv_sphere(d=dimensions, random_state=random_state)\n",
    "noise = np.sqrt(1e-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we define a machine learning model that is used to approximate the true data. Here, we decide for a Gaussian Process Regression model with the standard RBF kernel and an additional WhiteKernel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "kernel = RBF(length_scale=0.1, length_scale_bounds=[0.05,10])+WhiteKernel()\n",
    "regression_model = GPR(kernel)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now, we are equipped with everything to start the actual active learning routine. But before we call this routine, we need to define some parameters. Most parameters have default values that you can look up in the documentation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "initial_samples=5  #Number of initial data points \n",
    "max_samples=30     #Number of data points that are maximally acquired \n",
    "batch_size=5        #Collect data points in batches of five before evaluating the model with a test data set\n",
    "n_repetitions=2     #Repeat the active learning two times\n",
    "  \n",
    "initialization_method = 'random'   #Algorithm to collect initial data\n",
    "optimization_method = 'PSO'        #Algorithm to search for the maximum of the acquisition function. Choose from 'PSO' or 'lbfgs'AttributeError\n",
    "n_jobs = 1                         #Number of jobs to start for parallel computing\n",
    "\n",
    "pso_options = {'c1': 0.5, 'c2': 0.3, 'w': 0.9, 'p':10*dimensions, 'i':50}  #Options for particle swarm optimization\n",
    "\n",
    "active_learning_steps = int((max_samples-initial_samples)/batch_size) #Number of AL steps is calculated automatically"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this example, we want to compare the performance of 4 different acquisition functions, which we define below. In the dictionary, we save the name of the acquisition function together with a hyperparameter alpha. This is only used for the 'ideal' algorithm here."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "acquisition_functions = {'random':[0], 'ideal': [10], 'std': [0], 'GSx':[0]} "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To save the results, we create a dictionary that contains an empty data frame for each acquisition function. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'random_0': Empty DataFrame\n",
       " Columns: []\n",
       " Index: [],\n",
       " 'ideal_10': Empty DataFrame\n",
       " Columns: []\n",
       " Index: [],\n",
       " 'std_0': Empty DataFrame\n",
       " Columns: []\n",
       " Index: [],\n",
       " 'GSx_0': Empty DataFrame\n",
       " Columns: []\n",
       " Index: []}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "score_dict = {}\n",
    "for acquisition_function, alpha_values in acquisition_functions.items():\n",
    "    for alpha in alpha_values:\n",
    "        key = acquisition_function+'_'+str(alpha)\n",
    "        score_dict[key] = pd.DataFrame()\n",
    "\n",
    "score_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No, we run the Active Learning algorithm. We repeat the AL experiment only two times here. However, you can increase n_repetitions to run several AL experiments with different random seeds. Statistics will get better for running the experiment more often. Thus, for getting meaningful results when comparing different algorithms, it is suggested to run the AL experiment several times. \n",
    "Note that in the final application the AL experiment is only run once and without testing the models.\n",
    "\n",
    "For running the Active Learning it is recommended to use either the ```run_continuous_batch_learning_multi``` or ```run_batch_learning_multi``` for the population-based or pool-based approach, respectively. Both functions allow in principle to combine multiple objectives via aggregation functions. However, since we are here interested only in a single objective, we chose the identiy aggregation function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2026-01-30 12:13:14,519 - basic_logger - INFO - Setting up Active Learning\n",
      "2026-01-30 12:13:14,521 - basic_logger - INFO - Noise converted: \n",
      "2026-01-30 12:13:14,522 - basic_logger - INFO - from 0.001 to [0.001]\n",
      "2026-01-30 12:13:14,523 - basic_logger - INFO - Test metrics will be calculated.\n",
      "2026-01-30 12:13:14,526 - basic_logger - INFO - Initialization method: random\n",
      "2026-01-30 12:13:14,527 - basic_logger - INFO - Initialization finished.\n",
      "2026-01-30 12:13:14,550 - basic_logger - INFO - Start Active Learning\n",
      "2026-01-30 12:13:14,553 - basic_logger - INFO - Optimization method: PSO\n",
      "2026-01-30 12:13:14,554 - basic_logger - INFO - Acquisition function: random\n",
      "2026-01-30 12:13:14,561 - basic_logger - INFO - Step 1\n",
      "2026-01-30 12:13:14,659 - basic_logger - INFO - Step 2\n",
      "2026-01-30 12:13:14,766 - basic_logger - INFO - Step 3\n",
      "2026-01-30 12:13:14,908 - basic_logger - INFO - Step 4\n",
      "2026-01-30 12:13:15,008 - basic_logger - INFO - Step 5\n",
      "2026-01-30 12:13:15,105 - basic_logger - INFO - Finished Active Learning\n",
      "2026-01-30 12:13:15,108 - basic_logger - INFO - Setting up Active Learning\n",
      "2026-01-30 12:13:15,110 - basic_logger - INFO - Noise converted: \n",
      "2026-01-30 12:13:15,111 - basic_logger - INFO - from 0.001 to [0.001]\n",
      "2026-01-30 12:13:15,111 - basic_logger - INFO - Test metrics will be calculated.\n",
      "2026-01-30 12:13:15,113 - basic_logger - INFO - Initialization method: random\n",
      "2026-01-30 12:13:15,114 - basic_logger - INFO - Initialization finished.\n",
      "2026-01-30 12:13:15,136 - basic_logger - INFO - Start Active Learning\n",
      "2026-01-30 12:13:15,137 - basic_logger - INFO - Optimization method: PSO\n",
      "2026-01-30 12:13:15,138 - basic_logger - INFO - Acquisition function: ideal\n",
      "2026-01-30 12:13:15,139 - basic_logger - INFO - Step 1\n"
     ]
    }
   ],
   "source": [
    "%%capture\n",
    "\n",
    "for i in range(n_repetitions):\n",
    "    random_state += 1\n",
    "    \n",
    "    for acquisition_function, alpha_values in acquisition_functions.items():\n",
    "        for alpha in alpha_values:\n",
    "            samples, values, result_dict = run_continuous_batch_learning_multi(\n",
    "            models = [data_model], \n",
    "            aggregation_function = identity,\n",
    "            regression_models = [regression_model],\n",
    "            acquisition_function = acquisition_function,\n",
    "            opt_method = optimization_method,\n",
    "            pool = test_pool, \n",
    "            batch_size=batch_size,\n",
    "            noise=noise,\n",
    "            initial_samples=initial_samples, \n",
    "            active_learning_steps=active_learning_steps,\n",
    "            lim_features=lim,\n",
    "            alpha=alpha,\n",
    "            n_jobs=n_jobs,\n",
    "            random_state=random_state,\n",
    "            calculate_test_metrics=True,\n",
    "            initialization=initialization_method,\n",
    "            pso_options=pso_options\n",
    "            )\n",
    "\n",
    "            result = result_dict['aggregated']\n",
    "            key = acquisition_function+'_'+str(alpha)\n",
    "            score_dict[key] = pd.concat([score_dict[key], result])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As an output we get the acquired data points in the order they were acquired and also the result data frame which we save. You can see how this data frame looks like below. The mean squared error (MSE) the maximum error (MaxE), the mean absolute error (MAE) and the maximum observed value are stored."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>mean_MSE_train</th>\n",
       "      <th>mean_MAE_train</th>\n",
       "      <th>mean_MaxE_train</th>\n",
       "      <th>mean_MSE_test</th>\n",
       "      <th>mean_MAE_test</th>\n",
       "      <th>mean_MaxE_test</th>\n",
       "      <th>max_observation</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>m</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>5.0</th>\n",
       "      <td>2.468643</td>\n",
       "      <td>1.190516</td>\n",
       "      <td>2.867850</td>\n",
       "      <td>1.649410</td>\n",
       "      <td>1.021930</td>\n",
       "      <td>3.051051</td>\n",
       "      <td>-0.038660</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10.0</th>\n",
       "      <td>0.000046</td>\n",
       "      <td>0.003899</td>\n",
       "      <td>0.010574</td>\n",
       "      <td>0.012076</td>\n",
       "      <td>0.064867</td>\n",
       "      <td>0.291011</td>\n",
       "      <td>-0.020379</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>15.0</th>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.001037</td>\n",
       "      <td>0.002343</td>\n",
       "      <td>0.003411</td>\n",
       "      <td>0.022224</td>\n",
       "      <td>0.164779</td>\n",
       "      <td>-0.020379</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20.0</th>\n",
       "      <td>0.000001</td>\n",
       "      <td>0.000910</td>\n",
       "      <td>0.001985</td>\n",
       "      <td>0.002405</td>\n",
       "      <td>0.017744</td>\n",
       "      <td>0.147543</td>\n",
       "      <td>-0.003877</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>25.0</th>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.001151</td>\n",
       "      <td>0.003629</td>\n",
       "      <td>0.000015</td>\n",
       "      <td>0.002096</td>\n",
       "      <td>0.021392</td>\n",
       "      <td>-0.003877</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>30.0</th>\n",
       "      <td>0.000002</td>\n",
       "      <td>0.001173</td>\n",
       "      <td>0.003828</td>\n",
       "      <td>0.000012</td>\n",
       "      <td>0.001913</td>\n",
       "      <td>0.019268</td>\n",
       "      <td>-0.003877</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "      mean_MSE_train  mean_MAE_train  mean_MaxE_train  mean_MSE_test  \\\n",
       "m                                                                      \n",
       "5.0         2.468643        1.190516         2.867850       1.649410   \n",
       "10.0        0.000046        0.003899         0.010574       0.012076   \n",
       "15.0        0.000002        0.001037         0.002343       0.003411   \n",
       "20.0        0.000001        0.000910         0.001985       0.002405   \n",
       "25.0        0.000002        0.001151         0.003629       0.000015   \n",
       "30.0        0.000002        0.001173         0.003828       0.000012   \n",
       "\n",
       "      mean_MAE_test  mean_MaxE_test  max_observation  \n",
       "m                                                     \n",
       "5.0        1.021930        3.051051        -0.038660  \n",
       "10.0       0.064867        0.291011        -0.020379  \n",
       "15.0       0.022224        0.164779        -0.020379  \n",
       "20.0       0.017744        0.147543        -0.003877  \n",
       "25.0       0.002096        0.021392        -0.003877  \n",
       "30.0       0.001913        0.019268        -0.003877  "
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ave_scores = score_dict['random_0'].groupby('m').mean()\n",
    "ave_scores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now for example compare the MSE of the 4 different acquisition functions. We observe that all 3 AL algorithms perform better than just randomly choosing data points."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Data points')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for key, df in score_dict.items():\n",
    "    ave_scores = df.groupby('m').mean()\n",
    "    plt.plot(ave_scores.index, ave_scores['mean_MSE_test'], 'o--', label=key)\n",
    "plt.legend()\n",
    "plt.yscale('log')\n",
    "plt.ylabel('MSE')\n",
    "plt.xlabel('Data points')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "LECA_dev",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}