package sklearn

  1. Overview
  2. Docs
package sklearn
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `AffinityPropagation
]
type t = [ `AffinityPropagation | `BaseEstimator | `ClusterMixin | `Object ] Obj.t
val of_pyobject : Py.Object.t -> t
val to_pyobject : [> tag ] Obj.t -> Py.Object.t
val as_estimator : t -> [ `BaseEstimator ] Obj.t
val as_cluster : t -> [ `ClusterMixin ] Obj.t
val create : ?damping:float -> ?max_iter:int -> ?convergence_iter:int -> ?copy:bool -> ?preference:[> `ArrayLike ] Np.Obj.t -> ?affinity:[ `Euclidean | `Precomputed ] -> ?verbose:int -> ?random_state:int -> unit -> t

Perform Affinity Propagation Clustering of data.

Read more in the :ref:`User Guide <affinity_propagation>`.

Parameters ---------- damping : float, default=0.5 Damping factor (between 0.5 and 1) is the extent to which the current value is maintained relative to incoming values (weighted 1 - damping). This in order to avoid numerical oscillations when updating these values (messages).

max_iter : int, default=200 Maximum number of iterations.

convergence_iter : int, default=15 Number of iterations with no change in the number of estimated clusters that stops the convergence.

copy : bool, default=True Make a copy of input data.

preference : array-like of shape (n_samples,) or float, default=None Preferences for each point - points with larger values of preferences are more likely to be chosen as exemplars. The number of exemplars, ie of clusters, is influenced by the input preferences value. If the preferences are not passed as arguments, they will be set to the median of the input similarities.

affinity : 'euclidean', 'precomputed', default='euclidean' Which affinity to use. At the moment 'precomputed' and ``euclidean`` are supported. 'euclidean' uses the negative squared euclidean distance between points.

verbose : bool, default=False Whether to be verbose.

random_state : int or np.random.RandomStateInstance, default: 0 Pseudo-random number generator to control the starting state. Use an int for reproducible results across function calls. See the :term:`Glossary <random_state>`.

.. versionadded:: 0.23 this parameter was previously hardcoded as 0.

Attributes ---------- cluster_centers_indices_ : ndarray of shape (n_clusters,) Indices of cluster centers

cluster_centers_ : ndarray of shape (n_clusters, n_features) Cluster centers (if affinity != ``precomputed``).

labels_ : ndarray of shape (n_samples,) Labels of each point

affinity_matrix_ : ndarray of shape (n_samples, n_samples) Stores the affinity matrix used in ``fit``.

n_iter_ : int Number of iterations taken to converge.

Notes ----- For an example, see :ref:`examples/cluster/plot_affinity_propagation.py <sphx_glr_auto_examples_cluster_plot_affinity_propagation.py>`.

The algorithmic complexity of affinity propagation is quadratic in the number of points.

When ``fit`` does not converge, ``cluster_centers_`` becomes an empty array and all training samples will be labelled as ``-1``. In addition, ``predict`` will then label every sample as ``-1``.

When all training samples have equal similarities and equal preferences, the assignment of cluster centers and labels depends on the preference. If the preference is smaller than the similarities, ``fit`` will result in a single cluster center and label ``0`` for every sample. Otherwise, every training sample becomes its own cluster center and is assigned a unique label.

References ----------

Brendan J. Frey and Delbert Dueck, 'Clustering by Passing Messages Between Data Points', Science Feb. 2007

Examples -------- >>> from sklearn.cluster import AffinityPropagation >>> import numpy as np >>> X = np.array([1, 2], [1, 4], [1, 0], ... [4, 2], [4, 4], [4, 0]) >>> clustering = AffinityPropagation(random_state=5).fit(X) >>> clustering AffinityPropagation(random_state=5) >>> clustering.labels_ array(0, 0, 0, 1, 1, 1) >>> clustering.predict([0, 0], [4, 4]) array(0, 1) >>> clustering.cluster_centers_ array([1, 2], [4, 2])

val fit : ?y:Py.Object.t -> x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> t

Fit the clustering from features, or affinity matrix.

Parameters ---------- X : array-like or sparse matrix, shape (n_samples, n_features), or array-like, shape (n_samples, n_samples) Training instances to cluster, or similarities / affinities between instances if ``affinity='precomputed'``. If a sparse feature matrix is provided, it will be converted into a sparse ``csr_matrix``.

y : Ignored Not used, present here for API consistency by convention.

Returns ------- self

val fit_predict : ?y:Py.Object.t -> x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Fit the clustering from features or affinity matrix, and return cluster labels.

Parameters ---------- X : array-like or sparse matrix, shape (n_samples, n_features), or array-like, shape (n_samples, n_samples) Training instances to cluster, or similarities / affinities between instances if ``affinity='precomputed'``. If a sparse feature matrix is provided, it will be converted into a sparse ``csr_matrix``.

y : Ignored Not used, present here for API consistency by convention.

Returns ------- labels : ndarray, shape (n_samples,) Cluster labels.

val get_params : ?deep:bool -> [> tag ] Obj.t -> Dict.t

Get parameters for this estimator.

Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns ------- params : mapping of string to any Parameter names mapped to their values.

val predict : x:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> [> `ArrayLike ] Np.Obj.t

Predict the closest cluster each sample in X belongs to.

Parameters ---------- X : array-like or sparse matrix, shape (n_samples, n_features) New data to predict. If a sparse matrix is provided, it will be converted into a sparse ``csr_matrix``.

Returns ------- labels : ndarray, shape (n_samples,) Cluster labels.

val set_params : ?params:(string * Py.Object.t) list -> [> tag ] Obj.t -> t

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form ``<component>__<parameter>`` so that it's possible to update each component of a nested object.

Parameters ---------- **params : dict Estimator parameters.

Returns ------- self : object Estimator instance.

val cluster_centers_indices_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute cluster_centers_indices_: get value or raise Not_found if None.

val cluster_centers_indices_opt : t -> [> `ArrayLike ] Np.Obj.t option

Attribute cluster_centers_indices_: get value as an option.

val cluster_centers_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute cluster_centers_: get value or raise Not_found if None.

val cluster_centers_opt : t -> [> `ArrayLike ] Np.Obj.t option

Attribute cluster_centers_: get value as an option.

val labels_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute labels_: get value or raise Not_found if None.

val labels_opt : t -> [> `ArrayLike ] Np.Obj.t option

Attribute labels_: get value as an option.

val affinity_matrix_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute affinity_matrix_: get value or raise Not_found if None.

val affinity_matrix_opt : t -> [> `ArrayLike ] Np.Obj.t option

Attribute affinity_matrix_: get value as an option.

val n_iter_ : t -> int

Attribute n_iter_: get value or raise Not_found if None.

val n_iter_opt : t -> int option

Attribute n_iter_: get value as an option.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Stdlib.Format.formatter -> t -> unit

Pretty-print the object to a formatter.