Chapter05 - Baby steps with neural networks (perceptrons and backpropagation)/01. Tensorflow và các kiến thức cơ bản.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Nội dung kiến thức\n",
    "1. Giới thiệu về Tensorflow\n",
    "2. Các đối tượng trong Tensor<br/>\n",
    "    2.1 constant <br/>\n",
    "    2.2 Variable<br/>\n",
    "    2.3 placeholder<br/>\n",
    "    2.4 Các tensor đặc biệt <br/>\n",
    "    2.5 Các toán tử <br/>\n",
    "3. Graph <br/>\n",
    "    3.1 Cách tạo một Graph <br/>\n",
    "    3.2 Tensorboard <br/>\n",
    "4. Lady Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Giới thiệu về Tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.1 Tensorflow là gì"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Tensorflow</b> là một thư viện mã nguồn mở dùng để xử lí cách phép tính toán số học bằng cách mô tả một mô hình biểu đồ thể hiện sự thay đổi về giá trị của dữ liệu. Đây là một thư viện toán học được sử dụng nhiều trong các ứng dụng của học máy chẳng hạn như xây dựng các mạng nơ ron, các thuật toán phân loại kNN (k-Nearest Neighbor), SVM (Support Vector Machine),.... <br/>\n",
    "Tiền thân của Tensorflow là DistBelief - dự án về hệ thống học máy của Google Brain được phát triển vào năm 2011. Tensorflow là dự án thứ 2, được phát hành dưới dạng mã nguồn mở vào 09/11/2015."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>Một số project nổi tiếng sử dụng Tensorflow:</b>\n",
    "* <i>Phân loại ung thư da</i> – Dermatologist-level classification of skin cancer with deep neural networks (Esteva et al., Nature 2017)\n",
    "* <i>WaveNet</i>: Text to speech – Wavenet: A generative model for raw audio (Oord et al., 2016)\n",
    "* <i>Vẽ hình</i> – Draw Together with a Neural Network (Ha et al., 2017)\n",
    "* <i>Image Style Transfer Using Convolutional Neural Networks</i> (Gatys et al., 2016) Tensorflow adaptation by Cameroon Smith (cysmith@github)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Khi tôi viết bài viết này thì phiên bản hiện tại của Tensorflow là 2.0.0. Phiên bản v1 và v2 của Tensorflow khá khác nhau. Trong các bài viết này, tôi sẽ hướng dẫn các bạn phiên bản v1 trước và sau đó tiến tới v2 để các bạn có cái nhìn tổng quan nhất về sự khác nhau giữa 2 phiên bản. Để cài đặt tensorflow, các bạn có thể xem hướng dẫn tại trang chủ https://www.tensorflow.org/ . Các bạn nên cài tensorflow bản mới nhất, và cài trên GPU nếu như máy bạn có hỗ trợ GPU. Phiên bản v2 của tensorflow có thể implement v1 bằng cách sử dụng dòng lệnh sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From c:\\program files\\python37\\lib\\site-packages\\tensorflow_core\\python\\compat\\v2_compat.py:65: disable_resource_variables (from tensorflow.python.ops.variable_scope) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "non-resource variables are not supported in the long term\n"
     ]
    }
   ],
   "source": [
    "import tensorflow.compat.v1 as tf\n",
    "tf.disable_v2_behavior()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Để kiểm tra phiên bản Tensorflow đang sử dụng, ta làm như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.0.0'"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.2 Đặc trưng của tensorflow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorFlow = tensor + flow = data + flow => luồng của các dữ liệu."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensorflow là luồng của dữ liệu được thể hiện qua một đồ thị tính toán. Khi xây dựng một model tensorflow chúng ta thường tách biệt 2 phần riêng rẽ đó là:\n",
    "1. <i>Xây dựng, định nghĩa đồ thị</i>: Một đồ thị sẽ bao gồm các node và các cạnh. Node của đồ thị sẽ thể hiện chức năng tính toán (chẳng hạn phép cộng, trừ, nhân, chia,...) và cách cạnh thể hiện dữ liệu tính toán, thường là các dữ liệu nhiều chiều hay còn gọi là tensor được kết nối với nhau thông qua các node.\n",
    "2. <i>Sử dụng Session để thực thi tính toán trên đồ thị</i>: Đồ thị tính toán mà ta có mới chỉ là một bản thiết kế của mô hình. Chúng ta cần chạy bản thiết kế đó bằng cách kích hoạt một session để thực thi các operation của đồ thị. Các thực thi này sẽ cần được truyền dữ liệu đầu vào để làm nguyên liệu trả về kết quả ở đầu ra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/tensors_flowing.gif\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.3 Giới thiệu về tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Đơn vị dữ liệu chính của Tensorflow là những Tensor và Tensorflow là dòng chảy của những Tensor.\n",
    "Một Tensor bao gồm một tập hợp các giá trị nguyên thủy (integer, float, string, ..) cấu thành nên một tập hợp không giới hạn số chiều."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rank của một Tensor là số chiều của nó\n",
    "* Shape là một bộ (tuple) của các số biểu diễn số lượng phần tử có trong mỗi chiều."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ví dụ:\n",
    "* 3.0 : Tensor với rank là 0, nói cách khác là 1 Scalar (scalar)\n",
    "* [1., 2., 3.]: Tensor với rank là 1, là một vector có shape là [3] (vector)\n",
    "* [[1., 2., 3.], [4., 5., 6.]]: Tensor với rank là 2, là một ma trận có shape là [2, 3] (matrix)\n",
    "* [[[1., 2., 3.]], [[7., 8., 9.]]]: Tensor với rank là 3 với shape là [2, 1, 3] (N-tensor)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Các đối tượng trong tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 constant (Hằng số)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Là giá trị cố định trong tensorflow được khởi tạo thông qua hàm `tf.constant()`. Chúng ta sẽ không thể thay đổi được giá trị của một hằng số."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensor(\"x_1:0\", shape=(2,), dtype=int32)\n",
      "Tensor(\"Const_6:0\", shape=(2, 2), dtype=int32)\n",
      "Tensor(\"Const_7:0\", shape=(), dtype=float32)\n",
      "Rank của x là: Tensor(\"Rank:0\", shape=(), dtype=int32)\n",
      "Rank của y là: Tensor(\"Rank_1:0\", shape=(), dtype=int32)\n",
      "Rank của z là: Tensor(\"Rank_2:0\", shape=(), dtype=int32)\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([2, 2], name='x')\n",
    "y = tf.constant([[0, 1],[2, 3]])\n",
    "z = tf.constant(9, dtype=tf.float32)\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta nhận thấy, mặc dù đã khởi tạo các giá trị cho x, y, z nhưng khi hiển thị thì giá trị của chúng đều là 0. Đó là vì chúng ta mới chỉ tạo ra đồ thị gồm oprerator x, y, z nhưng vẫn chưa thực thi đồ thị đó. Do đó, chúng vẫn giữ giá trị mặc định là 0. Khi thực thi đô thị, chúng ta cần tạo ra một session để run operator nhằm kích hoạt luồng xử lý. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n",
      "[[0 1]\n",
      " [2 3]]\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    print(sess.run(x))\n",
    "    print(sess.run(y))\n",
    "    print(sess.run(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hoặc có thể triển khai code như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n",
      "[[0 1]\n",
      " [2 3]]\n",
      "9.0\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "print(sess.run(x))\n",
    "print(sess.run(y))\n",
    "print(sess.run(z))\n",
    "sess.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra có thể sử dụng lệnh `eval()` để đánh giá các node trong đồ thị. Nhưng phải truyền sess sẽ thực thi vào."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "sess = tf.Session()\n",
    "print(x.eval(session=sess))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta cũng có thể tạo session mặc định để thực thi thì không cần truyền tham số nữa."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.as_default()\n",
    "    print(y.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra ta có thể sử dụng lệnh `tf.InteractiveSession()` để tạo ra một session trong trạng thái mặc định (luôn được sử dụng) để đánh giá đồ thị."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.0"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tf.InteractiveSession()\n",
    "z.eval()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vẫn là ví dụ trên, ta thấy, ở trên tôi có dùng 3 cách khác nhau để khai báo 3 constant x, y, z. Với cách 1, ta có thể đặt tên cho tensor x, tức là tên này sẽ hiện là 1 node trên đồ thị tensorflow (phần sau chúng ta sẽ tìm hiểu graph). Với cách 2 thì khai báo constant là một ma trận và mặc định tên, mặc định kiểu dữ liệu. Với cách 3, tôi khai báo một constant là interger nhưng ép kiểu về float32."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong tensorflow, chúng ta có một số kiểu dữ liệu (`dtype`) thông dụng như sau:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/dtype.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nguồn: https://www.tensorflow.org/api_docs/python/tf/dtypes/DType"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra, chúng ta thấy có một tham số nữa là `shape` cho ta biết số chiều của tensor đó. Để lấy shape của một tensor, ta có thể làm như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2,)\n"
     ]
    }
   ],
   "source": [
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "print(y.get_shape())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2.2 Variable (Biến)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trái ngược với hằng. Biến là là giá thay đổi trong một đồ thị. Thông thường trong mạng nơ ron thì biến chính là ma trận hệ số của hàm loss function. Biến sẽ luôn có giá trị khởi tạo ban đầu để kích hoạt thuật toán gradient. Để tạo ra một variable trong tensorflow ta sử dụng hàm `tf.Variable()` hoặc `tf.get_variable()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# tạo biến với tf.Variable()\n",
    "s = tf.Variable(2, name=\"scalar\")\n",
    "m = tf.Variable([[0, 1], [2, 3]], name=\"matrix\")\n",
    "\n",
    "# tạo biến với tf.get_variable()\n",
    "s = tf.get_variable(\"scalar\", initializer=tf.constant(2))\n",
    "m = tf.get_variable(\"matrix\", initializer=tf.constant([[0, 1],[2, 3]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bạn có để ý thấy rằng, hằng số trong Tensorflow khai báo là tf.<font color=\"red\">c</font>onstant (Viết thường), nhưng biến lại là tf.<font color=\"red\">V</font>ariable (Viết hoa) không? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bởi vì tf.constant là một operator, còn tf.Variable là một class với nhiều opearator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<tf.Variable 'scalar_1:0' shape=() dtype=int32_ref>\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bạn thấy đấy, bên trên chúng ta đã khai báo biến s nhưng khi ta gọi đến, nó không hề mang giá trị khởi tạo mà chúng ta đã gán cho nó. Các biến sau khi khởi tạo nếu muốn được sử dụng sẽ cần được kích hoạt thông qua session bằng lệnh `tf.global_variables_initializer()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, array([[0, 1],\n",
      "       [2, 3]])]\n"
     ]
    }
   ],
   "source": [
    "# Khởi tạo tất cả trong 1 lần\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    print(sess.run([s, m]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong trường hợp chỉ muốn khởi tạo các biến trong danh sách cụ thể, ta có thể dùng hàm `tf.variables_initializer()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    sess.run(tf.variables_initializer([m]))\n",
    "    print(sess.run(m))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chúng ta có thể ghi một giá trị vào một biến sử dụng `tf.Variable.assign()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "W = tf.Variable(10)\n",
    "W.assign(100)\n",
    "with tf.Session() as sess:\n",
    "    sess.run(W.initializer)\n",
    "    print(W.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tại sao giá trị lại là 10 mà không phải là 100? W.assign(100) không ghi giá trị 100 và W, nhưng thay vào đó tạo một opearator assign để làm điều đó. Nhưng operator này phải chạy run session."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "W = tf.Variable(10)\n",
    "assign_op = W.assign(100)\n",
    "with tf.Session() as sess:\n",
    "    sess.run(assign_op)\n",
    "    print(W.eval())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lưu ý rằng, chúng ta không phải khởi tạo W trong trường hợp này vì <b>assign</b> đã thực hiện khởi tạo. Trong thực tế, opeator khởi tạo là một opearator gán, gán giá trị của biến cho chính nó."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra chúng ta còn có các phương thức `tf.Variable.assign_add()` và `tf.Variable.assign_sub()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "18\n"
     ]
    }
   ],
   "source": [
    "W = tf.Variable(10)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    sess.run(W.initializer)\n",
    "    print(sess.run(W.assign_add(10))) # >> 20\n",
    "    print(sess.run(W.assign_sub(2)))  # >> 18"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vì các Session Tensorflow duy trì các giá trị riêng biệt, mỗi Session có thể có giá trị hiện tại của riêng nó cho một biến được xác định trong graph."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n",
      "8\n",
      "120\n",
      "-42\n"
     ]
    }
   ],
   "source": [
    "W = tf.Variable(10)\n",
    "sess1 = tf.Session()\n",
    "sess2 = tf.Session()\n",
    "\n",
    "sess1.run(W.initializer)\n",
    "sess2.run(W.initializer)\n",
    "\n",
    "print(sess1.run(W.assign_add(10)))\t\t# >> 20\n",
    "print(sess2.run(W.assign_sub(2)))\t\t# >> 8\n",
    "\n",
    "print(sess1.run(W.assign_add(100)))\t\t# >> 120\n",
    "print(sess2.run(W.assign_sub(50)))\t\t# >> -42\n",
    "\n",
    "sess1.close()\n",
    "sess2.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 placeholder"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Là các biến mà giá trị ban đầu không được khởi tạo trong lúc tạo graph mà được truyền vào từ như tập data input để chạy một mô hình. Chẳng hạn một mô hình được xây dựng dựa trên một bộ dữ liệu có thể được sử dụng lại cho nhiều bộ dữ liệu khác có cùng đặc điểm. Khi đó giá trị mà ta cần truyền vào mô hình chính là các placeholder. Đồ thị của mô hình có thể được giữ nguyên (số lớp, số lượng đơn vị trong từng lớp, kích thước đầu vào, đầu ra,...) ta thu được các hệ số mới. Hàm số để khởi tạo placeholder là `tf.placeholder(dtype, shape)`. Giả sử bên dưới ta khởi tạo một placeholder a có kích thước 3x1. Chúng ta cần tính phép cộng a với một vector hằng số b kích thước 3x1. Ta làm như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = tf.placeholder(tf.float32, shape=[3])\n",
    "b = tf.constant([5, 5, 5], tf.float32)\n",
    "c = a + b\n",
    "# Lưu ý là a và b phải cùng kiểu dữ liệu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Khi đó một operation c được khởi tạo bằng với phép cộng a và b. Một điều ta dễ nhận thấy đó là giá trị của a không được khởi tạo mặc định như đối với kiểu biến thông thường (`tf.Variable()`) mà chỉ khi ta kích hoạt đồ thị tại operation c thì chúng ta mới truyền vào giá trị của a thông qua tham số `feed_dict` có dạng của một dictionary trong python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6. 7. 8.]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    print(sess.run(c, feed_dict = {a: [1, 2, 3]}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Khi ta cần thay một bộ dữ liệu khác thì chúng ta sẽ thay đổi giá trị của a trong feed_dict. Kết quả đầu ra sẽ thay đổi nhưng kích thước của ma trận đầu ra không thay đổi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8. 7. 6.]\n"
     ]
    }
   ],
   "source": [
    "with tf.Session() as sess:\n",
    "    print(sess.run(c, feed_dict = {a: [3, 2, 1]}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 Các tensor đặc biệt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cũng giống như numpy, tensor sẽ có những kiểu ma trận đặc biệt để giúp khởi tạo tensor nhanh hơn bao gồm: ma trận 0, ma trận 1, ma trận đơn vị, ma trận ngẫu nhiên,...."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.1 zeros tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`tf.zeros(shape = shape, dtype = dtype)` với dtype là kiểu biến và shape là kích thước của tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0. 0.]\n",
      "  [0. 0.]\n",
      "  [0. 0.]]\n",
      "\n",
      " [[0. 0.]\n",
      "  [0. 0.]\n",
      "  [0. 0.]]]\n"
     ]
    }
   ],
   "source": [
    "t_zeros = tf.zeros([2, 3, 2],tf.float32)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(t_zeros))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hoặc ta có thể tạo một zero tensor có kích thước bằng với một tensor cho trước thông qua hàm `tf.zeros_like(original_tensor)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[0 0]\n",
      "  [0 0]]\n",
      "\n",
      " [[0 0]\n",
      "  [0 0]]]\n"
     ]
    }
   ],
   "source": [
    "t_origin = tf.constant([[[1, 2], \n",
    "                         [3, 4]],\n",
    "                        [[5, 6],\n",
    "                         [7, 8]]])\n",
    "t_zeros = tf.zeros_like(t_origin)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(t_zeros))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.2 one tensor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hoàn toàn tương tự như zeros tensor, one tensor cũng có cú pháp như sau: `tf.ones(shape = shape, dtype = dtype)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor ones:[[[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]\n",
      "\n",
      " [[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]]\n",
      "\n",
      "tensor ones like:[[[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]\n",
      "\n",
      " [[1. 1.]\n",
      "  [1. 1.]\n",
      "  [1. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "t_ones = tf.ones([2, 3, 2],tf.float32)\n",
    "t_ones_like = tf.ones_like(t_ones)\n",
    "with tf.Session() as sess:\n",
    "    print('tensor ones:' + str(sess.run(t_ones)) + '\\n')\n",
    "    print('tensor ones like:' + str(sess.run(t_ones_like)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.3 Tensor đơn vị"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensor đơn vị sẽ có các phần tử là một ma trận đơn vị và được khởi tạo thông qua hàm:<br/>\n",
    "`\n",
    "tf.eye(\n",
    "    num_rows,\n",
    "    num_columns=None,\n",
    "    batch_shape=None,\n",
    "    dtype=tf.float32,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "Trong đó num_rows, num_columns lần lượt là số dòng và số cột, batch_shape là kích thước của tensor theo batch. Nếu batch_shape = [3, 3] thì tensor sẽ bao gồm 3 dòng và 3 cột trong đó một phần tử ứng với 1 dòng và 1 cột là một ma trận kích thước num_rows x num_columns. dtype là kiểu biến và name là tên của node. Kích thước của tensor khi biểu diễn đến từng phần tử của ma trận là [batch_shape, num_rows, num_columns]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1. 0. 0.]\n",
      "  [0. 1. 0.]\n",
      "  [0. 0. 1.]]]\n"
     ]
    }
   ],
   "source": [
    "t_eye = tf.eye(3, 3, [1], tf.float32)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(t_eye))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4.4 Tensor ngẫu nhiên"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Là tensor có các phần tử được tạo ra một cách ngẫu nhiên. Thông thường là phân phối `gaussian` với kì vọng và phương sai xác định. Hàm `tf.random_normal()` sẽ được sử dụng để tạo ra một tensor ngẫu nhiên có cú pháp: <br/>\n",
    "`\n",
    "tf.random_normal(\n",
    "    shape,\n",
    "    mean=0.0,\n",
    "    stddev=1.0,\n",
    "    dtype=tf.float32,\n",
    "    seed=None,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "Trong đó shape là kích thước của tensor, mean là trung bình, stddev là độ lệch chuẩn, giá trị seed là 1 số nguyên dương sẽ qui định lần chạy lại sau sẽ đưa ra kết quả như lần chạy trước. Mặc định của seed là các kết quả mỗi lần chạy sẽ không tái lập."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 8.609219   7.4252176 11.138338 ]\n",
      " [11.717785  10.369919  11.3175335]]\n"
     ]
    }
   ],
   "source": [
    "t_random = tf.random_normal([2, 3], mean = 9, stddev = 2)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(t_random))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ngoài ra ta còn có `tf.random_poisson()` sử dụng cho phân phối poisson và `tf.random_uniform()` sử dụng cho phân phối đều. Có cú pháp lần lượt là:<br/>\n",
    "`\n",
    "tf.random_poisson(\n",
    "    lam, #tham số đặc trưng xác định phân phối poisson\n",
    "    shape, #kích thước của tensor\n",
    "    dtype=tf.float32,\n",
    "    seed=None,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "và <br/>\n",
    "<br/>\n",
    "`\n",
    "tf.random_uniform(\n",
    "    shape, #kích thước của tensor\n",
    "    minval=0, #giá trị nhỏ nhất\n",
    "    maxval=None, #giá trị lớn nhất\n",
    "    dtype=tf.float32,\n",
    "    seed=None,\n",
    "    name=None\n",
    ")`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[2., 5., 1.],\n",
      "       [0., 3., 3.]], dtype=float32), array([[0.00673008, 0.40893292, 1.2881598 ],\n",
      "       [1.545161  , 0.7918601 , 0.09829569]], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "t_rand_pois = tf.random_poisson(lam = 2, shape = [2, 3])\n",
    "t_rand_unif = tf.random_uniform(shape = [2, 3], minval = 0, maxval = 2)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([t_rand_pois, t_rand_unif]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tham khảo thêm:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/dacbiet.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.5 Các toán tử"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.1 Phép cộng/trừ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Được thực hiện qua hàm `tf.add()` như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, -1]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant(1)\n",
    "y = tf.constant(2)\n",
    "z = tf.add(x, y)\n",
    "t = tf.add(x, -y)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([z, t]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.2 Phép nhân"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Được thực hiện qua hàm `tf.multiply()` như sau:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant(3)\n",
    "y = tf.constant(2)\n",
    "z = tf.multiply(x, y)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.3 Phép nhân ma trận"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sử dụng hàm `tf.matmul()` có cú pháp như sau:\n",
    "<br/>\n",
    "`\n",
    "tf.matmul(\n",
    "    a,\n",
    "    b,\n",
    "    transpose_a=False,\n",
    "    transpose_b=False,\n",
    "    adjoint_a=False,\n",
    "    adjoint_b=False,\n",
    "    a_is_sparse=False,\n",
    "    b_is_sparse=False,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "Trong đó a, b lần lượt là các tensor bên trái và tensor bên phải. <br/>\n",
    "Lưu ý là trong trường hợp tensor 2D thì số cột của a phải bằng số dòng của b; trường hợp tensor 3D thì kích thước của a phải bằng kích thước của b khi chuyển vị của 2 chiều cuối cùng. Các tham số transpose_a, transpose_b khi được thiệt lập True (mặc định False) lần lượt có ý nghĩa có chuyển vị trước khi nhân hay không. Các tham số a_is_sparse, b_is_sparse = True lần lượt có ý nghĩa coi a, b như là các biểu diễn của ma trận sparse (ma trận thưa) hay không (mặc định là không). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ví dụ với trường hợp tensor 2D:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 56.  62.  68.  74.]\n",
      " [152. 174. 196. 218.]\n",
      " [248. 286. 324. 362.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "x = tf.constant(np.arange(12), shape=[3, 4], dtype=tf.float32)\n",
    "y = tf.constant(np.arange(16), shape=[4,4], dtype=tf.float32)\n",
    "z = tf.matmul(x,y)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Ví dụ với trường hợp tensor 3D:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[ 120.  130.  140.  150.]\n",
      "  [ 320.  355.  390.  425.]\n",
      "  [ 520.  580.  640.  700.]\n",
      "  [ 720.  805.  890.  975.]]\n",
      "\n",
      " [[3120. 3230. 3340. 3450.]\n",
      "  [3820. 3955. 4090. 4225.]\n",
      "  [4520. 4680. 4840. 5000.]\n",
      "  [5220. 5405. 5590. 5775.]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = tf.constant(np.arange(40), shape=[2, 4, 5], dtype=tf.float32)\n",
    "y = tf.constant(np.arange(40), shape=[2, 5, 4], dtype=tf.float32)\n",
    "z = tf.matmul(x, y)\n",
    "\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.4 Tính trung bình"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Để tính trung bình của một tensor ta sẽ sử dụng hàm `tf.reduce_mean()`:\n",
    "<br/>\n",
    "`\n",
    "tf.reduce_mean(\n",
    "    input_tensor,\n",
    "    axis=None,\n",
    "    keepdims=None,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "input_tensor là tensor cần tính trung bình. axis là chiều cần tính trung bình. Nếu axis = None thì mặc định tính trung bình của toàn bộ các phần tử của tensor mà không xét đến chiều. Nếu tính trung bình theo một chiều nào đó thì số chiều của kết quả đầu ra sẽ giảm đi 1 do theo chiều đó tensor đều có 1 phần tử đại diện. keepdims = True có tác dụng giữ nguyên số chiều so với input__tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, array([[[4, 5, 6]]])]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])\n",
    "y = tf.reduce_mean(x)\n",
    "z = tf.reduce_mean(x, axis = 1, keepdims = True)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y, z]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.5 Min/Max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tương tự như cách tính trung bình. Ta sẽ sử dụng hàm `tf.reduce_min()` hoặc `tf.reduce_max()` có cú pháp lần lượt:\n",
    "<br/>\n",
    "`\n",
    "tf.reduce_max(\n",
    "    input_tensor,\n",
    "    axis=None,\n",
    "    keepdims=None,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "`\n",
    "tf.reduce_max(\n",
    "    input_tensor,\n",
    "    axis=None,\n",
    "    keepdims=None,\n",
    "    name=None\n",
    ")\n",
    "`\n",
    "<br/>\n",
    "Kết quả trả về sẽ là giá trị min hoặc max theo các chiều."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, array([[[1, 2, 3]]])]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]])\n",
    "y = tf.reduce_min(x)\n",
    "z = tf.reduce_min(x, axis = 1, keepdims = True)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y, z]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.5 Hàm exponential"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hàm mũ cơ số tự nhiên được sử dụng phổ biến trong học máy chẳng hạn như trong hồi qui logistic, hàm softmax, .... Chúng ta sẽ sử dụng hàm `tf.exp()` để tính giá trị của cơ số mũ đối với 1 tensor. Kết quả trả về là một tensor chứa các phần tử là lũy thừa cơ số tự nhiên ( e ) của phần tử tương ứng trên tensor gốc. Cú pháp của hàm đơn giản như sau:\n",
    "<br/>\n",
    "`tf.exp(x, name=None)`\n",
    "<br/>\n",
    "Lưu ý rằng x là tensor có kiểu định dạng nằm trong các kiếu half, float32, float64, complex64, complex128"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[[2.7182817e+00, 7.3890562e+00, 2.0085537e+01],\n",
      "        [5.4598152e+01, 1.4841316e+02, 4.0342880e+02],\n",
      "        [1.0966332e+03, 2.9809580e+03, 8.1030840e+03]]], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[[1, 2, 3], [4, 5, 6], [7, 8, 9]]], dtype = tf.float32)\n",
    "y = tf.exp(x)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.6 Hàm ReLu"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hàm relu có công thức là  `y=max(0,x)` . Đây là một hàm activation được sử dụng khá phổ biến trong các mô hình học máy trong những năm gần đây để thay thế cho hàm sigmoid bởi đạo hàm của nó tồn tại hầu khắp nơi (trừ điểm 0) và khi  x>0  đạo hàm chỉ nhận giá trị là 1 nên sẽ tiết kiệm chi phí tính toán đồng thồi không bị triệt tiêu. Trong khi hạn chế của đạo hàm sigmoid đó là mỗi lần  x  thay đổi sẽ phải tính lại đạo hàm và sẽ bị triệt tiêu khi giá trị của  x  vô cùng lớn hoặc vô cùng nhỏ. Chúng ta có thể sử dụng hàm `tf.nn.relu()` để tính giá trị relu của một tensor."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([[[1., 0., 3.],\n",
      "        [4., 5., 0.],\n",
      "        [7., 0., 9.]]], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([[[1, -2, 3], [4, 5, -6], [7, -8, 9]]], dtype = tf.float32)\n",
    "y = tf.nn.relu(x)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.7 Hàm Softmax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Được sử dụng để ước lượng xác xuất xảy ra của một class. Chẳng hạn chúng ta có bài toán phân loại $C$ class. Sau khi thiết lập mạng nơ ron ta tính được layer cuối cùng là vector $z∈R^C$ . Khi đó giá trị của hàm softmax ứng với class  i  sẽ là:\n",
    "\n",
    "$$a_i=\\frac{exp(z_i)}{∑_{j=1}^C exp(z_j)},  ∀i=1,2,…,C$$\n",
    " \n",
    "Một tính chất ta dễ nhận thấy là tổng các giá trị softmax của toàn bộ các class phải bằng 1.\n",
    "<br/>\n",
    "softmax có thể được tính toán thông qua hàm `tf.nn.softmax()` với cú pháp:\n",
    "<br/>\n",
    "`tf.nn.softmax(logits, dim=-1, name=None)`\n",
    "<br/>\n",
    "Trong đó logits là một tensor có các kiểu biến half, float32, float64."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[array([5.7628046e-04, 5.7628046e-04, 1.5664927e-03, 4.2581689e-03,\n",
      "       1.1574903e-02, 3.1463847e-02, 8.5527599e-02, 2.3248814e-01,\n",
      "       6.3196826e-01], dtype=float32)]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 1, 2, 3, 4, 5, 6, 7, 8], dtype = tf.float32)\n",
    "y = tf.nn.softmax(x)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kiểm tra tổng giá trị softmax trả về:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 1, 2, 3, 4, 5, 6, 7, 8], dtype = tf.float32)\n",
    "y = tf.nn.softmax(x)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run(tf.reduce_sum(y)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5.8 Argument min/max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hàm này sẽ trả về số thứ tự tương ứng theo một chiều nào đó trong một tensor có giá trị là lớn nhất hoặc nhỏ nhất. Cú pháp:\n",
    "<br/>\n",
    "`tf.argmax(input, axis=None, name=None, dimension=None)`\n",
    "<br/>\n",
    "`tf.argmin(input, axis=None, name=None, dimension=None)`\n",
    "<br/>\n",
    "trong đó input là tensor và axis là chiều để tính argmax hoặc argmin. Trường hợp thông thường được áp dụng là vector (tensor-1D)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 1]\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant([1, 9, 0, 2, 3, 4, 5, 6, 7, 8], dtype = tf.float32)\n",
    "y = tf.argmin(x)\n",
    "z = tf.argmax(x)\n",
    "with tf.Session() as sess:\n",
    "    print(sess.run([y, z]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tham khảo thêm:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/operator.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Như đã giới thiệu bên trên, tensorflow hoạt động dựa trên sự hình thành các đồ thị tính toán. Sau đó, khởi chạy các đồ thị này."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong Tensorflow, một Graph cấu thành bởi 2 thành phần chính:\n",
    "1. <i>tf.Operation</i>: Là các node của Graph. Operation mô tả sự tính toán để tạo ra các tensor. Các toán tử này có thể là Const Hằng số, Variable Biến số, Add Phép cộng, Mul Phép nhân...\n",
    "2. <i>tf.Tensor</i>: Là các cạnh của Graph. Chúng biểu diễn các giá trị dữ liệu xuyên suốt đồ thị. Hầu hết các hàm của Tensorflow đều trả lại tf.Tensors. Trong thế giới của Tensorflow, mọi kiểu dữ liệu đều được quy về một mối được gọi là Tensor hay trong Tensorflow, tất cả các loại dữ liệu đều là Tensor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tại Sao TF Sử Dụng Graph?\n",
    "1. Tối ưu trong tính toán. Cho phép chỉ tính toán các node cần để có được giá trị bạn muốn\n",
    "2. Chia bài toán thành các module nhỏ, giúp graph nhận biết module nào cần cho bài toán\n",
    "3. Tính toán phân tán, song song trên nhiều CPU, TPU, GPU hoặc trên nhiều máy\n",
    "4. Nhiều mô hình máy học sử dụng graph để học và biểu diễn(visualize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.1 Cách tạo một graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Chúng ta có 2 cách chính để tạo ra một graph đó là thông qua hàm tf.Graph() hoặc `tf.get_default_graph()`.\n",
    "<br/>\n",
    "Khi gọi hàm `tf.get_default_graph()` thì một graph mặc định luôn được tạo ra. Khi đó để thêm một phần tử operation mới vào graph mặc định ta chỉ cần khởi tạo operation. Chẳng hạn như bên dưới ta sẽ tạo ra một operation và kiểm tra xem operation này có phải là một thành phần của graph mặc định hay không."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is one part of default graph\n"
     ]
    }
   ],
   "source": [
    "x = tf.constant(5)\n",
    "if x.graph is tf.get_default_graph():\n",
    "    print('x is one part of default graph')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kết quả cho thấy một operation khi được tạo ra luông là một phần của graph mặc định. <br/>\n",
    "\n",
    "Khi khởi tạo một graph từ hàm `tf.Graph()` thì graph đó không mặc định. Do đó để thêm một operation vào graph thì ta phải chuyển graph vừa khởi tạo sang mặc định bằng hàm `as_default()` và tạo các operation trong graph đó."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is one part of default graph\n"
     ]
    }
   ],
   "source": [
    "g = tf.Graph()\n",
    "with g.as_default():\n",
    "    x = tf.constant(5)\n",
    "    if x.graph is g:\n",
    "        print('x is one part of default graph')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3.2 Tensorboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tensorboard làm một công cụ giúp ta hiển thị, theo dõi và quản lý các đồ thị từ một luồng xử lý dữ liệu tensorflow."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trong tensorboard có một vài hàm quan trọng có chức năng như sau:\n",
    "\n",
    "* `tf.summary.scalar`: Được gắn vào các nodes để lưu lại các giá trị của learning rate và loss sau mỗi lần xử lý.\n",
    "\n",
    "* `tf.summary.histogram`: Vẽ biểu đồ histogram phân phối của các trọng số và gradients từ một layer cụ thể.\n",
    "\n",
    "* `tf.summary.merge_all`: Sát nhập các thống kê của toàn bộ các nodes trong graph vào một bản thống kê dữ liệu chung.\n",
    "\n",
    "* `tf.summary.FileWriter`: Lưu toàn bộ các thống kê của đồ thị vào ổ đĩa.\n",
    "\n",
    "Chúng ta sẽ quan tâm đến hàm `tf.summary.FileWriter()` nhất bởi hàm này cho phép ta lưu và đọc một graph trên tensorboard. `tf.summary.FileWriter()` có cú pháp như sau: <br/>\n",
    "\n",
    "`tf.summary.FileWriter(folder directory, graph)`\n",
    "<br/>\n",
    "Trong đó folder directory là địa chỉ của thư mục mà ta sẽ lưu đồ thị. graph là đồ thị cần lưu vào disk. Lưu ý đồ thị này luôn phải để mặc định để có thể thêm các phần operation vào trong nó.\n",
    "\n",
    "Bên dưới chúng ta tạo ra một graph mặc định và lưu vào ổ đĩa ở folder cùng thư mục cha với file hiện hành có tên là `first_graph_logs`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(2, name = 'x_variabel')\n",
    "y = tf.Variable(4, name = 'y_variabel')\n",
    "z = tf.multiply(x, y)\n",
    "\n",
    "#Khởi tạo một writer để lưu graph mặc định vào ổ đĩa\n",
    "writer = tf.summary.FileWriter('first_graph_logs', tf.get_default_graph())\n",
    "with tf.Session() as sess:\n",
    "    #Khởi tạo toàn bộ các biến\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    #Thêm operation z vào graph mặc định\n",
    "    sess.run(z)\n",
    "#Đóng writer    \n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sau khi chạy chương trình trên một folder mới tên là `first_graph_logs` được tạo trong cùng thư mục với file hiện hành và lưu toàn bộ các kết quả xử lý và cấu trúc của graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "File sẽ được lưu lại dưới dạng một event file với format sau:<br/>\n",
    "`events.out.tfevents.{timestamp}.{hostname}`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Để đọc được graph này ta vào cửa số command line trỏ tới folder cha chứa file hiện hành và gõ lệnh:<br/>\n",
    "`tensorboard --logdir first_graph_logs`\n",
    "<br/>\n",
    "`--logdirs` là tên của tham số và giá trị phía sau là đường dẫn tới folder lưu trữ graph."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kết quả thu được như sau:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/tensorboard.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ta truy cập vào đường dẫn hiển thị trên console: http://localhost:6006/ sẽ xem được cấu trúc Graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Lady Loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lazy loading là khái niệm mô tả việc chỉ tạo đối tượng khi cần và tạo nó ngay trong session thay vì phải định nghĩa và thêm vào graph trước khi chạy."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ví dụ một chương trình thông thường:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(10, name='x')\n",
    "y = tf.Variable(20, name='y')\n",
    "z = tf.add(x, y)         # Tạo node trước khi thực thi graph\n",
    "writer = tf.summary.FileWriter('./graphs/normal_loading',\\\n",
    "                               tf.get_default_graph())\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    for _ in range(10):\n",
    "        sess.run(z)\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Còn đây là chương trình sử dụng lady loading:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = tf.Variable(10, name='x')\n",
    "y = tf.Variable(20, name='y')\n",
    "writer = tf.summary.FileWriter('./graphs/normal_loading',\\\n",
    "                               tf.get_default_graph())\n",
    "with tf.Session() as sess:\n",
    "    sess.run(tf.global_variables_initializer())\n",
    "    for _ in range(10):\n",
    "        sess.run(tf.add(x, y)) \n",
    "        # Không tạo node mà thực thi luôn phép cộng tại đây\n",
    "writer.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cả 2 đoạn code trên đều cho cùng một output. Tuy nhiên, nếu bạn định nghĩa trước thì hàm init đối tượng đó chỉ cần chạy một lần. Nhưng nếu sử dụng lazy loading, hàm init sẽ được gọi mỗi khi bạn sử dụng nó. Nếu bạn dùng lazy loading nhiều lần, chương trình của bạn sẽ chậm và tốn chi phí để thực thi. Bạn có thể xem biểu diễn của 2 chương trình trên TensorBoard."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorBoard của chương trình TF dùng lazy loading:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/ladyloading1.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "TensorBoard của chương trình TF không có lazy loading:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"./images/ladyloading2.png\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kết luận: Hạn chế sử dụng lazy loading."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Trên đây là các kiến thức cơ bản tổng quan về Tensorflow. Trong các bài viết tiếp theo, chúng ta sẽ cùng áp dụng tensorflow để giải quyết một vài bài toán đơn giản hoặc thiết lập một vài mô hình bằng tensorflow. Các bạn cần nắm vững các kiến thức cơ bản của bài này để có thể tiếp tục ở các bài sau."
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}