Sparse_Tensors.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Sparse Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import tensorflow as tf\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.date(2017, 7, 19)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "date.today()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "author = \"kyubyong. https://github.com/Kyubyong/tensorflow-exercises\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.2.1'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.13.1'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "sess = tf.InteractiveSession()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sparse Tensor Representation & Conversion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q1. Convert tensor x into a `SparseTensor`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SparseTensorValue(indices=array([[0, 0],\n",
      "       [1, 2]]), values=array([1, 2], dtype=int32), dense_shape=array([3, 4]))\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[1, 0, 0, 0],\n",
    "                 [0, 0, 2, 0],\n",
    "                 [0, 0, 0, 0]], dtype=tf.int32)\n",
    "sp = ...\n",
    "print(sp.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q2. Investigate the `dtype`, `indices`, `dense_shape` and `values` of the SparseTensor `sp` in Q1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dtype: <dtype: 'int32'>\n",
      "indices: [[0 0]\n",
      " [1 2]]\n",
      "dense_shape: [3 4]\n",
      "values: [1 2]\n"
     ]
    }
   ],
   "source": [
    "print(\"dtype:\", ...)\n",
    "print(\"indices:\", ...)\n",
    "print(\"dense_shape:\", ...)\n",
    "print(\"values:\", ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q3. Let's write a custom function that converts a SparseTensor to Tensor. Complete it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "SparseTensorValue(indices=array([[0, 0],\n",
      "       [1, 2]]), values=array([0, 1], dtype=int32), dense_shape=array([3, 4]))\n"
     ]
    }
   ],
   "source": [
    "def dense_to_sparse(tensor):\n",
    "    indices = tf.where(tf.not_equal(tensor, 0))\n",
    "    return tf.SparseTensor(indices=indices,\n",
    "                           values=...,  # for zero-based index\n",
    "                           dense_shape=tf.to_int64(tf.shape(tensor)))\n",
    "\n",
    "# Test\n",
    "print(dense_to_sparse(x).eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q4. Convert the SparseTensor `sp` to a Tensor using `tf.sparse_to_dense`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0]\n",
      " [0 0 2 0]\n",
      " [0 0 0 0]]\n",
      "Check if this is identical with x:\n",
      " [[1 0 0 0]\n",
      " [0 0 2 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "output = ...\n",
    "print(output.eval())\n",
    "print(\"Check if this is identical with x:\\n\", x.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Q5. Convert the SparseTensor `sp` to a Tensor using `tf.sparse_tensor_to_dense`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0 0]\n",
      " [0 0 2 0]\n",
      " [0 0 0 0]]\n",
      "Check if this is identical with x:\n",
      " [[1 0 0 0]\n",
      " [0 0 2 0]\n",
      " [0 0 0 0]]\n"
     ]
    }
   ],
   "source": [
    "output = ...\n",
    "print(output.eval())\n",
    "print(\"Check if this is identical with x:\\n\", x.eval())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}