Lab6_1. Softmax_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import tensorflow as tf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "tf.set_random_seed(7778)\n",
    "\n",
    "x_data = [[1, 2, 1, 1],\n",
    "          [2, 1, 3, 2],\n",
    "          [3, 1, 3, 4],\n",
    "          [4, 1, 5, 5],\n",
    "          [1, 7, 5, 5],\n",
    "          [1, 2, 5, 6],\n",
    "          [1, 6, 6, 6],\n",
    "          [1, 7, 7, 7]]\n",
    "y_data = [[0, 0, 1],\n",
    "          [0, 0, 1],\n",
    "          [0, 0, 1],\n",
    "          [0, 1, 0],\n",
    "          [0, 1, 0],\n",
    "          [0, 1, 0],\n",
    "          [1, 0, 0],\n",
    "          [1, 0, 0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "X = tf.placeholder(\"float\",[None,4])\n",
    "Y = tf.placeholder(\"float\",[None,3])\n",
    "nb_classes = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "W = tf.Variable(tf.random_normal([4, nb_classes]), name = 'weight')\n",
    "b = tf.Variable(tf.random_normal([nb_classes], name = 'bias'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "hypothesis = tf.nn.softmax(tf.matmul(X,W) + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Cross entropy cost/loss\n",
    "cost = tf.reduce_mean(-tf.reduce_sum(Y * tf.log(hypothesis), axis=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "optimizer = tf.train.GradientDescentOptimizer(learning_rate = 0.1).minimize(cost)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 8.49943\n",
      "200 0.650108\n",
      "400 0.539096\n",
      "600 0.444866\n",
      "800 0.353735\n",
      "1000 0.26595\n",
      "1200 0.227614\n",
      "1400 0.207002\n",
      "1600 0.189683\n",
      "1800 0.174935\n",
      "2000 0.162234\n",
      "~~~~~~~~~\n",
      "[[  1.34960944e-02   9.86500323e-01   3.49271681e-06]] [1]\n",
      "~~~~~~~~\n",
      "[[  3.54673446e-08   9.99765575e-01   2.34450577e-04]] [1]\n",
      "~~~~~~~~\n",
      "[[  7.55902472e-16   4.85275052e-07   9.99999523e-01]] [2]\n",
      "--------------\n",
      "[[  1.34961195e-02   9.86500323e-01   3.49271681e-06]\n",
      " [  3.54672096e-08   9.99765575e-01   2.34450126e-04]\n",
      " [  7.55902472e-16   4.85275052e-07   9.99999523e-01]] [1 1 2]\n"
     ]
    }
   ],
   "source": [
    "# Launch graph\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    for step in range(2001):\n",
    "        sess.run(optimizer, feed_dict = {X: x_data, Y: y_data})\n",
    "        if step %200 == 0:\n",
    "            print(step, sess.run(cost, feed_dict= {X: x_data, Y: y_data}))\n",
    "      \n",
    "    print(\"~~~~~~~~~\")\n",
    "    # Testing & One-hot encoding\n",
    "    a = sess.run(hypothesis, feed_dict = {X:[[1,10,7,9]]})\n",
    "    print(a, sess.run(tf.arg_max(a,1)))\n",
    "    \n",
    "    print(\"~~~~~~~~\")\n",
    "    \n",
    "    b = sess.run(hypothesis, feed_dict = {X:[[1,0,2,7]]})\n",
    "    print(b, sess.run(tf.arg_max(b,1)))\n",
    "    \n",
    "    print(\"~~~~~~~~\")\n",
    "    \n",
    "    c = sess.run(hypothesis, feed_dict = {X:[[3,2,0,1]]})\n",
    "    print(c, sess.run(tf.arg_max(c,1)))\n",
    "    \n",
    "    print('--------------')\n",
    "\n",
    "    all = sess.run(hypothesis, feed_dict={\n",
    "                   X: [[1,10,7,9], [1,0,2,7], [3,2,0,1]]})\n",
    "    print(all, sess.run(tf.arg_max(all, 1)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.6.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}