Note

Go to the end to download the full example code.

The skore API#

Skore has three types of reports: EstimatorReport (single train-test evaluation), CrossValidationReport (cross-validation), and ComparisonReport (comparing several estimators). All three are created via evaluate() by passing an estimator (or a list or dict of named estimators for comparison), the data X and y, and a splitter that controls the evaluation strategy.

This example showcases the unified API shared by these reports: they expose the same accessors (data, metrics, inspection). Methods that produce a visualization return a Display object with plot(), frame(), set_style(), and help().

Three report types, one API#

evaluate() returns one of three report types depending on its splitter argument: an EstimatorReport when splitter is a float or "prefit", a CrossValidationReport when splitter is an integer or a scikit-learn cross-validator (e.g. KFold, StratifiedKFold), or a ComparisonReport when passing a list or dict of estimators. All three respect the same accessor layout where applicable:

data: dataset analysis
metrics: performance metrics and related displays (e.g. ROC, confusion matrix)
inspection: model inspection (e.g. coefficients, feature importance)

The data accessor is not available on ComparisonReport because compared models may use different input data; you can still inspect each underlying report. Methods on these accessors return Display objects with a common interface.

First report: single train-test split#

We call evaluate() with the default splitter=0.2 to get an EstimatorReport. The accessors and display API shown below are the same for the other report types.

from sklearn.datasets import load_breast_cancer
from sklearn.ensemble import RandomForestClassifier
from sklearn.linear_model import LogisticRegression
from skore import compare, evaluate
from skrub import tabular_pipeline

X, y = load_breast_cancer(return_X_y=True, as_frame=True)
estimator = tabular_pipeline(LogisticRegression())

report = evaluate(estimator, X, y, splitter=0.2)

Data accessor: `report.data.summarize()` returns a display#

The data accessor provides dataset summaries. Its summarize() method returns a TableReportDisplay.

data_display = report.data.summarize()
data_display.help()

Every display implements the same API. You can:

Plot it (with optional backend and style):

data_display.plot(kind="dist", x="mean radius", y="mean texture")

<Figure size 640x480 with 1 Axes>

You can set the style of the plot via set_style() and then call plot():

data_display.set_style(scatterplot_kwargs={"color": "orange", "alpha": 1.0})
data_display.plot(kind="dist", x="mean radius", y="mean texture")

<Figure size 640x480 with 1 Axes>

Export the underlying data as pandas objects:

data_display.frame()

	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	radius error	texture error	perimeter error	area error	smoothness error	compactness error	concavity error	concave points error	symmetry error	fractal dimension error	worst radius	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
0	10.05	17.53	64.41	310.8	0.10070	0.07326	0.02511	0.01775	0.1890	0.06331	0.2619	2.0150	1.778	16.85	0.007803	0.01449	0.01690	0.008043	0.02100	0.002778	11.16	26.84	71.98	384.0	0.1402	0.14020	0.1055	0.06499	0.2894	0.07664	1
1	10.80	21.98	68.79	359.9	0.08801	0.05743	0.03614	0.01404	0.2016	0.05977	0.3077	1.6210	2.240	20.20	0.006543	0.02148	0.02991	0.010450	0.01844	0.002690	12.76	32.04	83.69	489.5	0.1303	0.16960	0.1927	0.07485	0.2965	0.07662	1
2	16.14	14.86	104.30	800.0	0.09495	0.08501	0.05500	0.04528	0.1735	0.05875	0.2387	0.6372	1.729	21.83	0.003958	0.01246	0.01831	0.008747	0.01500	0.001621	17.71	19.58	115.90	947.9	0.1206	0.17220	0.2310	0.11290	0.2778	0.07012	1
3	12.18	17.84	77.79	451.1	0.10450	0.07057	0.02490	0.02941	0.1900	0.06635	0.3661	1.5110	2.410	24.44	0.005433	0.01179	0.01131	0.015190	0.02220	0.003408	12.83	20.92	82.14	495.2	0.1140	0.09358	0.0498	0.05882	0.2227	0.07376	1
4	12.25	22.44	78.18	466.5	0.08192	0.05200	0.01714	0.01261	0.1544	0.05976	0.2239	1.1390	1.577	18.04	0.005096	0.01205	0.00941	0.004551	0.01608	0.002399	14.17	31.99	92.74	622.9	0.1256	0.18040	0.1230	0.06335	0.3100	0.08203	1
...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...	...
564	17.42	25.56	114.50	948.0	0.10060	0.11460	0.16820	0.06597	0.1308	0.05866	0.5296	1.6670	3.767	58.53	0.031130	0.08555	0.14380	0.039270	0.02175	0.012560	18.07	28.07	120.40	1021.0	0.1243	0.17930	0.2803	0.10990	0.1603	0.06818	0
565	12.75	16.70	82.51	493.8	0.11250	0.11170	0.03880	0.02995	0.2120	0.06623	0.3834	1.0030	2.495	28.62	0.007509	0.01561	0.01977	0.009199	0.01805	0.003629	14.45	21.74	93.63	624.1	0.1475	0.19790	0.1423	0.08045	0.3071	0.08557	1
566	20.18	19.54	133.80	1250.0	0.11330	0.14890	0.21330	0.12590	0.1724	0.06053	0.4331	1.0010	3.008	52.49	0.009087	0.02715	0.05546	0.019100	0.02451	0.004005	22.03	25.07	146.00	1479.0	0.1665	0.29420	0.5308	0.21730	0.3032	0.08075	0
567	18.31	20.58	120.80	1052.0	0.10680	0.12480	0.15690	0.09451	0.1860	0.05941	0.5449	0.9225	3.218	67.36	0.006176	0.01877	0.02913	0.010460	0.01559	0.002725	21.86	26.20	142.20	1493.0	0.1492	0.25360	0.3759	0.15100	0.3074	0.07863	0
568	15.04	16.74	98.73	689.4	0.09883	0.13640	0.07721	0.06142	0.1668	0.06869	0.3720	0.8423	2.304	34.84	0.004123	0.01819	0.01996	0.010040	0.01055	0.003237	16.76	20.43	109.70	856.9	0.1135	0.21760	0.1856	0.10180	0.2177	0.08549	1

569 rows × 31 columns

Metrics accessor: same idea, same display API#

The metrics accessor exposes methods such as confusion_matrix(), roc_curve(), precision_recall(), and prediction_error(). Each returns a display (e.g. ConfusionMatrixDisplay) with the same interface: plot(), frame(), set_style(), help().

metrics_display = report.metrics.confusion_matrix()
metrics_display.help()

metrics_display.frame()

	true_label	predicted_label	value
0	0	0	45
1	0	1	2
2	1	0	2
3	1	1	65

Draw the confusion matrix by calling plot():

_ = metrics_display.plot()

Inspection accessor#

The inspection accessor exposes model-specific displays (e.g. coefficients() for linear models, impurity_decrease() for trees). These also return Display objects with the same plot(), frame(), set_style(), and help() methods.

inspection_display = report.inspection.coefficients()
_ = inspection_display.plot(select_k=15, sorting_order="descending")

Second report type: cross-validation#

Using the same evaluate() with an integer splitter returns a CrossValidationReport. The same accessors and display API apply; only the way the report was built changes.

cv_report = evaluate(estimator, X, y, splitter=3)

Again: data, metrics, and inspection return displays with plot(), frame(), and set_style().

cv_report.data.summarize().plot(kind="dist", x="mean radius", y="mean texture")

<Figure size 640x480 with 1 Axes>

_ = cv_report.metrics.confusion_matrix().plot()

_ = cv_report.inspection.coefficients().plot(select_k=10, sorting_order="descending")

Third report type: comparison#

Skore makes it possible to compare several estimators side by side with a ComparisonReport. Pass a list or dict of estimators to evaluate() along with a single X and y; each model is evaluated on the same data. The resulting report exposes the same metrics and inspection accessors as the other report types (there is no data accessor, because compared models may rely on different inputs). Methods on these accessors still return Display objects, so the display API is unchanged.

comparison_report = evaluate(
    [
        tabular_pipeline(LogisticRegression()),
        tabular_pipeline(RandomForestClassifier()),
    ],
    X,
    y,
    splitter=0.2,
)
comparison_report

Pipeline(steps=[('tablevectorizer',
                 TableVectorizer(datetime=DatetimeEncoder(periodic_encoding='spline'))),
                ('simpleimputer', SimpleImputer(add_indicator=True)),
                ('squashingscaler', SquashingScaler(max_absolute_value=5)),
                ('logisticregression', LogisticRegression())])

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

Pipeline

?Documentation for PipelineiFitted

Parameters

	steps steps: list of tuples List of (name of step, estimator) tuples that are to be chained in sequential order. To be compatible with the scikit-learn API, all steps must define `fit`. All non-last steps must also define `transform`. See :ref:`Combining Estimators <combining_estimators>` for more details.	[('tablevectorizer', ...), ('simpleimputer', ...), ...]
	transform_input transform_input: list of str, default=None The names of the :term:`metadata` parameters that should be transformed by the pipeline before passing it to the step consuming it. This enables transforming some input arguments to ``fit`` (other than ``X``) to be transformed by the steps of the pipeline up to the step which requires them. Requirement is defined via :ref:`metadata routing <metadata_routing>`. For instance, this can be used to pass a validation set through the pipeline. You can only set this if metadata routing is enabled, which you can enable using ``sklearn.set_config(enable_metadata_routing=True)``. .. versionadded:: 1.6	None
	memory memory: str or object with the joblib.Memory interface, default=None Used to cache the fitted transformers of the pipeline. The last step will never be cached, even if it is a transformer. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute ``named_steps`` or ``steps`` to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming. See :ref:`sphx_glr_auto_examples_neighbors_plot_caching_nearest_neighbors.py` for an example on how to enable caching.	None
	verbose verbose: bool, default=False If True, the time elapsed while fitting each step will be printed as it is completed.	False

