---
# System prepended metadata

title: CS231N (2017) Lec 03 課程筆記
tags: [CV]

---

# CS231N (2017) Lec 03 課程筆記
###### tags: `CV`

🔷 Multi-class SVM Classifier - Loss function & Optimization
      📌 Recall from last time: Linear Classifier
            (1) 「輸出」各類別預測分數 (此例非 "機率值" 而是 "分數")
                  ➡️ 目標: 正確的類別 具有 最高的分數、
                                  視覺上最相似的類別 具有 次高的分數、
                                  視覺上第二相似的類別 具有 第三高的分數、
        

            (2)  KNN: 根據 distance metric 找最近鄰居，基於「所有資料點」

            (3)  Linear Classifier: 參數型分類器，基於從所有資料點提取出的「權重 (參數) 矩陣」

      📌 Steps of determining the weight
            (1) Loss function (損失函數)
                  定義一個函數
                  用於量化「損失」: 估計值 (輸出向量的「得分」) 和實際值 (「標籤」) 的差異
                  // 損失: 即「殘差」(residual)

            (2) Optimization (最佳化)
                  定義一種方法
                  用於找尋使損失函數最小化的權重 (參數, W)

      📌 Loss function of Linear Classifier
            (1) usage
                  可以告訴我們目前分類器的好壞
                  
            (2) functional form
                  給定一個資料集如下
                  { ( x_i, y_i ) }_i = 1 to N

                  其中 x_i 是影像 (像素強度矩陣)
                  其中 y_i 是標籤 (整數)

                  則，損失函數可定義為:
                  ➡️ L = 1/N  Σ_i  Li ( f ( x_i, W), y_i )
                        上述是一種非常龐統 (general) 的表示
                        即: 所有類別各自損失值的平均

                  ➡️ Li ( f ( x_i, W), y_i )
                         = 第 i 個樣本的損失
                         = Li (估計值 , 實際值) 
                         = 將 估計值: f ( x_i, W) 和 實際值: y_i  間的差異
                            以損失函數量化，所得到的數值

                  ➡️ 1/N  Σ_i
                         對所有樣本的 損失 取平均
                         其中 N 為資料集的樣本數
 
      📌 Loss function of Multi-class SVM Classifier  (Multi-class SVM loss)
                  給定一個資料集如下
                  { ( x_i, y_i ) }_i = 1 to N

                  其中 x_i 是影像 (像素強度矩陣)
                  其中 y_i 是標籤 (整數)
                  並用一個符號 s 表示得分，定義: s = f (x_i, W)

                  SVM 損失具有以下形式:
                  ➡️ Li = Σ_( j ≠ y_i ) 
                               {  0                                    if  s_( y_i ) >=  s_( j ) + 1
                                  s_( j ) - s_( y_i ) + 1     otherwise                           }
                            = max ( 0 ,  s_( j ) - s_( y_i ) + 1 )

                        解釋:
                            (1)
                             j 為 第 j 個標籤，與資料所屬的 "真實類別標籤" 相異
                            ---------------------------------------------------------------
                            若「預測正確」：真實標籤: s_( y_i ) 的得分較高  =>  令損失值為 0
                            反之，若「預測錯誤」  =>  令損失值為「一個移項後的正值」

                            (2)
                            「預測正確」情況下: s_( j ) - s_( y_i ) + 1 <= 0，會得到一個負值或 0
                             因此 max ( 0 ,  s_( j ) - s_( y_i ) + 1 ) 必為 0
                             反之，「預測錯誤」情況下: s_( j ) - s_( y_i ) + 1 > 0，會得到一個正值
                             因此 max ( 0 ,  s_( j ) - s_( y_i ) + 1 ) 必為 s_( j ) - s_( y_i ) + 1
                             原本的 條件式賦值 就可改寫為第二條等式的 最大值函數

                             (3)
                             「s_( y_i )  >=  s_( j ) + 1 」中的 "1" 
                              有關「"真實類別標籤" s_( y_i ) 『明顯』大於 "其它類別標籤" s_( j )」的陳述
                              若只以 >=  串接兩者，「明顯」的描述不夠明確
                              因此 "1" 可看作一個安全係數，確保兩者差異足夠明顯

                  ➡️ 圖形: Hinge (鉸鏈，合頁)
                        Multi-class SVM loss 的圖形長得像門的合頁，故又稱 Hinge Loss

                       Case1:   s_( y_i )  >=  s_( j ) + 1    →    Multi-class SVM loss = 0
                       「"真實類別標籤" s_( y_i ) 『明顯』大於 "其它類別標籤" s_( j )」
                        會使
                       「損失值為 0」

                       Case2:   s_( y_i )  <  s_( j ) + 1    →    Multi-class SVM loss = s_( j ) - s_( y_i ) + 1
                       「"真實類別標籤" s_( y_i ) 『無明顯』大於 "其它類別標籤" s_( j )」
                        會使
                       「損失值為 一條直線」

                  ➡️ 計算範例: 
                        (1) Q: { 貓咪、車子、青蛙 } Multi-class SVM 分類器的預測得分分別是 (3.2, 5.1, -1.7)
                                   若正確類別為貓，計算此分類器在貓咪類的 loss
                              A: 
                                   (步驟:
                                        定義: 總更新量  ← 0

                                        對所有其它錯誤類別：
                                            定義: 更新量 ← "錯誤類別的得分 - 真實類別的得分 + 1"
                                            更新量 ← max ( 0, 更新量 )
                                            總更新量  ← 總更新量 + 更新量

                                        特定類別的損失值  ← 總更新量
                                   )
                                  ------------------------------------------------------------------------------------
                                     loss (cat) = max ( 0, 5.1 - 3.2 + 1 ) + max ( 0, (-1.7) - 3.2 + 1 ) = 2.9

                        (2) Q: { 貓咪、車子、青蛙 } Multi-class SVM 分類器的預測得分分別是 (1.3, 4.9, 2.0)
                                   若正確類別為車，計算此分類器在車子類的 loss
                              A: loss (car) = max ( 0, 1.3 - 4.9 + 1 ) + max ( 0, 2 - 4.9 + 1 ) = 0
                                   //  或另一種方法:  正確類別標籤的分數最高，故 loss = 0

                        (3) Q: { 貓咪、車子、青蛙 } Multi-class SVM 分類器的預測得分分別是 (2.2, 2.5, -3.1)
                                   若正確類別為青蛙，計算此分類器在青蛙類的 loss
                              A: loss (frog) = max ( 0, 2.2 - (-3.1) + 1 ) + max ( 0, 2.5 - (-3.1) + 1 ) = 12.9

                        (3) Q: { 貓咪、車子、青蛙 } 承 (1) ~ (3)，計算此分類器的 loss
                              A: loss  = ( loss (cat) + loss (car) + loss (frog)) / 3 
                                            = (2.9+0+12.9)/3  ~=  5.27

                  ➡️ Q & A 
                        (1) Q: 計算範例 2 中，若車子的得分因為稍微搖晃 (jiggle) 而改變，loss (car) 會有何影響？
                              A: 若車子的得分變動不大
                                   邊界 (margin) 仍會保持不變 (=1)
                                   ---------------------------------------------------------
                                   補充 - 1: 
                                   margin = 1，令新值 X，當 2-X+1 > 0 (X < 3) 存在「非零 loss」
                                   // 計算範例 2 中，「得分較高的錯誤類別」為 青蛙類，其「得分為 2」
                                   // 且已知「邊界為 1」
                                   // 故「正確類別的得分需 >= 3」
                                   ---------------------------------------------------------
                                   補充 - 2: 
                                   > faintly 微弱的

                        (2) Q: Multi-class SVM 的 L_i 之最小值和最大值為何?
                              A: ➡️ (1) loss 最小值為 0
                                   ---------------------------------------------------------
                                   ➡️ 由 hinge loss 圖形可看出，即右側 = 0 的平坦函數值
                                   ➡️ 另一種方法: 
                                             當:「正確類別的得分最高」
                                             會使: L_i = 0 x (n-1) = 0

                                   ➡️ (2) loss 最大值為 ∞ 
                                   ---------------------------------------------------------
                                   ➡️ 由 hinge loss 圖形可看出，即左側無限延伸
                                   ➡️ 另一種方法: 
                                             已知 L_i = Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ]

                                             假設: 正確類別的得分 s_( y_i ) = -∞
                                             // 得分的數值範圍理論上沒有限制
                                                                ↓
                                             s_( j ) - s_( y_i ) + 1 = (有限實數集內 的 某個值) - (-∞) + 1 = ∞
                                                                ↓
                                                  max ( 0 , ∞ ) = ∞
                                                                ↓
                                             Σ_( j ≠ y_i ) [ ∞ ] = (n-1) x ∞ = ∞
                                                                ↓
                                                            L_i = ∞

                        (3) Q: 訓練初期，初始權重設定值通常是 ~= 0 的一批很小的隨機數值
                                   請問期望的 loss 為何？
                              A: 已知 s_( j ) ~= s_( y_i ) ~= 0
                                   故得 L_i = Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ]
                                                  = Σ_( j ≠ y_i )  [ max( 0, 0 - 0 + 1) ]
                                                  = (n - 1) x 1
                                                  =  n - 1   // 錯誤類別的數量
                                   ---------------------------------------------------------
                                   補充 - 1: 
                                   ➡️ 如果訓練初期，你的 loss 非 n-1 (n: 類別數量)，
                                         可能代表你的程式有問題，go check

                        (4) Q: 承 (3)，若 總和 (即 L_i 的總和: Σ_( j ≠ y_i )) 涵蓋所有類別，會怎樣？
                                   (包括 j = y_i)
                              A: total loss 會比原始定義的 total loss 多 1
                                   ---------------------------------------------------------
                                   補充 - 1: 
                                   n ( Σ_( j = y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ] )
                                   = n ( Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ] ) + 
                                      (score of correct class - score of correct class + 1)
                                   = n ( Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ] ) + 1

                                   // n : number
                                   ---------------------------------------------------------
                                   補充 - 2: 
                                   loss of zero (loss = 0) 的解釋是 not lossing at all 
                                   所以在單一類別的損失值 (L_i) 計算中
                                   通常只會考慮那些「錯誤類別」 (不是 image 之對應 class 的其它所有 classes)

                                   換句話說，是針對「所有非給定 label 的其它 labels」
                                   逐一計算殘差：當每一個「錯誤類別標籤的得分」遠大於「正確類別」，
                                                              則：懲罰一個非零值 loss ≠ 0
                                                              (希望「權重的數值」往正確的方向修正)；  
                                                              反之，
                                                              則：更新一個 loss = 0，代表不用做任何修正 
                                                              (保持不變)

                                   另一方面，
                                  「將『正確類別的得分』列入『L_i (單一類別的 loss)』的計算」到底有無意義？
                                   回到 L_i 的理解
                                   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                                   L_i 代表「與正確類別間差異的度量」：
                                       (a) 當「錯誤類別的得分大」並且「遠大於 (- margin) +正確類別的得分」
                                             (預測值 嚴重偏離 實際值)
                                             → 希望 L_i 大一點，使得修正的程度 (更新量) 較大 

                                       (b) 當「錯誤類別的得分小」但仍舊「大於 (- margin) +正確類別的得分」
                                             (預測值 稍微偏離 實際值)
                                             → 希望 L_i 小一點，使得修正的程度 (更新量) 較小
 
                                       (c) 只有當「錯誤類別的得分」小於或等於「(- margin) +正確類別的得分」
                                             (預測值 符合期待，足夠合理；
                                              不等式的右側，
                                              以「減去一個正實數 margin」確保「錯誤類別的得分『足夠小』」)
                                             → 希望 L_i = 0，不需做修正 
                                    ---------------------------------------------------------
                                   由上述說明可看出
                                   基本上「正確類別」在 L_i 的度量上，只扮演一個「被比較的對象」 
                                   而且確保錯誤類別的得分足夠小的方法是調整 margin 
                                   (margin 越大，對錯誤類別得分的容忍度越低)
                                   將「正確類別得分」納入 L_i 考量的實際作用並不大，沒必要特別這麼做

                        (5) Q: 若 L_i = Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ] 其中的 Σ (總和) 改成 平均
                                   會有何影響？
                              A: Doesn't change  (分類結果沒差)           
                                   ---------------------------------------------------------
                                   補充 -1
                                   L_i 中的 Σ 改成 平均，即: 「令 L_i ' = L_i / number of classes」

                                   考慮「同一個 dataset」的 number of classes 是一個「固定」常數：
                                   number of classes 的影響，會隨著訓練次數增加而被洗掉 (wash out)

                                   另外，通常損失值只關注相對數值 (衡量錯誤類的分數是否「相對小」) 而非絕對數值
                                   ---------------------------------------------------------
                                   若以圖形來表示的話
                                   類似: 分類結果不變 (原本若為線性分類，調整後仍是線性分類)
                                             只有尺度改變 (根據 number of classes 對不同資料集做不同程度的尺度縮放)
                                             仍可視為同一個分類問題
                                   ---------------------------------------------------------
                                   補充 -2
                                   loss 乘以或除以一個數，都會被學習過程裡乘以一個數或除以一個數抵銷

                                   ➡️ 詳見 Batch Normalization 或 Exponential weight decay

                        (6) Q: 若 L_i = Σ_( j ≠ y_i )  [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ]
                                   改成 L_i = Σ_( j ≠ y_i )  { [ max ( 0 , s_( j ) - s_( y_i ) + 1 ) ] ^ 2 }
                                   會有何影響？
                              A: Different (分類結果會有不同)
                                   ---------------------------------------------------------
                                   補充 -1
                                   這種調整，會帶來災難性的影響 (劇變)
                                   對於「錯誤類別的得分過高」的懲罰，會從「常數倍」變成「平方倍」
                                   是否應該制定這樣的 (平方倍的) 損失函數，取決於你應用 (應是指資料分佈)
                                   ---------------------------------------------------------
                                   補充 -2
                                   每一個介於兩種相異類別間的「決策邊界 (Decision boundary)」，
                                   (=> 可看作 the trade-offs between the goodness and badness)

                                   若原本是「線性函數」，調整後會變成「非線性函數」。
                                   (=> 以圖形表示，原本由「一條直線」作為「區分不同種類資料的漸進線或擬合線」
                                          若線性函數加上平方，
                                          則類似以「一條拋物線」作為「區分不同種類資料的漸進線或擬合線」)

                        (6) Q: 假設存在一個 W 使得 L = 0，這個 W 是唯一的嗎？
                              A: No, 2W is also has L = 0.
                                   ---------------------------------------------------------
                                   補充 -1

      📌 Multi-class SVM Loss: Example Code
                  def L_i_vectorized (X, Y_i, W):
                         scores = W.dot(X)    
                         //   ∀_( j ∈ class labels: [ 0,1,2 ] ) [ s_( j ) ]
                         //   i.e.,  [ 3.2  5.1  -1.7 ]  when  i = 0
                         //           [ 1.3  4.9    2.0 ]  when  i = 1
                         //           [ 2.2  2.5   -3.1 ]  when  i = 2

                         margins = np.maximum(0, scores - scores[Y_i] + 1)    
                         //  ∀_( j ) [ max ( 0, s_( j ) - s_( y_i ) + 1 ) ]
                         //   i.e.,  [ max(0, 3.2-3.2+1)  max(0, 5.1-3.2+1)  max(0, -1.7-3.2+1) ] 
                         //            = [ 1  2.9  0 ]  when  i = 0
                         //           [ max(0, 1.3-4.9+1)  max(0, 4.9-4.9+1)    max(0, 2.0-4.9+1) ] 
                         //            = [ 0  1  0 ]  when  i = 1
                         //           [ max(0, 2.2-(-3.1)+1)  max(0, 2.5-(-3.1)+1)   max(0, -3.1-(-3.1)+1) ] 
                         //            = [ 6.3  6.6  1 ]  when  i = 2

                         margins[Y_i] = 0    
                         //   ∀_( j ≠ y_i ) [ s_( j ) - s_( y_i ) + 1 ]
                         //   i.e.,  [ 1  2.9  0 ]  →  [ 0  2.9  0 ]  when i = 0
                         //           [ 0  1  0 ]  →  [ 0  0  0 ]  when i = 1
                         //           [ 6.3  6.6  1 ]  →  [ 6.3  6.6  0 ]  when i = 2

                         loss_i = np.sum(margins)    
                         //   i.e.,  sum( [ 0  2.9  0 ] ) = 2.9  when  i = 0
                         //           sum( [ 0  0  0 ] ) = 0  when  i = 1
                         //           sum( [ 6.3  6.6  0 ] ) = 12.9  when  i = 2

                         return loss_i
                         //   i.e.,  2.9  when  i = 0
                         //           0  when  i = 1
                         //          12.9  when  i = 2

      📌 Overfiting & Regularization
                  ➡️ 快速回顧: 機器學習的原理

                  損失函數: 
                         L ( W ) = 1/N  Σ_i to N  [ Li ( f ( x_i, W), y_i ) ]
                                         \\                                                       //                      
                                                資料損失 (Data loss)
                                                　模型預測結果
                                                    應該要與訓練資料匹配

                  (1)  
                  We only told our classifier: it should try to find a W that fits data.
                  But really in practice, we don't actually care that much about fitting the training data.
                  
                  我們只告訴我們的分類器：它應該嘗試找到適合數據的 W
                  但實務上我們並不太關心擬合訓練數據 
                  // 最基本的 ML 架構，在 performance of fitting 上，並沒有設計太多處理機制
                  // => 這邊是想引導出潛在的 overfiting 問題
                  //      以及，導入 regularization 的必要性

                  (2) 
                  The whole point of Machine Learning, 
                  is we use the training data to find a classifier, 
                  and we apply that thing to test data.

                  機器學習的全部意義在於:
                  我們利用訓練數據找到一個分類器，然後將其應用於測試數據

                  🔘 快速回顧: 機器學習的原理

                  🔘 損失函數: 
                        L ( W ) = 1/N  Σ_i to N  [ Li ( f ( x_i, W), y_i ) ]      +      λ R ( W ) 
                                         \\                                                       //              \\          //                    
                                             資料損失 (Data loss)                        正規化 (Regularization)
                                                 模型預測結果                                    模型應該儘量「簡單」
                                                 應該要與訓練資料匹配                     不會過度學習訓練集特徵
                                                                                                             因此加上它通常在測試集上會表現更好
                                                                                                             ➡️ R : 正規化懲罰 (Regularization Penalty)
                                                                                                             ➡️ λ : 正規化強度 (Regularization Strength)
                                                                                                                   　  是一種超參數 (Hyper-parameter)
                                                                                                             ➡️ 考慮一個多項式迴歸問題
                                                                                                                   用來最佳化的目標函數加入正規化項後
                                                                                                                   可以 誘導（encourage）模型 
                                                                                                                   選擇較低維度的擬合線（漸進線）
                                                                                                                   而不至於：過度擬合訓練集，而在測試集失準

                  🔘 概念: 取決於任務和模型
                   
                  🔘 奧卡姆剃刀 (Occam's Razor)
                        "Among competing hypotheses, the simplest is the best." --- William of Ockham, 1285 - 1317
                        解釋 ➡️ 根據某些實驗資料的觀察（observation）而做出多個相互比較優劣的假設之中，
                                       通常應該選擇相對簡單的假設，並將其推廣到未來較新的觀察上

                  🔘 何謂正規化「懲罰」
                        類似: 軟邊界、軟約束（soft constraint）
                       「懲罰」代表：資料點必須超過（overcome）這個這個「軟約束」才會被模型判斷為另一類

                  🔘 正規化懲罰的種類
                        ▫️ L2 :  R(W) = Σ_( k)  Σ_( l )  W^2_( k, l )
                                      最常見的形式

                                      L2 正規化僅是在懲罰權重向量 W 在歐式距離內的向量長度
                                      L2 regularization is just penalizing the Euclidean norm of this weight vector W
                                     
                                      其它變型：
                                      　－權重下降（weight decay）
                                      　－乘以 1/2
                                      
                        ▫️ L1 :  R(W) = Σ_( k)  Σ_( l )  | W_( k, l ) |
                                      跟稀疏性（Sparsity）有關

                        ▫️ Elastic Net ( L1 + L2 ) : R(W) = Σ_( k)  Σ_( l )  [  β  W^2_( k, l ) + | W_( k, l ) |  ]

                        ▫️ Max norm regularization

                        ▫️ Dropout

                        ▫️ Fancier: Batch Normalization 
                                              Stochastic Depth

                  🔘 延伸問題: L1 和 L2 正規化如何衡量（measure）模型的複雜度
                         example:
                             X = [ 1 1 1 1 ]
                             W_1 = [ 1 0 0 0 ]
                             W_2 = [ 0.25 0.25 0.25 0.25 ]
                             X dot W_1 = X dot W_2 = 1

                             ------------------------------------------
                             # L2 正規化如何衡量（measure）模型的複雜度
                             => L2 ( W_1) = 1, L2 ( W_2 ) = 1/16 * 4 = 0.25
                             => In terms of W_1 and W_2, 
                                   L2 regularization prefer W_2 because it has smaller norm.

                            L2 正規化對於模型的複雜度，主要以上述這種比較粗略的方式看待
                            L2 正規化的想法主要是: 
                                 (1)  它主要以「資料密集（density）程度」作為複雜性的衡量 🌟 
                                        即：資料點的分佈「越密集」，對 L2 正規化而言模型「複雜度越低」
                                       （可視為：歐幾里得空間中，以原點 (0,0) 為平均的離差平方和）
                                        它偏好選擇對於 輸入資料 X 中的每個 value (or entry) 
                                        都有一定程度影響的 權重 W
                                 (2)  這可能會使模型具有更高的 強固性 (robustness)
                                        因為 W 的最終數值更傾向於: 取決於整個 X，而非取決於 X 的一小部分
                            ------------------------------------------
                            # L1 正規化如何衡量（measure）模型的複雜度
                            => In terms of W_1 and W_2, 
                                  L1 regularization prefer W_1 because it has smaller norm.

                            L1 正規化的想法主要是: 
                                 它主要以「資料稀疏（sparsity）程度」作為複雜性的衡量 🌟 
                                 即：資料點的分佈「0s 的數量越少」，對 L2 正規化而言模型「複雜度越低」

🔷 Softmax Classifier (Multinomial Logistic Regression)

      📌 介紹
            🔘 Softmax Classifier，等同「多項式邏吉斯回歸」(Multinomial Logistic Regression)

            🔘 Softmax Classifier 的 loss function 對於 輸出分數（scores）的「可解釋性」較佳
                  // 〈比較〉
                  // Multi-class SVM 的 loss function 對於 輸出分數 的「可解釋性」較差
                  // => 只能得知: 希望「正確類別的得分」大於「錯誤類別的得分」
                  // => 但「得分」本身沒有太多意義或解釋

            🔘 Softmax Classifier 的 loss function
                  ➡️  得分 = 未正規化 的 類別機率值 取對數，符號: s
                  ➡️  Softmax 函數
                         P ( Y = k | X = x_i ) = ( e_( s )  *  k )  /  ( Σ_( j )  e_( s )  *  j ) 
                         where
                         s = f ( x_i ; W )
                         -----------------------
                         解釋: 
                          (1)  取自然指數
                                 針對: 輸入資料 x_i 、類別 k 的「得分」 s  計算其自然指數 e_( s ) 
                                 s 可能為正數有負數，而 e_( s ) 為正數

                          (2)  正規化
                                 將 e_( s )  x  k 除以 Σ_( j )  e_( s )  x  j ，
                                 即 Softmax 對單一類別的輸出機率值 P ( Y = k | X = x_i )，其值介於 [ 0,1 ]

                  ➡️  Softmax 分類器的 loss function
                          L_i  =  - log P ( Y = y_i | X = x_i ) 
                                 =  - log P ( e_( s )  *  y_i )  /  ( Σ_( j )  e_( s )  *  j ) 

                          //  L_i : loss function，負對數的估計機率值
                          //  P ( Y = y_i | X = x_i ) : 正確類別的估計機率值
                         -----------------------
                         解釋: 
                          (1)  上述 L_i 為針對特定單一類別所「計算出的機率分佈」，是一個「估計量」

                          (2)  與「真實的機率分佈」（目標）兩者的差值即是「殘差」

                          (3)  我們希望「計算出的機率分佈」匹配／接近（match / close to）「真實的機率分佈」
                                 //  真實機率分佈
                                 //  　只有 正確類別 的機率值是 1，其它類別的機率值都是 0

                                 //  衡量計算出的機率分佈和真實機率分佈的計算方法
                                 //  　計算方式-1: 　介於兩分佈間的「KL 散度」(KL divergence)
                                 //  　計算方式-2: 　最大概似估計 (MLE, Maximum Likelihood Estimation)

                          (4)  在 估計機率值 前面加上 - log 的用意
                                 因為 log 函數是一個簡單遞增函數 (monotonic function)
                                 「最大化: log (估計機率值)」會比針對「最大化: 估計機率值」容易
                                 所以設計為加上 log
                                 ---------------------------------
                                 更進一步，因為 loss function 通常定義為「最小化: 殘差」
                                 所以會再把 log 前面加上一個負號
                                 即:「最大化: log (估計機率值)」轉為「最小化: - log (估計機率值)」

      📌 Q&A
            🔘 Q1:  L_i 的理論最大／理論最小值為何？
            🔘 A1: 理論最大值 = + inf  （當正確類別的機率值 P = 0:  -log( 0 ) = log( 1 / 0 ) = + inf）
                         理論最小值 = 0  （當正確類別的機率值 P = 1:  -log( 1 ) = log( 1 ) = 0）

            🔘 Q2:  訓練初期， 因為 W 初始隨機值接近 0，因此所有類別的得分 s ~ = 0，
                           那麼訓練初期的 loss 應該為何？
            🔘 A2:  - log ( 1 / C ) = log ( C )
                          其中 C 代表類別數量
                          ➡️ 可作為測試的方法:  若訓練初期印出的 loss 值不是 log ( C )， go check 

            🔘 Q3:  試比較 Multi-class SVM 和 Softmax 分類器，在正確類別得分最高時，兩者有何差異
            🔘 A3:  Multi-class SVM 分類器
                               當滿足: 正確類別的得分大於一個代表「遠大於錯誤類別的得分」的特定值
                               停止對某資料點的最佳化
                               否則，持續對某資料點最佳化
                          Softmax 分類器
                               在指定次數下，無止盡地逼近「真實機率分佈」
                               即: 正確類別的機率值 = 1，其它所有錯誤類別機率值 = 0

🔷 最佳化 (Optimization)
      📌 Components
            🔘 prediction function, F
            🔘 loss function
            🔘 regularizer

      📌 最佳化策略 - 1: Random Search
            🔘 最蠢的第一種策略
                 ▫️ 步驟
                        1. 隨機取 n 組值作為不同的 W (權重) 的參數
                        2. 對每個 W 值: 都利用 L (X, Y, W) 計算此 W 對應的 loss 值
                        3. 若 loss 值比最佳 loss 更小: 則更新 最佳 loss，並記錄 W 作為最佳 W
                 ▫️ 實驗結果
                        CIFAR-10 的 10 種類別，各類別的 準確率 期望值 = 10%
                        實驗結果: Random Search 準確率 = 15%

      📌最佳化策略 - 2: Follow the Slope
            🔘 一維（單變量，如: f(x)）: 函數的導數（derivative），即: 函數 f 在 x 點附近的變化率
            🔘 多維（多變量，如: f(x, y)）: 函數的梯度，即: 沿每個維度的偏導數（partial derivatives）向量
       　 🔘 在任何方向上的斜率 = 「方向（某方向上的單位向量）」和「梯度」的點積（dot product）
       　 🔘 「負梯度方向」
                  將「最陡峭下降的方向」（某函數中: 「減少的值最大」的方向）定義為「負梯度」

            🔘 啟發: 此方法提供對於某函數的「線性一階近似」（linear, first-order approximation）
            🔘 權重向量 W 的實際運算流程
                  深度學習套件 ➡️ 不斷地計算給定函數的梯度 ➡️ 不斷地更新 W

      📌 評估梯度
            🔘 一種天真的方法 --- 有限差分法（Finite Differences）
                 ▫️ 意義
                       提供一種「數值型梯度」

                 ▫️ 步驟
                        1. 梯度的極限定義: 增加一個很小的值 h 之下，loss 的變化量
                        2. 根據 (1) 對每個 W 中的每個參數計算梯度

                 ▫️ 建議
                        1. 實際程式中，不要採用此方法，因為太慢、計算量龐大
                                 P.S. 在某些大型、複雜的 DL 模型，
                                         權重向量的參數數量可能不只此範例的 10 個，而是數千萬、數億個
                        2. 可做為檢查是否正確的 debugging tool

            🔘 牛頓－萊布尼茲法
                 ▫️ 意義
                       提供一種「分析型梯度」

                 ▫️ 建議
                        可在實際程式中用來評估梯度，此方法準確且快速

      📌 梯度下降法
            🔘 步驟
                  1. 使用隨機值，初始化 W (權重)
                  2. 不斷地: 
                      (a) 計算 loss 和梯度
                      (b) 根據步長（step size）和梯度，更新 W
                           ➡️ 步長是一個超參數，定義: 朝梯度的方向走多遠，又稱: 學習率（learning rate）

            🔘 種類
                 ▫️ 一般梯度下降法 (Gradient Descent)
                 ▫️ 一般梯度下降法 + Momentum
                 ▫️ Adam Optimizer
                 ▫️ 隨機梯度下降法 (Stochastic Gradient Descent)
                       Mini Batch: 從訓練集中抽樣出一個較小的集合
                                           為了縮減每一輪訓練的所需時間
                                           // 樣本數 通常是 2 的倍數 (32/64/128)

      📌 影像特徵
            🔘 影像分類流程
                 ▫️ 方法 1: 使用 線性分類器，並直接餵原始像素（feed raw pixels）訓練資料
                       ➡️ 將每個「像素強度」直接平坦化後直接轉交給線性分類器
                       ⭕: 「線性可分」（linear separability）的資料或許可以這樣做
                       ❌: 「多模態」（multi-modality）資料結果可能很糟

                 ▫️ 方法 2: 特徵萃取 → 使用 線性分類器，並使用具有代表性的特徵（features）訓練資料
                       ➡️ 蒐集影像 
                              → 計算影像的各種特徵表示（feature representations，如: 各方面描述外觀的量化資料） 
                                   並得到不同的特徵向量（feature vectors）
                              → 串接（concatenate）不同的特徵向量
                              → 放入分類器訓練

                 ▫️ 方法 3: 卷積神經網路（下一章 Lec 04 會提到）

            🔘 例: 顏色直方圖（Color Histogram）
                       ➡️ 步驟
                             1. 由可見光的光譜將顏色切分為固定數量的若干個桶子
                             2. 對每個像素: 依據色彩數值（如: RGB）累加對應桶子的計數
                             3. 最終得到描述影像「顏色分佈」的直方圖

            🔘 例: 梯度直方圖（Histogram of Gradient, HoG）
                       ➡️ Hubel & Wiesel: 方向的邊緣（oriented edge）在人類視覺系統中很重要
                       ➡️ 步驟
                             1. 由可見光的光譜將顏色切分為固定數量的若干個桶子
                             2. 對每個像素: 依據色彩數值（如: RGB）累加對應桶子的計數
                             3. 最終得到描述影像「顏色分佈」的直方圖

            🔘 例: 視覺詞袋（Visual Bag of Words）
                       ➡️ 每個視覺單詞（Visual word）在影像中的出現次數
                       ➡️ 視覺外觀
