netron/source/sklearn-metadata.json

[
  {
    "name": "lightgbm.basic.Booster",
    "attributes": [
      {
        "default": -1,
        "name": "best_iteration"
      },
      {
        "default": false,
        "name": "network"
      },
      {
        "default": null,
        "name": "train_set"
      },
      {
        "default": false,
        "name": "stride"
      },
      {
        "default": null,
        "name": "model_file"
      },
      {
        "default": null,
        "name": "params"
      },
      {
        "default": null,
        "name": "pandas_categorical"
      }
    ]
  },
  {
    "name": "lightgbm.sklearn.LGBMClassifier",
    "attributes": [
      {
        "default": "gbdt",
        "name": "boosting_type",
        "type": "string"
      },
      {
        "default": null,
        "name": "class_weight"
      },
      {
        "default": 1,
        "name": "colsample_bytree"
      },
      {
        "default": 0.05,
        "name": "learning_rate"
      },
      {
        "default": -1,
        "name": "max_depth"
      },
      {
        "default": 20,
        "name": "min_child_samples"
      },
      {
        "default": 0.001,
        "name": "min_child_weight"
      },
      {
        "default": 0,
        "name": "min_split_gain"
      },
      {
        "default": 100,
        "name": "n_estimators"
      },
      {
        "default": -1,
        "name": "n_jobs"
      },
      {
        "default": 31,
        "name": "num_leaves"
      },
      {
        "default": null,
        "name": "random_state"
      },
      {
        "default": 0,
        "name": "reg_alpha"
      },
      {
        "default": 0,
        "name": "reg_lambda"
      },
      {
        "default": true,
        "name": "silent",
        "type": "boolean"
      },
      {
        "default": 200000,
        "name": "subsample_for_bin"
      },
      {
        "default": 0,
        "name": "subsample_freq"
      },
      {
        "default": 1,
        "name": "subsample"
      }
    ]
  },
  {
    "name": "lightgbm.sklearn.LGBMRegressor",
    "attributes": [
      {
        "default": "gbdt",
        "name": "boosting_type",
        "type": "string"
      },
      {
        "default": null,
        "name": "class_weight"
      },
      {
        "default": 1,
        "name": "colsample_bytree"
      },
      {
        "default": 0.05,
        "name": "learning_rate"
      },
      {
        "default": -1,
        "name": "max_depth"
      },
      {
        "default": 20,
        "name": "min_child_samples"
      },
      {
        "default": 0.001,
        "name": "min_child_weight"
      },
      {
        "default": 0,
        "name": "min_split_gain"
      },
      {
        "default": 100,
        "name": "n_estimators"
      },
      {
        "default": -1,
        "name": "n_jobs"
      },
      {
        "default": 31,
        "name": "num_leaves"
      },
      {
        "default": null,
        "name": "random_state"
      },
      {
        "default": 0,
        "name": "reg_alpha"
      },
      {
        "default": 0,
        "name": "reg_lambda"
      },
      {
        "default": true,
        "name": "silent",
        "type": "boolean"
      },
      {
        "default": 200000,
        "name": "subsample_for_bin"
      },
      {
        "default": 0,
        "name": "subsample_freq"
      },
      {
        "default": 1,
        "name": "subsample"
      }
    ]
  },
  {
    "name": "sklearn.calibration.CalibratedClassifierCV",
    "description": "Probability calibration with isotonic regression or logistic regression.\n\nThis class uses cross-validation to both estimate the parameters of a\nclassifier and subsequently calibrate a classifier. With default\n`ensemble=True`, for each cv split it\nfits a copy of the base estimator to the training subset, and calibrates it\nusing the testing subset. For prediction, predicted probabilities are\naveraged across these individual calibrated classifiers. When\n`ensemble=False`, cross-validation is used to obtain unbiased predictions,\nvia :func:`~sklearn.model_selection.cross_val_predict`, which are then\nused for calibration. For prediction, the base estimator, trained using all\nthe data, is used. This is the prediction method implemented when\n`probabilities=True` for :class:`~sklearn.svm.SVC` and :class:`~sklearn.svm.NuSVC`\nestimators (see :ref:`User Guide <scores_probabilities>` for details).\n\nAlready fitted classifiers can be calibrated via the parameter\n`cv=\"prefit\"`. In this case, no cross-validation is used and all provided\ndata is used for calibration. The user has to take care manually that data\nfor model fitting and calibration are disjoint.\n\nThe calibration is based on the :term:`decision_function` method of the\n`estimator` if it exists, else on :term:`predict_proba`.\n\nRead more in the :ref:`User Guide <calibration>`.\n",
    "attributes": [
      {
        "default": null,
        "description": "This parameter is deprecated. Use `estimator` instead.\n\n.. deprecated:: 1.2\nThe parameter `base_estimator` is deprecated in 1.2 and will be\nremoved in 1.4. Use `estimator` instead.\n",
        "name": "base_estimator"
      },
      {
        "default": "sigmoid",
        "description": "The method to use for calibration. Can be 'sigmoid' which\ncorresponds to Platt's method (i.e. a logistic regression model) or\n'isotonic' which is a non-parametric approach. It is not advised to\nuse isotonic calibration with too few calibration samples\n``(<<1000)`` since it tends to overfit.\n",
        "name": "method"
      },
      {
        "default": null,
        "description": "Determines the cross-validation splitting strategy.\nPossible inputs for cv are:\n\n- None, to use the default 5-fold cross-validation,\n- integer, to specify the number of folds.\n- :term:`CV splitter`,\n- An iterable yielding (train, test) splits as arrays of indices.\n\nFor integer/None inputs, if ``y`` is binary or multiclass,\n:class:`~sklearn.model_selection.StratifiedKFold` is used. If ``y`` is\nneither binary nor multiclass, :class:`~sklearn.model_selection.KFold`\nis used.\n\nRefer to the :ref:`User Guide <cross_validation>` for the various\ncross-validation strategies that can be used here.\n\nIf \"prefit\" is passed, it is assumed that `estimator` has been\nfitted already and all data is used for calibration.\n\n.. versionchanged:: 0.22\n``cv`` default value if None changed from 3-fold to 5-fold.\n",
        "name": "cv",
        "optional": true,
        "type": "int32"
      },
      {
        "default": null,
        "description": "Number of jobs to run in parallel.\n``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n``-1`` means using all processors.\n\nBase estimator clones are fitted in parallel across cross-validation\niterations. Therefore parallelism happens only when `cv != \"prefit\"`.\n\nSee :term:`Glossary <n_jobs>` for more details.\n\n.. versionadded:: 0.24\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": true,
        "description": "Determines how the calibrator is fitted when `cv` is not `'prefit'`.\nIgnored if `cv='prefit'`.\n\nIf `True`, the `estimator` is fitted using training data, and\ncalibrated using testing data, for each `cv` fold. The final estimator\nis an ensemble of `n_cv` fitted classifier and calibrator pairs, where\n`n_cv` is the number of cross-validation folds. The output is the\naverage predicted probabilities of all pairs.\n\nIf `False`, `cv` is used to compute unbiased predictions, via\n:func:`~sklearn.model_selection.cross_val_predict`, which are then\nused for calibration. At prediction time, the classifier used is the\n`estimator` trained on all the data.\nNote that this method is also internally implemented  in\n:mod:`sklearn.svm` estimators with the `probabilities=True` parameter.\n\n.. versionadded:: 0.24\n",
        "name": "ensemble",
        "type": "boolean"
      },
      {
        "name": "estimator",
        "description": "The classifier whose output need to be calibrated to provide more\naccurate `predict_proba` outputs. The default classifier is\na :class:`~sklearn.svm.LinearSVC`.\n\n.. versionadded:: 1.2\n",
        "default": null
      }
    ]
  },
  {
    "name": "sklearn.compose._column_transformer.ColumnTransformer",
    "description": "Applies transformers to columns of an array or pandas DataFrame.\n\nThis estimator allows different columns or column subsets of the input\nto be transformed separately and the features generated by each transformer\nwill be concatenated to form a single feature space.\nThis is useful for heterogeneous or columnar data, to combine several\nfeature extraction mechanisms or transformations into a single transformer.\n\nRead more in the :ref:`User Guide <column_transformer>`.\n\n.. versionadded:: 0.20\n",
    "attributes": [
      {
        "description": "List of (name, transformer, columns) tuples specifying the\ntransformer objects to be applied to subsets of the data.\n\nname : str\nLike in Pipeline and FeatureUnion, this allows the transformer and\nits parameters to be set using ``set_params`` and searched in grid\nsearch.\ntransformer : {'drop', 'passthrough'} or estimator\nEstimator must support :term:`fit` and :term:`transform`.\nSpecial-cased strings 'drop' and 'passthrough' are accepted as\nwell, to indicate to drop the columns or to pass them through\nuntransformed, respectively.\ncolumns :  str, array-like of str, int, array-like of int,                 array-like of bool, slice or callable\nIndexes the data on its second axis. Integers are interpreted as\npositional columns, while strings can reference DataFrame columns\nby name.  A scalar string or int should be used where\n``transformer`` expects X to be a 1d array-like (vector),\notherwise a 2d array will be passed to the transformer.\nA callable is passed the input data `X` and can return any of the\nabove. To select multiple columns by name or dtype, you can use\n:obj:`make_column_selector`.\n",
        "name": "transformers"
      },
      {
        "description": "By default, only the specified columns in `transformers` are\ntransformed and combined in the output, and the non-specified\ncolumns are dropped. (default of ``'drop'``).\nBy specifying ``remainder='passthrough'``, all remaining columns that\nwere not specified in `transformers`, but present in the data passed\nto `fit` will be automatically passed through. This subset of columns\nis concatenated with the output of the transformers. For dataframes,\nextra columns not seen during `fit` will be excluded from the output\nof `transform`.\nBy setting ``remainder`` to be an estimator, the remaining\nnon-specified columns will use the ``remainder`` estimator. The\nestimator must support :term:`fit` and :term:`transform`.\nNote that using this feature requires that the DataFrame columns\ninput at :term:`fit` and :term:`transform` have identical order.\n",
        "name": "remainder",
        "default": "drop"
      },
      {
        "default": 0.3,
        "description": "If the output of the different transformers contains sparse matrices,\nthese will be stacked as a sparse matrix if the overall density is\nlower than this value. Use ``sparse_threshold=0`` to always return\ndense.  When the transformed output consists of all dense data, the\nstacked result will be dense, and this keyword will be ignored.\n",
        "name": "sparse_threshold",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Number of jobs to run in parallel.\n``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n``-1`` means using all processors. See :term:`Glossary <n_jobs>`\nfor more details.\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Multiplicative weights for features per transformer. The output of the\ntransformer is multiplied by these weights. Keys are transformer names,\nvalues the weights.\n",
        "name": "transformer_weights"
      },
      {
        "default": false,
        "description": "If True, the time elapsed while fitting each transformer will be\nprinted as it is completed.\n",
        "name": "verbose",
        "type": "boolean"
      },
      {
        "name": "prefix_feature_names_out",
        "description": "If True, :meth:`get_feature_names_out` will prefix all feature names\nwith the name of the transformer that generated that feature.\nIf False, :meth:`get_feature_names_out` will not prefix any feature\nnames and will error if feature names are not unique.\n\n.. versionadded:: 1.0\n",
        "type": "boolean",
        "default": true
      },
      {
        "name": "verbose_feature_names_out",
        "description": "If True, :meth:`ColumnTransformer.get_feature_names_out` will prefix\nall feature names with the name of the transformer that generated that\nfeature.\nIf False, :meth:`ColumnTransformer.get_feature_names_out` will not\nprefix any feature names and will error if feature names are not\nunique.\n\n.. versionadded:: 1.0\n",
        "type": "boolean",
        "default": true
      },
      {
        "name": "force_int_remainder_cols",
        "default": true,
        "description": "Force the columns of the last entry of `transformers_`, which\ncorresponds to the \"remainder\" transformer, to always be stored as\nindices (int) rather than column names (str). See description of the\n`transformers_` attribute for details.\n\n.. note::\nIf you do not access the list of columns for the remainder columns\nin the `transformers_` fitted attribute, you do not need to set\nthis parameter.\n\n.. versionadded:: 1.5\n\n.. versionchanged:: 1.7\nThe default value for `force_int_remainder_cols` will change from\n`True` to `False` in version 1.7.\n"
      }
    ]
  },
  {
    "name": "sklearn.decomposition._pca.PCA",
    "description": "Principal component analysis (PCA).\n\nLinear dimensionality reduction using Singular Value Decomposition of the\ndata to project it to a lower dimensional space. The input data is centered\nbut not scaled for each feature before applying the SVD.\n\nIt uses the LAPACK implementation of the full SVD or a randomized truncated\nSVD by the method of Halko et al. 2009, depending on the shape of the input\ndata and the number of components to extract.\n\nWith sparse inputs, the ARPACK implementation of the truncated SVD can be\nused (i.e. through :func:`scipy.sparse.linalg.svds`). Alternatively, one\nmay consider :class:`TruncatedSVD` where the data are not centered.\n\nNotice that this class only supports sparse inputs for some solvers such as\n\"arpack\" and \"covariance_eigh\". See :class:`TruncatedSVD` for an\nalternative with sparse data.\n\nFor a usage example, see\n:ref:`sphx_glr_auto_examples_decomposition_plot_pca_iris.py`\n\nRead more in the :ref:`User Guide <PCA>`.\n",
    "attributes": [
      {
        "default": null,
        "description": "Number of components to keep.\nif n_components is not set all components are kept::\n\nn_components == min(n_samples, n_features)\n\nIf ``n_components == 'mle'`` and ``svd_solver == 'full'``, Minka's\nMLE is used to guess the dimension. Use of ``n_components == 'mle'``\nwill interpret ``svd_solver == 'auto'`` as ``svd_solver == 'full'``.\n\nIf ``0 < n_components < 1`` and ``svd_solver == 'full'``, select the\nnumber of components such that the amount of variance that needs to be\nexplained is greater than the percentage specified by n_components.\n\nIf ``svd_solver == 'arpack'``, the number of components must be\nstrictly less than the minimum of n_features and n_samples.\n\nHence, the None case results in::\n\nn_components == min(n_samples, n_features) - 1\n",
        "name": "n_components",
        "type": "int32"
      },
      {
        "default": true,
        "description": "If False, data passed to fit are overwritten and running\nfit(X).transform(X) will not yield the expected results,\nuse fit_transform(X) instead.\n",
        "name": "copy",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "When True (False by default) the `components_` vectors are multiplied\nby the square root of n_samples and then divided by the singular values\nto ensure uncorrelated outputs with unit component-wise variances.\n\nWhitening will remove some information from the transformed signal\n(the relative variance scales of the components) but can sometime\nimprove the predictive accuracy of the downstream estimators by\nmaking their data respect some hard-wired assumptions.\n",
        "name": "whiten",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": "auto",
        "description": "\"auto\" :\nThe solver is selected by a default 'auto' policy is based on `X.shape` and\n`n_components`: if the input data has fewer than 1000 features and\nmore than 10 times as many samples, then the \"covariance_eigh\"\nsolver is used. Otherwise, if the input data is larger than 500x500\nand the number of components to extract is lower than 80% of the\nsmallest dimension of the data, then the more efficient\n\"randomized\" method is selected. Otherwise the exact \"full\" SVD is\ncomputed and optionally truncated afterwards.\n\"full\" :\nRun exact full SVD calling the standard LAPACK solver via\n`scipy.linalg.svd` and select the components by postprocessing\n\"covariance_eigh\" :\nPrecompute the covariance matrix (on centered data), run a\nclassical eigenvalue decomposition on the covariance matrix\ntypically using LAPACK and select the components by postprocessing.\nThis solver is very efficient for n_samples >> n_features and small\nn_features. It is, however, not tractable otherwise for large\nn_features (large memory footprint required to materialize the\ncovariance matrix). Also note that compared to the \"full\" solver,\nthis solver effectively doubles the condition number and is\ntherefore less numerical stable (e.g. on input data with a large\nrange of singular values).\n\"arpack\" :\nRun SVD truncated to `n_components` calling ARPACK solver via\n`scipy.sparse.linalg.svds`. It requires strictly\n`0 < n_components < min(X.shape)`\n\"randomized\" :\nRun randomized SVD by the method of Halko et al.\n\n.. versionadded:: 0.18.0\n\n.. versionchanged:: 1.5\nAdded the 'covariance_eigh' solver.\n",
        "name": "svd_solver"
      },
      {
        "default": 0.0,
        "description": "Tolerance for singular values computed by svd_solver == 'arpack'.\nMust be of range [0.0, infinity).\n\n.. versionadded:: 0.18.0\n",
        "name": "tol",
        "optional": true,
        "type": "float32"
      },
      {
        "default": "auto",
        "description": "Number of iterations for the power method computed by\nsvd_solver == 'randomized'.\nMust be of range [0, infinity).\n\n.. versionadded:: 0.18.0\n",
        "name": "iterated_power"
      },
      {
        "default": null,
        "description": "Used when the 'arpack' or 'randomized' solvers are used. Pass an int\nfor reproducible results across multiple function calls.\nSee :term:`Glossary <random_state>`.\n\n.. versionadded:: 0.18.0\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "name": "n_oversamples",
        "description": "This parameter is only relevant when `svd_solver=\"randomized\"`.\nIt corresponds to the additional number of random vectors to sample the\nrange of `X` so as to ensure proper conditioning. See\n:func:`~sklearn.utils.extmath.randomized_svd` for more details.\n\n.. versionadded:: 1.1\n",
        "type": "int32",
        "default": 10
      },
      {
        "name": "power_iteration_normalizer",
        "description": "Power iteration normalizer for randomized SVD solver.\nNot used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`\nfor more details.\n\n.. versionadded:: 1.1\n",
        "default": "auto"
      }
    ]
  },
  {
    "name": "sklearn.decomposition._truncated_svd.TruncatedSVD",
    "description": "Dimensionality reduction using truncated SVD (aka LSA).\n\nThis transformer performs linear dimensionality reduction by means of\ntruncated singular value decomposition (SVD). Contrary to PCA, this\nestimator does not center the data before computing the singular value\ndecomposition. This means it can work with sparse matrices\nefficiently.\n\nIn particular, truncated SVD works on term count/tf-idf matrices as\nreturned by the vectorizers in :mod:`sklearn.feature_extraction.text`. In\nthat context, it is known as latent semantic analysis (LSA).\n\nThis estimator supports two algorithms: a fast randomized SVD solver, and\na \"naive\" algorithm that uses ARPACK as an eigensolver on `X * X.T` or\n`X.T * X`, whichever is more efficient.\n\nRead more in the :ref:`User Guide <LSA>`.\n",
    "attributes": [
      {
        "default": 2,
        "description": "Desired dimensionality of output data.\nIf algorithm='arpack', must be strictly less than the number of features.\nIf algorithm='randomized', must be less than or equal to the number of features.\nThe default value is useful for visualisation. For LSA, a value of\n100 is recommended.\n",
        "name": "n_components",
        "type": "int32"
      },
      {
        "default": "randomized",
        "description": "SVD solver to use. Either \"arpack\" for the ARPACK wrapper in SciPy\n(scipy.sparse.linalg.svds), or \"randomized\" for the randomized\nalgorithm due to Halko (2009).\n",
        "name": "algorithm",
        "type": "string"
      },
      {
        "default": 5,
        "description": "Number of iterations for randomized SVD solver. Not used by ARPACK. The\ndefault is larger than the default in\n:func:`~sklearn.utils.extmath.randomized_svd` to handle sparse\nmatrices that may have large slowly decaying spectrum.\n",
        "name": "n_iter",
        "optional": true,
        "type": "int32"
      },
      {
        "default": null,
        "description": "Used during randomized svd. Pass an int for reproducible results across\nmultiple function calls.\nSee :term:`Glossary <random_state>`.\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "default": 0.0,
        "description": "Tolerance for ARPACK. 0 means machine precision. Ignored by randomized\nSVD solver.\n",
        "name": "tol",
        "optional": true,
        "type": "float32"
      },
      {
        "name": "n_oversamples",
        "description": "Number of oversamples for randomized SVD solver. Not used by ARPACK.\nSee :func:`~sklearn.utils.extmath.randomized_svd` for a complete\ndescription.\n\n.. versionadded:: 1.1\n",
        "type": "int32",
        "default": 10
      },
      {
        "name": "power_iteration_normalizer",
        "description": "Power iteration normalizer for randomized SVD solver.\nNot used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`\nfor more details.\n\n.. versionadded:: 1.1\n",
        "default": "auto"
      }
    ]
  },
  {
    "name": "sklearn.decomposition.PCA",
    "description": "Principal component analysis (PCA).\n\nLinear dimensionality reduction using Singular Value Decomposition of the\ndata to project it to a lower dimensional space. The input data is centered\nbut not scaled for each feature before applying the SVD.\n\nIt uses the LAPACK implementation of the full SVD or a randomized truncated\nSVD by the method of Halko et al. 2009, depending on the shape of the input\ndata and the number of components to extract.\n\nWith sparse inputs, the ARPACK implementation of the truncated SVD can be\nused (i.e. through :func:`scipy.sparse.linalg.svds`). Alternatively, one\nmay consider :class:`TruncatedSVD` where the data are not centered.\n\nNotice that this class only supports sparse inputs for some solvers such as\n\"arpack\" and \"covariance_eigh\". See :class:`TruncatedSVD` for an\nalternative with sparse data.\n\nFor a usage example, see\n:ref:`sphx_glr_auto_examples_decomposition_plot_pca_iris.py`\n\nRead more in the :ref:`User Guide <PCA>`.\n",
    "attributes": [
      {
        "default": null,
        "description": "Number of components to keep.\nif n_components is not set all components are kept::\n\nn_components == min(n_samples, n_features)\n\nIf ``n_components == 'mle'`` and ``svd_solver == 'full'``, Minka's\nMLE is used to guess the dimension. Use of ``n_components == 'mle'``\nwill interpret ``svd_solver == 'auto'`` as ``svd_solver == 'full'``.\n\nIf ``0 < n_components < 1`` and ``svd_solver == 'full'``, select the\nnumber of components such that the amount of variance that needs to be\nexplained is greater than the percentage specified by n_components.\n\nIf ``svd_solver == 'arpack'``, the number of components must be\nstrictly less than the minimum of n_features and n_samples.\n\nHence, the None case results in::\n\nn_components == min(n_samples, n_features) - 1\n",
        "name": "n_components",
        "type": "int32"
      },
      {
        "default": true,
        "description": "If False, data passed to fit are overwritten and running\nfit(X).transform(X) will not yield the expected results,\nuse fit_transform(X) instead.\n",
        "name": "copy",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "When True (False by default) the `components_` vectors are multiplied\nby the square root of n_samples and then divided by the singular values\nto ensure uncorrelated outputs with unit component-wise variances.\n\nWhitening will remove some information from the transformed signal\n(the relative variance scales of the components) but can sometime\nimprove the predictive accuracy of the downstream estimators by\nmaking their data respect some hard-wired assumptions.\n",
        "name": "whiten",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": "auto",
        "description": "\"auto\" :\nThe solver is selected by a default 'auto' policy is based on `X.shape` and\n`n_components`: if the input data has fewer than 1000 features and\nmore than 10 times as many samples, then the \"covariance_eigh\"\nsolver is used. Otherwise, if the input data is larger than 500x500\nand the number of components to extract is lower than 80% of the\nsmallest dimension of the data, then the more efficient\n\"randomized\" method is selected. Otherwise the exact \"full\" SVD is\ncomputed and optionally truncated afterwards.\n\"full\" :\nRun exact full SVD calling the standard LAPACK solver via\n`scipy.linalg.svd` and select the components by postprocessing\n\"covariance_eigh\" :\nPrecompute the covariance matrix (on centered data), run a\nclassical eigenvalue decomposition on the covariance matrix\ntypically using LAPACK and select the components by postprocessing.\nThis solver is very efficient for n_samples >> n_features and small\nn_features. It is, however, not tractable otherwise for large\nn_features (large memory footprint required to materialize the\ncovariance matrix). Also note that compared to the \"full\" solver,\nthis solver effectively doubles the condition number and is\ntherefore less numerical stable (e.g. on input data with a large\nrange of singular values).\n\"arpack\" :\nRun SVD truncated to `n_components` calling ARPACK solver via\n`scipy.sparse.linalg.svds`. It requires strictly\n`0 < n_components < min(X.shape)`\n\"randomized\" :\nRun randomized SVD by the method of Halko et al.\n\n.. versionadded:: 0.18.0\n\n.. versionchanged:: 1.5\nAdded the 'covariance_eigh' solver.\n",
        "name": "svd_solver",
        "type": "string"
      },
      {
        "default": 0.0,
        "description": "Tolerance for singular values computed by svd_solver == 'arpack'.\nMust be of range [0.0, infinity).\n\n.. versionadded:: 0.18.0\n",
        "name": "tol",
        "optional": true,
        "type": "float32"
      },
      {
        "default": "auto",
        "description": "Number of iterations for the power method computed by\nsvd_solver == 'randomized'.\nMust be of range [0, infinity).\n\n.. versionadded:: 0.18.0\n",
        "name": "iterated_power"
      },
      {
        "default": null,
        "description": "Used when the 'arpack' or 'randomized' solvers are used. Pass an int\nfor reproducible results across multiple function calls.\nSee :term:`Glossary <random_state>`.\n\n.. versionadded:: 0.18.0\n",
        "name": "random_state",
        "optional": true,
        "type": "int32"
      },
      {
        "name": "n_oversamples",
        "description": "This parameter is only relevant when `svd_solver=\"randomized\"`.\nIt corresponds to the additional number of random vectors to sample the\nrange of `X` so as to ensure proper conditioning. See\n:func:`~sklearn.utils.extmath.randomized_svd` for more details.\n\n.. versionadded:: 1.1\n",
        "type": "int32",
        "default": 10
      },
      {
        "name": "power_iteration_normalizer",
        "description": "Power iteration normalizer for randomized SVD solver.\nNot used by ARPACK. See :func:`~sklearn.utils.extmath.randomized_svd`\nfor more details.\n\n.. versionadded:: 1.1\n",
        "default": "auto"
      }
    ]
  },
  {
    "name": "sklearn.discriminant_analysis.LinearDiscriminantAnalysis",
    "description": "Linear Discriminant Analysis.\n\nA classifier with a linear decision boundary, generated by fitting class\nconditional densities to the data and using Bayes' rule.\n\nThe model fits a Gaussian density to each class, assuming that all classes\nshare the same covariance matrix.\n\nThe fitted model can also be used to reduce the dimensionality of the input\nby projecting it to the most discriminative directions, using the\n`transform` method.\n\n.. versionadded:: 0.17\n\nFor a comparison between\n:class:`~sklearn.discriminant_analysis.LinearDiscriminantAnalysis`\nand :class:`~sklearn.discriminant_analysis.QuadraticDiscriminantAnalysis`, see\n:ref:`sphx_glr_auto_examples_classification_plot_lda_qda.py`.\n\nRead more in the :ref:`User Guide <lda_qda>`.\n",
    "attributes": [
      {
        "default": "svd",
        "description": "Solver to use, possible values:\n- 'svd': Singular value decomposition (default).\nDoes not compute the covariance matrix, therefore this solver is\nrecommended for data with a large number of features.\n- 'lsqr': Least squares solution.\nCan be combined with shrinkage or custom covariance estimator.\n- 'eigen': Eigenvalue decomposition.\nCan be combined with shrinkage or custom covariance estimator.\n\n.. versionchanged:: 1.2\n`solver=\"svd\"` now has experimental Array API support. See the\n:ref:`Array API User Guide <array_api>` for more details.\n",
        "name": "solver"
      },
      {
        "description": "Shrinkage parameter, possible values:\n- None: no shrinkage (default).\n- 'auto': automatic shrinkage using the Ledoit-Wolf lemma.\n- float between 0 and 1: fixed shrinkage parameter.\n\nThis should be left to None if `covariance_estimator` is used.\nNote that shrinkage works only with 'lsqr' and 'eigen' solvers.\n\nFor a usage example, see\n:ref:`sphx_glr_auto_examples_classification_plot_lda.py`.\n",
        "name": "shrinkage",
        "default": null
      },
      {
        "default": null,
        "description": "The class prior probabilities. By default, the class proportions are\ninferred from the training data.\n",
        "name": "priors"
      },
      {
        "default": null,
        "description": "Number of components (<= min(n_classes - 1, n_features)) for\ndimensionality reduction. If None, will be set to\nmin(n_classes - 1, n_features). This parameter only affects the\n`transform` method.\n\nFor a usage example, see\n:ref:`sphx_glr_auto_examples_decomposition_plot_pca_vs_lda.py`.\n",
        "name": "n_components",
        "type": "int32"
      },
      {
        "default": false,
        "description": "If True, explicitly compute the weighted within-class covariance\nmatrix when solver is 'svd'. The matrix is always computed\nand stored for the other solvers.\n\n.. versionadded:: 0.17\n",
        "name": "store_covariance",
        "type": "boolean"
      },
      {
        "default": 0.0001,
        "description": "Absolute threshold for a singular value of X to be considered\nsignificant, used to estimate the rank of X. Dimensions whose\nsingular values are non-significant are discarded. Only used if\nsolver is 'svd'.\n\n.. versionadded:: 0.17\n",
        "name": "tol",
        "type": "float32"
      },
      {
        "default": null,
        "description": "If not None, `covariance_estimator` is used to estimate\nthe covariance matrices instead of relying on the empirical\ncovariance estimator (with potential shrinkage).\nThe object should have a fit method and a ``covariance_`` attribute\nlike the estimators in :mod:`sklearn.covariance`.\nif None the shrinkage parameter drives the estimate.\n\nThis should be left to None if `shrinkage` is used.\nNote that `covariance_estimator` works only with 'lsqr' and 'eigen'\nsolvers.\n\n.. versionadded:: 0.24\n",
        "name": "covariance_estimator"
      }
    ]
  },
  {
    "name": "sklearn.ensemble.forest.ExtraTreesClassifier",
    "description": "\nAn extra-trees classifier.\n\nThis class implements a meta estimator that fits a number of\nrandomized decision trees (a.k.a. extra-trees) on various sub-samples\nof the dataset and uses averaging to improve the predictive accuracy\nand control over-fitting.\n\nRead more in the :ref:`User Guide <forest>`.\n",
    "attributes": [
      {
        "default": 100,
        "description": "The number of trees in the forest.\n\n.. versionchanged:: 0.22\nThe default value of ``n_estimators`` changed from 10 to 100\nin 0.22.\n",
        "name": "n_estimators",
        "type": "int32"
      },
      {
        "default": "\"gini\"",
        "description": "The function to measure the quality of a split. Supported criteria are\n\"gini\" for the Gini impurity and \"entropy\" for the information gain.\n",
        "name": "criterion"
      },
      {
        "default": null,
        "description": "The maximum depth of the tree. If None, then nodes are expanded until\nall leaves are pure or until all leaves contain less than\nmin_samples_split samples.\n",
        "name": "max_depth",
        "type": "int32"
      },
      {
        "default": "2",
        "description": "The minimum number of samples required to split an internal node:\n\n- If int, then consider `min_samples_split` as the minimum number.\n- If float, then `min_samples_split` is a fraction and\n`ceil(min_samples_split * n_samples)` are the minimum\nnumber of samples for each split.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_split"
      },
      {
        "default": "1",
        "description": "The minimum number of samples required to be at a leaf node.\nA split point at any depth will only be considered if it leaves at\nleast ``min_samples_leaf`` training samples in each of the left and\nright branches.  This may have the effect of smoothing the model,\nespecially in regression.\n\n- If int, then consider `min_samples_leaf` as the minimum number.\n- If float, then `min_samples_leaf` is a fraction and\n`ceil(min_samples_leaf * n_samples)` are the minimum\nnumber of samples for each node.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_leaf"
      },
      {
        "default": 0,
        "description": "The minimum weighted fraction of the sum total of weights (of all\nthe input samples) required to be at a leaf node. Samples have\nequal weight when sample_weight is not provided.\n",
        "name": "min_weight_fraction_leaf",
        "type": "float32"
      },
      {
        "default": "\"auto\"",
        "description": "The number of features to consider when looking for the best split:\n\n- If int, then consider `max_features` features at each split.\n- If float, then `max_features` is a fraction and\n`int(max_features * n_features)` features are considered at each\nsplit.\n- If \"auto\", then `max_features=sqrt(n_features)`.\n- If \"sqrt\", then `max_features=sqrt(n_features)`.\n- If \"log2\", then `max_features=log2(n_features)`.\n- If None, then `max_features=n_features`.\n\nNote: the search for a split does not stop until at least one\nvalid partition of the node samples is found, even if it requires to\neffectively inspect more than ``max_features`` features.\n",
        "name": "max_features"
      },
      {
        "default": null,
        "description": "Grow trees with ``max_leaf_nodes`` in best-first fashion.\nBest nodes are defined as relative reduction in impurity.\nIf None then unlimited number of leaf nodes.\n",
        "name": "max_leaf_nodes",
        "type": "int32"
      },
      {
        "default": 0,
        "description": "A node will be split if this split induces a decrease of the impurity\ngreater than or equal to this value.\n\nThe weighted impurity decrease equation is the following::\n\nN_t / N * (impurity - N_t_R / N_t * right_impurity\n- N_t_L / N_t * left_impurity)\n\nwhere ``N`` is the total number of samples, ``N_t`` is the number of\nsamples at the current node, ``N_t_L`` is the number of samples in the\nleft child, and ``N_t_R`` is the number of samples in the right child.\n\n``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,\nif ``sample_weight`` is passed.\n\n.. versionadded:: 0.19\n",
        "name": "min_impurity_decrease",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Threshold for early stopping in tree growth. A node will split\nif its impurity is above the threshold, otherwise it is a leaf.\n\n.. deprecated:: 0.19\n``min_impurity_split`` has been deprecated in favor of\n``min_impurity_decrease`` in 0.19. The default value of\n``min_impurity_split`` has changed from 1e-7 to 0 in 0.23 and it\nwill be removed in 0.25. Use ``min_impurity_decrease`` instead.\n",
        "name": "min_impurity_split",
        "type": "float32"
      },
      {
        "default": false,
        "description": "Whether bootstrap samples are used when building trees. If False, the\nwhole dataset is used to build each tree.\n",
        "name": "bootstrap",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Whether to use out-of-bag samples to estimate\nthe generalization accuracy.\n",
        "name": "oob_score",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,\n:meth:`decision_path` and :meth:`apply` are all parallelized over the\ntrees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`\ncontext. ``-1`` means using all processors. See :term:`Glossary\n<n_jobs>` for more details.\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Controls 3 sources of randomness:\n\n- the bootstrapping of the samples used when building trees\n(if ``bootstrap=True``)\n- the sampling of the features to consider when looking for the best\nsplit at each node (if ``max_features < n_features``)\n- the draw of the splits for each of the `max_features`\n\nSee :term:`Glossary <random_state>` for details.\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "default": 0,
        "description": "Controls the verbosity when fitting and predicting.\n",
        "name": "verbose",
        "type": "int32"
      },
      {
        "default": false,
        "description": "When set to ``True``, reuse the solution of the previous call to fit\nand add more estimators to the ensemble, otherwise, just fit a whole\nnew forest. See :term:`the Glossary <warm_start>`.\n",
        "name": "warm_start",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Weights associated with classes in the form ``{class_label: weight}``.\nIf not given, all classes are supposed to have weight one. For\nmulti-output problems, a list of dicts can be provided in the same\norder as the columns of y.\n\nNote that for multioutput (including multilabel) weights should be\ndefined for each class of every column in its own dict. For example,\nfor four-class multilabel classification weights should be\n[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of\n[{1:1}, {2:5}, {3:1}, {4:1}].\n\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``\n\nThe \"balanced_subsample\" mode is the same as \"balanced\" except that\nweights are computed based on the bootstrap sample for every tree\ngrown.\n\nFor multi-output, the weights of each column of y will be multiplied.\n\nNote that these weights will be multiplied with sample_weight (passed\nthrough the fit method) if sample_weight is specified.\n",
        "name": "class_weight"
      },
      {
        "default": "0.0",
        "description": "Complexity parameter used for Minimal Cost-Complexity Pruning. The\nsubtree with the largest cost complexity that is smaller than\n``ccp_alpha`` will be chosen. By default, no pruning is performed. See\n:ref:`minimal_cost_complexity_pruning` for details.\n\n.. versionadded:: 0.22\n",
        "name": "ccp_alpha"
      },
      {
        "default": null,
        "description": "If bootstrap is True, the number of samples to draw from X\nto train each base estimator.\n\n- If None (default), then draw `X.shape[0]` samples.\n- If int, then draw `max_samples` samples.\n- If float, then draw `max_samples * X.shape[0]` samples. Thus,\n`max_samples` should be in the interval `(0, 1)`.\n\n.. versionadded:: 0.22\n",
        "name": "max_samples"
      }
    ]
  },
  {
    "name": "sklearn.ensemble.forest.RandomForestClassifier",
    "description": "\nA random forest classifier.\n\nA random forest is a meta estimator that fits a number of decision tree\nclassifiers on various sub-samples of the dataset and uses averaging to\nimprove the predictive accuracy and control over-fitting.\nThe sub-sample size is controlled with the `max_samples` parameter if\n`bootstrap=True` (default), otherwise the whole dataset is used to build\neach tree.\n\nRead more in the :ref:`User Guide <forest>`.\n",
    "attributes": [
      {
        "default": 100,
        "description": "The number of trees in the forest.\n\n.. versionchanged:: 0.22\nThe default value of ``n_estimators`` changed from 10 to 100\nin 0.22.\n",
        "name": "n_estimators",
        "type": "int32"
      },
      {
        "default": "\"gini\"",
        "description": "The function to measure the quality of a split. Supported criteria are\n\"gini\" for the Gini impurity and \"entropy\" for the information gain.\nNote: this parameter is tree-specific.\n",
        "name": "criterion"
      },
      {
        "default": null,
        "description": "The maximum depth of the tree. If None, then nodes are expanded until\nall leaves are pure or until all leaves contain less than\nmin_samples_split samples.\n",
        "name": "max_depth",
        "type": "int32"
      },
      {
        "default": "2",
        "description": "The minimum number of samples required to split an internal node:\n\n- If int, then consider `min_samples_split` as the minimum number.\n- If float, then `min_samples_split` is a fraction and\n`ceil(min_samples_split * n_samples)` are the minimum\nnumber of samples for each split.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_split"
      },
      {
        "default": "1",
        "description": "The minimum number of samples required to be at a leaf node.\nA split point at any depth will only be considered if it leaves at\nleast ``min_samples_leaf`` training samples in each of the left and\nright branches.  This may have the effect of smoothing the model,\nespecially in regression.\n\n- If int, then consider `min_samples_leaf` as the minimum number.\n- If float, then `min_samples_leaf` is a fraction and\n`ceil(min_samples_leaf * n_samples)` are the minimum\nnumber of samples for each node.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_leaf"
      },
      {
        "default": 0,
        "description": "The minimum weighted fraction of the sum total of weights (of all\nthe input samples) required to be at a leaf node. Samples have\nequal weight when sample_weight is not provided.\n",
        "name": "min_weight_fraction_leaf",
        "type": "float32"
      },
      {
        "default": "\"auto\"",
        "description": "The number of features to consider when looking for the best split:\n\n- If int, then consider `max_features` features at each split.\n- If float, then `max_features` is a fraction and\n`int(max_features * n_features)` features are considered at each\nsplit.\n- If \"auto\", then `max_features=sqrt(n_features)`.\n- If \"sqrt\", then `max_features=sqrt(n_features)` (same as \"auto\").\n- If \"log2\", then `max_features=log2(n_features)`.\n- If None, then `max_features=n_features`.\n\nNote: the search for a split does not stop until at least one\nvalid partition of the node samples is found, even if it requires to\neffectively inspect more than ``max_features`` features.\n",
        "name": "max_features"
      },
      {
        "default": null,
        "description": "Grow trees with ``max_leaf_nodes`` in best-first fashion.\nBest nodes are defined as relative reduction in impurity.\nIf None then unlimited number of leaf nodes.\n",
        "name": "max_leaf_nodes",
        "type": "int32"
      },
      {
        "default": 0,
        "description": "A node will be split if this split induces a decrease of the impurity\ngreater than or equal to this value.\n\nThe weighted impurity decrease equation is the following::\n\nN_t / N * (impurity - N_t_R / N_t * right_impurity\n- N_t_L / N_t * left_impurity)\n\nwhere ``N`` is the total number of samples, ``N_t`` is the number of\nsamples at the current node, ``N_t_L`` is the number of samples in the\nleft child, and ``N_t_R`` is the number of samples in the right child.\n\n``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,\nif ``sample_weight`` is passed.\n\n.. versionadded:: 0.19\n",
        "name": "min_impurity_decrease",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Threshold for early stopping in tree growth. A node will split\nif its impurity is above the threshold, otherwise it is a leaf.\n\n.. deprecated:: 0.19\n``min_impurity_split`` has been deprecated in favor of\n``min_impurity_decrease`` in 0.19. The default value of\n``min_impurity_split`` has changed from 1e-7 to 0 in 0.23 and it\nwill be removed in 0.25. Use ``min_impurity_decrease`` instead.\n\n",
        "name": "min_impurity_split",
        "type": "float32"
      },
      {
        "default": true,
        "description": "Whether bootstrap samples are used when building trees. If False, the\nwhole dataset is used to build each tree.\n",
        "name": "bootstrap",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Whether to use out-of-bag samples to estimate\nthe generalization accuracy.\n",
        "name": "oob_score",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`,\n:meth:`decision_path` and :meth:`apply` are all parallelized over the\ntrees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`\ncontext. ``-1`` means using all processors. See :term:`Glossary\n<n_jobs>` for more details.\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Controls both the randomness of the bootstrapping of the samples used\nwhen building trees (if ``bootstrap=True``) and the sampling of the\nfeatures to consider when looking for the best split at each node\n(if ``max_features < n_features``).\nSee :term:`Glossary <random_state>` for details.\n",
        "name": "random_state"
      },
      {
        "default": 0,
        "description": "Controls the verbosity when fitting and predicting.\n",
        "name": "verbose",
        "type": "int32"
      },
      {
        "default": false,
        "description": "When set to ``True``, reuse the solution of the previous call to fit\nand add more estimators to the ensemble, otherwise, just fit a whole\nnew forest. See :term:`the Glossary <warm_start>`.\n",
        "name": "warm_start",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Weights associated with classes in the form ``{class_label: weight}``.\nIf not given, all classes are supposed to have weight one. For\nmulti-output problems, a list of dicts can be provided in the same\norder as the columns of y.\n\nNote that for multioutput (including multilabel) weights should be\ndefined for each class of every column in its own dict. For example,\nfor four-class multilabel classification weights should be\n[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of\n[{1:1}, {2:5}, {3:1}, {4:1}].\n\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``\n\nThe \"balanced_subsample\" mode is the same as \"balanced\" except that\nweights are computed based on the bootstrap sample for every tree\ngrown.\n\nFor multi-output, the weights of each column of y will be multiplied.\n\nNote that these weights will be multiplied with sample_weight (passed\nthrough the fit method) if sample_weight is specified.\n",
        "name": "class_weight"
      },
      {
        "default": "0.0",
        "description": "Complexity parameter used for Minimal Cost-Complexity Pruning. The\nsubtree with the largest cost complexity that is smaller than\n``ccp_alpha`` will be chosen. By default, no pruning is performed. See\n:ref:`minimal_cost_complexity_pruning` for details.\n\n.. versionadded:: 0.22\n",
        "name": "ccp_alpha"
      },
      {
        "default": null,
        "description": "If bootstrap is True, the number of samples to draw from X\nto train each base estimator.\n\n- If None (default), then draw `X.shape[0]` samples.\n- If int, then draw `max_samples` samples.\n- If float, then draw `max_samples * X.shape[0]` samples. Thus,\n`max_samples` should be in the interval `(0, 1)`.\n\n.. versionadded:: 0.22\n",
        "name": "max_samples"
      }
    ]
  },
  {
    "name": "sklearn.ensemble.weight_boosting.AdaBoostClassifier",
    "description": "An AdaBoost classifier.\n\nAn AdaBoost [1] classifier is a meta-estimator that begins by fitting a\nclassifier on the original dataset and then fits additional copies of the\nclassifier on the same dataset but where the weights of incorrectly\nclassified instances are adjusted such that subsequent classifiers focus\nmore on difficult cases.\n\nThis class implements the algorithm known as AdaBoost-SAMME [2].\n\nRead more in the :ref:`User Guide <adaboost>`.\n\n.. versionadded:: 0.14\n",
    "attributes": [
      {
        "default": null,
        "description": "The base estimator from which the boosted ensemble is built.\nSupport for sample weighting is required, as well as proper\n``classes_`` and ``n_classes_`` attributes. If ``None``, then\nthe base estimator is ``DecisionTreeClassifier(max_depth=1)``.\n",
        "name": "base_estimator"
      },
      {
        "default": 50,
        "description": "The maximum number of estimators at which boosting is terminated.\nIn case of perfect fit, the learning procedure is stopped early.\n",
        "name": "n_estimators",
        "type": "int32"
      },
      {
        "default": 1,
        "description": "Learning rate shrinks the contribution of each classifier by\n``learning_rate``. There is a trade-off between ``learning_rate`` and\n``n_estimators``.\n",
        "name": "learning_rate",
        "type": "float32"
      },
      {
        "default": "SAMME.R",
        "description": "If 'SAMME.R' then use the SAMME.R real boosting algorithm.\n``base_estimator`` must support calculation of class probabilities.\nIf 'SAMME' then use the SAMME discrete boosting algorithm.\nThe SAMME.R algorithm typically converges faster than SAMME,\nachieving a lower test error with fewer boosting iterations.\n",
        "name": "algorithm"
      },
      {
        "default": null,
        "description": "Controls the random seed given at each `base_estimator` at each\nboosting iteration.\nThus, it is only used when `base_estimator` exposes a `random_state`.\nPass an int for reproducible output across multiple function calls.\nSee :term:`Glossary <random_state>`.\n",
        "name": "random_state"
      }
    ]
  },
  {
    "name": "sklearn.feature_extraction.text.CountVectorizer",
    "description": "Convert a collection of text documents to a matrix of token counts.\n\nThis implementation produces a sparse representation of the counts using\nscipy.sparse.csr_matrix.\n\nIf you do not provide an a-priori dictionary and you do not use an analyzer\nthat does some kind of feature selection then the number of features will\nbe equal to the vocabulary size found by analyzing the data.\n\nFor an efficiency comparison of the different feature extractors, see\n:ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.\n\nRead more in the :ref:`User Guide <text_feature_extraction>`.\n",
    "attributes": [
      {
        "default": "content",
        "description": "- If `'filename'`, the sequence passed as an argument to fit is\nexpected to be a list of filenames that need reading to fetch\nthe raw content to analyze.\n\n- If `'file'`, the sequence items must have a 'read' method (file-like\nobject) that is called to fetch the bytes in memory.\n\n- If `'content'`, the input is expected to be a sequence of items that\ncan be of type string or byte.\n",
        "name": "input",
        "type": "string"
      },
      {
        "default": "utf-8",
        "description": "If bytes or files are given to analyze, this encoding is used to\ndecode.\n",
        "name": "encoding",
        "type": "string"
      },
      {
        "default": "strict",
        "description": "Instruction on what to do if a byte sequence is given to analyze that\ncontains characters not of the given `encoding`. By default, it is\n'strict', meaning that a UnicodeDecodeError will be raised. Other\nvalues are 'ignore' and 'replace'.\n",
        "name": "decode_error"
      },
      {
        "default": null,
        "description": "Remove accents and perform other character normalization\nduring the preprocessing step.\n'ascii' is a fast method that only works on characters that have\na direct ASCII mapping.\n'unicode' is a slightly slower method that works on any characters.\nNone (default) means no character normalization is performed.\n\nBoth 'ascii' and 'unicode' use NFKD normalization from\n:func:`unicodedata.normalize`.\n",
        "name": "strip_accents"
      },
      {
        "default": true,
        "description": "Convert all characters to lowercase before tokenizing.\n",
        "name": "lowercase",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Override the preprocessing (strip_accents and lowercase) stage while\npreserving the tokenizing and n-grams generation steps.\nOnly applies if ``analyzer`` is not callable.\n",
        "name": "preprocessor"
      },
      {
        "default": null,
        "description": "Override the string tokenization step while preserving the\npreprocessing and n-grams generation steps.\nOnly applies if ``analyzer == 'word'``.\n",
        "name": "tokenizer"
      },
      {
        "default": null,
        "description": "If 'english', a built-in stop word list for English is used.\nThere are several known issues with 'english' and you should\nconsider an alternative (see :ref:`stop_words`).\n\nIf a list, that list is assumed to contain stop words, all of which\nwill be removed from the resulting tokens.\nOnly applies if ``analyzer == 'word'``.\n\nIf None, no stop words will be used. In this case, setting `max_df`\nto a higher value, such as in the range (0.7, 1.0), can automatically detect\nand filter stop words based on intra corpus document frequency of terms.\n",
        "name": "stop_words",
        "type": "string"
      },
      {
        "default": "r\"(?u)\\\\b\\\\w\\\\w+\\\\b\"",
        "description": "Regular expression denoting what constitutes a \"token\", only used\nif ``analyzer == 'word'``. The default regexp select tokens of 2\nor more alphanumeric characters (punctuation is completely ignored\nand always treated as a token separator).\n\nIf there is a capturing group in token_pattern then the\ncaptured group content, not the entire match, becomes the token.\nAt most one capturing group is permitted.\n",
        "name": "token_pattern",
        "type": "string"
      },
      {
        "default": "(1, 1)",
        "description": "The lower and upper boundary of the range of n-values for different\nword n-grams or char n-grams to be extracted. All values of n such\nsuch that min_n <= n <= max_n will be used. For example an\n``ngram_range`` of ``(1, 1)`` means only unigrams, ``(1, 2)`` means\nunigrams and bigrams, and ``(2, 2)`` means only bigrams.\nOnly applies if ``analyzer`` is not callable.\n",
        "name": "ngram_range"
      },
      {
        "default": "word",
        "description": "Whether the feature should be made of word n-gram or character\nn-grams.\nOption 'char_wb' creates character n-grams only from text inside\nword boundaries; n-grams at the edges of words are padded with space.\n\nIf a callable is passed it is used to extract the sequence of features\nout of the raw, unprocessed input.\n\n.. versionchanged:: 0.21\n\nSince v0.21, if ``input`` is ``filename`` or ``file``, the data is\nfirst read from the file and then passed to the given callable\nanalyzer.\n",
        "name": "analyzer",
        "type": "string"
      },
      {
        "default": "1.0",
        "description": "When building the vocabulary ignore terms that have a document\nfrequency strictly higher than the given threshold (corpus-specific\nstop words).\nIf float, the parameter represents a proportion of documents, integer\nabsolute counts.\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "max_df"
      },
      {
        "default": "1",
        "description": "When building the vocabulary ignore terms that have a document\nfrequency strictly lower than the given threshold. This value is also\ncalled cut-off in the literature.\nIf float, the parameter represents a proportion of documents, integer\nabsolute counts.\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "min_df"
      },
      {
        "default": null,
        "description": "If not None, build a vocabulary that only consider the top\n`max_features` ordered by term frequency across the corpus.\nOtherwise, all features are used.\n\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "max_features",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Either a Mapping (e.g., a dict) where keys are terms and values are\nindices in the feature matrix, or an iterable over terms. If not\ngiven, a vocabulary is determined from the input documents. Indices\nin the mapping should not be repeated and should not have any gap\nbetween 0 and the largest index.\n",
        "name": "vocabulary",
        "optional": true
      },
      {
        "default": false,
        "description": "If True, all non zero counts are set to 1. This is useful for discrete\nprobabilistic models that model binary events rather than integer\ncounts.\n",
        "name": "binary",
        "type": "boolean"
      },
      {
        "default": "np.int64",
        "description": "Type of the matrix returned by fit_transform() or transform().\n",
        "name": "dtype",
        "optional": true
      }
    ]
  },
  {
    "name": "sklearn.feature_extraction.text.TfidfVectorizer",
    "description": "Convert a collection of raw documents to a matrix of TF-IDF features.\n\nEquivalent to :class:`CountVectorizer` followed by\n:class:`TfidfTransformer`.\n\nFor an example of usage, see\n:ref:`sphx_glr_auto_examples_text_plot_document_classification_20newsgroups.py`.\n\nFor an efficiency comparison of the different feature extractors, see\n:ref:`sphx_glr_auto_examples_text_plot_hashing_vs_dict_vectorizer.py`.\n\nFor an example of document clustering and comparison with\n:class:`~sklearn.feature_extraction.text.HashingVectorizer`, see\n:ref:`sphx_glr_auto_examples_text_plot_document_clustering.py`.\n\nRead more in the :ref:`User Guide <text_feature_extraction>`.\n",
    "attributes": [
      {
        "default": "content",
        "description": "- If `'filename'`, the sequence passed as an argument to fit is\nexpected to be a list of filenames that need reading to fetch\nthe raw content to analyze.\n\n- If `'file'`, the sequence items must have a 'read' method (file-like\nobject) that is called to fetch the bytes in memory.\n\n- If `'content'`, the input is expected to be a sequence of items that\ncan be of type string or byte.\n",
        "name": "input",
        "type": "string"
      },
      {
        "default": "utf-8",
        "description": "If bytes or files are given to analyze, this encoding is used to\ndecode.\n",
        "name": "encoding",
        "type": "string"
      },
      {
        "default": "strict",
        "description": "Instruction on what to do if a byte sequence is given to analyze that\ncontains characters not of the given `encoding`. By default, it is\n'strict', meaning that a UnicodeDecodeError will be raised. Other\nvalues are 'ignore' and 'replace'.\n",
        "name": "decode_error"
      },
      {
        "default": null,
        "description": "Remove accents and perform other character normalization\nduring the preprocessing step.\n'ascii' is a fast method that only works on characters that have\na direct ASCII mapping.\n'unicode' is a slightly slower method that works on any characters.\nNone (default) means no character normalization is performed.\n\nBoth 'ascii' and 'unicode' use NFKD normalization from\n:func:`unicodedata.normalize`.\n",
        "name": "strip_accents"
      },
      {
        "default": true,
        "description": "Convert all characters to lowercase before tokenizing.\n",
        "name": "lowercase",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Override the preprocessing (string transformation) stage while\npreserving the tokenizing and n-grams generation steps.\nOnly applies if ``analyzer`` is not callable.\n",
        "name": "preprocessor"
      },
      {
        "default": null,
        "description": "Override the string tokenization step while preserving the\npreprocessing and n-grams generation steps.\nOnly applies if ``analyzer == 'word'``.\n",
        "name": "tokenizer"
      },
      {
        "description": "Whether the feature should be made of word or character n-grams.\nOption 'char_wb' creates character n-grams only from text inside\nword boundaries; n-grams at the edges of words are padded with space.\n\nIf a callable is passed it is used to extract the sequence of features\nout of the raw, unprocessed input.\n\n.. versionchanged:: 0.21\nSince v0.21, if ``input`` is ``'filename'`` or ``'file'``, the data\nis first read from the file and then passed to the given callable\nanalyzer.\n",
        "name": "analyzer",
        "default": "word"
      },
      {
        "default": null,
        "description": "If a string, it is passed to _check_stop_list and the appropriate stop\nlist is returned. 'english' is currently the only supported string\nvalue.\nThere are several known issues with 'english' and you should\nconsider an alternative (see :ref:`stop_words`).\n\nIf a list, that list is assumed to contain stop words, all of which\nwill be removed from the resulting tokens.\nOnly applies if ``analyzer == 'word'``.\n\nIf None, no stop words will be used. In this case, setting `max_df`\nto a higher value, such as in the range (0.7, 1.0), can automatically detect\nand filter stop words based on intra corpus document frequency of terms.\n",
        "name": "stop_words"
      },
      {
        "default": "r\"(?u)\\\\b\\\\w\\\\w+\\\\b",
        "description": "Regular expression denoting what constitutes a \"token\", only used\nif ``analyzer == 'word'``. The default regexp selects tokens of 2\nor more alphanumeric characters (punctuation is completely ignored\nand always treated as a token separator).\n\nIf there is a capturing group in token_pattern then the\ncaptured group content, not the entire match, becomes the token.\nAt most one capturing group is permitted.\n",
        "name": "token_pattern",
        "type": "string"
      },
      {
        "default": "(1, 1)",
        "description": "The lower and upper boundary of the range of n-values for different\nn-grams to be extracted. All values of n such that min_n <= n <= max_n\nwill be used. For example an ``ngram_range`` of ``(1, 1)`` means only\nunigrams, ``(1, 2)`` means unigrams and bigrams, and ``(2, 2)`` means\nonly bigrams.\nOnly applies if ``analyzer`` is not callable.\n",
        "name": "ngram_range"
      },
      {
        "default": "1.0",
        "description": "When building the vocabulary ignore terms that have a document\nfrequency strictly higher than the given threshold (corpus-specific\nstop words).\nIf float in range [0.0, 1.0], the parameter represents a proportion of\ndocuments, integer absolute counts.\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "max_df"
      },
      {
        "default": "1",
        "description": "When building the vocabulary ignore terms that have a document\nfrequency strictly lower than the given threshold. This value is also\ncalled cut-off in the literature.\nIf float in range of [0.0, 1.0], the parameter represents a proportion\nof documents, integer absolute counts.\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "min_df"
      },
      {
        "default": null,
        "description": "If not None, build a vocabulary that only consider the top\n`max_features` ordered by term frequency across the corpus.\nOtherwise, all features are used.\n\nThis parameter is ignored if vocabulary is not None.\n",
        "name": "max_features",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Either a Mapping (e.g., a dict) where keys are terms and values are\nindices in the feature matrix, or an iterable over terms. If not\ngiven, a vocabulary is determined from the input documents.\n",
        "name": "vocabulary",
        "optional": true
      },
      {
        "default": false,
        "description": "If True, all non-zero term counts are set to 1. This does not mean\noutputs will have only 0/1 values, only that the tf term in tf-idf\nis binary. (Set `binary` to True, `use_idf` to False and\n`norm` to None to get 0/1 outputs).\n",
        "name": "binary",
        "type": "boolean"
      },
      {
        "default": "float64",
        "description": "Type of the matrix returned by fit_transform() or transform().\n",
        "name": "dtype",
        "optional": true
      },
      {
        "default": "l2",
        "description": "Each output row will have unit norm, either:\n\n- 'l2': Sum of squares of vector elements is 1. The cosine\nsimilarity between two vectors is their dot product when l2 norm has\nbeen applied.\n- 'l1': Sum of absolute values of vector elements is 1.\nSee :func:`~sklearn.preprocessing.normalize`.\n- None: No normalization.\n",
        "name": "norm"
      },
      {
        "default": true,
        "description": "Enable inverse-document-frequency reweighting. If False, idf(t) = 1.\n",
        "name": "use_idf",
        "type": "boolean"
      },
      {
        "default": true,
        "description": "Smooth idf weights by adding one to document frequencies, as if an\nextra document was seen containing every term in the collection\nexactly once. Prevents zero divisions.\n",
        "name": "smooth_idf",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Apply sublinear tf scaling, i.e. replace tf with 1 + log(tf).\n",
        "name": "sublinear_tf",
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.feature_selection._univariate_selection.SelectKBest",
    "description": "Select features according to the k highest scores.\n\nRead more in the :ref:`User Guide <univariate_feature_selection>`.\n",
    "attributes": [
      {
        "default": "f_classif",
        "description": "Function taking two arrays X and y, and returning a pair of arrays\n(scores, pvalues) or a single array with scores.\nDefault is f_classif (see below \"See Also\"). The default function only\nworks with classification tasks.\n\n.. versionadded:: 0.18\n",
        "name": "score_func"
      },
      {
        "default": "10",
        "description": "Number of top features to select.\nThe \"all\" option bypasses selection, for use in a parameter search.\n",
        "name": "k",
        "optional": true
      }
    ]
  },
  {
    "name": "sklearn.impute._base.SimpleImputer",
    "description": "Univariate imputer for completing missing values with simple strategies.\n\nReplace missing values using a descriptive statistic (e.g. mean, median, or\nmost frequent) along each column, or using a constant value.\n\nRead more in the :ref:`User Guide <impute>`.\n\n.. versionadded:: 0.20\n`SimpleImputer` replaces the previous `sklearn.preprocessing.Imputer`\nestimator which is now removed.\n",
    "attributes": [
      {
        "description": "The placeholder for the missing values. All occurrences of\n`missing_values` will be imputed. For pandas' dataframes with\nnullable integer dtypes with missing values, `missing_values`\ncan be set to either `np.nan` or `pd.NA`.\n",
        "name": "missing_values",
        "default": "np.nan"
      },
      {
        "default": "mean",
        "description": "The imputation strategy.\n\n- If \"mean\", then replace missing values using the mean along\neach column. Can only be used with numeric data.\n- If \"median\", then replace missing values using the median along\neach column. Can only be used with numeric data.\n- If \"most_frequent\", then replace missing using the most frequent\nvalue along each column. Can be used with strings or numeric data.\nIf there is more than one such value, only the smallest is returned.\n- If \"constant\", then replace missing values with fill_value. Can be\nused with strings or numeric data.\n- If an instance of Callable, then replace missing values using the\nscalar statistic returned by running the callable over a dense 1d\narray containing non-missing values of each column.\n\n.. versionadded:: 0.20\nstrategy=\"constant\" for fixed value imputation.\n\n.. versionadded:: 1.5\nstrategy=callable for custom value imputation.\n",
        "name": "strategy",
        "type": "string"
      },
      {
        "default": null,
        "description": "When strategy == \"constant\", `fill_value` is used to replace all\noccurrences of missing_values. For string or object data types,\n`fill_value` must be a string.\nIf `None`, `fill_value` will be 0 when imputing numerical\ndata and \"missing_value\" for strings or object data types.\n",
        "name": "fill_value"
      },
      {
        "default": 0,
        "description": "Controls the verbosity of the imputer.\n\n.. deprecated:: 1.1\nThe 'verbose' parameter was deprecated in version 1.1 and will be\nremoved in 1.3. A warning will always be raised upon the removal of\nempty columns in the future version.\n",
        "name": "verbose",
        "type": "int32"
      },
      {
        "default": true,
        "description": "If True, a copy of X will be created. If False, imputation will\nbe done in-place whenever possible. Note that, in the following cases,\na new copy will always be made, even if `copy=False`:\n\n- If `X` is not an array of floating values;\n- If `X` is encoded as a CSR matrix;\n- If `add_indicator=True`.\n",
        "name": "copy",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "If True, a :class:`MissingIndicator` transform will stack onto output\nof the imputer's transform. This allows a predictive estimator\nto account for missingness despite imputation. If a feature has no\nmissing values at fit/train time, the feature won't appear on\nthe missing indicator even if there are missing values at\ntransform/test time.\n",
        "name": "add_indicator",
        "type": "boolean"
      },
      {
        "name": "keep_empty_features",
        "default": false,
        "description": "If True, features that consist exclusively of missing values when\n`fit` is called are returned in results when `transform` is called.\nThe imputed value is always `0` except when `strategy=\"constant\"`\nin which case `fill_value` will be used instead.\n\n.. versionadded:: 1.2\n"
      }
    ]
  },
  {
    "name": "sklearn.linear_model._logistic.LogisticRegression",
    "description": "\nLogistic Regression (aka logit, MaxEnt) classifier.\n\nIn the multiclass case, the training algorithm uses the one-vs-rest (OvR)\nscheme if the 'multi_class' option is set to 'ovr', and uses the\ncross-entropy loss if the 'multi_class' option is set to 'multinomial'.\n(Currently the 'multinomial' option is supported only by the 'lbfgs',\n'sag', 'saga' and 'newton-cg' solvers.)\n\nThis class implements regularized logistic regression using the\n'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. **Note\nthat regularization is applied by default**. It can handle both dense\nand sparse input. Use C-ordered arrays or CSR matrices containing 64-bit\nfloats for optimal performance; any other input format will be converted\n(and copied).\n\nThe 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization\nwith primal formulation, or no regularization. The 'liblinear' solver\nsupports both L1 and L2 regularization, with a dual formulation only for\nthe L2 penalty. The Elastic-Net regularization is only supported by the\n'saga' solver.\n\nRead more in the :ref:`User Guide <logistic_regression>`.\n",
    "attributes": [
      {
        "default": "l2",
        "description": "Specify the norm of the penalty:\n\n- `None`: no penalty is added;\n- `'l2'`: add a L2 penalty term and it is the default choice;\n- `'l1'`: add a L1 penalty term;\n- `'elasticnet'`: both L1 and L2 penalty terms are added.\n\n.. warning::\nSome penalties may not work with some solvers. See the parameter\n`solver` below, to know the compatibility between the penalty and\nsolver.\n\n.. versionadded:: 0.19\nl1 penalty with SAGA solver (allowing 'multinomial' + L1)\n",
        "name": "penalty"
      },
      {
        "default": false,
        "description": "Dual (constrained) or primal (regularized, see also\n:ref:`this equation <regularized-logistic-loss>`) formulation. Dual formulation\nis only implemented for l2 penalty with liblinear solver. Prefer dual=False when\nn_samples > n_features.\n",
        "name": "dual",
        "type": "boolean"
      },
      {
        "default": 0.0001,
        "description": "Tolerance for stopping criteria.\n",
        "name": "tol",
        "type": "float32"
      },
      {
        "default": 1.0,
        "description": "Inverse of regularization strength; must be a positive float.\nLike in support vector machines, smaller values specify stronger\nregularization.\n",
        "name": "C",
        "type": "float32"
      },
      {
        "default": true,
        "description": "Specifies if a constant (a.k.a. bias or intercept) should be\nadded to the decision function.\n",
        "name": "fit_intercept",
        "type": "boolean"
      },
      {
        "default": 1.0,
        "description": "Useful only when the solver 'liblinear' is used\nand self.fit_intercept is set to True. In this case, x becomes\n[x, self.intercept_scaling],\ni.e. a \"synthetic\" feature with constant value equal to\nintercept_scaling is appended to the instance vector.\nThe intercept becomes ``intercept_scaling * synthetic_feature_weight``.\n\nNote! the synthetic feature weight is subject to l1/l2 regularization\nas all other features.\nTo lessen the effect of regularization on synthetic feature weight\n(and therefore on the intercept) intercept_scaling has to be increased.\n",
        "name": "intercept_scaling",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Weights associated with classes in the form ``{class_label: weight}``.\nIf not given, all classes are supposed to have weight one.\n\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``.\n\nNote that these weights will be multiplied with sample_weight (passed\nthrough the fit method) if sample_weight is specified.\n\n.. versionadded:: 0.17\n*class_weight='balanced'*\n",
        "name": "class_weight"
      },
      {
        "default": null,
        "description": "Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the\ndata. See :term:`Glossary <random_state>` for details.\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "default": "lbfgs",
        "description": "\nAlgorithm to use in the optimization problem. Default is 'lbfgs'.\nTo choose a solver, you might want to consider the following aspects:\n\n- For small datasets, 'liblinear' is a good choice, whereas 'sag'\nand 'saga' are faster for large ones;\n- For multiclass problems, only 'newton-cg', 'sag', 'saga' and\n'lbfgs' handle multinomial loss;\n- 'liblinear' and 'newton-cholesky' can only handle binary classification\nby default. To apply a one-versus-rest scheme for the multiclass setting\none can wrapt it with the `OneVsRestClassifier`.\n- 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,\nespecially with one-hot encoded categorical features with rare\ncategories. Be aware that the memory usage of this solver has a quadratic\ndependency on `n_features` because it explicitly computes the Hessian\nmatrix.\n\n.. warning::\nThe choice of the algorithm depends on the penalty chosen and on\n(multinomial) multiclass support:\n\n================= ============================== ======================\nsolver            penalty                        multinomial multiclass\n================= ============================== ======================\n'lbfgs'           'l2', None                     yes\n'liblinear'       'l1', 'l2'                     no\n'newton-cg'       'l2', None                     yes\n'newton-cholesky' 'l2', None                     no\n'sag'             'l2', None                     yes\n'saga'            'elasticnet', 'l1', 'l2', None yes\n================= ============================== ======================\n\n.. note::\n'sag' and 'saga' fast convergence is only guaranteed on features\nwith approximately the same scale. You can preprocess the data with\na scaler from :mod:`sklearn.preprocessing`.\n\n.. seealso::\nRefer to the User Guide for more information regarding\n:class:`LogisticRegression` and more specifically the\n:ref:`Table <Logistic_regression>`\nsummarizing solver/penalty supports.\n\n.. versionadded:: 0.17\nStochastic Average Gradient descent solver.\n.. versionadded:: 0.19\nSAGA solver.\n.. versionchanged:: 0.22\nThe default solver changed from 'liblinear' to 'lbfgs' in 0.22.\n.. versionadded:: 1.2\nnewton-cholesky solver.\n",
        "name": "solver"
      },
      {
        "default": 100,
        "description": "Maximum number of iterations taken for the solvers to converge.\n",
        "name": "max_iter",
        "type": "int32"
      },
      {
        "default": "auto",
        "description": "If the option chosen is 'ovr', then a binary problem is fit for each\nlabel. For 'multinomial' the loss minimised is the multinomial loss fit\nacross the entire probability distribution, *even when the data is\nbinary*. 'multinomial' is unavailable when solver='liblinear'.\n'auto' selects 'ovr' if the data is binary, or if solver='liblinear',\nand otherwise selects 'multinomial'.\n\n.. versionadded:: 0.18\nStochastic Average Gradient descent solver for 'multinomial' case.\n.. versionchanged:: 0.22\nDefault changed from 'ovr' to 'auto' in 0.22.\n.. deprecated:: 1.5\n``multi_class`` was deprecated in version 1.5 and will be removed in 1.7.\nFrom then on, the recommended 'multinomial' will always be used for\n`n_classes >= 3`.\nSolvers that do not support 'multinomial' will raise an error.\nUse `sklearn.multiclass.OneVsRestClassifier(LogisticRegression())` if you\nstill want to use OvR.\n",
        "name": "multi_class"
      },
      {
        "default": 0,
        "description": "For the liblinear and lbfgs solvers set verbose to any positive\nnumber for verbosity.\n",
        "name": "verbose",
        "type": "int32"
      },
      {
        "default": false,
        "description": "When set to True, reuse the solution of the previous call to fit as\ninitialization, otherwise, just erase the previous solution.\nUseless for liblinear solver. See :term:`the Glossary <warm_start>`.\n\n.. versionadded:: 0.17\n*warm_start* to support *lbfgs*, *newton-cg*, *sag*, *saga* solvers.\n",
        "name": "warm_start",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Number of CPU cores used when parallelizing over classes if\nmulti_class='ovr'\". This parameter is ignored when the ``solver`` is\nset to 'liblinear' regardless of whether 'multi_class' is specified or\nnot. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`\ncontext. ``-1`` means using all processors.\nSee :term:`Glossary <n_jobs>` for more details.\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": null,
        "description": "The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only\nused if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent\nto using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent\nto using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a\ncombination of L1 and L2.\n",
        "name": "l1_ratio",
        "type": "float32"
      }
    ]
  },
  {
    "name": "sklearn.linear_model.LassoLars",
    "description": "Lasso model fit with Least Angle Regression a.k.a. Lars.\n\nIt is a Linear Model trained with an L1 prior as regularizer.\n\nThe optimization objective for Lasso is::\n\n(1 / (2 * n_samples)) * ||y - Xw||^2_2 + alpha * ||w||_1\n\nRead more in the :ref:`User Guide <least_angle_regression>`.\n",
    "attributes": [
      {
        "default": 1.0,
        "description": "Constant that multiplies the penalty term. Defaults to 1.0.\n``alpha = 0`` is equivalent to an ordinary least square, solved\nby :class:`LinearRegression`. For numerical reasons, using\n``alpha = 0`` with the LassoLars object is not advised and you\nshould prefer the LinearRegression object.\n",
        "name": "alpha",
        "type": "float32"
      },
      {
        "default": true,
        "description": "Whether to calculate the intercept for this model. If set\nto false, no intercept will be used in calculations\n(i.e. data is expected to be centered).\n",
        "name": "fit_intercept",
        "type": "boolean"
      },
      {
        "default": "False",
        "description": "Sets the verbosity amount.\n",
        "name": "verbose",
        "optional": true
      },
      {
        "default": false,
        "description": "This parameter is ignored when ``fit_intercept`` is set to False.\nIf True, the regressors X will be normalized before regression by\nsubtracting the mean and dividing by the l2-norm.\nIf you wish to standardize, please use\n:class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\non an estimator with ``normalize=False``.\n\n.. versionchanged:: 1.2\ndefault changed from True to False in 1.2.\n\n.. deprecated:: 1.2\n``normalize`` was deprecated in version 1.2 and will be removed in 1.4.\n",
        "name": "normalize",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": "auto",
        "description": "Whether to use a precomputed Gram matrix to speed up\ncalculations. If set to ``'auto'`` let us decide. The Gram\nmatrix can also be passed as argument.\n",
        "name": "precompute",
        "type": "boolean"
      },
      {
        "default": 500,
        "description": "Maximum number of iterations to perform.\n",
        "name": "max_iter",
        "optional": true,
        "type": "int32"
      },
      {
        "description": "The machine-precision regularization in the computation of the\nCholesky diagonal factors. Increase this for very ill-conditioned\nsystems. Unlike the ``tol`` parameter in some iterative\noptimization-based algorithms, this parameter does not control\nthe tolerance of the optimization.\n",
        "name": "eps",
        "optional": true,
        "type": "float32",
        "default": null
      },
      {
        "default": true,
        "description": "If True, X will be copied; else, it may be overwritten.\n",
        "name": "copy_X",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": true,
        "description": "If ``True`` the full path is stored in the ``coef_path_`` attribute.\nIf you compute the solution for a large problem or many targets,\nsetting ``fit_path`` to ``False`` will lead to a speedup, especially\nwith a small alpha.\n",
        "name": "fit_path",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Restrict coefficients to be >= 0. Be aware that you might want to\nremove fit_intercept which is set True by default.\nUnder the positive restriction the model coefficients will not converge\nto the ordinary-least-squares solution for small values of alpha.\nOnly coefficients up to the smallest alpha value (``alphas_[alphas_ >\n0.].min()`` when fit_path=True) reached by the stepwise Lars-Lasso\nalgorithm are typically in congruence with the solution of the\ncoordinate descent Lasso estimator.\n",
        "name": "positive",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Upper bound on a uniform noise parameter to be added to the\n`y` values, to satisfy the model's assumption of\none-at-a-time computations. Might help with stability.\n\n.. versionadded:: 0.23\n",
        "name": "jitter",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Determines random number generation for jittering. Pass an int\nfor reproducible output across multiple function calls.\nSee :term:`Glossary <random_state>`. Ignored if `jitter` is None.\n\n.. versionadded:: 0.23\n",
        "name": "random_state",
        "type": "int32"
      }
    ]
  },
  {
    "name": "sklearn.linear_model.LinearRegression",
    "description": "\nOrdinary least squares Linear Regression.\n\nLinearRegression fits a linear model with coefficients w = (w1, ..., wp)\nto minimize the residual sum of squares between the observed targets in\nthe dataset, and the targets predicted by the linear approximation.\n",
    "attributes": [
      {
        "default": true,
        "description": "Whether to calculate the intercept for this model. If set\nto False, no intercept will be used in calculations\n(i.e. data is expected to be centered).\n",
        "name": "fit_intercept",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": false,
        "description": "This parameter is ignored when ``fit_intercept`` is set to False.\nIf True, the regressors X will be normalized before regression by\nsubtracting the mean and dividing by the l2-norm.\nIf you wish to standardize, please use\n:class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``\non an estimator with ``normalize=False``.\n\n.. deprecated:: 1.0\n`normalize` was deprecated in version 1.0 and will be\nremoved in 1.2.\n",
        "name": "normalize",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": true,
        "description": "If True, X will be copied; else, it may be overwritten.\n",
        "name": "copy_X",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": null,
        "description": "The number of jobs to use for the computation. This will only provide\nspeedup in case of sufficiently large problems, that is if firstly\n`n_targets > 1` and secondly `X` is sparse or if `positive` is set\nto `True`. ``None`` means 1 unless in a\n:obj:`joblib.parallel_backend` context. ``-1`` means using all\nprocessors. See :term:`Glossary <n_jobs>` for more details.\n",
        "name": "n_jobs",
        "optional": true,
        "type": "int32"
      },
      {
        "default": false,
        "description": "When set to ``True``, forces the coefficients to be positive. This\noption is only supported for dense arrays.\n\n.. versionadded:: 0.24\n",
        "name": "positive",
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.linear_model.LogisticRegression",
    "description": "\nLogistic Regression (aka logit, MaxEnt) classifier.\n\nIn the multiclass case, the training algorithm uses the one-vs-rest (OvR)\nscheme if the 'multi_class' option is set to 'ovr', and uses the\ncross-entropy loss if the 'multi_class' option is set to 'multinomial'.\n(Currently the 'multinomial' option is supported only by the 'lbfgs',\n'sag', 'saga' and 'newton-cg' solvers.)\n\nThis class implements regularized logistic regression using the\n'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. **Note\nthat regularization is applied by default**. It can handle both dense\nand sparse input. Use C-ordered arrays or CSR matrices containing 64-bit\nfloats for optimal performance; any other input format will be converted\n(and copied).\n\nThe 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization\nwith primal formulation, or no regularization. The 'liblinear' solver\nsupports both L1 and L2 regularization, with a dual formulation only for\nthe L2 penalty. The Elastic-Net regularization is only supported by the\n'saga' solver.\n\nRead more in the :ref:`User Guide <logistic_regression>`.\n",
    "attributes": [
      {
        "default": "l2",
        "description": "Specify the norm of the penalty:\n\n- `None`: no penalty is added;\n- `'l2'`: add a L2 penalty term and it is the default choice;\n- `'l1'`: add a L1 penalty term;\n- `'elasticnet'`: both L1 and L2 penalty terms are added.\n\n.. warning::\nSome penalties may not work with some solvers. See the parameter\n`solver` below, to know the compatibility between the penalty and\nsolver.\n\n.. versionadded:: 0.19\nl1 penalty with SAGA solver (allowing 'multinomial' + L1)\n",
        "name": "penalty",
        "optional": true
      },
      {
        "default": false,
        "description": "Dual (constrained) or primal (regularized, see also\n:ref:`this equation <regularized-logistic-loss>`) formulation. Dual formulation\nis only implemented for l2 penalty with liblinear solver. Prefer dual=False when\nn_samples > n_features.\n",
        "name": "dual",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": 0.0001,
        "description": "Tolerance for stopping criteria.\n",
        "name": "tol",
        "optional": true,
        "type": "float32"
      },
      {
        "default": 1.0,
        "description": "Inverse of regularization strength; must be a positive float.\nLike in support vector machines, smaller values specify stronger\nregularization.\n",
        "name": "C",
        "optional": true,
        "type": "float32"
      },
      {
        "default": true,
        "description": "Specifies if a constant (a.k.a. bias or intercept) should be\nadded to the decision function.\n",
        "name": "fit_intercept",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": 1.0,
        "description": "Useful only when the solver 'liblinear' is used\nand self.fit_intercept is set to True. In this case, x becomes\n[x, self.intercept_scaling],\ni.e. a \"synthetic\" feature with constant value equal to\nintercept_scaling is appended to the instance vector.\nThe intercept becomes ``intercept_scaling * synthetic_feature_weight``.\n\nNote! the synthetic feature weight is subject to l1/l2 regularization\nas all other features.\nTo lessen the effect of regularization on synthetic feature weight\n(and therefore on the intercept) intercept_scaling has to be increased.\n",
        "name": "intercept_scaling",
        "optional": true,
        "type": "float32"
      },
      {
        "default": null,
        "description": "Weights associated with classes in the form ``{class_label: weight}``.\nIf not given, all classes are supposed to have weight one.\n\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``.\n\nNote that these weights will be multiplied with sample_weight (passed\nthrough the fit method) if sample_weight is specified.\n\n.. versionadded:: 0.17\n*class_weight='balanced'*\n",
        "name": "class_weight",
        "optional": true
      },
      {
        "default": null,
        "description": "Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the\ndata. See :term:`Glossary <random_state>` for details.\n",
        "name": "random_state",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "lbfgs",
        "description": "\nAlgorithm to use in the optimization problem. Default is 'lbfgs'.\nTo choose a solver, you might want to consider the following aspects:\n\n- For small datasets, 'liblinear' is a good choice, whereas 'sag'\nand 'saga' are faster for large ones;\n- For multiclass problems, only 'newton-cg', 'sag', 'saga' and\n'lbfgs' handle multinomial loss;\n- 'liblinear' and 'newton-cholesky' can only handle binary classification\nby default. To apply a one-versus-rest scheme for the multiclass setting\none can wrapt it with the `OneVsRestClassifier`.\n- 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,\nespecially with one-hot encoded categorical features with rare\ncategories. Be aware that the memory usage of this solver has a quadratic\ndependency on `n_features` because it explicitly computes the Hessian\nmatrix.\n\n.. warning::\nThe choice of the algorithm depends on the penalty chosen and on\n(multinomial) multiclass support:\n\n================= ============================== ======================\nsolver            penalty                        multinomial multiclass\n================= ============================== ======================\n'lbfgs'           'l2', None                     yes\n'liblinear'       'l1', 'l2'                     no\n'newton-cg'       'l2', None                     yes\n'newton-cholesky' 'l2', None                     no\n'sag'             'l2', None                     yes\n'saga'            'elasticnet', 'l1', 'l2', None yes\n================= ============================== ======================\n\n.. note::\n'sag' and 'saga' fast convergence is only guaranteed on features\nwith approximately the same scale. You can preprocess the data with\na scaler from :mod:`sklearn.preprocessing`.\n\n.. seealso::\nRefer to the User Guide for more information regarding\n:class:`LogisticRegression` and more specifically the\n:ref:`Table <Logistic_regression>`\nsummarizing solver/penalty supports.\n\n.. versionadded:: 0.17\nStochastic Average Gradient descent solver.\n.. versionadded:: 0.19\nSAGA solver.\n.. versionchanged:: 0.22\nThe default solver changed from 'liblinear' to 'lbfgs' in 0.22.\n.. versionadded:: 1.2\nnewton-cholesky solver.\n",
        "name": "solver",
        "optional": true
      },
      {
        "default": 100,
        "description": "Maximum number of iterations taken for the solvers to converge.\n",
        "name": "max_iter",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "auto",
        "description": "If the option chosen is 'ovr', then a binary problem is fit for each\nlabel. For 'multinomial' the loss minimised is the multinomial loss fit\nacross the entire probability distribution, *even when the data is\nbinary*. 'multinomial' is unavailable when solver='liblinear'.\n'auto' selects 'ovr' if the data is binary, or if solver='liblinear',\nand otherwise selects 'multinomial'.\n\n.. versionadded:: 0.18\nStochastic Average Gradient descent solver for 'multinomial' case.\n.. versionchanged:: 0.22\nDefault changed from 'ovr' to 'auto' in 0.22.\n.. deprecated:: 1.5\n``multi_class`` was deprecated in version 1.5 and will be removed in 1.7.\nFrom then on, the recommended 'multinomial' will always be used for\n`n_classes >= 3`.\nSolvers that do not support 'multinomial' will raise an error.\nUse `sklearn.multiclass.OneVsRestClassifier(LogisticRegression())` if you\nstill want to use OvR.\n",
        "name": "multi_class",
        "optional": true
      },
      {
        "default": 0,
        "description": "For the liblinear and lbfgs solvers set verbose to any positive\nnumber for verbosity.\n",
        "name": "verbose",
        "optional": true,
        "type": "int32"
      },
      {
        "default": false,
        "description": "When set to True, reuse the solution of the previous call to fit as\ninitialization, otherwise, just erase the previous solution.\nUseless for liblinear solver. See :term:`the Glossary <warm_start>`.\n\n.. versionadded:: 0.17\n*warm_start* to support *lbfgs*, *newton-cg*, *sag*, *saga* solvers.\n",
        "name": "warm_start",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Number of CPU cores used when parallelizing over classes if\nmulti_class='ovr'\". This parameter is ignored when the ``solver`` is\nset to 'liblinear' regardless of whether 'multi_class' is specified or\nnot. ``None`` means 1 unless in a :obj:`joblib.parallel_backend`\ncontext. ``-1`` means using all processors.\nSee :term:`Glossary <n_jobs>` for more details.\n",
        "name": "n_jobs",
        "optional": true,
        "type": "int32"
      },
      {
        "default": null,
        "description": "The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only\nused if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent\nto using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent\nto using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a\ncombination of L1 and L2.\n",
        "name": "l1_ratio",
        "optional": true,
        "type": "float32"
      }
    ]
  },
  {
    "name": "sklearn.model_selection._search.GridSearchCV",
    "description": "Exhaustive search over specified parameter values for an estimator.\n\nImportant members are fit, predict.\n\nGridSearchCV implements a \"fit\" and a \"score\" method.\nIt also implements \"score_samples\", \"predict\", \"predict_proba\",\n\"decision_function\", \"transform\" and \"inverse_transform\" if they are\nimplemented in the estimator used.\n\nThe parameters of the estimator used to apply these methods are optimized\nby cross-validated grid-search over a parameter grid.\n\nRead more in the :ref:`User Guide <grid_search>`.\n",
    "attributes": [
      {
        "description": "This is assumed to implement the scikit-learn estimator interface.\nEither estimator needs to provide a ``score`` function,\nor ``scoring`` must be passed.\n",
        "name": "estimator"
      },
      {
        "description": "Dictionary with parameters names (`str`) as keys and lists of\nparameter settings to try as values, or a list of such\ndictionaries, in which case the grids spanned by each dictionary\nin the list are explored. This enables searching over any sequence\nof parameter settings.\n",
        "name": "param_grid"
      },
      {
        "default": null,
        "description": "Strategy to evaluate the performance of the cross-validated model on\nthe test set.\n\nIf `scoring` represents a single score, one can use:\n\n- a single string (see :ref:`scoring_parameter`);\n- a callable (see :ref:`scoring`) that returns a single value.\n\nIf `scoring` represents multiple scores, one can use:\n\n- a list or tuple of unique strings;\n- a callable returning a dictionary where the keys are the metric\nnames and the values are the metric scores;\n- a dictionary with metric names as keys and callables a values.\n\nSee :ref:`multimetric_grid_search` for an example.\n",
        "name": "scoring"
      },
      {
        "default": null,
        "description": "Number of jobs to run in parallel.\n``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n``-1`` means using all processors. See :term:`Glossary <n_jobs>`\nfor more details.\n\n.. versionchanged:: v0.20\n`n_jobs` default changed from 1 to None\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "description": "Controls the number of jobs that get dispatched during parallel\nexecution. Reducing this number can be useful to avoid an\nexplosion of memory consumption when more jobs get dispatched\nthan CPUs can process. This parameter can be:\n\n- None, in which case all the jobs are immediately\ncreated and spawned. Use this for lightweight and\nfast-running jobs, to avoid delays due to on-demand\nspawning of the jobs\n\n- An int, giving the exact number of total jobs that are\nspawned\n\n- A str, giving an expression as a function of n_jobs,\nas in '2*n_jobs'\n",
        "name": "pre_dispatch",
        "default": "2*n_jobs"
      },
      {
        "default": false,
        "description": "If True, return the average score across folds, weighted by the number\nof samples in each test set. In this case, the data is assumed to be\nidentically distributed across the folds, and the loss minimized is\nthe total loss per sample, and not the mean loss across the folds.\n\n.. deprecated:: 0.22\nParameter ``iid`` is deprecated in 0.22 and will be removed in 0.24\n",
        "name": "iid",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Determines the cross-validation splitting strategy.\nPossible inputs for cv are:\n\n- None, to use the default 5-fold cross validation,\n- integer, to specify the number of folds in a `(Stratified)KFold`,\n- :term:`CV splitter`,\n- An iterable yielding (train, test) splits as arrays of indices.\n\nFor integer/None inputs, if the estimator is a classifier and ``y`` is\neither binary or multiclass, :class:`StratifiedKFold` is used. In all\nother cases, :class:`KFold` is used. These splitters are instantiated\nwith `shuffle=False` so the splits will be the same across calls.\n\nRefer :ref:`User Guide <cross_validation>` for the various\ncross-validation strategies that can be used here.\n\n.. versionchanged:: 0.22\n``cv`` default value if None changed from 3-fold to 5-fold.\n",
        "name": "cv",
        "type": "int32"
      },
      {
        "default": "True",
        "description": "Refit an estimator using the best found parameters on the whole\ndataset.\n\nFor multiple metric evaluation, this needs to be a `str` denoting the\nscorer that would be used to find the best parameters for refitting\nthe estimator at the end.\n\nWhere there are considerations other than maximum score in\nchoosing a best estimator, ``refit`` can be set to a function which\nreturns the selected ``best_index_`` given ``cv_results_``. In that\ncase, the ``best_estimator_`` and ``best_params_`` will be set\naccording to the returned ``best_index_`` while the ``best_score_``\nattribute will not be available.\n\nThe refitted estimator is made available at the ``best_estimator_``\nattribute and permits using ``predict`` directly on this\n``GridSearchCV`` instance.\n\nAlso for multiple metric evaluation, the attributes ``best_index_``,\n``best_score_`` and ``best_params_`` will only be available if\n``refit`` is set and all of them will be determined w.r.t this specific\nscorer.\n\nSee ``scoring`` parameter to know more about multiple metric\nevaluation.\n\nSee :ref:`sphx_glr_auto_examples_model_selection_plot_grid_search_digits.py`\nto see how to design a custom selection strategy using a callable\nvia `refit`.\n\n.. versionchanged:: 0.20\nSupport for callable added.\n",
        "name": "refit",
        "type": "boolean"
      },
      {
        "description": "Controls the verbosity: the higher, the more messages.\n\n- >1 : the computation time for each fold and parameter candidate is\ndisplayed;\n- >2 : the score is also displayed;\n- >3 : the fold and candidate parameter indexes are also displayed\ntogether with the starting time of the computation.\n",
        "name": "verbose",
        "type": "int32"
      },
      {
        "description": "Value to assign to the score if an error occurs in estimator fitting.\nIf set to 'raise', the error is raised. If a numeric value is given,\nFitFailedWarning is raised. This parameter does not affect the refit\nstep, which will always raise the error.\n",
        "name": "error_score",
        "default": "np.nan"
      },
      {
        "default": false,
        "description": "If ``False``, the ``cv_results_`` attribute will not include training\nscores.\nComputing training scores is used to get insights on how different\nparameter settings impact the overfitting/underfitting trade-off.\nHowever computing the scores on the training set can be computationally\nexpensive and is not strictly required to select the parameters that\nyield the best generalization performance.\n\n.. versionadded:: 0.19\n\n.. versionchanged:: 0.21\nDefault value was changed from ``True`` to ``False``\n",
        "name": "return_train_score",
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.naive_bayes.BernoulliNB",
    "description": "Naive Bayes classifier for multivariate Bernoulli models.\n\nLike MultinomialNB, this classifier is suitable for discrete data. The\ndifference is that while MultinomialNB works with occurrence counts,\nBernoulliNB is designed for binary/boolean features.\n\nRead more in the :ref:`User Guide <bernoulli_naive_bayes>`.\n",
    "attributes": [
      {
        "default": "1.0",
        "description": "Additive (Laplace/Lidstone) smoothing parameter\n(set alpha=0 and force_alpha=True, for no smoothing).\n",
        "name": "alpha",
        "optional": true,
        "type": "float32"
      },
      {
        "default": "0.0",
        "description": "Threshold for binarizing (mapping to booleans) of sample features.\nIf None, input is presumed to already consist of binary vectors.\n",
        "name": "binarize",
        "optional": true
      },
      {
        "default": true,
        "description": "Whether to learn class prior probabilities or not.\nIf false, a uniform prior will be used.\n",
        "name": "fit_prior",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Prior probabilities of the classes. If specified, the priors are not\nadjusted according to the data.\n",
        "name": "class_prior",
        "optional": true
      },
      {
        "name": "force_alpha",
        "description": "If False and alpha is less than 1e-10, it will set alpha to\n1e-10. If True, alpha will remain unchanged. This may cause\nnumerical errors if alpha is too close to 0.\n\n.. versionadded:: 1.2\n.. versionchanged:: 1.4\nThe default value of `force_alpha` changed to `True`.\n",
        "type": "boolean",
        "default": true
      }
    ]
  },
  {
    "name": "sklearn.naive_bayes.ComplementNB",
    "description": "The Complement Naive Bayes classifier described in Rennie et al. (2003).\n\nThe Complement Naive Bayes classifier was designed to correct the \"severe\nassumptions\" made by the standard Multinomial Naive Bayes classifier. It is\nparticularly suited for imbalanced data sets.\n\nRead more in the :ref:`User Guide <complement_naive_bayes>`.\n\n.. versionadded:: 0.20\n",
    "attributes": [
      {
        "default": "1.0",
        "description": "Additive (Laplace/Lidstone) smoothing parameter\n(set alpha=0 and force_alpha=True, for no smoothing).\n",
        "name": "alpha",
        "optional": true,
        "type": "float32"
      },
      {
        "default": true,
        "description": "Only used in edge case with a single class in the training set.\n",
        "name": "fit_prior",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Prior probabilities of the classes. Not used.\n",
        "name": "class_prior",
        "optional": true
      },
      {
        "default": false,
        "description": "Whether or not a second normalization of the weights is performed. The\ndefault behavior mirrors the implementations found in Mahout and Weka,\nwhich do not follow the full algorithm described in Table 9 of the\npaper.\n",
        "name": "norm",
        "optional": true,
        "type": "boolean"
      },
      {
        "name": "force_alpha",
        "description": "If False and alpha is less than 1e-10, it will set alpha to\n1e-10. If True, alpha will remain unchanged. This may cause\nnumerical errors if alpha is too close to 0.\n\n.. versionadded:: 1.2\n.. versionchanged:: 1.4\nThe default value of `force_alpha` changed to `True`.\n",
        "type": "boolean",
        "default": true
      }
    ]
  },
  {
    "name": "sklearn.naive_bayes.MultinomialNB",
    "description": "\nNaive Bayes classifier for multinomial models.\n\nThe multinomial Naive Bayes classifier is suitable for classification with\ndiscrete features (e.g., word counts for text classification). The\nmultinomial distribution normally requires integer feature counts. However,\nin practice, fractional counts such as tf-idf may also work.\n\nRead more in the :ref:`User Guide <multinomial_naive_bayes>`.\n",
    "attributes": [
      {
        "default": "1.0",
        "description": "Additive (Laplace/Lidstone) smoothing parameter\n(set alpha=0 and force_alpha=True, for no smoothing).\n",
        "name": "alpha",
        "optional": true,
        "type": "float32"
      },
      {
        "default": true,
        "description": "Whether to learn class prior probabilities or not.\nIf false, a uniform prior will be used.\n",
        "name": "fit_prior",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Prior probabilities of the classes. If specified, the priors are not\nadjusted according to the data.\n",
        "name": "class_prior",
        "optional": true
      },
      {
        "name": "force_alpha",
        "description": "If False and alpha is less than 1e-10, it will set alpha to\n1e-10. If True, alpha will remain unchanged. This may cause\nnumerical errors if alpha is too close to 0.\n\n.. versionadded:: 1.2\n.. versionchanged:: 1.4\nThe default value of `force_alpha` changed to `True`.\n",
        "type": "boolean",
        "default": true
      }
    ]
  },
  {
    "name": "sklearn.neighbors.KNeighborsClassifier",
    "description": "Classifier implementing the k-nearest neighbors vote.\n\nRead more in the :ref:`User Guide <classification>`.\n",
    "attributes": [
      {
        "default": 5,
        "description": "Number of neighbors to use by default for :meth:`kneighbors` queries.\n",
        "name": "n_neighbors",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "uniform",
        "description": "Weight function used in prediction.  Possible values:\n\n- 'uniform' : uniform weights.  All points in each neighborhood\nare weighted equally.\n- 'distance' : weight points by the inverse of their distance.\nin this case, closer neighbors of a query point will have a\ngreater influence than neighbors which are further away.\n- [callable] : a user-defined function which accepts an\narray of distances, and returns an array of the same shape\ncontaining the weights.\n\nRefer to the example entitled\n:ref:`sphx_glr_auto_examples_neighbors_plot_classification.py`\nshowing the impact of the `weights` parameter on the decision\nboundary.\n",
        "name": "weights",
        "optional": true
      },
      {
        "default": "auto",
        "description": "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\nbased on the values passed to :meth:`fit` method.\n\nNote: fitting on sparse input will override the setting of\nthis parameter, using brute force.\n",
        "name": "algorithm",
        "optional": true
      },
      {
        "default": 30,
        "description": "Leaf size passed to BallTree or KDTree.  This can affect the\nspeed of the construction and query, as well as the memory\nrequired to store the tree.  The optimal value depends on the\nnature of the problem.\n",
        "name": "leaf_size",
        "optional": true,
        "type": "int32"
      },
      {
        "default": 2.0,
        "description": "Power parameter for the Minkowski metric. When p = 1, this is equivalent\nto using manhattan_distance (l1), and euclidean_distance (l2) for p = 2.\nFor arbitrary p, minkowski_distance (l_p) is used. This parameter is expected\nto be positive.\n",
        "name": "p",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "minkowski",
        "description": "Metric to use for distance computation. Default is \"minkowski\", which\nresults in the standard Euclidean distance when p = 2. See the\ndocumentation of `scipy.spatial.distance\n<https://docs.scipy.org/doc/scipy/reference/spatial.distance.html>`_ and\nthe metrics listed in\n:class:`~sklearn.metrics.pairwise.distance_metrics` for valid metric\nvalues.\n\nIf metric is \"precomputed\", X is assumed to be a distance matrix and\nmust be square during fit. X may be a :term:`sparse graph`, in which\ncase only \"nonzero\" elements may be considered neighbors.\n\nIf metric is a callable function, it takes two arrays representing 1D\nvectors as inputs and must return one value indicating the distance\nbetween those vectors. This works for Scipy's metrics, but is less\nefficient than passing the metric name as a string.\n",
        "name": "metric"
      },
      {
        "default": null,
        "description": "Additional keyword arguments for the metric function.\n",
        "name": "metric_params",
        "optional": true
      },
      {
        "default": null,
        "description": "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>`\nfor more details.\nDoesn't affect :meth:`fit` method.\n",
        "name": "n_jobs",
        "optional": true,
        "type": "int32"
      }
    ]
  },
  {
    "name": "sklearn.neighbors.KNeighborsRegressor",
    "description": "Regression based on k-nearest neighbors.\n\nThe target is predicted by local interpolation of the targets\nassociated of the nearest neighbors in the training set.\n\nRead more in the :ref:`User Guide <regression>`.\n\n.. versionadded:: 0.9\n",
    "attributes": [
      {
        "default": 5,
        "description": "Number of neighbors to use by default for :meth:`kneighbors` queries.\n",
        "name": "n_neighbors",
        "optional": true,
        "type": "int32"
      },
      {
        "description": "Weight function used in prediction.  Possible values:\n\n- 'uniform' : uniform weights.  All points in each neighborhood\nare weighted equally.\n- 'distance' : weight points by the inverse of their distance.\nin this case, closer neighbors of a query point will have a\ngreater influence than neighbors which are further away.\n- [callable] : a user-defined function which accepts an\narray of distances, and returns an array of the same shape\ncontaining the weights.\n\nUniform weights are used by default.\n",
        "name": "weights",
        "default": "uniform"
      },
      {
        "default": "auto",
        "description": "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\nbased on the values passed to :meth:`fit` method.\n\nNote: fitting on sparse input will override the setting of\nthis parameter, using brute force.\n",
        "name": "algorithm",
        "optional": true
      },
      {
        "default": 30,
        "description": "Leaf size passed to BallTree or KDTree.  This can affect the\nspeed of the construction and query, as well as the memory\nrequired to store the tree.  The optimal value depends on the\nnature of the problem.\n",
        "name": "leaf_size",
        "optional": true,
        "type": "int32"
      },
      {
        "default": 2.0,
        "description": "Power parameter for the Minkowski metric. When p = 1, this is\nequivalent to using manhattan_distance (l1), and euclidean_distance\n(l2) for p = 2. For arbitrary p, minkowski_distance (l_p) is used.\n",
        "name": "p",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "minkowski",
        "description": "Metric to use for distance computation. Default is \"minkowski\", which\nresults in the standard Euclidean distance when p = 2. See the\ndocumentation of `scipy.spatial.distance\n<https://docs.scipy.org/doc/scipy/reference/spatial.distance.html>`_ and\nthe metrics listed in\n:class:`~sklearn.metrics.pairwise.distance_metrics` for valid metric\nvalues.\n\nIf metric is \"precomputed\", X is assumed to be a distance matrix and\nmust be square during fit. X may be a :term:`sparse graph`, in which\ncase only \"nonzero\" elements may be considered neighbors.\n\nIf metric is a callable function, it takes two arrays representing 1D\nvectors as inputs and must return one value indicating the distance\nbetween those vectors. This works for Scipy's metrics, but is less\nefficient than passing the metric name as a string.\n\nIf metric is a DistanceMetric object, it will be passed directly to\nthe underlying computation routines.\n",
        "name": "metric"
      },
      {
        "default": null,
        "description": "Additional keyword arguments for the metric function.\n",
        "name": "metric_params",
        "optional": true
      },
      {
        "default": null,
        "description": "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>`\nfor more details.\nDoesn't affect :meth:`fit` method.\n",
        "name": "n_jobs",
        "optional": true,
        "type": "int32"
      }
    ]
  },
  {
    "name": "sklearn.neural_network.multilayer_perceptron.MLPRegressor",
    "description": "Multi-layer Perceptron regressor.\n\nThis model optimizes the squared-loss using LBFGS or stochastic gradient\ndescent.\n\n.. versionadded:: 0.18\n",
    "attributes": [
      {
        "default": "(100,)",
        "description": "The ith element represents the number of neurons in the ith\nhidden layer.\n",
        "name": "hidden_layer_sizes"
      },
      {
        "default": "relu",
        "description": "Activation function for the hidden layer.\n\n- 'identity', no-op activation, useful to implement linear bottleneck,\nreturns f(x) = x\n\n- 'logistic', the logistic sigmoid function,\nreturns f(x) = 1 / (1 + exp(-x)).\n\n- 'tanh', the hyperbolic tan function,\nreturns f(x) = tanh(x).\n\n- 'relu', the rectified linear unit function,\nreturns f(x) = max(0, x)\n",
        "name": "activation"
      },
      {
        "default": "adam",
        "description": "The solver for weight optimization.\n\n- 'lbfgs' is an optimizer in the family of quasi-Newton methods.\n\n- 'sgd' refers to stochastic gradient descent.\n\n- 'adam' refers to a stochastic gradient-based optimizer proposed by\nKingma, Diederik, and Jimmy Ba\n\nNote: The default solver 'adam' works pretty well on relatively\nlarge datasets (with thousands of training samples or more) in terms of\nboth training time and validation score.\nFor small datasets, however, 'lbfgs' can converge faster and perform\nbetter.\n",
        "name": "solver"
      },
      {
        "default": 0.0001,
        "description": "L2 penalty (regularization term) parameter.\n",
        "name": "alpha",
        "type": "float32"
      },
      {
        "default": "auto",
        "description": "Size of minibatches for stochastic optimizers.\nIf the solver is 'lbfgs', the classifier will not use minibatch.\nWhen set to \"auto\", `batch_size=min(200, n_samples)`\n",
        "name": "batch_size",
        "type": "int32"
      },
      {
        "default": "constant",
        "description": "Learning rate schedule for weight updates.\n\n- 'constant' is a constant learning rate given by\n'learning_rate_init'.\n\n- 'invscaling' gradually decreases the learning rate ``learning_rate_``\nat each time step 't' using an inverse scaling exponent of 'power_t'.\neffective_learning_rate = learning_rate_init / pow(t, power_t)\n\n- 'adaptive' keeps the learning rate constant to\n'learning_rate_init' as long as training loss keeps decreasing.\nEach time two consecutive epochs fail to decrease training loss by at\nleast tol, or fail to increase validation score by at least tol if\n'early_stopping' is on, the current learning rate is divided by 5.\n\nOnly used when solver='sgd'.\n",
        "name": "learning_rate"
      },
      {
        "default": "0.001",
        "description": "The initial learning rate used. It controls the step-size\nin updating the weights. Only used when solver='sgd' or 'adam'.\n",
        "name": "learning_rate_init"
      },
      {
        "default": "0.5",
        "description": "The exponent for inverse scaling learning rate.\nIt is used in updating effective learning rate when the learning_rate\nis set to 'invscaling'. Only used when solver='sgd'.\n",
        "name": "power_t"
      },
      {
        "default": 200,
        "description": "Maximum number of iterations. The solver iterates until convergence\n(determined by 'tol') or this number of iterations. For stochastic\nsolvers ('sgd', 'adam'), note that this determines the number of epochs\n(how many times each data point will be used), not the number of\ngradient steps.\n",
        "name": "max_iter",
        "type": "int32"
      },
      {
        "default": true,
        "description": "Whether to shuffle samples in each iteration. Only used when\nsolver='sgd' or 'adam'.\n",
        "name": "shuffle",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Determines random number generation for weights and bias\ninitialization, train-test split if early stopping is used, and batch\nsampling when solver='sgd' or 'adam'.\nPass an int for reproducible results across multiple function calls.\nSee :term:`Glossary <random_state>`.\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "default": 0.0001,
        "description": "Tolerance for the optimization. When the loss or score is not improving\nby at least ``tol`` for ``n_iter_no_change`` consecutive iterations,\nunless ``learning_rate`` is set to 'adaptive', convergence is\nconsidered to be reached and training stops.\n",
        "name": "tol",
        "type": "float32"
      },
      {
        "default": false,
        "description": "Whether to print progress messages to stdout.\n",
        "name": "verbose",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "When set to True, reuse the solution of the previous\ncall to fit as initialization, otherwise, just erase the\nprevious solution. See :term:`the Glossary <warm_start>`.\n",
        "name": "warm_start",
        "type": "boolean"
      },
      {
        "default": 0.9,
        "description": "Momentum for gradient descent update.  Should be between 0 and 1. Only\nused when solver='sgd'.\n",
        "name": "momentum",
        "type": "float32"
      },
      {
        "default": true,
        "description": "Whether to use Nesterov's momentum. Only used when solver='sgd' and\nmomentum > 0.\n",
        "name": "nesterovs_momentum",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Whether to use early stopping to terminate training when validation\nscore is not improving. If set to true, it will automatically set\naside 10% of training data as validation and terminate training when\nvalidation score is not improving by at least ``tol`` for\n``n_iter_no_change`` consecutive epochs.\nOnly effective when solver='sgd' or 'adam'\n",
        "name": "early_stopping",
        "type": "boolean"
      },
      {
        "default": 0.1,
        "description": "The proportion of training data to set aside as validation set for\nearly stopping. Must be between 0 and 1.\nOnly used if early_stopping is True\n",
        "name": "validation_fraction",
        "type": "float32"
      },
      {
        "default": 0.9,
        "description": "Exponential decay rate for estimates of first moment vector in adam,\nshould be in [0, 1). Only used when solver='adam'\n",
        "name": "beta_1",
        "type": "float32"
      },
      {
        "default": 0.999,
        "description": "Exponential decay rate for estimates of second moment vector in adam,\nshould be in [0, 1). Only used when solver='adam'\n",
        "name": "beta_2",
        "type": "float32"
      },
      {
        "default": 1e-08,
        "description": "Value for numerical stability in adam. Only used when solver='adam'\n",
        "name": "epsilon",
        "type": "float32"
      },
      {
        "default": 10,
        "description": "Maximum number of epochs to not meet ``tol`` improvement.\nOnly effective when solver='sgd' or 'adam'\n\n.. versionadded:: 0.20\n",
        "name": "n_iter_no_change",
        "type": "int32"
      },
      {
        "default": 15000,
        "description": "Only used when solver='lbfgs'. Maximum number of function calls.\nThe solver iterates until convergence (determined by 'tol'), number\nof iterations reaches max_iter, or this number of function calls.\nNote that number of function calls will be greater than or equal to\nthe number of iterations for the MLPRegressor.\n\n.. versionadded:: 0.22\n",
        "name": "max_fun",
        "type": "int32"
      }
    ]
  },
  {
    "name": "sklearn.pipeline.FeatureUnion",
    "description": "Concatenates results of multiple transformer objects.\n\nThis estimator applies a list of transformer objects in parallel to the\ninput data, then concatenates the results. This is useful to combine\nseveral feature extraction mechanisms into a single transformer.\n\nParameters of the transformers may be set using its name and the parameter\nname separated by a '__'. A transformer may be replaced entirely by\nsetting the parameter with its name to another transformer, removed by\nsetting to 'drop' or disabled by setting to 'passthrough' (features are\npassed without transformation).\n\nRead more in the :ref:`User Guide <feature_union>`.\n\n.. versionadded:: 0.13\n",
    "attributes": [
      {
        "description": "List of transformer objects to be applied to the data. The first\nhalf of each tuple is the name of the transformer. The transformer can\nbe 'drop' for it to be ignored or can be 'passthrough' for features to\nbe passed unchanged.\n\n.. versionadded:: 1.1\nAdded the option `\"passthrough\"`.\n\n.. versionchanged:: 0.22\nDeprecated `None` as a transformer in favor of 'drop'.\n",
        "name": "transformer_list"
      },
      {
        "default": null,
        "description": "Number of jobs to run in parallel.\n``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.\n``-1`` means using all processors. See :term:`Glossary <n_jobs>`\nfor more details.\n\n.. versionchanged:: v0.20\n`n_jobs` default changed from 1 to None\n",
        "name": "n_jobs",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Multiplicative weights for features per transformer.\nKeys are transformer names, values the weights.\nRaises ValueError if key not present in ``transformer_list``.\n",
        "name": "transformer_weights"
      },
      {
        "default": false,
        "description": "If True, the time elapsed while fitting each transformer will be\nprinted as it is completed.\n",
        "name": "verbose",
        "type": "boolean"
      },
      {
        "name": "verbose_feature_names_out",
        "default": true,
        "description": "If True, :meth:`get_feature_names_out` will prefix all feature names\nwith the name of the transformer that generated that feature.\nIf False, :meth:`get_feature_names_out` will not prefix any feature\nnames and will error if feature names are not unique.\n\n.. versionadded:: 1.5\n"
      }
    ]
  },
  {
    "name": "sklearn.preprocessing._data.StandardScaler",
    "description": "Standardize features by removing the mean and scaling to unit variance.\n\nThe standard score of a sample `x` is calculated as:\n\nz = (x - u) / s\n\nwhere `u` is the mean of the training samples or zero if `with_mean=False`,\nand `s` is the standard deviation of the training samples or one if\n`with_std=False`.\n\nCentering and scaling happen independently on each feature by computing\nthe relevant statistics on the samples in the training set. Mean and\nstandard deviation are then stored to be used on later data using\n:meth:`transform`.\n\nStandardization of a dataset is a common requirement for many\nmachine learning estimators: they might behave badly if the\nindividual features do not more or less look like standard normally\ndistributed data (e.g. Gaussian with 0 mean and unit variance).\n\nFor instance many elements used in the objective function of\na learning algorithm (such as the RBF kernel of Support Vector\nMachines or the L1 and L2 regularizers of linear models) assume that\nall features are centered around 0 and have variance in the same\norder. If a feature has a variance that is orders of magnitude larger\nthan others, it might dominate the objective function and make the\nestimator unable to learn from other features correctly as expected.\n\n`StandardScaler` is sensitive to outliers, and the features may scale\ndifferently from each other in the presence of outliers. For an example\nvisualization, refer to :ref:`Compare StandardScaler with other scalers\n<plot_all_scaling_standard_scaler_section>`.\n\nThis scaler can also be applied to sparse CSR or CSC matrices by passing\n`with_mean=False` to avoid breaking the sparsity structure of the data.\n\nRead more in the :ref:`User Guide <preprocessing_scaler>`.\n",
    "attributes": [
      {
        "default": true,
        "description": "If False, try to avoid a copy and do inplace scaling instead.\nThis is not guaranteed to always work inplace; e.g. if the data is\nnot a NumPy array or scipy.sparse CSR matrix, a copy may still be\nreturned.\n",
        "name": "copy",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": true,
        "description": "If True, center the data before scaling.\nThis does not work (and will raise an exception) when attempted on\nsparse matrices, because centering them entails building a dense\nmatrix which in common use cases is likely to be too large to fit in\nmemory.\n",
        "name": "with_mean",
        "type": "boolean"
      },
      {
        "default": true,
        "description": "If True, scale the data to unit variance (or equivalently,\nunit standard deviation).\n",
        "name": "with_std",
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.preprocessing._encoders.OneHotEncoder",
    "description": "\nEncode categorical features as a one-hot numeric array.\n\nThe input to this transformer should be an array-like of integers or\nstrings, denoting the values taken on by categorical (discrete) features.\nThe features are encoded using a one-hot (aka 'one-of-K' or 'dummy')\nencoding scheme. This creates a binary column for each category and\nreturns a sparse matrix or dense array (depending on the ``sparse_output``\nparameter).\n\nBy default, the encoder derives the categories based on the unique values\nin each feature. Alternatively, you can also specify the `categories`\nmanually.\n\nThis encoding is needed for feeding categorical data to many scikit-learn\nestimators, notably linear models and SVMs with the standard kernels.\n\nNote: a one-hot encoding of y labels should use a LabelBinarizer\ninstead.\n\nRead more in the :ref:`User Guide <preprocessing_categorical_features>`.\nFor a comparison of different encoders, refer to:\n:ref:`sphx_glr_auto_examples_preprocessing_plot_target_encoder.py`.\n",
    "attributes": [
      {
        "description": "Categories (unique values) per feature:\n\n- 'auto' : Determine categories automatically from the training data.\n- list : ``categories[i]`` holds the categories expected in the ith\ncolumn. The passed categories should not mix strings and numeric\nvalues within a single feature, and should be sorted in case of\nnumeric values.\n\nThe used categories can be found in the ``categories_`` attribute.\n\n.. versionadded:: 0.20\n",
        "name": "categories",
        "default": "auto"
      },
      {
        "description": "Specifies a methodology to use to drop one of the categories per\nfeature. This is useful in situations where perfectly collinear\nfeatures cause problems, such as when feeding the resulting data\ninto an unregularized linear regression model.\n\nHowever, dropping one category breaks the symmetry of the original\nrepresentation and can therefore induce a bias in downstream models,\nfor instance for penalized linear classification or regression models.\n\n- None : retain all features (the default).\n- 'first' : drop the first category in each feature. If only one\ncategory is present, the feature will be dropped entirely.\n- 'if_binary' : drop the first category in each feature with two\ncategories. Features with 1 or more than 2 categories are\nleft intact.\n- array : ``drop[i]`` is the category in feature ``X[:, i]`` that\nshould be dropped.\n\nWhen `max_categories` or `min_frequency` is configured to group\ninfrequent categories, the dropping behavior is handled after the\ngrouping.\n\n.. versionadded:: 0.21\nThe parameter `drop` was added in 0.21.\n\n.. versionchanged:: 0.23\nThe option `drop='if_binary'` was added in 0.23.\n\n.. versionchanged:: 1.1\nSupport for dropping infrequent categories.\n",
        "name": "drop",
        "default": null
      },
      {
        "default": true,
        "description": "Will return sparse matrix if set True else will return an array.\n\n.. deprecated:: 1.2\n`sparse` is deprecated in 1.2 and will be removed in 1.4. Use\n`sparse_output` instead.\n",
        "name": "sparse",
        "type": "boolean"
      },
      {
        "default": "np.float64",
        "description": "Desired dtype of output.\n",
        "name": "dtype"
      },
      {
        "default": "error",
        "description": "Specifies the way unknown categories are handled during :meth:`transform`.\n\n- 'error' : Raise an error if an unknown category is present during transform.\n- 'ignore' : When an unknown category is encountered during\ntransform, the resulting one-hot encoded columns for this feature\nwill be all zeros. In the inverse transform, an unknown category\nwill be denoted as None.\n- 'infrequent_if_exist' : When an unknown category is encountered\nduring transform, the resulting one-hot encoded columns for this\nfeature will map to the infrequent category if it exists. The\ninfrequent category will be mapped to the last position in the\nencoding. During inverse transform, an unknown category will be\nmapped to the category denoted `'infrequent'` if it exists. If the\n`'infrequent'` category does not exist, then :meth:`transform` and\n:meth:`inverse_transform` will handle an unknown category as with\n`handle_unknown='ignore'`. Infrequent categories exist based on\n`min_frequency` and `max_categories`. Read more in the\n:ref:`User Guide <encoder_infrequent_categories>`.\n\n.. versionchanged:: 1.1\n`'infrequent_if_exist'` was added to automatically handle unknown\ncategories and infrequent categories.\n",
        "name": "handle_unknown"
      },
      {
        "name": "min_frequency",
        "description": "Specifies the minimum frequency below which a category will be\nconsidered infrequent.\n\n- If `int`, categories with a smaller cardinality will be considered\ninfrequent.\n\n- If `float`, categories with a smaller cardinality than\n`min_frequency * n_samples`  will be considered infrequent.\n\n.. versionadded:: 1.1\nRead more in the :ref:`User Guide <encoder_infrequent_categories>`.\n",
        "default": null
      },
      {
        "name": "max_categories",
        "description": "Specifies an upper limit to the number of output features for each input\nfeature when considering infrequent categories. If there are infrequent\ncategories, `max_categories` includes the category representing the\ninfrequent categories along with the frequent categories. If `None`,\nthere is no limit to the number of output features.\n\n.. versionadded:: 1.1\nRead more in the :ref:`User Guide <encoder_infrequent_categories>`.\n",
        "type": "int32",
        "default": null
      },
      {
        "name": "sparse_output",
        "default": true,
        "description": "When ``True``, it returns a :class:`scipy.sparse.csr_matrix`,\ni.e. a sparse matrix in \"Compressed Sparse Row\" (CSR) format.\n\n.. versionadded:: 1.2\n`sparse` was renamed to `sparse_output`\n"
      },
      {
        "name": "feature_name_combiner",
        "default": "\"concat\"",
        "description": "Callable with signature `def callable(input_feature, category)` that returns a\nstring. This is used to create feature names to be returned by\n:meth:`get_feature_names_out`.\n\n`\"concat\"` concatenates encoded feature name and category with\n`feature + \"_\" + str(category)`.E.g. feature X with values 1, 6, 7 create\nfeature names `X_1, X_6, X_7`.\n\n.. versionadded:: 1.3\n"
      }
    ]
  },
  {
    "name": "sklearn.preprocessing.Binarizer",
    "description": "Binarize data (set feature values to 0 or 1) according to a threshold.\n\nValues greater than the threshold map to 1, while values less than\nor equal to the threshold map to 0. With the default threshold of 0,\nonly positive values map to 1.\n\nBinarization is a common operation on text count data where the\nanalyst can decide to only consider the presence or absence of a\nfeature rather than a quantified number of occurrences for instance.\n\nIt can also be used as a pre-processing step for estimators that\nconsider boolean random variables (e.g. modelled using the Bernoulli\ndistribution in a Bayesian setting).\n\nRead more in the :ref:`User Guide <preprocessing_binarization>`.\n",
    "attributes": [
      {
        "default": true,
        "description": "Set to False to perform inplace binarization and avoid a copy (if\nthe input is already a numpy array or a scipy.sparse CSR matrix).\n",
        "name": "copy",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": 0.0,
        "description": "Feature values below or equal to this are replaced by 0, above it by 1.\nThreshold may not be less than 0 for operations on sparse matrices.\n",
        "name": "threshold",
        "optional": true,
        "type": "float32"
      }
    ]
  },
  {
    "name": "sklearn.preprocessing.LabelEncoder",
    "description": "Encode target labels with value between 0 and n_classes-1.\n\nThis transformer should be used to encode target values, *i.e.* `y`, and\nnot the input `X`.\n\nRead more in the :ref:`User Guide <preprocessing_targets>`.\n\n.. versionadded:: 0.12\n"
  },
  {
    "name": "sklearn.preprocessing.MultiLabelBinarizer",
    "description": "Transform between iterable of iterables and a multilabel format.\n\nAlthough a list of sets or tuples is a very intuitive format for multilabel\ndata, it is unwieldy to process. This transformer converts between this\nintuitive format and the supported multilabel format: a (samples x classes)\nbinary matrix indicating the presence of a class label.\n",
    "attributes": [
      {
        "default": null,
        "description": "Indicates an ordering for the class labels.\nAll entries should be unique (cannot contain duplicate classes).\n",
        "name": "classes",
        "optional": true
      },
      {
        "default": false,
        "description": "Set to True if output binary array is desired in CSR sparse format.\n",
        "name": "sparse_output",
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.svm.classes.SVC",
    "description": "C-Support Vector Classification.\n\nThe implementation is based on libsvm. The fit time scales at least\nquadratically with the number of samples and may be impractical\nbeyond tens of thousands of samples. For large datasets\nconsider using :class:`sklearn.svm.LinearSVC` or\n:class:`sklearn.linear_model.SGDClassifier` instead, possibly after a\n:class:`sklearn.kernel_approximation.Nystroem` transformer.\n\nThe multiclass support is handled according to a one-vs-one scheme.\n\nFor details on the precise mathematical formulation of the provided\nkernel functions and how `gamma`, `coef0` and `degree` affect each\nother, see the corresponding section in the narrative documentation:\n:ref:`svm_kernels`.\n\nRead more in the :ref:`User Guide <svm_classification>`.\n",
    "attributes": [
      {
        "default": 1,
        "description": "Regularization parameter. The strength of the regularization is\ninversely proportional to C. Must be strictly positive. The penalty\nis a squared l2 penalty.\n",
        "name": "C",
        "type": "float32"
      },
      {
        "default": "rbf",
        "description": "Specifies the kernel type to be used in the algorithm.\nIt must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or\na callable.\nIf none is given, 'rbf' will be used. If a callable is given it is\nused to pre-compute the kernel matrix from data matrices; that matrix\nshould be an array of shape ``(n_samples, n_samples)``.\n",
        "name": "kernel"
      },
      {
        "default": 3,
        "description": "Degree of the polynomial kernel function ('poly').\nIgnored by all other kernels.\n",
        "name": "degree",
        "type": "int32"
      },
      {
        "description": "Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.\n\n- if ``gamma='scale'`` (default) is passed then it uses\n1 / (n_features * X.var()) as value of gamma,\n- if 'auto', uses 1 / n_features.\n\n.. versionchanged:: 0.22\nThe default value of ``gamma`` changed from 'auto' to 'scale'.\n",
        "name": "gamma"
      },
      {
        "default": 0,
        "description": "Independent term in kernel function.\nIt is only significant in 'poly' and 'sigmoid'.\n",
        "name": "coef0",
        "type": "float32"
      },
      {
        "default": true,
        "description": "Whether to use the shrinking heuristic.\nSee the :ref:`User Guide <shrinking_svm>`.\n",
        "name": "shrinking",
        "type": "boolean"
      },
      {
        "default": false,
        "description": "Whether to enable probability estimates. This must be enabled prior\nto calling `fit`, will slow down that method as it internally uses\n5-fold cross-validation, and `predict_proba` may be inconsistent with\n`predict`. Read more in the :ref:`User Guide <scores_probabilities>`.\n",
        "name": "probability",
        "type": "boolean"
      },
      {
        "default": 0.001,
        "description": "Tolerance for stopping criterion.\n",
        "name": "tol",
        "type": "float32"
      },
      {
        "default": 200,
        "description": "Specify the size of the kernel cache (in MB).\n",
        "name": "cache_size",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Set the parameter C of class i to class_weight[i]*C for\nSVC. If not given, all classes are supposed to have\nweight one.\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``\n",
        "name": "class_weight"
      },
      {
        "default": false,
        "description": "Enable verbose output. Note that this setting takes advantage of a\nper-process runtime setting in libsvm that, if enabled, may not work\nproperly in a multithreaded context.\n",
        "name": "verbose",
        "type": "boolean"
      },
      {
        "default": -1,
        "description": "Hard limit on iterations within solver, or -1 for no limit.\n",
        "name": "max_iter",
        "type": "int32"
      },
      {
        "default": "ovr",
        "description": "Whether to return a one-vs-rest ('ovr') decision function of shape\n(n_samples, n_classes) as all other classifiers, or the original\none-vs-one ('ovo') decision function of libsvm which has shape\n(n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one\n('ovo') is always used as multi-class strategy. The parameter is\nignored for binary classification.\n\n.. versionchanged:: 0.19\ndecision_function_shape is 'ovr' by default.\n\n.. versionadded:: 0.17\n*decision_function_shape='ovr'* is recommended.\n\n.. versionchanged:: 0.17\nDeprecated *decision_function_shape='ovo' and None*.\n",
        "name": "decision_function_shape"
      },
      {
        "default": false,
        "description": "If true, ``decision_function_shape='ovr'``, and number of classes > 2,\n:term:`predict` will break ties according to the confidence values of\n:term:`decision_function`; otherwise the first class among the tied\nclasses is returned. Please note that breaking ties comes at a\nrelatively high computational cost compared to a simple predict.\n\n.. versionadded:: 0.22\n",
        "name": "break_ties",
        "type": "boolean"
      },
      {
        "default": null,
        "description": "Controls the pseudo random number generation for shuffling the data for\nprobability estimates. Ignored when `probability` is False.\nPass an int for reproducible output across multiple function calls.\nSee :term:`Glossary <random_state>`.\n",
        "name": "random_state"
      }
    ]
  },
  {
    "name": "sklearn.svm.SVC",
    "description": "C-Support Vector Classification.\n\nThe implementation is based on libsvm. The fit time scales at least\nquadratically with the number of samples and may be impractical\nbeyond tens of thousands of samples. For large datasets\nconsider using :class:`~sklearn.svm.LinearSVC` or\n:class:`~sklearn.linear_model.SGDClassifier` instead, possibly after a\n:class:`~sklearn.kernel_approximation.Nystroem` transformer or\nother :ref:`kernel_approximation`.\n\nThe multiclass support is handled according to a one-vs-one scheme.\n\nFor details on the precise mathematical formulation of the provided\nkernel functions and how `gamma`, `coef0` and `degree` affect each\nother, see the corresponding section in the narrative documentation:\n:ref:`svm_kernels`.\n\nTo learn how to tune SVC's hyperparameters, see the following example:\n:ref:`sphx_glr_auto_examples_model_selection_plot_nested_cross_validation_iris.py`\n\nRead more in the :ref:`User Guide <svm_classification>`.\n",
    "attributes": [
      {
        "default": 1.0,
        "description": "Regularization parameter. The strength of the regularization is\ninversely proportional to C. Must be strictly positive. The penalty\nis a squared l2 penalty. For an intuitive visualization of the effects\nof scaling the regularization parameter C, see\n:ref:`sphx_glr_auto_examples_svm_plot_svm_scale_c.py`.\n",
        "name": "C",
        "optional": true,
        "type": "float32"
      },
      {
        "default": "rbf",
        "description": "Specifies the kernel type to be used in the algorithm. If\nnone is given, 'rbf' will be used. If a callable is given it is used to\npre-compute the kernel matrix from data matrices; that matrix should be\nan array of shape ``(n_samples, n_samples)``. For an intuitive\nvisualization of different kernel types see\n:ref:`sphx_glr_auto_examples_svm_plot_svm_kernels.py`.\n",
        "name": "kernel",
        "optional": true,
        "type": "string"
      },
      {
        "default": 3,
        "description": "Degree of the polynomial kernel function ('poly').\nMust be non-negative. Ignored by all other kernels.\n",
        "name": "degree",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "scale",
        "description": "Kernel coefficient for 'rbf', 'poly' and 'sigmoid'.\n\n- if ``gamma='scale'`` (default) is passed then it uses\n1 / (n_features * X.var()) as value of gamma,\n- if 'auto', uses 1 / n_features\n- if float, must be non-negative.\n\n.. versionchanged:: 0.22\nThe default value of ``gamma`` changed from 'auto' to 'scale'.\n",
        "name": "gamma",
        "optional": true,
        "type": "float32"
      },
      {
        "default": 0.0,
        "description": "Independent term in kernel function.\nIt is only significant in 'poly' and 'sigmoid'.\n",
        "name": "coef0",
        "optional": true,
        "type": "float32"
      },
      {
        "default": false,
        "description": "Whether to enable probability estimates. This must be enabled prior\nto calling `fit`, will slow down that method as it internally uses\n5-fold cross-validation, and `predict_proba` may be inconsistent with\n`predict`. Read more in the :ref:`User Guide <scores_probabilities>`.\n",
        "name": "probability",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": true,
        "description": "Whether to use the shrinking heuristic.\nSee the :ref:`User Guide <shrinking_svm>`.\n",
        "name": "shrinking",
        "optional": true,
        "type": "boolean"
      },
      {
        "default": 0.001,
        "description": "Tolerance for stopping criterion.\n",
        "name": "tol",
        "optional": true,
        "type": "float32"
      },
      {
        "default": 200.0,
        "description": "Specify the size of the kernel cache (in MB).\n",
        "name": "cache_size",
        "optional": true,
        "type": "float32"
      },
      {
        "default": null,
        "description": "Set the parameter C of class i to class_weight[i]*C for\nSVC. If not given, all classes are supposed to have\nweight one.\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``.\n",
        "name": "class_weight",
        "optional": true
      },
      {
        "default": false,
        "description": "Enable verbose output. Note that this setting takes advantage of a\nper-process runtime setting in libsvm that, if enabled, may not work\nproperly in a multithreaded context.\n",
        "name": "verbose",
        "type": "boolean"
      },
      {
        "default": -1,
        "description": "Hard limit on iterations within solver, or -1 for no limit.\n",
        "name": "max_iter",
        "optional": true,
        "type": "int32"
      },
      {
        "default": "ovr",
        "description": "Whether to return a one-vs-rest ('ovr') decision function of shape\n(n_samples, n_classes) as all other classifiers, or the original\none-vs-one ('ovo') decision function of libsvm which has shape\n(n_samples, n_classes * (n_classes - 1) / 2). However, note that\ninternally, one-vs-one ('ovo') is always used as a multi-class strategy\nto train models; an ovr matrix is only constructed from the ovo matrix.\nThe parameter is ignored for binary classification.\n\n.. versionchanged:: 0.19\ndecision_function_shape is 'ovr' by default.\n\n.. versionadded:: 0.17\n*decision_function_shape='ovr'* is recommended.\n\n.. versionchanged:: 0.17\nDeprecated *decision_function_shape='ovo' and None*.\n",
        "name": "decision_function_shape"
      },
      {
        "default": null,
        "description": "Controls the pseudo random number generation for shuffling the data for\nprobability estimates. Ignored when `probability` is False.\nPass an int for reproducible output across multiple function calls.\nSee :term:`Glossary <random_state>`.\n",
        "name": "random_state",
        "optional": true,
        "type": "int32"
      },
      {
        "default": false,
        "description": "If true, ``decision_function_shape='ovr'``, and number of classes > 2,\n:term:`predict` will break ties according to the confidence values of\n:term:`decision_function`; otherwise the first class among the tied\nclasses is returned. Please note that breaking ties comes at a\nrelatively high computational cost compared to a simple predict.\n\n.. versionadded:: 0.22\n",
        "name": "break_ties",
        "optional": true,
        "type": "boolean"
      }
    ]
  },
  {
    "name": "sklearn.tree.tree.DecisionTreeClassifier",
    "description": "A decision tree classifier.\n\nRead more in the :ref:`User Guide <tree>`.\n",
    "attributes": [
      {
        "default": "\"gini\"",
        "description": "The function to measure the quality of a split. Supported criteria are\n\"gini\" for the Gini impurity and \"entropy\" for the information gain.\n",
        "name": "criterion"
      },
      {
        "default": "\"best\"",
        "description": "The strategy used to choose the split at each node. Supported\nstrategies are \"best\" to choose the best split and \"random\" to choose\nthe best random split.\n",
        "name": "splitter"
      },
      {
        "default": null,
        "description": "The maximum depth of the tree. If None, then nodes are expanded until\nall leaves are pure or until all leaves contain less than\nmin_samples_split samples.\n",
        "name": "max_depth",
        "type": "int32"
      },
      {
        "default": "2",
        "description": "The minimum number of samples required to split an internal node:\n\n- If int, then consider `min_samples_split` as the minimum number.\n- If float, then `min_samples_split` is a fraction and\n`ceil(min_samples_split * n_samples)` are the minimum\nnumber of samples for each split.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_split"
      },
      {
        "default": "1",
        "description": "The minimum number of samples required to be at a leaf node.\nA split point at any depth will only be considered if it leaves at\nleast ``min_samples_leaf`` training samples in each of the left and\nright branches.  This may have the effect of smoothing the model,\nespecially in regression.\n\n- If int, then consider `min_samples_leaf` as the minimum number.\n- If float, then `min_samples_leaf` is a fraction and\n`ceil(min_samples_leaf * n_samples)` are the minimum\nnumber of samples for each node.\n\n.. versionchanged:: 0.18\nAdded float values for fractions.\n",
        "name": "min_samples_leaf"
      },
      {
        "default": 0,
        "description": "The minimum weighted fraction of the sum total of weights (of all\nthe input samples) required to be at a leaf node. Samples have\nequal weight when sample_weight is not provided.\n",
        "name": "min_weight_fraction_leaf",
        "type": "float32"
      },
      {
        "default": null,
        "description": "The number of features to consider when looking for the best split:\n\n- If int, then consider `max_features` features at each split.\n- If float, then `max_features` is a fraction and\n`int(max_features * n_features)` features are considered at each\nsplit.\n- If \"auto\", then `max_features=sqrt(n_features)`.\n- If \"sqrt\", then `max_features=sqrt(n_features)`.\n- If \"log2\", then `max_features=log2(n_features)`.\n- If None, then `max_features=n_features`.\n\nNote: the search for a split does not stop until at least one\nvalid partition of the node samples is found, even if it requires to\neffectively inspect more than ``max_features`` features.\n",
        "name": "max_features",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Controls the randomness of the estimator. The features are always\nrandomly permuted at each split, even if ``splitter`` is set to\n``\"best\"``. When ``max_features < n_features``, the algorithm will\nselect ``max_features`` at random at each split before finding the best\nsplit among them. But the best found split may vary across different\nruns, even if ``max_features=n_features``. That is the case, if the\nimprovement of the criterion is identical for several splits and one\nsplit has to be selected at random. To obtain a deterministic behaviour\nduring fitting, ``random_state`` has to be fixed to an integer.\nSee :term:`Glossary <random_state>` for details.\n",
        "name": "random_state",
        "type": "int32"
      },
      {
        "default": null,
        "description": "Grow a tree with ``max_leaf_nodes`` in best-first fashion.\nBest nodes are defined as relative reduction in impurity.\nIf None then unlimited number of leaf nodes.\n",
        "name": "max_leaf_nodes",
        "type": "int32"
      },
      {
        "default": 0,
        "description": "A node will be split if this split induces a decrease of the impurity\ngreater than or equal to this value.\n\nThe weighted impurity decrease equation is the following::\n\nN_t / N * (impurity - N_t_R / N_t * right_impurity\n- N_t_L / N_t * left_impurity)\n\nwhere ``N`` is the total number of samples, ``N_t`` is the number of\nsamples at the current node, ``N_t_L`` is the number of samples in the\nleft child, and ``N_t_R`` is the number of samples in the right child.\n\n``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,\nif ``sample_weight`` is passed.\n\n.. versionadded:: 0.19\n",
        "name": "min_impurity_decrease",
        "type": "float32"
      },
      {
        "default": 0,
        "description": "Threshold for early stopping in tree growth. A node will split\nif its impurity is above the threshold, otherwise it is a leaf.\n\n.. deprecated:: 0.19\n``min_impurity_split`` has been deprecated in favor of\n``min_impurity_decrease`` in 0.19. The default value of\n``min_impurity_split`` has changed from 1e-7 to 0 in 0.23 and it\nwill be removed in 0.25. Use ``min_impurity_decrease`` instead.\n",
        "name": "min_impurity_split",
        "type": "float32"
      },
      {
        "default": null,
        "description": "Weights associated with classes in the form ``{class_label: weight}``.\nIf None, all classes are supposed to have weight one. For\nmulti-output problems, a list of dicts can be provided in the same\norder as the columns of y.\n\nNote that for multioutput (including multilabel) weights should be\ndefined for each class of every column in its own dict. For example,\nfor four-class multilabel classification weights should be\n[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of\n[{1:1}, {2:5}, {3:1}, {4:1}].\n\nThe \"balanced\" mode uses the values of y to automatically adjust\nweights inversely proportional to class frequencies in the input data\nas ``n_samples / (n_classes * np.bincount(y))``\n\nFor multi-output, the weights of each column of y will be multiplied.\n\nNote that these weights will be multiplied with sample_weight (passed\nthrough the fit method) if sample_weight is specified.\n",
        "name": "class_weight"
      },
      {
        "default": "deprecated",
        "description": "This parameter is deprecated and will be removed in v0.24.\n\n.. deprecated:: 0.22\n",
        "name": "presort"
      },
      {
        "default": "0.0",
        "description": "Complexity parameter used for Minimal Cost-Complexity Pruning. The\nsubtree with the largest cost complexity that is smaller than\n``ccp_alpha`` will be chosen. By default, no pruning is performed. See\n:ref:`minimal_cost_complexity_pruning` for details.\n\n.. versionadded:: 0.22\n",
        "name": "ccp_alpha"
      }
    ]
  }
]