Fitted attributes

Name	Type	Value
classes_ classes_: ndarray of shape (n_classes,) The classes labels. Only exist if the last step of the pipeline is a classifier.	ndarray[int64](2,)	[0,1]
feature_names_in_ feature_names_in_: ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 1.0	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
n_features_in_ n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24	int	30

tablevectorizer: TableVectorizer

?Documentation for tablevectorizer: TableVectorizer

Parameters

	low_cardinality low_cardinality: transformer, "passthrough" or "drop", default=OneHotEncoder instance The transformer for string or categorical columns with strictly fewer than ``cardinality_threshold`` unique values. By default, we use a :class:`~sklearn.preprocessing.OneHotEncoder` that ignores unknown categories and drop one of the transformed columns if the feature contains only 2 categories.	OneHotEncoder..._output=False)
	high_cardinality high_cardinality: transformer, "passthrough" or "drop", default=StringEncoder instance The transformer for string or categorical columns with at least ``cardinality_threshold`` unique values. The default is a :class:`~skrub.StringEncoder` with 30 components (30 output columns for each input). .. versionchanged:: 0.6.0 The default ``high_cardinality`` encoder has been changed from :class:`~skrub.GapEncoder` to :class:`~skrub.StringEncoder`.	StringEncoder()
	numeric numeric: transformer, "passthrough" or "drop", default="passthrough" The transformer for numeric columns (floats, ints, booleans).	PassThrough()
	datetime datetime: transformer, "passthrough" or "drop", default=DatetimeEncoder instance The transformer for date and datetime columns. By default, we use a :class:`~skrub.DatetimeEncoder`.	DatetimeEncod...ding='spline')
	cardinality_threshold cardinality_threshold: int, default=40 String and categorical columns with a number of unique values strictly smaller than this threshold are handled by the transformer ``low_cardinality``, the rest are handled by the transformer ``high_cardinality``.	40
	specific_transformers specific_transformers: list of (transformer, list of column names) pairs, default=() Override the categories above for the given columns and force using the specified transformer. This disables any preprocessing usually done by the TableVectorizer; the columns are passed to the transformer without any modification. A column is not allowed to appear twice in ``specific_transformers``. Consider wrapping the ``TableVectorizer`` in :class:`~skrub.ApplyToCols` to select or exclude specific columns from the processing. Alternatively, the :ref:`skrub Data Ops <user_guide_data_ops_index>` allows for more complex pre-processing.	()
	drop_null_fraction drop_null_fraction: float or None, default=1.0 Fraction of null above which the column is dropped. If `drop_null_fraction` is set to ``1.0``, the column is dropped if it contains only nulls or NaNs (this is the default behavior). If `drop_null_fraction` is a number in ``[0.0, 1.0)``, the column is dropped if the fraction of nulls is strictly larger than `drop_null_fraction`. If `drop_null_fraction` is ``None``, this selection is disabled: no columns are dropped based on the number of null values they contain.	1.0
	drop_if_constant drop_if_constant: bool, default=False If set to true, drop columns that contain a single unique value. Note that missing values are considered as one additional distinct value.	False
	drop_if_unique drop_if_unique: bool, default=False If set to true, drop columns that contain only unique values, i.e., the number of unique values is equal to the number of rows in the column. Numeric columns are never dropped. .. deprecated:: 0.9.0 This functionality can drop informative columns and is unlikely to be of use in practice. It is therefore deprecated and will be removed in a future version.	False
	datetime_format datetime_format: str, default=None The format to use when parsing dates. If None, the format is inferred.	None
	null_strings null_strings: str or sequence of str, default=None Additional strings to consider as null values, beyond the default list.	None
	n_jobs n_jobs: int, default=None Number of jobs to run in parallel. ``None`` means 1 unless in a joblib ``parallel_backend`` context. ``-1`` means using all processors.	None

Fitted attributes

Name	Type	Value
all_outputs_ all_outputs_: list of str The names of the output columns.	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
all_processing_steps_ all_processing_steps_: dict Maps the name of each column to a list of all the processing steps that were applied to it. Those steps may include some pre-processing transformations such as converting strings to datetimes or numbers, the main transformer (e.g. the :class:`~skrub.DatetimeEncoder`), and a post-processing step casting the main transformer's output to :obj:`numpy.float32`. See the "Examples" section below for details.	dict	{'ar...or': [DropUninformative(), ToFloat(), PassThrough(), {'area error': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'compactness...r': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'concave poi...r': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'concavity error': ToFloat()}], ...}
column_to_kind_ column_to_kind_: dict Maps each column name to the kind (``"high_cardinality"``, ``"low_cardinality"``, ``"specific"``, etc.) it was assigned.	dict	{'ar...or': 'numeric', 'co...or': 'numeric', 'co...or': 'numeric', 'co...or': 'numeric', ...}
feature_names_in_ feature_names_in_: list of str The names of the input columns, after applying some cleaning (casting all column names to strings and deduplication).	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
input_to_outputs_ input_to_outputs_: dict Maps the name of each input column to the names of the corresponding output columns.	dict	{'ar...or': ['ar...or'], 'co...or': ['co...or'], 'co...or': ['co...or'], 'co...or': ['co...or'], ...}
kind_to_columns_ kind_to_columns_: dict The reverse of ``column_to_kind_``: maps each kind of column (``"high_cardinality"``, ``"low_cardinality"``, etc.) to a list of column names. For example ``kind_to_columns['datetime']`` contains the names of all datetime columns.	dict	{'da...me': [], 'hi...ty': [], 'lo...ty': [], 'numeric': ['me...us', 'me...re', 'me...er', 'me...ea', ...], ...}
n_features_in_ n_features_in_: int The number of input columns.	int	30
output_to_input_ output_to_input_: dict The reverse of ``input_to_outputs_``: maps the name of each output column to the name of the column in the input dataframe from which it was derived.	dict	{'ar...or': 'ar...or', 'co...or': 'co...or', 'co...or': 'co...or', 'co...or': 'co...or', ...}
transformers_ transformers_: dict Maps the name of each column to the fitted transformer that was applied to it.	dict	{'ar...or': PassThrough(), 'co...or': PassThrough(), 'co...or': PassThrough(), 'co...or': PassThrough(), ...}

numeric

['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']

PassThrough

Parameters

datetime

DatetimeEncoder

?Documentation for DatetimeEncoder

Parameters

	periodic_encoding periodic_encoding: 'circular', 'spline', or None, default=None Add periodic features with different granularities. Add periodic features using either trigonometric (``circular``) or ``spline`` encoding. If ``None``, no periodic encoding is applied.	'spline'
	resolution resolution: str or None, default="hour" If a string, extract up to this resolution. Must be "year", "month", "day", "hour", "minute", "second", "microsecond", or "nanosecond". For example, ``resolution="day"`` generates the features "year", "month", and "day" only. If the input column contains dates with no time information, time features ("hour", "minute", … ) are never extracted. If ``None``, the features listed above are not extracted (but day of the week and total seconds may still be extracted, see below).	'hour'
	add_weekday add_weekday: bool, default=False Extract the day of the week as a numerical feature from 1 (Monday) to 7 (Sunday).	False
	add_total_seconds add_total_seconds: bool, default=True Add the total number of seconds since the Unix epoch (00:00:00 UTC on 1 January 1970).	True
	add_day_of_year add_day_of_year: bool, default=False Add the day of year (ordinal day) as an integer in the range 1 to 365 (or 366 in the case of leap years). January 1st will be day 1, December 31st will be day 365 on non-leap years.	False

low_cardinality

OneHotEncoder

?Documentation for OneHotEncoder

Parameters

	drop drop: {'first', 'if_binary'} or an array-like of shape (n_features,), default=None Specifies a methodology to use to drop one of the categories per feature. This is useful in situations where perfectly collinear features cause problems, such as when feeding the resulting data into an unregularized linear regression model. However, dropping one category breaks the symmetry of the original representation and can therefore induce a bias in downstream models, for instance for penalized linear classification or regression models. - None : retain all features (the default). - 'first' : drop the first category in each feature. If only one category is present, the feature will be dropped entirely. - 'if_binary' : drop the first category in each feature with two categories. Features with 1 or more than 2 categories are left intact. - array : ``drop[i]`` is the category in feature ``X[:, i]`` that should be dropped. When `max_categories` or `min_frequency` is configured to group infrequent categories, the dropping behavior is handled after the grouping. .. versionadded:: 0.21 The parameter `drop` was added in 0.21. .. versionchanged:: 0.23 The option `drop='if_binary'` was added in 0.23. .. versionchanged:: 1.1 Support for dropping infrequent categories.	'if_binary'
	sparse_output sparse_output: bool, default=True When ``True``, it returns a SciPy sparse matrix/array in "Compressed Sparse Row" (CSR) format. .. versionadded:: 1.2 `sparse` was renamed to `sparse_output`	False
	dtype dtype: number type, default=np.float64 Desired dtype of output.	'float32'
	handle_unknown handle_unknown: {'error', 'ignore', 'infrequent_if_exist', 'warn'}, default='error' Specifies the way unknown categories are handled during :meth:`transform`. - 'error' : Raise an error if an unknown category is present during transform. - 'ignore' : When an unknown category is encountered during transform, the resulting one-hot encoded columns for this feature will be all zeros. In the inverse transform, an unknown category will be denoted as None. - 'infrequent_if_exist' : When an unknown category is encountered during transform, the resulting one-hot encoded columns for this feature will map to the infrequent category if it exists. The infrequent category will be mapped to the last position in the encoding. During inverse transform, an unknown category will be mapped to the category denoted `'infrequent'` if it exists. If the `'infrequent'` category does not exist, then :meth:`transform` and :meth:`inverse_transform` will handle an unknown category as with `handle_unknown='ignore'`. Infrequent categories exist based on `min_frequency` and `max_categories`. Read more in the :ref:`User Guide <encoder_infrequent_categories>`. - 'warn' : When an unknown category is encountered during transform a warning is issued, and the encoding then proceeds as described for `handle_unknown="infrequent_if_exist"`. .. versionchanged:: 1.1 `'infrequent_if_exist'` was added to automatically handle unknown categories and infrequent categories. .. versionadded:: 1.6 The option `"warn"` was added in 1.6.	'ignore'
	categories categories: 'auto' or a list of array-like, default='auto' Categories (unique values) per feature: - 'auto' : Determine categories automatically from the training data. - list : ``categories[i]`` holds the categories expected in the ith column. The passed categories should not mix strings and numeric values within a single feature, and should be sorted in case of numeric values. The used categories can be found in the ``categories_`` attribute. .. versionadded:: 0.20	'auto'
	min_frequency min_frequency: int or float, default=None Specifies the minimum frequency below which a category will be considered infrequent. - If `int`, categories with a smaller cardinality will be considered infrequent. - If `float`, categories with a smaller cardinality than `min_frequency * n_samples` will be considered infrequent. .. versionadded:: 1.1 Read more in the :ref:`User Guide <encoder_infrequent_categories>`.	None
	max_categories max_categories: int, default=None Specifies an upper limit to the number of output features for each input feature when considering infrequent categories. If there are infrequent categories, `max_categories` includes the category representing the infrequent categories along with the frequent categories. If `None`, there is no limit to the number of output features. .. versionadded:: 1.1 Read more in the :ref:`User Guide <encoder_infrequent_categories>`.	None
	feature_name_combiner feature_name_combiner: "concat" or callable, default="concat" Callable with signature `def callable(input_feature, category)` that returns a string. This is used to create feature names to be returned by :meth:`get_feature_names_out`. `"concat"` concatenates encoded feature name and category with `feature + "_" + str(category)`.E.g. feature X with values 1, 6, 7 create feature names `X_1, X_6, X_7`. .. versionadded:: 1.3	'concat'

