diff --git a/notebooks/airbnb_tf.ipynb b/notebooks/airbnb_tf.ipynb
new file mode 100644
index 0000000..06b8e4a
--- /dev/null
+++ b/notebooks/airbnb_tf.ipynb
@@ -0,0 +1,827 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Load data\n",
+    "\n",
+    "<https://www.kaggle.com/dgomonov/new-york-city-airbnb-open-data>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import re\n",
+    "import sage\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import gender_guesser.detector as detector\n",
+    "from sklearn.model_selection import train_test_split"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "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>id</th>\n",
+       "      <th>name</th>\n",
+       "      <th>host_id</th>\n",
+       "      <th>host_name</th>\n",
+       "      <th>neighbourhood_group</th>\n",
+       "      <th>neighbourhood</th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>room_type</th>\n",
+       "      <th>price</th>\n",
+       "      <th>minimum_nights</th>\n",
+       "      <th>number_of_reviews</th>\n",
+       "      <th>last_review</th>\n",
+       "      <th>reviews_per_month</th>\n",
+       "      <th>calculated_host_listings_count</th>\n",
+       "      <th>availability_365</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>2539</td>\n",
+       "      <td>Clean &amp; quiet apt home by the park</td>\n",
+       "      <td>2787</td>\n",
+       "      <td>John</td>\n",
+       "      <td>Brooklyn</td>\n",
+       "      <td>Kensington</td>\n",
+       "      <td>40.64749</td>\n",
+       "      <td>-73.97237</td>\n",
+       "      <td>Private room</td>\n",
+       "      <td>149</td>\n",
+       "      <td>1</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2018-10-19</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>6</td>\n",
+       "      <td>365</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2595</td>\n",
+       "      <td>Skylit Midtown Castle</td>\n",
+       "      <td>2845</td>\n",
+       "      <td>Jennifer</td>\n",
+       "      <td>Manhattan</td>\n",
+       "      <td>Midtown</td>\n",
+       "      <td>40.75362</td>\n",
+       "      <td>-73.98377</td>\n",
+       "      <td>Entire home/apt</td>\n",
+       "      <td>225</td>\n",
+       "      <td>1</td>\n",
+       "      <td>45</td>\n",
+       "      <td>2019-05-21</td>\n",
+       "      <td>0.38</td>\n",
+       "      <td>2</td>\n",
+       "      <td>355</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>3647</td>\n",
+       "      <td>THE VILLAGE OF HARLEM....NEW YORK !</td>\n",
+       "      <td>4632</td>\n",
+       "      <td>Elisabeth</td>\n",
+       "      <td>Manhattan</td>\n",
+       "      <td>Harlem</td>\n",
+       "      <td>40.80902</td>\n",
+       "      <td>-73.94190</td>\n",
+       "      <td>Private room</td>\n",
+       "      <td>150</td>\n",
+       "      <td>3</td>\n",
+       "      <td>0</td>\n",
+       "      <td>NaT</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>1</td>\n",
+       "      <td>365</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>3831</td>\n",
+       "      <td>Cozy Entire Floor of Brownstone</td>\n",
+       "      <td>4869</td>\n",
+       "      <td>LisaRoxanne</td>\n",
+       "      <td>Brooklyn</td>\n",
+       "      <td>Clinton Hill</td>\n",
+       "      <td>40.68514</td>\n",
+       "      <td>-73.95976</td>\n",
+       "      <td>Entire home/apt</td>\n",
+       "      <td>89</td>\n",
+       "      <td>1</td>\n",
+       "      <td>270</td>\n",
+       "      <td>2019-07-05</td>\n",
+       "      <td>4.64</td>\n",
+       "      <td>1</td>\n",
+       "      <td>194</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>5022</td>\n",
+       "      <td>Entire Apt: Spacious Studio/Loft by central park</td>\n",
+       "      <td>7192</td>\n",
+       "      <td>Laura</td>\n",
+       "      <td>Manhattan</td>\n",
+       "      <td>East Harlem</td>\n",
+       "      <td>40.79851</td>\n",
+       "      <td>-73.94399</td>\n",
+       "      <td>Entire home/apt</td>\n",
+       "      <td>80</td>\n",
+       "      <td>10</td>\n",
+       "      <td>9</td>\n",
+       "      <td>2018-11-19</td>\n",
+       "      <td>0.10</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "     id                                              name  host_id  \\\n",
+       "0  2539                Clean & quiet apt home by the park     2787   \n",
+       "1  2595                             Skylit Midtown Castle     2845   \n",
+       "2  3647               THE VILLAGE OF HARLEM....NEW YORK !     4632   \n",
+       "3  3831                   Cozy Entire Floor of Brownstone     4869   \n",
+       "4  5022  Entire Apt: Spacious Studio/Loft by central park     7192   \n",
+       "\n",
+       "     host_name neighbourhood_group neighbourhood  latitude  longitude  \\\n",
+       "0         John            Brooklyn    Kensington  40.64749  -73.97237   \n",
+       "1     Jennifer           Manhattan       Midtown  40.75362  -73.98377   \n",
+       "2    Elisabeth           Manhattan        Harlem  40.80902  -73.94190   \n",
+       "3  LisaRoxanne            Brooklyn  Clinton Hill  40.68514  -73.95976   \n",
+       "4        Laura           Manhattan   East Harlem  40.79851  -73.94399   \n",
+       "\n",
+       "         room_type  price  minimum_nights  number_of_reviews last_review  \\\n",
+       "0     Private room    149               1                  9  2018-10-19   \n",
+       "1  Entire home/apt    225               1                 45  2019-05-21   \n",
+       "2     Private room    150               3                  0         NaT   \n",
+       "3  Entire home/apt     89               1                270  2019-07-05   \n",
+       "4  Entire home/apt     80              10                  9  2018-11-19   \n",
+       "\n",
+       "   reviews_per_month  calculated_host_listings_count  availability_365  \n",
+       "0               0.21                               6               365  \n",
+       "1               0.38                               2               355  \n",
+       "2                NaN                               1               365  \n",
+       "3               4.64                               1               194  \n",
+       "4               0.10                               1                 0  "
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Load data\n",
+    "df = sage.datasets.airbnb()\n",
+    "\n",
+    "# Sample rows\n",
+    "df.head(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Categorical features\n",
+    "categorical_columns = ['neighbourhood_group', 'neighbourhood', 'room_type']\n",
+    "for column in categorical_columns:\n",
+    "    df[column] = pd.Categorical(df[column]).codes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Exclude outliers (top 0.5%)\n",
+    "df = df[df['price'] < df['price'].quantile(0.995)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Features derived from name\n",
+    "df['name_length'] = df['name'].apply(lambda x: len(x))\n",
+    "df['name_isupper'] = df['name'].apply(lambda x: int(x.isupper()))\n",
+    "df['name_words'] = df['name'].apply(lambda x: len(re.findall(r'\\w+', x)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Host gender guess\n",
+    "guesser = detector.Detector()\n",
+    "df['host_gender'] = df['host_name'].apply(lambda x: guesser.get_gender(x.split(' ')[0]))\n",
+    "df['host_gender'] = pd.Categorical(df['host_gender']).codes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Number of days since last review\n",
+    "most_recent = df['last_review'].max()\n",
+    "df['last_review'] = (most_recent - df['last_review']).dt.days\n",
+    "df['last_review'] = (df['last_review'] - df['last_review'].mean()) / df['last_review'].std()\n",
+    "df['last_review'] = df['last_review'].fillna(-5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Missing values\n",
+    "df['reviews_per_month'] = df['reviews_per_month'].fillna(0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Normalize other numerical features\n",
+    "df['number_of_reviews'] = (df['number_of_reviews'] - df['number_of_reviews'].mean()) / df['number_of_reviews'].std()\n",
+    "df['availability_365'] = (df['availability_365'] - df['availability_365'].mean()) / df['availability_365'].std()\n",
+    "df['name_length'] = (df['name_length'] - df['name_length'].mean()) / df['name_length'].std()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Normalize latitude and longitude\n",
+    "df['latitude'] = (df['latitude'] - df['latitude'].mean()) / df['latitude'].std()\n",
+    "df['longitude'] = (df['longitude'] - df['longitude'].mean()) / df['longitude'].std()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Drop columns\n",
+    "df = df.drop(['id', 'host_id', 'host_name', 'name'], axis=1)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "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>neighbourhood_group</th>\n",
+       "      <th>neighbourhood</th>\n",
+       "      <th>latitude</th>\n",
+       "      <th>longitude</th>\n",
+       "      <th>room_type</th>\n",
+       "      <th>price</th>\n",
+       "      <th>minimum_nights</th>\n",
+       "      <th>number_of_reviews</th>\n",
+       "      <th>last_review</th>\n",
+       "      <th>reviews_per_month</th>\n",
+       "      <th>calculated_host_listings_count</th>\n",
+       "      <th>availability_365</th>\n",
+       "      <th>name_length</th>\n",
+       "      <th>name_isupper</th>\n",
+       "      <th>name_words</th>\n",
+       "      <th>host_gender</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>1</td>\n",
+       "      <td>108</td>\n",
+       "      <td>-1.492033</td>\n",
+       "      <td>-0.440795</td>\n",
+       "      <td>1</td>\n",
+       "      <td>149</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.321948</td>\n",
+       "      <td>-0.034852</td>\n",
+       "      <td>0.21</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1.922931</td>\n",
+       "      <td>-0.276169</td>\n",
+       "      <td>0</td>\n",
+       "      <td>7</td>\n",
+       "      <td>2</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>2</td>\n",
+       "      <td>127</td>\n",
+       "      <td>0.452497</td>\n",
+       "      <td>-0.687792</td>\n",
+       "      <td>0</td>\n",
+       "      <td>225</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.484307</td>\n",
+       "      <td>-0.552366</td>\n",
+       "      <td>0.38</td>\n",
+       "      <td>2</td>\n",
+       "      <td>1.846815</td>\n",
+       "      <td>-1.513431</td>\n",
+       "      <td>0</td>\n",
+       "      <td>3</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>2</td>\n",
+       "      <td>94</td>\n",
+       "      <td>1.467544</td>\n",
+       "      <td>0.219381</td>\n",
+       "      <td>1</td>\n",
+       "      <td>150</td>\n",
+       "      <td>3</td>\n",
+       "      <td>-0.523512</td>\n",
+       "      <td>-5.000000</td>\n",
+       "      <td>0.00</td>\n",
+       "      <td>1</td>\n",
+       "      <td>1.922931</td>\n",
+       "      <td>-0.180995</td>\n",
+       "      <td>1</td>\n",
+       "      <td>6</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>1</td>\n",
+       "      <td>41</td>\n",
+       "      <td>-0.802204</td>\n",
+       "      <td>-0.167581</td>\n",
+       "      <td>0</td>\n",
+       "      <td>89</td>\n",
+       "      <td>1</td>\n",
+       "      <td>5.523401</td>\n",
+       "      <td>-0.661188</td>\n",
+       "      <td>4.64</td>\n",
+       "      <td>1</td>\n",
+       "      <td>0.621350</td>\n",
+       "      <td>-0.561691</td>\n",
+       "      <td>0</td>\n",
+       "      <td>5</td>\n",
+       "      <td>5</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>2</td>\n",
+       "      <td>61</td>\n",
+       "      <td>1.274978</td>\n",
+       "      <td>0.174098</td>\n",
+       "      <td>0</td>\n",
+       "      <td>80</td>\n",
+       "      <td>10</td>\n",
+       "      <td>-0.321948</td>\n",
+       "      <td>-0.109819</td>\n",
+       "      <td>0.10</td>\n",
+       "      <td>1</td>\n",
+       "      <td>-0.855298</td>\n",
+       "      <td>1.056268</td>\n",
+       "      <td>0</td>\n",
+       "      <td>8</td>\n",
+       "      <td>1</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "   neighbourhood_group  neighbourhood  latitude  longitude  room_type  price  \\\n",
+       "0                    1            108 -1.492033  -0.440795          1    149   \n",
+       "1                    2            127  0.452497  -0.687792          0    225   \n",
+       "2                    2             94  1.467544   0.219381          1    150   \n",
+       "3                    1             41 -0.802204  -0.167581          0     89   \n",
+       "4                    2             61  1.274978   0.174098          0     80   \n",
+       "\n",
+       "   minimum_nights  number_of_reviews  last_review  reviews_per_month  \\\n",
+       "0               1          -0.321948    -0.034852               0.21   \n",
+       "1               1           0.484307    -0.552366               0.38   \n",
+       "2               3          -0.523512    -5.000000               0.00   \n",
+       "3               1           5.523401    -0.661188               4.64   \n",
+       "4              10          -0.321948    -0.109819               0.10   \n",
+       "\n",
+       "   calculated_host_listings_count  availability_365  name_length  \\\n",
+       "0                               6          1.922931    -0.276169   \n",
+       "1                               2          1.846815    -1.513431   \n",
+       "2                               1          1.922931    -0.180995   \n",
+       "3                               1          0.621350    -0.561691   \n",
+       "4                               1         -0.855298     1.056268   \n",
+       "\n",
+       "   name_isupper  name_words  host_gender  \n",
+       "0             0           7            2  \n",
+       "1             0           3            1  \n",
+       "2             1           6            1  \n",
+       "3             0           5            5  \n",
+       "4             0           8            1  "
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# New sample rows\n",
+    "df.head(5)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rearrange columns\n",
+    "target_col = 'price'\n",
+    "cols = df.columns.tolist()\n",
+    "del cols[cols.index(target_col)]\n",
+    "cols.append(target_col)\n",
+    "feature_names = cols[:-1]\n",
+    "df = df[cols]\n",
+    "\n",
+    "# Split data\n",
+    "train, test = train_test_split(\n",
+    "    df.values, test_size=int(0.1 * len(df.values)), random_state=0)\n",
+    "train, val = train_test_split(\n",
+    "    train, test_size=int(0.1 * len(df.values)), random_state=0)\n",
+    "Y_train = train[:, -1:].copy()\n",
+    "Y_val = val[:, -1:].copy()\n",
+    "Y_test = test[:, -1:].copy()\n",
+    "train = train[:, :-1].copy()\n",
+    "val = val[:, :-1].copy()\n",
+    "test = test[:, :-1].copy()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Train model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tensorflow as tf\n",
+    "from tensorflow import keras\n",
+    "from tensorflow.keras import layers"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "batch_size = 32\n",
+    "\n",
+    "# Prepare the training dataset.\n",
+    "train_dataset = tf.data.Dataset.from_tensor_slices((train, Y_train))\n",
+    "train_dataset = train_dataset.shuffle(buffer_size=1024).batch(batch_size)\n",
+    "\n",
+    "# Prepare the validation dataset.\n",
+    "val_dataset = tf.data.Dataset.from_tensor_slices((val, Y_val))\n",
+    "val_dataset = val_dataset.batch(batch_size)\n",
+    "\n",
+    "# Get model\n",
+    "model = keras.Sequential(\n",
+    "    [\n",
+    "        layers.Dense(128, activation='relu', input_shape=(train.shape[1],)),\n",
+    "        layers.Dense(256, activation='relu'),\n",
+    "        layers.Dense(64, activation='relu'),\n",
+    "        layers.Dense(1)\n",
+    "    ],\n",
+    "    name='airbnb_model'\n",
+    ")\n",
+    "\n",
+    "# Instantiate an optimizer to train the model.\n",
+    "optimizer = keras.optimizers.Adam(learning_rate=1e-3)\n",
+    "\n",
+    "# Instantiate a loss function.\n",
+    "loss_fn = keras.losses.MeanSquaredError()\n",
+    "\n",
+    "# Prepare the metrics.\n",
+    "train_acc_metric = keras.metrics.MeanSquaredError()\n",
+    "val_acc_metric = keras.metrics.MeanSquaredError()\n",
+    "\n",
+    "# Utils.\n",
+    "@tf.function\n",
+    "def train_step(x, y):\n",
+    "    with tf.GradientTape() as tape:\n",
+    "        preds = model(x)\n",
+    "        loss_value = loss_fn(y, preds)\n",
+    "    grads = tape.gradient(loss_value, model.trainable_weights)\n",
+    "    optimizer.apply_gradients(zip(grads, model.trainable_weights))\n",
+    "    train_acc_metric.update_state(y, preds)\n",
+    "    return loss_value\n",
+    "\n",
+    "@tf.function\n",
+    "def test_step(x, y):\n",
+    "    preds = model(x)\n",
+    "    val_acc_metric.update_state(y, preds)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 50\n",
+    "\n",
+    "for epoch in range(epochs):\n",
+    "\n",
+    "    # Iterate over the batches of the dataset.\n",
+    "    for step, (x_batch_train, y_batch_train) in enumerate(train_dataset):\n",
+    "        loss_value = train_step(x_batch_train, y_batch_train)\n",
+    "\n",
+    "    # Display metrics at the end of each epoch.\n",
+    "    train_acc = train_acc_metric.result()\n",
+    "\n",
+    "    # Reset training metrics at the end of each epoch\n",
+    "    train_acc_metric.reset_states()\n",
+    "\n",
+    "    # Run a validation loop at the end of each epoch.\n",
+    "    for x_batch_val, y_batch_val in val_dataset:\n",
+    "        test_step(x_batch_val, y_batch_val)\n",
+    "\n",
+    "    val_acc = val_acc_metric.result()\n",
+    "    val_acc_metric.reset_states()\n",
+    "\n",
+    "# For classification (which is not the case here): see \n",
+    "# https://github.com/iancovert/sage/blob/master/sage/utils.py#L36,\n",
+    "# as output activations should already be applied properly.\n",
+    "# probability_model = tf.keras.Sequential([model, tf.keras.layers.Softmax()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training acc: 6417.3271\n",
+      "Validation acc: 7278.4600\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Training acc: %.4f\" % (float(train_acc),))\n",
+    "print(\"Validation acc: %.4f\" % (float(val_acc),))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate individual feature importance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up imputer for Tensorflow model, assuming that any necessary output activations are applied properly. If not, please set up keras.Sequential with keras.layers.Softmax()\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1/1 [03:28<00:00, 208.31s/it]     \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Setup and calculate\n",
+    "imputer = sage.MarginalImputer(model, test[:512])\n",
+    "estimator = sage.PermutationEstimator(imputer, 'mse')\n",
+    "sage_values = estimator(test, Y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot results\n",
+    "sage_values.plot(feature_names)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Calculate grouped feature importance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Feature groups\n",
+    "feature_groups = group_names = {\n",
+    "    'location (grouped)': ['latitude', 'longitude', 'neighbourhood', 'neighbourhood_group'],\n",
+    "    'name (grouped)': ['name_words', 'name_length', 'name_isupper'],\n",
+    "    'reviews (grouped)': ['last_review', 'reviews_per_month', 'number_of_reviews'],\n",
+    "    'host (grouped)': ['host_gender', 'calculated_host_listings_count'],\n",
+    "    'availability': ['availability_365'],\n",
+    "    'room_type': ['room_type']\n",
+    "}\n",
+    "group_names = [group for group in feature_groups]\n",
+    "for col in feature_names:\n",
+    "    if np.all([col not in group[1] for group in feature_groups.items()]):\n",
+    "        group_names.append(col)\n",
+    "\n",
+    "# Group indices\n",
+    "groups = []\n",
+    "for _, group in feature_groups.items():\n",
+    "    ind_list = []\n",
+    "    for feature in group:\n",
+    "        ind_list.append(cols.index(feature))\n",
+    "    groups.append(ind_list)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Setting up imputer for Tensorflow model, assuming that any necessary output activations are applied properly. If not, please set up keras.Sequential with keras.layers.Softmax()\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "100%|██████████| 1/1 [01:33<00:00, 93.20s/it]      \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Setup and calculate\n",
+    "imputer = sage.GroupedMarginalImputer(model, test[:512], groups)\n",
+    "estimator = sage.PermutationEstimator(imputer, 'mse')\n",
+    "sage_values = estimator(test, Y_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 720x504 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot results\n",
+    "sage_values.plot(group_names)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "interpreter": {
+   "hash": "c4f92193806e2908606a5f23edd55a5282f2f433b73b1c504507f9256ed9f0b4"
+  },
+  "kernelspec": {
+   "display_name": "Python 3.9.7 ('base')",
+   "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.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/sage/utils.py b/sage/utils.py
index 6b48f47..e5fe800 100644
--- a/sage/utils.py
+++ b/sage/utils.py
@@ -29,10 +29,18 @@ def model_conversion(model):
               'not, please set up nn.Sequential with nn.Sigmoid or nn.Softmax')
 
         import torch
+        model.eval()
         device = next(model.parameters()).device
         return lambda x: model(torch.tensor(
             x, dtype=torch.float32, device=device)).cpu().data.numpy()
 
+    elif safe_isinstance(model, 'keras.Model'):
+        print('Setting up imputer for keras model, assuming that any '
+              'necessary output activations are applied properly. If not, '
+              'please set up keras.Sequential with keras.layers.Softmax()')
+
+        return lambda x: model(x, training=False).numpy()
+
     elif callable(model):
         # Assume model is compatible function or callable object.
         return model