val of_pyobject : Py.Object.t -> tval to_pyobject : t -> Py.Object.tval create :
?strategy:string ->
?random_state:[ `Int of int | `RandomState of Py.Object.t | `None ] ->
?constant:[ `Int of int | `String of string | `Ndarray of Ndarray.t ] ->
unit ->
tDummyClassifier is a classifier that makes predictions using simple rules.
This classifier is useful as a simple baseline to compare with other (real) classifiers. Do not use it for real problems.
Read more in the :ref:`User Guide <dummy_estimators>`.
.. versionadded:: 0.13
Parameters ---------- strategy : str, default="stratified" Strategy to use to generate predictions.
* "stratified": generates predictions by respecting the training set's class distribution. * "most_frequent": always predicts the most frequent label in the training set. * "prior": always predicts the class that maximizes the class prior (like "most_frequent") and ``predict_proba`` returns the class prior. * "uniform": generates predictions uniformly at random. * "constant": always predicts a constant label that is provided by the user. This is useful for metrics that evaluate a non-majority class
.. versionchanged:: 0.22 The default value of `strategy` will change to "prior" in version 0.24. Starting from version 0.22, a warning will be raised if `strategy` is not explicitly set.
.. versionadded:: 0.17 Dummy Classifier now supports prior fitting strategy using parameter *prior*.
random_state : int, RandomState instance or None, optional, default=None If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`.
constant : int or str or array-like of shape (n_outputs,) The explicit constant as predicted by the "constant" strategy. This parameter is useful only for the "constant" strategy.
Attributes ---------- classes_ : array or list of array of shape (n_classes,) Class labels for each output.
n_classes_ : array or list of array of shape (n_classes,) Number of label for each output.
class_prior_ : array or list of array of shape (n_classes,) Probability of each class for each output.
n_outputs_ : int, Number of outputs.
sparse_output_ : bool, True if the array returned from predict is to be in sparse CSC format. Is automatically set to True if the input y is passed in sparse format.
Examples -------- >>> import numpy as np >>> from sklearn.dummy import DummyClassifier >>> X = np.array(-1, 1, 1, 1) >>> y = np.array(0, 1, 1, 1) >>> dummy_clf = DummyClassifier(strategy="most_frequent") >>> dummy_clf.fit(X, y) DummyClassifier(strategy='most_frequent') >>> dummy_clf.predict(X) array(1, 1, 1, 1) >>> dummy_clf.score(X, y) 0.75
val fit :
?sample_weight:Ndarray.t ->
x:[ `Ndarray of Ndarray.t | `PyObject of Py.Object.t ] ->
y:Ndarray.t ->
t ->
tFit the random classifier.
Parameters ---------- X : array-like, object with finite length or shape Training data, requires length = n_samples
y : array-like of shape (n_samples,) or (n_samples, n_outputs) Target values.
sample_weight : array-like of shape (n_samples,), default=None Sample weights.
Returns ------- self : object
val get_params : ?deep:bool -> t -> Py.Object.tGet 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:[ `Ndarray of Ndarray.t | `PyObject of Py.Object.t ] ->
t ->
Ndarray.tPerform classification on test vectors X.
Parameters ---------- X : array-like, object with finite length or shape Training data, requires length = n_samples
Returns ------- y : array-like of shape (n_samples,) or (n_samples, n_outputs) Predicted target values for X.
val predict_log_proba :
x:[ `Ndarray of Ndarray.t | `PyObject of Py.Object.t ] ->
t ->
Py.Object.tReturn log probability estimates for the test vectors X.
Parameters ---------- X : array-like, object with finite length or shape Training data, requires length = n_samples
Returns ------- P : array-like or list of array-like of shape (n_samples, n_classes) Returns the log probability of the sample for each class in the model, where classes are ordered arithmetically for each output.
val predict_proba :
x:[ `Ndarray of Ndarray.t | `PyObject of Py.Object.t ] ->
t ->
Ndarray.tReturn probability estimates for the test vectors X.
Parameters ---------- X : array-like, object with finite length or shape Training data, requires length = n_samples
Returns ------- P : array-like or list of array-lke of shape (n_samples, n_classes) Returns the probability of the sample for each class in the model, where classes are ordered arithmetically, for each output.
val score :
?sample_weight:Ndarray.t ->
x:[ `Ndarray of Ndarray.t | `None ] ->
y:Ndarray.t ->
t ->
floatReturns the mean accuracy on the given test data and labels.
In multi-label classification, this is the subset accuracy which is a harsh metric since you require for each sample that each label set be correctly predicted.
Parameters ---------- X : array-like, None Test samples with shape = (n_samples, n_features) or None. Passing None as test samples gives the same result as passing real test samples, since DummyClassifier operates independently of the sampled observations.
y : array-like of shape (n_samples,) or (n_samples, n_outputs) True labels for X.
sample_weight : array-like of shape (n_samples,), default=None Sample weights.
Returns ------- score : float Mean accuracy of self.predict(X) wrt. y.
val set_params : ?params:(string * Py.Object.t) list -> t -> tSet 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 n_classes_ : t -> Py.Object.tAttribute n_classes_: see constructor for documentation
val class_prior_ : t -> Py.Object.tAttribute class_prior_: see constructor for documentation
val n_outputs_ : t -> intAttribute n_outputs_: see constructor for documentation
val sparse_output_ : t -> boolAttribute sparse_output_: see constructor for documentation
val to_string : t -> stringPrint the object to a human-readable representation.
val show : t -> stringPrint the object to a human-readable representation.
val pp : Format.formatter -> t -> unitPretty-print the object to a formatter.