diff --git a/.gitignore b/.gitignore
index 60815f0ac234a1d61e057dd64005ec9dc43d85aa..3c7da3c3c6416a8b8023ee2a81d58202ed15c00b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,2 @@
 .ipynb_checkpoints/
-venv*
+.*venv*
diff --git a/01_introduction.ipynb b/01_introduction.ipynb
index 6c7a65188ca264b94ba1bfd9a66bed16b94b7334..98806b8dfe9e1022c56ac215351dbb94515fdd9d 100644
--- a/01_introduction.ipynb
+++ b/01_introduction.ipynb
@@ -21,7 +21,7 @@
     "   1. Where will my car at given velocity stop when I break now ?\n",
     "   2. Where on the night sky will I see the moon tonight ?\n",
     "   2. Is the email I received spam ? \n",
-    "   4. What article X should I recommend to my customers Y ?\n",
+    "   4. Which article X should I recommend to a customer Y ?\n",
     "   \n",
     "- The first two questions can be answered based on existing physical models (formulas). \n",
     "\n",
@@ -38,13 +38,17 @@
     "\n",
     "E.g. for the spamming example:\n",
     "\n",
-    "- We have no explicit formula for such a task\n",
-    "- We have a vague understanding of the problem domeani, because we know that some words are specific for spam emails, other words are specific for my personal and job emails.\n",
+    "- We have no explicit formula for such a task (and devising one would boil down to lots of trial with different statistics or scores and possibly weighting of them).\n",
+    "- We have a vague understanding of the problem domain, because we know that some words are specific for spam emails, other words are specific for my personal and job emails.\n",
     "- My mailbox is full with examples for spam vs non-spam.\n",
     "\n",
     "\n",
     "**In such cases machine learning offers approaches to build models based on example data.**\n",
     "\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<i class=\"fa fa-info-circle\"></i>\n",
+    "The closely-related concept of <b>data mining</b> usually means use of predictive machine learning models to explicitly discover previously unknown knowledge from a specific data set, such as, for instance, association rules between customer and article types in the Problem 4 above.\n",
+    "</div>\n",
     "\n",
     "\n",
     "\n",
@@ -69,16 +73,19 @@
     "\n",
     "Some parts of ML are older than you might think. This is a rough time line with a few selected achievements from this field:\n",
     "\n",
-    " \n",
-    "    1812: Bayes Theorem\n",
+    "    1805: Least squares regression\n",
+    "    1812: Bayes' rule\n",
     "    1913: Markov Chains\n",
+    "\n",
     "    1951: First neural network\n",
-    "    1959: first use or term \"machine learning\" AI pioneer Arthur Samuel\n",
+    "    1957-65: \"k-means\" clustering algorithm\n",
+    "    1959: Term \"machine learning\" is coined by Arthur Samuel, an AI pioneer\n",
     "    1969: Book \"Perceptrons\": Limitations of Neural Networks\n",
-    "    1986: Backpropagation to learn neural networks\n",
-    "    1995: Randomized Forests and Support Vector Machines\n",
-    "    1998: Public appearance of ML: naive Bayes Classifier for Spam detection\n",
-    "    2000+: Deep learning\n",
+    "    1984: Book \"Classification And Regression Trees\"\n",
+    "    1974-86: Neural networks learning breakthrough: backpropagation method\n",
+    "    1995: Randomized Forests and Support Vector Machines methods\n",
+    "    1998: Public appearance: first ML implementations of spam filtering methods; naive Bayes Classifier method\n",
+    "    2006-12: Neural networks learning breakthrough: deep learning\n",
     "    \n",
     "So the field is not as new as one might think, but due to \n",
     "\n",
@@ -111,7 +118,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## ML terms: What are \"features\" ?\n",
+    "## ML lingo: What are \"features\" ?\n",
     "\n",
     "A typical and very common situation is that our data is presented as a table, as in the following example:"
    ]
