# 李宏毅
`test`
[Youtube課程，35堂](https://www.youtube.com/watch?v=CXgbekl66jc&list=PLJV_el3uVTsPy9oCRY30oBPNLCo89yu49&index=1)
[各種課的投影片網址](http://speech.ee.ntu.edu.tw/~tlkagk/courses.html)

## [0] 簡易流程
- 盡可能增加資料
- 做feature
1. 新增feature
2. 做feature engineering（多次項）
3. 做regularization
- 深化模型（模型選擇）
- 調整模型（先確認問題所在）
- Underfitting：連training data都fit不進去。
- 需要重新設計Model（並沒有包含到最好的那個function）
- 新增feature，讓他更複雜
- （collect更多data並沒有用）
- Overfitting：training可以，test data爆掉。
- 需要更多data讓他更穩定（或是根據我自己知道的規則去fake up一些假的，手寫辨識圖片，向左向右旋轉一下也符合真實情況，但可以視為新資料。影像辨識左右翻轉也可視為新資料，語音辨識使用變聲器或增加合成雜訊）
- 新增regularization到loss項使得曲線更平滑，那個$\lambda$項手動調整
- 畫圖：
- 把參數變化對Loss變化作圖（error surface），才知道方向和Lr是否正確

## [1] Introduction
- 人工智慧從1950年代就有，1980視機器學習只是一種手段，2010深度學習才開始，這堂課是2017年開的，當今坐在2019年的電腦前。
- 機器學習的原因：
- 本能賦予的是無法超越創造者的（使用成千上萬的"IF"判斷式），機器自己學習那些rule是比人設定的rule還要有效率僅此而已，無論是逐行條列或未來擴充。
- 機器自己去找到一個function，有個input有個output，從大量的input去自己找到內部的轉換過程。
- 作法：3步驟
- 訂出function set：準備成千上萬的function（從同一個model裡面延伸的），選擇哪種邏輯的function set，Linear，non-linear，deep-learning。
- 衡量function好壞：根據所有trainin data去分別測試每一個function的結果來打分數（Goodness of function）
- 有效率的挑選分數最好的function：是否有舉一舉一反三的學習功能
- 
- 課程地圖：（最高位階的是senario，比較無法控制的情境，不像是可以選擇的data，第二層是解的問題種類，我們如何把現實生活的問題重新塑造成機器可以的用武之地，第三層是使用的方法，不同情境仍可以相同方法）
- Supervised learning（label成本高）
- Regression：輸出一個數值（scalar）
- Linear
- Classification：Binary是非題（垃圾郵件與否），Multification選擇題（新聞分類）
- Deep learning
- SVM，decision Tree，K-NN
- Structure learning：具有結構性的output，語音辨識，語言翻譯，人臉辨識。（獵人的暗黑大陸，才是真的精髓所在，像是GAN對抗式生成）
- Semi-supervised learning：只有一點點的label資料
- Transfer learning：只有一點點的label資料，但是還有別的跟此任務沒關但是有label的資料，如何求得外援，或借用借用猩猩的脊椎骨來還原人類的血肉。
- Unsupervised learning
- Machine Drawing：給機器大量圖片，沒有input的情況下，要機器自已創作。
- Reinforce learning：Deepmind拿這個東西去玩一些小遊戲，還有AlphaGO。跟supervised的差別就是，透過每次的feedback來學習，這個feedback只有一個好壞的分數，你要自己去學習是哪邊扣了分或加了分，需要有一個對手，所以他自己跟自己下。（比較符合人類社會長大後的學習方式）。這個架構還包括當我們仍不知道reward可以設成什麼的時候，讓機器自己去學到底怎樣比較好。

## [2] 為什麼需要Machine Learning
- AI訓練師：幫不同的問題挑模型、Loss Function。
- 神奇寶貝訓練師要選擇相剋的屬性，而且神奇寶貝有時候也不一定聽話（小智的噴火龍），還有些複雜模型的最佳化比較困難，需要有經驗的AI訓練師輔助。

## [3] Regression：寶可夢案例研究
- 舉例：股票市場（明天道瓊指數），無人車（方向盤角度），推薦（狗買某商品的可能性），寶可夢（進化後的CP值）
- 寶可夢CP預測：$f(w,b)$，weight，bias
- X$^{上標}$：某個完整東西X裡面的編號。第一個input是$X^1$，第一個output是$\hat y^1$（hat表示是正確的值，一個input必須該有的output）。
- X$_{下標}$：某個完整東西X裡面的某個component。$X_{cp}$進化前CP值，$X_{s}$種類，$X_{w}重量$，$X_{h}$高度，$X_{hp}$血量。$y$進化後CP值。
- Loss function（$L$）：告訴我們某一個function有多不好。$L(f^n)=L(w,b)$。如：估測誤差平均（MAE）...（也可自訂）
- Gradient Descent：只要目標Loss可以微分GD就可以解。
- Gradient（$\nabla L$）：把所有參數對Loss的偏為分寫成向量（就這樣）。
- 偏微分（求導）：先隨機初始化，並且找到$\frac {dL}{dw}=0$的切線斜率
- $\eta$：如果是正的，要減少w值，負的增加w值。移動的效率稱為$\eta$（leanring rate），決定收斂速度。
- Convex：線性問題的Loss畫出來是凸面的（等高線只有一個圓圈），表示有最佳解。在比較複雜的模型比較會沒有找到global minimum（Linear沒有這個問題）。
- AdaGrad：讓不同參數使用不同learning rate
- 深化模型複雜度：
- 引入二次項，一樣用GD去優化...
- 引入三次項，一樣用GD去優化...
- 『注意』：training set上一定會越來越好，test set上就會出現overfitting（駕訓班過度訓練的奇怪技能）。
- 做regularization：在Loss function裡面加上一項懲罰係數膨脹的 $MSE+\lambda \sum(w_i)^2$。比較平滑的function，對輸入比較不敏感。$\lambda$需要自己手動調整

## [4] Regression：Demo
- 畫Cmap來輔助最後的圖
- AdaGrad不同參數不同learning rate

## [5] Where does error come from?
- 有可能來自 bias 或 Variance（會引導future work）
- Bias：對於training data而言越複雜的模型error下降，瞄別的地方，但是穩定度高
- Variance：對於test data而言，越複雜模型error上升，瞄得越準，但是手越抖
- 簡單Model：囊括function set範圍小，沒有包含到最佳函數$\hat f$所以bias大。但是範圍集中，受training data影響力小，分散程度小，variance小。
- 複雜Model：囊括function set範圍大，可能有包含到最佳函數$\hat f$所以bias小。但是範圍分散，受training data影響力大，分散程度大，variance大。
- 
- 模型好壞
- Underfitting：連training data都fit不進去。
- 需要重新設計Model（並沒有包含到最好的那個function）
- 新增feature，讓他更複雜
- （collect更多data並沒有用）
- Overfitting：training可以，test data爆掉。
- 需要更多data讓他更穩定（或是根據我自己知道的規則去fake up一些假的，手寫辨識圖片，向左向右旋轉一下也符合真實情況，但可以視為新資料。影像辨識左右翻轉也可視為新資料，語音辨識使用變聲器或增加合成雜訊）
- 新增regularization到loss項使得曲線更平滑，那個$\lambda$項手動調整
- 注意事項：可以切validation去挑model，再去public test set去試，但是這個結果如果不好，也不要想說再回頭去給model動手腳，因為真實世界是在private test set上面的，所以那個小部分的public set裡頭的bias不要太認真的考慮進去。（老師的建議）
- 通常都會使用Cross validation

## [6] Gradient Descent
- 優化：要minimize的叫做Loss，要maximize的叫做Objective func.
- Gradient：是一個向量，由每個參數對objective func.做偏微分的結果所排列組成，畫在座標平面上也是一個方向（是假想cmap等高線的髮線方向），update就是乘上負號相反，再乘上lr。
- 普遍GD的限制：有時候會卡在local minimum的地方（而且微分值為非常接近0的地方還包含saddle point）。
- 每一組update的參數，一定會使得Loss func.越來越小：微分的Taylor Series，整理到後來，要讓目標點乘gradient的內積最小，所以就是給一個負號，並且透過lr去控制scale（步伐）。不過lr要無窮夠小，假設的那個式子才會夠精確。
- Newton：這個是有考慮到二次微分的，但是整體而言的成本不划算。
- Learning Rate：慢慢調～可以做參數-Loss的變化，看看Loss下降的速度隨著epoch增加。調整的方式
- 靜態（fixed）：0.0001, 0.001, 0.01, 0.1, 1,...
- 動態（Adaptive）：
- 1/t Decay：$\eta ^t=\frac{\eta}{\sqrt{t+1}}$
- 不同參數不同lr：
- AdaGrad：使用上述的Decay lr，再讓每輪lr先除以過去這個參數所有過去微分值的RMS。整理一下$w^{t+1} \leftarrow w^t - \frac{\eta}{\sqrt{\sum^t_{i=0}(g^i)^2}}g^t$，這個參數到後面會update相當慢。
- 強調反差：反差萌，因為過去的平均是一種常態，當今的$g^t$是當今的。
- 原理：如果有很多個參數，那“斜率越大就距離最低點最遠”這東西就不成立，我們知道要跟1次微分成正比，並跟二次微分成反比。但2次微分計算比較沒有效率，所以就當作在1次微分曲線上面sample夠多點來代表二次微分的結果。
- Adam Optimizer：比較穩定（老師說的）
- SGD：Stochastic Gradient Descent，可以讓學習速度更快。一般的GD是把每筆data代進去所產生的loss加總再update，SGD是可依序可隨機的每代入每筆data，就update一次，步伐小，方向凌亂，但是在參數很多時這種隨機步伐小的效果不錯。
- Feature Scaling：
- 讓不同feature有相同的scaling（縮放比例），讓等高線呈現圓形
- 不然在update時步調不一致（會需要麻煩的分開lr），而且會針對等高線的髮線方向，不會直指最低點

## [7] AOE as example
- GD永遠不會知道自己是不是在global minimum裡面
- 

## [8] Minecraft as example
- 有時候使用GD時loss不減反增（多維度情況），向右/向前是低的，所以你向右前反而是高的。
- 

## [9] Classification：Probabilistic Generative Model
- 如果用Regression來代替binary分類的話，regression的loss會去懲罰那些“太過正確”的資料點，而去弄壞了decision boundary。所以要用專門的classification來做，且此外無法面對multiclass的問題
- Gaussian Distrubition
- 假設data是從一個Gaussian Distrubition裡面被sample出來的：input是feature vector，output是一個密度值（跟機率成正比，假設等於機率），如果出來結果大於或小於0.5當作界線。這邊也假設是2-D Gaussian，表示兩兩feature之間有關係。
- GD可表示成平均值（$\mu$）和共變異數矩陣（$\Sigma$）：假設每個feature都是從GD中被sample出來的。把一個沒見過的樣本x帶入一個GD的公式中就會有不同的機率密度值，越接近$\mu$的點的機率密度越大。
- 如何找$\mu$和$\Sigma$：使用Maximum Likelihood來找。各種類型的GD去sample出空間中任何點的機率都不會是0，只有Likelihood大小高低。我們要找到一組$\mu$和$\Sigma$使得，這個GD去sample出這組training data時的機率最大。$\mu^*, \Sigma^*=arg_{\mu, \Sigma}maxL(\mu, \Sigma)$
- $\mu^*$：$\frac1n \sum^{79}_{n=1}x^n$
- $\Sigma^*$：$\frac1n \sum^{79}_{n=1}(x^n-\mu^*)(x^n-\mu^*)^T$（就是平方的數學表示式）
- 以寶可夢的binary分類舉例：
- 共用cov-matrix：通常不同的class會share同一個covariance martix，比較穩定，也減少計算量（受feature size影響，越多也越容易overfitting）。$\Sigma=P(C_1)\Sigma^1+P(C_2)\Sigma^2$。在binary的情況，decision boundary反而會變成一條直線，因為最後簡化成$P(C_1|x)=\sigma(w*x+b)$... 但如果只是要找$w,b$何不直接找？（若為直接找，那就變成使用Gradient求Logistic Regression，屬於Discriminative Model了）
- 別的可能：
- Naive-Bayes：也可以假設是feature之間完全獨立的1-D Gaussian，那cov-matrix就會是對角的。通常bias太大...，是個baseline
- Bernoulli：若feature包含0/1，那就可能要假設從Bernoulli distribution中sample出來的
- Sigmoid Function
- 從後驗機率Posterior Prob延伸出來的，會介在0~1之間。可以說，後驗機率=Gaussian=Sigmoid的邏輯。

## [10] Logistic Regression
- Sigmoid Function
- 原理：先讓資料點透過線性回歸（$w,b$），再代入Sigmoid就是Losgistic Regression。given $x$他是屬於$C_1$的機率。不過要去優化的東西，是類別，正確得1分，錯誤得0分。
- 偏微分：$\sigma(z)'=\frac{\delta \sigma(z)}{\delta z}=\sigma(z)(1-\sigma(z))$，會介在0~0.25
- **『重要』綜合提點**：後驗機率的內部假設即是資料會從Gaussian Distribution中被sample出來，再經過整理和約分之後會直接變成，Sigmoid的公式，公式內部包含的z就是一組普通的linear regression，但公式的output會變成0~1之間的數字表示從某組$w,b$所展現的Gaussian被sample出來的可能性（而非線性回歸產生的任意值），整個運算可以稱為一個Neuron，神經網路就是無數個Neuron（有加上sigmoid的Perceptron）的不同深度廣度的排列，深度超過3層的稱為深度學習。
- 
- Logistic Regression
- 衡量 $Logistic(w,b)$ 的好壞：
- 先整理一下，要讓GD能產生所有這組training data的機率最大（相乘），取個log後則要讓結果最小，假設$C_1$為1，$C_2$為0，再用$\sum$重新整理後，會等於計算兩個Bernoulli Distrobution之間的Cross Entropy（兩個分佈的相似度公式，$H(p,p)=0$，資訊理論有教過）
- Objective Function：要讓我們假設的Bernoulli Distrobution和真實答案的Bernoulli Distrobution的Cross Entropy最小（分佈最接近）。
- 為何分類問題的Loss不用Square Error（跟線性一樣）：就在於$\hat y$的假設為0/1，而把Loss做完微分後的公式，會出現如果如果預測結果跟跟資料很近或很遠時，算出來的微分都為0，使得參數不再更新。（把整個Square error的參數變化對Loss的圖畫出來後，發現離最低點很近或很遠的都是平的，也就是低谷/高原的陷阱）
- Optimizer：一樣使用Gradient，微分化簡之後跟Linear再update時一樣
- Logistic vs. Linear
- Output：0~1之間的小數；任何可能的值
- Loss：正確答案為0/1目標是要讓兩個分佈的crossEntropy越小越接近；正確答案為任意數目標是要讓square error最小
- Update：兩者相同（3大影響要素）為lr大小、每個data的第i個component真實值、每筆預測值和真實值的差距加總。
- 
- 偷偷摸摸的技巧：先使用Least Square Error找到最佳解，再用那個點初始化$(w,b)$重跑Linear。（作弊...），此方法deep learning不適用，無法先看到global optimum
- Logistic的限制：decision boundary是線性的，如果資料是非線性的分類。
- Feature Transformation：找到規則，把舊的點投影到新的規則上面。但是這樣已經是人的智慧，不是人工智慧。
- 要讓機器自己做到Feature Transform，就把很多的Logistic接在一起就變深了，就是deep learning！（下一章節）

#### Discriminative vs Generative
- Logistic（判別模型）Gaussian（生成模型）：如果把covariance matrix共用，前兩者公式向同。

| | Discriminative（Logistic） | Generative （Gaussian） |
|:-----------------:|:---------------------------------------------------------------:|:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|
| 公式相同 | $P(C_1\|x)$ | $\sigma(w*x+b)$ |
| 找$w,b$ | Gradient直接硬找$w,b$ | 先算出$\mu^1, \mu^2, \Sigma^{-1}$ <br><br> $w^T = (\mu^1-\mu^2)^T*\Sigma^{-1}$ <br> $b=-\frac 12(\mu^1)^T(\Sigma^1)^{-1}\mu^1$ <br> $+ \frac 12(\mu^2)^T(\Sigma^2)^{-1}\mu^2$ <br> $+ln\frac{N_1}{N_2}$ |
| 相同function pool | 跟生成模型$w,b$不同 | 跟判別模型$w,b$不同 |
| 對Data的假設 | 沒有假設，沒有腦補 | 假設為 Gaussian, Bernoulli, Naive Bayes ... <br> 不需要真的看見有某種attribute的組合出現過 <br> 自行腦補真的有可能會出現某種組合，因為是分開算出現的機率相乘 |
| 優劣 | 受到Data量影響大，在資料量多時，準確度高 <br> 對Noise的敏感度高 | 受到Data量影響小，在資料量少時，腦補是有效的 <br> 對Noise的敏感度低 <br> 算式中的 $P(C_1)$和$P(x\|C_1)$可以參考來自不同的source <br> 如：語音辨識使用NN屬於判別模型，但是系統本身屬於生成模型 <br> 因為$P(C_1)$可以參考全世界的文字資料 <br> Class-depedent的$P(x\|C_1)$再參考語音資料即可 |

- Multi-class Classification：
- Softmax：有不同線性Class所產生的$\hat y$，對每個$y$取$exp(y)$（這個可以讓比較大的設值做強化），然後讓每個$exp(y)$除以所有$exp(y)$的總和（做normalization）。
- 特色：output會介在0~1之間（跟sigmoid一樣），加總會是1。作為用來估計Posterior Probability。假設每一個class是用dummy做的。
- 延伸：可以Google一個叫做Maximum Entropy，跟Logistic是一模一樣的東西（從另外的觀點來說明Classifier是SoftMax那樣）。
- Objective function：就是計算pred_y和true_y的CrossEntropy。【注意！底下公式Cross_Entropy少一個負號】

## [11] Deep Learning
- 歷史沿革：
- 1958：Perceptron（純linear Model），海軍project。
- 1969：Perceptron limitation（非線性問題）
- 1980：Multi-layer Perceptron。（跟當今DNN技術無所差異，當時又叫做Neural Network
- 1986：Backpropagation。Hinton。（受限於最多3層）
- 1989：1 hidden layer is good enough, why deep。（MLP整個臭掉，大家轉向使用SVM）
- 2006：RBM initialization。Hinton。（Restricted Boltzmann machine做$w,b$的初始化，有用的就叫做Deep Learning，換個名字改改運，非常複雜，不是NN-based，是graphical-based，...，不過最強的地方是重新喚起大家對deep learning的興趣，是石頭湯的故事。）
- 2009：GPU。（一週的東西縮短到幾個小時）
- 2011：Exceptionally good in speech recognition
- 2012：win ILSVRC image competition
- 2012：AlexNet。8 layer。錯誤率（16.4%）
- 2014：VGG。19 layer。錯誤率（7.3%）
- 2014：GoogleNet。22 layer。錯誤率（6.7%）
- 2015：Residual Net。152 layer。錯誤率（3.57%）。（Fully Connect是train不起來的，要用殘差網路）
- NN
- DNN（Fully connect Feedforward Network）：最傳統
- Input layer：data點
- Hidden layer：中間那些，負責extract feature取代手動的feature engineering/transformation
- Output layer：最後一層nn，如果做multi-class分類就會再加上softmax（強化大的同時縮放在0~1）
- Matrix Operation：數學表示式會排成矩陣形狀，然後用activation function（做非線性的轉換，如sigmoid）包住。
- 簡化：NN就是讓一個vector（乘以matrix再加一個vector，再通過activation，得到一個vector）的n次loop
- 悖論 tradeoff：
- 非deep learning：要找到很好的feature，做feature engineering
- deep learning：把問題變成要決定多少層，每層多少個。
- 傾向於不知道要怎們找到好的feature時（語音，影像辨識），人類懂的這些東西的知識過於內隱
- 但NLP進步量比較少（因為人類在辨識時，比較強，設立if清單的ad hoc很容易）
- 自動學習structure：Evolutionary Artificial NN，余天立，像是基因演算法可以。

## [12] Backpropagation
- 原則：跟linear的Gradient Descent是差不多幾乎一樣的。問題就在於參數環環相扣且有太多（語音辨識有7,8層，每層1000個的話，倆倆配對），Gradient會是一個上百萬維的vector，Backpropagation則是可以加速gradient計算的方法。
- 核心：Chain Rule兩條規則
- 
- 從頭可以用chain rule拆解成一個可以秒解的forward pass和一個要繼續拆解的值。這個值又要繼續拆解成一部分可以秒解的forward pass和一個要繼續拆解的值...。直到最後一項才解開，然後順著回去源頭把第一個解開。
- 統整：
- 先用正向的傳遞一次
- 再反向的建立一個neural network一路算回來就可以得到最前面的$w,b$對$L$的偏微分了
- 

## [13] Keras 1.0："Hello world" of deep learning
- TensorFlow or Theano：彈性大，不好學，尤其是Theano（ci-e-no）專門算微分的，用來給backpropagation
- Keras：作為TensorFlow的介面，作者在Google上班，未來可能作為TensorFlow官方的API。Keras在希臘文為牛角，預言一個夢精靈的故事，如果是通過象牙的門出現夢就不會實現，通過牛角做的門，夢就會實現。
- 實作：疊積木，把別人寫好的東西疊出來而已。
- batch_size：把trainin data隨機的切，然後每次只先加總一個batch的Loss量做參數更新，直到把所有batch都loop過才算一個epoch。每次再選batch都會隨機，使得參數更新不會陷入低端的local minimum
- 概念：跟SGD（batch_size=1）相同。
- 數量：主要要用mini batch的理由是因為實作上的issue，他可以在穩定度和速度中達到平衡。而同一個batch使用平行運算，但是GPU的平行運算有自己的數量限制，也不能太多
- Full-batch：容易找到local minimum，幾個epoch就卡住了。
- 提醒：如果沒有用 GPU 運算，那不會變快。或是裝GPU但沒設mini-batch
- nb_epoch：就是epoch number，但是參數update的次數還要乘以(data_size/batch_size)（更快）。
- 好處：可以Save/load model，可以直接算分數evaluate或predict就好

## [14] Keras （舊版）
- （略）

## [15] Keras 2.0 - 1

import numpy as np
from keras.models import Sequential
from keras.layers.core import Dense, Dropout, Activation
from keras.layers import Conv2D, MaxPooling2D, Flatten
from keras.optimizers import SGD, Adam
from keras.utils import np_utils
from keras.datasets import mnist

def load_data():
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    number = 10000
    x_train = x_train[0:number]
    y_train = y_train[0:number]
    x_train = x_train.reshape(number, 28*28)
    x_test = x_test.reshape(x_test.shape[0], 28*28)
    x_train = x_train.astype("float32")
    x_test = x_test.astype("float32")
    ## 把class轉成dummy
    y_train = np_utils.to_categorical(y_train, 10)
    y_test = np_utils.to_categorical(y_test, 10)
    x_train = x_train
    x_test = x_test
    # x_test = np.random.normal(x_test)
    x_train = x_train / 255
    x_test = x_test / 255
    return (x_train, y_train), (x_test, y_test)

(x_train, y_train), (x_test, y_test) = load_data()

model = Sequential()
model.add(Dense(input_dim = 28*28, units = 689, activation = "sigmoid"))
model.add(Dense(units = 689, activation = "sigmoid"))
model.add(Dense(units = 689, activation = "sigmoid"))
model.add(Dense(units = 10, activation = "softmax"))
model.compile(loss="mse", optimizer = Adam(lr=0.01), metrics=["accuracy"])
model.fit(x_train, y_train, batch_size = 100, epochs = 20)
score = model.evaluate(x_test, y_test)

print("Accuracy is {}" .format(score[1]))

## [16] Tips for Deep Learning
- CNN裡面的MaxPooling不能微分，畫在座標軸上沒有斜率這東西，$L_1reg$的問題。
- NN：不容易overfitting（不像別的演算法），他是連fit進去都有問題的，有時候再training set上面本來就不好了，tune完不能只看test set（別的演算法很容易在training set上拿滿分）。
- Underfitting（老師的定義）：model不夠複雜所產生的，但如果是參數量增加才train壞那不算
- 一個論文下來會瞄準解決training set上的問題或解決test set上的問題（overfitting）。
### 解決training set上的問題（小智噴火龍等級夠卻不願意好好聽話）
- 換Activation func：
- Sigmoid：在很深的網絡中會有梯度消失/爆炸問題，就是越靠近output層的參數的gradient比較大（受到sigmoid壓縮次數較少），update快一下子就收斂了，但前面幾乎還是在初始化的random狀態。（所以最早期RBM就是分層train參數做初始化再疊起來，前面沒update到也不要緊反正pretrain過）
- ReLU：Rectified Linear Unit，小於零讓他output零，大於零不變。計算更快速（不像sigmoid還有exp項），跟生物特徵比較像，像是無限多個sigmoid的bias疊加，解決梯度消失問題。他會使得正向參數傳遞變成線性，或者為零（忽略該neuron）。但是這些neuron有時候會傳東西出來有時候不會所以整體而言讓NN仍屬於非線性，因為他們的input會改變他們的operation region。而微分下去正的的傳1，負的就傳0，因為相信input不可能真的為0，所以那點不能微也不理他。
- LeakyReLU：把小於0的部分乘上0.01作為output，不歸0。
- Parametric ReLU：把小於0的部分乘上$\alpha$，也是一樣作為參數用GD來更新，每個activation都有自己的$\alpha$。
- Maxout：讓network自動學的activation function，跟MaxPooling很像，他就只是選定好特定數量neuron的output要為一組，選一個大的當代表。這個數量也是要手動調的。所以operation region會很彈性。
- 
- 使用Adaptive Learning Rate
- AdaGrad：讓不同的參數有不同的lr。Learning rate變成，原本的learning rate除上過去所有Gradient的值的開根號加總。但是遇到的問題，會讓他有時步伐大，有時步伐小，不是只有大反差而已，要更dynamic。
- Adam：由RMSProp和Momentum所組成，不過最後有做bias correction（這個值很小但是會越來越接近1）。
- RMSProp：Hinton線上課程提出的，但是沒有Paper就是。可以動態調整收斂效率的learning rate，跟AdaGrad差距的地方就是有一個$\alpha$來調整過去gradient的影響力曲線（是要讓過往的驟減快一點或慢一點，而不是像AdaGrad給過去每次的gradient一樣的權重），一樣是算Gradient的RMS但decay速度有差
- Momentum：引入慣性定律，讓球球可以搞定local minimum，低點時一樣再多走幾步看遠一點是不是有更低點。移動方向不再只有考慮gradient，而是“現在的gradient的反向乘上lr（新的方向），加上前一個時間點移動的方向乘以$\lambda$做加權（慣性方向）”。
- 不過其實他就是把過去的gradient加起來，然後每加一輪就乘上一個權重，讓前面decay。不過就是這個慣性的力量，讓你有機會可以跳出一個不太深的local minimum。
- 『額外提點』：其實要卡在local minimum, saddle point, plateau在複雜網絡之中是不容易的，yann LeCun在2007年說過local minimum前提是要在每個維度上面都要是local minimum，這機率要同時發生的話太小了，不過參考一下就好。
### 解決test set上的問題（overfitting）
- Early Stopping：假設learning rate正確，training set的loss逐漸變小的情況下，Model最好也是要停在一邊test set的最低值上面，也就是loss以test為主。此外，Early Stopping在有些地方也指當train下去loss下降的速度已經低於某個百分比時，就停止，可以加速epoch。
- Regularization：重新定義loss function。加上regularization項乘以1/2再乘以懲罰係數$\lambda$（自己調），然而所有參數$w$的集合$\theta$是不包括$b$，因為他不會影響function的平滑程度。，所以這招又叫做weight decay。
- $L_2-$Norm：每個參數平方加總，也就是先強化大參數再給予懲罰，而數學細節上就是每次在update的時候會偷偷的乘上0.99的感覺讓他越來越靠近0。對於原先就很大的參數可以下降的幅度很大，會保留很多接近0的值。
- $L_1-$Norm：每個參數取絕對值加總，數學細節上就是每次在update的時候會偷偷的讓他以加一/減一的方式靠近零0。結果可能會有很小很小的值，和還是很大很大的值，比較sparse，差異很大。
- 『補充比較』：通常在做參數initialization時會讓他小一點，然後越update離0越遠，early stopping也是防止他update次數增加，regularization則是偷偷乘上0.999也是相同效果。不過regularization在nn裡面並沒有SVM裡面效果來得大，SVM有可能一步就找到最好結果了（是要解convex optimization），沒有iteration，因此regularization要寫在Loss function裡面。
- Dropout：
- 作法：
- Training時：對NN裡面（除了output layer）做隨機sampling（p%被丟掉），此時結構會改變，變得細一點，每次都不一樣，在Training使用的時候一定會變差點，但是test會變好。
- 直覺來說：平時要增強自己的訓練強度，所有有些招式不使用。traing時如果總是有人會擺爛，那自己會更努力。
- Test時：是不做的dropout的，用全部的$w$下去，但是所有的$w$要乘上(1-p%)。
- 直覺來說：只有要在貫徹自己的忍道的時候才使用全部的$w$。
- 為何要乘(1-p%)的原因：把Dropout視為一個很大的Ensamble Model，Ensamble這邊原理就是不同NN structure再把結果做平均（雖然variance但是平均bias很小），像是Random Forest就是這精髓。配合mini-batch的隨機性，加上dropout的隨機性，幾次update就train幾種network，但是每個network只train了一個batch，但是不用擔心，這些不同network的參數是share的（所以同一個參數可能被很多次batch去train過），可以看成每次update都是為下一個network做初始化。而testing時，我們剛剛的假設，把每個邏輯上只train一次的network都拿過來跑一次取平均（運算量太大），因此我們乾脆把所有的$w$去乘上(1-p%)來減少他所產生的力道，這樣結果才不會用力過猛。不過我們只能說這樣直接對$w$動手腳可以“逼近”傳統ensemble的作法，除非這個NN的activation是線性的，像是 "ReLU", "MaxOut"，比起"Sigmoid"更接近線性，效果好很多。

## [17] Keras 2.0 - 2
- 都要先確認training set上的accuracy是多少
- 更改對於問題類型-loss function。（多重分類問題使用mse會比較不好，要用crossentropy
- 看看batch_size的影響
- 看看層數的影響，可以用for迴圈
- 換一下activation function
- 換一下Optimizer，可能使用Adam在accuracy的上升會比較快
- 老師故意在test set上每一個piexl故意加一些noise，而這樣會讓test set結果掉到0.5以下，所以緊接著Dropout的rate可以調大一點（一般設0.5，這邊設0.7），Dropout要加在每個hidden layer後面。提醒一下一定會傷害到training的手腳，但是test會變好。
- （以上的微調，有時候沒調好也不定要調回來，試著在深入別的辦法即可）

## [18] Fizz Buzz in TensorFlow（sequal）
- 有一個人，去面試一間公司，要求程式能力...，1~100，3的倍數印出Fizz，5的倍數印出Buzz，15的倍數印出Fizz Buzz...
- 
- 先去網路上找到一些已經標記好的1~1000的數字，數字本身用2進位10維，label有4維，分別是output本身數字/Fizz/Buzz/Fizz Buzz，這樣下去train，把hidden layer size增加就過關了...，不一定是增加深度。
- 

## [19] Convolution Neural Network（CNN）
- 原理：為了簡化DNN的架構，而拿掉一些weight，因為domain knowledge知道有些參數用不到。一組filter就等於某"種"特定的neuron，share相同的weight，在做update的時候就是把gradient平均再運算。
- 上圖：
- CNN = (Convolution + Pooling)*n + Flatten + DNN
- 上圖：
- 為什麼CNN的小型detector works？3要素
- 如果要進行偵測的話，只需要看一小塊，不用看整張圖（Convolution）
- 相同的pattern可以出現在圖片的任何地方，所以共用辨識的neuron即可（Convolution），不過大小嘴和小鳥嘴的辨識，model不一定可以handle這樣的scaling...Deepmind最近發一篇paper說，CNN前面再接一個Network，告訴你這image的哪些地方要坐旋轉和縮放，再丟到CNN裡面。
- 做影像subsampling其實不會影響影像辨識（Pooling）
### Convolution
- 概念：每個Filter就是一個neuron，一個matrix，matrix內部就是裝$w$，需要去學的
- 運算：Filter去跟影像做內積（相乘相加），然後再挪動一個stride的距離，做完Convolution後影像會縮小，變成原本長度減去filter_size再加1的大小。這些被轉換過的value又叫做feature map。總共有多少個filter，每張圖就會得到n倍的image量
- 彩色圖片：每張圖片都是3*x*x的大小，filter也必須是3*y*y的立方體。代表相同圖片某pixel點的RGB三元色稱為channel。
- 『整理』：有多少filter，就會得到幾倍的image量又稱為**feature map**，而每個image的RGB深度則稱為**channel**。image長寬的縮放本長度減去filter_size再加1的大小。
### Pooling
- 進行subsampling，可以自己定以n*n個大小為一組，選最大，最小，平均，出來，跟MaxOut的邏輯相同。

### 後續概念
- 更後面的Conv層的pattern複雜度就更高，image也會越來越小
- Keras：
- 跟一般DNN的差別，在Keras的input要改成3D的tensor（高維vector）長*寬*RGB，然後改一下network structure而已。
- 圖示：
- 
- 分析CNN的學習效果
- Neuron到底學到了什麼：
- 第一層的filter：weight可以理解，印出來看就知道。
- 第二層之後的filter：比較難以理解，但是我們可以去計算到底怎樣的image可以讓這個filter被activate的程度最大（加總feature map的值），反向去猜，使用gradient ascent，固定Network的參數去調整input的形況。...（課程範例是紋路）
- DNN中的hidden neuron：也用相同的gradient ascent去找。（課程範例是不規則的圖）
- DNN中的output neuron：去逆向gradient ascent，但是發現，讓他最高分的圖，根本不是有“數字”的樣子，因此，Network和我們學到的東西實在是太不一樣了...。所以更改一下activate的程度，對x做一些constrain（因為真正有墨水的地方是少的），加上$L_1$Norm去懲罰過大的參數。
- 『補充』Deep Dream：把一張照片送到CNN裡面，接著把某一層layer的output拿出來去放大（大的變大小的變小），再用gradient的方式回去找到真的可以讓這層output值最大的input的image，也就是強化他原本所get到的pattern。
- 『補充』Deep Style：讓某張圖片附有某些知名畫風。把原image丟給CNN，得到filter的output（表示有哪些content，因為會被filter給強化），再把“名畫”丟到CNN並得到filter的output，針對filter output之間的corelation（代表這張"名畫"的style），並且找到一張image（用gradient）讓他通過filter output的結果像是原image，而filter output之間的corelation卻像"名畫"的。
- 
- CNN的應用場景：
- AlphaGO某些東西和影像處理是相似的：有些pattern只需要看一小部分的棋面（他的第一層就用5x5的filter）就可以知道，（叫吃、鳥喙）。不同位置都有可能出現叫吃
- AlphaGO網絡架構：19x19x48的input，每個落點都以48種處境表示（domain knowledge），一開始有做zero padding（周圍補零），第一層filter是5x5的大小有192個，stride設1，使用ReLU，接下來的2~21層都使用3x3的filter，沒有使用MaxPooling（根據圍棋的CNN我們選擇不使用）
- Speech處理：Spectrogram聲音頻譜，但是使用CNN在處理的時候，不會按照sequential的方向，反而只會同一個時間點的範圍去detect，因為通常後續都還會再接上DNN或Lstm已經會考慮，所以要依照應用場景
- Text處理：把每個字用embedding表示，而filter大小需涵蓋整個vector並橫向延伸到別的vector，並且在移動時以sequential為主，因為filter的原意是要偵測不同位置的相同pattern，但是embedding的每個維度是獨立的，並沒有可能出現相同pattern（該篇paper作者說）。
- 視覺化：
- 讓Machine畫出以假亂真的圖：

## [20] Why Deep？
- 如果要比較深度網路的效果，他要讓短胖vs長瘦的參數量差不多才可以比較。
- Deep就是所謂的Modualization，模組化（他可以讓一步到位的傳統模型變簡單，而參數某種程度上是變少的），讓下層的Call上層的模組，原本要一步做到位的的複雜東西，都被上層basic model(每個neuron視為basic classifier，並把上層的都當作basic module)做掉了，也不會受限於資料量太少而train不好的問題。
- 並不是因為big data讓deep learning可以work：如果我有所有資料，那我就做rule base就好啦，就是因為沒有才要machine去學模式。（跟我們的認知是不一樣的）。
- Speech：裡面很多方法啦... window(250ms)取樣做成acoustic feature，做成phoneme，做成tri-phone，決定state（a-e-i-o-u...之類的），再用language model找到同音異字問題。
- 使用CNN在acoustic feature取樣：
- 傳統：使用GMM，一個state用一個distribution，可以share一些distribution，但是人類舌頭所決定發的聲音之間是有關聯的，發母音只受三件事情影響，舌頭前後/上下位置和嘴形。
- 上圖：
- DNN：Input一個acoustic feature，output屬於每個state的機率，所有的state共用一個DNN，而整體的參數量其實跟傳統的幾十個GMM差不多。把第一層layer output降維印出來，可以看出他想要辨識input的舌頭位置和嘴型的，跟上面那張圖相同。
- Universality Function
- 表示：任何continuous function都可以用一層的NN來表示（只要夠寬）。這個理論其實是沒有效率的，比起hierarchy structure。
- Analogy譬喻：
- 邏輯電路：可以用兩個xor可以表示各種類型的邏輯電路組成，但是會相當沒有效率而已，而且你會需要很多很多的xor才可以達到效果，越多的參數也表示overfitting的可能，而且可以用比較少的data學習到。
- 窗花：先做模組化的轉換，對折（feature transform），再來操作和分類。
- End-to-end Learning：夠deep的網絡才可以做這件事，每一站的參數都用學的，而不用太多domain knowledge介入，像是語音辨識這種古聖先賢智慧的結晶前面的東西幾乎不能改動，但是後半部慢慢的可以被NN給取代...
- 上圖：

## [21] Semi-supervised Learning
- 假設unlabel數量（只有input，沒有y）遠大於labeled的數量。又可分成兩種
- Transductive Learning：如果偷偷用了test set的feature（但是沒有用到他的label）
- Inductive Learning：unlabel的不是test set，而是training set本人或額外的
- 一些假設：需要依賴你對於data的分佈的假設是不是合理的
- 大綱：
- Semi-supervised的Generative Model
- Assumption 1：Low-density Separation
- Assumption 2：Smoothness
- Better Representation
### Generative Model（類EM algo）
- 如何實作：
- 初始化生成模型參數（假設為binary-classification）
- E-step：根據這組參數模型對unlabel data進行預測並記錄後驗機率
- M-step：根據這些後驗機率去Update生成模型的參數
- 回到E-step，直到收斂，而初始化的參數值會大大影響結果
- 上圖：
- 背後理論：
- Supervised learning：是要去maximize該label data的log-likelihood（有一個closed-form solution）
- Semi-sepervise：是要去maximize該label/unlabel data的log-likelihood。也就是label data的後驗，加上unlabel data被所有distribution產生的機率總和的最大化，需要iterative而且並非convex。

### Low-density Seperation
- 一些假設：世界非黑即白，會有很明顯的交界，而交界的資料點數量會是最少的。就是hard-label的概念。因為如果使用semi-supervised的話，你原本就predict出soft的了，結果還給他soft，那丟進去原本的model算cross-entropy後為1，參數不會去調整到等於沒用。...我們應該把[0.7 0.3]以上的直接標成[1 0]回去train，[0.4 0.6]以下的分不清楚交給人工！
- Self-training：用label data去train一個model出來，然後去predict那些unlabel的，然後選出一部分（自己決定）出來丟進去label data裡面重train（label就用剛剛predict的）。有點像是Generative Model，不過這邊用的是hard-label，generative用的是soft-label。
- Entropy-baed Regularization：同意不要使用非黑即白，但是可能性要夠集中於某個class，把loss function中加入entropy，取entropy比較小的，同時可以對這個進行加權，看是要偏向label或unlabel data，而這個方法也會讓model不會去overfit到label data，所以稱為某種程度的regularization。
- Semi-supervised SVM：窮舉所有可能的label可能性，每個可能性都去算svm（找到最寬的margin和最少的error）。不過他的做法是每次改變一筆label，如果讓objective function變大的話就改。

### Smoothness
- 近朱者赤，近墨者黑。蓬生麻中不扶而直，白沙在涅，與之俱黑。但是unlabel data可能要夠多，才會有路徑可以過去
- 如果$x_1$和$x_2$有過度的型態，那他們的相似度就會是高的
- 上圖：
- Cluster and then Label：就跟unsupervised一樣，但是尤其時image的pixel通常沒有辦法很好表達，所以沒有先通過auto-encoder的話，通常不會work。
- Graph-based：就是把data之間的橋樑，透過別的data特性去紀錄。
- 特性：label influence will propagate through graph，data點必須夠多才可能把該連的東西都連起來
- 像是論文之間的citation，或是網頁之間的hyperlink。
- K-NN，e-Neighborhood（density-based的半徑距離）
- 給Edge不同weight，跟GBF($s(x^i,x^j)=exp(-\gamma||x^i-x^j||^2)$)成正比，這個式子也是強化極值，而且下降速度很快，所以要相當靠近的點的$s(x^i,x^j)$才會大。
- Smoothness：去計算不同的label之間的weight的加總，相同的話就不考慮，我們想要知道在那些不同class的邊界，weight的總和就可以表示平滑程度大小。smoothness越小，越smooth。也是一樣把這個smoothness考慮進去到loss裡面最小化，然後做手動加權。
- 『延伸』：這樣的smoothness，可以針對NN裡面任何一層的output，自行設計loss function加到裡面。

### Better Representation
- 去蕪存菁，化繁為簡。
- 精神：我們看到的世界是很複雜，但是背後有可能是幾個簡單的東西在操控而已，背後的潛在因素（latent factor）就稱為better representation

## [22] Unsupervised Learning - Linear 降維
- Unsupervised分為兩大類：
- 化繁為簡：Clustering & Dimension Reduction。只有input，並且做抽象化（generalization）產出
- 無中生有：Generative。只有output，輸入一段code，機器自動產生相似的output
- Clustering：
- K-means：隨機初始化k個群，計算距離市中心的距離，assign，update市中心，再assign...。初始化很重要，並且一開始要決定要幾個k
- HAC：一開始所有data自己一個cluster，計算cluster之間兩兩計算相似度，相似度最高的做merge，merge後的data有幾種常見合併方式，再去計算剩餘的cluster兩兩相似度，一路建成完整的tree。最後再決定留下幾群即可。
- Dimension Reduction：
- 又叫做Distributed Representation
- Feature selection：直接拿掉一些不要用的feature
- PCA：也是一樣讓原本的vector乘上一個metric，屬於線性轉換的範疇
- 內積：讓原先的vector在新的vector上做投影，我們希望得到的新的分佈是越大越好，歧異度variance要大一點。
- 降維的維度：新的vector彼此之間要垂直（orthogonal），內積為0，才不會找到的新vector都一樣
- Lagrange multiplier：找到包含有所有新vector的矩陣（或也可以用一個linear NN來描述，但是不保證可以有最小的解）。
- 優化式子如下：找到一個$w^1$使得$(w^1)^TCov(x)w^1$最大，限制式是$(w^1)^Tw^1$必須為1不然會純粹爆炸，這個$Cov(x)$屬於辦正定沒有負值，$w^1$就是$Cov(x)$的eiganvector（metric）。
- 降維之後的$z=Wx$的$Cov(z)$會是對角矩陣：而這樣做的話，會使得資料符合了某些模型的假設了，像是Generative Model假設每個參數獨立，可以避免overfitting。
- 弱點：Unsupervised並找到variance最大的，但在classification上面可能會混淆，我們需要supervised的LDA。而且他是linear的沒有辦法做非線性轉換。
- 到底要取幾個PCA：看看variance佔總variance和的大小。
- 『提點』：用PCA做人臉辨識和手寫數字，其實找到的Component都不會是一個眼睛一個鼻子或一個斜線一個圈圈，這是人認為的component（此外，再畫PCA的component時要稍微平移，因為負值沒有顏色可以表示），因為PCA允許負值，所以可能先畫一個複雜的東西再把不要的減掉，如果想要從0開始加上去，全部都正數的話，要用NMF（同時如果有些data而言，負數的attribute人類不容易解釋）。
- Matrix Factorization：
- 背後操縱世界的latent pattern：
- 上圖：
- 那為什麼會有所見的世界的樣子：因為兩個相近的東西碰撞（做內積），就會得到高的分數。不過不能只用“萌傲嬌-萌天然呆”來描述所有人，至於要用多少個什麼來描述，就看我們了...
- 即便遇到missing value，可以先無視，用NN和gradient decent硬train一波，然後再來對missing value進行預測，會用在推薦系統。（Netflex的比賽）
- 上圖：
- 可以讓他更精確：各給他加上一點bias...或是想要讓他的分類更不模糊，就加上$L_1$的正規化，最後用gradient硬train一波就行。
- Latent semantic analysis（LSA）：
- 把Matrix Factorization用在topic analysis就是Latent semantic analysis。
- 也是一樣找到每個document和詞彙背後的latent factors。可能是某個主題（財經味道、政治味道、...）
- 『常用』：PLSA（Probablistic LSA），LDA（Latent Dirichlet Allocation，跟Linear Discriminant Analysis是完全不一樣的）
- 跟PCA相近的降維作法：
- Multidimensional Scaling（MDS）：不需要把每個data表示成feature vector，只需要知道feature vector之間的distance，就可以做MDS。像是城市不容易描述成vector但是兩兩間的距離是容易的。他跟PCA是有關係的，也保留了在高維空間的距離，降到低維時仍存在
- Probablistic PCA
- Kernel PCA：非線性版本（傳統預設是只有線性）
- Canonical Correlation Analysis(CCA)：如果有兩種不同source，同時有聲音訊號和唇形，都做降維
- Independent Component Analysis(ICA)：Source seperation，原本PCA要找到正交（相互垂直的），但是在這邊只要找到independent就可（他定義一個複雜的方法）。
- Linear Discriminant Analysis(LDA)：屬於supervised的方式

## [23] Unsupervised Learning - Word Embedding
- Word Embedding也是一種dimension reduction
- 只有input，沒有output。只知道輸入不知道輸出。可是不能用auto-encoder（在一個NN把其中一層output拉出來變成他的feature vector），因為一開始若使用"1-of-N"本來word之間的information就沒有get到了。
- 看看上下文或隔壁的人去賦予自己意義（兩種類型）
- Count base：如果常常一起出現的話，就會比較接近，這方法是Glove Vector。原則上是說兩個東西的向量的inner product要越接近他們一起出現在的文章數量$co\_occure(w_i,w_j)$，跟NMF是有點像的
- Prediction base：input是1-of-N，output是預測下一個字是哪個字的機率，也是N維。等model都train好了以後，再讓1-of-N的data通過他後取出第一層的output當作word-embedding再做降維投影。
- 但是通常input都會有接近10個word再去predict下一個word是什麼，會共用$w$減少參數
- 有一些別的分支：CBOW（Continuous bag of word）用前後的字去predict中間的字、Skip-gram用一個字去predict前後一個字。
- 『提醒』：其實這個NN的Model不是deep的，他只有一層，而且是線性。過去很早以前其他人其實是用deep做word vector，效果不是很好。
- 『提醒』：word embedding在2010年的語音屆紅起來的，稱呼continuous language model。
- 好處：
- 可以發現文字之間想得到或意想不到的意思（固然存在的語意幽默感）
- 
- 預先做好image-embedding就可以對影像進行分類，而且可以不需要先看過某些特定的影像也可進行分類
- 
- Document（word sequence）也可以變成vector（相同長度），先做出bag-of-word模型，再用auto-encoder就可以做semantic embedding。
- 跳脫詞袋模型，讓embedding具有語意順序（包含supervised和unsupervised的）：

## [24] Unsupervised Learning - Neighbor Embedding
- t-SNE（Neighbor Embedding）：非線性的降維
- Manifold Learning：Data point的分佈其實在比較低維的空間裡面，但是被塞到高維的空間去display，地球模型就是（只有在距離近時畢氏定理"歐式距離"才會有效，不然就會被稍微扭曲），所以就是要把在高維空間裡面的東西攤平（做非線性的轉換）。
- Locally Linear Embedding（LLE）：假設每個人$x^i$都可以用自己的某個鄰居$x^j$做linear combination（乘上一個$w$）來表示。那我們會想要降維之後的兩個點仍$z^i,z^j$可以用$w_{i,j}$來做線性轉換，他沒有明確的說降維方法，要好好的挑一下neighbor要選幾個（太小太大都不太好）
- Laplacian Eigenmaps：考慮之前smooth等級這件事，就是說要有足夠的過度的點可以連過去，可以用graph-based來做。解出來就是graph Laplacian matrix的eigen vector對應到比較小的eigen value那些。如果先找到了對應的z再做clustering的話，就叫做spectral clustering
- t-SNE（T-distributed stochastic Neighbor Embedding）
- 解決的問題：前面假設"相近的點必須是接近的"，但是沒有假設"不相近的點要離遠遠的"。
- 也是一樣計算兩兩點之間的similarity$S(x^i,x^j)$，然後需要做一下normalization，$P(x^j|x^i)=\frac{S(x^i,x^j)}{\sum_{x\ne i}S(x^i,x^k)}$，然後再做降維之後的$z^i,z^j$的$Q(z^j|z^i)=\frac{S'(z^i,z^j)}{\sum_{z\ne i}S'(z^i,x^k)}$，前面的normalization就是防止不同空間的距離的scale不同。降維就是要讓$P,Q$的distribution越接近越好。（用KL divergent，用gradient descent做）。
- $S(x^i,x^j)=exp(-||x^i-x^j||_2)$：RBF這東西可以強化"距離"這件事，只有很近的會有值，然後取負的exp會掉很快，距離一拉開就會掉很多。
- T-distribution：可是在降維之後兩兩間的similarity用的是$s'(z^i,z^j)=1/(1+||z^i-z^j||_2)$，他這個T-distribution可以有很多種分佈型態，而這邊這種會使得他尾巴比較長（下降慢，也就是對於距離遠的similarity掉得慢，距離遠的會被拉的更遠，近的會更近）
- 然而，兩兩間的similarity在t-SNE計算高維度空間時，會跑太久，通常會先降維（用PCA降成50維，再用t-SNE畫圖）。
- t-SNE沒有辦法吃新的data，因為similarity那邊要重新計算，純粹拿來一開始做visualization，沒有用在training/test上面的
- 

## [25] Unsupervised Learning - Auto Encoder/Decoder
- Encoder/Decoder：訓練一個神經網絡（gradient descent），讓原本的input以一個更compact的方式來表示，遠小於input的維度（又稱為bottleneck），而decoder則是透過這些code將data還原，網絡可以很深（就稱為Deep Auto-encoder），不好train，通常要做RBM initialization（2006）。
- PCA-related：在做的事情也是相當像的！就是要讓還原後的$\hat x$失真最少，不過他是很淺的線性轉換，失真大。
- 兩種比較：
- Text Retrieval：
- 傳統上會用vector space model的bag-of-word，但是語意（semantic）沒有考慮進去。Hinton有次用在一個小的文章集效果很好，降成2維然後畫圖就可以做相似度分類，主題分類，query。LSA的效果也是差的。
- Similar Image Search：
- 以圖找圖：如果只是比較pixel-wise相似度的話，Michael Jackson跟馬蹄鐵是很像的。但如果用Encoder考慮進來再算相似度，效果就會好，而且Encoder-Decoder是unsupervised的，data幾乎無限
- CNN：
- Convolution -> Pooling
- Unpooling -> Deconvolution
- Unpooling：需要多紀錄Maxpooling的max-location，才知道怎麼還原，不過Keras好像直接repeat複製4份擴張
- Deconvolution：其實就是convolution（只是名字取得不好為讓人誤解），只要在一開始做padding，後面的都跟Conv一樣。
- Sequence-to-sequence：
- 有時候data不適合被表示成vector，語音/文章有長有短，若用bag-of-word表示成等長的vector會失去詞彙之間的前後關係。
- Pre-train DNN：
- 找比較好的initialization，greedy layer-wise
- 注意如果Auto-encode的bottleneck層反而是比input還要大，那要小心它什麼都沒做（擺爛），Loss要加上regularization（$L_1$norm之類的，必須要是sparse的，只有某幾維能有值，其他的必須是0）
- 這東西就是希望可以逐層的找到最好值，逐層pretrain，每次都去夾著下一個，train好以後fix這層$w$，再去夾下一層，直到最後要接近bottleneck那層時再用random的初始化，最後只需要去做一點點的fine-tune而已。
- 
- 『提醒』：現在絕大多數DNN都是不用依賴逐層pre-train了，除非是semi-supervised的，先用unlabel data去pretrain好之後，再用label data做最後的Fine-tuning，一樣使用backpropagation。
- De-noising Auto Encoder：
- 原data是$x$，先加上一點雜訊$x'$再傳入encoder/decoder並讓output的$y$盡可能的像$x$，可以讓model學到如何過濾雜訊
- Contractive auto-encoder：在learn的時候加上constraint，當input有變化時，對於結果的影響要是小的（跟加上雜訊效果是一樣的）。
- 其他：RBM（也是降維方法不過他不是NN，可以拿來初始化），Deep Believe Network（跟RBM一樣是graphic-model就是）
- Encoder：如果給一個random的input number，能不能用encoder產生出新的image。先用784維的MNIST（經過標準化讓他集中在0附近）通過hidden layer投射到2維平面上做圖，再透過2維解回來原來image，再把最集中的範圍等間隔的sample點出來（不一定有原本data降維對應），通過encoder去產生數字，就會有驚人效果不同的軸掌管不同東西。
- 上圖：

## [26] Unsupervised Learning - Deep Generative Model (Part I)
- OpenAI文章：What I cannot create, I do not understand. 要一直知道如何產生出來才真正懂了。
### Pixel RNN
- 每次點一個點畫出pixel，最後點出整張圖，input是3維（RGB），漸進式增加input（RNN可以處理），跟sequential很像，完全是unsupervised的。在不同的generative model裡面，Pixel RNN出圖最清晰。可以做image或語音的片段都可以，影像的也可以。不過結果很難被evaluate
- 上圖：
### Variational Autoencoder (VAE, 2013)
- 如果把encoder/decoder拿出來隨便給一組code讓他產生的話會結果不好，要用VAE去生成這個input的code。
- 作法：encoder/decoder部分是一樣的...但是要加上一些。VAE做的圖其實不是很好的，不知道他在畫什麼，需要控制一些東西。那個$\sigma$其實就是控制Variance和Noise的大小，另外加的那項黃色的就是要對Variance做限制（不然他會Output 0）。
- 上圖：
- 上圖：
- VAE寫詩：input sentence，output sentence，這需要用RNN來處理。
- Why VAE：普通的Encode只有精確對應的Code和Output，而因為NN不是線性的，所以Output之間的中間，並不會如直覺一般的被腦部（滿月-半月-弦月）。但是VAE有一個Noise的範圍，所以他會讓介在中間的Code會同步採取不同Output的特性，使得中間的Code也等於介在中間的Output。
- Gaussian Mixture Model
- 修過語音的應該就會知道這個
- 覺得一個Model背後可能有很多Distribution疊加的，先決定要從哪個Gaussian去Sample data，再去Sample。要去找到Gaussian就用EM algorithm即可。
- 假設每一個data都是從某個Gaussian被sample出來的，等同於先做clustering，但是最好的還是可以Output一個各個不同面向的attribute（屬於不同class的機率），VAE就是Gaussian的distributed representation版本
- VAE最後有點像是regularization項的，其實就是另一個Auto-encoder。
- 上圖：
- Conditional VAE：
- 要讓VAE產生手寫數字：給一個digit，把特性抽出來（筆畫粗細...），放進去Encoder時，一方面給他有關數字特性的Distribution，另外一方面告訴Decoder他是什麼數字，就可以output一大排相同字型的數字。
- 上圖：
- VAE的嚴重問題：（所以後續有GAN）
- 從來沒有去學產生看起來像真的的image，產生某張image跟database中某中image越接近越好（我們使用MSE來衡量pixel-wise）。但是錯誤的位置是有差的，無法衡量，頂多只是原資料的linear combination，這樣感覺沒有非常intelligence

### [27] Generative Adversarial Network (GAN,2014)
- 新的Paper，2014年12月。由Yann Lecun欽點。
- 擬態演化：枯葉蝶 vs 枯葉...
- Generator vs Distriminator：
- Gen從來沒有看過真正的image，他唯一要做的就是要騙過上一代的Dis...，然而相繼演化，Gen可以產生真的沒有出現在databased裡面的東西，看起很智能。
- 上圖：
- 作法：
- Dis-er：吃image，output一個vector，通過sigmoid介在0~1（real/fake）
- Gen-er：跟VAE的decoder架構一樣，吃一個從任意distribution去sample出來的vector，丟到generator出來假的image
- Dis-er：使用Binary Classification去做假的image（標為0），真image（標為1）的discrimination
- Gen-er：透過上一代discriminator去update該generator。仍然吃一個從任意distribution去sample出來的vector，是固定住discriminator並調generator的參數使得discriminator的output越接近1越好，整體而言是一個很大的NN，使用gradient descent。
- 限制：
- 參數不容易調，可能一下子就偏太多
- dis-er好壞不知道：
- 有時候容易收斂是因為gen-er太強，而是因為dis-er分辨不出來
- 或是很不容易收斂不是因為gen-er太弱，而是dis-er分辨不出來
- 現在需要隨時坐在旁邊看gen-er的output圖像好不好才知道方向和參數是不是對的，沒有很明確的signal告訴你現在的generator到底有多好？
- 在NN只要最小化Loss
- 在GAN需要使得"well-matched in a contest"（保持動態競合）

## [28] Transfer Learning
- 假設現在有一些跟我們的task沒有直接相關的data，能幫助我現在的task，也就是說有哪些layer的參數是可以共用的，或稍微作為initialization。一樣的domain（分佈相同）或一樣的task（狗，高飛狗）。很少的data（台語語音，醫療資料，特殊法律文件）
- 四種情況
- 我們Task相關：Target data。Label，unlabel。
- 我們Task無關：Source data。Label，unlabel。
### $Target(\#)+Source(\#)$
- Fine Tune：用source去train（做initialization），用target來fine-tune（若回過頭source壞掉也沒關係）。target很少量，Source很大量。像是要train某個人的語音辨識系統，他的話很少，但Youtube上有很多別人的。
- 『補充』：如果target真的太少，就叫做one-shot training、
- 小技巧：
- Conservative Training：用source做完後在train target時，loss部位加上constraint，使得新的model的output/parameter跟原本舊model的output/parameter不要相差太遠。
- Layer Trasfer：只從原model複製部分layer到新的model，而用target去train少量的layer即可，防止overfitting。
- 哪些layer要被Copy：語音辨識（固定後面，train前面），Image（固定前面，train後面。CNN圖像辨識而言前面是比較基本的pattern比較可以共用）...
- Multitask Learning：target的tune完後，還是會繼續考慮考慮source的performance。
- 如果Input的feature有共通性，則可以讓後面不同的task共用前幾層。或是讓兩個task只共用中間的某幾層。
- 經常看到的例子是多國語言語音辨識，共用acoustic featuer和前幾層，後面幾個layer各個語言用自己的參數。
- Progressive Neural Networks：（不知道怎麼解釋）
- 上圖：

### $Target({!}\#)+Source(\#)$
- Domain-adversarial training：原本是打算用target訓練模型，再用source直接跑。但這樣一定是爛的，他們不在同一個corpus內，若把NN前半部視為抽feature，後半部視為classification的問題，那要求"抽feature層"的output把domain knowledge去掉。希望把target和source在抽完feature降維後的結果可以混在一起，這樣後面的classification才會有用。
- 作法：把feature extractor（作為Generator）的output丟給一個domain classifier，他會分辨目前的data來自target/source（作為Discriminator），而同時把抽feature層的output也要接上label predictor。
- 上圖：
- Zero-shot Learning：假說的部分是一樣的，但Source和target原本要面對的task是很不一樣的。
- DeViSE：把Image和word都投影到新的向量空間去。這邊有點事要跳脫input的image的最上層級別的樣貌，把他分解成他的抽象化feature，這東西叫做attribute embedding。
- ConSE：Convex Comination of Semantic Embedding，使用NN先做語音辨識的分類（soft classification），再從Semantic Embedding的空間中找到從soft classfication建議的折衷選擇。
- 『補充』（老師本人）：
- 此外... 部落格有個新東西：不同語言的input在吃進去後，會把他們project（encoder）到一個相同的只跟semantic有關的vector space當中，會有一個decoder去解回你的目標語言（翻譯）。可以說成，machine自己發明一個secret language作為所有語言的中繼站。

### $Target(\#{!}\#)+Source({!}\#)$
- 在source沒有label的情況下，如果target有label（self-taught learning），如果連target都沒有label（self-taught clustering）
- Self-taught learning：跟semi-supervised有些不一樣的地方為，他在train時就有一半label的data進來，而這些label和unlabel的data的關係是很遠的，原本就是在解不同task。
- 目標：從source去學一個feature extractor，可能可以是encoder，在用encoder去target data上抽feature

## [29] Support Vector Machine（SVM）
- 使用Hinge Loss和Kernel Method（kernel tree）。
- 比較：（x軸為$\hat y^nf(x)$，y軸為Loss）
- Ideal Loss：正確的硬分類
- Sigmoid + SquareError：在值很大的時候update速度很慢不划算
- Sigmoid + CrossEntropy：在loss很大的時候update速度也很快，而且如果已經得到很好的結果還要再更好（盡可能的想要把某一科考到最好，有些會Fail）。也可作為Ideal Loss的upper bound。
- Hinge Loss：跟CrossEntropy最大的不同，對於已經做得“好”的example的態度，會覺得大於1已經很棒的及格就好（盡可能的讓所有科目及格，並且歐趴）。也可作為Ideal Loss的upper bound。不過在實作上Hinge並沒有好太多，不過比較不怕outlier（比較robust）
- SVM
- 上圖：
- 其實他就是一個Logistic regression把loss改成Hinge Loss，而若你有一個NN使用Hinge Loss就會有Deep的版本，而這個Hinge Loss都是Convex的，就像ReLU和Maxout一樣，看起來不可微但是可以用Gradient的
- 得到最佳解的$w$：是Data做linear combination來的，而因為使用Hinge Loss的關係，有些operation region可能是0，所以剛剛說的linear combination對有些data來說weight是0，而那些不是0的就是support vector（可以用來決定model長什麼樣子的資料點，只有少數的點可以作為support vector，所以他是比較robust的）。
- Kernel Trick：把w寫成是Data做linear combination（Logistic Regression也可以用這樣的技巧）。簡單來說，就是套件內部可以做運算的加速。可以最後簡化成兩個vector先做inner product再做運算，而不是先各別做了feature transform在做運算。所以可以直接去設計kernel function，而不用去理會input的兩個vector做完feature transform後長什麼樣子。而這個東西特別有效在於input並不是一個strcture data（如不同長度的sequence）。
- 『補充』：kernel function其實就是投影到高維以後的inner product的東西，有點類似在計算兩個vector的similarity
- 『補充』：RBF kernel可以想像成在無窮多為的平面上去做事情，很容易overfitting。
- 『補充』：如果今天在logistic regression使用CrossEntropy，他的微分在很多地方是不等於0的，每次update參數都不會有沒貢獻的點，所以參數矩陣不會是sparse的，對於outlier影響小，比較robust。
- 『補充』：如果我幾天要看看一個聲音訊號屬於哪種情緒，有長有短沒辦法向量化，我們可以直接定kernel。如Dynamic Time Alignment kernel in SVM（金融科技課有，就是只能往右和右上方的爬格子）
- 『補充』SVM相關方法
- Support Vector Regression：Regression是要model output跟正確答案越近越好，SVR就是我近到某個距離就好，少於那個的，loss等於0參數就不再更新，防止outlier
- Ranking SVM：考慮排序，如果希望output是一個list，按照output由高到低搜索，但是這樣沒有optimize到問題，可以直接考慮Ranking，而不用管真的值
- One-class-SVM：希望屬於positive的集中在某個地方，其餘的隨意散播
- Deep Learning和SVM的差別！！
- DL的前幾layer看作feature transform，最後面的看作linear classification。
- SVM也是先apply一個kernel function把feature轉到高維平面（先做好兩兩的高維內積加總，而不是單筆資料的feature transform而已），再apply linear classifier(通常會用hidge loss)，而SVM的kernel也是可以用學的，使用“Multiple kernel Learning”，但是沒辦法像DL做得這麼多，頂多是linear ensemble而已，如果只有一個kernel就是NN只有一個hidden layer。

## [30] Recurrent Neural Network（RNN）- 1
- Slot Filling：有點像是我們上傳一份履歷表，系統自動讀取幫我們轉成內建的表格，智慧客服也是。如果是用DNN來做，就是把某個文字丟進去，output他屬於每個slot的機率。所以只input單詞的vector是不行的，希望NN有記憶力，記得前面的hint，這種有記憶的NN就叫做RNN，每層hidden layer有output都會另外被存到一個memory的裡，下次可以拿出來使用。因此，RNN就算輸入一樣的東西輸出也是不同的，order也會影響。
- 種類
- Elman Network：分層存output（這東西沒有辦法清楚存在memory中的值，在參數update中他不會被考慮在obkective function裡面）
- Jordan Network：存整個NN的output值（傳說效果比較好）
- Bidirection RNN：同時train兩個相同input sequence但反向的NN，然後再逐層做output，這樣每個詞彙所考慮的範圍就會比較廣。
- LSTM（Long short-term Memory，比較長的短期記憶）
- Gate：有3個閘門可以通過學習，input（決定什麼時候打開），output（決定什麼時候打開），forget（決定什麼時候要把過去的東西格式化掉）。整個LSTM的cell有四個input，而控制閘門的運算會用sigmoid轉成0~1好用來當作是否開啟的訊號
- 人體LSTM：
- 
- 
- 
- 
- 
- LSTM需要的參數量很多，跟一般NN比起來的話，在Neuron數量相同的情況下，參數量是4倍。
- Keras會支援
- LSTM：預設的RNN都是在講他
- GRU：簡易版LSTM，據說只有兩個gate，performance差不多，參數量少了三分之一，也比較不容易overfitting
- SimpleRNN：最原始的課堂一開始講的那種...

## [31] Recurrent Neural Network（RNN）- 2
- RNN中的Target Function
- 依序丟進去LSTM模型，在坐後做分類，使用CrossEntropy。而Training仍使用Gradient Descent，有一套新的演算法叫做BPTT(Backpropagation through time)
- RNN的訓練比較困難，通常他的error surface（參數變化對Loss的影響作圖）很崎嶇，平坦和突然隆起的銜接沒有過度，但是gradient會亂跳，所以要加上"clipping"，使得gradient有一個上限。原因就在於RNN在做memory transition時，反覆使用了某個參數，所以變化量是該參數的n次方（取決於sequence長度），使得一點點的變化，後面影響就大，可是learning rate跟不上去平衡他。
- 為什麼要把RNN換成LSTM
- LSTM可以解決低度消失（lr可以設小一點），但是不能解決梯度爆炸。
- 為什麼可以解決梯度消失：因為對於forget gate那邊，LSTM不會每次都把過去的memory洗掉，而是會乘上一個值然後加上該輪的input，只要forget gate沒有作用，過去的gradient就還有影響力。（跟傳統RNN每輪都清空不一樣）
- 別的解決梯度消失演算法：Clockwise RNN，SCRN，使用Identity Matrix初始化傳統RNN的transition weight，再用ReLU（傳說可以屌打LSTM）
- Many to one：情緒辨識，關鍵詞彙辨識（key term extrraction）。
- 
- Many to many：Input和output都是sequence，但是output比較短時，語音辨識（speech recognition），input是acustic vector，output是中文詞彙，trimming和CTC（output可以加入null）可以解決疊字問題，CTC可以解決從來沒有出現過的詞彙，他可能可以知道是人名地名。而Google語音辨識已經採用CTC
- Many to Many（No limitation）：不確定input和output誰長誰短，就是sequence to sequence leanring
- 
- Beyond Sequence：Syntactic parsing tree（文法結構樹）
- Auto-encoder Text：在有考慮sequence的情況下**把一個document透過encoder變成一個vector，在透過decoder長回一模一樣的句子**，不需要Label的data，只需要大量的網路文章即可
- 
- 四層的LSTM：
- 
- 語音辨識也行：
- 
- **Attention-based Model**
- 除了RNN之外有用到memory的Model，把重要的資訊讀出來，把重要的資訊寫回去
- Neural Turing Machine（2014年底）
- 
- 常用在reading comprehension，把每一句話變成vector代表這句話的語意（semantic），可以問一個DNN問題，他會iterative的去對的地方拿東西出來，變成答案
- 托福聽力：
- 小小技巧：選答案長度最短的，選那個跟其他三個“語意最像的”
- Deep Learning vs Structure Learning
- RNN, LSTM：都可以做sequence to Sequence，只看了句子的一部分（除非考慮了bi-direction），Cost function（每個時間點的output和reference的CrossEntropy）和error（兩個seq之間的distance）可能比較沒有關係。但他可以是Deep的（完勝structure learning）
- HMM, CRF, Structured Perceptron/SVM：都可以做sequence to Sequence，若使用了Viterbi則會考慮完整個句子（勝）。可以很清楚的考慮label之間的關聯性（可以直接下限制說，同一個label要出現5次以上才算數），Cost是error的upper bound（勝），但structure learning比較只能是linear的（因為evaluation function是linear的）
- 可以把兩個一起learn，先通過RNN再通過structure
- 語音辨識：CNN/LSTM/DNN + HMM
- 語意標籤：Bi-directional LSTM + CRF/Structured SVM
- 總之，未來Deep和structure一起就會是主流，老師開的課就叫做Machine Learning and have it deep and structure（MLDS）

## [32] Ensemble
### Bagging：
- 特性
- 當為regression做平均，或clsasification做投票。Model有點複雜，variance可以降下來且bias本來就很小的情況適用。
- Bagging無法使function fit資料，如果本身就不準的話。
- Bagging是用在很強很複雜的單體Model
- Bagging的model順序沒有關係
- 製造data
- 使用resample的方式製造不同的training data（Model）
- reweighting（等於直接更改loss）
### Boosting
- 特性
- Boosting是用在很若弱很複雜的單體Model
- 找到的不同classifier必須是互補的，訓練也必須有特定順序
- 使用resample的方式製造不同的training data（Model）
- Adaboosting：
- 先訓練一個classifier（$C^1$）正確率稍微大於0.5即可，但每筆資料的loss的weight不同
- 這時候再重新weight這些loss，使得loss等於0.5，再用這些data重新train一個（$C^2$）。能做到這樣就是把原本答對的權重弄小，把原本打錯的配分弄大，去強化學習錯誤的，這樣新的model的weight就會特別去針對錯誤data的分類加強。數學來表達也就是若分類正確，權重除以$d_1$，分類錯誤權重乘以$d_1$...（每一輪的weight都是用上一輪的weight下去做權重變化）依這個方法訓練了一大堆classifier
- Aggregate
- Uniform：對於bi-class而言，就是把預測加起來（soft-classification），如果是正數就是第一類，負數就第二類
- Non-uniform：針對這些分類器的正確率，高的就給高的線性組合權重，低的就給低一點。（有個公式）
- 
- 
- 神奇的地方：即便training dat上面已經得到100%的正確率，增加新的tree到Adaboost裡面仍可以繼續優化testing data，因為每新增一個weak classifier就可以增加一點點margin使得model更robust，SVM也有這樣的效果。
- 為什麼會繼續increse margin，因為他始終不會使loss等於0而不再更新參數：
- 一大堆數學：upper bound的證明
- 此外：對於bagging（投票）而言，深度不夠，是沒有辦法靠三個臭皮匠勝過諸葛亮的，但是boosting的話，一堆互補的笨蛋是可以串起來就得到很好的效果
- Gradient Boosting
- 特性：為Adaboost更general的版本，想要找到一個新的function讓過去所有function的loss總和可以更小一點
- 如何找到那個新的function：講簡單一點，可以看成另一個gradient descent在update參數的過程，不過這邊是update一個新的function給那個終極function set做boosting，因此也會有learning rate，而要找到的function則可以看成新的一組的參數的集合，就分別對他做偏微分，而那個learning rate（$\alpha_t$）就透過gradient來找，找到的learning rate會剛好等於剛剛的adaboost裡面為每個function都乘以的權重 $\alpha_t$（而這個權重是用個別的error rate算出來的$ln\sqrt {(1-\epsilon_t)/\epsilon_t}$），就是表現好的權重高，表現不好的權重低，所以才說看成Adaboost的general版本。
### Stacking
- 特性
- 其實就是跟投票絕對多數制和regression的平均有點像，跟Bagging是差不多的概念，不過後面要再接一個簡單的Model（linear, logistic）即可。

## [33] Deep Reinforcement Learning
- 一些皮毛（scratching the surface）
- Google在201502在natural上面發一篇paper用reinforcement learing來玩Atari小遊戲，可以痛電人類。2016年春天的AlphaGO也可以痛電人類。David Silver說，AI就是RL+Dl
- Reinforcement Learning：有一個agent有一個environment。而這個agent會對於這個environment有一些觀察observation稱為state，也會有觀察不完全的環境狀態，partial unobserved state（而不是系統本身的state）。而machine（agent）會做出一些action來改變環境，環境再給予reward是一種feedback。
- 應用
- 圍棋：只有在少數情況會有reward，因此是很sparse的
- 其實，人也不知道要下在哪裡，所以人也不知道optimal的，但是reinforcement learning則是從過去的經驗去學習，去找到好壞的細節，需要跟Machine下3000千萬盤之後才會有所進步，AlphaGO一開始是supervised的讓他有一點初始，再去做reinforcement
- ChatBot：用LSTM的encoder/decoder，做Sequence to sequencce learning。所以讓兩個Agent自己去對話。始終應該會出現使用GAN來訓練機器人的，試著去騙過discriminator來當作reward
- 無人車
- Google server節電
- Text Generation
- Video Game：讓AI去玩遊戲是讓machine看到pixel後作出反應，而不是讓machine去讀程式碼。
- 困難點
- Reward Delay：要開火之後才得到reward，如果他知道這件事情就會瘋狂開火，但是現在的左右移動會讓未來的開火有好的效果
- Agent的行為會影響環境：要學會持續探索這個世界的所有可能性才可以知道遊戲規則，不能只依賴現有最好的選擇
- 對於2017年而言，有馬可夫模型，Deep Q-learning沒這麼強，最強的是A3C的agent，reinforcement學習有value-base和policy-based的方法
- 

### Asynchronous Advantage Actor-Critic(A3C)
- Policy-based（Actor）
- 跟ML三步驟一樣，Policy也就是Actor也就是Agent...
- 後面都是數學，崩潰...聽說在下學期會繼續補充完
- Gradient descent update
- Value-based（Critic）
- 崩潰...這學期沒有說

## [34] Policy Gradient (Suppplimentary Explaination)
- 就是Policy-based的gradient...透過reward去更改要update重複的次數，唯一需要做的是，learn classifier的時候，給training example新的weight。（Keras是有支援的）很花時間，比較麻煩的是蒐集完data之後都要解一次分類問題train一次NN，再去蒐集一次training data，再reapeat
- 上圖（不筆記）：
- 
- 

## [35] Reinforcement Learning（Include Q-Learning）
- 機器和環境做互動，最後得到一個結果，而這個結果會改變下一輪的input。我們通常會覺得外界來的資訊有點複雜，會需要做完摘要再丟給機器，就是state(summarize of observation)
- 純粹的supervised的learning叫做Behavior Cloning，但是沒有辦法決定到底哪些重要哪些不重要。其實有兩種是推薦的，reinforcement learning和learning by demonstration（加上一些限制讓他不是照單全收，或稱為apprenticeship learning）Inverse reinforcement learning就是 learning by demonstration的一種
- 每一輪的input叫做observation，每完整完成一次遊戲叫做episode，把最後的reward加總就是total reward($R$)，希望這個reward越大越好，因此使用gradient ascent，我們無法控制環境和reward，只能控制Agent。他們的關係如下：
- 
- 其實在80年代就有reinforcement learning（查表的Actor），但現在會紅只是換成DeepNN而已
- 如果發現有不能微分的地方，就用policy gradient硬train一發
- Critic就是能量Actor有多好：Critic就是指說，給他一個input，他會output未來獲勝的機率期望值有多大，他是depends on Actor的，如果是給一樣的input pixel但是Actor不同時，output也不同。
- 如何評估Critic的好壞
- Monto-Carlo：就是去看他每一步預測的勝負跟最終勝負像不像（用regression），需要等到遊戲結束時有那個total reward可以update
- 
- Temporal-difference：不用等到遊戲結束就可以update參數
- 
- Q-learning(state-action value function)：輸入state和action就可以看到得到的分數有多少，用Q function找到一個比較好的Actor。把Q-learning接到上面兩種Critic判斷後面，一定可以找到一個新的$\pi$讓Actor更好。（限制就是，如果action有無限多種，是continuous的，那就不能用了）
- Rainbow：Q-learning的trick，有七種方法。比較好實作的是DQN...
- A3C：讓Actor不要真的去看環境的reward（隨機性），去看Critic就好這方法就叫做Actor-Critic。
- Pathwise Derivative Policy Gradient：這個技術就是跟GAN的概念有點像
- 
- Limitation Learning：有很多的專家玩給Actor看，機器沒有reward fucntion。其實跟多數的case是沒有明確的reward，就是現實生活無法真的量化。
- 技術剛好是反過來的，專家玩出來的東西就是我們的Actor，然後根據Environment參數來得到最好的reward function，再去訓練一個reinforcement model找到最好的Actor。
- Principle：老師是最好的...
- 
- 
- 跟GAN是非常像的
-