	text	is_toxic
0	Two-Minute Mysteries by Donald J. Sobol? I read those in middle school. Might be a different think though.	Not Toxic
1	Are you feeling it now, mr mark?	Not Toxic
2	Can we get some pro environment conspiracy theories going? What about the gay frogs?! Surely this substance will threaten male virility!	Not Toxic
3	so many haters on the internet . dident get what so bad about this video.... i think u just jealous logan paul.... fuck humens	Toxic
4	I do this with store-bought breaded shrimp all the time. The way you are better than be is that the seasoning is IN the batter, not dusted on top. Play! Experiment! You'll do something wonderful if you are already putting in that effort.	Not Toxic

995	ILLEGITIMATE INCOMPETENT TYRANT TALIBIDEN	Toxic
996	From the theories I’ve read I’m pretty sure you’re right and he’s singed	Not Toxic
997	I can't bear how nice this is. I guess its bearnessities. I'll see my self out	Not Toxic
998	I’m 70 and I agree.	Not Toxic
999	Especially Today's Politicians #traderjoe #delouse #fuckliberals #wethepewple #iwillnotcomply #defiant #fafo #hardinasoftworld #hellandback #irrepressible #shepherdoffire ⌖ #america #freedom #2A #shallnotbeinfringed #noquarter #nosurrender #molonlabe #letfreedomring #keepthepowderdry #patriot #veteran #warrior	Toxic

Column	Column name	dtype	Is sorted	Null values	Unique values	Mean	Std	Min	Median	Max
0	text	ObjectDType	False	0 (0.0%)	999 (99.9%)
1	is_toxic	ObjectDType	False	0 (0.0%)	2 (0.2%)

Column 1	Column 2	Cramér's V	Pearson's Correlation
text	is_toxic	0.100

Metric	mean	std
Accuracy	0.822667	0.032180
Precision	0.823620	0.035558
Recall	0.825368	0.036734
ROC AUC	0.901039	0.033199
Log loss	0.393744	0.054369
Brier score	0.126894	0.021050
Fit time (s)	0.182098	0.003279
Predict time (s)	0.032289	0.000350

	text	is_toxic
253	RACIST , EVIL INHUMAN POST ! WHERE ARE THE QUEENS BANNING THIS SHITE ?	Toxic
667	Gorgeous! Are you the artist? Do you have a website or Instagram I can follow?	Not Toxic
85	Yeah I’m interested in the potential of this story. How could a BBEG trick a party into reviving them instead of a teammate?	Not Toxic
969	i would agree. we will see continuously more adds, until people start paying upfront / it al goes into subscription services.	Not Toxic
75	Smite jinx... int or pentakill? Both.	Not Toxic

835	https://www.reddit.com/r/anime/comments/qkcuk6/comment/hivx9j6/?utm_source=share&utm_medium=web2x&context=3	Not Toxic
192	MSNBC and CNN anchors are a bunch of freaks elitist that ride a high horse and look down on everyone else it's overdue for true Americans to do something about this evil trash	Toxic
629	Biden the biggest douch bag in presidential history!	Toxic
559	So super cute! 🖤	Not Toxic
684	His presidency isn't dead, his brain is. It's a Weekend at Bernie's president. FJB! LGB!	Toxic

Column	Column name	dtype	Is sorted	Null values	Unique values	Mean	Std	Min	Median	Max
0	text	ObjectDType	False	0 (0.0%)	750 (100.0%)
1	is_toxic	ObjectDType	False	0 (0.0%)	2 (0.3%)

	text	is_toxic
253	RACIST , EVIL INHUMAN POST ! WHERE ARE THE QUEENS BANNING THIS SHITE ?	Toxic
667	Gorgeous! Are you the artist? Do you have a website or Instagram I can follow?	Not Toxic
85	Yeah I’m interested in the potential of this story. How could a BBEG trick a party into reviving them instead of a teammate?	Not Toxic
969	i would agree. we will see continuously more adds, until people start paying upfront / it al goes into subscription services.	Not Toxic
75	Smite jinx... int or pentakill? Both.	Not Toxic

835	https://www.reddit.com/r/anime/comments/qkcuk6/comment/hivx9j6/?utm_source=share&utm_medium=web2x&context=3	Not Toxic
192	MSNBC and CNN anchors are a bunch of freaks elitist that ride a high horse and look down on everyone else it's overdue for true Americans to do something about this evil trash	Toxic
629	Biden the biggest douch bag in presidential history!	Toxic
559	So super cute! 🖤	Not Toxic
684	His presidency isn't dead, his brain is. It's a Weekend at Bernie's president. FJB! LGB!	Toxic

Column	Column name	dtype	Is sorted	Null values	Unique values	Mean	Std	Min	Median	Max
0	text	ObjectDType	False	0 (0.0%)	750 (100.0%)
1	is_toxic	ObjectDType	False	0 (0.0%)	2 (0.3%)

Column 1	Column 2	Cramér's V	Pearson's Correlation
text	is_toxic	0.109

	logisticregression_mean	logisticregression_std	favorability
