Day05-內建學習-機器學習-分類模型(DataWhale)

二、sklearn建構分類項目

2.1 收集資料集并選擇合适的特征

使用IRIS鸢尾花資料集

from sklearn import datasets
import pandas as pd

iris = datasets.load_iris()
X = iris.data
y = iris.target
feature = iris.feature_names
data = pd.DataFrame(X, columns=feature)
data['target'] = y
data.head(2)
           

sepal length (cm)	sepal width (cm)	petal length (cm)	petal width (cm)	target
5.1	3.5	1.4	0.2
1	4.9	3.0	1.4	0.2

特征解釋：

• sepal length：花萼長度
• sepal width：花萼款年度
• sepal length：花瓣長度
• sepal width：花瓣寬度

2.2 選擇度量模型性能的名額

• 分類問題本身的因變量是離散變量
• 在分類任務種，對于每個類别犯錯的代價不盡相同

評價名額

• 真陽性TP(True Positive)：預測值和真實值都為正
• 真陰性TN(True Negative)：預測值與真實值都是負
• 假陽性FP(False Positive)：預測值為正，實際值為負
• 假陰性FN(False Negative): 預測值為負，實際值為負

模型名額：

• 準确率：分類正确的樣本數占總樣本的比例

  A C C = T P + T N T P + T N + F P + F N ACC = \frac{TP+TN}{TP+TN+FP+FN} ACC=TP+TN+FP+FNTP+TN​

• 精度：預測為正且分類正确的樣本占預測為正的比例

  P R E = T P T P + F P PRE = \frac{TP}{TP+FP} PRE=TP+FPTP​

• 召回率：預測為正且分類正确的樣本占類别為正的比例

  R E C = T P T P + F N REC = \frac{TP}{TP+FN} REC=TP+FNTP​

• F1值：綜合衡量精度和召回率

  F 1 = 2 P R E × R E C P R E + R E C F1 = 2\frac{PRE \times REC}{PRE + REC} F1=2PRE+RECPRE×REC​

• ROC曲線：以假陽率為橫軸，真陽率為縱軸畫出來的曲線，曲線下方面積越大越好

  真陽率： T P R = T P T P + F P TPR = \frac{TP}{TP+FP} TPR=TP+FPTP​

  假陽率： F P R = F P T P + F P FPR = \frac{FP}{TP+FP} FPR=TP+FPFP​

2.3 選擇具體的模型并訓練

2.3.1 邏輯回歸Logistic Regression

邏輯回歸的因變量一般是二分類

正常步驟：

• 尋找h函數(hypothesis)
• 構造J函數(損失函數)
• 尋找使J函數最小時的 θ \theta θ

(1) 構造預測函數h

利用sigmoid函數:

g ( z ) = 1 1 + e − z g(z) = \frac{1}{1+e^{-z}} g(z)=1+e−z1​

對于線性邊界，邊界為：

θ 0 + θ 1 x 1 + . . . + θ n x n = ∑ i = 1 n θ i x i = θ T x \theta_0+\theta_1x_1+...+\theta_nx_n = \sum_{i=1}^{n}\theta_ix_i = \theta^Tx θ0​+θ1​x1​+...+θn​xn​=i=1∑n​θi​xi​=θTx

構造預測函數為：

h θ ( x ) = g ( θ T x ) = 1 1 + e − θ T x h_\theta(x) = g(\theta^Tx) = \frac{1}{1+e^{-\theta^{T}x}} hθ​(x)=g(θTx)=1+e−θTx1​

h θ ( x ) h_\theta(x) hθ​(x)：表示結果取1的機率

P ( y = 1 ∣ x ; θ ) = h θ ( x ) P(y=1|x;\theta)=h_\theta(x) P(y=1∣x;θ)=hθ​(x)

P ( y = 0 ∣ x ; θ ) = 1 − h θ ( x ) P(y=0|x;\theta)=1-h_\theta(x) P(y=0∣x;θ)=1−hθ​(x)

(2)構造損失函數J

基于最大似然估計推導出:

C o s t ( h θ ( x ) , y ) = { − l o g ( h θ ( x ) ) y = 1 − l o g ( 1 − h θ ( x ) ) y = 0 Cost(h_\theta(x),y) = \begin{cases} -log(h_\theta(x)) & y=1\\ -log(1-h_\theta(x)) & y=0 \end{cases} Cost(hθ​(x),y)={−log(hθ​(x))−log(1−hθ​(x))​y=1y=0​

因為預測值越高，損失值越小，是以取 − J ( θ ) -J(\theta) −J(θ)

J ( θ ) = − 1 m ∑ i = 1 n C o s t ( h θ ( x i ) ) J ( θ ) = − 1 m ∑ i = 1 n ( y ( i ) l o g ( h θ x ( i ) ) + ( 1 − y ( i ) ) l o g ( 1 − h θ x ( i ) ) ) ) J(\theta)=-\frac{1}{m}\sum_{i=1}^{n}Cost(h_\theta(x^{i}))\\ J(\theta)=-\frac{1}{m}\sum_{i=1}^{n}(y^{(i)}log (h_\theta x^{(i)})+(1-y^{(i)})log(1-h_\theta x^{(i)} ))) J(θ)=−m1​i=1∑n​Cost(hθ​(xi))J(θ)=−m1​i=1∑n​(y(i)log(hθ​x(i))+(1−y(i))log(1−hθ​x(i))))

對 J ( θ ) J(\theta) J(θ)求導結果為：

J ( θ ) = − ∑ i = 1 n ( y ( i ) − h θ ( x i ) ) x ( i ) J(\theta) = -\sum_{i=1}^{n}(y^{(i)}-h_\theta(x^{i}))x^{(i)} J(θ)=−i=1∑n​(y(i)−hθ​(xi))x(i)

采用梯度下降疊代求解：

θ = θ + α ( Y − h θ ( x i ) ) X \theta = \theta +\alpha (Y -h_\theta(x^{i}))X θ=θ+α(Y−hθ​(xi))X

代碼

https://zhuanlan.zhihu.com/p/159308288

# 選擇sepal length (cm)、petal length (cm)進行研究
import pandas as pd 
import matplotlib.pyplot as plt

X1 = data[['sepal length (cm)','petal length (cm)','target' ]] 
z0 = X1[X1['target']==0]
z1 = X1[X1['target']==1]
z2 = X1[X1['target']==2]

plt.scatter(z0.iloc[:,0],z0.iloc[:,1] ,color = 'red',marker='o',label='0Type')
plt.scatter(z1.iloc[:,0],z1.iloc[:,1] ,color = 'blue',marker='x',label='1Tyoe')
plt.scatter(z2.iloc[:,0],z2.iloc[:,1] ,color = 'green',marker='+',label='2Type')
plt.xlabel('sepal length')
plt.ylabel('petal length')
plt.legend(loc=2)
plt.show()
           

# 使用邏輯回歸進行分類

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler ,PolynomialFeatures
from sklearn.pipeline import Pipeline
import matplotlib.patches as mpatches
import matplotlib as mpl


x = X1.iloc[:,:2]
y = X1.iloc[:,2]
lr = Pipeline([('sc', StandardScaler()),
                   ('poly', PolynomialFeatures(degree=10)),
                   ('clf', LogisticRegression(max_iter=1000)) ])#打開最大限制
lr.fit(x,y)
y_hat = lr.predict(x)
y_hat_prob = lr.predict_proba(x)
np.set_printoptions(suppress=True)
print('準确度：%.2f%%' % (100*np.mean(y_hat == y.ravel())))
           

準确度：96.00%
           

# 畫圖
N, M = 200, 200     # 橫縱各采樣多少個值
x1_min, x1_max = x.iloc[:, 0].min(), x.iloc[:, 0].max()   # 第0列的範圍
x2_min, x2_max = x.iloc[:, 1].min(), x.iloc[:, 1].max()   # 第1列的範圍
t1 = np.linspace(x1_min, x1_max, N)
t2 = np.linspace(x2_min, x2_max, M)
x1, x2 = np.meshgrid(t1, t2)                    # 生成網格采樣點
x_test = np.stack((x1.flat, x2.flat), axis=1)   # 測試點


