perceptron.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_t(labels_path):\n",
    "    with open(labels_path) as f:\n",
    "        training_labels = [int(x) for x in f.read().splitlines()]\n",
    "    return np.array(training_labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_T_matrix(t):\n",
    "    # Labels matrix, each row representing one class, and the columns represent whether\n",
    "    # the image belongs to that class (row index) or not (-1, 1) \n",
    "    T = np.zeros((10, len(t)))\n",
    "    for i in range(len(T)):\n",
    "        T[i] = np.where(t == i, 1, -1)\n",
    "    return T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def initialize_weights_matrix():\n",
    "    # 10 weight vectors (classes), each one is all zeros except for the first feature.\n",
    "    weight_matrix =  np.zeros((785, 10))\n",
    "    weight_matrix[0] = np.ones(10)\n",
    "    return weight_matrix.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_confusion_matrix(x_delta, weights_matrix, true_labels):    \n",
    "    predictions = np.dot(x_delta, weights_matrix)\n",
    "    conf_matrix = np.zeros((10, 10))\n",
    "    for i, row in enumerate(predictions):\n",
    "        # The index (class) of the maximum value (most probable class)\n",
    "        prediction = np.where(row == row.max())[0][0]\n",
    "        true_value = true_labels[i]\n",
    "        conf_matrix[true_value][prediction] += 1\n",
    "\n",
    "    return conf_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_x_delta(folder_name, number_images):\n",
    "    x_input_points = np.zeros((0, 784))\n",
    "    for i in range(1, number_images + 1): # +1 Since it's exclusive\n",
    "        img_path = '{}/{}.jpg'.format(folder_name, i)\n",
    "        x_input_points = np.append(x_input_points, plt.imread(img_path).reshape(1, 784), axis=0)\n",
    "\n",
    "    return np.append(x_input_points, np.ones((x_input_points.shape[0], 1)), axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading in a separate cell to avoid multiple loads.\n",
    "x_delta = get_x_delta('Train', 2400)\n",
    "T = get_T_matrix(get_t('Train/Training Labels.txt'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train all learning rates for 500 epochs.\n",
    "learning_rates_powers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "resulting_weights = []\n",
    "\n",
    "for e_p in learning_rates_powers: # Eta Power \"e_p\"\n",
    "    w_m = initialize_weights_matrix()\n",
    "    for c in range(0,10): # Class \"c\"\n",
    "        for _ in range(0,500): # Iteration/Epoch\n",
    "            for i in range(0, 2400): # Image \"i\"\n",
    "                r = 1 if np.dot(w_m[c], x_delta[i]) >=0 else -1\n",
    "                if r != T[:,i][c]:\n",
    "                    # Update weight-vector if image \"i\" is misclassified\n",
    "                    w_m[c] += (10 ** (-1 * e_p)) * (np.multiply(x_delta[i], T[:,i][c]))\n",
    "    resulting_weights += [(e_p, w_m)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_delta_test = get_x_delta('Test', 200)\n",
    "test_true_labels = get_t('Test/Test Labels.txt')\n",
    "for eta_power, weights_matrix in resulting_weights:\n",
    "    confusion_matrix = get_confusion_matrix(x_delta_test, weights_matrix.T, test_true_labels)\n",
    "    plt.imshow(confusion_matrix)\n",
    "    plt.savefig('Confusion-{}.jpg'.format(eta_power))"
   ]
  }
 ],
 "metadata": {
  "file_extension": ".py",
  "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.5.2"
  },
  "mimetype": "text/x-python",
  "name": "python",
  "npconvert_exporter": "python",
  "pygments_lexer": "ipython3",
  "version": 3
 },
 "nbformat": 4,
 "nbformat_minor": 2
}