@@ -219,12 +226,16 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "\n",
-    "**Definitions**:\n",
-    "- every row of such a matrix is called a **sample** or **feature vector**. \n",
-    "\n",
-    "- the cells in a row are **feature values**.\n",
-    "- every column name is called a **feature name** or **attribute**."
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<i class=\"fa fa-warning\"></i>&nbsp;<strong>Definitions</strong>\n",
+    "<ul>\n",
+    "    <li>every row of such a matrix is called a <strong>sample</strong> or <strong>feature vector</strong>;</li>\n",
+    "    <li>the cells in a row are <strong>feature values</strong>;</li>\n",
+    "    <li>every column name is called a <strong>feature name</strong> or <strong>attribute</strong>.</li>\n",
+    "</ul>\n",
+    "\n",
+    "Features are also commonly called <strong>variables</strong>.\n",
+    "</div>"
    ]
   },
   {
@@ -233,18 +244,14 @@
    "source": [
     "This table shown holds five samples.\n",
     "\n",
-    "The feature names are `alcohol_content`, `bitterness`, `darkness`, `fruitiness` and `is_yummy`."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "(Almost) all machine learning algorithms require that your data is numerical and/or categorial. In some applications it is not obvious how to transform data to a numerical presentation.\n",
-    "\n",
-    "**Definition**:\n",
+    "The feature names are `alcohol_content`, `bitterness`, `darkness`, `fruitiness` and `is_yummy`.\n",
     "\n",
-    "*Categorical data*: data which has only a limited set of allowed values. A `taste` feature could only allow values `sour`, `bitter`, `sweet`, `salty`."
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<i class=\"fa fa-warning\"></i>&nbsp;<strong>More definitions</strong>\n",
+    "<ul>\n",
+    "    <li>The first four features have continuous numerical values within some ranges - these are called <strong>numerical features</strong>,</li>\n",
+    "    <li>the <code>is_yummy</code> feature has only a finite set of values (\"categories\"): <code>0</code> (\"no\") and <code>1</code> (\"yes\") - this is called a <strong>categorical feature</strong>.</li>\n",
+    "</ul>\n"
    ]
   },
   {
@@ -253,14 +260,25 @@
    "source": [
     "A straight-forward application for machine-learning on the previos beer dataset is: **\"can we predict `is_yummy` from the other features\"** ?\n",
     "\n",
-    "In this case we would call the features `alcohol_content`, `bitterness`, `darkness`, `fruitiness` our **input features** and `is_yummy` our **target value**."
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<i class=\"fa fa-warning\"></i>&nbsp;<strong>Even more definitions</strong>\n",
+    "\n",
+    "In context of the question above we call:\n",
+    "<ul>\n",
+    "    <li>the <code>alcohol_content</code>, <code>bitterness</code>, <code>darkness</code>, <code>fruitiness</code> features our <strong>input features</strong>, and</li>\n",
+    "    <li>the <code>is_yummy</code> feature our <strong>target/output feature</strong> or a <strong>label</strong> of our data samples.\n",
+    "        <ul>\n",
+    "            <li>Values of categorical labels, such as <code>0</code> (\"no\") and <code>1</code> (\"yes\") here, are often called <strong>classes</strong>.</li>\n",
+    "        </ul>\n",
+    "    </li>\n",
+    "</ul>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### How to represent images as  feature vectors ?\n",
+    "### How to represent images as feature vectors?\n",
     "\n",
     "To simplify our explanations we consider gray images only here. Computers represent images as matrices. Every cell in the matrix represents one pixel, and the numerical value in the matrix cell its gray value.\n",
     "\n",
@@ -273,7 +291,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -284,30 +302,41 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['DESCR', 'data', 'images', 'target', 'target_names']\n"
+     ]
+    }
+   ],
    "source": [
-    "dd = load_digits()"
+    "dd = load_digits()\n",
+    "print(dir(dd))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Next we plot the first nine digits from this data set:"
+    "Let's plot the first ten digits from this data set:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 76,
-   "metadata": {},
+   "execution_count": 4,
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
-       "<Figure size 1296x360 with 9 Axes>"
+       "<Figure size 1440x360 with 10 Axes>"
       ]
      },
      "metadata": {
@@ -317,12 +346,12 @@
     }
    ],
    "source": [
-    "N = 9\n",
+    "N = 10\n",
     "\n",
     "plt.figure(figsize=(2 * N, 5))\n",
     "\n",
     "for i, image in enumerate(dd.images[:N]):\n",
-    "    plt.subplot(1, N, i + 1)\n",
+    "    plt.subplot(1, N, i + 1).set_title(dd.target[i])\n",
     "    plt.imshow(image, cmap=\"gray\")"
    ]
   },