accuracy	0.822667	0.032180	(↗︎)
precision	0.823620	0.035558	(↗︎)
recall	0.825368	0.036734	(↗︎)
roc_auc	0.901039	0.033199	(↗︎)
log_loss	0.393744	0.054369	(↘︎)
brier_score	0.126894	0.021050	(↘︎)
fit_time	0.182098	0.003279	(↘︎)
predict_time	0.032289	0.000350	(↘︎)

	split	threshold	precision	recall
0	0	0.004611	0.506667	1.000000
1	0	0.023608	0.531469	1.000000
2	0	0.023939	0.528169	0.986842
3	0	0.066300	0.576923	0.986842
4	0	0.070432	0.573643	0.973684
...	...	...	...	...
468	4	0.995320	1.000000	0.066667
469	4	0.996643	1.000000	0.053333
470	4	0.996861	1.000000	0.040000
471	4	0.999029	1.000000	0.026667
472	4	0.999881	1.000000	0.013333

	feature	coefficient_mean	coefficient_std
0	Intercept	-0.243448	0.087540
1	text_00	0.520481	0.072374
2	text_01	0.640356	0.170732
3	text_02	0.006669	2.267251
4	text_03	0.255316	1.056051
5	text_04	1.380711	0.995806
6	text_05	-0.243086	0.823388
7	text_06	0.353746	0.362825
8	text_07	0.204637	0.244194
9	text_08	-0.035371	0.733832
10	text_09	0.376660	0.610687
11	text_10	-0.201819	0.511644
12	text_11	-0.099357	0.205994
13	text_12	-0.079186	0.527071
14	text_13	-0.055234	0.338381
15	text_14	0.002133	0.403027
16	text_15	-0.010264	0.239392
17	text_16	0.204061	0.387195
18	text_17	-0.194062	0.266098
19	text_18	0.176111	0.546032
20	text_19	-0.056368	0.297341
21	text_20	-0.377464	0.313493
22	text_21	-0.103353	0.292703
23	text_22	-0.100379	0.062667
24	text_23	0.000174	0.170993
25	text_24	-0.130224	0.235263
26	text_25	-0.307009	0.360734
27	text_26	-0.173430	0.213544
28	text_27	-0.154933	0.085061
29	text_28	0.180420	0.356470
30	text_29	0.149520	0.180058

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

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

	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

	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

	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

	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'

	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

text

is_toxic

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

text

is_toxic

Please enable javascript

	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

	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, ...)

	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

	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

	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

	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

Metric	mean	std
Accuracy	0.812000	0.031411
Precision	0.841484	0.048526
Recall	0.775088	0.044436
ROC AUC	0.880024	0.043085
Log loss	0.458317	0.044647
Brier score	0.145625	0.018738
Fit time (s)	0.399920	0.004154
Predict time (s)	0.041152	0.000471

Metric	LogisticRegression
Accuracy	0.816000
Precision	0.834783
Recall	0.780488
ROC AUC	0.912105
Log loss	0.368210
Brier score	0.118757
Fit time (s)	0.183366
Predict time (s)	0.042362

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[object](2,)	['Not Toxic','Toxic']
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	['text']
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	1

Name	Type	Value
all_outputs_ all_outputs_: list of str The names of the output columns.	list	['text_00', 'text_01', 'text_02', 'text_03', ...]
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	{'text': [CleanNullStrings(), DropUninformative(), ToStr(), StringEncoder(), ...]}
column_to_kind_ column_to_kind_: dict Maps each column name to the kind (``"high_cardinality"``, ``"low_cardinality"``, ``"specific"``, etc.) it was assigned.	dict	{'text': 'hi...ty'}
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	['text']
input_to_outputs_ input_to_outputs_: dict Maps the name of each input column to the names of the corresponding output columns.	dict	{'text': ['text_00', 'text_01', 'text_02', 'text_03', ...]}
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': ['text'], 'lo...ty': [], 'numeric': [], ...}
n_features_in_ n_features_in_: int The number of input columns.	int	1
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	{'text_00': 'text', 'text_01': 'text', 'text_02': 'text', 'text_03': 'text', ...}
transformers_ transformers_: dict Maps the name of each column to the fitted transformer that was applied to it.	dict	{'text': StringEncoder()}

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,)	['text_00','text_01','text_02',...,'text_27','text_28','text_29']
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,)	[ 0.54,-0. ,-0.01,..., 0. ,-0. , 0. ]

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]

	ID	Skore report ID	Key	Log loss	ROC AUC	Fit time (s)	Predict time (s)	Log loss (std)	ROC AUC (std)	Fit time (s) (std)	Predict time (s) (std)	Date	Learner	Dataset	Report type
	skore:report:cross-validation:38930	01a039b4-723c-77fa-8405-3b44272ebf72	logreg_cv									2026-08-25T16:18:07.321441+00:00	LogisticRegression	97224d15c6bb6df0ba6fce4dbd9f40d7	cross-validation
	skore:report:cross-validation:38936	01a039b4-ab6e-7440-bb60-7035838b869e	rf_cv									2026-08-25T16:19:33.645875+00:00	RandomForestClassifier	97224d15c6bb6df0ba6fce4dbd9f40d7	cross-validation