{
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "_cell_guid": "86b330f1-31e7-7218-f539-f423efa24a74"
      },
      "outputs": [],
      "source": [
        "import tensorflow as tf\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "testing_size = 2000\n",
        "\n",
        "epochs_completed = 0\n",
        "index_in_epoch = 0\n",
        "\n",
        "\n",
        "output = tf.placeholder(tf.float32, [None, 10])\n",
        "input = tf.placeholder(tf.float32, [None, 784])\n",
        "\n",
        "data = pd.read_csv(\"../input/train.csv\")\n",
        "\n",
        "imageset = data.iloc[:, 1:]\n",
        "labels_flat = data[[0]].values.ravel()\n",
        "\n",
        "\n",
        "def dense_to_one_hot(labels_dense, num_classes):\n",
        "    num_labels = labels_dense.shape[0]\n",
        "    index_offset = np.arange(num_labels) * num_classes\n",
        "    labels_one_hot = np.zeros((num_labels, num_classes))\n",
        "    labels_one_hot.flat[index_offset + labels_dense.ravel()] = 1\n",
        "    return labels_one_hot\n",
        "\n",
        "\n",
        "labels = dense_to_one_hot(labels_flat, np.unique(labels_flat).shape[0])\n",
        "\n",
        "validation_images = imageset[:testing_size]\n",
        "validation_labels = labels[:testing_size]\n",
        "\n",
        "train_images = imageset[testing_size:]\n",
        "train_labels = labels[testing_size:]\n",
        "\n",
        "num_examples = train_images.shape[0]\n",
        "\n",
        "# serve data by batches\n",
        "def next_batch(batch_size):\n",
        "    \n",
        "    global train_images\n",
        "    global train_labels\n",
        "    global index_in_epoch\n",
        "    global epochs_completed\n",
        "    \n",
        "    start = index_in_epoch\n",
        "    index_in_epoch += batch_size\n",
        "    \n",
        "    # when all trainig data have been already used, it is reorder randomly    \n",
        "    if index_in_epoch > num_examples:\n",
        "        # finished epoch\n",
        "        epochs_completed += 1\n",
        "        # shuffle the data\n",
        "        perm = np.arange(num_examples)\n",
        "        np.random.shuffle(perm)\n",
        "        train_images = train_images[perm]\n",
        "        train_labels = train_labels[perm]\n",
        "        # start next epoch\n",
        "        start = 0\n",
        "        index_in_epoch = batch_size\n",
        "        assert batch_size <= num_examples\n",
        "    end = index_in_epoch\n",
        "    return train_images[start:end], train_labels[start:end]\n",
        "\n",
        "\n",
        "#Define level one -\n",
        "\n",
        "weights_1_layer = tf.Variable(tf.random_normal([784, 500]))\n",
        "bias_1_layer = tf.Variable(tf.random_normal([ 500]))\n",
        "level_1_layer =  tf.nn.relu(tf.matmul(input,weights_1_layer) + bias_1_layer)\n",
        "\n",
        "weights_output = tf.Variable(tf.random_normal([500, 10]))\n",
        "bias_output = tf.Variable(tf.random_normal([ 10]))\n",
        "prediction = tf.matmul(level_1_layer,weights_output) + bias_output\n",
        "predict_onehot = tf.argmax(prediction,1)\n",
        "\n",
        "\n",
        "\n",
        "cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=output) )\n",
        "optimizer = tf.train.AdamOptimizer().minimize(cost)\n",
        "\n",
        "batch_size =100\n",
        "epochs = 10\n",
        "totalcost = 0\n",
        "count , _ = train_images.shape\n",
        "\n",
        "\n",
        "with tf.Session() as sess:\n",
        "\tsess.run(tf.global_variables_initializer())\n",
        "\tfor epoch in range(epochs):\n",
        "\t\tfor _ in range(int(count/batch_size)):\n",
        "\t\t\tx, y = next_batch(batch_size)\n",
        "\t\t\t_ , c = sess.run([optimizer,cost], feed_dict = {input: x, output: y })\n",
        "\t\t\ttotalcost += c\n",
        "\t\tprint('Executed Epoch - ', epoch ,'Total cost - ' , totalcost)\n",
        "\t\ttotalcost = 0\n",
        "\t\tindex_in_epoch = 0\n",
        "\t\tepochs_completed = 0\n",
        "\n",
        "\tcorrect = tf.equal(tf.argmax(prediction,1), tf.argmax(output,1))\n",
        "\taccuracy = tf.reduce_mean(tf.cast(correct, 'float'))\n",
        "\tprint('Accuracy:', accuracy.eval({input:validation_images, output:validation_labels}))\n",
        "\n",
        "\ttest_data = pd.read_csv('../input/test.csv')\n",
        "\tpredicted_lables = np.zeros(test_data.shape[0])\n",
        "\t\n",
        "\tfor i in range(int(test_data.shape[0]/batch_size)):\n",
        "\t\tx = test_data[i*batch_size : (i+1)*batch_size]\n",
        "\t\tpredicted_lables[i*batch_size : (i+1)*batch_size] = predict_onehot.eval(feed_dict = { input : x})\n",
        "\n",
        "\tnp.savetxt('sample_submission.csv', \n",
        "\t           np.c_[range(1,len(test_data)+1),predicted_lables], \n",
        "\t           delimiter=',', \n",
        "\t           header = 'ImageId,Label', \n",
        "\t           comments = '', \n",
        "\t           fmt='%d')"
      ]
    }
  ],
  "metadata": {
    "_change_revision": 0,
    "_is_fork": false,
    "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.6.0"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}