@@ -330,53 +359,86 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "And this is the first image from the data set, it is a 8 x 8 matrix with values 0 to 15. The range 0 to 15 is fixed for this specific data set. Other formats allow e.g. values 0..255 or floating point values in the range 0 to 1."
+    "The data is a set of 8 x 8 matrices with values 0 to 15. The range 0 to 15 is fixed for this specific data set. Other formats allow e.g. values 0..255 or floating point values in the range 0 to 1."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(8, 8)\n",
-      "[[ 0.  0.  5. 13.  9.  1.  0.  0.]\n",
+      "images.ndim: 3\n",
+      "images[0].shape: (8, 8)\n",
+      "images[0]:\n",
+      " [[ 0.  0.  5. 13.  9.  1.  0.  0.]\n",
       " [ 0.  0. 13. 15. 10. 15.  5.  0.]\n",
       " [ 0.  3. 15.  2.  0. 11.  8.  0.]\n",
       " [ 0.  4. 12.  0.  0.  8.  8.  0.]\n",
       " [ 0.  5.  8.  0.  0.  9.  8.  0.]\n",
       " [ 0.  4. 11.  0.  1. 12.  7.  0.]\n",
       " [ 0.  2. 14.  5. 10. 12.  0.  0.]\n",
-      " [ 0.  0.  6. 13. 10.  0.  0.  0.]]\n"
+      " [ 0.  0.  6. 13. 10.  0.  0.  0.]]\n",
+      "images.shape: (1797, 8, 8)\n",
+      "images.size: 115008\n",
+      "images.dtype: float64\n",
+      "images.itemsize: 8\n",
+      "target.size: 1797\n",
+      "target_names: [0 1 2 3 4 5 6 7 8 9]\n",
+      "DESCR:\n",
+      " Optical Recognition of Handwritten Digits Data Set\n",
+      "===================================================\n",
+      "\n",
+      "Notes\n",
+      "-----\n",
+      "Data Set Characteristics:\n",
+      "    :Number of Instances: 5620\n",
+      "    :Number of Attributes: 64\n",
+      "    :Attribute Information: 8x8 image of integer pixels in the range 0..16.\n",
+      "    :Missing Attribute Values: None\n",
+      "    :Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)\n",
+      "    :Date: July; 1998\n",
+      "\n",
+      "This is a copy of the test set of the UCI ML hand-written digits datasets\n",
+      "http://archive.ics.uci.edu/ml/datas \n",
+      "[...]\n"
      ]
     }
    ],
    "source": [
-    "print(dd.images[0].shape)\n",
-    "print(dd.images[0])"
+    "print(\"images.ndim:\", dd.images.ndim) # number of dimensions of the array\n",
+    "print(\"images[0].shape:\", dd.images[0].shape) # dimensions of a first sample array\n",
+    "print(\"images[0]:\\n\", dd.images[0]) # first sample array\n",
+    "print(\"images.shape:\", dd.images.shape) # dimensions of the array of all samples\n",
+    "print(\"images.size:\", dd.images.size) # total number of elements of the array\n",
+    "print(\"images.dtype:\", dd.images.dtype) # type of the elements in the array\n",
+    "print(\"images.itemsize:\", dd.images.itemsize) # size in bytes of each element of the array\n",
+    "print(\"target.size:\", dd.target.size) # size of the target feature vector (labels of samples)\n",
+    "print(\"target_names:\", dd.target_names) # classes vector\n",
+    "print(\"DESCR:\\n\", dd.DESCR[:500], \"\\n[...]\") # description of the dataset"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "To transform such an image to a feature vector we just have to concatenate the rows to one single vector of size 64:"
+    "To transform such an image to a feature vector we just have to flatten the matrix by concatenating the rows to one single vector of size 64:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(64,)\n",
-      "[ 0.  0.  5. 13.  9.  1.  0.  0.  0.  0. 13. 15. 10. 15.  5.  0.  0.  3.\n",
+      "image_vector.shape: (64,)\n",
+      "image_vector: [ 0.  0.  5. 13.  9.  1.  0.  0.  0.  0. 13. 15. 10. 15.  5.  0.  0.  3.\n",
       " 15.  2.  0. 11.  8.  0.  0.  4. 12.  0.  0.  8.  8.  0.  0.  5.  8.  0.\n",
       "  0.  9.  8.  0.  0.  4. 11.  0.  1. 12.  7.  0.  0.  2. 14.  5. 10. 12.\n",
       "  0.  0.  0.  0.  6. 13. 10.  0.  0.  0.]\n"
@@ -384,9 +446,9 @@
     }
    ],
    "source": [
-    "vector = dd.images[0].flatten()\n",
-    "print(vector.shape)\n",
-    "print(vector)"
+    "image_vector = dd.images[0].flatten()\n",
+    "print(\"image_vector.shape:\", image_vector.shape)\n",
+    "print(\"image_vector:\", image_vector)"
    ]
   },
   {
@@ -400,7 +462,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we start a machine learning project for texts, we first have to choose and fix an enumerated dictionary or words for this project. The final representation of texts as feature vectors depends on this dictionary. \n",
+    "If we start a machine learning project for texts, we first have to choose a dictionary - set of words for this project. The final representation of a text as a feature vector depends on this dictionary.\n",
     "\n",
     "Such a dictionary can be very large, but for the sake of simplicity we use a very small enumerated dictionary to explain the overall procedure:\n",
     "\n",
@@ -414,7 +476,7 @@
     "| beer     | 4     |\n",
     "| pizza    | 5     |\n",
     "\n",
-    "To \"vectorize\" a given text we count the words in the text which also exist in the vocabulary and put the counts at the given position `Index`.\n",
+    "To \"vectorize\" a given text we count the words in the text which also exist in the vocabulary and put the counts at the given `Index`.\n",
     "\n",
     "E.g. `\"I dislike american pizza, but american beer is nice\"`:\n",
     "\n",
@@ -427,11 +489,11 @@
     "| beer     | 4     | 1     |\n",
     "| pizza    | 5     | 1     |\n",
     "\n",
-    "The according feature vector is the `Count` column, which is:\n",
+    "The respective feature vector is the `Count` column, which is:\n",
     "\n",
     "`[0, 1, 2, 0, 1, 1]`\n",
     "\n",
-    "In real case scenarios the dictionary is much bigger, this results then in vectors with only few non-zero entries (so called sparse vectors)."
+    "In real case scenarios the dictionary is much bigger, which often results in vectors with only few non-zero entries (so called **sparse vectors**)."
    ]
   },
   {
@@ -443,7 +505,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 77,
+   "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
@@ -458,15 +520,57 @@
     "from sklearn.feature_extraction.text import CountVectorizer\n",
     "from itertools import count\n",
     "\n",
-    "vocabulary = {\"like\": 0, \"dislike\": 1, \"american\": 2, \"italian\": 3, \"beer\": 4, \"pizza\": 5}\n",
+    "vocabulary = {\n",
+    "    \"like\": 0,\n",
+    "    \"dislike\": 1,\n",
+    "    \"american\": 2,\n",
+    "    \"italian\": 3,\n",
+    "    \"beer\": 4,\n",
+    "    \"pizza\": 5,\n",
+    "}\n",
     "\n",
     "vectorizer = CountVectorizer(vocabulary=vocabulary)\n",
     "\n",
     "# create count vector for a pice of text:\n",
-    "vector = vectorizer.fit_transform([\"I dislike american pizza. But american beer is nice\"]).toarray().flatten()\n",
+    "vector = vectorizer.fit_transform([\n",
+    "    \"I dislike american pizza. But american beer is nice\"\n",
+    "]).toarray().flatten()\n",
     "print(vector)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## ML lingo: What are the different types of datasets?\n",
+    "\n",
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<i class=\"fa fa-warning\"></i>&nbsp;<strong>Definitions</strong>\n",
+    "\n",
+    "Subset of data used for:\n",
+    "<ul>\n",
+    "    <li>learning (training) a model is called a <strong>training set</strong>;</li>\n",
+    "    <li>improving ML method performance by adjusting its parameters is called <strong>validation set</strong>;</li>\n",
+    "    <li>assesing final performance is called <strong>test set</strong>.</li>\n",
+    "</ul>\n",
+    "</div>\n",
+    "\n",
+    "<table>\n",
+    "    <tr>\n",
+    "        <td><img src=\"./data_split.png\" width=300px></td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td style=\"font-size:75%\"><center>Img source: https://dziganto.github.io</center></td>\n",
+    "    </tr>\n",
+    "</table>\n",
+    "\n",
+    "\n",
+    "You will learn more on how to select wisely subsets of your data and about related issues later in the course. For now just remember that:\n",
+    "1. the training and validation datasets must be disjunct during each iteration of the method improvement, and\n",
+    "1. the test dataset must be independent from the model (hence, from the other datasets), i.e. it is indeed used only for the final assesment of the method's performance (think: locked in the safe until you're done with model tweaking).\n",
+    "\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -487,11 +591,24 @@
     "\n",
     "Examples for supervised learning:\n",
     "\n",
-    "- Classification: Predict the class `is_yummy`  based on the attributes `alcohol_content`,\t`bitterness`, \t`darkness` and `fruitiness`. (two class problem).\n",
+    "- Classification: predict the class `is_yummy`  based on the attributes `alcohol_content`,\t`bitterness`, \t`darkness` and `fruitiness` (a standard two class problem).\n",
+    "\n",
+    "- Classification: predict the digit-shown based on a 8 x 8 pixel image (a multi-class problem).\n",
+    "\n",
+    "- Regression: predict temperature based on how long sun was shining in the last 10 minutes.\n",
     "\n",
-    "- Classification: predict the digit-shown based on a 8 x 8 pixel image (this is a multi-class problem).\n",
     "\n",
-    "- Regression: Predict the length of a salmon based on its age and weight."
+    "\n",
+    "<table>\n",
+    "    <tr>\n",
+    "    <td><img src=\"./classification-svc-2d-poly.png\" width=400px></td>\n",
+    "    <td><img src=\"./regression-lin-1d.png\" width=400px></td>\n",
+    "    </tr>\n",
+    "    <tr>\n",
+    "        <td><center>Classification</center></td>\n",
+    "        <td><center>Linear regression</center></td>\n",
+    "    </tr>\n",
+    "</table>\n"
    ]
   },
   {
@@ -508,13 +625,13 @@
     "\n",
     "Examples for unsupervised learning:\n",
     "\n",
-    "- Can we split up our beer data set into sub groups of similar beers ?\n",
-    "- Can we reduce our data set because groups of features are somehow correlated ?\n",
+    "- Can we split up our beer data set into sub groups of similar beers?\n",
+    "- Can we reduce our data set because groups of features are somehow correlated?\n",
     "\n",
     "<table>\n",
     "    <tr>\n",
-    "    <td><img src=\"./cluster-image.png/\" width=60%></td>\n",
-    "    <td><img src=\"./nonlin-pca.png/\" width=60%></td>\n",
+    "    <td><img src=\"./cluster-image.png/\" width=400px></td>\n",
+    "    <td><img src=\"./nonlin-pca.png/\" width=400px></td>\n",
     "    </tr>\n",
     "    <tr>\n",
     "        <td><center>Clustering</center></td>\n",
@@ -550,6 +667,15 @@
     "# Exercise section 1"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<div class=\"alert alert-block alert-danger\">\n",
+    "<strong>TODO:</strong> prepare set of actual small exercises out of it (currently it's just more of a tutorial/example).\n",
+    "</div>"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -559,7 +685,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 126,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
@@ -644,7 +770,7 @@
        "4         4.148710    0.570586  1.461568    0.260218         0"
       ]
      },
