package sklearn

You can search for identifiers within the package.

in-package search v0.2.0

sklearn
- Sklearn

Legend:
Library
Module
Module type
Parameter
Class
Class type

type t

val of_pyobject : Py.Object.t -> t

val to_pyobject : t -> Py.Object.t

val create : 
  ?strategy:string ->
  ?constant:[ `I of int | `F of float | `Arr of Arr.t ] ->
  ?quantile:Py.Object.t ->
  unit ->
  t

DummyRegressor is a regressor that makes predictions using simple rules.

This regressor is useful as a simple baseline to compare with other (real) regressors. Do not use it for real problems.

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

.. versionadded:: 0.13

Parameters ---------- strategy : str Strategy to use to generate predictions.

* "mean": always predicts the mean of the training set * "median": always predicts the median of the training set * "quantile": always predicts a specified quantile of the training set, provided with the quantile parameter. * "constant": always predicts a constant value that is provided by the user.

constant : int or float 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.

quantile : float in 0.0, 1.0 The quantile to predict using the "quantile" strategy. A quantile of 0.5 corresponds to the median, while 0.0 to the minimum and 1.0 to the maximum.

Attributes ---------- constant_ : array, shape (1, n_outputs) Mean or median or quantile of the training targets or constant value given by the user.

n_outputs_ : int, Number of outputs.

Examples -------- >>> import numpy as np >>> from sklearn.dummy import DummyRegressor >>> X = np.array(1.0, 2.0, 3.0, 4.0) >>> y = np.array(2.0, 3.0, 5.0, 10.0) >>> dummy_regr = DummyRegressor(strategy="mean") >>> dummy_regr.fit(X, y) DummyRegressor() >>> dummy_regr.predict(X) array(5., 5., 5., 5.) >>> dummy_regr.score(X, y) 0.0

val fit : 
  ?sample_weight:Arr.t ->
  x:[ `Arr of Arr.t | `Object_with_finite_shape of Py.Object.t ] ->
  y:Arr.t ->
  t ->
  t

Fit the random regressor.

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 -> 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 : ?return_std:bool -> x:Arr.t -> t -> Arr.t

Perform classification on test vectors X.

Parameters ---------- X : array-like, object with finite length or shape Training data, requires length = n_samples

return_std : boolean, optional Whether to return the standard deviation of posterior prediction. All zeros in this case.

Returns ------- y : array-like of shape (n_samples,) or (n_samples, n_outputs) Predicted target values for X.

y_std : array-like of shape (n_samples,) or (n_samples, n_outputs) Standard deviation of predictive distribution of query points.

val score : 
  ?sample_weight:Arr.t ->
  x:[ `Arr of Arr.t | `None ] ->
  y:Arr.t ->
  t ->
  float

Returns the coefficient of determination R^2 of the prediction.

The coefficient R^2 is defined as (1 - u/v), where u is the residual sum of squares ((y_true - y_pred) ** 2).sum() and v is the total sum of squares ((y_true - y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a R^2 score of 0.0.

Parameters ---------- X : array-like, None Test samples with shape = (n_samples, n_features) or None. For some estimators this may be a precomputed kernel matrix instead, shape = (n_samples, n_samples_fitted], where n_samples_fitted is the number of samples used in the fitting for the estimator. Passing None as test samples gives the same result as passing real test samples, since DummyRegressor operates independently of the sampled observations.

y : array-like of shape (n_samples,) or (n_samples, n_outputs) True values for X.

sample_weight : array-like of shape (n_samples,), default=None Sample weights.

Returns ------- score : float R^2 of self.predict(X) wrt. y.

val set_params : ?params:(string * Py.Object.t) list -> 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 constant_ : t -> Arr.t

Attribute constant_: get value or raise Not_found if None.

val constant_opt : t -> Arr.t option

Attribute constant_: get value as an option.

val n_outputs_ : t -> int

Attribute n_outputs_: get value or raise Not_found if None.

val n_outputs_opt : t -> int option

Attribute n_outputs_: 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 : Format.formatter -> t -> unit

Pretty-print the object to a formatter.