mpl.rcParams['font.sans-serif'] = ['simHei']
mpl.rcParams['axes.unicode_minus'] = False
cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF'])
cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b'])
y_hat = lr.predict(x_test)                
y_hat = y_hat.reshape(x1.shape)   
plt.figure(facecolor='w')
plt.pcolormesh(x1, x2, y_hat, cmap=cm_light)  
plt.scatter(z0.iloc[:,0],z0.iloc[:,1] ,color = 'red',marker='o',label='0Type')
plt.scatter(z1.iloc[:,0],z1.iloc[:,1] ,color = 'blue',marker='x',label='1Type')
plt.scatter(z2.iloc[:,0],z2.iloc[:,1] ,color = 'green',marker='+',label='2Type')
plt.xlabel(u'花萼長度', fontsize=14)
plt.ylabel(u'花瓣長度', fontsize=14)
plt.xlim(x1_min, x1_max)
plt.ylim(x2_min, x2_max)
plt.grid()
patchs = [mpatches.Patch(color='#77E0A0', label='0Type'),
              mpatches.Patch(color='#FF8080', label='1Type'),
              mpatches.Patch(color='#A0A0FF', label='2Type')]
plt.legend(handles=patchs, fancybox=True, framealpha=0.8)
plt.title(u'鸢尾花Logistic回歸分類效果', fontsize=17)
plt.show()
           

2.3.2 線性判别分析

**思想是：**最大化類間均值，最小化類内方差。意思就是将資料投影在低次元上，并且投影後同種類别資料的投影點盡可能的接近，不同類别資料的投影點的中心點盡可能的遠。

參數

• solver：:{‘svd’，‘lsqr’，‘eigen’}，預設=‘svd’

  ‘svd’：奇異值分解（預設）。不計算協方差矩陣，是以建議将此求解器用于具有大量特征的資料。

  ‘lsqr’：最小二乘解，可以與收縮結合使用。

  ‘eigen’：特征值分解，可以與收縮結合使用。

• shrinkage：收縮參數可能使用的值
• priors：先驗機率。預設情況下，類的比例是根據訓練集推斷出來的。
• n_components：降維所保留的成分個數
• store_convariance：若為真，當解算器為"svd"時，明确計算權重的類内協方差矩陣。

屬性

• chef_：權重向量。
• intercept_
• covariance_：權重類内協方差矩陣
• explained_variance_ratio_：每個被選中成分所能解釋的方差的百分比
• means_
• priors_：類先驗(和為1)。
• classes_：唯一類标簽。

方法

• decision_function(self, X): 将決策函數應用于樣本數組
• fit(self, X, y)
• fit_transform(self, X[, y])：拟合資料然後将其進行轉化
• predict(self, X)
• predict_log_proba(self, X)：估計對數機率
• predict_proba(self, X)：估計機率
• transform(self, X)： 将資料投射至最大類分塊中
• score：傳回給定測試資料和标簽的平均精度

from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
lda_iris = LinearDiscriminantAnalysis()
lda_iris.fit(X,y)
lda_iris.score(X,y)
           

0.98
           

2.3.3 樸素貝葉斯

思想： 假設特征之間是獨立的，将線性判别分析中的協方差矩陣中的協方差全部變成0，隻保留各自特征的方差

參數

• priors
• var_smoothing：所有特征的最大方差部分，添加到方差中用于提高計算穩定性。

屬性

• class_count_：每個類别中保留的訓練樣本數量。
• class_prior_：每個類别的機率。
• classes_；分類器已知的類别标簽
• epsilon_：方差的絕對相加值
• sigma_：每個類中每個特征的方差
• theta_：每個類中每個特征的均值

參數

• fit()
• partial_fit(X, y[, classes, sample_weight]): 對一批樣本進行增量拟合
• predict(X)
• predict_log_proba(X)
• predict_proba(X)
• score(X, y[, sample_weight])：傳回給定測試資料和标簽上的平均準确率。

from sklearn.naive_bayes import GaussianNB
NB_iris = GaussianNB()
NB_iris.fit(X, y)
NB_iris.score(X,y)
           

0.96
           

2.3.4 決策樹

思路： 給定一個觀測值，因變量的預測值為它所屬的終端結點内訓練集的最常出現的類。分類錯誤率作為确定分裂節點的準則(分類錯誤率：此區域内的訓練集中非常見類所占比例)

決策樹分類算法的完整步驟：

a. 選擇最優切分特征j以及該特征上的最優點s：

周遊特征j以及固定j後周遊切分點s，選擇使得基尼系數或者交叉熵最小的(j,s)