-     "execution_count": 126,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -659,7 +785,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 159,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
@@ -680,7 +806,7 @@
     "for_plot = beer_data.copy()\n",
     "\n",
     "def translate_label(value):\n",
-    "    return \"yummy\" if value == 1 else \"not yummy\"\n",
+    "    return \"not yummy\" if value == 0 else \"yummy\"\n",
     "\n",
     "for_plot[\"is_yummy\"] = for_plot[\"is_yummy\"].apply(translate_label)\n",
     "\n",
@@ -696,26 +822,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 157,
-   "metadata": {},
+   "execution_count": 10,
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "# INPUT FEATURES\n",
       "   alcohol_content  bitterness  darkness  fruitiness\n",
       "0         3.739295    0.422503  0.989463    0.215791\n",
       "1         4.207849    0.841668  0.928626    0.380420\n",
       "2         4.709494    0.322037  5.374682    0.145231\n",
       "3         4.684743    0.434315  4.072805    0.191321\n",
       "4         4.148710    0.570586  1.461568    0.260218\n",
+      "...\n",
+      "(225, 4)\n",
       "\n",
+      "# LABELS\n",
       "0    0\n",
       "1    0\n",
       "2    1\n",
       "3    1\n",
       "4    0\n",
-      "Name: is_yummy, dtype: int64\n"
+      "Name: is_yummy, dtype: int64\n",
+      "...\n",
+      "(225,)\n"
      ]
     }
    ],
