程序员经验分享-hwhale

【scikit-learn】网格搜索来进行高效的参数调优

2023-05-16


内容概要¶

  • 如何使用K折交叉验证来搜索最优调节参数
  • 如何让搜索参数的流程更加高效
  • 如何一次性的搜索多个调节参数
  • 在进行真正的预测之前，如何对调节参数进行处理
  • 如何削减该过程的计算代价

1. K折交叉验证回顾¶

交叉验证的过程

  • 选择K的值（一般是10），将数据集分成K等份
  • 使用其中的K-1份数据作为训练数据，另外一份数据作为测试数据，进行模型的训练
  • 使用一种度量测度来衡量模型的预测性能

交叉验证的优点

  • 交叉验证通过降低模型在一次数据分割中性能表现上的方差来保证模型性能的稳定性
  • 交叉验证可以用于选择调节参数、比较模型性能差别、选择特征

交叉验证的缺点

  • 交叉验证带来一定的计算代价，尤其是当数据集很大的时候，导致计算过程会变得很慢

2. 使用GridSearchCV进行高效调参¶

GridSearchCV根据你给定的模型自动进行交叉验证，通过调节每一个参数来跟踪评分结果，实际上，该过程代替了进行参数搜索时的for循环过程。

In [1]: 

from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
%matplotlib inline

from sklearn.grid_search import GridSearchCV
In [2]: 

# read in the iris data
iris = load_iris()

# create X (features) and y (response)
X = iris.data
y = iris.target
In [3]: 

# define the parameter values that should be searched
k_range = range(1, 31)
print k_range
  

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]
In [4]: 

# create a parameter grid: map the parameter names to the values that should be searched
# 下面是构建parameter grid，其结构是key为参数名称，value是待搜索的数值列表的一个字典结构
param_grid = dict(n_neighbors=k_range)
print param_grid
  

{'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]}
In [5]: 

knn = KNeighborsClassifier(n_neighbors=5)
# instantiate the grid
# 这里GridSearchCV的参数形式和cross_val_score的形式差不多，其中param_grid是parameter grid所对应的参数
# GridSearchCV中的n_jobs设置为-1时，可以实现并行计算（如果你的电脑支持的情况下）
grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy')

我们可以知道，这里的grid search针对每个参数进行了10次交叉验证，并且一共对30个参数进行相同过程的交叉验证

In [6]: 

grid.fit(X, y)
Out[6]: 

GridSearchCV(cv=10, error_score='raise',
       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_neighbors=5, p=2, weights='uniform'),
       fit_params={}, iid=True, loss_func=None, n_jobs=1,
       param_grid={'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30]},
       pre_dispatch='2*n_jobs', refit=True, score_func=None,
       scoring='accuracy', verbose=0)
In [7]: 

# view the complete results (list of named tuples)
grid.grid_scores_
Out[7]: 

[mean: 0.96000, std: 0.05333, params: {'n_neighbors': 1},
 mean: 0.95333, std: 0.05207, params: {'n_neighbors': 2},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 3},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 4},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 5},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 6},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 7},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 8},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 9},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 10},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 11},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 12},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 13},
 mean: 0.97333, std: 0.04422, params: {'n_neighbors': 14},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 15},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 16},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 17},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 18},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 19},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 20},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 21},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 22},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 23},
 mean: 0.96000, std: 0.04422, params: {'n_neighbors': 24},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 25},
 mean: 0.96000, std: 0.04422, params: {'n_neighbors': 26},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 27},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 28},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 29},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 30}]
In [8]: 

# examine the first tuple
print grid.grid_scores_[0].parameters
print grid.grid_scores_[0].cv_validation_scores
print grid.grid_scores_[0].mean_validation_score
  

{'n_neighbors': 1}
[ 1.          0.93333333  1.          0.93333333  0.86666667  1.
  0.86666667  1.          1.          1.        ]
0.96
In [9]: 

# create a list of the mean scores only
grid_mean_scores = [result.mean_validation_score for result in grid.grid_scores_]
print grid_mean_scores
  