high_cardinality

StringEncoder

?Documentation for StringEncoder

Parameters

	n_components n_components: int, default=30 Number of components to be used for the singular value decomposition (SVD). Must be a positive integer.	30
	vectorizer vectorizer: str, "tfidf" or "hashing", default="tfidf" Vectorizer to apply to the strings, either `tfidf` or `hashing` for scikit-learn TfidfVectorizer or HashingVectorizer respectively.	'tfidf'
	ngram_range ngram_range: tuple of (int, int) pairs, default=(3,4) The lower and upper boundary of the range of n-values for different n-grams to be extracted. All values of n such that min_n <= n <= max_n will be used. For example an ``ngram_range`` of ``(1, 1)`` means only unigrams, ``(1, 2)`` means unigrams and bigrams, and ``(2, 2)`` means only bigrams.	(3, ...)
	analyzer analyzer: str, "char", "word" or "char_wb", default="char_wb" Whether the feature should be made of word or character n-grams. Option ``char_wb`` creates character n-grams only from text inside word boundaries; n-grams at the edges of words are padded with space.	'char_wb'
	stop_words stop_words: {'english'}, list, default=None If 'english', a built-in stop word list for English is used. There are several known issues with 'english' and you should consider an alternative (see `Using stop words <https://scikit-learn.org/stable/modules/feature_extraction.html#using-stop-words>`_). If a list, that list is assumed to contain stop words, all of which will be removed from the resulting tokens. Only applies if ``analyzer == 'word'``. If None, no stop words will be used.	None
	random_state random_state: int, RandomState instance or None, default=None Used during randomized svd. Pass an int for reproducible results across multiple function calls.	None
	vocabulary vocabulary: Mapping or iterable, default=None In case of "tfidf" vectorizer, the vocabulary mapping passed to the vectorizer. Either a Mapping (e.g., a dict) where keys are terms and values are indices in the feature matrix, or an iterable over terms.	None

30 features

mean radius

mean texture

mean perimeter

mean area

mean smoothness

mean compactness

mean concavity

mean concave points

mean symmetry

mean fractal dimension

radius error

texture error

perimeter error

area error

smoothness error

compactness error

concavity error

concave points error

symmetry error

fractal dimension error

worst radius

worst texture

worst perimeter

worst area

worst smoothness

worst compactness

worst concavity

worst concave points

worst symmetry

worst fractal dimension

SimpleImputer

?Documentation for SimpleImputer

Parameters

	add_indicator add_indicator: bool, default=False If True, a :class:`MissingIndicator` transform will stack onto output of the imputer's transform. This allows a predictive estimator to account for missingness despite imputation. If a feature has no missing values at fit/train time, the feature won't appear on the missing indicator even if there are missing values at transform/test time.	True
	missing_values missing_values: int, float, str, np.nan, None or pandas.NA, default=np.nan The placeholder for the missing values. All occurrences of `missing_values` will be imputed. For pandas' dataframes with nullable integer dtypes with missing values, `missing_values` can be set to either `np.nan` or `pd.NA`.	nan
	strategy strategy: str or Callable, default='mean' The imputation strategy. - If "mean", then replace missing values using the mean along each column. Can only be used with numeric data. - If "median", then replace missing values using the median along each column. Can only be used with numeric data. - If "most_frequent", then replace missing using the most frequent value along each column. Can be used with strings or numeric data. If there is more than one such value, only the smallest is returned. - If "constant", then replace missing values with fill_value. Can be used with strings or numeric data. - If an instance of Callable, then replace missing values using the scalar statistic returned by running the callable over a dense 1d array containing non-missing values of each column. .. versionadded:: 0.20 strategy="constant" for fixed value imputation. .. versionadded:: 1.5 strategy=callable for custom value imputation.	'mean'
	fill_value fill_value: str or numerical value, default=None When strategy == "constant", `fill_value` is used to replace all occurrences of missing_values. For string or object data types, `fill_value` must be a string. If `None`, `fill_value` will be 0 when imputing numerical data and "missing_value" for strings or object data types.	None
	copy copy: bool, default=True If True, a copy of X will be created. If False, imputation will be done in-place whenever possible. Note that, in the following cases, a new copy will always be made, even if `copy=False`: - If `X` is not an array of floating values; - If `X` is encoded as a CSR matrix; - If `add_indicator=True`.	True
	keep_empty_features keep_empty_features: bool, default=False If True, features that consist exclusively of missing values when `fit` is called are returned in results when `transform` is called. The imputed value is always `0` except when `strategy="constant"` in which case `fill_value` will be used instead. .. versionadded:: 1.2	False

Fitted attributes

Name	Type	Value
feature_names_in_ feature_names_in_: ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0	ndarray[object](30,)	['mean radius','mean texture','mean perimeter',...,'worst concave points', 'worst symmetry','worst fractal dimension']
indicator_ indicator_: :class:`~sklearn.impute.MissingIndicator` Indicator used to add binary indicators for missing values. `None` if `add_indicator=False`.	MissingIndicator	MissingIndica..._on_new=False)
n_features_in_ n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24	int	30
statistics_ statistics_: array of shape (n_features,) The imputation fill value for each feature. Computing statistics can result in `np.nan` values. During :meth:`transform`, features corresponding to `np.nan` statistics will be discarded.	ndarray[float64](30,)	[14.11,19.15,91.82,..., 0.11, 0.29, 0.08]

30 features

mean radius

mean texture

mean perimeter

mean area

mean smoothness

mean compactness

mean concavity

mean concave points

mean symmetry

mean fractal dimension

radius error

texture error

perimeter error

area error

smoothness error

compactness error

concavity error

concave points error

symmetry error

fractal dimension error

worst radius

worst texture

worst perimeter

worst area

worst smoothness

worst compactness

worst concavity

worst concave points

worst symmetry

worst fractal dimension

SquashingScaler

?Documentation for SquashingScaler

Parameters

	max_absolute_value max_absolute_value: float, default=3.0 Maximum absolute value that the transformed data can take.	5
	quantile_range quantile_range: tuple of float, default=(0.25, 0.75) The quantiles used to compute the scaling factor. The first value is the lower quantile and the second value is the upper quantile. The default values are the 25th and 75th percentiles, respectively. The quantiles are used to compute the scaling factor for the robust scaling step. The quantiles are computed from the finite values in the input column. If the two quantiles are equal, the scaling factor is computed from the 0th and 100th percentiles (i.e., the minimum and maximum values of the finite values in the input column).	(25.0, ...)

Fitted attributes

Name	Type	Value
minmax_cols_	ndarray[bool](30,)	[False,False,False,...,False,False,False]
minmax_scaler_	NoneType	None
n_features_in_	int	30
robust_cols_	ndarray[bool](30,)	[ True, True, True,..., True, True, True]
robust_scaler_	RobustScaler	RobustScaler()
zero_cols_	ndarray[bool](30,)	[False,False,False,...,False,False,False]

30 features

x0

x1

x2

x3

x4

x5

x6

x7

x8

x9

x10

x11

x12

x13

x14

x15

x16

x17

x18

x19

x20

x21

x22

x23

x24

x25

x26

x27

x28

x29

LogisticRegression

?Documentation for LogisticRegression