@@ -726,92 +860,111 @@
     "# only the last column:\n",
     "labels = beer_data.iloc[:, -1]\n",
     "\n",
+    "print('# INPUT FEATURES')\n",
     "print(input_features.head(5))\n",
+    "print('...')\n",
+    "print(input_features.shape)\n",
     "print()\n",
-    "print(labels.head(5))"
+    "print('# LABELS')\n",
+    "print(labels.head(5))\n",
+    "print('...')\n",
+    "print(labels.shape)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We experiment now the so called `LogisticRegression` classifier. The name is misleading: logistic regression internally uses a kind of regression algorithm for probabilities with the final goal to classify data. So even if the name contains \"regression\" it still is a classifier."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 81,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.linear_model import LogisticRegression"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 144,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "classifier = LogisticRegression(C=1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "In `scikit-learn` all classifiers have a `fit` method to learn from data:"
+    "Let's start learning with the so called `LogisticRegression` classifier.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<i class=\"fa fa-info-circle\"></i>\n",
+    "In logistic regression the linear regression is used internally and then transformed (using logistic function) to probability of belonging to one of the two classes. Even so the name contains \"regression\", it is still a classifier.\n",
+    "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 145,
-   "metadata": {},
+   "execution_count": 11,
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "LogisticRegression(C=1, class_weight=None, dual=False, fit_intercept=True,\n",
+       "LogisticRegression(C=1.0, class_weight=None, dual=False, fit_intercept=True,\n",
        "          intercept_scaling=1, max_iter=100, multi_class='ovr', n_jobs=1,\n",
        "          penalty='l2', random_state=None, solver='liblinear', tol=0.0001,\n",
        "          verbose=0, warm_start=False)"
       ]
      },
