碼上快樂

相關內容    簡體    繁體

sklearn數據集划分

本文轉載自   查看原文   2019-10-31 17:36   982    python

sklearn數據集划分方法有如下方法：

KFold，GroupKFold，StratifiedKFold，LeaveOneGroupOut，LeavePGroupsOut，LeaveOneOut，LeavePOut，ShuffleSplit，GroupShuffleSplit，StratifiedShuffleSplit，PredefinedSplit，TimeSeriesSplit，

①數據集划分方法——K折交叉驗證：KFold，GroupKFold，StratifiedKFold，

  • 將全部訓練集S分成k個不相交的子集，假設S中的訓練樣例個數為m，那么每一個自己有m/k個訓練樣例，相應的子集為{s1，s2，...，sk}
  • 每次從分好的子集里面，拿出一個作為測試集，其他k-1個作為訓練集
  • 在k-1個訓練集上訓練出學習器模型
  • 把這個模型放到測試集上，得到分類率的平均值，作為該模型或者假設函數的真實分類率

這個方法充分利用了所以樣本，但計算比較繁瑣，需要訓練k次，測試k次

 KFold：

復制代碼 
import numpy as np
#KFold
from sklearn.model_selection import KFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
kf=KFold(n_splits=2)    #分成幾個組
kf.get_n_splits(X)
print(kf)
for train_index,test_index in kf.split(X):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
#KFold(n_splits=2, random_state=None, shuffle=False) #Train Index: [3 4 5] ,Test Index: [0 1 2] #Train Index: [0 1 2] ,Test Index: [3 4 5]
復制代碼 
GroupKFold：
復制代碼 
import numpy as np
from sklearn.model_selection import GroupKFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
groups=np.array([1,2,3,4,5,6])
group_kfold=GroupKFold(n_splits=2)
group_kfold.get_n_splits(X,y,groups)
print(group_kfold)
for train_index,test_index in group_kfold.split(X,y,groups):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)

#GroupKFold(n_splits=2)
#Train Index: [0 2 4] ,Test Index: [1 3 5]
#Train Index: [1 3 5] ,Test Index: [0 2 4]
復制代碼 
StratifiedKFold：保證訓練集中每一類的比例是相同的
復制代碼 
import numpy as np
from sklearn.model_selection import StratifiedKFold
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,1,1,2,2,2])
skf=StratifiedKFold(n_splits=3)
skf.get_n_splits(X,y)
print(skf)
for train_index,test_index in skf.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)

#StratifiedKFold(n_splits=3, random_state=None, shuffle=False)
#Train Index: [1 2 4 5] ,Test Index: [0 3]
#Train Index: [0 2 3 5] ,Test Index: [1 4]
#Train Index: [0 1 3 4] ,Test Index: [2 5]
復制代碼 
 

②數據集划分方法——留一法：LeaveOneGroupOut，LeavePGroupsOut，LeaveOneOut，LeavePOut，

  • 留一法驗證（Leave-one-out，LOO）：假設有N個樣本，將每一個樣本作為測試樣本，其他N-1個樣本作為訓練樣本，這樣得到N個分類器，N個測試結果，用這N個結果的平均值來衡量模型的性能
  • 如果LOO與K-fold CV比較，LOO在N個樣本上建立N個模型而不是k個，更進一步，N個模型的每一個都是在N-1個樣本上訓練的，而不是（k-1）*n/k。兩種方法中，假定k不是很大而且k<<N，LOO比k-fold CV更耗時
  • 留P法驗證（Leave-p-out）：有N個樣本，將每P個樣本作為測試樣本，其它N-P個樣本作為訓練樣本，這樣得到個train-test pairs，不像LeaveOneOut和KFold，當P>1時，測試集將會發生重疊，當P=1的時候，就變成了留一法

 leaveOneOut：測試集就留下一個

復制代碼 
import numpy as np
from sklearn.model_selection import LeaveOneOut
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
loo=LeaveOneOut()
loo.get_n_splits(X)
print(loo)
for train_index,test_index in loo.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
#LeaveOneOut()
#Train Index: [1 2 3 4 5] ,Test Index: [0]
#Train Index: [0 2 3 4 5] ,Test Index: [1]
#Train Index: [0 1 3 4 5] ,Test Index: [2]
#Train Index: [0 1 2 4 5] ,Test Index: [3]
#Train Index: [0 1 2 3 5] ,Test Index: [4]
#Train Index: [0 1 2 3 4] ,Test Index: [5
復制代碼 
LeavePOut：測試集留下P個
復制代碼 
import numpy as np
from sklearn.model_selection import LeavePOut
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
lpo=LeavePOut(p=3)
lpo.get_n_splits(X)
print(lpo)
for train_index,test_index in lpo.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)

