\n",
"
sklearn.neighbors._classification.KNeighborsClassifier
def __init__(n_neighbors=5, *, weights='uniform', algorithm='auto', leaf_size=30, p=2, metric='minkowski', metric_params=None, n_jobs=None)
/usr/local/lib/python3.11/dist-packages/sklearn/neighbors/_classification.pyClassifier implementing the k-nearest neighbors vote.\n",
"\n",
"Read more in the :ref:`User Guide <classification>`.\n",
"\n",
"Parameters\n",
"----------\n",
"n_neighbors : int, default=5\n",
" Number of neighbors to use by default for :meth:`kneighbors` queries.\n",
"\n",
"weights : {'uniform', 'distance'}, callable or None, default='uniform'\n",
" Weight function used in prediction. Possible values:\n",
"\n",
" - 'uniform' : uniform weights. All points in each neighborhood\n",
" are weighted equally.\n",
" - 'distance' : weight points by the inverse of their distance.\n",
" in this case, closer neighbors of a query point will have a\n",
" greater influence than neighbors which are further away.\n",
" - [callable] : a user-defined function which accepts an\n",
" array of distances, and returns an array of the same shape\n",
" containing the weights.\n",
"\n",
" Refer to the example entitled\n",
" :ref:`sphx_glr_auto_examples_neighbors_plot_classification.py`\n",
" showing the impact of the `weights` parameter on the decision\n",
" boundary.\n",
"\n",
"algorithm : {'auto', 'ball_tree', 'kd_tree', 'brute'}, default='auto'\n",
" Algorithm used to compute the nearest neighbors:\n",
"\n",
" - 'ball_tree' will use :class:`BallTree`\n",
" - 'kd_tree' will use :class:`KDTree`\n",
" - 'brute' will use a brute-force search.\n",
" - 'auto' will attempt to decide the most appropriate algorithm\n",
" based on the values passed to :meth:`fit` method.\n",
"\n",
" Note: fitting on sparse input will override the setting of\n",
" this parameter, using brute force.\n",
"\n",
"leaf_size : int, default=30\n",
" Leaf size passed to BallTree or KDTree. This can affect the\n",
" speed of the construction and query, as well as the memory\n",
" required to store the tree. The optimal value depends on the\n",
" nature of the problem.\n",
"\n",
"p : float, default=2\n",
" Power parameter for the Minkowski metric. When p = 1, this is equivalent\n",
" to using manhattan_distance (l1), and euclidean_distance (l2) for p = 2.\n",
" For arbitrary p, minkowski_distance (l_p) is used. This parameter is expected\n",
" to be positive.\n",
"\n",
"metric : str or callable, default='minkowski'\n",
" Metric to use for distance computation. Default is "minkowski", which\n",
" results in the standard Euclidean distance when p = 2. See the\n",
" documentation of `scipy.spatial.distance\n",
" <https://docs.scipy.org/doc/scipy/reference/spatial.distance.html>`_ and\n",
" the metrics listed in\n",
" :class:`~sklearn.metrics.pairwise.distance_metrics` for valid metric\n",
" values.\n",
"\n",
" If metric is "precomputed", X is assumed to be a distance matrix and\n",
" must be square during fit. X may be a :term:`sparse graph`, in which\n",
" case only "nonzero" elements may be considered neighbors.\n",
"\n",
" If metric is a callable function, it takes two arrays representing 1D\n",
" vectors as inputs and must return one value indicating the distance\n",
" between those vectors. This works for Scipy's metrics, but is less\n",
" efficient than passing the metric name as a string.\n",
"\n",
"metric_params : dict, default=None\n",
" Additional keyword arguments for the metric function.\n",
"\n",
"n_jobs : int, default=None\n",
" The number of parallel jobs to run for neighbors search.\n",
" ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n",
" ``-1`` means using all processors. See :term:`Glossary <n_jobs>`\n",
" for more details.\n",
" Doesn't affect :meth:`fit` method.\n",
"\n",
"Attributes\n",
"----------\n",
"classes_ : array of shape (n_classes,)\n",
" Class labels known to the classifier\n",
"\n",
"effective_metric_ : str or callble\n",
" The distance metric used. It will be same as the `metric` parameter\n",
" or a synonym of it, e.g. 'euclidean' if the `metric` parameter set to\n",
" 'minkowski' and `p` parameter set to 2.\n",
"\n",
"effective_metric_params_ : dict\n",
" Additional keyword arguments for the metric function. For most metrics\n",
" will be same with `metric_params` parameter, but may also contain the\n",
" `p` parameter value if the `effective_metric_` attribute is set to\n",
" 'minkowski'.\n",
"\n",
"n_features_in_ : int\n",
" Number of features seen during :term:`fit`.\n",
"\n",
" .. versionadded:: 0.24\n",
"\n",
"feature_names_in_ : ndarray of shape (`n_features_in_`,)\n",
" Names of features seen during :term:`fit`. Defined only when `X`\n",
" has feature names that are all strings.\n",
"\n",
" .. versionadded:: 1.0\n",
"\n",
"n_samples_fit_ : int\n",
" Number of samples in the fitted data.\n",
"\n",
"outputs_2d_ : bool\n",
" False when `y`'s shape is (n_samples, ) or (n_samples, 1) during fit\n",
" otherwise True.\n",
"\n",
"See Also\n",
"--------\n",
"RadiusNeighborsClassifier: Classifier based on neighbors within a fixed radius.\n",
"KNeighborsRegressor: Regression based on k-nearest neighbors.\n",
"RadiusNeighborsRegressor: Regression based on neighbors within a fixed radius.\n",
"NearestNeighbors: Unsupervised learner for implementing neighbor searches.\n",
"\n",
"Notes\n",
"-----\n",
"See :ref:`Nearest Neighbors <neighbors>` in the online documentation\n",
"for a discussion of the choice of ``algorithm`` and ``leaf_size``.\n",
"\n",
".. warning::\n",
"\n",
" Regarding the Nearest Neighbors algorithms, if it is found that two\n",
" neighbors, neighbor `k+1` and `k`, have identical distances\n",
" but different labels, the results will depend on the ordering of the\n",
" training data.\n",
"\n",
"https://en.wikipedia.org/wiki/K-nearest_neighbor_algorithm\n",
"\n",
"Examples\n",
"--------\n",
">>> X = [[0], [1], [2], [3]]\n",
">>> y = [0, 0, 1, 1]\n",
">>> from sklearn.neighbors import KNeighborsClassifier\n",
">>> neigh = KNeighborsClassifier(n_neighbors=3)\n",
">>> neigh.fit(X, y)\n",
"KNeighborsClassifier(...)\n",
">>> print(neigh.predict([[1.1]]))\n",
"[0]\n",
">>> print(neigh.predict_proba([[0.9]]))\n",
"[[0.666... 0.333...]]\n",
" \n",
"