Parameters

	penalty penalty: {'l1', 'l2', 'elasticnet', None}, default='l2' Specify the norm of the penalty: - `None`: no penalty is added; - `'l2'`: add an L2 penalty term and it is the default choice; - `'l1'`: add an L1 penalty term; - `'elasticnet'`: both L1 and L2 penalty terms are added. .. warning:: Some penalties may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. .. versionadded:: 0.19 l1 penalty with SAGA solver (allowing 'multinomial' + L1) .. deprecated:: 1.8 `penalty` was deprecated in version 1.8 and will be removed in 1.10. Use `l1_ratio` and `C` instead. `l1_ratio=0` for `penalty='l2'`, `l1_ratio=1` for `penalty='l1'`, `l1_ratio` set to any float between 0 and 1 for `penalty='elasticnet'`, and `C=np.inf` for `penalty=None`.	'deprecated'
	C C: float, default=1.0 Inverse of regularization strength; must be a positive float. Like in support vector machines, smaller values specify stronger regularization. `C=np.inf` results in unpenalized logistic regression. For a visual example on the effect of tuning the `C` parameter with an L1 penalty, see: :ref:`sphx_glr_auto_examples_linear_model_plot_logistic_path.py`.	1.0
	l1_ratio l1_ratio: float, default=0.0 The Elastic-Net mixing parameter, with `0 <= l1_ratio <= 1`. Setting `l1_ratio=1` gives a pure L1-penalty, setting `l1_ratio=0` a pure L2-penalty. Any value between 0 and 1 gives an Elastic-Net penalty of the form `l1_ratio * L1 + (1 - l1_ratio) * L2`. .. warning:: Certain values of `l1_ratio`, i.e. some penalties, may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. .. versionchanged:: 1.8 Default value changed from None to 0.0. .. deprecated:: 1.8 `None` is deprecated and will be removed in version 1.10. Always use `l1_ratio` to specify the penalty type.	0.0
	dual dual: bool, default=False Dual (constrained) or primal (regularized, see also :ref:`this equation <regularized-logistic-loss>`) formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer `dual=False` when n_samples > n_features.	False
	tol tol: float, default=1e-4 Tolerance for stopping criteria.	0.0001
	fit_intercept fit_intercept: bool, default=True Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function.	True
	intercept_scaling intercept_scaling: float, default=1 Useful only when the solver `liblinear` is used and `self.fit_intercept` is set to `True`. In this case, `x` becomes `[x, self.intercept_scaling]`, i.e. a "synthetic" feature with constant value equal to `intercept_scaling` is appended to the instance vector. The intercept becomes ``intercept_scaling * synthetic_feature_weight``. .. note:: The synthetic feature weight is subject to L1 or L2 regularization as all other features. To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept) `intercept_scaling` has to be increased.	1
	class_weight class_weight: dict or 'balanced', default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))``. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. .. versionadded:: 0.17 class_weight='balanced'	None
	random_state random_state: int, RandomState instance, default=None Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the data. See :term:`Glossary <random_state>` for details.	None
	solver solver: {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'}, default='lbfgs' Algorithm to use in the optimization problem. Default is 'lbfgs'. To choose a solver, you might want to consider the following aspects: - 'lbfgs' is a good default solver because it works reasonably well for a wide class of problems. - For :term:`multiclass` problems (`n_classes >= 3`), all solvers except 'liblinear' minimize the full multinomial loss, 'liblinear' will raise an error. - 'newton-cholesky' is a good choice for `n_samples` >> `n_features * n_classes`, especially with one-hot encoded categorical features with rare categories. Be aware that the memory usage of this solver has a quadratic dependency on `n_features * n_classes` because it explicitly computes the full Hessian matrix. - For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones; - 'liblinear' can only handle binary classification by default. To apply a one-versus-rest scheme for the multiclass setting one can wrap it with the :class:`~sklearn.multiclass.OneVsRestClassifier`. .. warning:: The choice of the algorithm depends on the penalty chosen (`l1_ratio=0` for L2-penalty, `l1_ratio=1` for L1-penalty and `0 < l1_ratio < 1` for Elastic-Net) and on (multinomial) multiclass support: ================= ======================== ====================== solver l1_ratio multinomial multiclass ================= ======================== ====================== 'lbfgs' l1_ratio=0 yes 'liblinear' l1_ratio=1 or l1_ratio=0 no 'newton-cg' l1_ratio=0 yes 'newton-cholesky' l1_ratio=0 yes 'sag' l1_ratio=0 yes 'saga' 0<=l1_ratio<=1 yes ================= ======================== ====================== .. note:: 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from :mod:`sklearn.preprocessing`. .. seealso:: Refer to the :ref:`User Guide <Logistic_regression>` for more information regarding :class:`LogisticRegression` and more specifically the :ref:`Table <logistic_regression_solvers>` summarizing solver/penalty supports. .. versionadded:: 0.17 Stochastic Average Gradient (SAG) descent solver. Multinomial support in version 0.18. .. versionadded:: 0.19 SAGA solver. .. versionchanged:: 0.22 The default solver changed from 'liblinear' to 'lbfgs' in 0.22. .. versionadded:: 1.2 newton-cholesky solver. Multinomial support in version 1.6.	'lbfgs'
	max_iter max_iter: int, default=100 Maximum number of iterations taken for the solvers to converge.	100
	verbose verbose: int, default=0 For the liblinear and lbfgs solvers set verbose to any positive number for verbosity.	0
	warm_start warm_start: bool, default=False When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. Useless for liblinear solver. See :term:`the Glossary <warm_start>`. .. versionadded:: 0.17 warm_start to support lbfgs, newton-cg, sag, saga solvers.	False
	n_jobs n_jobs: int, default=None Does not have any effect. .. deprecated:: 1.8 `n_jobs` is deprecated in version 1.8 and will be removed in 1.10.	None

Fitted attributes

Name	Type	Value
classes_ classes_: ndarray of shape (n_classes, ) A list of class labels known to the classifier.	ndarray[int64](2,)	[0,1]
coef_ coef_: ndarray or CSR matrix of shape (1, n_features) or (n_classes, n_features) Coefficients of the features in the decision function. `coef_` is of shape (1, n_features) when the given problem is binary. By default, it will be created as a dense array, but can be turned to sparse (CSR format) through :meth:`sparsify` (which can be beneficial under L1 regularization when many coefficients are zero), and back to dense through :meth:`densify`.	ndarray[float32](1, 30)	[[-0.35,-0.78,-0.36,...,-1.05,-0.67,-0.75]]
intercept_ intercept_: ndarray of shape (1,) or (n_classes,) Intercept (a.k.a. bias) added to the decision function. If `fit_intercept` is set to False, the intercept is set to zero. `intercept_` is of shape (1,) when the given problem is binary.	ndarray[float32](1,)	[3.05]
n_features_in_ n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24	int	30
n_iter_ n_iter_: ndarray of shape (1, ) Actual number of iterations for all classes. .. versionchanged:: 0.20 In SciPy <= 1.0.0 the number of lbfgs iterations may exceed ``max_iter``. ``n_iter_`` will now report at most ``max_iter``.	ndarray[int32](1,)	[17]

Please enable javascript

The skrub table reports need javascript to display correctly. If you are displaying a report in a Jupyter notebook and you see this message, you may need to re-execute the cell or to trust the notebook (button on the top right or "File > Trust notebook").

Pipeline(steps=[('tablevectorizer',
                 TableVectorizer(low_cardinality=OrdinalEncoder(handle_unknown='use_encoded_value',
                                                                unknown_value=-1))),
                ('randomforestclassifier', RandomForestClassifier())])

In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.

Pipeline

?Documentation for PipelineiFitted

Parameters

	steps steps: list of tuples List of (name of step, estimator) tuples that are to be chained in sequential order. To be compatible with the scikit-learn API, all steps must define `fit`. All non-last steps must also define `transform`. See :ref:`Combining Estimators <combining_estimators>` for more details.	[('tablevectorizer', ...), ('randomforestclassifier', ...)]
	transform_input transform_input: list of str, default=None The names of the :term:`metadata` parameters that should be transformed by the pipeline before passing it to the step consuming it. This enables transforming some input arguments to ``fit`` (other than ``X``) to be transformed by the steps of the pipeline up to the step which requires them. Requirement is defined via :ref:`metadata routing <metadata_routing>`. For instance, this can be used to pass a validation set through the pipeline. You can only set this if metadata routing is enabled, which you can enable using ``sklearn.set_config(enable_metadata_routing=True)``. .. versionadded:: 1.6	None
	memory memory: str or object with the joblib.Memory interface, default=None Used to cache the fitted transformers of the pipeline. The last step will never be cached, even if it is a transformer. By default, no caching is performed. If a string is given, it is the path to the caching directory. Enabling caching triggers a clone of the transformers before fitting. Therefore, the transformer instance given to the pipeline cannot be inspected directly. Use the attribute ``named_steps`` or ``steps`` to inspect estimators within the pipeline. Caching the transformers is advantageous when fitting is time consuming. See :ref:`sphx_glr_auto_examples_neighbors_plot_caching_nearest_neighbors.py` for an example on how to enable caching.	None
	verbose verbose: bool, default=False If True, the time elapsed while fitting each step will be printed as it is completed.	False

Fitted attributes

Name	Type	Value
classes_ classes_: ndarray of shape (n_classes,) The classes labels. Only exist if the last step of the pipeline is a classifier.	ndarray[int64](2,)	[0,1]
feature_names_in_ feature_names_in_: ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Only defined if the underlying estimator exposes such an attribute when fit. .. versionadded:: 1.0	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
n_features_in_ n_features_in_: int Number of features seen during :term:`fit`. Only defined if the underlying first estimator in `steps` exposes such an attribute when fit. .. versionadded:: 0.24	int	30

tablevectorizer: TableVectorizer

?Documentation for tablevectorizer: TableVectorizer

Parameters

	low_cardinality low_cardinality: transformer, "passthrough" or "drop", default=OneHotEncoder instance The transformer for string or categorical columns with strictly fewer than ``cardinality_threshold`` unique values. By default, we use a :class:`~sklearn.preprocessing.OneHotEncoder` that ignores unknown categories and drop one of the transformed columns if the feature contains only 2 categories.	OrdinalEncode...nown_value=-1)
	high_cardinality high_cardinality: transformer, "passthrough" or "drop", default=StringEncoder instance The transformer for string or categorical columns with at least ``cardinality_threshold`` unique values. The default is a :class:`~skrub.StringEncoder` with 30 components (30 output columns for each input). .. versionchanged:: 0.6.0 The default ``high_cardinality`` encoder has been changed from :class:`~skrub.GapEncoder` to :class:`~skrub.StringEncoder`.	StringEncoder()
	numeric numeric: transformer, "passthrough" or "drop", default="passthrough" The transformer for numeric columns (floats, ints, booleans).	PassThrough()
	datetime datetime: transformer, "passthrough" or "drop", default=DatetimeEncoder instance The transformer for date and datetime columns. By default, we use a :class:`~skrub.DatetimeEncoder`.	DatetimeEncoder()
	cardinality_threshold cardinality_threshold: int, default=40 String and categorical columns with a number of unique values strictly smaller than this threshold are handled by the transformer ``low_cardinality``, the rest are handled by the transformer ``high_cardinality``.	40
	specific_transformers specific_transformers: list of (transformer, list of column names) pairs, default=() Override the categories above for the given columns and force using the specified transformer. This disables any preprocessing usually done by the TableVectorizer; the columns are passed to the transformer without any modification. A column is not allowed to appear twice in ``specific_transformers``. Consider wrapping the ``TableVectorizer`` in :class:`~skrub.ApplyToCols` to select or exclude specific columns from the processing. Alternatively, the :ref:`skrub Data Ops <user_guide_data_ops_index>` allows for more complex pre-processing.	()
	drop_null_fraction drop_null_fraction: float or None, default=1.0 Fraction of null above which the column is dropped. If `drop_null_fraction` is set to ``1.0``, the column is dropped if it contains only nulls or NaNs (this is the default behavior). If `drop_null_fraction` is a number in ``[0.0, 1.0)``, the column is dropped if the fraction of nulls is strictly larger than `drop_null_fraction`. If `drop_null_fraction` is ``None``, this selection is disabled: no columns are dropped based on the number of null values they contain.	1.0
	drop_if_constant drop_if_constant: bool, default=False If set to true, drop columns that contain a single unique value. Note that missing values are considered as one additional distinct value.	False
	drop_if_unique drop_if_unique: bool, default=False If set to true, drop columns that contain only unique values, i.e., the number of unique values is equal to the number of rows in the column. Numeric columns are never dropped. .. deprecated:: 0.9.0 This functionality can drop informative columns and is unlikely to be of use in practice. It is therefore deprecated and will be removed in a future version.	False
	datetime_format datetime_format: str, default=None The format to use when parsing dates. If None, the format is inferred.	None
	null_strings null_strings: str or sequence of str, default=None Additional strings to consider as null values, beyond the default list.	None
	n_jobs n_jobs: int, default=None Number of jobs to run in parallel. ``None`` means 1 unless in a joblib ``parallel_backend`` context. ``-1`` means using all processors.	None