#LeavePOut(p=3)
#Train Index: [3 4 5] ,Test Index: [0 1 2]
#Train Index: [2 4 5] ,Test Index: [0 1 3]
#Train Index: [2 3 5] ,Test Index: [0 1 4]
#Train Index: [2 3 4] ,Test Index: [0 1 5]
#Train Index: [1 4 5] ,Test Index: [0 2 3]
#Train Index: [1 3 5] ,Test Index: [0 2 4]
#Train Index: [1 3 4] ,Test Index: [0 2 5]
#Train Index: [1 2 5] ,Test Index: [0 3 4]
#Train Index: [1 2 4] ,Test Index: [0 3 5]
#Train Index: [1 2 3] ,Test Index: [0 4 5]
#Train Index: [0 4 5] ,Test Index: [1 2 3]
#Train Index: [0 3 5] ,Test Index: [1 2 4]
#Train Index: [0 3 4] ,Test Index: [1 2 5]
#Train Index: [0 2 5] ,Test Index: [1 3 4]
#Train Index: [0 2 4] ,Test Index: [1 3 5]
#Train Index: [0 2 3] ,Test Index: [1 4 5]
#Train Index: [0 1 5] ,Test Index: [2 3 4]
#Train Index: [0 1 4] ,Test Index: [2 3 5]
#Train Index: [0 1 3] ,Test Index: [2 4 5]
#Train Index: [0 1 2] ,Test Index: [3 4 5]
復制代碼

 

③數據集划分方法——隨機划分法：ShuffleSplit，GroupShuffleSplit，StratifiedShuffleSplit

  • ShuffleSplit迭代器產生指定數量的獨立的train/test數據集划分，首先對樣本全體隨機打亂，然后再划分出train/test對，可以使用隨機數種子random_state來控制數字序列發生器使得訊算結果可重現
  • ShuffleSplit是KFlod交叉驗證的比較好的替代，他允許更好的控制迭代次數和train/test的樣本比例
  • StratifiedShuffleSplit和ShuffleSplit的一個變體，返回分層划分，也就是在創建划分的時候要保證每一個划分中類的樣本比例與整體數據集中的原始比例保持一致

#ShuffleSplit 把數據集打亂順序，然后划分測試集和訓練集，訓練集額和測試集的比例隨機選定，訓練集和測試集的比例的和可以小於1

復制代碼 
import numpy as np
from sklearn.model_selection import ShuffleSplit
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,3,4,5,6])
rs=ShuffleSplit(n_splits=3,test_size=.25,random_state=0)
rs.get_n_splits(X)
print(rs)
for train_index,test_index in rs.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)
print("==============================")
rs=ShuffleSplit(n_splits=3,train_size=.5,test_size=.25,random_state=0)
rs.get_n_splits(X)
print(rs)
for train_index,test_index in rs.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)

#ShuffleSplit(n_splits=3, random_state=0, test_size=0.25, train_size=None)
#Train Index: [1 3 0 4] ,Test Index: [5 2]
#Train Index: [4 0 2 5] ,Test Index: [1 3]
#Train Index: [1 2 4 0] ,Test Index: [3 5]
#==============================
#ShuffleSplit(n_splits=3, random_state=0, test_size=0.25, train_size=0.5)
#Train Index: [1 3 0] ,Test Index: [5 2]
#Train Index: [4 0 2] ,Test Index: [1 3]
#Train Index: [1 2 4] ,Test Index: [3 5]
復制代碼

 #StratifiedShuffleSplitShuffleSplit 把數據集打亂順序，然后划分測試集和訓練集，訓練集額和測試集的比例隨機選定，訓練集和測試集的比例的和可以小於1,但是還要保證訓練集中各類所占的比例是一樣的

復制代碼 
import numpy as np
from sklearn.model_selection import StratifiedShuffleSplit
X=np.array([[1,2],[3,4],[5,6],[7,8],[9,10],[11,12]])
y=np.array([1,2,1,2,1,2])
sss=StratifiedShuffleSplit(n_splits=3,test_size=.5,random_state=0)
sss.get_n_splits(X,y)
print(sss)
for train_index,test_index in sss.split(X,y):
    print("Train Index:",train_index,",Test Index:",test_index)
    X_train,X_test=X[train_index],X[test_index]
    y_train,y_test=y[train_index],y[test_index]
    #print(X_train,X_test,y_train,y_test)

#StratifiedShuffleSplit(n_splits=3, random_state=0, test_size=0.5,train_size=None)
#Train Index: [5 4 1] ,Test Index: [3 2 0]
#Train Index: [5 2 3] ,Test Index: [0 4 1]
#Train Index: [5 0 4] ,Test Index: [3 1 2]
復制代碼


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 sklearn之划分數據集 sklearn數據集的導入及划分 sklearn 划分數據集。 sklearn中的數據集的划分 sklearn之分類模型數據集的划分問題 數據集的划分 sklearn數據集 SKLearn數據集API（一） sklearn.model_selection.train_test_split划分訓練數據集 使用Sklearn-train_test_split 划分數據集
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM