第三週--二值化與GLCM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 題目說明：\n",
    "下面的作法可以製造一個大小為4*4，而元素值介在0~4之間的np array，\n",
    "\n",
    "請複製下列程式碼，並依照題目說明對該array進行操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.random.randint(0, 5, size=(4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 1, 2, 0],\n",
       "       [1, 3, 0, 0],\n",
       "       [3, 3, 0, 2],\n",
       "       [0, 4, 4, 1]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第一題--二值化：\n",
    "\n",
    "二值化是我們在進行圖像處理時，時常使用的技巧。\n",
    "\n",
    "關鍵在於把本來擁有各種數值的矩陣，變成只有兩個值。\n",
    "\n",
    "（這樣會把彩色的圖變成黑白的噢，至於為什麼就請你自己查了ＸＤ）\n",
    "\n",
    "\n",
    "# 問題來了：\n",
    "\n",
    "請你把矩陣a裡面，大於0的值全部變成1，而0維持0。\n",
    "\n",
    "提示：可以使用之前教過的for迴圈跟if。\n",
    "\n",
    "進階：numpy有一個非常高明的技巧可以做到這個，\n",
    "\n",
    "請你練習google看看把它找出來。\n",
    "\n",
    "# 這可以用在哪裡：\n",
    "\n",
    "某些助教之前在做漢字字型的自動生成研究時，\n",
    "\n",
    "這是非常重要，可以改善結果的小技巧。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 解答一： for 迴圈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# 這裡做不做都沒關係，只是為了後面方便，所以把a用c複製下來。\n",
    "\n",
    "# 這裡不能直接用 c = a, 否則會因為numpy使用pointer賦值的關係，連a的數值一起動到。\n",
    "c = a.copy()\n",
    "\n",
    "# 正式開始\n",
    "for i in range(4):\n",
    "    for j in range(4):\n",
    "        if c[i][j] > 0:\n",
    "            c[i][j] = 1\n",
    "        else: \n",
    "            c[i][j] = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 1, 2, 0],\n",
       "       [1, 3, 0, 0],\n",
       "       [3, 3, 0, 2],\n",
       "       [0, 4, 4, 1]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [1, 1, 0, 1],\n",
       "       [0, 1, 1, 1]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 傳說中的大絕招： np.where\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "b = np.where(a>0, 1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [1, 1, 0, 1],\n",
       "       [0, 1, 1, 1]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 說明：\n",
    "\n",
    "這是numpy的一個小技巧。\n",
    "\n",
    "np.where這個函式的用法大致上是： np.where(condition, x, y)，\n",
    "\n",
    "滿足condition的部分會做x, 不滿足的會做y。\n",
    "\n",
    "缺點是使用時很容易不小心寫錯出bug，要多練習。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 進階挑戰第二題--GLCM：\n",
    "\n",
    "GLCM是一種非常特別的矩陣，\n",
    "\n",
    "在進行人工智慧的圖像辨識時，\n",
    "\n",
    "可以當作圖片的某種「特徵」來處理。\n",
    "\n",
    "做法大概是這樣的：\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 假裝你已經有了一個二值化的矩陣："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = np.random.randint(0, 2, size=(4, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 1],\n",
       "       [1, 1, 0, 0],\n",
       "       [1, 1, 0, 0],\n",
       "       [1, 0, 0, 0]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最基本的GLCM會把兩兩一組數字的出現頻率記錄下來。\n",
    "\n",
    "比如說(0, 0)在a矩陣出現的次數是6， (0, 1)是1， (1, 0)是3， (1, 1）是2，\n",
    "\n",
    "那a的GLCM就會長這樣： [6, 1, 3, 2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 問題來了：\n",
    "\n",
    "請你自己產生一個4*4的二值化矩陣，\n",
    "然後寫一個函式把他的GLCM顯示出來。\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 這可以幹嘛：\n",
    "\n",
    "某些助教前幾天好不容易搞定了一個用在研究上的進階GLCM寫法，\n",
    "\n",
    "做夢都會夢到的那種。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 解答一：陰魂不散的for迴圈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def GLCM(a):\n",
    "    output = np.zeros(shape=(4, ))\n",
    "    \n",
    "    #(i, j)直接寫(4, 3)也可以，只是使用shape可以處理大小不固定的矩陣。\n",
    "    # a.shape = [4, 4]\n",
    "    for i in range(a.shape[0]):\n",
    "        for j in range(a.shape[1]-1):\n",
    "            if [a[i][j], a[i][j+1]] == [0, 0]:\n",
    "                output[0] += 1\n",
    "            \n",
    "            elif [a[i][j], a[i][j+1]] == [0, 1]:\n",
    "                output[1] += 1\n",
    "            \n",
    "            elif [a[i][j], a[i][j+1]] == [1, 0]:\n",
    "                output[2] += 1\n",
    "            \n",
    "            elif [a[i][j], a[i][j+1]] == [1, 1]:\n",
    "                output[3] += 1\n",
    "                \n",
    "    print (output)\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6.  1.  3.  2.]\n"
     ]
    }
   ],
   "source": [
    "GLCM(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#  解答二--黃助教的神乎其技：\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def GLCM_ultra(a):\n",
    "    output = np.zeros(shape=(4, ))\n",
    "    \n",
    "    \n",
    "    # 這裡的關鍵在於，比起到時候一個一個慢慢比，不如直接把a分成兩個矩陣，\n",
    "    # 用numpy的矩陣運算一起比然後加起來。\n",
    "    b = a[:, :-1]\n",
    "    c = a[:, 1:]\n",
    "    \n",
    "    #之後的作法就是用邏輯的方式，來做出前面用if做的事情：\n",
    "    #比如說 （b, c) == (1, 1) 之類的\n",
    "    \n",
    "    #一些邏輯:\n",
    "    # a and b = a*b\n",
    "    # a or b = a+b - a*b\n",
    "    # not a = 1 - a\n",
    "    \n",
    "    one = np.ones(shape=(a.shape[0], a.shape[1]-1))\n",
    "    not_b = one - b\n",
    "    not_c = one - c\n",
    "    \n",
    "    # not_b*not_c之類的，是整個矩陣的運算結果，出來也是矩陣\n",
    "    # 可是output[0]，或說我們要的，是一個一個的值，\n",
    "    # 所以要用np.sum這個函式加起來。\n",
    "    \n",
    "    # (0, 0)\n",
    "    # (not b) and (not c)\n",
    "    output[0] = np.sum(not_b*not_c)\n",
    "    \n",
    "    #(0, 1)\n",
    "    # (not a) and b\n",
    "    output[1] = np.sum(not_b*c)\n",
    "    \n",
    "    #(1, 0)\n",
    "    # a and (not b)\n",
    "    output[2] = np.sum(b*not_c)\n",
    "    \n",
    "    #(1, 1)\n",
    "    # a and b\n",
    "    output[3] = np.sum(b*c)\n",
    "    \n",
    "    print(output)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 6.  1.  3.  2.]\n"
     ]
    }
   ],
   "source": [
    "GLCM_ultra(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 看起來一樣，對嗎？\n",
    "\n",
    "# 那為什麼要寫得這麼複雜呢？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "因為numpy有個很重要的特色是「平行化運算」，\n",
    "\n",
    "用for迴圈要算好幾百次的東西，用numpy的特殊寫法可以「一次」就算完。\n",
    "\n",
    "上面寫法的特色，就在於都是「整個矩陣」地在處理，\n",
    "\n",
    "會比用for迴圈一個元素一個元素慢慢比快很多。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 用一個大一點的矩陣來比看看速度："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a_ultra = np.random.randint(0, 2, size=(256, 256))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 16543.  16290.  16293.  16154.]\n",
      "\n",
      "花費時間：  0.356550931930542ms\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "\n",
    "start = time.time()\n",
    "GLCM(a_ultra)\n",
    "end = time.time()\n",
    "\n",
    "print()\n",
    "print(\"花費時間： \", str(end-start)+\"ms\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 16543.  16290.  16293.  16154.]\n",
      "\n",
      "花費時間：  0.01167917251586914ms\n"
     ]
    }
   ],
   "source": [
    "start = time.time()\n",
    "GLCM_ultra(a_ultra)\n",
    "end = time.time()\n",
    "\n",
    "print()\n",
    "print(\"花費時間： \", str(end-start)+\"ms\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 想想看，如果這是全台灣人的資料形成的，超級大矩陣。\n",
    "\n",
    "# 平行化之後會快多少？"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "當然，這樣寫很花時間，去記住並理解這些特殊的解法也不是一朝一夕的事情，\n",
    "\n",
    "所以你不需要硬去背這些。\n",
    "\n",
    "現在你只要會寫基礎的解答一，然後大概知道有解答二這樣的寫法，\n",
    "\n",
    "等你長大到需要使用解答二的方法的時候，去google一下就可以了。"
   ]
  },
  {
   "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.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}