[0.95999999999999996, 0.95333333333333337, 0.96666666666666667, 0.96666666666666667, 0.96666666666666667, 0.96666666666666667, 0.96666666666666667, 0.96666666666666667, 0.97333333333333338, 0.96666666666666667, 0.96666666666666667, 0.97333333333333338, 0.97999999999999998, 0.97333333333333338, 0.97333333333333338, 0.97333333333333338, 0.97333333333333338, 0.97999999999999998, 0.97333333333333338, 0.97999999999999998, 0.96666666666666667, 0.96666666666666667, 0.97333333333333338, 0.95999999999999996, 0.96666666666666667, 0.95999999999999996, 0.96666666666666667, 0.95333333333333337, 0.95333333333333337, 0.95333333333333337]
In [10]: 

# plot the results
plt.plot(k_range, grid_mean_scores)
plt.xlabel('Value of K for KNN')
plt.ylabel('Cross-Validated Accuracy')
Out[10]: 

<matplotlib.text.Text at 0x6e34090>
In [11]: 

# examine the best model
print grid.best_score_
print grid.best_params_
print grid.best_estimator_
  

0.98
{'n_neighbors': 13}
KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_neighbors=13, p=2, weights='uniform')

3. 同时对多个参数进行搜索¶

这里我们使用knn的两个参数，分别是n_neighbors和weights，其中weights参数默认是uniform，该参数将所有数据看成等同的，而另一值是distance，它将近邻的数据赋予更高的权重，而较远的数据赋予较低权重。

In [12]: 

# define the parameter values that should be searched
k_range = range(1, 31)
weight_options = ['uniform', 'distance']
In [13]: 

# create a parameter grid: map the parameter names to the values that should be searched
param_grid = dict(n_neighbors=k_range, weights=weight_options)
print param_grid
  

{'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], 'weights': ['uniform', 'distance']}
In [14]: 

# instantiate and fit the grid
grid = GridSearchCV(knn, param_grid, cv=10, scoring='accuracy')
grid.fit(X, y)
Out[14]: 

GridSearchCV(cv=10, error_score='raise',
       estimator=KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski',
           metric_params=None, n_neighbors=5, p=2, weights='uniform'),
       fit_params={}, iid=True, loss_func=None, n_jobs=1,
       param_grid={'n_neighbors': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30], 'weights': ['uniform', 'distance']},
       pre_dispatch='2*n_jobs', refit=True, score_func=None,
       scoring='accuracy', verbose=0)
In [15]: 

# view the complete results
grid.grid_scores_
Out[15]: 

[mean: 0.96000, std: 0.05333, params: {'n_neighbors': 1, 'weights': 'uniform'},
 mean: 0.96000, std: 0.05333, params: {'n_neighbors': 1, 'weights': 'distance'},
 mean: 0.95333, std: 0.05207, params: {'n_neighbors': 2, 'weights': 'uniform'},
 mean: 0.96000, std: 0.05333, params: {'n_neighbors': 2, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 3, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 3, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 4, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 4, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 5, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 5, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 6, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 6, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 7, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 7, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 8, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 8, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 9, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 9, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 10, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 10, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 11, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 11, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 12, 'weights': 'uniform'},
 mean: 0.97333, std: 0.04422, params: {'n_neighbors': 12, 'weights': 'distance'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 13, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 13, 'weights': 'distance'},
 mean: 0.97333, std: 0.04422, params: {'n_neighbors': 14, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 14, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 15, 'weights': 'uniform'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 15, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 16, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 16, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 17, 'weights': 'uniform'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 17, 'weights': 'distance'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 18, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 18, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 19, 'weights': 'uniform'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 19, 'weights': 'distance'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 20, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 20, 'weights': 'distance'},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 21, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 21, 'weights': 'distance'},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 22, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 22, 'weights': 'distance'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 23, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 23, 'weights': 'distance'},
 mean: 0.96000, std: 0.04422, params: {'n_neighbors': 24, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 24, 'weights': 'distance'},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 25, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 25, 'weights': 'distance'},
 mean: 0.96000, std: 0.04422, params: {'n_neighbors': 26, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 26, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 27, 'weights': 'uniform'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 27, 'weights': 'distance'},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 28, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 28, 'weights': 'distance'},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 29, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 29, 'weights': 'distance'},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 30, 'weights': 'uniform'},
 mean: 0.96667, std: 0.03333, params: {'n_neighbors': 30, 'weights': 'distance'}]
