精华内容
下载资源
问答
  • kfold
    千次阅读
    2019-08-04 17:02:36

    https://blog.csdn.net/kancy110/article/details/74910185

    折交叉验证:sklearn.model_selection.KFold(n_splits=3, shuffle=False, random_state=None)

    思路:将训练/测试数据集划分n_splits个互斥子集,每次用其中一个子集当作验证集,剩下的n_splits-1个作为训练集,进行n_splits次训练和测试,得到n_splits个结果

    注意点:对于不能均等份的数据集,其前n_samples % n_splits子集拥有n_samples // n_splits + 1个样本,其余子集都只有n_samples // n_splits样本

    参数说明:

    n_splits:表示划分几等份

    shuffle:在每次划分时,是否进行洗牌

    ①若为Falses时,其效果等同于random_state等于整数,每次划分的结果相同

    ②若为True时,每次划分的结果都不一样,表示经过洗牌,随机取样的

    random_state:随机种子数

    属性:

    ①get_n_splits(X=None, y=None, groups=None):获取参数n_splits的值

    ②split(X, y=None, groups=None):将数据集划分成训练集和测试集,返回索引生成器

    通过一个不能均等划分的栗子,设置不同参数值,观察其结果

    ①设置shuffle=False,运行两次,发现两次结果相同

    In [1]: from sklearn.model_selection import KFold
       ...: import numpy as np
       ...: X = np.arange(24).reshape(12,2)
       ...: y = np.random.choice([1,2],12,p=[0.4,0.6])
       ...: kf = KFold(n_splits=5,shuffle=False)
       ...: for train_index , test_index in kf.split(X):
       ...:     print('train_index:%s , test_index: %s ' %(train_index,test_index))
       ...:
       ...:
    train_index:[ 3  4  5  6  7  8  9 10 11] , test_index: [0 1 2]
    train_index:[ 0  1  2  6  7  8  9 10 11] , test_index: [3 4 5]
    train_index:[ 0  1  2  3  4  5  8  9 10 11] , test_index: [6 7]
    train_index:[ 0  1  2  3  4  5  6  7 10 11] , test_index: [8 9]
    train_index:[0 1 2 3 4 5 6 7 8 9] , test_index: [10 11]
     
    In [2]: from sklearn.model_selection import KFold
       ...: import numpy as np
       ...: X = np.arange(24).reshape(12,2)
       ...: y = np.random.choice([1,2],12,p=[0.4,0.6])
       ...: kf = KFold(n_splits=5,shuffle=False)
       ...: for train_index , test_index in kf.split(X):
       ...:     print('train_index:%s , test_index: %s ' %(train_index,test_index))
       ...:
       ...:
    train_index:[ 3  4  5  6  7  8  9 10 11] , test_index: [0 1 2]
    train_index:[ 0  1  2  6  7  8  9 10 11] , test_index: [3 4 5]
    train_index:[ 0  1  2  3  4  5  8  9 10 11] , test_index: [6 7]
    train_index:[ 0  1  2  3  4  5  6  7 10 11] , test_index: [8 9]
    train_index:[0 1 2 3 4 5 6 7 8 9] , test_index: [10 11]

     

    更多相关内容
  • 1.我要做交叉验证,需要每个训练集和测试集都保持相同的样本分布比例,直接用sklearn提供的KFold并不能满足这个需求。 2.将生成的交叉验证数据集保存成CSV文件,而不是直接用sklearn训练分类模型。 3.在编码过程中有...
  • HLS_KNN_K折叠 对KNN使用的火车/测试数据进行交叉验证。
  • kfold

    2020-12-06 16:14:03
    from sklearn.model_selection import GroupKFold,KFold def group_k_fold(): ''' K-fold iterator variant with non-overlapping groups. 根据组来划分数据,不同组的类别与数据的折数相等。相同组里面的数据...
    import numpy as np
    from sklearn.model_selection import GroupKFold,KFold
    def group_k_fold():
        '''
        K-fold iterator variant with non-overlapping groups.
        根据组来划分数据,不同组的类别与数据的折数相等。相同组里面的数据不会出现在两个不同的折中。
    
        The same group will not appear in two different folds (the number of
        distinct groups has to be at least equal to the number of folds).
    
        The folds are approximately balanced in the sense that the number of
        distinct groups is approximately the same in each fold.
    
        '''
        X = np.array([[1, 2], [3, 4], [5, 6], [7, 8],[9,10],[10,11]])
        y = np.array([1, 2, 3, 4,5,6])
        groups = np.array([0, 0, 2, 2, 3, 3])
        group_kfold = GroupKFold(n_splits=3)
        # n_splits: int, default = 5 Number of folds.Must be at least of 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:", train_index, "TEST:", test_index)
    
            X_train, X_test = X[train_index], X[test_index]
    
            y_train, y_test = y[train_index], y[test_index]
    
            print('\n X_train:', X_train, '\n X_test:', X_test, '\n y_train:', y_train, '\n y_test:', y_test)
            print('**** step ****')
    
    def k_fold():
        '''
        将数据随机地分成K等份,每次留一份作为测试集,其余的作为训练集。进行K次
    
        '''
        x = ['a', 'b', 'c', 'd', 'e', 'f']
        kf = KFold(n_splits=3)  # 先将KFold实例化  3折就是将训练数据三等分,每次取其中的1/3作为测试集,其余的是训练集
        for train, test in kf.split(x):  # 调用split方法,将原始数据集划分
            print(train, test)
    
    group_k_fold()
    
    
    展开全文
  • 5. KFold, StratifiedKFold,StratifiedShuffleSplit, GroupKFold区别以及Stratified Group KFold

    5. KFold, StratifiedKFold,StratifiedShuffleSplit, GroupKFold区别以及Stratified Group KFold 实现

    在机器学习,一般不能直接拿整个数据集取训练,而采用cross-validation方法来训练。增强随机性减小噪声等,来减少过拟合,从而有限的数据中获取学习到更全面的信息,增强模型的泛化能力。在sklearn中,经常使用的有:KFold, StratifiedKFold,StratifiedShuffleSplit, GroupKFold。逐一解释使用区别,使用一个简单的df。(一般情况下, n_splits=5/10)

    import pandas as pd
    import numpy as np
    from sklearn.model_selection import KFold, StratifiedKFold,\
                StratifiedShuffleSplit, GroupKFold, GroupShuffleSplit
              
              
    df2 = pd.DataFrame([[6.5, 1, 2],
                [8, 1, 0],
                [61, 2, 1],
                [54, 0, 1],
                [78, 0, 1],
                [119, 2, 2],
                [111, 1, 2],
                [23, 0, 0],
                [31, 2, 0]], columns=['h', 'w', 'class'])
    df2
    
    	h		w class
    0	6.5		1	2
    1	8.0		1	0
    2	61.0 	2	1
    3	54.0	0	1
    4	78.0	0	1
    5	119.0	2	2
    6	111.0	1	2
    7	23.0	0	0
    8	31.0	2	0
    

    1. KFold 使用

    X = df2.drop(['class'], axis=1)
    y = df2['class']
    floder = KFold(n_splits=3, random_state=2020, shuffle=True)
    for train_idx, test_idx in floder.split(X,y):
        print("KFold Spliting:")
        print('Train index: %s | test index: %s' % (train_idx, test_idx))
        # print(X.iloc[train_idx], y.iloc[train_idx], '\n', X.iloc[test_idx], y.iloc[test_idx])
    ===================================================================
    KFold Spliting:
    Train index: [0 1 3 5 6 8] | test index: [2 4 7]
    KFold Spliting:
    Train index: [0 2 3 4 7 8] | test index: [1 5 6]
    KFold Spliting:
    Train index: [1 2 4 5 6 7] | test index: [0 3 8]
    

    注意划分后得到的是针对数据的索引。我们现在只关注其test index,可以发现每次划分得到的索引不是按照class对应的类别均匀划分的,如第一次[2,4,7]对应类别是1,1,0. 其实 train index也一样,2,0,1,2,2,0.这在很多时候是不满足要求的,因为我们很多时候希望每次划分得到的train dataset/valid dataset其中对应的target类别是均匀的。

    有意思的是,你将 n_splits=8或9试试,可以看到不同划分数目,得到test index数目是不一样的。如 n_splits=8时, 第1 folds中test index size为 n_samples // n_splits + 1= 2,其余为1。

    The first n_samples % n_splits folds have size n_samples // n_splits + 1, other folds have size n_samples // n_splits, where n_samples is the number of samples.

    ​ —— kfold

    现在我们知道,KFold不能按照target类别来均匀划分,如果数据集必须按target类别来划分呢?那就要用到 StratifiedKFold

    2. StratifiedKFold使用

    sfolder = StratifiedKFold(n_splits=3, random_state=2020, shuffle=True)
    for train_idx, test_idx in sfolder.split(X,y):
        print("StratifiedKFold Spliting:")
        print('Train index: %s | test index: %s' % (train_idx, test_idx))
        
    ======================================================
    StratifiedKFold Spliting:
    Train index: [0 3 4 5 7 8] | test index: [1 2 6]
    StratifiedKFold Spliting:
    Train index: [1 2 3 5 6 8] | test index: [0 4 7]
    StratifiedKFold Spliting:
    Train index: [0 1 2 4 6 7] | test index: [3 5 8]
    

    这时我们得到的第一次test index 为 [1 2 6],train index也可以验证,也就是说,划分得到的数据集target类别是均匀的。但是还有些数据,如df中特征列 w如果也代表类别,我们希望将这个特征列相同类别划成一组呢?就像df.groupby一样意思。这可以用 GroupKFold.

    3. GroupKFold使用

    gfolder = GroupKFold(n_splits=3)
    for train_idx, test_idx in gfolder.split(X,y, groups=X['w']):
        print("GroupKFold Spliting:")
        print('Train index: %s | test index: %s' % (train_idx, test_idx))
       
    ========================================================================
    GroupKFold Spliting:
    Train index: [0 1 3 4 6 7] | test index: [2 5 8]
    GroupKFold Spliting:
    Train index: [2 3 4 5 7 8] | test index: [0 1 6]
    GroupKFold Spliting:
    Train index: [0 1 2 5 6 8] | test index: [3 4 7]
    

    这里第一次test index为 [2 5 8],对应w列为2。 [0 1 6]为1。这样就得到了按组划分了。可以试试将 groups=y看看。

    4. StratifiedShuffleSplit使用

    StratifiedShuffleSplitStratifiedKFoldShuffleSplit缝合怪。其跟 StratifiedKFold最大区别是可以重复采样,可以看到第一个test index是 [1 5 4],第二个是 [8 0 4],那么有可能某两个fold的index是一样的, not guarantee that all folds will be different

    shuffle_split = StratifiedShuffleSplit(n_splits=3, random_state=2020, test_size=3) #test_size必须比类别大或者 可以重复采样
    for train_idx, test_idx in shuffle_split.split(X,y):
        print("StratifiedShuffleSplit Spliting:")
        print('Train index: %s | test index: %s' % (train_idx, test_idx))
    ====================================================================
    StratifiedShuffleSplit Spliting:
    Train index: [8 2 3 0 6 7] | test index: [1 5 4]
    StratifiedShuffleSplit Spliting:
    Train index: [3 1 6 2 7 5] | test index: [8 0 4]
    StratifiedShuffleSplit Spliting:
    Train index: [1 8 2 6 0 4] | test index: [7 3 5]
    

    5. Stratified Group KFold 实现

    现在很多数据集会出现非常不均衡情况,如果在训练可能要求按照某些特征group和target列这两个均匀划分,为此出现了 Stratified Group KFold, 可以看做 GroupKFoldStratifiedKFold缝合怪。

    下面代码来自于stratifiedgroupkfold , 数据集是sklearn iris。另外再添加一列ID,就是令groups=df[‘ID’]并且划分后train valid 中y还是跟原数据集分布一样。

    import numpy as np
    import pandas as pd
    import random
    from sklearn.model_selection import GroupKFold
    from collections import Counter, defaultdict
    from sklearn.datasets import load_iris
    
    def read_data():
        iris = load_iris()
        df = pd.DataFrame(iris.data, columns=iris.feature_names)
        df['target'] = iris.target
    
        #新定义一个ID列
        list_id = ['A', 'B', 'C', 'D', 'E']
        df['ID'] = np.random.choice(list_id, len(df))
    
        features = iris.feature_names
        return df, features
    
    df, features = read_data()
    print(df.sample(6))
    
         sepal length (cm)  sepal width (cm)  petal length (cm)  petal width (cm)     target   ID
    133                6.3               2.8                5.1               1.5   	2    	C
    21                 5.1               3.7                1.5               0.4   	0		A
    84                 5.4               3.0                4.5               1.5   	1		A
    62                 6.0               2.2                4.0               1.0   	1		D
    5                  5.4               3.9                1.7               0.4   	0		B	
    132                6.4               2.8                5.6               2.2   	2		E
         
    

    StratiiedGroupKFold 分解实现:

    def count_y(y, groups):
        """统计每个group里各个y 数目"""
        unique_num = np.max(y) + 1
        #key不存在默认返回 np.zeros(unique_num)
        y_counts_per_group = defaultdict(lambda : np.zeros(unique_num))
    
        for label, g  in zip(y, groups):
            y_counts_per_group[g][label] += 1
    
        # defaultdict(<function__main__.<lambda>>,
        # {'A': array([5., 9., 8.]),
        # 'B': array([11., 12., 10.]),
        # 'C': array([13., 8., 8.]),
        # 'D': array([9., 11., 11.]),
        # 'E': array([12., 10., 13.])})
        return y_counts_per_group
    
    def StratiiedGroupKFold(X, y, groups, features, k, seed=None):
        """
        StratiiedGroupKFold数据,yeild划分后数据集索引
        :param X: 数据集X
        :param y: y target
        :param groups: 指定其分布划分的groups
        :param features: 特征
        :param k: n_split
        :param seed:
        """
        max_y = np.max(y)
        #得到每个groups y的数目的统计字典
        y_counts_per_group = count_y(y, groups)
        gf = GroupKFold(n_splits=k)
        for train_idx, val_idx in gf.split(X, y, groups):
            #分别获取train val划分后数据 以及各自对应的ID列类别数目
            x_train = X.iloc[train_idx,:]
            #id列类别数目
            id_train = x_train['ID'].unique()
            x_train = x_train[features]
    
            x_val, y_val = X.iloc[val_idx, :], y.iloc[val_idx]
            id_val = x_val['ID'].unique()
            x_val = x_val[features]
    
            #统计training dataset 和 validation dataset中y中每个类别数目
            y_counts_train = np.zeros(max_y + 1)
            y_counts_val = np.zeros(max_y + 1)
            for id in id_train:
                y_counts_train += y_counts_per_group[id]
            for id in id_val:
                y_counts_val += y_counts_per_group[id]
    
            #train dataset中按ID列统计y类别相对于最大数目的比例
            numratio_train = y_counts_train / np.max(y_counts_train)
            #stratified 数目: validation dataset对应y_counts_train最大值索引的count数目 * numratio_train向上取整
            stratified_count = np.ceil(y_counts_val[np.argmax(y_counts_train)] * numratio_train).astype(int)
    
            val_idx = np.array([])
            np.random.rand(seed)
            for num in range(max_y + 1):
                val_idx = np.append(val_idx, np.random.choice(y_val[y_val==num].index, stratified_count[num]))
            val_idx = val_idx.astype(int)
    
            yield train_idx, val_idx
    

    看看划分效果:

    def get_distribution(y_vals):
        """返回个y各类别的占比"""
        y_distribut = Counter(y_vals)
        y_vals_sum = sum(y_distribut.values())
        return [f'{y_distribut[i]/y_vals_sum:.2%}' for i in range(np.max(y_vals) + 1)]
    
    X = df.drop('target', axis=1)
    y = df['target']
    groups = df['ID']
    
    distribution = [get_distribution(y)]
    index = ['all dataset']
    
    #看看划分情况
    for fold, (train_idx, val_idx) in enumerate(StratiiedGroupKFold(X, y, groups, features, k=3, seed=2020)):
        print(f'Train ID - fold {fold:1d}:{groups[train_idx].unique()}\
           Test ID - fold {fold:1d}:{groups[val_idx].unique()}')
    
        distribution.append(get_distribution(y[train_idx]))
        index.append(f'train set - fold{fold:1d}')
        distribution.append(get_distribution(y[val_idx]))
        index.append(f'valid set - fold{fold:1d}')
    print(pd.DataFrame(distribution, index=index, columns={f' Label{l:2d}' for l in range(np.max(y)+1)}))
    
    Train ID - fold 0:['B' 'A' 'C' 'D']   Test ID - fold 0:['E']
    Train ID - fold 1:['A' 'D' 'E']       Test ID - fold 1:['B' 'C']
    Train ID - fold 2:['B' 'C' 'E']       Test ID - fold 2:['A' 'D']
                       Label 1  Label 2  Label 0
    all dataset         33.33%   33.33%   33.33%
    train set - fold0   32.48%   31.62%   35.90%
    valid set - fold0   33.33%   33.33%   33.33%
    train set - fold1   34.44%   33.33%   32.22%
    valid set - fold1   33.93%   33.93%   32.14%
    train set - fold2   33.33%   35.48%   31.18%
    valid set - fold2   33.33%   35.42%   31.25%
    
    

    通用实现

    def stratified_group_k_fold(X, y, groups, k, seed=None):
        labels_num = np.max(y) + 1
        y_counts_per_group = defaultdict(lambda: np.zeros(labels_num))
        y_distr = Counter()
        for label, g in zip(y, groups):
            y_counts_per_group[g][label] += 1
            y_distr[label] += 1
    
        y_counts_per_fold = defaultdict(lambda: np.zeros(labels_num))
        groups_per_fold = defaultdict(set)
    
        def eval_y_counts_per_fold(y_counts, fold):
            y_counts_per_fold[fold] += y_counts
            std_per_label = []
            for label in range(labels_num):
                label_std = np.std([y_counts_per_fold[i][label] / y_distr[label] for i in range(k)])
                std_per_label.append(label_std)
            y_counts_per_fold[fold] -= y_counts
            return np.mean(std_per_label)
    
        groups_and_y_counts = list(y_counts_per_group.items())
        random.Random(seed).shuffle(groups_and_y_counts)
    
        for g, y_counts in sorted(groups_and_y_counts, key=lambda x: -np.std(x[1])):
            best_fold = None
            min_eval = None
            for i in range(k):
                fold_eval = eval_y_counts_per_fold(y_counts, i)
                if min_eval is None or fold_eval < min_eval:
                    min_eval = fold_eval
                    best_fold = i
            y_counts_per_fold[best_fold] += y_counts
            groups_per_fold[best_fold].add(g)
    
        all_groups = set(groups)
        for i in range(k):
            train_groups = all_groups - groups_per_fold[i]
            test_groups = groups_per_fold[i]
    
            train_indices = [i for i, g in enumerate(groups) if g in train_groups]
            test_indices = [i for i, g in enumerate(groups) if g in test_groups]
    
            yield train_indices, test_indices
    

    Inference

    [1] StratifiedKFold v.s KFold v.s StratifiedShuffleSplit

    [2] sampling

    [3] imbalanced-learn

    展开全文
  • KFold交叉验证

    2020-12-10 11:47:20
    KFold模块from sklearn.model_selection import KFold为什么要使用交叉验证?交叉验证的介绍交叉验证是在机器学习建立模型和验证模型参数时常用的办法。 交叉验证,顾名思义,就是重复的使用数据,把得到的样本数据...

    KFold模块

    from sklearn.model_selection import KFold

    为什么要使用交叉验证?交叉验证的介绍

    交叉验证是在机器学习建立模型和验证模型参数时常用的办法。 交叉验证,顾名思义,就是重复的使用数据,把得到的样本数据进行切分,组合为不同的训练集和测试集,用训练集来训练模型,用测试集来评估模型预测的好坏。在此基础上可以得到多组不同的训练集和测试集,某次训练集中的某样本在下次可能成为测试集中的样本,即所谓“交叉”。

    那么什么时候才需要交叉验证呢?交叉验证用在数据不是很充足的时候。它的基本想法就是重复地使用数据:把给定的数据进行切分,将切分的数据集组合为训练集和测试集,在此基础上反复地进行训练、测试以及模型选择。 比如在我日常项目里面,对于普通适中问题,如果数据样本量小于一万条,我们就会采用交叉验证来训练优化选择模型。如果样本大于一万条的话,我们一般随机的把数据分成三份,一份为训练集(Training Set),一份为验证集(Validation Set),最后一份为测试集(Test Set)。用训练集来训练模型,用验证集来评估模型预测的好坏和选择模型及其对应的参数。把最终得到的模型再用于测试集,最终决定使用哪个模型以及对应参数。

    交叉验证的目的是为了能有效地估计模型的泛化能力 (测试误差),从而进行模型选择。 评估模型,然后通过的出来的准确率,我们再进行模型选择。

    K折交叉验证原理

    这便是交叉验证的过程:

    1、首先随机地将数据集切分为 k 个互不相交的大小相同的子集;

    2、然后将 k-1 个子集当成训练集训练模型,剩下的 (held out) 一个子集当测试集测试模型;

    3、将上一步对可能的 k 种选择重复进行 (每次挑一个不同的子集做测试集);

    4、在每个训练集上训练后得到一个模型,用这个模型在相应的测试集上测试,计算并保存模型的评估指标,

    5、这样就训练了 k 个模型,每个模型都在相应的测试集上计算测试误差,得到了 k 个测试误差。

    对这 k 次的测试误差取平均便得到一个交叉验证误差,并作为当前 k 折交叉验证下模型的性能指标。

    在模型选择时,假设模型有许多可以调整的参数可供调参,一组可以调整的参数便确定一个模型,计算其交叉验证误差,最后选择使得交叉验证误差最小的那一组的调整参数。这便是模型选择过程。

    简而言之,就是我们通过交叉验证验证不同的模型,或者不同的参数组合,最终我们选择准确度高的作为我们的模型。

    k 一般大于等于2,实际操作时一般从3开始取,只有在原始数据集样本数量小的时候才会尝试取2。

    k折交叉验证可以有效的避免过拟合以及欠拟合状态的发生,最后得到的结果也比较具有说服性。

    k折交叉验证最大的优点:

    所有数据都会参与到训练和预测中,有效避免过拟合,充分体现了交叉的思想

    交叉验证可能存在 bias 或者 variance。如果我们提高切分的数量 k,variance 会上升但 bias 可能会下降。相反得,如果降低 k,bias 可能会上升但 variance 会下降。bias-variance tradeoff 是一个有趣的问题,我们希望模型的 bias 和 variance 都很低,但有时候做不到,只好权衡利弊,选取他们二者的平衡点。

    通常使用10折交叉验证,当然这也取决于训练数据的样本数量。

    当我们的数据集小时,我们的数据无法满足模型的复杂度就会过拟合,使用交叉验证我们可以重复地使用数据:把给定的数据进行切分,将切分的数据集组合为训练集和测试集,在此基础上反复地进行训练、测试以及模型选择。相当于我们增加了我们的数据量(防止过拟合)。最后得到我们模型的准确率(性能)。

    pipeline的流程案例-代码解释:

    from sklearn.preprocessing import StandardScaler

    from sklearn.decomposition import PCA

    from sklearn.linear_model import LogisticRegression

    from sklearn.pipeline import Pipeline

    pipe_lr = Pipeline([('sc', StandardScaler()),

    ('pca', PCA(n_components=2)),

    ('clf', LogisticRegression(random_state=1))

    ])

    pipe_lr.fit(X_train, y_train)

    print('Test accuracy: %.3f' % pipe_lr.score(X_test, y_test))

    Pipeline执行流程的分析

    pipeline 的中间过程由scikit-learn相适配的转换器(transformer)构成,最后一步是一个estimator。

    比如上述的代码,StandardScaler和PCA transformer 构成intermediate steps,LogisticRegression 作为最终的estimator。

    当我们执行 pipe_lr.fit(X_train, y_train)时,首先由StandardScaler在训练集上执行 fit和transform方法,transformed后的数据又被传递给Pipeline对象的下一步,也即PCA()。和StandardScaler一样,PCA也是执行fit和transform方法,最终将转换后的数据传递给 LosigsticRegression。

    from sklearn.ensemble import RandomForestClassifier

    from sklearn.model_selection import GridSearchCV

    from sklearn.datasets import load_iris

    from sklearn.pipeline import Pipeline

    from sklearn.preprocessing import StandardScaler

    # 创建随机森林模型

    rf=RandomForestClassifier()

    # 加载数据

    data=load_iris()

    # 定义参数调优的范围,randomforestclassifier__n_estimators __前面定义的是名字,后面定义的内容是参数

    parameters={"randomforestclassifier__n_estimators":range(1,11),

    "randomforestclassifier__max_depth":range(1,5)}

    # 定义pipeline 流水线

    pipeline=Pipeline([

    ('scaler',StandardScaler()),

    ('randomforestclassifier',rf)

    ])

    # 使用GridSearchCV 进行参数调优

    clf=GridSearchCV(estimator=pipeline,param_grid=parameters,cv=6)

    # 进行数据集分类

    clf.fit(data.data,data.target)

    # 打印最优分数 给出不同参数情况下的评价结果

    print("最优分数:%.4lf"%clf.best_score_)

    # 打印最优参数 描述了已取得最佳结果的参数的组合

    print("最优参数:%s"%clf.best_params_)

    展开全文
  • KFold与StratifiedKFold

    2022-03-12 11:48:21
    sklearn 中的KFold与StratifiedKFold函数的使用
  • kFold

    2019-03-26 13:58:01
    k折交叉验证,k次的预测结果取平均即可! 同时平衡了偏差和方差的问题
  • k-交叉验证KFold

    2020-12-28 20:59:32
    执行kFold = KFold(n_splits=3) :其中KFold是一个类,n_split=3表示,当执行KFold的split函数后,数据集被分成三份,两份训练集和一份验证集。执行index = kFold.split(X=X):index是一个生成器...
  • kfold-x验证

    2021-02-15 19:25:57
    概述 该项目实现了KNN模型和k... && docker run -p 8080:8080 kfold docker build -t kfold . && docker run -p 8080:8080 kfold ,并使用输出中的URL来访问K-Fold Cross Validation Experiments.ipynb Jupyter笔记本。
  • 交叉验证之KFold

    千次阅读 2022-05-18 17:44:14
    1.通过sklearn.model_selection.KFold所提供的一个小例子来进行理解交叉验证及应用交叉验证 2. from sklearn.model_selection import KFold import numpy as np X = np.array(["a", "b", "c", "d", "e"]) # ...
  • KFold是sklearn中用来做交叉检验的,在sklearn 的版本升级中,KFold被挪了地方。 在sklearn 0.18及以上的版本中,sklearn.cross_validation包被废弃,KFold被挪到了sklearn.model_selection中,本来以为挪就挪了,...
  • PCA SVM KFold face detection

    2022-07-02 19:14:11
    In this paper, we concentrate on PCA, SVM, and KFold with face detection. In the present research, face detection often uses deep learning networks to train the face detection model. However, it only ...
  • KFold交叉验证的用法

    2022-04-14 15:45:30
    from sklearn.model_selection import KFold kfold = KFold(n_splits=5, shuffle=False) # n_splits:将原始数据分成多少折(份) shuffle:是否打乱每折的顺序 test = torch.arange(10) for train_data, test_data ...
  • sklearn KFold()

    万次阅读 多人点赞 2019-03-18 11:36:55
    最近实践过程中遇到需要KFold() 记录一下,以便日后查阅 KFold()在sklearn中属于model_slection模块 from sklearn.model_selection import KFold KFold(n_splits=’warn’, shuffle=False, random_state=None)...
  • K折交叉验证(KFold)

    千次阅读 2021-08-16 15:53:56
    K折交叉验证:sklearn.model_selection.KFold(n_splits=n, shuffle=False, random_state=None) 思路:将训练/测试数据集划分为n个互斥子集,每次用其中一个子集当作验证集,剩下的n-1个作为训练集,进行n次训练和...
  • 我要做交叉验证,需要每个训练集和测试集都保持相同的样本分布比例,直接用sklearn提供的KFold并不能满足这个需求。2.将生成的交叉验证数据集保存成CSV文件,而不是直接用sklearn训练分类模型。3.在编码过程中有一的...
  • KFold与StratifiedKFold
  • sklearn库中 Kfold, RepeatedKFold,ShuffleSplit三者对比 KFold X = np.arange(5) ss = KFold(n_splits=4, shuffle=True) for train_index, test_index in ss.split(X): print("@@%s %s" % (train_index, test_...
  • mcs_kfold mcs_kfold代表“蒙特卡洛分层k折”。 该库试图在所有折叠中均等地分配离散/分类变量。 在内部,更改种子并重复分层k倍试验,以找到在指定变量的分布中熵最少的种子。 这种方法的最大优点是可以应用于多维...
  • kfold训练

    2021-08-03 22:23:32
    fold_num = 0 for fold, (trn_idx, val_idx) in enumerate(folds): if fold == fold_num: print('Training with {} started'.format(fold)) print('Train : {}, Val : {}'.format(len(trn_idx), len(val_idx))) ...
  • GroupKFold,KFold,StratifiedKFold
  • 将全部训练集S分成k个不相交的子集,假设S中的训练样例个数为m,那么每一个...StratifiedKFold用法类似Kfold,但是他是分层采样,确保训练集,测试集中各类别样本的比例与原始数据集中相同 Parameters n_splits : int
  • kfold和StratifiedKFold 用法

    千次阅读 2021-01-16 17:19:39
    kfold和StratifiedKFold 用法两者区别代码及结果展示结果分析 两者区别 代码及结果展示 from sklearn.model_selection import KFold from sklearn.model_selection import StratifiedKFold #定义一个数据集 img_...
  • @[TOC](sklearn sklearn中KFold()的具体用法)
  • This is kfold algorithm fo adaboost
  • KFold----交叉验证

    万次阅读 多人点赞 2020-08-11 00:35:31
    但是仅凭一次考试就对模型的好坏进行评判显然是不合理的,所以接下来就要介绍交叉验证法 二、 K折交叉验证:sklearn.model_selection.KFold(n_splits=3, shuffle=False, random_state=None) 2.1 KFold简介 一般...
  • python sklearn中KFold()与StratifiedKFold()

    千次阅读 2020-12-30 15:14:26
    KFold划分数据集的原理:根据n_split直接进行划分 StratifiedKFold划分数据集的原理:划分后的训练集和验证集中类别分布尽量和原数据集一样 1、KFold函数 KFold函数共有三个参数: n_splits:默认为3,表示将数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,344
精华内容 3,737
关键字:

kfold

友情链接: 3D-Construction.rar