b. 按照(j,s)分裂特征空間，每個區域内的類别為該區域内樣本比例最多的類别。

c. 繼續調用步驟1，2直到滿足停止條件，就是每個區域的樣本數小于等于5。

d. 将特征空間劃分為J個不同的區域，生成分類樹。

參數：

• criterion：度量樹的切分品質的方法{“gini”, “entropy”}
• splitter：在每個節點上拆分政策的選擇
• max_depth：樹的最大深度
• min_samples_split：拆分内部節點所需的最少樣本數
• min_samples_leaf：在葉節點處所需的最小樣本數
• min_weight_fraction_leaf；在所有葉節點處（所有輸入樣本）的權重總和中的最小權重分數
• max_features：尋找最佳分割時要考慮的特征數量
• random_state：控制估計器的随機性

屬性

• classes_：類标簽
• feature_importances_：特征重要程度資料
• max_features_：max_features 的推斷值。
• n_classes_：整數的類别數
• n_features_：模型拟合訓練時的特征數量
• n_outputs_：模型拟合訓練時的輸出數量
• tree_：基礎的Tree對象。

方法

• apply(X):傳回每個葉子節點上被預測樣本的索引。
• cost_complexity_pruning_path(X, y):在最小化成本複雜性修剪期間計算修剪路徑
• decision_path(X): 傳回決策樹的決策路徑。
• get_depth():決策樹的深度
• get_n_leaves():決策樹的葉子數
• predict()
• predict_log_proba()
• predict_proba()
• score()

from sklearn.tree import DecisionTreeClassifier
tree_iris = DecisionTreeClassifier(min_samples_leaf=5)
tree_iris.fit(X,y)
tree_iris.score(X,y)
           

0.9733333333333334
           

2.3.5 支援向量機SVM

思想： 找到一個分割平面将兩個類别分開

參數:

• C：正則化參數。正則化的強度與C成反比。必須嚴格為正。
• kernel：指定算法中使用的核心類型。{‘linear’,‘poly’,‘rbf’,‘sigmoid’,‘precomputed’}
• defree：多項式核函數的次數。
• gamma：核系數。浮點數或者{scale, auto} , 預設scale
• coef0：核函數中的獨立項。隻在’poly’和’sigmoid’中有意義
• probability：是否啟用機率估計
• tol：殘差收斂條件。
• epsilon：epsilon-SVR模型中的Epsilon。它指定了在訓練損失函數中預測值與實際值之間距離為epsilon的epsilon-tube。
• shrinking：是否使用縮小啟發式
• cache_size：指定核心緩存的大小
• verbose：是否啟用詳細輸出。此參數針對liblinear中運作每個程序時設定，如果啟用，則可能無法在多線程上下文中正常工作
• max_iter：對求解器内的疊代進行硬性限制，或者為-1（無限制時）

屬性：

• support_：支援向量的名額。
• support_vectors_：支援向量
• n_support_：每個類别的支援向量數量。
• dual_coef_：決策函數中支援向量的系數。
• coef_：系數
• fit_status_：如果拟合無誤，則為0；否則為1
• intercept_：截距
• classes_：不重複類别标簽
• shape_fit_：訓練向量X的數組次元

方法：

• decision_function(X)：計算X中樣本的決策函數
• fit()：拟合模型
• get_params([deep])：擷取這個估計器的參數
• predict(X)
• score(X,y)
• set_params()

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC

svc_iris = make_pipeline(StandardScaler(), SVC(gamma='auto'))
svc_iris.fit(X, y)
svc_iris.score(X,y)
           

0.9733333333333334
           

Z. 補充

Z1. sigmoid函數

# 繪制sigmoid函數圖像
import numpy as np 
import matplotlib.pyplot as plt
def sigmoid(x):
    y = 1/(1+np.exp(-x))
    return y

x = np.arange(-8,8,0.2)
y = sigmoid(x)
plt.plot(x,y)
plt.show()
           

Z2. 梯度下降法

https://zhuanlan.zhihu.com/p/36564434

原理

• 常用的一階優化方法
• 求解無限制優化問題，找到 m i n f ( x ) minf(x) minf(x)

推導