In [16]: 

# examine the best model
print grid.best_score_
print grid.best_params_
  

0.98
{'n_neighbors': 13, 'weights': 'uniform'}

4. 使用最佳参数做出预测¶

In [17]: 

# train your model using all data and the best known parameters
knn = KNeighborsClassifier(n_neighbors=13, weights='uniform')
knn.fit(X, y)

# make a prediction on out-of-sample data
knn.predict([3, 5, 4, 2])
Out[17]: 

array([1])

这里使用之前得到的最佳参数对模型进行重新训练，在训练时，就可以将所有的数据都作为训练数据全部投入到模型中去，这样就不会浪费个别数据了。

In [18]: 

# shortcut: GridSearchCV automatically refits the best model using all of the data
grid.predict([3, 5, 4, 2])
Out[18]: 

array([1])

5. 使用RandomizeSearchCV来降低计算代价¶

  • RandomizeSearchCV用于解决多个参数的搜索过程中计算代价过高的问题
  • RandomizeSearchCV搜索参数中的一个子集，这样你可以控制计算代价
In [19]: 

from sklearn.grid_search import RandomizedSearchCV
In [20]: 

# specify "parameter distributions" rather than a "parameter grid"
param_dist = dict(n_neighbors=k_range, weights=weight_options)
In [21]: 

# n_iter controls the number of searches
rand = RandomizedSearchCV(knn, param_dist, cv=10, scoring='accuracy', n_iter=10, random_state=5)
rand.fit(X, y)
rand.grid_scores_
Out[21]: 

[mean: 0.97333, std: 0.03266, params: {'n_neighbors': 18, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 8, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 24, 'weights': 'distance'},
 mean: 0.98000, std: 0.03055, params: {'n_neighbors': 20, 'weights': 'uniform'},
 mean: 0.95333, std: 0.04269, params: {'n_neighbors': 28, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 9, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 5, 'weights': 'distance'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 5, 'weights': 'uniform'},
 mean: 0.97333, std: 0.03266, params: {'n_neighbors': 19, 'weights': 'uniform'},
 mean: 0.96667, std: 0.04472, params: {'n_neighbors': 20, 'weights': 'distance'}]
In [22]: 

# examine the best model
print rand.best_score_
print rand.best_params_
  

0.98
{'n_neighbors': 20, 'weights': 'uniform'}
In [23]: 

# run RandomizedSearchCV 20 times (with n_iter=10) and record the best score
best_scores = []
for _ in range(20):
    rand = RandomizedSearchCV(knn, param_dist, cv=10, scoring='accuracy', n_iter=10)
    rand.fit(X, y)
    best_scores.append(round(rand.best_score_, 3))
print best_scores
  

[0.98, 0.98, 0.973, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.98, 0.973, 0.98, 0.98, 0.98, 0.973, 0.98, 0.98, 0.973, 0.973]

当你的调节参数是连续的，比如回归问题的正则化参数，有必要指定一个连续分布而不是可能值的列表，这样RandomizeSearchCV就可以执行更好的grid search。

参考资料¶

  • scikit-learn documentation: Grid search, GridSearchCV, RandomizedSearchCV
  • Timed example: Comparing randomized search and grid search
  • scikit-learn workshop by Andreas Mueller: Video segment on randomized search (3 minutes), related notebook
  • Paper by Yoshua Bengio: Random Search for Hyper-Parameter Optimization
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