-     "execution_count": 145,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
-    "classifier.fit(input_features, labels)"
+    "from sklearn.linear_model import LogisticRegression\n",
+    "classifier = LogisticRegression()\n",
+    "classifier"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Also `scikit-learn` classifiers have a `predict` method for predicting classes for input features. Here we just re-classify our learning data:"
+    "<div class=\"alert alert-block alert-warning\">\n",
+    "<i class=\"fa fa-warning\"></i>&nbsp;<strong>`scikit-learn` API</strong>\n",
+    "\n",
+    "In <code>scikit-learn</code> all classifiers have:\n",
+    "<ul>\n",
+    "    <li>a <strong><code>fit()</code></strong> method to learn from data, and</li>\n",
+    "    <li>and a subsequent <strong><code>predict()</code></strong> method for predicting classes from input features.</li>\n",
+    "</ul>\n",
+    "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "train first..\n",
+      "(225,)\n"
+     ]
+    }
+   ],
    "source": [
-    "predicted_labels = classifier.predict(input_features)"
+    "# Sanity check: can't predict if not fitted (trained)\n",
+    "from sklearn.exceptions import NotFittedError\n",
+    "try:\n",
+    "    classifier.predict(input_features)\n",
+    "except NotFittedError:\n",
+    "    print(\"train first..\")\n",
+    "\n",
+    "# Fit\n",
+    "classifier.fit(input_features, labels)\n",
+    "\n",
+    "# Predict\n",
+    "predicted_labels = classifier.predict(input_features)\n",
+    "print(predicted_labels.shape)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Lets check our result with a few examples:"
+    "Here we've just re-classified our training data. Lets check our result with a few examples:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 48,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
@@ -842,7 +995,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 140,
+   "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
@@ -850,7 +1003,7 @@
      "output_type": "stream",
      "text": [
       "225 examples\n",
-      "191 labeled correctly\n"
+      "187 labeled correctly\n"
      ]
     }
    ],
