01. Intro to Tensorflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Intro to Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import numpy as np\n",
    "import mitdeeplearning as mdl\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'music' is a 0-d Tensor\n",
      "'depth' is a 0-d Tensor\n"
     ]
    }
   ],
   "source": [
    "# testing on 0-d tensor\n",
    "\n",
    "music = tf.constant(\"kpop\", tf.string)\n",
    "depth = tf.constant(11.24325, tf.float16)\n",
    "\n",
    "print(\"'music' is a {}-d Tensor\".format(tf.rank(music).numpy()))\n",
    "print(\"'depth' is a {}-d Tensor\".format(tf.rank(depth).numpy()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "'music' is a 1-d Tensor with shape:  tf.Tensor([2], shape=(1,), dtype=int32)\n",
      "'depth' is a 1-d Tensor with shape:  tf.Tensor([2], shape=(1,), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "# testing 1-d tensor\n",
    "music = tf.constant([\"kpop\", \"jrock\"], tf.string)\n",
    "depth = tf.constant([11.24325, 222.21412], tf.float16)\n",
    "\n",
    "print(\"'music' is a {}-d Tensor with shape: \".format(tf.rank(music).numpy()), tf.shape(music))\n",
    "print(\"'depth' is a {}-d Tensor with shape: \".format(tf.rank(depth).numpy()), tf.shape(depth))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# testing 2-d tensor\n",
    "\n",
    "matrix = tf.constant([[2,3],\n",
    "                    [3,5]])\n",
    "\n",
    "# test\n",
    "assert isinstance(matrix, tf.Tensor), \"matrix must be a tf Tensor object\"\n",
    "assert tf.rank(matrix).numpy() == 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''TODO: Define a 4-d Tensor.'''\n",
    "# Use tf.zeros to initialize a 4-d Tensor of zeros with size 10 x 256 x 256 x 3. \n",
    "#   You can think of this as 10 images where each image is RGB 256 x 256.\n",
    "images = tf.zeros([10, 256, 256, 3]) # [number_of_images, pixel_h, pixel_w, channels]\n",
    "\n",
    "assert isinstance(images, tf.Tensor), \"matrix must be a tf Tensor object\"\n",
    "assert tf.rank(images).numpy() == 4, \"matrix must be of rank 4\"\n",
    "assert tf.shape(images).numpy().tolist() == [10, 256, 256, 3], \"matrix is incorrect shape\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "TensorShape([10, 256, 256, 3])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "images.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "row vector: [3 5]\n",
      "column vector: [2 3]\n",
      "scalar: 5\n"
     ]
    }
   ],
   "source": [
    "row_vector = matrix[1]\n",
    "column_vector = matrix[:,0]\n",
    "scalar = matrix[1,1]\n",
    "\n",
    "print(\"row vector: {}\".format(row_vector.numpy()))\n",
    "print(\"column vector: {}\".format(column_vector.numpy()))\n",
    "print(\"scalar: {}\".format(scalar.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Computation on Tensors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(76, shape=(), dtype=int32)\n",
      "tf.Tensor(76, shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "a = tf.constant(15)\n",
    "b = tf.constant(61)\n",
    "\n",
    "# addition\n",
    "c1 = tf.add(a,b)\n",
    "c2 = a + b\n",
    "print(c1)\n",
    "print(c2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# constract simple computation\n",
    "\n",
    "def func(a,b):\n",
    "    c = tf.add(tf.multiply(a,b), tf.subtract(b, a))\n",
    "    d = tf.multiply(tf.add(c, a), tf.multiply(b, c))\n",
    "    return d\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor(1007616660000.0, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "a, b = 45.9, 771.2\n",
    "\n",
    "d_out = func(a, b)\n",
    "print(d_out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Neural Network in Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]\n"
     ]
    }
   ],
   "source": [
    "print(tf.config.list_physical_devices('GPU'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2697296 0.4574668 0.6653726]]\n"
     ]
    },
    {
     "ename": "AssertionError",
     "evalue": "\nArrays are not almost equal to 7 decimals\n[FAIL] output is of incorrect value. expected [[0.2697296 0.4574668 0.6653726]] but got [[0.2697859  0.45750418 0.66536945]]\nMismatched elements: 3 / 3 (100%)\nMax absolute difference: 5.6296587e-05\nMax relative difference: 0.00020867\n x: array([[0.2697296, 0.4574668, 0.6653726]], dtype=float32)\n y: array([[0.2697859, 0.4575042, 0.6653695]], dtype=float32)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32ms:\\( F I X E D   P R O J E C T )\\004. Learning\\001. Intro to Deep Learning\\01. Intro to Tensorflow.ipynb Cell 15\u001b[0m in \u001b[0;36m<cell line: 23>\u001b[1;34m()\u001b[0m\n\u001b[0;32m     <a href='vscode-notebook-cell:/s%3A/%28%20F%20I%20X%20E%20D%20%20%20P%20R%20O%20J%20E%20C%20T%20%29/004.%20Learning/001.%20Intro%20to%20Deep%20Learning/01.%20Intro%20to%20Tensorflow.ipynb#ch0000014?line=19'>20</a>\u001b[0m y \u001b[39m=\u001b[39m layer\u001b[39m.\u001b[39mcall(x_input)\n\u001b[0;32m     <a href='vscode-notebook-cell:/s%3A/%28%20F%20I%20X%20E%20D%20%20%20P%20R%20O%20J%20E%20C%20T%20%29/004.%20Learning/001.%20Intro%20to%20Deep%20Learning/01.%20Intro%20to%20Tensorflow.ipynb#ch0000014?line=21'>22</a>\u001b[0m \u001b[39mprint\u001b[39m(y\u001b[39m.\u001b[39mnumpy())\n\u001b[1;32m---> <a href='vscode-notebook-cell:/s%3A/%28%20F%20I%20X%20E%20D%20%20%20P%20R%20O%20J%20E%20C%20T%20%29/004.%20Learning/001.%20Intro%20to%20Deep%20Learning/01.%20Intro%20to%20Tensorflow.ipynb#ch0000014?line=22'>23</a>\u001b[0m mdl\u001b[39m.\u001b[39;49mlab1\u001b[39m.\u001b[39;49mtest_custom_dense_layer_output(y)\n",
      "File \u001b[1;32mc:\\Users\\zakis\\anaconda3\\envs\\tf1\\lib\\site-packages\\mitdeeplearning\\lab1.py:85\u001b[0m, in \u001b[0;36mtest_custom_dense_layer_output\u001b[1;34m(y)\u001b[0m\n\u001b[0;32m     83\u001b[0m true_y \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[\u001b[39m0.2697859\u001b[39m,  \u001b[39m0.45750418\u001b[39m, \u001b[39m0.66536945\u001b[39m]],dtype\u001b[39m=\u001b[39m\u001b[39m'\u001b[39m\u001b[39mfloat32\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m     84\u001b[0m \u001b[39massert\u001b[39;00m tf\u001b[39m.\u001b[39mshape(y)\u001b[39m.\u001b[39mnumpy()\u001b[39m.\u001b[39mtolist() \u001b[39m==\u001b[39m \u001b[39mlist\u001b[39m(true_y\u001b[39m.\u001b[39mshape), \u001b[39m\"\u001b[39m\u001b[39m[FAIL] output is of incorrect shape. expected \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m but got \u001b[39m\u001b[39m{}\u001b[39;00m\u001b[39m\"\u001b[39m\u001b[39m.\u001b[39mformat(true_y\u001b[39m.\u001b[39mshape, y\u001b[39m.\u001b[39mnumpy()\u001b[39m.\u001b[39mshape)\n\u001b[1;32m---> 85\u001b[0m np\u001b[39m.\u001b[39;49mtesting\u001b[39m.\u001b[39;49massert_almost_equal(y\u001b[39m.\u001b[39;49mnumpy(), true_y, decimal\u001b[39m=\u001b[39;49m\u001b[39m7\u001b[39;49m, err_msg\u001b[39m=\u001b[39;49m\u001b[39m\"\u001b[39;49m\u001b[39m[FAIL] output is of incorrect value. expected \u001b[39;49m\u001b[39m{}\u001b[39;49;00m\u001b[39m but got \u001b[39;49m\u001b[39m{}\u001b[39;49;00m\u001b[39m\"\u001b[39;49m\u001b[39m.\u001b[39;49mformat(y\u001b[39m.\u001b[39;49mnumpy(), true_y), verbose\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n\u001b[0;32m     86\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39m[PASS] test_custom_dense_layer_output\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[0;32m     87\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mTrue\u001b[39;00m\n",
      "    \u001b[1;31m[... skipping hidden 2 frame]\u001b[0m\n",
      "File \u001b[1;32mc:\\Users\\zakis\\anaconda3\\envs\\tf1\\lib\\site-packages\\numpy\\testing\\_private\\utils.py:844\u001b[0m, in \u001b[0;36massert_array_compare\u001b[1;34m(comparison, x, y, err_msg, verbose, header, precision, equal_nan, equal_inf)\u001b[0m\n\u001b[0;32m    840\u001b[0m         err_msg \u001b[39m+\u001b[39m\u001b[39m=\u001b[39m \u001b[39m'\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m'\u001b[39m \u001b[39m+\u001b[39m \u001b[39m'\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39m'\u001b[39m\u001b[39m.\u001b[39mjoin(remarks)\n\u001b[0;32m    841\u001b[0m         msg \u001b[39m=\u001b[39m build_err_msg([ox, oy], err_msg,\n\u001b[0;32m    842\u001b[0m                             verbose\u001b[39m=\u001b[39mverbose, header\u001b[39m=\u001b[39mheader,\n\u001b[0;32m    843\u001b[0m                             names\u001b[39m=\u001b[39m(\u001b[39m'\u001b[39m\u001b[39mx\u001b[39m\u001b[39m'\u001b[39m, \u001b[39m'\u001b[39m\u001b[39my\u001b[39m\u001b[39m'\u001b[39m), precision\u001b[39m=\u001b[39mprecision)\n\u001b[1;32m--> 844\u001b[0m         \u001b[39mraise\u001b[39;00m \u001b[39mAssertionError\u001b[39;00m(msg)\n\u001b[0;32m    845\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mValueError\u001b[39;00m:\n\u001b[0;32m    846\u001b[0m     \u001b[39mimport\u001b[39;00m \u001b[39mtraceback\u001b[39;00m\n",
      "\u001b[1;31mAssertionError\u001b[0m: \nArrays are not almost equal to 7 decimals\n[FAIL] output is of incorrect value. expected [[0.2697296 0.4574668 0.6653726]] but got [[0.2697859  0.45750418 0.66536945]]\nMismatched elements: 3 / 3 (100%)\nMax absolute difference: 5.6296587e-05\nMax relative difference: 0.00020867\n x: array([[0.2697296, 0.4574668, 0.6653726]], dtype=float32)\n y: array([[0.2697859, 0.4575042, 0.6653695]], dtype=float32)"
     ]
    }
   ],
   "source": [
    "class ourDenseLayer(tf.keras.layers.Layer):\n",
    "    def __init__(self, n_output_nodes):\n",
    "        super(ourDenseLayer, self).__init__()\n",
    "        self.n_output_nodes = n_output_nodes\n",
    "    \n",
    "    def build(self, input_shape):\n",
    "        d = int(input_shape[-1])\n",
    "        self.weight = self.add_weight(\"weight\", shape=[d, self.n_output_nodes])\n",
    "        self.bias = self.add_weight(\"bias\", shape=[1, self.n_output_nodes])\n",
    "\n",
    "    def call(self, x):\n",
    "        z = tf.add(tf.matmul(x, self.weight), self.bias)\n",
    "        y = tf.sigmoid(z)\n",
    "        return y\n",
    "\n",
    "tf.random.set_seed(1)\n",
    "layer = ourDenseLayer(3)\n",
    "layer.build((1,2))\n",
    "x_input = tf.constant([[1,2.]], shape=(1,2))\n",
    "y = layer.call(x_input)\n",
    "\n",
    "print(y.numpy())\n",
    "mdl.lab1.test_custom_dense_layer_output(y) # only differ from 0.0000*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# defining NN using sequential API\n",
    "\n",
    "from tensorflow.keras import Sequential\n",
    "from tensorflow.keras.layers import Dense\n",
    "\n",
    "n_output_nodes = 3\n",
    "model = Sequential()\n",
    "\n",
    "\n",
    "dense_layer = Dense(n_output_nodes, activation='sigmoid', use_bias=True)\n",
    "model.add(dense_layer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:5 out of the last 5 calls to <function Model.make_predict_function.<locals>.predict_function at 0x0000023CA0E7F490> triggered tf.function retracing. Tracing is expensive and the excessive number of tracings could be due to (1) creating @tf.function repeatedly in a loop, (2) passing tensors with different shapes, (3) passing Python objects instead of tensors. For (1), please define your @tf.function outside of the loop. For (2), @tf.function has reduce_retracing=True option that can avoid unnecessary retracing. For (3), please refer to https://www.tensorflow.org/guide/function#controlling_retracing and https://www.tensorflow.org/api_docs/python/tf/function for  more details.\n",
      "1/1 [==============================] - 0s 39ms/step\n",
      "[[0.9139073  0.32680833 0.83922404]]\n"
     ]
    }
   ],
   "source": [
    "x_input = tf.constant([[1,2.]], shape=(1,2))\n",
    "\n",
    "model_output = model.predict(x_input)\n",
    "print(model_output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Dense\n",
    "\n",
    "class SubClassModel(tf.keras.Model):\n",
    "    def __init__(self, n_output_nodes):\n",
    "        super(SubClassModel, self).__init__()\n",
    "        self.dense_layer = Dense(n_output_nodes, activation='sigmoid', use_bias=True)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        return self.dense_layer(inputs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tf.Tensor([[0.25837278 0.49682617 0.449808  ]], shape=(1, 3), dtype=float32)\n"
     ]
    }
   ],
   "source": [
    "n_output_nodes = 3\n",
    "model = SubClassModel(n_output_nodes)\n",
    "x_input = tf.constant([[1,2.]], shape=(1,2))\n",
    "print(model.call(x_input))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define model using subclassing and specifying custom behavior\n",
    "\n",
    "from tensorflow.keras import Model\n",
    "from tensorflow.keras.layers import Dense\n",
    "\n",
    "class Identity(tf.keras.Model):\n",
    "    def __init__(self, n_output_nodes):\n",
    "        super(Identity, self).__init__()\n",
    "        self.dense_layer = Dense(n_output_nodes, activation='sigmoid', use_bias=True)\n",
    "\n",
    "    def call(self, inputs):\n",
    "        x = self.dense_layer(inputs)\n",
    "        y = tf.identity(x)\n",
    "        return x, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network output with activation: 0.07463503628969193; network identity output: 0.7021217346191406\n"
     ]
    }
   ],
   "source": [
    "n_output_nodes = 3\n",
    "model = Identity(n_output_nodes)\n",
    "x_input = tf.constant([[1,2.]], shape=(1,2))\n",
    "\n",
    "output = model.call(x_input)\n",
    "out_activate = output[0][0]\n",
    "out_identity = output[0][-1]\n",
    "\n",
    "print(\"Network output with activation: {}; network identity output: {}\".format(out_activate.numpy(), out_identity.numpy()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Automatic Differentiation with Tensorflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "# let be y = x^2\n",
    "# x = 3.0\n",
    "\n",
    "x = tf.Variable(3.0)\n",
    "\n",
    "with tf.GradientTape() as tape:\n",
    "    y = x*x\n",
    "    dy_dx = tape.gradient(y, x)\n",
    "\n",
    "assert dy_dx.numpy() == 6.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initializing x: [1.7451856]\n"
     ]
    }
   ],
   "source": [
    "# function minimization with differentiation and SGD\n",
    "\n",
    "# x is a random value\n",
    "x = tf.Variable(tf.random.normal([1]))\n",
    "print(\"initializing x: {}\".format(x.numpy()))\n",
    "\n",
    "learning_rate = 1e-2\n",
    "history = []\n",
    "\n",
    "# target value\n",
    "x_f = 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'x value')"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i in range(500):\n",
    "  with tf.GradientTape() as tape:\n",
    "    '''TODO: define the loss as described above'''\n",
    "    loss =  (x-x_f)**2\n",
    "\n",
    "  # loss minimization using gradient tape\n",
    "  grad = tape.gradient(loss, x) # compute the derivative of the loss with respect to x\n",
    "  new_x = x - learning_rate*grad # sgd update\n",
    "  x.assign(new_x) # update the value of x\n",
    "  history.append(x.numpy()[0])\n",
    "\n",
    "# Plot the evolution of x as we optimize towards x_f!\n",
    "plt.plot(history)\n",
    "plt.plot([0, 500],[x_f,x_f])\n",
    "plt.legend(('Predicted', 'True'))\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('x value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.10.4 ('tf1')",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "e5d47089378e6e18d5e41b4ec5dc5221a0b09d5a84cf9a8c4af6a05ce24c8606"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}