【scikit-learn】网格搜索来进行高效的参数调优 的相关文章

  • 求符合给定条件的整数集（做题）

    题目如上 xff1b 首先我们先想思路 xff1a 先来一个输入 xff0c 读入这个数 xff0c 然后我们需要三个变量来储存这三个数 xff1b 然后我们遍历所有的组合 xff0c 这个依靠循环 接下来是代码 xff1a include

  • 水仙花数（做题）

    代码如下 xff1a include lt stdio h gt int main int a scanf 34 d 34 amp a float t t 61 0 1 while a gt 0 t 61 t 10 a 判断几位数 int

  • 一分钟了解动态内存分配

    谈到这 xff0c 必然离不开malloc函数 在上面可以看出此函数需要一个头文件 include lt stdilb h gt 而且返回类型是void 传进去的是空间大小 xff0c 此函数申请的空间是字节为单位的 这其中的就分配了100

  • 动态内存分配深究

    接下来我们将探究以下三个问题 xff1a 1 相邻两次malloc得到的空间是否是连续的呢 xff1f 2 你得到的空间的实际大小是否就是你要求的大小呢 xff1f 3 如果你malloc零长度会得到什么结果呢 xff1f 第一个问题 xf

  • 同一个页面不打开两次

    lt script language 61 34 javascript 34 gt function popwin3 path window open path 34 cart 34 34 height 61 520 width 61 52

  • 超易懂！二分查找 详析

    二分算法的 本质 是 xff1a 假如我们可以找到事物的 某种性质 xff0c 这种性质 可以将区间一分为二 xff0c 一半满足 xff0c 一半不满足 我们就可以二分 另外 xff0c 有 连续性 必可以 二分 二分模板一共有两个 xf

  • 手摸手 Spring Cloud Gateway + JWT 实现登录认证

    你好 xff0c 我是悟空 前言 上篇我已经讲解了 Spring Cloud 的原理和实战 xff0c 这次就要结合 JWT 来实现登录认证的功能了 本文已收录至 深入剖析 Spring Cloud 底层架构原理 xff0c 已更新 18

  • 百行代码实现VLC简易视频播放器【VLC环境配置过程+可执行源码注释完整】

    文章目录 什么是VLC x1f680 VLC 库的集成 VLC环境配置演示 win10系统 43 vs2017 43 win64 x1f34e VLC 库的基本使用 x1f382 视频播放器实现 自定义函数Unicode2Utf8讲解 x1

  • HttpWebRequest 使用NetworkCredential 进行域认证下载时不成功 的解决方案

    最近在项目中使用pWebRequest 使用NetworkCredential 进行域认证下载时老不成功 xff0c 最后Google了解决方案 xff0c 发现几乎所有讨论的方案都不成功 xff0c 只好埋头自己解决 xff0c 最后总算

  • Firefox 的用户脚本管理器 greasemonkey 的使用一例

    一 什么是greasemonkey Firefox 的用户脚本管理器 greasemonkey 使你可以向任何网页添加DHTML语句 用户脚本 来改变它们的显示方式 就像CSS可以让你接管网页的样式 xff0c 而用户脚本 User Scr

  • Apache Http 服务器安装教程

    我在学习网络开发的时候需要从服务器上获得json数据 xff0c 所以在自己的电脑上安装了一个本地服务器 xff0c 其中遇到的一些问题 xff0c 在这里都写出来 首先 xff0c 我们需要访问apache http服务器的下载网页 xf

  • STM32的UART奇偶校验注意

    STM32的UART奇偶校验注意 STM32的UART在初始化时 xff0c 我们通常用到最多的就是无校验位 xff0c 1停止位 但是我在项目中也遇到某些芯片通信用的需要奇校验或者偶校验 xff0c 这里需要特别注意的是STM32中开启奇

  • Realtek RTL8762C/Realtek RTL8762D学习记录

    本人基于日常工作整理编写的8762C FAQ文档 xff0c 记录RTL8762C 8762D系列软件开发常见问题以及解决方案 希望它能发挥更多作用 帮到有需要的朋友 关键字 xff1a 8762CMF 8762CK 8762CJ 8762

  • 蓝牙BLE---DA14683的SPI主机通信讲解

    DA14683的SPI主机通信例程 Date 2018 12 19 Create Jim 导入例程 首先导入ble peripheral例程或者pxp reporter例程 再到以下位置打开硬件SPI的宏定义 xff1a 获取SPI例程源码

  • 06.5 Code

    06 5 Code 推力 force 推力的应用旋翼的气动阻力空气阻力矩滚转力矩电机的转速 推力 force span class token comment force 61 电机的转速 xff5c 电机的转速 xff5c xff08 带

  • C、C++ 对于char*和char[]的理解

    1 char 和char 的共同点 都是指针 xff0c 指向第一个字符所在的地址 2 char 的用法 char a 61 34 aaa 34 char p1 61 a char 是常量指针 xff08 常量的指针 xff09 xff0c

  • 重新抛出(rethrow)

    有可能单个catch不能完全处理一个异常 在进行了一些校正行动之后 xff0c catch可能确定该异常必须由函数调用链中更上层的函数来处理 xff0c catch可以通过重新抛出 rethrow 将异常传递给函数调用链中更上层的函数 重新

  • 4-2 图像聚类算法

    4 2 图像聚类算法 目录1 分类与聚类1 1 分类1 2 聚类1 3 聚类样本间的属性1 4 聚类的常见算法 2 K Means聚类2 1 概念2 2 步骤2 3 例子2 4 K Means聚类与图像处理2 5 K Means聚类优缺点优

  • JavaWeb-03 统一字符集编码、JSP的页面元素、JSP九大内置对象-request

    1 使用Eclipse开发Web项目 JSP项目 tomacat 2 在Eclipse中创建的Web项目 xff1a 浏览器可以直接访问WebContent中的文件例如 http 127 0 0 1 8888 MyJspProject in

  • 9-1 从零开始训练网络

    9 1 从零开始训练网络 目录1 搭建网络基本架构要完成的功能 2 构建训练网络1 实现网络训练功能2 获取训练数据及预处理 3 启动训练网络并测试数据 目录 搭建网络基本架构构建训练网络启动训练网络并测试数据 1 搭建网络基本架构 要完成