Fitted attributes

Name	Type	Value
all_outputs_ all_outputs_: list of str The names of the output columns.	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
all_processing_steps_ all_processing_steps_: dict Maps the name of each column to a list of all the processing steps that were applied to it. Those steps may include some pre-processing transformations such as converting strings to datetimes or numbers, the main transformer (e.g. the :class:`~skrub.DatetimeEncoder`), and a post-processing step casting the main transformer's output to :obj:`numpy.float32`. See the "Examples" section below for details.	dict	{'ar...or': [DropUninformative(), ToFloat(), PassThrough(), {'area error': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'compactness...r': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'concave poi...r': ToFloat()}], 'co...or': [DropUninformative(), ToFloat(), PassThrough(), {'concavity error': ToFloat()}], ...}
column_to_kind_ column_to_kind_: dict Maps each column name to the kind (``"high_cardinality"``, ``"low_cardinality"``, ``"specific"``, etc.) it was assigned.	dict	{'ar...or': 'numeric', 'co...or': 'numeric', 'co...or': 'numeric', 'co...or': 'numeric', ...}
feature_names_in_ feature_names_in_: list of str The names of the input columns, after applying some cleaning (casting all column names to strings and deduplication).	list	['me...us', 'me...re', 'me...er', 'me...ea', ...]
input_to_outputs_ input_to_outputs_: dict Maps the name of each input column to the names of the corresponding output columns.	dict	{'ar...or': ['ar...or'], 'co...or': ['co...or'], 'co...or': ['co...or'], 'co...or': ['co...or'], ...}
kind_to_columns_ kind_to_columns_: dict The reverse of ``column_to_kind_``: maps each kind of column (``"high_cardinality"``, ``"low_cardinality"``, etc.) to a list of column names. For example ``kind_to_columns['datetime']`` contains the names of all datetime columns.	dict	{'da...me': [], 'hi...ty': [], 'lo...ty': [], 'numeric': ['me...us', 'me...re', 'me...er', 'me...ea', ...], ...}
n_features_in_ n_features_in_: int The number of input columns.	int	30
output_to_input_ output_to_input_: dict The reverse of ``input_to_outputs_``: maps the name of each output column to the name of the column in the input dataframe from which it was derived.	dict	{'ar...or': 'ar...or', 'co...or': 'co...or', 'co...or': 'co...or', 'co...or': 'co...or', ...}
transformers_ transformers_: dict Maps the name of each column to the fitted transformer that was applied to it.	dict	{'ar...or': PassThrough(), 'co...or': PassThrough(), 'co...or': PassThrough(), 'co...or': PassThrough(), ...}

numeric

['mean radius', 'mean texture', 'mean perimeter', 'mean area', 'mean smoothness', 'mean compactness', 'mean concavity', 'mean concave points', 'mean symmetry', 'mean fractal dimension', 'radius error', 'texture error', 'perimeter error', 'area error', 'smoothness error', 'compactness error', 'concavity error', 'concave points error', 'symmetry error', 'fractal dimension error', 'worst radius', 'worst texture', 'worst perimeter', 'worst area', 'worst smoothness', 'worst compactness', 'worst concavity', 'worst concave points', 'worst symmetry', 'worst fractal dimension']

PassThrough

Parameters

datetime

DatetimeEncoder

?Documentation for DatetimeEncoder

Parameters

	resolution resolution: str or None, default="hour" If a string, extract up to this resolution. Must be "year", "month", "day", "hour", "minute", "second", "microsecond", or "nanosecond". For example, ``resolution="day"`` generates the features "year", "month", and "day" only. If the input column contains dates with no time information, time features ("hour", "minute", … ) are never extracted. If ``None``, the features listed above are not extracted (but day of the week and total seconds may still be extracted, see below).	'hour'
	add_weekday add_weekday: bool, default=False Extract the day of the week as a numerical feature from 1 (Monday) to 7 (Sunday).	False
	add_total_seconds add_total_seconds: bool, default=True Add the total number of seconds since the Unix epoch (00:00:00 UTC on 1 January 1970).	True
	add_day_of_year add_day_of_year: bool, default=False Add the day of year (ordinal day) as an integer in the range 1 to 365 (or 366 in the case of leap years). January 1st will be day 1, December 31st will be day 365 on non-leap years.	False
	periodic_encoding periodic_encoding: 'circular', 'spline', or None, default=None Add periodic features with different granularities. Add periodic features using either trigonometric (``circular``) or ``spline`` encoding. If ``None``, no periodic encoding is applied.	None

low_cardinality

OrdinalEncoder

?Documentation for OrdinalEncoder

Parameters

	handle_unknown handle_unknown: {'error', 'use_encoded_value'}, default='error' When set to 'error' an error will be raised in case an unknown categorical feature is present during transform. When set to 'use_encoded_value', the encoded value of unknown categories will be set to the value given for the parameter `unknown_value`. In :meth:`inverse_transform`, an unknown category will be denoted as None. .. versionadded:: 0.24	'use_encoded_value'
	unknown_value unknown_value: int or np.nan, default=None When the parameter handle_unknown is set to 'use_encoded_value', this parameter is required and will set the encoded value of unknown categories. It has to be distinct from the values used to encode any of the categories in `fit`. If set to np.nan, the `dtype` parameter must be a float dtype. .. versionadded:: 0.24	-1
	categories categories: 'auto' or a list of array-like, default='auto' Categories (unique values) per feature: - 'auto' : Determine categories automatically from the training data. - list : ``categories[i]`` holds the categories expected in the ith column. The passed categories should not mix strings and numeric values, and should be sorted in case of numeric values. The used categories can be found in the ``categories_`` attribute.	'auto'
	dtype dtype: number type, default=np.float64 Desired dtype of output.	<class 'numpy.float64'>
	encoded_missing_value encoded_missing_value: int or np.nan, default=np.nan Encoded value of missing categories. If set to `np.nan`, then the `dtype` parameter must be a float dtype. .. versionadded:: 1.1	nan
	min_frequency min_frequency: int or float, default=None Specifies the minimum frequency below which a category will be considered infrequent. - If `int`, categories with a smaller cardinality will be considered infrequent. - If `float`, categories with a smaller cardinality than `min_frequency * n_samples` will be considered infrequent. .. versionadded:: 1.3 Read more in the :ref:`User Guide <encoder_infrequent_categories>`.	None
	max_categories max_categories: int, default=None Specifies an upper limit to the number of output categories for each input feature when considering infrequent categories. If there are infrequent categories, `max_categories` includes the category representing the infrequent categories along with the frequent categories. If `None`, there is no limit to the number of output features. `max_categories` do not take into account missing or unknown categories. Setting `unknown_value` or `encoded_missing_value` to an integer will increase the number of unique integer codes by one each. This can result in up to `max_categories + 2` integer codes. .. versionadded:: 1.3 Read more in the :ref:`User Guide <encoder_infrequent_categories>`.	None

high_cardinality

StringEncoder

?Documentation for StringEncoder