@@ -863,7 +1016,11 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Comment: `predicted_labels == labels` evaluates as a vector of values `True` or `False`. Python handles `True` as `1` and `False` as `0` when used as numbers. So the `sum(...)` just counts the correct results.\n"
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<i class=\"fa fa-info-circle\"></i>\n",
+    "<code>predicted_labels == labels</code> evaluates to a vector of <code>True</code> or <code>False</code> Boolean values. When used as numbers, Python handles <code>True</code> as <code>1</code> and <code>False</code> as <code>0</code>. So, <code>sum(...)</code> simply counts the correctly predicted labels.\n",
+    "</div>\n",
+    "\n"
    ]
   },
   {
@@ -890,76 +1047,94 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now we play with a different ML algorithm, the so called `Support Vector Classifier` (which belongs to a class of algorithms named `SVM`s (`Support Vector Machines`).\n",
-    "\n",
-    "**we will discuss available ML algorithms in a following script**\n"
+    "# Exercise section 2"
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 154,
+   "cell_type": "markdown",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "from sklearn.svm import SVC\n",
-    "\n",
-    "classifier = SVC(C=1)\n",
-    "classifier.fit(features, labels)\n",
-    "\n",
-    "predicted_labels = classifier.predict(features)"
+    "<div class=\"alert alert-block alert-danger\">\n",
+    "<strong>TODO:</strong> I propose to start excercise session 2 here, and ask to do re-classification with SVM, and only then play w/ regularization param.\n",
+    "</div>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Lets evaluate the performance again:"
+    "Now, train a different `scikit-learn` classifier - the so called **Support Vector Classifier** `SVC`, and evaluate its \"re-classification\" performance again.\n",
+    "\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<i class=\"fa fa-info-circle\"></i>\n",
+    "<code>SVC</code>  belongs to a class of algorithms named \"Support Vector Machines\" (SVMs). We will discuss available ML algorithms in more detail in the following scripts.\n",
+    "</div>"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 155,
+   "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "(225,)\n",
-      "(225,)\n",
-      "205\n"
+      "225 examples\n",
+      "205 labeled correctly\n"
      ]
     }
    ],
    "source": [
-    "print(predicted_labels.shape)\n",
-    "print(labels.shape)\n",
-    "print(sum(predicted_labels == labels))"
+    "from sklearn.svm import SVC\n",
+    "# ...\n",
+    "# REMOVE the following lines in the target script\n",
+    "classifier = SVC()\n",
+    "classifier.fit(input_features, labels)\n",
+    "\n",
+    "predicted_labels = classifier.predict(input_features)\n",
+    "\n",
+    "assert(predicted_labels.shape == labels.shape)\n",
+    "print(len(labels), \"examples\")\n",
+    "print(sum(predicted_labels == labels), \"labeled correctly\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This is a better result ! **But this does not indicate that `SVC` is always superior to `LogisticRegression`.**\n",
+    "Better?\n",
     "\n",
-    "Here `SVC` just seems to fit better to our current machine learning task.\n",
+    "<div class=\"alert alert-block alert-info\">\n",
+    "<i class=\"fa fa-info-circle\"></i>\n",
+    "Better re-classification does not indicate here that <code>SVC</code> is better than <code>LogisticRegression</code>. At most it seems to fit better to our training data. We will learn later that this may actually not necessarily be a good thing.\n",
+    "</div>\n",
     "\n",
-    "### Instructions:\n",
-    "\n",
-    "- Play with parameter `C` for `LogisticRegresseion` and `SVC`.\n"
+    "Note that both `LogisticRegression` and `SVC` classifiers have a parameter `C` which allows to enforce simplification (know also as regularization) of the resulting model. Test the beers data \"re-classification\" with different values of this parameter."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 75,
+   "execution_count": 16,
    "metadata": {},
+   "outputs": [],
+   "source": [
+    "?LogisticRegression\n",
+    "# ..."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "collapsed": true
+   },
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/Users/uweschmitt/Projects/machinelearning-introduction-workshop/venv3.6/lib/python3.6/site-packages/ipykernel_launcher.py:9: UserWarning: get_ipython_dir has moved to the IPython.paths module since IPython 4.0.\n",
+      "/Users/mikolajr/Workspace/SSDM/machinelearning-introduction-workshop/.venv/lib/python3.7/site-packages/ipykernel_launcher.py:9: UserWarning: get_ipython_dir has moved to the IPython.paths module since IPython 4.0.\n",
       "  if __name__ == '__main__':\n"
      ]
     },
@@ -1058,7 +1233,7 @@
        "<IPython.core.display.HTML object>"
       ]
      },
-     "execution_count": 75,
+     "execution_count": 17,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -1164,13 +1339,6 @@
     "css_styling()\n",
     "#REMOVEEND"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -1189,7 +1357,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.7.1"
   }
  },
  "nbformat": 4,
diff --git a/classification-svc-2d-poly.png b/classification-svc-2d-poly.png
new file mode 100644
index 0000000000000000000000000000000000000000..1f26ad59d3beecd513f298abea94bd4a34f078ca
Binary files /dev/null and b/classification-svc-2d-poly.png differ
diff --git a/classifier_examples.ipynb b/classifier_examples.ipynb
index b33e955869ffad47c476100a96219d664ea6847e..24acd18d1b4bff47859d4c0d98f8d76927499274 100644
--- a/classifier_examples.ipynb
+++ b/classifier_examples.ipynb
@@ -662,6 +662,127 @@
     "plt.scatter(xv, yv, color=colors)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## SVC 2D plots"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import pandas as pd\n",