考慮一個無限制優化問題 m i n f ( x ) minf(x) minf(x)，其中 f ( x ) f(x) f(x)為連續函數，構造序列 x 0 , x 1 , x 2 , . . . x^0,x^1,x^2,... x0,x1,x2,...使得 f ( x t + 1 ) < f ( x t ) ， t = 1 , 2 , 3 , . . . f(x^{t+1})<f(x^t)，t=1,2,3,... f(xt+1)<f(xt)，t=1,2,3,...，不斷執行該過程，即可收斂到局部極小點

對于一進制函數，函數值僅随着 x x x的變化而變化，設計下一個 x t + 1 x^{t+1} xt+1是沿着某一方向走一小步 Δ x \Delta x Δx得到的。

對于一進制函數， x x x存在兩個方向，正向 Δ x > 0 \Delta x > 0 Δx>0，負向 Δ x < 0 \Delta x < 0 Δx<0，使用泰勒展開式：

f ( x + Δ x ) ≈ f ( x ) + Δ x ∇ f ( x ) f(x+\Delta x) \approx f(x)+\Delta x \nabla f(x) f(x+Δx)≈f(x)+Δx∇f(x)

梯度下降的目的是使 f ( x + Δ x ) < f ( x ) f(x+\Delta x)<f(x) f(x+Δx)<f(x)，是以需要保證

$\Delta x\nabla f(x)<0 $

選擇令：

Δ x = − α ∇ f ( x ) ( α > 0 ) \Delta x = -\alpha\nabla f(x)\quad(\alpha >0) Δx=−α∇f(x)(α>0)

α \alpha α是一個較小的整數，進而： Δ x ∇ f ( x ) = − α ( ∇ f ( x ) ) 2 \Delta x \nabla f(x) = -\alpha\big(\nabla f\left(x\right)\big)^2 Δx∇f(x)=−α(∇f(x))2，是以保證了 Δ x ∇ f ( x ) < 0 \Delta x \nabla f(x) <0 Δx∇f(x)<0

進而，設定

f ( x + Δ x ) = f ( x − α ∇ f ( x ) ) < f ( x ) f(x+\Delta x) = f(x-\alpha \nabla f(x)) < f(x) f(x+Δx)=f(x−α∇f(x))<f(x)

隻需要令 x t + 1 = x t − α ∇ f ( x t ) x^{t+1} = x^t-\alpha \nabla f(x^t) xt+1=xt−α∇f(xt)就可以沿負梯度方向走

代碼實作

import numpy as np
import matplotlib.pyplot as plt

def f(x):
    return np.power(x,2) #計算x的2次方

def d_f_1(x):
    return 2.0*x

def d_f_2(f, x,delta=1e-4):
    return (f(x+delta)-f(x-delta))/(2*delta)
           

xs = np.arange(-10, 11)
plt.plot(xs,f(xs))
plt.show()
           

learning_rate = 0.1
max_loop = 30

x_init = 10.0
x = x_init
lr = 0.1
for i in range(max_loop):
    d_f_x = d_f_2(f,x)
    x = x- learning_rate * d_f_x
    print(x)
print('initial x = ', x_init)
print('arg min f(x) of x = ',x)
print('f(x)=',f(x))
           

8.000000000004661
6.400000000004837
5.120000000003557
4.0960000000043095
3.276800000005622
2.6214400000032967
2.097152000001259
1.6777216000003392
1.3421772800004028
1.0737418240003205
0.8589934592002546
0.6871947673602241
0.5497558138881831
0.4398046511105336
0.35184372088844174
0.2814749767107627
0.22517998136861533
0.18014398509489674
0.14411518807592116
0.11529215046073862
0.09223372036859068
0.07378697629487216
0.05902958103589708
0.047223664828717364
0.03777893186297355
0.03022314549037856
0.024178516392302875
0.019342813113842325
0.015474250491073885
0.012379400392859128
initial x =  10.0
arg min f(x) of x =  0.012379400392859128
f(x)= 0.00015324955408672073
           

Z3. 簡單線性基本推導公式

https://mp.weixin.qq.com/s/6pHrXJ-O2LLYGPzZHOF4hw

對于簡單線性回歸