Parameters

	n_components n_components: int, default=30 Number of components to be used for the singular value decomposition (SVD). Must be a positive integer.	30
	vectorizer vectorizer: str, "tfidf" or "hashing", default="tfidf" Vectorizer to apply to the strings, either `tfidf` or `hashing` for scikit-learn TfidfVectorizer or HashingVectorizer respectively.	'tfidf'
	ngram_range ngram_range: tuple of (int, int) pairs, default=(3,4) The lower and upper boundary of the range of n-values for different n-grams to be extracted. All values of n such that min_n <= n <= max_n will be used. For example an ``ngram_range`` of ``(1, 1)`` means only unigrams, ``(1, 2)`` means unigrams and bigrams, and ``(2, 2)`` means only bigrams.	(3, ...)
	analyzer analyzer: str, "char", "word" or "char_wb", default="char_wb" Whether the feature should be made of word or character n-grams. Option ``char_wb`` creates character n-grams only from text inside word boundaries; n-grams at the edges of words are padded with space.	'char_wb'
	stop_words stop_words: {'english'}, list, default=None If 'english', a built-in stop word list for English is used. There are several known issues with 'english' and you should consider an alternative (see `Using stop words <https://scikit-learn.org/stable/modules/feature_extraction.html#using-stop-words>`_). If a list, that list is assumed to contain stop words, all of which will be removed from the resulting tokens. Only applies if ``analyzer == 'word'``. If None, no stop words will be used.	None
	random_state random_state: int, RandomState instance or None, default=None Used during randomized svd. Pass an int for reproducible results across multiple function calls.	None
	vocabulary vocabulary: Mapping or iterable, default=None In case of "tfidf" vectorizer, the vocabulary mapping passed to the vectorizer. Either a Mapping (e.g., a dict) where keys are terms and values are indices in the feature matrix, or an iterable over terms.	None

30 features

mean radius

mean texture

mean perimeter

mean area

mean smoothness

mean compactness

mean concavity

mean concave points

mean symmetry

mean fractal dimension

radius error

texture error

perimeter error

area error

smoothness error

compactness error

concavity error

concave points error

symmetry error

fractal dimension error

worst radius

worst texture

worst perimeter

worst area

worst smoothness

worst compactness

worst concavity

worst concave points

worst symmetry

worst fractal dimension

RandomForestClassifier

?Documentation for RandomForestClassifier