随机推荐

  • 基于知识图谱的推荐系统

    基于知识图谱的推荐系统 推荐系统 xff1a 核心目标是通过分析用户行为 兴趣 需求等信息 在海量的数据中挖掘用户感兴趣的信息 如商品 新闻 POI point of interest 和试题 等 个性化推荐算法是推荐系统的核心 其主要可以

  • mysql级联删除

    mysql级联删除 场景 xff1a 员工表 id xff1a 员工idleader id xff1a 该员工的领导的id xff08 也是员工id xff09 外键dept id xff1a 该员工的部门id xff08 部门表外键 xf

  • 【Seata】安装 - mac

    1 下载 官网 xff1a https seata io zh cn index html 2 修改配置文件 2 1 file conf 还有user password 2 2 registry conf 1 xff09 registry

  • Go Modules模式

    Go Modules模式 xff08 1 xff09 go mod 命令 命令作用go mod init生成 go mod 文件 在当前文件夹下初始化一个新的 go mod 文件go mod download下载 go mod 文件中指明的

  • 【Go】flag

    flag String span class token keyword func span span class token function String span span class token punctuation span n

  • Mybatis 逆向工程

    Mybatis 逆向工程 Maven项目generatorConfig xmlpom xml Maven项目 项目结构 xff1a generatorConfig xml span class token prolog lt xml ver

  • 原理分享 | 单片机常用通信协议汇总（上）

    vx 嵌入式工程师成长日记 https mp weixin qq com s biz 61 Mzg4Mzc3NDUxOQ 61 61 amp mid 61 2247484134 amp idx 61 1 amp sn 61 b779ccf0

  • C语言模拟TCP通信-------收发数据

    简介 这篇是我学习网络编程时初次接触到的 xff0c 感觉挺适合初学者 xff0c 下文主要介绍了如何使用Linux模拟TCP通信 xff0c 分为客户端和服务器端两大部分 xff0c 外加一个总的头文件 流程 服务器端和客户端使用TCP的

  • 多传感器融合记录

    多传感器信息融合的典型应用 多传感器融合中的时间硬同步1 论文阅读 weixin 39606911的博客 CSDN博客 前言阅读硕士论文 自动驾驶中多传感器集成同步控制器设计与实现 xff0c 该论文为自动驾驶设计了一套时间同步控制器 xf

  • VINS记录

    euroc launch lt launch gt lt arg name 61 34 config path 34 default 61 34 find feature tracker config euroc euroc config

  • OpenCV介绍与入门

    OpenCV入门 OpenCV介绍关于OpenCV1 OpenCV能做什么 xff1b 2 OpenCV与图形学与FFmpeg的关系 xff1b 3 OpenCV的未来 xff1b OpenCV介绍 OpenCV是计算机视觉的框架 关于Op

  • 【可见光室内定位】（一）概览

    目录 一 室内无线定位技术概况二 研究现状三 应用前景背景 一 室内无线定位技术概况 二 研究现状 得益于可见光通信 xff08 xff36 xff2c xff23 xff09 技术的迅速发展 xff0c 可 见光定位 xff08 xff3

  • 【机器学习中的数学】比例混合分布

    比例混合分布 Scale Mixture Distribution 混合分布是来自其他随机变量的集合构成的随机变量的概率分布 xff1a 一个随机变量是根据给定的概率从集合随机选取的 xff0c 然后所选随机变量的值就得到了 first a

  • 互联网相似图像识别检索引擎 —— 基于图像签名的方式

    一 引言 多媒体识别是信息检索中难度较高且需求日益旺盛的一个问题 以图像为例 xff0c 按照图像检索中使用的信息区分 xff0c 图像可以分为两类 xff1a 基于文本的图像检索和基于内容识别的图像检索 xff08 CBIR xff1a

  • 【Vim】使用map自定义快捷键

    map简介 map是一个映射命令 将常用的很长的命令映射到一个新的功能键上 map是Vim强大的一个重要原因 xff0c 可以自定义各种快捷键 xff0c 用起来自然得心应手 映射的种类 有五种映射存在 xff1a 用于普通模式 输入命令时

  • 【Scala】使用Option、Some、None，避免使用null

    避免null使用 大多数语言都有一个特殊的关键字或者对象来表示一个对象引用的是 无 xff0c 在Java xff0c 它是null 在Java 里 xff0c null 是一个关键字 xff0c 不是一个对象 xff0c 所以对它调用任何

  • 【Linux】使用update-alternatives命令进行版本的切换

    引言 在Debian系统中 xff0c 我们可能会同时安装有很多功能类似的程序和可选配置 xff0c 可能会出现同一软件的多个版本并存的场景 比如像是一些编程语言工具 xff0c 一些系统中自带的是python2 6 xff0c 而现在py

  • stm32G0 启动

    目的 STM32G是意法半导体这两年新推出的系列芯片 xff0c 相比原先的F系列的芯片有很多提升点 xff0c 将来必将取代F系列芯片的地位 对于新芯片的应用来说能够正确下载与运行程序是比较重要的一点 xff0c 这篇文章将对 STM32

  • 【scikit-learn】交叉验证及其用于参数选择、模型选择、特征选择的例子

    xfeff xfeff 内容概要 训练集 测试集分割用于模型验证的缺点K折交叉验证是如何克服之前的不足交叉验证如何用于选择调节参数 选择模型 选择特征改善交叉验证 1 模型验证回顾 进行模型验证的一个重要目的是要选出一个最合适的模型 xff

  • 【scikit-learn】网格搜索来进行高效的参数调优

    xfeff xfeff 内容概要 如何使用K折交叉验证来搜索最优调节参数如何让搜索参数的流程更加高效如何一次性的搜索多个调节参数在进行真正的预测之前 xff0c 如何对调节参数进行处理如何削减该过程的计算代价 1 K折交叉验证回顾 交叉验证

热门标签