• 損失函數

  損失函數描述了單個樣本預測值和真實值之間誤差的程度。用來度量模型一次預測的好壞

  損失函數是衡量預測模型預測期望結果表現的名額。損失函數越小，模型的魯棒性越好。

  常見的損失函數

  • 0-1損失函數

    用來表述分類問題，當預測分類錯誤時，損失函數值為1，正确為0

    L ( Y , f ( X ) ) = { 1 , Y ≠ f ( X ) 0 , Y = f ( X ) L(Y,f(X)) = \begin{cases} 1, Y \neq f(X) \\ 0, Y = f(X) \end{cases} L(Y,f(X))={1,Y​=f(X)0,Y=f(X)​

  • 平方損失函數

    用來描述回歸問題，用來表示連續性變量，為預測值與真實值內插補點的平方。（誤內插補點越大、懲罰力度越強，也就是對內插補點敏感）

    L ( Y , f ( X ) ) = ( Y − f ( X ) ) 2 L(Y,f(X)) = (Y-f(X))^2 L(Y,f(X))=(Y−f(X))2

  • 絕對損失函數

    用在回歸模型，用距離的絕對值來衡量

    L ( Y , f ( X ) ) = ∣ Y − f ( X ) ∣ L(Y,f(X)) = |Y - f(X)| L(Y,f(X))=∣Y−f(X)∣

  • 對數損失函數

    是預測值Y和條件機率之間的衡量。事實上，該損失函數用到了極大似然估計的思想。P(Y|X)通俗的解釋就是：在目前模型的基礎上，對于樣本X，其預測值為Y，也就是預測正确的機率。由于機率之間的同時滿足需要使用乘法，為了将其轉化為加法，我們将其取對數。最後由于是損失函數，是以預測正确的機率越高，其損失值應該是越小，是以再加個負号取個反。

    L ( Y , f ( X ) ) = − l o g P ( Y ∣ X ) L(Y,f(X)) = -logP(Y|X) L(Y,f(X))=−logP(Y∣X)

以上損失函數是針對于單個樣本的，但是一個訓練資料集中存在N個樣本，N個樣本給出N個損失，使用風險函數

• 期望風險

  期望風險是損失函數的期望，用來表達理論上模型f(X)關于聯合分布P(X,Y)的平均意義下的損失。又叫期望損失/風險函數。

  R e x p ( f ) = E p [ L ( Y , f ( X ) ) ] = ∫ X × Y L ( y , f ( x ) ) P ( x , y ) d x d y R_{exp}(f) = E_p[L(Y,f(X))] = \int_{X\times Y}L(y,f(x))P(x,y)dxdy Rexp​(f)=Ep​[L(Y,f(X))]=∫X×Y​L(y,f(x))P(x,y)dxdy

• 經驗函數

  模型f(X)關于訓練資料集的平均損失，稱為經驗風險或經驗損失。

  R e m p ( f ) = 1 N ∑ i = 1 N L ( y i , f ( x i ) ) R_{emp}(f) = \frac{1}{N}\sum_{i=1}^{N}L(y_i,f(x_i)) Remp​(f)=N1​i=1∑N​L(yi​,f(xi​))

  經驗風險最小的模型為最優模型。在訓練集上最小經驗風險最小，也就意味着預測值和真實值盡可能接近，模型的效果越好。公式含義為取訓練樣本集中對數損失函數平均值的最小。

• 經驗風險最小化和結構風險最小化

  期望風險是模型關于聯合分布的期望損失，經驗風險是模型關于訓練樣本資料集的平均損失。根據大數定律，當樣本容量N趨于無窮時，經驗風險趨于期望風險。是以，用經驗風險去估計期望風險。是由于訓練樣本個數有限，可能會出現過度拟合的問題，即決策函數對于訓練集幾乎全部拟合，但是對于測試集拟合效果過差。是以需要對其進行矯正：(當樣本容量不大的時候，經驗風險最小化容易産生“過拟合”的問題，為了“減緩”過拟合問題，提出了結構風險最小理論。結構風險最小化為經驗風險與複雜度同時較小。)

  m i n 1 N ∑ i = 1 N L ( y i , f ( x i ) ) + λ J ( f ) min \frac{1}{N}\sum_{i=1}{N}L(y_i,f(x_i))+\lambda J(f) minN1​i=1∑​NL(yi​,f(xi​))+λJ(f)

  在經驗風險上加上一個正則化項(regularizer)，或者叫做罰項(penalty) 。正則化項是J(f)是函數的複雜度再乘一個權重系數（用以權衡經驗風險和複雜度）