t-sne.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  t-distributed stochastic neighbor embedding (t-SNE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sklearn\n",
    "from sklearn.manifold import TSNE\n",
    "from sklearn.datasets import load_digits\n",
    "import pandas as pd\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patheffects as PathEffects\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lade MNIST Digits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "digits = load_digits()\n",
    "print(f'Digits shape: {digits.data.shape}')\n",
    "# print(digits['DESCR'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nrows, ncols = 2, 5\n",
    "fig, axs = plt.subplots(2,5, figsize=(30,10))\n",
    "\n",
    "for i in range(nrows):\n",
    "    for j in range(ncols):\n",
    "        axs[i,j].matshow(digits.images[i*5 + j,...])\n",
    "        axs[i,j].set(xticks=[], yticks=[])\n",
    "        axs[i,j].set_title(digits.target[i*5 + j])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`digits` enthält sowohl die Daten der Ziffern (`digits.data`), als auch die echten Target-Labels (`digits.target`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'Shapes: Data-{digits.data.shape}, Target-{digits.target.shape}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wenden wir jetzt t-SNE auf den Datensatz an und versuchen eine Dimensions-Reduktion von $\\mathbb{R}^{64}$ auf $\\mathbb{R}^{2}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tsne = TSNE(n_components=2, random_state=42).fit_transform(digits.data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scatter(x, colors=None):\n",
    "    palette = np.array(sns.color_palette(\"cubehelix\", 10))\n",
    "    target_colors = colors if type(colors) is np.ndarray else np.ones(x.shape[0])\n",
    "    \n",
    "    # We create a scatter plot.\n",
    "    f = plt.figure(figsize=(10, 10))\n",
    "    ax = plt.subplot(aspect='equal')\n",
    "    alpha = 0.5 if x.shape[0] < 5000 else 0.1\n",
    "    sc = ax.scatter(x[:,0], x[:,1], lw=0, s=40, c=palette[target_colors.astype(np.int)], alpha=alpha)\n",
    "    plt.xlim(-25, 25)\n",
    "    plt.ylim(-25, 25)\n",
    "    ax.axis('tight')\n",
    "\n",
    "    txts = []\n",
    "    # We add the labels for each digit.\n",
    "    if type(colors) is np.ndarray:\n",
    "        for i in range(10):\n",
    "            # Position of each label.\n",
    "            xtext, ytext = np.median(x[colors == i, :], axis=0)\n",
    "            txt = ax.text(xtext, ytext, str(i), fontsize=16)\n",
    "            txt.set_path_effects([\n",
    "                PathEffects.Stroke(linewidth=5, foreground=\"w\"),\n",
    "                PathEffects.Normal()])\n",
    "            txts.append(txt)\n",
    "\n",
    "    return f, ax, sc, txts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter(tsne, digits.target);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Die Einfärbung hilft uns, die Cluster zu differenzieren. In Monochrom ist es nicht ganz so einfach:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter(tsne);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Was macht denn DBSCAN aus dem Erzeugnis von t-SNE?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.cluster import DBSCAN\n",
    "\n",
    "db = DBSCAN(eps=5, min_samples=4).fit(tsne)\n",
    "def plot(data, labels):\n",
    "    fig, ax = plt.subplots(1, figsize=(10,10))\n",
    "    sns.scatterplot(data[:,0], data[:,1], hue=[\"Rauschen\" if x < 0 else \"Cluster {}\".format(x) for x in labels], ax=ax);\n",
    "    \n",
    "plot(tsne, db.labels_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Schauen wir mal, wie der Algorithmus mit unseren \"hochaufgelösten\" Bildern umgeht..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "train = pd.read_csv('./data/mnist/train.csv')\n",
    "target = train.label\n",
    "train = train.drop(\"label\",axis=1)\n",
    "m,n = train.shape\n",
    "print(f'Wir haben {m} Datenpunkte mit {n} Features')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Achtung:** Die folgende Zelle braucht ihre Zeit - auf meinem Rechner ca 45 Minuten. Hier stoßen wir an eine Grenze von Scikit-Learn - die Berechnungen erfolgen nur auf einem Kern."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%time tsne = TSNE(n_components=2, random_state=42).fit_transform(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter(tsne, np.asarray(target));"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter(tsne);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}