Parameters

	n_estimators n_estimators: int, default=100 The number of trees in the forest. .. versionchanged:: 0.22 The default value of ``n_estimators`` changed from 10 to 100 in 0.22.	100
	criterion criterion: {"gini", "entropy", "log_loss"}, default="gini" The function to measure the quality of a split. Supported criteria are "gini" for the Gini impurity and "log_loss" and "entropy" both for the Shannon information gain, see :ref:`tree_mathematical_formulation`. Note: This parameter is tree-specific.	'gini'
	max_depth max_depth: int, default=None The maximum depth of the tree. If None, then nodes are expanded until all leaves are pure or until all leaves contain less than min_samples_split samples.	None
	min_samples_split min_samples_split: int or float, default=2 The minimum number of samples required to split an internal node: - If int, then consider `min_samples_split` as the minimum number. - If float, then `min_samples_split` is a fraction and `ceil(min_samples_split * n_samples)` are the minimum number of samples for each split. .. versionchanged:: 0.18 Added float values for fractions.	2
	min_samples_leaf min_samples_leaf: int or float, default=1 The minimum number of samples required to be at a leaf node. A split point at any depth will only be considered if it leaves at least ``min_samples_leaf`` training samples in each of the left and right branches. This may have the effect of smoothing the model, especially in regression. - If int, then consider `min_samples_leaf` as the minimum number. - If float, then `min_samples_leaf` is a fraction and `ceil(min_samples_leaf * n_samples)` are the minimum number of samples for each node. .. versionchanged:: 0.18 Added float values for fractions.	1
	min_weight_fraction_leaf min_weight_fraction_leaf: float, default=0.0 The minimum weighted fraction of the sum total of weights (of all the input samples) required to be at a leaf node. Samples have equal weight when sample_weight is not provided.	0.0
	max_features max_features: {"sqrt", "log2", None}, int or float, default="sqrt" The number of features to consider when looking for the best split: - If int, then consider `max_features` features at each split. - If float, then `max_features` is a fraction and `max(1, int(max_features * n_features_in_))` features are considered at each split. - If "sqrt", then `max_features=sqrt(n_features)`. - If "log2", then `max_features=log2(n_features)`. - If None, then `max_features=n_features`. .. versionchanged:: 1.1 The default of `max_features` changed from `"auto"` to `"sqrt"`. Note: the search for a split does not stop until at least one valid partition of the node samples is found, even if it requires to effectively inspect more than ``max_features`` features.	'sqrt'
	max_leaf_nodes max_leaf_nodes: int, default=None Grow trees with ``max_leaf_nodes`` in best-first fashion. Best nodes are defined as relative reduction in impurity. If None then unlimited number of leaf nodes.	None
	min_impurity_decrease min_impurity_decrease: float, default=0.0 A node will be split if this split induces a decrease of the impurity greater than or equal to this value. The weighted impurity decrease equation is the following:: N_t / N * (impurity - N_t_R / N_t * right_impurity - N_t_L / N_t * left_impurity) where ``N`` is the total number of samples, ``N_t`` is the number of samples at the current node, ``N_t_L`` is the number of samples in the left child, and ``N_t_R`` is the number of samples in the right child. ``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum, if ``sample_weight`` is passed. .. versionadded:: 0.19	0.0
	bootstrap bootstrap: bool, default=True Whether bootstrap samples are used when building trees. If False, the whole dataset is used to build each tree.	True
	oob_score oob_score: bool or callable, default=False Whether to use out-of-bag samples to estimate the generalization score. By default, :func:`~sklearn.metrics.accuracy_score` is used. Provide a callable with signature `metric(y_true, y_pred)` to use a custom metric. Only available if `bootstrap=True`. For an illustration of out-of-bag (OOB) error estimation, see the example :ref:`sphx_glr_auto_examples_ensemble_plot_ensemble_oob.py`.	False
	n_jobs n_jobs: int, default=None The number of jobs to run in parallel. :meth:`fit`, :meth:`predict`, :meth:`decision_path` and :meth:`apply` are all parallelized over the trees. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary <n_jobs>` for more details.	None
	random_state random_state: int, RandomState instance or None, default=None Controls both the randomness of the bootstrapping of the samples used when building trees (if ``bootstrap=True``) and the sampling of the features to consider when looking for the best split at each node (if ``max_features < n_features``). See :term:`Glossary <random_state>` for details.	None
	verbose verbose: int, default=0 Controls the verbosity when fitting and predicting.	0
	warm_start warm_start: bool, default=False When set to ``True``, reuse the solution of the previous call to fit and add more estimators to the ensemble, otherwise, just fit a whole new forest. See :term:`Glossary <warm_start>` and :ref:`tree_ensemble_warm_start` for details.	False
	class_weight class_weight: {"balanced", "balanced_subsample"}, dict or list of dicts, default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. For multi-output problems, a list of dicts can be provided in the same order as the columns of y. Note that for multioutput (including multilabel) weights should be defined for each class of every column in its own dict. For example, for four-class multilabel classification weights should be [{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of [{1:1}, {2:5}, {3:1}, {4:1}]. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))`` The "balanced_subsample" mode is the same as "balanced" except that weights are computed based on the bootstrap sample for every tree grown. For multi-output, the weights of each column of y will be multiplied. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified.	None
	ccp_alpha ccp_alpha: non-negative float, default=0.0 Complexity parameter used for Minimal Cost-Complexity Pruning. The subtree with the largest cost complexity that is smaller than ``ccp_alpha`` will be chosen. By default, no pruning is performed. See :ref:`minimal_cost_complexity_pruning` for details. See :ref:`sphx_glr_auto_examples_tree_plot_cost_complexity_pruning.py` for an example of such pruning. .. versionadded:: 0.22	0.0
	max_samples max_samples: int or float, default=None If bootstrap is True, the number of samples to draw from X to train each base estimator. - If None (default), then draw `X.shape[0]` samples irrespective of `sample_weight`. - If int, then draw `max_samples` samples. - If float, then draw `max_samples * X.shape[0]` unweighted samples or `max_samples * sample_weight.sum()` weighted samples. .. versionadded:: 0.22 .. versionchanged:: 1.9 Float `max_samples` is relative to `sample_weight.sum()` instead of `X.shape[0]` for weighted samples.	None
	monotonic_cst monotonic_cst: array-like of int of shape (n_features), default=None Indicates the monotonicity constraint to enforce on each feature. - 1: monotonic increase - 0: no constraint - -1: monotonic decrease If monotonic_cst is None, no constraints are applied. Monotonicity constraints are not supported for: - multiclass classifications (i.e. when `n_classes > 2`), - multioutput classifications (i.e. when `n_outputs_ > 1`). The constraints hold over the probability of the positive class. Read more in the :ref:`User Guide <monotonic_cst_gbdt>`. .. versionadded:: 1.4	None

Fitted attributes

Name	Type	Value
classes_ classes_: ndarray of shape (n_classes,) or a list of such arrays The classes labels (single output problem), or a list of arrays of class labels (multi-output problem).	ndarray[int64](2,)	[0,1]
estimator_ estimator_: :class:`~sklearn.tree.DecisionTreeClassifier` The child estimator template used to create the collection of fitted sub-estimators. .. versionadded:: 1.2 `base_estimator_` was renamed to `estimator_`.	DecisionTreeClassifier	DecisionTreeClassifier()
estimators_ estimators_: list of DecisionTreeClassifier The collection of fitted sub-estimators.	list	[DecisionTreeC...te=1806821274), DecisionTreeC...ate=332006677), DecisionTreeC...ate=936460482), DecisionTreeC...te=1668254322), ...]
estimators_samples_ estimators_samples_: list of arrays The subset of drawn samples (i.e., the in-bag samples) for each base estimator. Each subset is defined by an array of the indices selected. .. versionadded:: 1.4	list	[array([383, ... dtype=int32), array([376, 3... dtype=int32), array([151, ... dtype=int32), array([223, 1... dtype=int32), ...]
feature_importances_ feature_importances_: ndarray of shape (n_features,) The impurity-based feature importances. The higher, the more important the feature. The importance of a feature is computed as the (normalized) total reduction of the criterion brought by that feature. It is also known as the Gini importance. Warning: impurity-based feature importances can be misleading for high cardinality features (many unique values). See :func:`sklearn.inspection.permutation_importance` as an alternative.	ndarray[float64](30,)	[0.03,0.01,0.07,...,0.12,0.01,0.01]
feature_names_in_ feature_names_in_: ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0	ndarray[object](30,)	['mean radius','mean texture','mean perimeter',...,'worst concave points', 'worst symmetry','worst fractal dimension']
n_classes_ n_classes_: int or list The number of classes (single output problem), or a list containing the number of classes for each output (multi-output problem).	int	2
n_features_in_ n_features_in_: int Number of features seen during :term:`fit`. .. versionadded:: 0.24	int	30
n_outputs_ n_outputs_: int The number of outputs when ``fit`` is performed.	int	1

Please enable javascript

The skrub table reports need javascript to display correctly. If you are displaying a report in a Jupyter notebook and you see this message, you may need to re-execute the cell or to trust the notebook (button on the top right or "File > Trust notebook").

comparison_report.metrics.summarize().frame()

estimator	LogisticRegression	RandomForestClassifier
accuracy	0.964912	0.973684
precision_0	0.957447	0.958333
precision_1	0.970149	0.984848
recall_0	0.957447	0.978723
recall_1	0.970149	0.970149
roc_auc	0.995554	0.997142
log_loss	0.080457	0.090610
brier_score	0.025149	0.023977
fit_time	0.124317	0.358079
predict_time	0.065832	0.082884

To compare evaluations on different feature matrices, call evaluate() once per matrix, then pass the resulting reports to compare():

X_1 = X.iloc[:, :15]
X_2 = X.iloc[:, 15:]
report_logistic = evaluate(tabular_pipeline(LogisticRegression()), X_1, y, splitter=0.2)
report_forest = evaluate(
    tabular_pipeline(RandomForestClassifier()), X_2, y, splitter=0.2
)
comparison_report = compare([report_logistic, report_forest])
comparison_report.help()

comparison_report.metrics.summarize().frame()

estimator	LogisticRegression	RandomForestClassifier
accuracy	0.938596	0.947368
precision_0	0.916667	0.918367
precision_1	0.954545	0.969231
recall_0	0.936170	0.957447
recall_1	0.940299	0.940299
roc_auc	0.988885	0.996189
log_loss	0.137672	0.102117
brier_score	0.043119	0.028519
fit_time	0.068291	0.282086
predict_time	0.037320	0.049124

Summary#

Three report types (EstimatorReport, CrossValidationReport, ComparisonReport) are all created with evaluate() and share the same accessor layout: report.data, report.metrics, report.inspection (where applicable).
Accessor methods that produce figures or tables return Display objects.
Displays share a single, predictable API:
- plot(**kwargs) — render the visualization
- frame(**kwargs) — return the data as a pandas object
- set_style(policy=..., **kwargs) — customize appearance
- help() — show available options

This consistency makes it easy to switch between report types and to reuse the same workflow across data, metrics, and inspection.

Total running time of the script: (0 minutes 13.307 seconds)

Gallery generated by Sphinx-Gallery

Column	Column name	dtype	Is sorted	Unique values	Mean	Std	Min	Median	Max
0	mean radius	Float64DType	False	456 (80.1%)	14.1	3.52	6.98	13.4	28.1
1	mean texture	Float64DType	False	479 (84.2%)	19.3	4.30	9.71	18.8	39.3
2	mean perimeter	Float64DType	False	522 (91.7%)	92.0	24.3	43.8	86.2	188.
3	mean area	Float64DType	False	539 (94.7%)	655.	352.	144.	551.	2.50e+03
4	mean smoothness	Float64DType	False	474 (83.3%)	0.0964	0.0141	0.0526	0.0959	0.163
5	mean compactness	Float64DType	False	537 (94.4%)	0.104	0.0528	0.0194	0.0926	0.345
6	mean concavity	Float64DType	False	537 (94.4%)	0.0888	0.0797	0.00	0.0615	0.427
7	mean concave points	Float64DType	False	542 (95.3%)	0.0489	0.0388	0.00	0.0335	0.201
8	mean symmetry	Float64DType	False	432 (75.9%)	0.181	0.0274	0.106	0.179	0.304
9	mean fractal dimension	Float64DType	False	499 (87.7%)	0.0628	0.00706	0.0500	0.0615	0.0974
10	radius error	Float64DType	False	540 (94.9%)	0.405	0.277	0.112	0.324	2.87
11	texture error	Float64DType	False	519 (91.2%)	1.22	0.552	0.360	1.11	4.88
12	perimeter error	Float64DType	False	533 (93.7%)	2.87	2.02	0.757	2.29	22.0
13	area error	Float64DType	False	528 (92.8%)	40.3	45.5	6.80	24.5	542.
14	smoothness error	Float64DType	False	547 (96.1%)	0.00704	0.00300	0.00171	0.00638	0.0311
15	compactness error	Float64DType	False	541 (95.1%)	0.0255	0.0179	0.00225	0.0204	0.135
16	concavity error	Float64DType	False	533 (93.7%)	0.0319	0.0302	0.00	0.0259	0.396
17	concave points error	Float64DType	False	507 (89.1%)	0.0118	0.00617	0.00	0.0109	0.0528
18	symmetry error	Float64DType	False	498 (87.5%)	0.0205	0.00827	0.00788	0.0187	0.0790
19	fractal dimension error	Float64DType	False	545 (95.8%)	0.00379	0.00265	0.000895	0.00319	0.0298
20	worst radius	Float64DType	False	457 (80.3%)	16.3	4.83	7.93	15.0	36.0
21	worst texture	Float64DType	False	511 (89.8%)	25.7	6.15	12.0	25.4	49.5
22	worst perimeter	Float64DType	False	514 (90.3%)	107.	33.6	50.4	97.7	251.
23	worst area	Float64DType	False	544 (95.6%)	881.	569.	185.	686.	4.25e+03
24	worst smoothness	Float64DType	False	411 (72.2%)	0.132	0.0228	0.0712	0.131	0.223
25	worst compactness	Float64DType	False	529 (93.0%)	0.254	0.157	0.0273	0.212	1.06
26	worst concavity	Float64DType	False	539 (94.7%)	0.272	0.209	0.00	0.227	1.25
27	worst concave points	Float64DType	False	492 (86.5%)	0.115	0.0657	0.00	0.0999	0.291
28	worst symmetry	Float64DType	False	500 (87.9%)	0.290	0.0619	0.157	0.282	0.664
29	worst fractal dimension	Float64DType	False	535 (94.0%)	0.0839	0.0181	0.0550	0.0800	0.207
30	target	Int64DType	False	2 (0.4%)	0.627	0.484	0	1	1

Column	Column name	dtype	Is sorted	Unique values	Mean	Std	Min	Median	Max
0	mean radius	Float64DType	False	456 (80.1%)	14.1	3.52	6.98	13.4	28.1
1	mean texture	Float64DType	False	479 (84.2%)	19.3	4.30	9.71	18.8	39.3
2	mean perimeter	Float64DType	False	522 (91.7%)	92.0	24.3	43.8	86.2	188.
3	mean area	Float64DType	False	539 (94.7%)	655.	352.	144.	551.	2.50e+03
4	mean smoothness	Float64DType	False	474 (83.3%)	0.0964	0.0141	0.0526	0.0959	0.163
5	mean compactness	Float64DType	False	537 (94.4%)	0.104	0.0528	0.0194	0.0926	0.345
6	mean concavity	Float64DType	False	537 (94.4%)	0.0888	0.0797	0.00	0.0615	0.427
7	mean concave points	Float64DType	False	542 (95.3%)	0.0489	0.0388	0.00	0.0335	0.201
8	mean symmetry	Float64DType	False	432 (75.9%)	0.181	0.0274	0.106	0.179	0.304
9	mean fractal dimension	Float64DType	False	499 (87.7%)	0.0628	0.00706	0.0500	0.0615	0.0974
10	radius error	Float64DType	False	540 (94.9%)	0.405	0.277	0.112	0.324	2.87
11	texture error	Float64DType	False	519 (91.2%)	1.22	0.552	0.360	1.11	4.88
12	perimeter error	Float64DType	False	533 (93.7%)	2.87	2.02	0.757	2.29	22.0
13	area error	Float64DType	False	528 (92.8%)	40.3	45.5	6.80	24.5	542.
14	smoothness error	Float64DType	False	547 (96.1%)	0.00704	0.00300	0.00171	0.00638	0.0311
15	compactness error	Float64DType	False	541 (95.1%)	0.0255	0.0179	0.00225	0.0204	0.135
16	concavity error	Float64DType	False	533 (93.7%)	0.0319	0.0302	0.00	0.0259	0.396
17	concave points error	Float64DType	False	507 (89.1%)	0.0118	0.00617	0.00	0.0109	0.0528
18	symmetry error	Float64DType	False	498 (87.5%)	0.0205	0.00827	0.00788	0.0187	0.0790
19	fractal dimension error	Float64DType	False	545 (95.8%)	0.00379	0.00265	0.000895	0.00319	0.0298
20	worst radius	Float64DType	False	457 (80.3%)	16.3	4.83	7.93	15.0	36.0
21	worst texture	Float64DType	False	511 (89.8%)	25.7	6.15	12.0	25.4	49.5
22	worst perimeter	Float64DType	False	514 (90.3%)	107.	33.6	50.4	97.7	251.
23	worst area	Float64DType	False	544 (95.6%)	881.	569.	185.	686.	4.25e+03
24	worst smoothness	Float64DType	False	411 (72.2%)	0.132	0.0228	0.0712	0.131	0.223
25	worst compactness	Float64DType	False	529 (93.0%)	0.254	0.157	0.0273	0.212	1.06
26	worst concavity	Float64DType	False	539 (94.7%)	0.272	0.209	0.00	0.227	1.25
27	worst concave points	Float64DType	False	492 (86.5%)	0.115	0.0657	0.00	0.0999	0.291
28	worst symmetry	Float64DType	False	500 (87.9%)	0.290	0.0619	0.157	0.282	0.664
29	worst fractal dimension	Float64DType	False	535 (94.0%)	0.0839	0.0181	0.0550	0.0800	0.207
30	target	Int64DType	False	2 (0.4%)	0.627	0.484	0	1	1

	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	radius error	texture error	perimeter error	area error	smoothness error	compactness error	concavity error	concave points error	symmetry error	fractal dimension error	worst radius	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	radius error	texture error	perimeter error	area error	smoothness error	compactness error	concavity error	concave points error	symmetry error	fractal dimension error	worst radius	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
0	10.1	17.5	64.4	311.	0.101	0.0733	0.0251	0.0177	0.189	0.0633	0.262	2.02	1.78	16.9	0.00780	0.0145	0.0169	0.00804	0.0210	0.00278	11.2	26.8	72.0	384.	0.140	0.140	0.105	0.0650	0.289	0.0766	1
1	10.8	22.0	68.8	360.	0.0880	0.0574	0.0361	0.0140	0.202	0.0598	0.308	1.62	2.24	20.2	0.00654	0.0215	0.0299	0.0104	0.0184	0.00269	12.8	32.0	83.7	490.	0.130	0.170	0.193	0.0748	0.296	0.0766	1
2	16.1	14.9	104.	800.	0.0950	0.0850	0.0550	0.0453	0.173	0.0587	0.239	0.637	1.73	21.8	0.00396	0.0125	0.0183	0.00875	0.0150	0.00162	17.7	19.6	116.	948.	0.121	0.172	0.231	0.113	0.278	0.0701	1
3	12.2	17.8	77.8	451.	0.104	0.0706	0.0249	0.0294	0.190	0.0664	0.366	1.51	2.41	24.4	0.00543	0.0118	0.0113	0.0152	0.0222	0.00341	12.8	20.9	82.1	495.	0.114	0.0936	0.0498	0.0588	0.223	0.0738	1
4	12.2	22.4	78.2	466.	0.0819	0.0520	0.0171	0.0126	0.154	0.0598	0.224	1.14	1.58	18.0	0.00510	0.0120	0.00941	0.00455	0.0161	0.00240	14.2	32.0	92.7	623.	0.126	0.180	0.123	0.0634	0.310	0.0820	1

564	17.4	25.6	114.	948.	0.101	0.115	0.168	0.0660	0.131	0.0587	0.530	1.67	3.77	58.5	0.0311	0.0856	0.144	0.0393	0.0217	0.0126	18.1	28.1	120.	1.02e+03	0.124	0.179	0.280	0.110	0.160	0.0682	0
565	12.8	16.7	82.5	494.	0.113	0.112	0.0388	0.0300	0.212	0.0662	0.383	1.00	2.50	28.6	0.00751	0.0156	0.0198	0.00920	0.0181	0.00363	14.4	21.7	93.6	624.	0.147	0.198	0.142	0.0804	0.307	0.0856	1
566	20.2	19.5	134.	1.25e+03	0.113	0.149	0.213	0.126	0.172	0.0605	0.433	1.00	3.01	52.5	0.00909	0.0272	0.0555	0.0191	0.0245	0.00400	22.0	25.1	146.	1.48e+03	0.167	0.294	0.531	0.217	0.303	0.0808	0
567	18.3	20.6	121.	1.05e+03	0.107	0.125	0.157	0.0945	0.186	0.0594	0.545	0.922	3.22	67.4	0.00618	0.0188	0.0291	0.0105	0.0156	0.00272	21.9	26.2	142.	1.49e+03	0.149	0.254	0.376	0.151	0.307	0.0786	0
568	15.0	16.7	98.7	689.	0.0988	0.136	0.0772	0.0614	0.167	0.0687	0.372	0.842	2.30	34.8	0.00412	0.0182	0.0200	0.0100	0.0106	0.00324	16.8	20.4	110.	857.	0.114	0.218	0.186	0.102	0.218	0.0855	1

	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	radius error	texture error	perimeter error	area error	smoothness error	compactness error	concavity error	concave points error	symmetry error	fractal dimension error	worst radius	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
	mean radius	mean texture	mean perimeter	mean area	mean smoothness	mean compactness	mean concavity	mean concave points	mean symmetry	mean fractal dimension	radius error	texture error	perimeter error	area error	smoothness error	compactness error	concavity error	concave points error	symmetry error	fractal dimension error	worst radius	worst texture	worst perimeter	worst area	worst smoothness	worst compactness	worst concavity	worst concave points	worst symmetry	worst fractal dimension	target
0	10.1	17.5	64.4	311.	0.101	0.0733	0.0251	0.0177	0.189	0.0633	0.262	2.02	1.78	16.9	0.00780	0.0145	0.0169	0.00804	0.0210	0.00278	11.2	26.8	72.0	384.	0.140	0.140	0.105	0.0650	0.289	0.0766	1
1	10.8	22.0	68.8	360.	0.0880	0.0574	0.0361	0.0140	0.202	0.0598	0.308	1.62	2.24	20.2	0.00654	0.0215	0.0299	0.0104	0.0184	0.00269	12.8	32.0	83.7	490.	0.130	0.170	0.193	0.0748	0.296	0.0766	1
2	16.1	14.9	104.	800.	0.0950	0.0850	0.0550	0.0453	0.173	0.0587	0.239	0.637	1.73	21.8	0.00396	0.0125	0.0183	0.00875	0.0150	0.00162	17.7	19.6	116.	948.	0.121	0.172	0.231	0.113	0.278	0.0701	1
3	12.2	17.8	77.8	451.	0.104	0.0706	0.0249	0.0294	0.190	0.0664	0.366	1.51	2.41	24.4	0.00543	0.0118	0.0113	0.0152	0.0222	0.00341	12.8	20.9	82.1	495.	0.114	0.0936	0.0498	0.0588	0.223	0.0738	1
4	12.2	22.4	78.2	466.	0.0819	0.0520	0.0171	0.0126	0.154	0.0598	0.224	1.14	1.58	18.0	0.00510	0.0120	0.00941	0.00455	0.0161	0.00240	14.2	32.0	92.7	623.	0.126	0.180	0.123	0.0634	0.310	0.0820	1

564	17.4	25.6	114.	948.	0.101	0.115	0.168	0.0660	0.131	0.0587	0.530	1.67	3.77	58.5	0.0311	0.0856	0.144	0.0393	0.0217	0.0126	18.1	28.1	120.	1.02e+03	0.124	0.179	0.280	0.110	0.160	0.0682	0
565	12.8	16.7	82.5	494.	0.113	0.112	0.0388	0.0300	0.212	0.0662	0.383	1.00	2.50	28.6	0.00751	0.0156	0.0198	0.00920	0.0181	0.00363	14.4	21.7	93.6	624.	0.147	0.198	0.142	0.0804	0.307	0.0856	1
566	20.2	19.5	134.	1.25e+03	0.113	0.149	0.213	0.126	0.172	0.0605	0.433	1.00	3.01	52.5	0.00909	0.0272	0.0555	0.0191	0.0245	0.00400	22.0	25.1	146.	1.48e+03	0.167	0.294	0.531	0.217	0.303	0.0808	0
567	18.3	20.6	121.	1.05e+03	0.107	0.125	0.157	0.0945	0.186	0.0594	0.545	0.922	3.22	67.4	0.00618	0.0188	0.0291	0.0105	0.0156	0.00272	21.9	26.2	142.	1.49e+03	0.149	0.254	0.376	0.151	0.307	0.0786	0
568	15.0	16.7	98.7	689.	0.0988	0.136	0.0772	0.0614	0.167	0.0687	0.372	0.842	2.30	34.8	0.00412	0.0182	0.0200	0.0100	0.0106	0.00324	16.8	20.4	110.	857.	0.114	0.218	0.186	0.102	0.218	0.0855	1

The skore API#

Three report types, one API#

First report: single train-test split#

Data accessor: report.data.summarize() returns a display#

Metrics accessor: same idea, same display API#

Inspection accessor#

Second report type: cross-validation#

Third report type: comparison#

mean radius

mean texture

mean perimeter

mean area

mean smoothness

mean compactness

mean concavity

mean concave points

mean symmetry

mean fractal dimension

radius error

texture error

perimeter error

area error

smoothness error

compactness error

concavity error

concave points error

symmetry error

fractal dimension error

worst radius

worst texture

worst perimeter

worst area

worst smoothness

worst compactness

worst concavity

worst concave points

worst symmetry

worst fractal dimension

target

Please enable javascript

mean radius

mean texture

mean perimeter

mean area

mean smoothness

mean compactness

mean concavity

mean concave points

mean symmetry

mean fractal dimension

radius error

texture error

perimeter error

area error

smoothness error

compactness error

concavity error

concave points error

symmetry error

fractal dimension error

worst radius

worst texture

worst perimeter

worst area

worst smoothness

worst compactness

worst concavity

worst concave points

worst symmetry

worst fractal dimension

target

Please enable javascript

Summary#

Data accessor: `report.data.summarize()` returns a display#