Repository: scikit-activeml/scikit-activeml (language: python)

Issue:
Getting started 



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index cede3b90..c98b57df 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -21,11 +21,6 @@ jobs:
       run: |
         sudo apt-get install pandoc
         python -m pip install --upgrade pip
-        pip install sphinx>=3.5.1
-        pip install sphinxcontrib-bibtex>=2.1.4
-        pip install numpydoc>=1.1.0
-        pip install nbsphinx>=0.8.2
-        pip install sphinx-rtd-theme>=0.5.1
         pip install -r requirements.txt
     - name: Lint with flake8
       run: |
@@ -45,5 +40,10 @@ jobs:
         fail_ci_if_error: true
     - name: Create documentation with sphinx
       run: |
-        cd docs
-        make html
+        pip install jupyter
+        pip install sphinx>=3.5.1
+        pip install sphinxcontrib-bibtex>=2.1.4
+        pip install numpydoc>=1.1.0
+        pip install nbsphinx>=0.8.2
+        pip install sphinx-rtd-theme>=0.5.1
+        sphinx-build -b html docs docs/_build
diff --git a/docs/index.rst b/docs/index.rst
index d6bb029d..544de612 100644
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -6,6 +6,7 @@ Contents:
 .. toctree::
    :maxdepth: 2
 
+   notebooks/getting_started
    developers_guide
    api/api
 