+    "beer_data = pd.read_csv(\"beers.csv\")\n",
+    "input_features = beer_data.iloc[:, :-1]\n",
+    "labels = beer_data.iloc[:, -1]\n",
+    "# pick 2 features from `input_features.columns`\n",
+    "input_features_names = [\"bitterness\", \"darkness\"]\n",
+    "X = input_features[input_features_names]\n",
+    "y = labels\n",
+    "\n",
+    "'''Source: https://scikit-learn.org/stable/auto_examples/svm/plot_iris.html#sphx-glr-auto-examples-svm-plot-iris-py\n",
+    "'''\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "def make_meshgrid(x, y, h=.02):\n",
+    "    \"\"\"Create a mesh of points to plot in\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    x: data to base x-axis meshgrid on\n",
+    "    y: data to base y-axis meshgrid on\n",
+    "    h: stepsize for meshgrid, optional\n",
+    "\n",
+    "    Returns\n",
+    "    -------\n",
+    "    xx, yy : ndarray\n",
+    "    \"\"\"\n",
+    "    x_min, x_max = x.min() - 1, x.max() + 1\n",
+    "    y_min, y_max = y.min() - 1, y.max() + 1\n",
+    "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),\n",
+    "                         np.arange(y_min, y_max, h))\n",
+    "    return xx, yy\n",
+    "\n",
+    "\n",
+    "def plot_contours(ax, clf, xx, yy, **params):\n",
+    "    \"\"\"Plot the decision boundaries for a classifier.\n",
+    "\n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    ax: matplotlib axes object\n",
+    "    clf: a classifier\n",
+    "    xx: meshgrid ndarray\n",
+    "    yy: meshgrid ndarray\n",
+    "    params: dictionary of params to pass to contourf, optional\n",
+    "    \"\"\"\n",
+    "    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])\n",
+    "    Z = Z.reshape(xx.shape)\n",
+    "    out = ax.contourf(xx, yy, Z, **params)\n",
+    "    return out\n",
+    "\n",
+    "\n",
+    "\n",
+    "from sklearn import svm\n",
+    "\n",
+    "# we create an instance of SVM and fit out data. We do not scale our\n",
+    "# data since we want to plot the support vectors\n",
+    "C = 1.0  # SVM regularization parameter\n",
+    "models = (\n",
+    "    svm.SVC(kernel='linear', C=C),\n",
+    "    svm.LinearSVC(C=C),\n",
+    "    svm.SVC(kernel='rbf', gamma=0.7, C=C),\n",
+    "    svm.SVC(kernel='poly', degree=3, C=C),\n",
+    ")\n",
+    "models = [clf.fit(X, y) for clf in models]\n",
+    "\n",
+    "# title for the plots\n",
+    "titles = (\n",
+    "    'SVC with linear kernel',\n",
+    "    'LinearSVC (linear kernel)',\n",
+    "    'SVC with RBF kernel',\n",
+    "    'SVC with polynomial (degree 3) kernel',\n",
+    ")\n",
+    "\n",
+    "models = models[-1:]\n",
+    "titles = ('Is the beer yummy (blue) or not (red)?',)\n",
+    "\n",
+    "# Set-up 2x2 grid for plotting.\n",
+    "#fig, sub = plt.subplots(2, 2)\n",
+    "fig, sub = plt.subplots(1, 1)\n",
+    "plt.subplots_adjust(wspace=0.4, hspace=0.4)\n",
+    "\n",
+    "X0, X1 = X.iloc[:, 0], X.iloc[:, 1]\n",
+    "xx, yy = make_meshgrid(X0, X1)\n",
+    "\n",
+    "for clf, title, ax in zip(models, titles, sub.flatten() if hasattr(sub, 'flatten') else [sub]):\n",
+    "    plot_contours(ax, clf, xx, yy,\n",
+    "                  cmap=plt.cm.coolwarm, alpha=0.8)\n",
+    "    ax.scatter(X0, X1, c=y, cmap=plt.cm.coolwarm, s=20, edgecolors='k')\n",
+    "    ax.set_xlim(xx.min(), xx.max())\n",
+    "    ax.set_ylim(yy.min(), yy.max())\n",
+    "    ax.set_xlabel(input_features_names[0])\n",
+    "    ax.set_ylabel(input_features_names[1])\n",
+    "    ax.set_xticks(())\n",
+    "    ax.set_yticks(())\n",
+    "    ax.set_title(title)"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -686,7 +807,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.6"
+   "version": "3.7.1"
   }
  },
  "nbformat": 4,
diff --git a/data_split.png b/data_split.png
new file mode 100644
index 0000000000000000000000000000000000000000..c368e5cc652ee4df68d4d752182aa6a64fa4fa43
Binary files /dev/null and b/data_split.png differ
diff --git a/regression-lin-1d.png b/regression-lin-1d.png
new file mode 100644
index 0000000000000000000000000000000000000000..aea25afb7a18cdd8effb27010b5a4b56714b071b
Binary files /dev/null and b/regression-lin-1d.png differ