精华内容
下载资源
问答
  • 网格搜索

    2021-01-19 16:59:23
    X 和输出 Y X = dataset[:,0:8] Y = dataset[:,8] # 创建模型 model = KerasClassifier(build_fn=create_model, verbose=0) # 定义网格搜索参数 batch_size = [10,20,40,60,80,100] epochs = [10,20,50,100] param_...

    1.Batchsize and epochs

    import numpy as np
    from sklearn.model_selection import GridSearchCV
    import tensorflow as tf
    from tensorflow.keras import Sequential,layers
    from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
    from sklearn.datasets import load_iris
    
    def create_model():
        # 创建模型
        model = Sequential()
        model.add(layers.Dense(12, input_dim=8, activation='relu'))
        model.add(layers.Dense(1, activation='sigmoid'))
    
        # 编译模型
        model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
        return model
    
    # 为了复现,设置随机种子
    seed = 7
    np.random.seed(seed)
    
    dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")
    # 切分数据为输入 X 和输出 Y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    
    # 创建模型
    model = KerasClassifier(build_fn=create_model, verbose=0)
    # 定义网格搜索参数
    batch_size = [10,20,40,60,80,100]
    epochs = [10,20,50,100]
    param_grid = dict(batch_size=batch_size, epochs=epochs)
    grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=-1)
    grid_result = grid.fit(X, Y)
    
    print("Best: %f using %s"%(grid_result.best_score_,grid_result.best_params_))
    
    

    2.Optimizer

    import numpy as np
    from sklearn.model_selection import GridSearchCV
    import tensorflow as tf
    from tensorflow.keras import Sequential,layers
    from tensorflow.keras.layers import Dense
    from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
    from sklearn.datasets import load_iris
    
    
    # 构建模型的函数
    def create_model(optimizer='adam'):
        # 创建模型
        model = Sequential()
        model.add(Dense(12, input_dim=8, activation='relu'))
        model.add(Dense(1, activation='sigmoid'))
    
        # 编译模型
        model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
        return model
    
    # 为了复现,设置随机种子
    seed = 7
    np.random.seed(seed)
    
    # 加载数据
    dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")
    # 切分数据为输入 X 和输出 Y
    X = dataset[:,0:8]
    Y = dataset[:,8]
    
    # 创建模型,使用到了上一步找出的 epochs、batch size 最优参数
    model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=80, verbose=0)
    # 定义网格搜索参数
    optimizer = ['SGD', 'RMSprop', 'Adagrad', 'Adadelta', 'Adam', 'Adamax', 'Nadam']
    param_grid = dict(optimizer=optimizer)
    grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1)
    grid_result = grid.fit(X, Y)
    
    # 总结结果
    print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))
    

    3.Learning and Momentum

    import numpy as np
    from sklearn.model_selection import GridSearchCV
    import tensorflow as tf
    from tensorflow.keras import Sequential,layers
    from tensorflow.keras.layers import Dense
    from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
    from sklearn.datasets import load_iris
    
    def create_model(learn_rate = 0.01,momentum=0):
        model = Sequential()
        model.add(Dense(12,input_dim=8,activation='relu'))
        model.add(Dense(1,activation='sigmoid'))
    
        optimizer = tf.keras.optimizers.SGD(lr = learn_rate,momentum=momentum)
        model.compile(loss = tf.keras.losses.binary_crossentropy,optimizer=optimizer,metrics=['accuracy'])
        return model
    
    seed = 7
    np.random.seed(seed)
    
    
    dataset = np.loadtxt("pima-indians-diabetes.csv", delimiter=",")
    
    X = dataset[:,0:8]
    Y = dataset[:,8]
    
    model = KerasClassifier(build_fn=create_model, epochs=100, batch_size=10, verbose=0)
    
    learn_rate = [0.001, 0.01, 0.1, 0.2, 0.3]
    momentum = [0.0, 0.2, 0.4, 0.6, 0.8, 0.9]
    param_grid = dict(learn_rate=learn_rate, momentum=momentum)
    grid = GridSearchCV(estimator=model, param_grid=param_grid, n_jobs=1)
    grid_result = grid.fit(X, Y)
    
    # 总结结果
    print("Best: %f using %s" % (grid_result.best_score_, grid_result.best_params_))

    输出所有参数对应的得分,以及管道使用网格搜索

    import numpy as np
    from sklearn import datasets
    from sklearn.model_selection import train_test_split
    from sklearn.pipeline import Pipeline
    from sklearn.preprocessing import StandardScaler
    from sklearn.model_selection import GridSearchCV
    #线性SVM分类,注意是SVC
    #知识点:线性svm分类,网格搜索参数格式:"linear_svc__C",__对应管道中的处理器名字,以及网格搜索输出对应参数与成绩的方法
    from sklearn.svm import LinearSVC
    
    iris = datasets.load_iris()
    X = iris["data"][:,(2,3)]
    y = (iris["target"]==2).astype(np.float64)
    
    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2)
    
    svm_clf = Pipeline([
        ("scaler",StandardScaler()),
        ("svc",LinearSVC(loss="hinge"))#hinge通常用作最大间隔算法,二分类问题
    ])
    #svm_clf.fit(X_train,y_train)
    
    #打印管道模型的分数
    #print("使用管道模型评分:{:.2f}".format(svm_clf.score(X_test,y_test)))
    #网格搜索
    params = {"svc__C":[0.01,0.1,1,10,100],
              "svc__max_iter":[1,10,100,200,300]}
    grid = GridSearchCV(svm_clf,params,cv=3)
    grid.fit(X_train,y_train)
    print("交叉验证最高分:{}".format(grid.best_score_))
    print("模型最优参数:{}".format(grid.best_params_))
    print("测试集得分:{}".format(grid.score(X_test,y_test)))
    params = grid.cv_results_['params']
    means = grid.cv_results_['mean_test_score']
    for mean,param in zip(means,params):
        print("%f with: %r" % (mean,param))

     

    展开全文
  • 网格搜索算法

    2018-04-23 19:55:40
    网格搜索算法,优化向量机。对于向量机的参数进行最优化处理
  • 网格搜索

    万次阅读 多人点赞 2018-08-28 21:37:09
    网格搜索法是指定参数值的一种穷举搜索方法,通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。 即,将各个参数可能的取值进行排列组合,列出所有可能的组合结果生成“网格”。然后将各组合...

    网格搜索法是指定参数值的一种穷举搜索方法,通过将估计函数的参数通过交叉验证的方法进行优化来得到最优的学习算法。

    即,将各个参数可能的取值进行排列组合,列出所有可能的组合结果生成“网格”。然后将各组合用于SVM训练,并使用交叉验证对表现进行评估。在拟合函数尝试了所有的参数组合后,返回一个合适的分类器,自动调整至最佳参数组合,可以通过clf.best_params_获得参数值

     

     

     

    版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_32547403/article/details/73008127

    交叉验证与网格搜索

    交叉验证与网格搜索是机器学习中的两个非常重要且基本的概念,但是这两个概念在刚入门的时候并不是非常容易理解与掌握,自己开始学习的时候,对这两个概念理解的并不到位,现在写一篇关于交叉验证与网格搜索的文章,将这两个基本的概念做一下梳理。

    网格搜索

    网格搜索(Grid Search)名字非常大气,但是用简答的话来说就是你手动的给出一个模型中你想要改动的所用的参数,程序自动的帮你使用穷举法来将所用的参数都运行一遍。决策树中我们常常将最大树深作为需要调节的参数;AdaBoost中将弱分类器的数量作为需要调节的参数。

    评分方法

    为了确定搜索参数,也就是手动设定的调节的变量的值中,那个是最好的,这时就需要使用一个比较理想的评分方式(这个评分方式是根据实际情况来确定的可能是accuracy、f1-score、f-beta、pricise、recall等)

    交叉验证

    有了好的评分方式,但是只用一次的结果就能说明某组的参数组合比另外的参数组合好吗?这显然是不严谨的,上小学的时候老师就告诉我们要求平均��。所以就有了交叉验证这一概念。下面以K折交叉验证为例介绍这一概念。

    1. 首先进行数据分割 
      将原始数据集分为训练集和测试集。如下图以8:2的方式分割: 
      png 
      训练集使用来训练模型,测试集使用来测试模型的准确率。 
      注意:绝对不能使用测试集来训练数据,这相当于考试的时候先让你把考试的答案背过了,又让你参加考试。
    2. 数据验真 
      在k折交叉验证方法中其中K-1份作为训练数据,剩下的一份作为验真数据:

    png1 
    这个过程一共需要进行K次,将最后K次使用实现选择好的评分方式的评分求平均返回,然后找出最大的一个评分对用的参数组合。这也就完成了交叉验证这一过程。

    ### 举例 下面使用一个简单的例子(预测年收入是否大于5万美元)来进行说明网格搜索与交叉验证的使用。 数据集来自[UCI机器学习知识库](https://archive.ics.uci.edu/ml/datasets/Census+Income)。

    import numpy as np
    import pandas as pd
    from IPython.display import display
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.model_selection import train_test_split
    from sklearn.metrics import make_scorer, fbeta_score, accuracy_score
    from sklearn.model_selection import GridSearchCV, KFold
    
    %matplotlib inline 
    
    data = pd.read_csv("census.csv")
    
    # 将数据切分成特征和标签
    income_raw = data['income']
    features_raw = data.drop('income', axis=1)
    
    # 显示部分数据
    # display(features_raw.head(n=1))
    
    # 因为原始数据中的,capital-gain 和 capital-loss的倾斜度非常高,所以要是用对数转换。
    skewed = ['capital-gain', 'capital-loss']
    features_raw[skewed] = data[skewed].apply(lambda x: np.log(x + 1))
    
    # 归一化数字特征,是为了保证所有的特征均被平等的对待
    scaler = MinMaxScaler()
    numerical = ['age', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']
    features_raw[numerical] = scaler.fit_transform(data[numerical])
    # display(features_raw.head(n=1))
    
    # 独热编码,将非数字的形式转化为数字
    features = pd.get_dummies(features_raw)
    income = income_raw.replace(['>50K', ['<=50K']], [1, 0])
    
    # 切分数据集
    X_train, X_test, y_train, y_test = train_test_split(features, income, test_size=0.2, random_state=0)
    
    # Adaboost
    from sklearn.ensemble import AdaBoostClassifier
    clf_Ada = AdaBoostClassifier(random_state=0)
    
    # 决策树
    from sklearn.tree import DecisionTreeClassifier
    clf_Tree = DecisionTreeClassifier(random_state=0)
    
    # KNN
    from sklearn.neighbors import KNeighborsClassifier
    clf_KNN = KNeighborsClassifier()
    
    # SVM
    from sklearn.svm import SVC
    clf_svm = SVC(random_state=0)
    
    # Logistic
    from sklearn.linear_model import LogisticRegression
    clf_log = LogisticRegression(random_state=0)
    
    # 随机森林
    from sklearn.ensemble import RandomForestClassifier
    clf_forest = RandomForestClassifier(random_state=0)
    
    # GBDT
    from sklearn.ensemble import GradientBoostingClassifier
    clf_gbdt = GradientBoostingClassifier(random_state=0)
    
    # GaussianNB
    from sklearn.naive_bayes import GaussianNB
    clf_NB = GaussianNB()
    
    scorer = make_scorer(accuracy_score)
    
    # 参数调优
    
    kfold = KFold(n_splits=10)
    # 决策树
    parameter_tree = {'max_depth': xrange(1, 10)}
    grid = GridSearchCV(clf_Tree, parameter_tree, scorer, cv=kfold)
    grid = grid.fit(X_train, y_train)
    
    print "best score: {}".format(grid.best_score_)
    display(pd.DataFrame(grid.cv_results_).T)

    best score: 0.855737070514.dataframe thead tr:only-child th { text-align: right; } .dataframe thead th { text-align: left; } .dataframe tbody tr th { vertical-align: top; }

      0 1 2 3 4 5 6 7 8
    mean_fit_time 0.0562535 0.0692133 0.0885126 0.110233 0.128337 0.158719 0.17124 0.193637 0.223979
    mean_score_time 0.00240474 0.00228212 0.00221529 0.0026047 0.00226772 0.00254297 0.00231481 0.00246696 0.00256622
    mean_test_score 0.75114 0.823811 0.839345 0.839926 0.846671 0.852392 0.851508 0.853139 0.855737
    mean_train_score 0.75114 0.82421 0.839628 0.840503 0.847878 0.853329 0.855264 0.859202 0.863667
    param_max_depth 1 2 3 4 5 6 7 8 9
    params {u’max_depth’: 1} {u’max_depth’: 2} {u’max_depth’: 3} {u’max_depth’: 4} {u’max_depth’: 5} {u’max_depth’: 6} {u’max_depth’: 7} {u’max_depth’: 8} {u’max_depth’: 9}
    rank_test_score 9 8 7 6 5 3 4 2 1
    split0_test_score 0.760641 0.8267 0.843836 0.844666 0.851575 0.855721 0.855445 0.86042 0.859038
    split0_train_score 0.750084 0.823828 0.839184 0.83943 0.847538 0.852913 0.854295 0.859947 0.863233
    split1_test_score 0.758154 0.821172 0.839138 0.842454 0.845218 0.849641 0.847706 0.850746 0.852957
    split1_train_score 0.750361 0.824442 0.839706 0.845911 0.850088 0.854203 0.855831 0.861482 0.864984
    split2_test_score 0.754837 0.824212 0.840243 0.84052 0.8466 0.854616 0.854339 0.854063 0.856551
    split2_train_score 0.750729 0.824718 0.839031 0.839307 0.847323 0.852237 0.854203 0.859578 0.86397
    split3_test_score 0.73162 0.820619 0.838032 0.838308 0.8466 0.850746 0.848535 0.846877 0.852957
    split3_train_score 0.753309 0.824503 0.839829 0.840106 0.848337 0.853742 0.85537 0.858104 0.863171
    split4_test_score 0.746545 0.818684 0.83361 0.833886 0.83969 0.847982 0.845495 0.85047 0.848811
    split4_train_score 0.751651 0.824718 0.840321 0.840597 0.844897 0.853558 0.858319 0.861912 0.864922
    split5_test_score 0.754284 0.826147 0.844942 0.845218 0.854063 0.859038 0.85738 0.858209 0.861802
    split5_train_score 0.750791 0.823889 0.839061 0.839338 0.847323 0.852729 0.854111 0.856967 0.862741
    split6_test_score 0.754284 0.825318 0.838032 0.837756 0.845495 0.848535 0.848535 0.852128 0.857103
    split6_train_score 0.750791 0.823981 0.839829 0.840167 0.848429 0.853773 0.855647 0.857766 0.863141
    split7_test_score 0.749793 0.821399 0.835499 0.835499 0.844623 0.85264 0.852087 0.853746 0.85264
    split7_train_score 0.75129 0.824416 0.840111 0.840418 0.848372 0.853501 0.854945 0.860811 0.863882
    split8_test_score 0.753387 0.826375 0.838264 0.83854 0.84407 0.852087 0.852917 0.852364 0.858446
    split8_train_score 0.750891 0.823864 0.839803 0.84008 0.848372 0.853071 0.854945 0.857801 0.863391
    split9_test_score 0.747857 0.827481 0.841858 0.842411 0.84877 0.852917 0.85264 0.852364 0.857064
    split9_train_score 0.751505 0.823741 0.839404 0.839681 0.848096 0.853563 0.854975 0.857647 0.863237
    std_fit_time 0.0123583 0.00442788 0.00552026 0.00631691 0.0053195 0.0157011 0.00476991 0.00622854 0.0147429
    std_score_time 0.000529214 0.000467091 0.000355028 0.000760624 0.000460829 0.000504627 0.000446289 0.000445256 0.000449312
    std_test_score 0.00769898 0.00292464 0.00333118 0.00358776 0.00382496 0.00324406 0.00360414 0.00366389 0.00363761
    std_train_score 0.000855482 0.000366166 0.000418973 0.00185264 0.00124698 0.000553171 0.00116151 0.00168732 0.000726325
    展开全文
  • svm 网格搜索

    2016-03-09 15:43:07
    SVM参数优化 网格搜索
  • ML-DecisionTree-RandomForest-GridSearch-RandomizedGridSearch 机器学习-决策树,随机森林,网格搜索,随机网格搜索
  • sklearn网格搜索

    2020-10-09 16:55:44
    网格搜索 通过不同参数组合尝试训练网络 获得最优参数、最优模型 """ import numpy as np import sklearn.naive_bayes as nb import matplotlib.pyplot as mp import sklearn.svm as svm import sklearn.model_...
    """
        网格搜索  通过不同参数组合尝试训练网络
        获得最优参数、最优模型
    """
    import numpy as np
    import sklearn.naive_bayes as nb
    import matplotlib.pyplot as mp
    import sklearn.svm as svm
    import sklearn.model_selection as ms
    import sklearn.metrics as sm
    
    # 加载数据
    data = np.loadtxt("./multiple2.txt", delimiter=",")
    x = data[:, :2].astype("float")
    y = data[:, -1].astype("float")
    print(x.shape, x.dtype)
    print(y.shape, y.dtype)
    
    train_x, test_x, train_y, test_y = \
        ms.train_test_split(x, y, test_size=0.25, random_state=7)
    
    # SVC probability 是否保存置信概率
    model = svm.SVC(probability=True)
    
    # 设置网格参数
    params = [{'kernel': ['linear'], 'C': [1, 10, 100, 1000]},
              {'kernel': ['poly'], 'C': [1], 'degree': [2, 3]},
              {'kernel': ['rbf'], 'C': [1, 10, 100, 1000], 'gamma': [1, 0.1, 0.01, 0.001]}]
    
    # 网格搜索 确定最优超参数
    model = ms.GridSearchCV(model, params, cv=5)
    
    model.fit(train_x, train_y)
    
    print(model.best_params_)   # 最优参数
    print(model.best_score_)    # 最好得分
    print(model.best_estimator_)
    
    展开全文
  • 针对有多个参数的机器学习模型,手动调参繁琐,通过网格搜索,遍历所有参数,得到最优参数 网格搜索就是穷举法 #网格搜索 from sklearn.model_selection import GridSearchCV param_grid=[{"kernel":["linear"],"C...

    针对有多个参数的机器学习模型,手动调参繁琐,通过网格搜索,遍历所有参数,得到最优参数

    网格搜索就是穷举法+k折交叉验证

    #网格搜索
    from sklearn.model_selection import GridSearchCV
    
    param_grid=[{"kernel":["linear"],"C":[0.1, 0.2,1, 10,100],},
                {"kernel":["rbf"],"C":[0.1, 0.2,1, 10,100], "gamma": [1,0.1, 0.01],},
                {"kernel":["poly"],"C": [0.1, 1, 10,100], "gamma": [1, 0.1, 0.01],"degree":[3,5,10],"coef0":[0,0.1,1]},
                {"kernel":["sigmoid"], "C": [0.1, 1, 10,100], "gamma": [1, 0.1, 0.01],"coef0":[0,0.1,1]}]
    
    grid = GridSearchCV(SVR(), param_grid=param_grid, cv=4) #cv表示k折交叉验证
    grid.fit(train_X,train_y)
    print('grid_best_params:',  grid.best_params_)
    print('grid.best_score_:', grid.best_score_)#f1得分
    

    确定核函数的选择,之后可以进行更详细的调参

    另外还有随机搜索方法可以借鉴

    sklearn.model_selection.GridSearchCV
    Scikit中使用Grid_Search来获取模型的最佳参数
    Python机器学习笔记 Grid SearchCV(网格搜索)

    展开全文
  • 了解网格搜索,可以阅读:Python机器学习笔记 Grid SearchCV(网格搜索) GridSearchCV其实可以拆分为GridSearch和CV,即网格搜索和交叉验证。网格搜索,搜索的是参数,即在指定的参数范围内,按步长依次调整参数,...
  • 交叉验证 网格搜索
  • Grid Search网格搜索

    2019-06-18 15:59:14
    什么是Grid Search 网格搜索? Grid Search:一种调参手段;穷举搜索:在所有候选的参数选择中,通过循环遍历,尝试每一种可能性,表现最好的参数就是最终的结果。其原理就像是在数组里找最大值。(为什么叫网格...
  • 什么是Grid Search 网格搜索? 网格搜素是一种常用的调参手段,是一种穷举方法。给定一系列超参,然后再所有超参组合中穷举遍历,从所有组合中选出最优的一组超参数,其实就是暴力方法在全部解中找最优解。 为什么...
  • sklearn 之网格搜索

    2019-10-13 22:01:30
    通过网格搜索得到 使模型效果最好的一组参数。 kNN网格搜索 param_grid =[ #knn通过距离权重计算 {'weights':['uniform'], #k的取值 取1到11 'n_neighbors':[i for i in range(1,11)] },{ #通过样本点个数 '...
  • 模型调参之网格搜索与随机搜索 网格搜索法(GridSearchCV) GridSearchCV:GridSearchCV可以拆分成GridSearch和CV两部分,即网格搜素和交叉验证。GridSearch系统地遍历多种参数组合,通过交叉验证确定最佳效果参数...
  • 数据挖掘—网格搜索2

    2020-11-02 21:03:58
    数据挖掘—网格搜索21、分析交叉验证的结果2、网格的条件参数3、使用不同的交叉验证策略进行网格搜索(1) 传入交叉验证分离器(2)嵌套交叉验证(3)交叉验证与网格搜索并行 1、分析交叉验证的结果 将交叉验证的...
  • python_交叉网格搜索

    2019-12-11 20:45:50
    python_交叉网格搜索 ### 3.2 交叉网格搜索 #grid_search parameters = {'max_depth':[3,4,5,6,7]} #定义网格搜索参数 RF_grid = grid_search.GridSearchCV(estimator=RandomForestClassifier(),#模型 ...
  • 超参数搜索之网格搜索与并行搜索

    万次阅读 2017-09-06 11:40:18
    超参数搜索: 所谓的模型配置,一般统称为模型的超参数(Hyperparameters),比如KNN算法中的K值,SVM...称这种启发式的超参数搜索方法为网格搜索网格搜索 由于超参数的空间是无尽的,因此超参数的组合配置只能是
  • 但是当超参数个数比较多的时候,我们仍然采用网格搜索,那么搜索所需时间将会指数级上升。 比如我们有四个超参数,每个范围都是[10,100],那么我们所需的搜索次数是10*10*10*10=10^4。 如果再增加一个超参数,那么...
  • 机器学习-网格搜索

    千次阅读 2018-04-25 20:07:44
    一. 什么是网格搜索?二.网格搜索是如何计算出最优模型的?
  • 机器学习——网格搜索

    千次阅读 2019-08-14 09:58:17
    网格搜索特点 网格搜索类似于穷举法,来确定模型参数的一个最优的组合,但相应的会大量的增加计算时间,但精确率等指标会很高 代码如下 import pandas as pd import matplotlib.pyplot as plt from sklearn.linear_...
  • 交叉验证与网格搜索

    2017-06-10 21:00:43
    交叉验证与网格搜索 交叉验证与网格搜索是机器学习中的两个非常重要且基本的概念,但是这两个概念在刚入门的时候并不是非常容易理解与掌握,自己开始学习的时候,对这两个概念理解的并不到位,现在写...
  • gridSearchCV(网格搜索)的参数、方法及示例 1.简介 GridSearchCV的sklearn官方网址: ... GridSearc...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,938
精华内容 1,975
关键字:

网格搜索