KNeighborsRegressor#

class sklearn.neighbors.KNeighborsRegressor(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)#

基于k近邻的回归。

目标是通过训练集中最近邻目标的局部插值来预测的。

更多信息请参阅 用户指南 。

Added in version 0.9.

Parameters:
n_neighborsint, default=5

默认用于 kneighbors 查询的邻居数量。

weights{‘uniform’, ‘distance’}, callable or None, default=’uniform’

用于预测的权重函数。可能的值：

  • ‘uniform’ : 均匀权重。每个邻域中的所有点权重相同。

  • ‘distance’ : 按距离的倒数加权。在这种情况下，查询点的近邻将比远邻有更大的影响。

  • [callable] : 用户定义的函数，接受距离数组并返回相同形状的权重数组。

默认使用均匀权重。

algorithm{‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, default=’auto’

用于计算最近邻的算法：

  • ‘ball_tree’ 将使用 BallTree

  • ‘kd_tree’ 将使用 KDTree

  • ‘brute’ 将使用暴力搜索。

  • ‘auto’ 将尝试根据传递给 fit 方法的值决定最合适的算法。

注意：在稀疏输入上拟合将覆盖此参数的设置，使用暴力搜索。

leaf_sizeint, default=30

传递给 BallTree 或 KDTree 的叶子大小。这会影响构建和查询的速度，以及存储树所需的内存。最佳值取决于问题的性质。

pfloat, default=2

闵可夫斯基度量的幂参数。当 p = 1 时，这相当于使用曼哈顿距离（l1），当 p = 2 时，相当于使用欧几里得距离（l2）。对于任意 p，使用闵可夫斯基距离（l_p）。

metricstr, DistanceMetric object or callable, default=’minkowski’

用于距离计算的度量。默认是 “minkowski”，当 p = 2 时，结果为标准欧几里得距离。请参阅 scipy.spatial.distance 的文档和 distance_metrics 中列出的度量，以获取有效的度量值。

如果度量是 “precomputed”，则假定 X 是距离矩阵，并且在拟合时必须是方阵。X 可以是 稀疏图 ，在这种情况下，只考虑 “非零” 元素作为邻居。

如果度量是可调用函数，它接受两个表示一维向量的数组作为输入，并返回一个值，表示这两个向量之间的距离。这适用于 Scipy 的度量，但比将度量名称作为字符串传递效率低。

如果度量是 DistanceMetric 对象，它将直接传递给底层计算例程。

metric_paramsdict, default=None

度量函数的额外关键字参数。

n_jobsint, default=None

用于邻居搜索的并行作业数量。 None 表示 1，除非在 joblib.parallel_backend 上下文中。 -1 表示使用所有处理器。有关更多详细信息，请参阅 Glossary 。 不影响 fit 方法。

Attributes:
effective_metric_str or callable

使用的距离度量。它将与 metric 参数相同或为其同义词，例如，如果 metric 参数设置为 ‘minkowski’ 且 p 参数设置为 2，则为 ‘euclidean’。

effective_metric_params_dict

度量函数的额外关键字参数。对于大多数度量，将与 metric_params 参数相同，但如果 effective_metric_ 属性设置为 ‘minkowski’，则可能还包含 p 参数值。

n_features_in_int

在 fit 过程中看到的特征数量。

Added in version 0.24.

feature_names_in_ndarray of shape ( n_features_in_ ,)

在 fit 过程中看到的特征名称。仅当 X 的特征名称均为字符串时定义。

Added in version 1.0.

n_samples_fit_int

拟合数据中的样本数量。

See also

NearestNeighbors

用于实现邻居搜索的无监督学习器。

RadiusNeighborsRegressor

基于固定半径内邻居的回归。

KNeighborsClassifier

实现 k 近邻投票的分类器。

RadiusNeighborsClassifier

在给定半径内实现邻居投票的分类器。

Notes

有关 algorithm 和 leaf_size 选择的讨论，请参阅在线文档中的 Nearest Neighbors 。

Warning

关于最近邻算法，如果发现两个邻居，邻居 k+1 和 k ，具有相同的距离但不同的标签，结果将取决于训练数据的顺序。

https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm

Examples

>>> X = [[0], [1], [2], [3]]
>>> y = [0, 0, 1, 1]
>>> from sklearn.neighbors import KNeighborsRegressor
>>> neigh = KNeighborsRegressor(n_neighbors=2)
>>> neigh.fit(X, y)
KNeighborsRegressor(...)
>>> print(neigh.predict([[1.5]]))
[0.5]
fit(X, y)#

拟合从训练数据集得到的k近邻回归器。

Parameters:
X{array-like, sparse matrix} of shape (n_samples, n_features) or (n_samples, n_samples) if metric=’precomputed’

训练数据。

y{array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_outputs)

目标值。

Returns:
selfKNeighborsRegressor

拟合的k近邻回归器。

get_metadata_routing()#

获取此对象的元数据路由。

请查看 用户指南 以了解路由机制的工作原理。

Returns:
routingMetadataRequest

MetadataRequest 封装的 路由信息。

get_params(deep=True)#

获取此估计器的参数。

Parameters:
deepbool, 默认=True

如果为True，将返回此估计器和包含的子对象（也是估计器）的参数。

Returns:
paramsdict

参数名称映射到它们的值。

kneighbors(X=None, n_neighbors=None, return_distance=True)#

查找一个点的K近邻。

返回每个点的邻居的索引和距离。

Parameters:
X{array-like, sparse matrix}, shape (n_queries, n_features), 或 (n_queries, n_indexed) 如果 metric == ‘precomputed’, default=None

查询点或点。 如果未提供，则返回每个索引点的邻居。 在这种情况下，查询点不视为其自身的邻居。

n_neighborsint, default=None

每个样本所需的邻居数量。默认值是在构造函数中传递的值。

return_distancebool, default=True

是否返回距离。

Returns:
neigh_distndarray of shape (n_queries, n_neighbors)

表示到点的长度的数组，仅在 return_distance=True 时存在。

neigh_indndarray of shape (n_queries, n_neighbors)

在总体矩阵中最接近点的索引。

Examples

在以下示例中，我们从一个表示数据集的数组构造一个 NearestNeighbors 类，并询问谁是 [1,1,1] 最近的点

>>> samples = [[0., 0., 0.], [0., .5, 0.], [1., 1., .5]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(n_neighbors=1)
>>> neigh.fit(samples)
NearestNeighbors(n_neighbors=1)
>>> print(neigh.kneighbors([[1., 1., 1.]]))
(array([[0.5]]), array([[2]]))

如你所见，它返回 [[0.5]] 和 [[2]]，这意味着元素距离为 0.5，并且是 samples 的第三个元素（索引从 0 开始）。你也可以查询多个点：

>>> X = [[0., 1., 0.], [1., 0., 1.]]
>>> neigh.kneighbors(X, return_distance=False)
array([[1],
       [2]]...)
kneighbors_graph(X=None, n_neighbors=None, mode='connectivity')#

计算X中点的k-邻居的（加权）图。

Parameters:
X{array-like, sparse matrix}，形状为(n_queries, n_features)， 或者如果metric == ‘precomputed’，形状为(n_queries, n_indexed)，默认=None

查询点或点。 如果没有提供，则返回每个索引点的邻居。 在这种情况下，查询点不被视为其自身的邻居。 对于 metric='precomputed' ，形状应为 (n_queries, n_indexed)。否则，形状应为 (n_queries, n_features)。

n_neighborsint, 默认=None

每个样本的邻居数量。默认值是在构造函数中传递的值。

mode{‘connectivity’, ‘distance’}, 默认=’connectivity’

返回矩阵的类型：’connectivity’将返回带有1和0的连通性矩阵，在’distance’中， 边是点之间的距离，距离的类型取决于NearestNeighbors类中选择的metric参数。

Returns:
A形状为(n_queries, n_samples_fit)的稀疏矩阵

n_samples_fit 是拟合数据中的样本数量。 A[i, j] 给出连接 i 到 j 的边的权重。 矩阵为CSR格式。

See also

NearestNeighbors.radius_neighbors_graph

计算X中点的（加权）邻居图。

Examples

>>> X = [[0], [3], [1]]
>>> from sklearn.neighbors import NearestNeighbors
>>> neigh = NearestNeighbors(n_neighbors=2)
>>> neigh.fit(X)
NearestNeighbors(n_neighbors=2)
>>> A = neigh.kneighbors_graph(X)
>>> A.toarray()
array([[1., 0., 1.],
       [0., 1., 1.],
       [1., 0., 1.]])
predict(X)#

预测提供数据的标签。

Parameters:
X{array-like, sparse matrix} of shape (n_queries, n_features), 或 (n_queries, n_indexed) 如果 metric == ‘precomputed’

测试样本。

Returns:
yndarray of shape (n_queries,) 或 (n_queries, n_outputs), dtype=int

目标值。

score(X, y, sample_weight=None)#

返回预测的决定系数。

决定系数 \(R^2\) 定义为 \((1 - rac{u}{v})\) ，其中 \(u\) 是残差平方和 ((y_true - y_pred)** 2).sum() ，而 \(v\) 是总平方和 ((y_true - y_true.mean()) ** 2).sum() 。最好的可能得分是 1.0，它可能是负的（因为模型可能任意地差）。一个总是预测 y 的期望值的常数模型，忽略输入特征，将得到 \(R^2\) 得分为 0.0。

Parameters:
Xarray-like of shape (n_samples, n_features)

测试样本。对于某些估计器，这可能是一个预计算的核矩阵或一个形状为 (n_samples, n_samples_fitted) 的通用对象列表，其中 n_samples_fitted 是估计器拟合中使用的样本数量。

yarray-like of shape (n_samples,) or (n_samples, n_outputs)

X 的真实值。

sample_weightarray-like of shape (n_samples,), default=None

样本权重。

Returns:
scorefloat

\(R^2\) 相对于 y 的 self.predict(X) 。

Notes

在调用回归器的 score 时使用的 \(R^2\) 得分从 0.23 版本开始使用 multioutput='uniform_average' 以保持与 r2_score 默认值一致。 这影响了所有多输出回归器的 score 方法（除了 MultiOutputRegressor ）。

set_params(**params)#

设置此估计器的参数。

该方法适用于简单估计器以及嵌套对象（例如 Pipeline ）。后者具有形式为 <component>__<parameter> 的参数，以便可以更新嵌套对象的每个组件。

Parameters:
**paramsdict

估计器参数。

Returns:
selfestimator instance

估计器实例。

set_score_request(*, sample_weight: bool | None | str = '$UNCHANGED$') → KNeighborsRegressor#

Request metadata passed to the score method.

Note that this method is only relevant if enable_metadata_routing=True (see sklearn.set_config ). Please see User Guide on how the routing mechanism works.

The options for each parameter are:

  • True : metadata is requested, and passed to score if provided. The request is ignored if metadata is not provided.

  • False : metadata is not requested and the meta-estimator will not pass it to score .

  • None : metadata is not requested, and the meta-estimator will raise an error if the user provides it.

  • str : metadata should be passed to the meta-estimator with this given alias instead of the original name.

The default ( sklearn.utils.metadata_routing.UNCHANGED ) retains the existing request. This allows you to change the request for some parameters and not others.

Added in version 1.3.

Note

This method is only relevant if this estimator is used as a sub-estimator of a meta-estimator, e.g. used inside a Pipeline . Otherwise it has no effect.

Parameters:
sample_weightstr, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED

Metadata routing for sample_weight parameter in score .

Returns:
selfobject

The updated object.

On this page
Show Source