diff --git a/docs/notebooks/getting_started.ipynb b/docs/notebooks/getting_started.ipynb
new file mode 100644
index 00000000..cf45deca
--- /dev/null
+++ b/docs/notebooks/getting_started.ipynb
@@ -0,0 +1,257 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Getting Started"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The main purpose of this tutorial is to ease the implementation of our library `scikit-activeml` to new users. `scikit-activeml` is a library that executes the most important query strategies. It is built upon the well-known machine learning frame-work `scikit-learn`, which makes it user-friendly. For better understanding, we show an exemplary active learning cycle here. Let's start by importing the relevant packages from both `scikit-learn` and `scikit-activeml`. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.datasets import make_classification\n",
+    "\n",
+    "from skactiveml.classifier import SklearnClassifier\n",
+    "from skactiveml.pool import UncertaintySampling\n",
+    "from skactiveml.utils import is_unlabeled, is_labeled, MISSING_LABEL\n",
+    "from skactiveml.visualization import plot_decision_boundary, plot_utility\n",
+    "\n",
+    "import warnings\n",
+    "warnings.filterwarnings(\"ignore\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Data set Generation\n",
+    "We generate a data set of 100 data points with two clusters from the `make_classification` method of `scikit-learn`. This method also returns the true labels of each data point. In practice, however, we do not know these labels unless we ask an oracle. The labels are stored in `y_true`, which acts as an oracle."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "X, y_true = make_classification(n_features=2, n_redundant=0, random_state=0)\n",
+    "bound = [[min(X[:, 0]), min(X[:, 1])], [max(X[:, 0]), max(X[:, 1])]]\n",
+    "plt.scatter(X[:, 0], X[:, 1], c=y_true, cmap='jet')\n",
+    "plt.xlabel('Feature 1')\n",
+    "plt.ylabel('Feature 2')\n",
+    "plt.title('Data set');"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Classification\n",
+    "Our goal is to classify the data points into two classes. To do so, we introduce a vector `y` to store the labels that we acquire from the oracle (`y_true`). As shown below, the vector `y` is unlabeled at the beginning."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan nan\n",
+      " nan nan nan nan nan nan nan nan nan nan]\n"
+     ]
+    }
+   ],
+   "source": [
+    "y = np.full(shape=y_true.shape, fill_value=MISSING_LABEL)\n",
+    "print(y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "There are many easy-to-use classification algorithms in `scikit-learn`. In this example, we use the logistic regression classifier. Details of other classifiers can be accessed from here: https://scikit-activeml.readthedocs.io/en/latest/api/classifier.html. As `scikit-learn` classifiers cannot cope with missing labels, we need to wrap these with the `SklearnClassifier`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "clf = SklearnClassifier(LogisticRegression(), classes=np.unique(y_true))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Query Strategy\n",
+    "The query strategies are the central part of our library. In this example, we use uncertainty sampling with entropy to determine the most uncertain data points. All implemented strategies can be accessed from here: https://scikit-activeml.readthedocs.io/en/latest/api/pool.html."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "qs = UncertaintySampling(clf, method='entropy', random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Active Learning Cycle\n",
+    "In this example, we perform 20 iterations of the active learning cycle (`n_cycles=20`). In each iteration, we acquire one label (`batch_size=1`). The total number of labels to be acquired is `batch_size * n_cycles`. \n",
+    "Inside the loop, we first get the indices of the unlabeled instances. In the first iteration, `unlbld_idx` contains all indices because all data points are unlabeled. Next, we use the unlabeled indices to create the list `X_cand` of candidate instances that can still be queried and ask the query strategy to give us the indices of the most informative data points in `X_cand`. The `query` method returns the indices of the best `batch_size` instances together with the corresponding instances. In our case, the output is just a single index, as `batch_size=1`.\n",
+    "\n",
+    "Finally, we ask the oracle for the true label of the selected data point and store it in `y` to train our classifier. We continue until we reach the 20 labeled data points. \n",
+    "Below, we see the implementation of an active learning cycle. The first figure shows the decision boundary after acquiring the label of two data points. The second figure shows the decision boundary with 10 acquired labels, which shows significant improvement compared to the first figure. The last figure shows the decision boundary after acquiring labels for 20 data points. Finally, we use the accuracy score as a performance measure, which shows the accuracy of our classifier in the specified iterations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "pycharm": {
+     "name": "#%%\n"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After 2 iterations:\n",
+      "The accuracy score is 0.5.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAD4CAYAAADxeG0DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZkUlEQVR4nO3df4xc1XUH8O/Z9dqswZUxBrz+gU2AuEsWG8suVZyqITIQqyF10wqJpEoEVLKoQkrUVmmKJWgbIaUlilLoD7CKnUZykoIIBcUgr/kVihzwb8eLFwNx2XqxwbUtY9Nd78/TP2bH3p19M/PevPve/fG+H2kl7+x45szs7Hn3nnvefaKqICIifzXZDoCIiNJhIici8hwTORGR55jIiYg8x0ROROS5KTae9OJLLtZ5V7TZeGoiIq+c/PDUuX+fOnUKfX19UnkfK4l83hVteOKlH9t4aiIir2ze2Im+M/0AgMceeyzyPiytEBE5rGNlO5qnNNe8j5URORERxbNw8QIAQNe27qr3ERtndnYsu1ZZWqGi6Tl4GF3butF3ph/TZ7SiY2X7uT9Sojg+NWvZLlVdUXk7R+REOeg5eBi7XtyHkeERAEDfmX7senEfADCZU2qskRPloGtb97kkXjYyPFJzukwUFxM5UQ7KXQdxbydKgomcKAfTZ7Qmup0oCSZyohxEtZA1T2lGx8p2SxFRSLjYSZSD8S1k7Foh05jIiXKycPECJm7KBEsrRESeYyInIvIcEzkRkedYI6cg8PR3KjImcvIeT3+nomNphbzH09+p6DgiJ++FdPp7qCWiUF+XK1KPyEVkgYi8LCIHRORNEbnXRGBEcYVy+nu5RFQ+AJVLRD0HD1uOLJ1QX5dLTIzIhwH8haruFpEZAHaJyFZVPWDgscmA0EdDHSvbJ9TIAT9Pf69VIvL59xXq63JJ6kSuqkcBHB379xkR6QYwDwATuQOKsBAYyunvIZWIxgv1dbnEaI1cRBYBWAbgjYifrQWwFgDa5reZfFqqoSijoRBOf58+ozUyuflWIqoU6utyibFELiIXAXgKwDdV9XTlz1V1PYD1QOlSb6ael2rjaMgfLpaITJTlXHxdoTGSyEWkBaUkvklVf2biMcmMrEZDodfdbXCtRGSqLOfa6wpR6kQuIgLgcQDdqvr99CGRSXFGQ0mTchHq7ra4VCIyWZZz6XWFyMSI/DMAvgpgv4jsHbvtPlV9zsBjU0r1RkP1knJUki9K3b3oWJbzh4muldcAiIFYKCO1RkP1zorcuXUPRkdLSxp9Z/onfF+Jf+BhiVuWY5nNPp6iX3C1Rl17f7F/UtKulsQBdiGEJs7l6XiyjxuYyAuu1lmRg2eHqv4/Xn8yfAsXL8DyVUvPfUamz2jF8lVLJ4y2uc+NG7jXSsHVWgzdvmV31f+3fNVSTqcLoN4iJevobmAiL7hai6F7XtmPoYHJo/KWaS3sQiAAPNnHFUzkVDUpL7vxOuzo3APV83VxEcGyG6/LMzxyGE/2cQMTOVXFEzmoHn5G3MBETjWxhOIe19r9+Bmxj4mcyCM8q5aisP2QyCNs96MoHJETeSTUdj/XykW+4YicyCOhXNZuPJ4dmh5H5AXFEZCfQmz34yZs6TGRFxAXzPwVYrtfqOWiPDGRF1CWIyCO9LMXWrsfzw5Nj4m8gLIaAeU10ufBIiwhlovyxsXOgB3p7cOeN07i9EcT90vJasEsj9Y4LoyFJ84ui1QbR+QB+vj0EP78rh3Yue0EWlqaMDQ0iju+fjW+cd9vQkTQsbI9cg+VtCOgPGqdXBgLU2jlorwxkQdo3T17sOO1ExgcHMXA2VEAwI/+9df4xCcvwq23lf5YRIBxeRwiwPEjJ1KVLPKodXJhjGgyllYCc+b0EF7t/BCDg6MTbu/vG8GGh98FUBrVRl3559D+nlQlizhXlEkrxD5qorSYyANz5qMhNDVHX0L15IlBAPFHr0nr23nUOvM4WBD5hqWVwMyZ14rpF03B2f6JdeSmZuDTn50NoHoJJErSkkXWtc4Q+6iJ0mIiD0xTk+D+7y3Bt+/ejYGzI1AFWloErRdOwTfuK41ao9q9qnGxZGH6YMF2RvIdE7knkiSbm784F5fPbcWGR95B73t9+K3PzMYdX78Kl88tJeWoUe2cRZehp7s3k15elxMlz3KlEDCRe6CRZLNk+cX4wQ9vqPqYUaPa2XMvMZ5wXU+UbGekEDCReyCvZJNFfdv1RMl2RgqBka4VEdkgIsdEpMvE49FEPicb12NnOyOFwFT74Q8BrDb0WFTB52TjeuxsZ6QQGEnkqvoqgJMmHosm8znZuB479/mgEORWIxeRtQDWAkDb/La8njYINnun03ac+ND3zX0+yHcyfuOkVA8ksgjAz1W1o959O5Zdq0+89GMjz0vZqew4AUqjaY5Yiez41Kxlu1R1ReXt7FopmCQjbNc7ToiohIm8QJL2dLvecUJEJabaD38C4JcAFotIr4j8iYnHJbOSXvjB9Y4TIioxMiJX1S+beBzKVtIRNi/BReQHllYKJOmFH3zoOCEiJvKgVS5sNrIx1vjWvPLjbd+y21pSd3kDLiJbeGGJQEVdpLinuxcL2+dj6gUt5+7X1BzvI+DCRY9diIHIRUzkgaq2sNn7zhGMDJ+/DNzQwFCsZJh0oTQLLsRA5CIm8kBVW8AcPDvUUDJ0oRXRhRiIXMREHqikLYL1kqELrYguxEDkIibyQFXbrKplWkvk/eslQxc2v3IhBiIXsWslUNUu59b7zpFJ942TDPNoRazXkeJ6OyQ7asgWY5tmJcFNs/IXtQEWALRMa8GyG6+znnB836DL9/jJD9w0KzBJR39RHR8A0DJ1ihOJxvcNunyPn/zGRO6hRi5o7HrHR634nnz4GedLFa6/vxQ2JnID8q6NNjL6m3pBCwbPDkXevnljp/W6brXtA8riHKyyVuv3nHT7AyKT2LWSko2zDZOO/noOHsbQwPCk20UEQwPDTpwpGdWRUsnmyT/1fs8dK9vR1CQT/k9Tk7CjhnLBEXlKNmqjSUd/Xdu6EbWoHXXbyPAIdnTuyX0/lcqOlGpslSri/J4r304LfQRBY1dQdUzkKdmojSbdXjZpLOUE33emHzu37sGeV/ZjaGAo8z+e8Rt0lcs9lWyVKur9nqMOlqrKxU5DGlkXKhKWVlKycbZh0iu/V4tFRCJvH290VDE0UKqt51l6ce3kn3q/Zy52Zov77NTGEXlKti6+kOTK79ViXNg+f9K2tvXk1VLn2sk/9X7PXOzMFg+UtTGRp+RawolSK8bZcy85d7uIRNbNK+X1x5PkYJW1er9nXk0pWzxQ1sZEboBLCaeaajFWXjgi6uzPSkX946n1e/bhgO4zHihrYyKncyqT0dQLWjA0MDxhlM4/nup8OKD7igfK2pjIaYLKZFSt5YutYJQ3HiirYyKnmqL+eNgKRuQWth9SYmwFI3ILEzklxlYwIrewtEKJ5dEKxho8UXwckVNiWZ91aWMjMiKfGRmRi8hqAP8IoBnAv6nqd008Lrkp61Ywly7SwJkB+SB1IheRZgD/DOBmAL0AdojIs6p6IO1jU+OyTkBZtoK5UoNndw75wsSI/AYA76rqIQAQkZ8CWAOAidwSUwnI1mg06xp83Nfl0syAqBYTiXwegPHFy14Av115JxFZC2AtALTNbzPwtFSNiQRkczSa5enYUa9r+5bdOH7kBJZ/7voJ93VlZlA0LGcll9tip6quV9UVqrpi1uyZeT1tIZlIQDZ7xZNu05tEtYtQH9rfM2kx1cYWxUXHhe7GmBiRvw9g/F/Y/LHbyBITpQnbo9GsavC14q+csXCjpvyxnNUYE4l8B4BrRORKlBL47QC+YuBxqUFRCQgA5iy6LPZjhLptaK2LPFfe7ttGTSGUJGwPIHyVOpGr6rCI3ANgC0rthxtU9c3UkVHDFi5egONHTuDQ/p4Jt/d092L23Eti/XGHOhrtWNmO7Vt2R/4s6iBlcmaQZaLNY00jjwNFqAOIrBmpkavqc6r6SVW9SlUfNPGYlM4H7x2bdFuSGneWdWqbFi5egE9ct3DS7VkfpLKu/Wa9ppFX7dq1S/z5gqfoB8rEFDWrOrXtEsDyz10/4cpIecSQde0365JEXrVr38pZrmAiD1StWvDmjZ1V/ziyTrKunGST997WWSfarEsSedauue94ctxrJVBRU9SyatPiPKbPrm2B23PwMDZv7MSTDz+DzRs7M2tzy7qVMeuSBFsx3ebliNz21Nwl1d6LyilqpahpcR7TZ5Mju7SfgzxnB1kvHmddkgh18TsU3iVyV6bmLqj3XpS/nnz4mcj/X5k885g+myoBmPgc5NmznEftN8uSBGvXbvMukfOEgfPivhdx6+V5tH6ZGtmZ+Bzk3bPse+23XvycKdvjXSLnCQPnxX0vqp0gVL5veSSbx/TZ1MjOxOcg757lkBMdZ8p2eZfIecLAeXHfi7j18i/cecuE+2WVbEyMTNN8DsYn1EpZ1X1DT3ScKdvlXSI3MWoMZWSU5L2IWy/3Zfrf6OegMqGOl+VnIfREx5myXd4l8rRT85BGRo28F6HMaBr9HFTb/RBApgf00BNdKJ8rX3mXyIF0o8bQRkZJ34uQ2sga+Rwk2f3QpNATXUifKx8V7oSg0EdG9YS6h0pctRJnlp+B0PcQKfrnyjYvR+RphD4yisN0HdynNYekux+aUoQ+bF/WV0JUuETOKaBZvq05VNviN4/PABMdZaVwibwII6M8+bjmkNfuhz7NVMhvhUvkAEdGJvm65pD1Z8C3mQr5rXCLnWQWd8WL5toujxS2Qo7IQ+DKtJ1rDtF8namQn5jIPeTStL38fHte2Y+hgSEAQPMUTvTidke5ckAmvzGRe8jFBcbRkdFz/x48O1T4enCcmUojB2QmforCRO6hvKft9ZJHtQPL9i270bWtu5DJJk53VNIDskszMXILE7mH8jypKU7yqHUAKXKyqdcZk/SAnNdMjKN+/zCReyjPBcY4yaPWhSui7p9WKIkm6QE5j5kYR/1+4qqUh/Lc1yJO8qh1oed6j5NUHheIzkvS/VfyaPVk26SfOCL3VF4nNcUZNda7cEXl/dNwcaG3UUnPMq52pac5iy4zFhPbJv2UKpGLyG0A/gZAO4AbVHWniaDIHXHLOOUDS9SFG0yWfUJLNEkOyNX2ienp7gUAfPDesdTlJm4q56e0pZUuAH8I4FUDsZCDkpZxsi77FP1M0g/eOzbptpHhERza32Ok3BT6druhSjUiV9VuABARM9FQw7JcAExaxsmy7FP0M0njzjwaLTdxUzk/5VYjF5G1ANYCQNv8tryethCK1GlQ9ERTr0NovEbLTdxUzj91E7mIvABgTsSP1qlq9JV8I6jqegDrAaBj2bUaO0Kqy+YC4OmPhvDo9w5iy38eQctUwW1fW4Sv/ulVmDo1u4aoIieaagueURopN4XS2lk0dRO5qt6URyDUOFsLgIMDI/jKza+i93/6MDRYOkX/X/7hIHZsO45H/+PTmT53UUXNSOYsugw93b2py01FmtmFhu2HAbDVadD57BF8eLT/XBIHgLP9I9jx2gkc2HcK1y6dmenzF1XUjMTEhTJCau0smrTth18C8AiASwFsFpG9qvp5I5FRbLYWAHf98iT6/m/yFF+h+MXzh/Dfu49zip4TE+Wm0Fo7iyRt18rTAJ42FAs1yNYC4IIrp2PaBU0YODs64fYmAT46+j76ppduD3GKHmItmT3k/rJSWjn54Sls3tgZxIffFTYWANfcfgUefehtDOB8Im9qFkydOopFiybet3KK7nMiDLWWXPTWTp9Z22vF5z0yqOSSS6dhwzMrsejqCzF1WhNapjZhyfKZuPMOoDli65XyaM/3/VJC3Y8kzz18yCyri51cSMlOXiPejmUXY/P2m3DsaD+mtDRh1uxp2Lyxs+YU3fdFNRO1ZFdnJEVu7fSZ9d0PuZBino0R72VtrZg1exqA+qd5+76olnabAN9nJOQe64mcCynm2Z7615ui+75fStr9SGz/fig8VksrXEjJRpoRr6kpf60puu+Lamm7hHyfkZB7rCVyl+qCoWm0jSyvbowQ9ktJU0tmmx+ZZiWRz7p8Jr5w5y02nroQGh3x5rkIWeRFNd9nJOQenqIfoEZHvJzy5yOEGQm5hYk8UI2MeDnlz0+RZyRknvWuFXIHrw5D5CeOyOkcTvmJ/MREHoOrZ+FlgVN+Iv8wkdcR6gZJ5IYiDRIoO0zkdfi+Lwi5y7VBAg8q/uJiZx1syaOsuHSqPvd/8RsTeR2+7wtC7nJpkODSQYWSYyKvgy15lBWXBgkuHVQoOdbI62BLHmXFpVP1eTJYOrbXF5jIY2BLHmXBpUGCSwcV37iwaM1ETmSRK4MElw4qvnGhs42JnIgAuHNQ8Y0L6wtc7CQiSsGFRWsmciKiFFzobGNphYgoBRfWF1IlchF5CMAXAQwC+DWAO1X1lIG4iJxju8WM3GV7fSFtaWUrgA5VXQLgbQB/nT4kIvfwFHZyWapErqqdqjo89u3rAOanD4nIPTyFnVxmcrHzLgDPV/uhiKwVkZ0isvPk8VMGn5Yoey60mBFVUzeRi8gLItIV8bVm3H3WARgGsKna46jqelVdoaorZs2eaSR4ory40GJGVE3dxU5VvanWz0XkDgC3AlilqmooLiKn8BR2clnarpXVAL4F4LOq2mcmJCL3uNBiRlRN2j7yfwIwDcBWEQGA11X17tRRETnIdouZK9iG6Z5UiVxVrzYVCBG5z4Wd/mgynqJPRLGxDdNNTOREFBvbMN3ERE5EsbEN001M5EQUmws7/dFk3P2QiGJjG6abmMjJG2x7cwPbMN3DRE5eYNsbUXWskZMX2PZGVB0TOXmBbW9E1bG0Ql6YPqM1MmkXue2NawZUxhE5eYFtbxPxikU0HkfkBeXbaI5tbxPVWjMo6ntSZEzkBeRrBwjb3s7jmgGNx9JKAbEDxH88VZ7GYyIvII7m/Mc1AxqPpZUCYgeI/7hmQOMxkRcQrz8ZBq4ZUBkTeQFxNEcUFibyguJojigcXOwkIvIcEzkRkeeYyImIPMdETkTkOSZyIiLPMZETEXmOiZyIyHOpErmIfEdEfiUie0WkU0TmmgqMiIjiSTsif0hVl6jq9QB+DuD+9CEREVESqRK5qp4e9+2FADRdOERElFTqU/RF5EEAXwPwEYDP1bjfWgBrAaBtflvapyUiojF1R+Qi8oKIdEV8rQEAVV2nqgsAbAJwT7XHUdX1qrpCVVfMmj3T2AsgIiq6uiNyVb0p5mNtAvAcgAdSRURERImk7Vq5Zty3awC8lS4cIiJKKm2N/LsishjAKIAeAHenD4mIiJJIlchV9Y9MBUJERI3hmZ1ERJ5jIici8hwTORGR55jIiYg8x0ROROQ5JnIiIs8xkRMReY6JnIjIc0zkRESeYyInIvIcEzkRkedSX1iC4us5eBhd27rRd6Yf02e0omNlOxYuXmA7LCLyHBN5TnoOHsauF/dhZHgEANB3ph+7XtwHAEzmRJQKSys56drWfS6Jl40Mj6BrW7eliIgoFEzkOek705/odiKiuFhaycn0Ga2RSXv6jFYL0djFtQIiszgiz0nHynY0T2mecFvzlGZ0rGy3FJEd5bWC8kGtvFbQc/Cw5ciI/MVEnpOFixdg+aql50bg02e0YvmqpYUbiXKtgMg8UdX8n1Tkf1G6xmctswEczyGcrPgcf2axt7W1La/2s6NHj+4y9DR87+3wOXbAj/gXquqllTdaSeRxiMhOVV1hO45G+Ry/z7EDfsfP2O3xOX6WVoiIPMdETkTkOZcT+XrbAaTkc/w+xw74HT9jt8fb+J2tkRMRUTwuj8iJiCgGJnIiIs85nchF5Dsi8isR2SsinSIy13ZMSYjIQyLy1threFpEZtqOKS4RuU1E3hSRURHxoiVLRFaLyEEReVdEvm07niREZIOIHBORLtuxJCUiC0TkZRE5MPaZudd2THGJyAUisl1E9o3F/re2Y2qE0zVyEfkNVT099u8/A3Ctqt5tOazYROQWAC+p6rCI/D0AqOpfWQ4rFhFpBzAK4DEAf6mqOy2HVJOINAN4G8DNAHoB7ADwZVU9YDWwmETkdwF8DOBHqtphO54kRKQNQJuq7haRGQB2AfgDH957EREAF6rqxyLSAuA1APeq6uuWQ0vE6RF5OYmPuRCAu0edCKraqarDY9++DmC+zXiSUNVuVT1oO44EbgDwrqoeUtVBAD8FsMZyTLGp6qsATtqOoxGqelRVd4/9+wyAbgDz7EYVj5Z8PPZty9iXV3kGcDyRA4CIPCgihwH8MYD7bceTwl0AnrcdRMDmARi/81YvPEkmIRGRRQCWAXjDciixiUiziOwFcAzAVlX1JvYy64lcRF4Qka6IrzUAoKrrVHUBgE0A7rEb7WT14h+7zzoAwyi9BmfEiZ0oLhG5CMBTAL5ZMZt2mqqOqOr1KM2YbxARr0pbgAP7kavqTTHvugnAcwAeyDCcxOrFLyJ3ALgVwCp1bEEiwXvvg/cBjN9Kcv7YbZSDsfryUwA2qerPbMfTCFU9JSIvA1gNwKtFZ+sj8lpE5Jpx364B8JatWBohIqsBfAvA76tqn+14ArcDwDUicqWITAVwO4BnLcdUCGMLho8D6FbV79uOJwkRubTcTSYirSgtlnuVZwD3u1aeArAYpe6JHgB3q6o3oywReRfANAAnxm563ZeuGxH5EoBHAFwK4BSAvar6eatB1SEivwfgBwCaAWxQ1QftRhSfiPwEwI0obaX6IYAHVPVxq0HFJCK/A+C/AOxH6W8VAO5T1efsRRWPiCwB8O8ofWaaADyhqn9nN6rknE7kRERUn9OlFSIiqo+JnIjIc0zkRESeYyInIvIcEzkRkeeYyImIPMdETkTkuf8HjJXxPl9vSuwAAAAASUVORK5CYII=\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After 10 iterations:\n",
+      "The accuracy score is 0.93.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After 20 iterations:\n",
+      "The accuracy score is 0.94.\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": "<Figure size 432x288 with 1 Axes>",
+      "image/png": "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\n"
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "n_cycles = 20\n",
+    "y = np.full(shape=y_true.shape, fill_value=MISSING_LABEL)\n",
+    "for c in range(n_cycles):\n",
+    "    unlbld_idx = np.where(is_unlabeled(y))[0]\n",
+    "    query_idx = unlbld_idx[qs.query(X_cand=X[unlbld_idx], X=X, y=y, batch_size=1)]\n",
+    "    y[query_idx] = y_true[query_idx]\n",
+    "    clf.fit(X, y)\n",
+    "    \n",
+    "    # plotting\n",
+    "    unlbld_idx = np.where(is_unlabeled(y))[0]\n",
+    "    lbld_idx = np.where(is_labeled(y))[0]\n",
+    "    if len(lbld_idx) in [2, 10, 20]:\n",
+    "        print(f'After {len(lbld_idx)} iterations:')\n",
+    "        print(f'The accuracy score is {clf.score(X,y_true)}.')\n",
+    "        plot_utility(qs, {'X': X, 'y': y}, bound=bound)\n",
+    "        plot_decision_boundary(clf, bound)\n",
+    "        plt.scatter(X[unlbld_idx,0], X[unlbld_idx,1], c='gray')\n",
+    "        plt.scatter(X[:,0], X[:,1], c=y, cmap='jet')\n",
+    "        plt.show()\n"
+   ]
+  }
+ ],
+ "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.9.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
\ No newline at end of file
diff --git a/skactiveml/visualization/__init__.py b/skactiveml/visualization/__init__.py
new file mode 100644
index 00000000..8bd859ea
--- /dev/null
+++ b/skactiveml/visualization/__init__.py
@@ -0,0 +1,7 @@
+"""
+The :mod:`skactiveml.visualization` module includes various tools for
+visualization.
+"""
+from ._feature_space import plot_utility, plot_decision_boundary
+
+__all__ = ['plot_utility', 'plot_decision_boundary']
diff --git a/skactiveml/visualization/_feature_space.py b/skactiveml/visualization/_feature_space.py
new file mode 100644
index 00000000..ab7cae50
--- /dev/null
+++ b/skactiveml/visualization/_feature_space.py
@@ -0,0 +1,195 @@
+import warnings
+
+import numpy as np
+
+from matplotlib import pyplot as plt
+from matplotlib.axes import Axes
+from matplotlib.colors import Colormap
+from sklearn.base import ClassifierMixin
+from sklearn.neighbors import KNeighborsRegressor
+from sklearn.utils import check_array
+
+from ..base import QueryStrategy
+from ..utils import check_scalar
+
+
+def plot_decision_boundary(clf, feature_bound, ax=None, res=21,
+                           boundary_dict=None, confidence=0.75,
+                           cmap='coolwarm_r', confidence_dict=None):
+    """Plot the decision boundary of the given classifier.
+
+    Parameters
+    ----------
+    clf: Sklearn classifier
+        The fitted classifier whose decision boundary is plotted. If confidence
+        is not None, the classifier must implement the predict_proba function.
+    feature_bound: array-like, [[xmin, ymin], [xmax, ymax]]
+        Determines the area in which the boundary is plotted.
+    ax: matplotlib.axes.Axes, optional (default=None)
+        The axis on which the decision boundary is plotted.
+    res: int, optional (default=21)
+        The resolution of the plot.
+    boundary_dict: dict, optional (default=None)
+        Additional parameters for the boundary contour.
+    confidence: scalar | None, optional (default=0.5)
+        The confidence interval plotted with dashed lines. It is not plotted if
+        confidence is None. Must be in the open interval (0.5, 1). The value
+        stands for the ratio best class / second best class.
+    cmap: str | matplotlib.colors.Colormap, optional (default='coolwarm_r')
+        The colormap for the confidence levels.
+    confidence_dict: dict, optional (default=None)
+        Additional parameters for the confidence contour. Must not contain a
+        colormap because cmap is used.
+    """
+    if not isinstance(clf, ClassifierMixin):
+        raise TypeError("'clf' must be an Sklearn classifier.")
+    check_scalar(res, 'res', int, min_val=1)
+    if ax is None:
+        ax = plt.gca()
+    if not isinstance(ax, Axes):
+        raise TypeError("ax must be a matplotlib.axes.Axes.")
+    check_array(feature_bound)
+    xmin, ymin, xmax, ymax = np.ravel(feature_bound)
+
+    # Check and convert the colormap
+    if isinstance(cmap, str):
+        cmap = plt.cm.get_cmap(cmap)
+    if not isinstance(cmap, Colormap):
+        raise TypeError("'cmap' must be a string or a Colormap.")
+
+    if confidence is not None:
+        check_scalar(confidence, 'confidence', float, min_inclusive=False,
+                     max_inclusive=False, min_val=0.5, max_val=1)
+
+    # Update additional arguments
+    boundary_args = {'colors': 'k', 'linewidths': [2], 'zorder': 1}
+    if boundary_dict is not None:
+        if not isinstance(boundary_dict, dict):
+            raise TypeError("boundary_dict' must be a dictionary.")
+        boundary_args.update(boundary_dict)
+    confidence_args = {'linewidths': [2, 2], 'linestyles': '--', 'alpha': 0.9,
+                       'vmin': 0.2, 'vmax': 0.8, 'zorder': 1}
+    if confidence_dict is not None:
+        if not isinstance(confidence_dict, dict):
+            raise TypeError("confidence_dict' must be a dictionary.")
+        confidence_args.update(confidence_dict)
+
+    # Create mesh for plotting
+    x_vec = np.linspace(xmin, xmax, res)
+    y_vec = np.linspace(ymin, ymax, res)
+    X_mesh, Y_mesh = np.meshgrid(x_vec, y_vec)
+    mesh_instances = np.array([X_mesh.reshape(-1), Y_mesh.reshape(-1)]).T
+
+    # Calculate predictions
+    if hasattr(clf, 'predict_proba'):
+        predictions = clf.predict_proba(mesh_instances)
+        classes = np.array(range(predictions.shape[1]))
+    elif hasattr(clf, 'predict'):
+        if confidence is not None:
+            warnings.warn("The given classifier does not implement "
+                          "'predict_proba'. Thus, the confidence cannot be "
+                          "plotted.")
+            confidence = None
+        predicted_classes = clf.predict(mesh_instances)
+        classes = np.array(range(len(np.unique(predicted_classes))))
+        predictions = np.zeros((len(predicted_classes), len(classes)))
+        for idx, y in enumerate(predicted_classes):
+            predictions[idx, y] = 1
+    else:
+        raise AttributeError("'clf' must implement 'predict' or "
+                             "'predict_proba'")
+
+    posterior_list = []
+
+    for y in classes:
+        posteriors = predictions[:, y].reshape(X_mesh.shape)
+        posterior_list.append(posteriors)
+
+    norm = plt.Normalize(vmin=min(classes), vmax=max(classes))
+
+    for y in classes:
+        posteriors = posterior_list[y]
+        posteriors_best_alternative = np.zeros_like(posteriors)
+        for y2 in np.setdiff1d(classes, [y]):
+            posteriors_best_alternative = np.max([posteriors_best_alternative,
+                                                  posterior_list[y2]], axis=0)
+
+        posteriors = posteriors / (posteriors + posteriors_best_alternative)
+        ax.contour(X_mesh, Y_mesh, posteriors, [.5], **boundary_args)
+        if confidence is not None:
+            ax.contour(X_mesh, Y_mesh, posteriors, [confidence],
+                       colors=[cmap(norm(y))], **confidence_args)
+
+
+def plot_utility(qs, qs_dict, X_cand=None, feature_bound=None, ax=None, res=21,
+                 contour_dict=None):
+    """ Plot the utility for the given query strategy.
+
+    Parameters
+    ----------
+    qs: QueryStrategy
+        The query strategy for which the utility is plotted.
+    qs_dict: dict
+        Dictionary with the parameters for the qs.query method.
+    X_cand: array-like, shape(n_candidates, n_features)
+        Unlabeled candidate instances. If X_cand is given, the utility is
+        calculated only for these instances and is interpolated. Otherwise, the
+        utility is calculated for every point in the given area.
+    feature_bound: array-like, [[xmin, ymin], [xmax, ymax]]
+        Determines the area in which the boundary is plotted. If X_cand is not
+        given, bound must not be None. Otherwise, the bound is determined based
+        on the data.
+    ax: matplotlib.axes.Axes, optional (default=None)
+        The axis on which the boundary is plotted.
+    res: int, optional (default=21)
+        The resolution of the plot.
+    contour_dict: dict, optional (default=None)
+        Additional parameters for the utility contour.
+    """
+    if not isinstance(qs, QueryStrategy):
+        raise TypeError("'qs' must be a query strategy.")
+    if not isinstance(qs_dict, dict):
+        raise TypeError("'qs_dict' must be a dictionary.")
+    if 'X_cand' in qs_dict.keys():
+        raise ValueError("'X_cand' must be given as separate argument.")
+
+    if feature_bound is not None:
+        check_array(feature_bound)
+        xmin, ymin, xmax, ymax = np.ravel(feature_bound)
+    elif X_cand is not None:
+        xmin = min(X_cand[:, 0])
+        xmax = max(X_cand[:, 0])
+        ymin = min(X_cand[:, 1])
+        ymax = max(X_cand[:, 1])
+    else:
+        raise ValueError("If 'X_cand' is None, 'bound' must be given.")
+
+    if ax is None:
+        ax = plt.gca()
+    if not isinstance(ax, Axes):
+        raise TypeError("ax must be a matplotlib.axes.Axes.")
+    check_scalar(res, 'res', int, min_val=1)
+
+    x_vec = np.linspace(xmin, xmax, res)
+    y_vec = np.linspace(ymin, ymax, res)
+    X_mesh, Y_mesh = np.meshgrid(x_vec, y_vec)
+    mesh_instances = np.array([X_mesh.reshape(-1), Y_mesh.reshape(-1)]).T
+
+    contour_args = {'cmap': 'Greens', 'alpha': 0.75}
+    if contour_dict is not None:
+        if not isinstance(contour_dict, dict):
+            raise TypeError("contour_dict' must be a dictionary.")
+        contour_args.update(contour_dict)
+
+    if X_cand is None:
+        _, utilities = qs.query(mesh_instances, **qs_dict,
+                                return_utilities=True)
+        utilities = utilities.reshape(X_mesh.shape)
+        ax.contourf(X_mesh, Y_mesh, utilities, **contour_args)
+    else:
+        _, utilities = qs.query(X_cand, **qs_dict, return_utilities=True)
+        utilities = utilities.reshape(-1)
+        neighbors = KNeighborsRegressor(n_neighbors=1)
+        neighbors.fit(X_cand, utilities)
+        scores = neighbors.predict(mesh_instances).reshape(X_mesh.shape)
+        ax.contourf(X_mesh, Y_mesh, scores, **contour_args)


Test patch:
diff --git a/skactiveml/visualization/tests/__init__.py b/skactiveml/visualization/tests/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/skactiveml/visualization/tests/images/dec_bound_multiclass_base.pdf b/skactiveml/visualization/tests/images/dec_bound_multiclass_base.pdf
new file mode 100644
index 00000000..5b7b5547
Binary files /dev/null and b/skactiveml/visualization/tests/images/dec_bound_multiclass_base.pdf differ
diff --git a/skactiveml/visualization/tests/images/dec_bound_svc_base.pdf b/skactiveml/visualization/tests/images/dec_bound_svc_base.pdf
new file mode 100644
index 00000000..e6c82648
Binary files /dev/null and b/skactiveml/visualization/tests/images/dec_bound_svc_base.pdf differ
diff --git a/skactiveml/visualization/tests/images/dec_bound_w_cand_base.pdf b/skactiveml/visualization/tests/images/dec_bound_w_cand_base.pdf
new file mode 100644
index 00000000..e188d998
Binary files /dev/null and b/skactiveml/visualization/tests/images/dec_bound_w_cand_base.pdf differ
diff --git a/skactiveml/visualization/tests/images/dec_bound_wo_cand_base.pdf b/skactiveml/visualization/tests/images/dec_bound_wo_cand_base.pdf
new file mode 100644
index 00000000..f238043f
Binary files /dev/null and b/skactiveml/visualization/tests/images/dec_bound_wo_cand_base.pdf differ
diff --git a/skactiveml/visualization/tests/test_feature_space.py b/skactiveml/visualization/tests/test_feature_space.py
new file mode 100644
index 00000000..3b4ff01d
--- /dev/null
+++ b/skactiveml/visualization/tests/test_feature_space.py
@@ -0,0 +1,210 @@
+import unittest
+import numpy as np
+import os
+
+from matplotlib import pyplot as plt
+from matplotlib import testing
+from matplotlib.testing.compare import compare_images
+from sklearn.base import ClassifierMixin
+from sklearn.datasets import make_classification
+from sklearn.svm import LinearSVC
+
+from skactiveml.classifier import PWC
+from skactiveml import visualization
+from skactiveml.pool import UncertaintySampling
+from skactiveml.visualization._feature_space import plot_decision_boundary, \
+    plot_utility
+
+
+class TestFeatureSpace(unittest.TestCase):
+
+    def setUp(self):
+        self.path_prefix = os.path.dirname(visualization.__file__) + \
+                           '/tests/images/'
+        np.random.seed(0)
+        self.X, self.y = make_classification(n_features=2, n_redundant=0,
+                                             random_state=0)
+        train_indices = np.random.randint(0, len(self.X), size=20)
+        cand_indices = np.setdiff1d(np.arange(len(self.X)), train_indices)
+        self.X_train = self.X[train_indices]
+        self.y_train = self.y[train_indices]
+        self.X_cand = self.X[cand_indices]
+        self.clf = PWC()
+        self.clf.fit(self.X_train, self.y_train)
+        self.qs = UncertaintySampling()
+        self.qs_dict = {'clf': self.clf, 'X': self.X_train, 'y': self.y_train}
+
+        x1_min = min(self.X[:, 0])
+        x1_max = max(self.X[:, 0])
+        x2_min = min(self.X[:, 1])
+        x2_max = max(self.X[:, 1])
+        self.bound = [[x1_min, x2_min], [x1_max, x2_max]]
+
+        self.cmap = 'jet'
+
+        testing.set_font_settings_for_testing()
+        testing.set_reproducibility_for_testing()
+        testing.setup()
+
+    # Tests for plot_decision_boundary function
+    def test_decision_boundary_clf(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.qs,
+                          feature_bound=self.bound)
+        clf = TestClassifier()
+        self.assertRaises(AttributeError, plot_decision_boundary, clf=clf,
+                          feature_bound=self.bound)
+
+    def test_decision_boundary_bound(self):
+        self.assertRaises(ValueError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=[0, 0, 1, 1])
+
+    def test_decision_boundary_res(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, res='string')
+
+    def test_decision_boundary_ax(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, ax=3)
+
+    def test_decision_boundary_confidence(self):
+        self.assertRaises(ValueError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, confidence=0.0)
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, confidence='string')
+        plot_decision_boundary(self.clf, self.bound, confidence=None)
+        svc = LinearSVC()
+        svc.fit(self.X_train, self.y_train)
+        self.assertWarns(Warning, plot_decision_boundary, clf=svc,
+                         feature_bound=self.bound, confidence=0.75)
+
+    def test_decision_boundary_cmap(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, cmap=4)
+
+    def test_decision_boundary_boundary_dict(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, boundary_dict='string')
+        plot_decision_boundary(clf=self.clf, feature_bound=self.bound,
+                               boundary_dict={'colors': 'r'})
+
+    def test_decision_boundary_confidence_dict(self):
+        self.assertRaises(TypeError, plot_decision_boundary, clf=self.clf,
+                          feature_bound=self.bound, confidence_dict='string')
+        plot_decision_boundary(clf=self.clf, feature_bound=self.bound,
+                               confidence_dict={'linestyles': ':'})
+
+    # Tests for plot_utility function
+    def test_utility_qs(self):
+        self.assertRaises(TypeError, plot_utility, qs=self.clf,
+                          qs_dict=self.qs_dict, feature_bound=self.bound)
+
+    def test_utility_qs_dict(self):
+        self.assertRaises(TypeError, plot_utility, qs=self.qs,
+                          qs_dict={0, 1, 2}, feature_bound=self.bound)
+
+        qs_dict = self.qs_dict
+        qs_dict['X_cand'] = []
+        self.assertRaises(ValueError, plot_utility, qs=self.qs,
+                          qs_dict=qs_dict, feature_bound=self.bound)
+
+    def test_utility_X_cand(self):
+        self.assertRaises(ValueError, plot_utility, qs=self.qs,
+                          qs_dict=self.qs_dict)
+
+    def test_utility_res(self):
+        self.assertRaises(ValueError, plot_utility, qs=self.qs,
+                          qs_dict=self.qs_dict, feature_bound=self.bound,
+                          res=-3)
+
+    def test_utility_ax(self):
+        self.assertRaises(TypeError, plot_utility, qs=self.qs,
+                          qs_dict=self.qs_dict, feature_bound=self.bound, ax=2)
+
+    def test_utility_contour_dict(self):
+        self.assertRaises(TypeError, plot_utility, qs=self.qs,
+                          qs_dict=self.qs_dict, feature_bound=self.bound,
+                          contour_dict='string')
+        plot_utility(qs=self.qs, qs_dict=self.qs_dict,
+                     feature_bound=self.bound,
+                     contour_dict={'linestyles': '.'})
+
+    # Graphical tests
+    def test_no_candidates(self):
+        fig, ax = plt.subplots()
+        plot_utility(self.qs, self.qs_dict, feature_bound=self.bound, ax=ax)
+        ax.scatter(self.X_cand[:, 0], self.X_cand[:, 1], c='k', marker='.')
+        ax.scatter(self.X_train[:, 0], self.X_train[:, 1], c=self.y_train,
+                   cmap=self.cmap, alpha=.9, marker='.')
+        plot_decision_boundary(self.clf, self.bound, ax=ax, cmap=self.cmap)
+
+        fig.savefig(self.path_prefix + 'dec_bound_wo_cand.pdf')
+        comparison = compare_images(self.path_prefix +
+                                    'dec_bound_wo_cand_base.pdf',
+                                    self.path_prefix + 'dec_bound_wo_cand.pdf',
+                                    tol=0)
+        self.assertIsNone(comparison)
+
+    def test_with_candidates(self):
+        fig, ax = plt.subplots()
+        plot_utility(self.qs, self.qs_dict, X_cand=self.X_cand, ax=ax)
+        ax.scatter(self.X[:, 0], self.X[:, 1], c='k', marker='.')
+        ax.scatter(self.X_train[:, 0], self.X_train[:, 1], c=self.y_train,
+                   cmap=self.cmap, alpha=.9, marker='.')
+        plot_decision_boundary(self.clf, self.bound, ax=ax, cmap=self.cmap)
+
+        fig.savefig(self.path_prefix + 'dec_bound_w_cand.pdf')
+        comparison = compare_images(self.path_prefix +
+                                    'dec_bound_w_cand_base.pdf',
+                                    self.path_prefix + 'dec_bound_w_cand.pdf',
+                                    tol=0)
+        self.assertIsNone(comparison)
+
+    def test_multi_class(self):
+        X, y = make_classification(n_features=2, n_redundant=0, random_state=0,
+                                   n_classes=3, n_clusters_per_class=1)
+        train_indices = np.random.randint(0, len(X), size=20)
+        cand_indices = np.setdiff1d(np.arange(len(X)), train_indices)
+        X_train = X[train_indices]
+        y_train = y[train_indices]
+        X_cand = X[cand_indices]
+        clf = PWC()
+        clf.fit(X_train, y_train)
+        qs = UncertaintySampling()
+        bound = [[min(X[:, 0]), min(X[:, 1])], [max(X[:, 0]), max(X[:, 1])]]
+
+        fig, ax = plt.subplots()
+        plot_utility(qs, {'clf': clf, 'X': X_train, 'y': y_train},
+                     feature_bound=bound, ax=ax)
+        ax.scatter(X_cand[:, 0], X_cand[:, 1], c='k', marker='.')
+        ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train,
+                   cmap=self.cmap, alpha=.9, marker='.')
+        plot_decision_boundary(clf, bound, ax=ax, res=101, cmap=self.cmap)
+        fig.savefig(self.path_prefix + 'dec_bound_multiclass.pdf')
+        comparison = compare_images(self.path_prefix +
+                                    'dec_bound_multiclass_base.pdf',
+                                    self.path_prefix +
+                                    'dec_bound_multiclass.pdf',
+                                    tol=0)
+        self.assertIsNone(comparison)
+
+    def test_svc(self):
+        svc = LinearSVC()
+        svc.fit(self.X_train, self.y_train)
+
+        fig, ax = plt.subplots()
+        plot_utility(self.qs, self.qs_dict, X_cand=self.X_cand, ax=ax)
+        ax.scatter(self.X[:, 0], self.X[:, 1], c='k', marker='.')
+        ax.scatter(self.X_train[:, 0], self.X_train[:, 1], c=self.y_train,
+                   cmap=self.cmap, alpha=.9, marker='.')
+        plot_decision_boundary(svc, self.bound, ax=ax, cmap=self.cmap)
+
+        fig.savefig(self.path_prefix + 'dec_bound_svc.pdf')
+        comparison = compare_images(self.path_prefix +
+                                    'dec_bound_svc_base.pdf',
+                                    self.path_prefix + 'dec_bound_svc.pdf',
+                                    tol=0)
+        self.assertIsNone(comparison)
+
+
+class TestClassifier(ClassifierMixin):
+    pass